ftdi-elan.c revision 16e2e5f634f86ccda18366967c4e592eb61bc9cc
1/* 2* USB FTDI client driver for Elan Digital Systems's Uxxx adapters 3* 4* Copyright(C) 2006 Elan Digital Systems Limited 5* http://www.elandigitalsystems.com 6* 7* Author and Maintainer - Tony Olech - Elan Digital Systems 8* tony.olech@elandigitalsystems.com 9* 10* This program is free software;you can redistribute it and/or 11* modify it under the terms of the GNU General Public License as 12* published by the Free Software Foundation, version 2. 13* 14* 15* This driver was written by Tony Olech(tony.olech@elandigitalsystems.com) 16* based on various USB client drivers in the 2.6.15 linux kernel 17* with constant reference to the 3rd Edition of Linux Device Drivers 18* published by O'Reilly 19* 20* The U132 adapter is a USB to CardBus adapter specifically designed 21* for PC cards that contain an OHCI host controller. Typical PC cards 22* are the Orange Mobile 3G Option GlobeTrotter Fusion card. 23* 24* The U132 adapter will *NOT *work with PC cards that do not contain 25* an OHCI controller. A simple way to test whether a PC card has an 26* OHCI controller as an interface is to insert the PC card directly 27* into a laptop(or desktop) with a CardBus slot and if "lspci" shows 28* a new USB controller and "lsusb -v" shows a new OHCI Host Controller 29* then there is a good chance that the U132 adapter will support the 30* PC card.(you also need the specific client driver for the PC card) 31* 32* Please inform the Author and Maintainer about any PC cards that 33* contain OHCI Host Controller and work when directly connected to 34* an embedded CardBus slot but do not work when they are connected 35* via an ELAN U132 adapter. 36* 37*/ 38#include <linux/kernel.h> 39#include <linux/errno.h> 40#include <linux/init.h> 41#include <linux/list.h> 42#include <linux/ioctl.h> 43#include <linux/pci_ids.h> 44#include <linux/slab.h> 45#include <linux/module.h> 46#include <linux/kref.h> 47#include <linux/mutex.h> 48#include <asm/uaccess.h> 49#include <linux/usb.h> 50#include <linux/workqueue.h> 51#include <linux/platform_device.h> 52MODULE_AUTHOR("Tony Olech"); 53MODULE_DESCRIPTION("FTDI ELAN driver"); 54MODULE_LICENSE("GPL"); 55#define INT_MODULE_PARM(n, v) static int n = v;module_param(n, int, 0444) 56static int distrust_firmware = 1; 57module_param(distrust_firmware, bool, 0); 58MODULE_PARM_DESC(distrust_firmware, "true to distrust firmware power/overcurren" 59 "t setup"); 60extern struct platform_driver u132_platform_driver; 61static struct workqueue_struct *status_queue; 62static struct workqueue_struct *command_queue; 63static struct workqueue_struct *respond_queue; 64/* 65* ftdi_module_lock exists to protect access to global variables 66* 67*/ 68static struct mutex ftdi_module_lock; 69static int ftdi_instances = 0; 70static struct list_head ftdi_static_list; 71/* 72* end of the global variables protected by ftdi_module_lock 73*/ 74#include "usb_u132.h" 75#include <asm/io.h> 76#include "../core/hcd.h" 77 78 /* FIXME ohci.h is ONLY for internal use by the OHCI driver. 79 * If you're going to try stuff like this, you need to split 80 * out shareable stuff (register declarations?) into its own 81 * file, maybe name <linux/usb/ohci.h> 82 */ 83 84#include "../host/ohci.h" 85/* Define these values to match your devices*/ 86#define USB_FTDI_ELAN_VENDOR_ID 0x0403 87#define USB_FTDI_ELAN_PRODUCT_ID 0xd6ea 88/* table of devices that work with this driver*/ 89static struct usb_device_id ftdi_elan_table[] = { 90 {USB_DEVICE(USB_FTDI_ELAN_VENDOR_ID, USB_FTDI_ELAN_PRODUCT_ID)}, 91 { /* Terminating entry */ } 92}; 93 94MODULE_DEVICE_TABLE(usb, ftdi_elan_table); 95/* only the jtag(firmware upgrade device) interface requires 96* a device file and corresponding minor number, but the 97* interface is created unconditionally - I suppose it could 98* be configured or not according to a module parameter. 99* But since we(now) require one interface per device, 100* and since it unlikely that a normal installation would 101* require more than a couple of elan-ftdi devices, 8 seems 102* like a reasonable limit to have here, and if someone 103* really requires more than 8 devices, then they can frig the 104* code and recompile 105*/ 106#define USB_FTDI_ELAN_MINOR_BASE 192 107#define COMMAND_BITS 5 108#define COMMAND_SIZE (1<<COMMAND_BITS) 109#define COMMAND_MASK (COMMAND_SIZE-1) 110struct u132_command { 111 u8 header; 112 u16 length; 113 u8 address; 114 u8 width; 115 u32 value; 116 int follows; 117 void *buffer; 118}; 119#define RESPOND_BITS 5 120#define RESPOND_SIZE (1<<RESPOND_BITS) 121#define RESPOND_MASK (RESPOND_SIZE-1) 122struct u132_respond { 123 u8 header; 124 u8 address; 125 u32 *value; 126 int *result; 127 struct completion wait_completion; 128}; 129struct u132_target { 130 void *endp; 131 struct urb *urb; 132 int toggle_bits; 133 int error_count; 134 int condition_code; 135 int repeat_number; 136 int halted; 137 int skipped; 138 int actual; 139 int non_null; 140 int active; 141 int abandoning; 142 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 143 int toggle_bits, int error_count, int condition_code, 144 int repeat_number, int halted, int skipped, int actual, 145 int non_null); 146}; 147/* Structure to hold all of our device specific stuff*/ 148struct usb_ftdi { 149 struct list_head ftdi_list; 150 struct mutex u132_lock; 151 int command_next; 152 int command_head; 153 struct u132_command command[COMMAND_SIZE]; 154 int respond_next; 155 int respond_head; 156 struct u132_respond respond[RESPOND_SIZE]; 157 struct u132_target target[4]; 158 char device_name[16]; 159 unsigned synchronized:1; 160 unsigned enumerated:1; 161 unsigned registered:1; 162 unsigned initialized:1; 163 unsigned card_ejected:1; 164 int function; 165 int sequence_num; 166 int disconnected; 167 int gone_away; 168 int stuck_status; 169 int status_queue_delay; 170 struct semaphore sw_lock; 171 struct usb_device *udev; 172 struct usb_interface *interface; 173 struct usb_class_driver *class; 174 struct delayed_work status_work; 175 struct delayed_work command_work; 176 struct delayed_work respond_work; 177 struct u132_platform_data platform_data; 178 struct resource resources[0]; 179 struct platform_device platform_dev; 180 unsigned char *bulk_in_buffer; 181 size_t bulk_in_size; 182 size_t bulk_in_last; 183 size_t bulk_in_left; 184 __u8 bulk_in_endpointAddr; 185 __u8 bulk_out_endpointAddr; 186 struct kref kref; 187 u32 controlreg; 188 u8 response[4 + 1024]; 189 int expected; 190 int recieved; 191 int ed_found; 192}; 193#define kref_to_usb_ftdi(d) container_of(d, struct usb_ftdi, kref) 194#define platform_device_to_usb_ftdi(d) container_of(d, struct usb_ftdi, \ 195 platform_dev) 196static struct usb_driver ftdi_elan_driver; 197static void ftdi_elan_delete(struct kref *kref) 198{ 199 struct usb_ftdi *ftdi = kref_to_usb_ftdi(kref); 200 dev_warn(&ftdi->udev->dev, "FREEING ftdi=%p\n", ftdi); 201 usb_put_dev(ftdi->udev); 202 ftdi->disconnected += 1; 203 mutex_lock(&ftdi_module_lock); 204 list_del_init(&ftdi->ftdi_list); 205 ftdi_instances -= 1; 206 mutex_unlock(&ftdi_module_lock); 207 kfree(ftdi->bulk_in_buffer); 208 ftdi->bulk_in_buffer = NULL; 209} 210 211static void ftdi_elan_put_kref(struct usb_ftdi *ftdi) 212{ 213 kref_put(&ftdi->kref, ftdi_elan_delete); 214} 215 216static void ftdi_elan_get_kref(struct usb_ftdi *ftdi) 217{ 218 kref_get(&ftdi->kref); 219} 220 221static void ftdi_elan_init_kref(struct usb_ftdi *ftdi) 222{ 223 kref_init(&ftdi->kref); 224} 225 226static void ftdi_status_requeue_work(struct usb_ftdi *ftdi, unsigned int delta) 227{ 228 if (!queue_delayed_work(status_queue, &ftdi->status_work, delta)) 229 kref_put(&ftdi->kref, ftdi_elan_delete); 230} 231 232static void ftdi_status_queue_work(struct usb_ftdi *ftdi, unsigned int delta) 233{ 234 if (queue_delayed_work(status_queue, &ftdi->status_work, delta)) 235 kref_get(&ftdi->kref); 236} 237 238static void ftdi_status_cancel_work(struct usb_ftdi *ftdi) 239{ 240 if (cancel_delayed_work(&ftdi->status_work)) 241 kref_put(&ftdi->kref, ftdi_elan_delete); 242} 243 244static void ftdi_command_requeue_work(struct usb_ftdi *ftdi, unsigned int delta) 245{ 246 if (!queue_delayed_work(command_queue, &ftdi->command_work, delta)) 247 kref_put(&ftdi->kref, ftdi_elan_delete); 248} 249 250static void ftdi_command_queue_work(struct usb_ftdi *ftdi, unsigned int delta) 251{ 252 if (queue_delayed_work(command_queue, &ftdi->command_work, delta)) 253 kref_get(&ftdi->kref); 254} 255 256static void ftdi_command_cancel_work(struct usb_ftdi *ftdi) 257{ 258 if (cancel_delayed_work(&ftdi->command_work)) 259 kref_put(&ftdi->kref, ftdi_elan_delete); 260} 261 262static void ftdi_response_requeue_work(struct usb_ftdi *ftdi, 263 unsigned int delta) 264{ 265 if (!queue_delayed_work(respond_queue, &ftdi->respond_work, delta)) 266 kref_put(&ftdi->kref, ftdi_elan_delete); 267} 268 269static void ftdi_respond_queue_work(struct usb_ftdi *ftdi, unsigned int delta) 270{ 271 if (queue_delayed_work(respond_queue, &ftdi->respond_work, delta)) 272 kref_get(&ftdi->kref); 273} 274 275static void ftdi_response_cancel_work(struct usb_ftdi *ftdi) 276{ 277 if (cancel_delayed_work(&ftdi->respond_work)) 278 kref_put(&ftdi->kref, ftdi_elan_delete); 279} 280 281void ftdi_elan_gone_away(struct platform_device *pdev) 282{ 283 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev); 284 ftdi->gone_away += 1; 285 ftdi_elan_put_kref(ftdi); 286} 287 288 289EXPORT_SYMBOL_GPL(ftdi_elan_gone_away); 290static void ftdi_release_platform_dev(struct device *dev) 291{ 292 dev->parent = NULL; 293} 294 295static void ftdi_elan_do_callback(struct usb_ftdi *ftdi, 296 struct u132_target *target, u8 *buffer, int length); 297static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi); 298static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi); 299static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi); 300static int ftdi_elan_checkingPCI(struct usb_ftdi *ftdi); 301static int ftdi_elan_enumeratePCI(struct usb_ftdi *ftdi); 302static int ftdi_elan_synchronize(struct usb_ftdi *ftdi); 303static int ftdi_elan_stuck_waiting(struct usb_ftdi *ftdi); 304static int ftdi_elan_command_engine(struct usb_ftdi *ftdi); 305static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi); 306static int ftdi_elan_hcd_init(struct usb_ftdi *ftdi) 307{ 308 int result; 309 if (ftdi->platform_dev.dev.parent) 310 return -EBUSY; 311 ftdi_elan_get_kref(ftdi); 312 ftdi->platform_data.potpg = 100; 313 ftdi->platform_data.reset = NULL; 314 ftdi->platform_dev.id = ftdi->sequence_num; 315 ftdi->platform_dev.resource = ftdi->resources; 316 ftdi->platform_dev.num_resources = ARRAY_SIZE(ftdi->resources); 317 ftdi->platform_dev.dev.platform_data = &ftdi->platform_data; 318 ftdi->platform_dev.dev.parent = NULL; 319 ftdi->platform_dev.dev.release = ftdi_release_platform_dev; 320 ftdi->platform_dev.dev.dma_mask = NULL; 321 snprintf(ftdi->device_name, sizeof(ftdi->device_name), "u132_hcd"); 322 ftdi->platform_dev.name = ftdi->device_name; 323 dev_info(&ftdi->udev->dev, "requesting module '%s'\n", "u132_hcd"); 324 request_module("u132_hcd"); 325 dev_info(&ftdi->udev->dev, "registering '%s'\n", 326 ftdi->platform_dev.name); 327 result = platform_device_register(&ftdi->platform_dev); 328 return result; 329} 330 331static void ftdi_elan_abandon_completions(struct usb_ftdi *ftdi) 332{ 333 mutex_lock(&ftdi->u132_lock); 334 while (ftdi->respond_next > ftdi->respond_head) { 335 struct u132_respond *respond = &ftdi->respond[RESPOND_MASK & 336 ftdi->respond_head++]; 337 *respond->result = -ESHUTDOWN; 338 *respond->value = 0; 339 complete(&respond->wait_completion); 340 } mutex_unlock(&ftdi->u132_lock); 341} 342 343static void ftdi_elan_abandon_targets(struct usb_ftdi *ftdi) 344{ 345 int ed_number = 4; 346 mutex_lock(&ftdi->u132_lock); 347 while (ed_number-- > 0) { 348 struct u132_target *target = &ftdi->target[ed_number]; 349 if (target->active == 1) { 350 target->condition_code = TD_DEVNOTRESP; 351 mutex_unlock(&ftdi->u132_lock); 352 ftdi_elan_do_callback(ftdi, target, NULL, 0); 353 mutex_lock(&ftdi->u132_lock); 354 } 355 } 356 ftdi->recieved = 0; 357 ftdi->expected = 4; 358 ftdi->ed_found = 0; 359 mutex_unlock(&ftdi->u132_lock); 360} 361 362static void ftdi_elan_flush_targets(struct usb_ftdi *ftdi) 363{ 364 int ed_number = 4; 365 mutex_lock(&ftdi->u132_lock); 366 while (ed_number-- > 0) { 367 struct u132_target *target = &ftdi->target[ed_number]; 368 target->abandoning = 1; 369 wait_1:if (target->active == 1) { 370 int command_size = ftdi->command_next - 371 ftdi->command_head; 372 if (command_size < COMMAND_SIZE) { 373 struct u132_command *command = &ftdi->command[ 374 COMMAND_MASK & ftdi->command_next]; 375 command->header = 0x80 | (ed_number << 5) | 0x4; 376 command->length = 0x00; 377 command->address = 0x00; 378 command->width = 0x00; 379 command->follows = 0; 380 command->value = 0; 381 command->buffer = &command->value; 382 ftdi->command_next += 1; 383 ftdi_elan_kick_command_queue(ftdi); 384 } else { 385 mutex_unlock(&ftdi->u132_lock); 386 msleep(100); 387 mutex_lock(&ftdi->u132_lock); 388 goto wait_1; 389 } 390 } 391 wait_2:if (target->active == 1) { 392 int command_size = ftdi->command_next - 393 ftdi->command_head; 394 if (command_size < COMMAND_SIZE) { 395 struct u132_command *command = &ftdi->command[ 396 COMMAND_MASK & ftdi->command_next]; 397 command->header = 0x90 | (ed_number << 5); 398 command->length = 0x00; 399 command->address = 0x00; 400 command->width = 0x00; 401 command->follows = 0; 402 command->value = 0; 403 command->buffer = &command->value; 404 ftdi->command_next += 1; 405 ftdi_elan_kick_command_queue(ftdi); 406 } else { 407 mutex_unlock(&ftdi->u132_lock); 408 msleep(100); 409 mutex_lock(&ftdi->u132_lock); 410 goto wait_2; 411 } 412 } 413 } 414 ftdi->recieved = 0; 415 ftdi->expected = 4; 416 ftdi->ed_found = 0; 417 mutex_unlock(&ftdi->u132_lock); 418} 419 420static void ftdi_elan_cancel_targets(struct usb_ftdi *ftdi) 421{ 422 int ed_number = 4; 423 mutex_lock(&ftdi->u132_lock); 424 while (ed_number-- > 0) { 425 struct u132_target *target = &ftdi->target[ed_number]; 426 target->abandoning = 1; 427 wait:if (target->active == 1) { 428 int command_size = ftdi->command_next - 429 ftdi->command_head; 430 if (command_size < COMMAND_SIZE) { 431 struct u132_command *command = &ftdi->command[ 432 COMMAND_MASK & ftdi->command_next]; 433 command->header = 0x80 | (ed_number << 5) | 0x4; 434 command->length = 0x00; 435 command->address = 0x00; 436 command->width = 0x00; 437 command->follows = 0; 438 command->value = 0; 439 command->buffer = &command->value; 440 ftdi->command_next += 1; 441 ftdi_elan_kick_command_queue(ftdi); 442 } else { 443 mutex_unlock(&ftdi->u132_lock); 444 msleep(100); 445 mutex_lock(&ftdi->u132_lock); 446 goto wait; 447 } 448 } 449 } 450 ftdi->recieved = 0; 451 ftdi->expected = 4; 452 ftdi->ed_found = 0; 453 mutex_unlock(&ftdi->u132_lock); 454} 455 456static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi) 457{ 458 ftdi_command_queue_work(ftdi, 0); 459 return; 460} 461 462static void ftdi_elan_command_work(struct work_struct *work) 463{ 464 struct usb_ftdi *ftdi = 465 container_of(work, struct usb_ftdi, command_work.work); 466 467 if (ftdi->disconnected > 0) { 468 ftdi_elan_put_kref(ftdi); 469 return; 470 } else { 471 int retval = ftdi_elan_command_engine(ftdi); 472 if (retval == -ESHUTDOWN) { 473 ftdi->disconnected += 1; 474 } else if (retval == -ENODEV) { 475 ftdi->disconnected += 1; 476 } else if (retval) 477 dev_err(&ftdi->udev->dev, "command error %d\n", retval); 478 ftdi_command_requeue_work(ftdi, msecs_to_jiffies(10)); 479 return; 480 } 481} 482 483static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi) 484{ 485 ftdi_respond_queue_work(ftdi, 0); 486 return; 487} 488 489static void ftdi_elan_respond_work(struct work_struct *work) 490{ 491 struct usb_ftdi *ftdi = 492 container_of(work, struct usb_ftdi, respond_work.work); 493 if (ftdi->disconnected > 0) { 494 ftdi_elan_put_kref(ftdi); 495 return; 496 } else { 497 int retval = ftdi_elan_respond_engine(ftdi); 498 if (retval == 0) { 499 } else if (retval == -ESHUTDOWN) { 500 ftdi->disconnected += 1; 501 } else if (retval == -ENODEV) { 502 ftdi->disconnected += 1; 503 } else if (retval == -EILSEQ) { 504 ftdi->disconnected += 1; 505 } else { 506 ftdi->disconnected += 1; 507 dev_err(&ftdi->udev->dev, "respond error %d\n", retval); 508 } 509 if (ftdi->disconnected > 0) { 510 ftdi_elan_abandon_completions(ftdi); 511 ftdi_elan_abandon_targets(ftdi); 512 } 513 ftdi_response_requeue_work(ftdi, msecs_to_jiffies(10)); 514 return; 515 } 516} 517 518 519/* 520* the sw_lock is initially held and will be freed 521* after the FTDI has been synchronized 522* 523*/ 524static void ftdi_elan_status_work(struct work_struct *work) 525{ 526 struct usb_ftdi *ftdi = 527 container_of(work, struct usb_ftdi, status_work.work); 528 int work_delay_in_msec = 0; 529 if (ftdi->disconnected > 0) { 530 ftdi_elan_put_kref(ftdi); 531 return; 532 } else if (ftdi->synchronized == 0) { 533 down(&ftdi->sw_lock); 534 if (ftdi_elan_synchronize(ftdi) == 0) { 535 ftdi->synchronized = 1; 536 ftdi_command_queue_work(ftdi, 1); 537 ftdi_respond_queue_work(ftdi, 1); 538 up(&ftdi->sw_lock); 539 work_delay_in_msec = 100; 540 } else { 541 dev_err(&ftdi->udev->dev, "synchronize failed\n"); 542 up(&ftdi->sw_lock); 543 work_delay_in_msec = 10 *1000; 544 } 545 } else if (ftdi->stuck_status > 0) { 546 if (ftdi_elan_stuck_waiting(ftdi) == 0) { 547 ftdi->stuck_status = 0; 548 ftdi->synchronized = 0; 549 } else if ((ftdi->stuck_status++ % 60) == 1) { 550 dev_err(&ftdi->udev->dev, "WRONG type of card inserted " 551 "- please remove\n"); 552 } else 553 dev_err(&ftdi->udev->dev, "WRONG type of card inserted " 554 "- checked %d times\n", ftdi->stuck_status); 555 work_delay_in_msec = 100; 556 } else if (ftdi->enumerated == 0) { 557 if (ftdi_elan_enumeratePCI(ftdi) == 0) { 558 ftdi->enumerated = 1; 559 work_delay_in_msec = 250; 560 } else 561 work_delay_in_msec = 1000; 562 } else if (ftdi->initialized == 0) { 563 if (ftdi_elan_setupOHCI(ftdi) == 0) { 564 ftdi->initialized = 1; 565 work_delay_in_msec = 500; 566 } else { 567 dev_err(&ftdi->udev->dev, "initialized failed - trying " 568 "again in 10 seconds\n"); 569 work_delay_in_msec = 1 *1000; 570 } 571 } else if (ftdi->registered == 0) { 572 work_delay_in_msec = 10; 573 if (ftdi_elan_hcd_init(ftdi) == 0) { 574 ftdi->registered = 1; 575 } else 576 dev_err(&ftdi->udev->dev, "register failed\n"); 577 work_delay_in_msec = 250; 578 } else { 579 if (ftdi_elan_checkingPCI(ftdi) == 0) { 580 work_delay_in_msec = 250; 581 } else if (ftdi->controlreg & 0x00400000) { 582 if (ftdi->gone_away > 0) { 583 dev_err(&ftdi->udev->dev, "PCI device eject con" 584 "firmed platform_dev.dev.parent=%p plat" 585 "form_dev.dev=%p\n", 586 ftdi->platform_dev.dev.parent, 587 &ftdi->platform_dev.dev); 588 platform_device_unregister(&ftdi->platform_dev); 589 ftdi->platform_dev.dev.parent = NULL; 590 ftdi->registered = 0; 591 ftdi->enumerated = 0; 592 ftdi->card_ejected = 0; 593 ftdi->initialized = 0; 594 ftdi->gone_away = 0; 595 } else 596 ftdi_elan_flush_targets(ftdi); 597 work_delay_in_msec = 250; 598 } else { 599 dev_err(&ftdi->udev->dev, "PCI device has disappeared\n" 600 ); 601 ftdi_elan_cancel_targets(ftdi); 602 work_delay_in_msec = 500; 603 ftdi->enumerated = 0; 604 ftdi->initialized = 0; 605 } 606 } 607 if (ftdi->disconnected > 0) { 608 ftdi_elan_put_kref(ftdi); 609 return; 610 } else { 611 ftdi_status_requeue_work(ftdi, 612 msecs_to_jiffies(work_delay_in_msec)); 613 return; 614 } 615} 616 617 618/* 619* file_operations for the jtag interface 620* 621* the usage count for the device is incremented on open() 622* and decremented on release() 623*/ 624static int ftdi_elan_open(struct inode *inode, struct file *file) 625{ 626 int subminor = iminor(inode); 627 struct usb_interface *interface = usb_find_interface(&ftdi_elan_driver, 628 subminor); 629 if (!interface) { 630 printk(KERN_ERR "can't find device for minor %d\n", subminor); 631 return -ENODEV; 632 } else { 633 struct usb_ftdi *ftdi = usb_get_intfdata(interface); 634 if (!ftdi) { 635 return -ENODEV; 636 } else { 637 if (down_interruptible(&ftdi->sw_lock)) { 638 return -EINTR; 639 } else { 640 ftdi_elan_get_kref(ftdi); 641 file->private_data = ftdi; 642 return 0; 643 } 644 } 645 } 646} 647 648static int ftdi_elan_release(struct inode *inode, struct file *file) 649{ 650 struct usb_ftdi *ftdi = (struct usb_ftdi *)file->private_data; 651 if (ftdi == NULL) 652 return -ENODEV; 653 up(&ftdi->sw_lock); /* decrement the count on our device */ 654 ftdi_elan_put_kref(ftdi); 655 return 0; 656} 657 658 659/* 660* 661* blocking bulk reads are used to get data from the device 662* 663*/ 664static ssize_t ftdi_elan_read(struct file *file, char __user *buffer, 665 size_t count, loff_t *ppos) 666{ 667 char data[30 *3 + 4]; 668 char *d = data; 669 int m = (sizeof(data) - 1) / 3; 670 int bytes_read = 0; 671 int retry_on_empty = 10; 672 int retry_on_timeout = 5; 673 struct usb_ftdi *ftdi = (struct usb_ftdi *)file->private_data; 674 if (ftdi->disconnected > 0) { 675 return -ENODEV; 676 } 677 data[0] = 0; 678 have:if (ftdi->bulk_in_left > 0) { 679 if (count-- > 0) { 680 char *p = ++ftdi->bulk_in_last + ftdi->bulk_in_buffer; 681 ftdi->bulk_in_left -= 1; 682 if (bytes_read < m) { 683 d += sprintf(d, " %02X", 0x000000FF & *p); 684 } else if (bytes_read > m) { 685 } else 686 d += sprintf(d, " .."); 687 if (copy_to_user(buffer++, p, 1)) { 688 return -EFAULT; 689 } else { 690 bytes_read += 1; 691 goto have; 692 } 693 } else 694 return bytes_read; 695 } 696 more:if (count > 0) { 697 int packet_bytes = 0; 698 int retval = usb_bulk_msg(ftdi->udev, 699 usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr), 700 ftdi->bulk_in_buffer, ftdi->bulk_in_size, 701 &packet_bytes, 50); 702 if (packet_bytes > 2) { 703 ftdi->bulk_in_left = packet_bytes - 2; 704 ftdi->bulk_in_last = 1; 705 goto have; 706 } else if (retval == -ETIMEDOUT) { 707 if (retry_on_timeout-- > 0) { 708 goto more; 709 } else if (bytes_read > 0) { 710 return bytes_read; 711 } else 712 return retval; 713 } else if (retval == 0) { 714 if (retry_on_empty-- > 0) { 715 goto more; 716 } else 717 return bytes_read; 718 } else 719 return retval; 720 } else 721 return bytes_read; 722} 723 724static void ftdi_elan_write_bulk_callback(struct urb *urb) 725{ 726 struct usb_ftdi *ftdi = urb->context; 727 int status = urb->status; 728 729 if (status && !(status == -ENOENT || status == -ECONNRESET || 730 status == -ESHUTDOWN)) { 731 dev_err(&ftdi->udev->dev, "urb=%p write bulk status received: %" 732 "d\n", urb, status); 733 } 734 usb_buffer_free(urb->dev, urb->transfer_buffer_length, 735 urb->transfer_buffer, urb->transfer_dma); 736} 737 738static int fill_buffer_with_all_queued_commands(struct usb_ftdi *ftdi, 739 char *buf, int command_size, int total_size) 740{ 741 int ed_commands = 0; 742 int b = 0; 743 int I = command_size; 744 int i = ftdi->command_head; 745 while (I-- > 0) { 746 struct u132_command *command = &ftdi->command[COMMAND_MASK & 747 i++]; 748 int F = command->follows; 749 u8 *f = command->buffer; 750 if (command->header & 0x80) { 751 ed_commands |= 1 << (0x3 & (command->header >> 5)); 752 } 753 buf[b++] = command->header; 754 buf[b++] = (command->length >> 0) & 0x00FF; 755 buf[b++] = (command->length >> 8) & 0x00FF; 756 buf[b++] = command->address; 757 buf[b++] = command->width; 758 while (F-- > 0) { 759 buf[b++] = *f++; 760 } 761 } 762 return ed_commands; 763} 764 765static int ftdi_elan_total_command_size(struct usb_ftdi *ftdi, int command_size) 766{ 767 int total_size = 0; 768 int I = command_size; 769 int i = ftdi->command_head; 770 while (I-- > 0) { 771 struct u132_command *command = &ftdi->command[COMMAND_MASK & 772 i++]; 773 total_size += 5 + command->follows; 774 } return total_size; 775} 776 777static int ftdi_elan_command_engine(struct usb_ftdi *ftdi) 778{ 779 int retval; 780 char *buf; 781 int ed_commands; 782 int total_size; 783 struct urb *urb; 784 int command_size = ftdi->command_next - ftdi->command_head; 785 if (command_size == 0) 786 return 0; 787 total_size = ftdi_elan_total_command_size(ftdi, command_size); 788 urb = usb_alloc_urb(0, GFP_KERNEL); 789 if (!urb) { 790 dev_err(&ftdi->udev->dev, "could not get a urb to write %d comm" 791 "ands totaling %d bytes to the Uxxx\n", command_size, 792 total_size); 793 return -ENOMEM; 794 } 795 buf = usb_buffer_alloc(ftdi->udev, total_size, GFP_KERNEL, 796 &urb->transfer_dma); 797 if (!buf) { 798 dev_err(&ftdi->udev->dev, "could not get a buffer to write %d c" 799 "ommands totaling %d bytes to the Uxxx\n", command_size, 800 total_size); 801 usb_free_urb(urb); 802 return -ENOMEM; 803 } 804 ed_commands = fill_buffer_with_all_queued_commands(ftdi, buf, 805 command_size, total_size); 806 usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev, 807 ftdi->bulk_out_endpointAddr), buf, total_size, 808 ftdi_elan_write_bulk_callback, ftdi); 809 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 810 if (ed_commands) { 811 char diag[40 *3 + 4]; 812 char *d = diag; 813 int m = total_size; 814 u8 *c = buf; 815 int s = (sizeof(diag) - 1) / 3; 816 diag[0] = 0; 817 while (s-- > 0 && m-- > 0) { 818 if (s > 0 || m == 0) { 819 d += sprintf(d, " %02X", *c++); 820 } else 821 d += sprintf(d, " .."); 822 } 823 } 824 retval = usb_submit_urb(urb, GFP_KERNEL); 825 if (retval) { 826 dev_err(&ftdi->udev->dev, "failed %d to submit urb %p to write " 827 "%d commands totaling %d bytes to the Uxxx\n", retval, 828 urb, command_size, total_size); 829 usb_buffer_free(ftdi->udev, total_size, buf, urb->transfer_dma); 830 usb_free_urb(urb); 831 return retval; 832 } 833 usb_free_urb(urb); /* release our reference to this urb, 834 the USB core will eventually free it entirely */ 835 ftdi->command_head += command_size; 836 ftdi_elan_kick_respond_queue(ftdi); 837 return 0; 838} 839 840static void ftdi_elan_do_callback(struct usb_ftdi *ftdi, 841 struct u132_target *target, u8 *buffer, int length) 842{ 843 struct urb *urb = target->urb; 844 int halted = target->halted; 845 int skipped = target->skipped; 846 int actual = target->actual; 847 int non_null = target->non_null; 848 int toggle_bits = target->toggle_bits; 849 int error_count = target->error_count; 850 int condition_code = target->condition_code; 851 int repeat_number = target->repeat_number; 852 void (*callback) (void *, struct urb *, u8 *, int, int, int, int, int, 853 int, int, int, int) = target->callback; 854 target->active -= 1; 855 target->callback = NULL; 856 (*callback) (target->endp, urb, buffer, length, toggle_bits, 857 error_count, condition_code, repeat_number, halted, skipped, 858 actual, non_null); 859} 860 861static char *have_ed_set_response(struct usb_ftdi *ftdi, 862 struct u132_target *target, u16 ed_length, int ed_number, int ed_type, 863 char *b) 864{ 865 int payload = (ed_length >> 0) & 0x07FF; 866 mutex_lock(&ftdi->u132_lock); 867 target->actual = 0; 868 target->non_null = (ed_length >> 15) & 0x0001; 869 target->repeat_number = (ed_length >> 11) & 0x000F; 870 if (ed_type == 0x02) { 871 if (payload == 0 || target->abandoning > 0) { 872 target->abandoning = 0; 873 mutex_unlock(&ftdi->u132_lock); 874 ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response, 875 payload); 876 ftdi->recieved = 0; 877 ftdi->expected = 4; 878 ftdi->ed_found = 0; 879 return ftdi->response; 880 } else { 881 ftdi->expected = 4 + payload; 882 ftdi->ed_found = 1; 883 mutex_unlock(&ftdi->u132_lock); 884 return b; 885 } 886 } else if (ed_type == 0x03) { 887 if (payload == 0 || target->abandoning > 0) { 888 target->abandoning = 0; 889 mutex_unlock(&ftdi->u132_lock); 890 ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response, 891 payload); 892 ftdi->recieved = 0; 893 ftdi->expected = 4; 894 ftdi->ed_found = 0; 895 return ftdi->response; 896 } else { 897 ftdi->expected = 4 + payload; 898 ftdi->ed_found = 1; 899 mutex_unlock(&ftdi->u132_lock); 900 return b; 901 } 902 } else if (ed_type == 0x01) { 903 target->abandoning = 0; 904 mutex_unlock(&ftdi->u132_lock); 905 ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response, 906 payload); 907 ftdi->recieved = 0; 908 ftdi->expected = 4; 909 ftdi->ed_found = 0; 910 return ftdi->response; 911 } else { 912 target->abandoning = 0; 913 mutex_unlock(&ftdi->u132_lock); 914 ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response, 915 payload); 916 ftdi->recieved = 0; 917 ftdi->expected = 4; 918 ftdi->ed_found = 0; 919 return ftdi->response; 920 } 921} 922 923static char *have_ed_get_response(struct usb_ftdi *ftdi, 924 struct u132_target *target, u16 ed_length, int ed_number, int ed_type, 925 char *b) 926{ 927 mutex_lock(&ftdi->u132_lock); 928 target->condition_code = TD_DEVNOTRESP; 929 target->actual = (ed_length >> 0) & 0x01FF; 930 target->non_null = (ed_length >> 15) & 0x0001; 931 target->repeat_number = (ed_length >> 11) & 0x000F; 932 mutex_unlock(&ftdi->u132_lock); 933 if (target->active) 934 ftdi_elan_do_callback(ftdi, target, NULL, 0); 935 target->abandoning = 0; 936 ftdi->recieved = 0; 937 ftdi->expected = 4; 938 ftdi->ed_found = 0; 939 return ftdi->response; 940} 941 942 943/* 944* The engine tries to empty the FTDI fifo 945* 946* all responses found in the fifo data are dispatched thus 947* the response buffer can only ever hold a maximum sized 948* response from the Uxxx. 949* 950*/ 951static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi) 952{ 953 u8 *b = ftdi->response + ftdi->recieved; 954 int bytes_read = 0; 955 int retry_on_empty = 1; 956 int retry_on_timeout = 3; 957 int empty_packets = 0; 958 read:{ 959 int packet_bytes = 0; 960 int retval = usb_bulk_msg(ftdi->udev, 961 usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr), 962 ftdi->bulk_in_buffer, ftdi->bulk_in_size, 963 &packet_bytes, 500); 964 char diag[30 *3 + 4]; 965 char *d = diag; 966 int m = packet_bytes; 967 u8 *c = ftdi->bulk_in_buffer; 968 int s = (sizeof(diag) - 1) / 3; 969 diag[0] = 0; 970 while (s-- > 0 && m-- > 0) { 971 if (s > 0 || m == 0) { 972 d += sprintf(d, " %02X", *c++); 973 } else 974 d += sprintf(d, " .."); 975 } 976 if (packet_bytes > 2) { 977 ftdi->bulk_in_left = packet_bytes - 2; 978 ftdi->bulk_in_last = 1; 979 goto have; 980 } else if (retval == -ETIMEDOUT) { 981 if (retry_on_timeout-- > 0) { 982 dev_err(&ftdi->udev->dev, "TIMED OUT with packe" 983 "t_bytes = %d with total %d bytes%s\n", 984 packet_bytes, bytes_read, diag); 985 goto more; 986 } else if (bytes_read > 0) { 987 dev_err(&ftdi->udev->dev, "ONLY %d bytes%s\n", 988 bytes_read, diag); 989 return -ENOMEM; 990 } else { 991 dev_err(&ftdi->udev->dev, "TIMED OUT with packe" 992 "t_bytes = %d with total %d bytes%s\n", 993 packet_bytes, bytes_read, diag); 994 return -ENOMEM; 995 } 996 } else if (retval == -EILSEQ) { 997 dev_err(&ftdi->udev->dev, "error = %d with packet_bytes" 998 " = %d with total %d bytes%s\n", retval, 999 packet_bytes, bytes_read, diag); 1000 return retval; 1001 } else if (retval) { 1002 dev_err(&ftdi->udev->dev, "error = %d with packet_bytes" 1003 " = %d with total %d bytes%s\n", retval, 1004 packet_bytes, bytes_read, diag); 1005 return retval; 1006 } else if (packet_bytes == 2) { 1007 unsigned char s0 = ftdi->bulk_in_buffer[0]; 1008 unsigned char s1 = ftdi->bulk_in_buffer[1]; 1009 empty_packets += 1; 1010 if (s0 == 0x31 && s1 == 0x60) { 1011 if (retry_on_empty-- > 0) { 1012 goto more; 1013 } else 1014 return 0; 1015 } else if (s0 == 0x31 && s1 == 0x00) { 1016 if (retry_on_empty-- > 0) { 1017 goto more; 1018 } else 1019 return 0; 1020 } else { 1021 if (retry_on_empty-- > 0) { 1022 goto more; 1023 } else 1024 return 0; 1025 } 1026 } else if (packet_bytes == 1) { 1027 if (retry_on_empty-- > 0) { 1028 goto more; 1029 } else 1030 return 0; 1031 } else { 1032 if (retry_on_empty-- > 0) { 1033 goto more; 1034 } else 1035 return 0; 1036 } 1037 } 1038 more:{ 1039 goto read; 1040 } 1041 have:if (ftdi->bulk_in_left > 0) { 1042 u8 c = ftdi->bulk_in_buffer[++ftdi->bulk_in_last]; 1043 bytes_read += 1; 1044 ftdi->bulk_in_left -= 1; 1045 if (ftdi->recieved == 0 && c == 0xFF) { 1046 goto have; 1047 } else 1048 *b++ = c; 1049 if (++ftdi->recieved < ftdi->expected) { 1050 goto have; 1051 } else if (ftdi->ed_found) { 1052 int ed_number = (ftdi->response[0] >> 5) & 0x03; 1053 u16 ed_length = (ftdi->response[2] << 8) | 1054 ftdi->response[1]; 1055 struct u132_target *target = &ftdi->target[ed_number]; 1056 int payload = (ed_length >> 0) & 0x07FF; 1057 char diag[30 *3 + 4]; 1058 char *d = diag; 1059 int m = payload; 1060 u8 *c = 4 + ftdi->response; 1061 int s = (sizeof(diag) - 1) / 3; 1062 diag[0] = 0; 1063 while (s-- > 0 && m-- > 0) { 1064 if (s > 0 || m == 0) { 1065 d += sprintf(d, " %02X", *c++); 1066 } else 1067 d += sprintf(d, " .."); 1068 } 1069 ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response, 1070 payload); 1071 ftdi->recieved = 0; 1072 ftdi->expected = 4; 1073 ftdi->ed_found = 0; 1074 b = ftdi->response; 1075 goto have; 1076 } else if (ftdi->expected == 8) { 1077 u8 buscmd; 1078 int respond_head = ftdi->respond_head++; 1079 struct u132_respond *respond = &ftdi->respond[ 1080 RESPOND_MASK & respond_head]; 1081 u32 data = ftdi->response[7]; 1082 data <<= 8; 1083 data |= ftdi->response[6]; 1084 data <<= 8; 1085 data |= ftdi->response[5]; 1086 data <<= 8; 1087 data |= ftdi->response[4]; 1088 *respond->value = data; 1089 *respond->result = 0; 1090 complete(&respond->wait_completion); 1091 ftdi->recieved = 0; 1092 ftdi->expected = 4; 1093 ftdi->ed_found = 0; 1094 b = ftdi->response; 1095 buscmd = (ftdi->response[0] >> 0) & 0x0F; 1096 if (buscmd == 0x00) { 1097 } else if (buscmd == 0x02) { 1098 } else if (buscmd == 0x06) { 1099 } else if (buscmd == 0x0A) { 1100 } else 1101 dev_err(&ftdi->udev->dev, "Uxxx unknown(%0X) va" 1102 "lue = %08X\n", buscmd, data); 1103 goto have; 1104 } else { 1105 if ((ftdi->response[0] & 0x80) == 0x00) { 1106 ftdi->expected = 8; 1107 goto have; 1108 } else { 1109 int ed_number = (ftdi->response[0] >> 5) & 0x03; 1110 int ed_type = (ftdi->response[0] >> 0) & 0x03; 1111 u16 ed_length = (ftdi->response[2] << 8) | 1112 ftdi->response[1]; 1113 struct u132_target *target = &ftdi->target[ 1114 ed_number]; 1115 target->halted = (ftdi->response[0] >> 3) & 1116 0x01; 1117 target->skipped = (ftdi->response[0] >> 2) & 1118 0x01; 1119 target->toggle_bits = (ftdi->response[3] >> 6) 1120 & 0x03; 1121 target->error_count = (ftdi->response[3] >> 4) 1122 & 0x03; 1123 target->condition_code = (ftdi->response[ 1124 3] >> 0) & 0x0F; 1125 if ((ftdi->response[0] & 0x10) == 0x00) { 1126 b = have_ed_set_response(ftdi, target, 1127 ed_length, ed_number, ed_type, 1128 b); 1129 goto have; 1130 } else { 1131 b = have_ed_get_response(ftdi, target, 1132 ed_length, ed_number, ed_type, 1133 b); 1134 goto have; 1135 } 1136 } 1137 } 1138 } else 1139 goto more; 1140} 1141 1142 1143/* 1144* create a urb, and a buffer for it, and copy the data to the urb 1145* 1146*/ 1147static ssize_t ftdi_elan_write(struct file *file, 1148 const char __user *user_buffer, size_t count, 1149 loff_t *ppos) 1150{ 1151 int retval = 0; 1152 struct urb *urb; 1153 char *buf; 1154 struct usb_ftdi *ftdi = file->private_data; 1155 1156 if (ftdi->disconnected > 0) { 1157 return -ENODEV; 1158 } 1159 if (count == 0) { 1160 goto exit; 1161 } 1162 urb = usb_alloc_urb(0, GFP_KERNEL); 1163 if (!urb) { 1164 retval = -ENOMEM; 1165 goto error_1; 1166 } 1167 buf = usb_buffer_alloc(ftdi->udev, count, GFP_KERNEL, 1168 &urb->transfer_dma); 1169 if (!buf) { 1170 retval = -ENOMEM; 1171 goto error_2; 1172 } 1173 if (copy_from_user(buf, user_buffer, count)) { 1174 retval = -EFAULT; 1175 goto error_3; 1176 } 1177 usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev, 1178 ftdi->bulk_out_endpointAddr), buf, count, 1179 ftdi_elan_write_bulk_callback, ftdi); 1180 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1181 retval = usb_submit_urb(urb, GFP_KERNEL); 1182 if (retval) { 1183 dev_err(&ftdi->udev->dev, "failed submitting write urb, error %" 1184 "d\n", retval); 1185 goto error_3; 1186 } 1187 usb_free_urb(urb); 1188 1189exit: 1190 return count; 1191error_3: 1192 usb_buffer_free(ftdi->udev, count, buf, urb->transfer_dma); 1193error_2: 1194 usb_free_urb(urb); 1195error_1: 1196 return retval; 1197} 1198 1199static const struct file_operations ftdi_elan_fops = { 1200 .owner = THIS_MODULE, 1201 .llseek = no_llseek, 1202 .read = ftdi_elan_read, 1203 .write = ftdi_elan_write, 1204 .open = ftdi_elan_open, 1205 .release = ftdi_elan_release, 1206}; 1207 1208/* 1209* usb class driver info in order to get a minor number from the usb core, 1210* and to have the device registered with the driver core 1211*/ 1212static struct usb_class_driver ftdi_elan_jtag_class = { 1213 .name = "ftdi-%d-jtag", 1214 .fops = &ftdi_elan_fops, 1215 .minor_base = USB_FTDI_ELAN_MINOR_BASE, 1216}; 1217 1218/* 1219* the following definitions are for the 1220* ELAN FPGA state machgine processor that 1221* lies on the other side of the FTDI chip 1222*/ 1223#define cPCIu132rd 0x0 1224#define cPCIu132wr 0x1 1225#define cPCIiord 0x2 1226#define cPCIiowr 0x3 1227#define cPCImemrd 0x6 1228#define cPCImemwr 0x7 1229#define cPCIcfgrd 0xA 1230#define cPCIcfgwr 0xB 1231#define cPCInull 0xF 1232#define cU132cmd_status 0x0 1233#define cU132flash 0x1 1234#define cPIDsetup 0x0 1235#define cPIDout 0x1 1236#define cPIDin 0x2 1237#define cPIDinonce 0x3 1238#define cCCnoerror 0x0 1239#define cCCcrc 0x1 1240#define cCCbitstuff 0x2 1241#define cCCtoggle 0x3 1242#define cCCstall 0x4 1243#define cCCnoresp 0x5 1244#define cCCbadpid1 0x6 1245#define cCCbadpid2 0x7 1246#define cCCdataoverrun 0x8 1247#define cCCdataunderrun 0x9 1248#define cCCbuffoverrun 0xC 1249#define cCCbuffunderrun 0xD 1250#define cCCnotaccessed 0xF 1251static int ftdi_elan_write_reg(struct usb_ftdi *ftdi, u32 data) 1252{ 1253 wait:if (ftdi->disconnected > 0) { 1254 return -ENODEV; 1255 } else { 1256 int command_size; 1257 mutex_lock(&ftdi->u132_lock); 1258 command_size = ftdi->command_next - ftdi->command_head; 1259 if (command_size < COMMAND_SIZE) { 1260 struct u132_command *command = &ftdi->command[ 1261 COMMAND_MASK & ftdi->command_next]; 1262 command->header = 0x00 | cPCIu132wr; 1263 command->length = 0x04; 1264 command->address = 0x00; 1265 command->width = 0x00; 1266 command->follows = 4; 1267 command->value = data; 1268 command->buffer = &command->value; 1269 ftdi->command_next += 1; 1270 ftdi_elan_kick_command_queue(ftdi); 1271 mutex_unlock(&ftdi->u132_lock); 1272 return 0; 1273 } else { 1274 mutex_unlock(&ftdi->u132_lock); 1275 msleep(100); 1276 goto wait; 1277 } 1278 } 1279} 1280 1281static int ftdi_elan_write_config(struct usb_ftdi *ftdi, int config_offset, 1282 u8 width, u32 data) 1283{ 1284 u8 addressofs = config_offset / 4; 1285 wait:if (ftdi->disconnected > 0) { 1286 return -ENODEV; 1287 } else { 1288 int command_size; 1289 mutex_lock(&ftdi->u132_lock); 1290 command_size = ftdi->command_next - ftdi->command_head; 1291 if (command_size < COMMAND_SIZE) { 1292 struct u132_command *command = &ftdi->command[ 1293 COMMAND_MASK & ftdi->command_next]; 1294 command->header = 0x00 | (cPCIcfgwr & 0x0F); 1295 command->length = 0x04; 1296 command->address = addressofs; 1297 command->width = 0x00 | (width & 0x0F); 1298 command->follows = 4; 1299 command->value = data; 1300 command->buffer = &command->value; 1301 ftdi->command_next += 1; 1302 ftdi_elan_kick_command_queue(ftdi); 1303 mutex_unlock(&ftdi->u132_lock); 1304 return 0; 1305 } else { 1306 mutex_unlock(&ftdi->u132_lock); 1307 msleep(100); 1308 goto wait; 1309 } 1310 } 1311} 1312 1313static int ftdi_elan_write_pcimem(struct usb_ftdi *ftdi, int mem_offset, 1314 u8 width, u32 data) 1315{ 1316 u8 addressofs = mem_offset / 4; 1317 wait:if (ftdi->disconnected > 0) { 1318 return -ENODEV; 1319 } else { 1320 int command_size; 1321 mutex_lock(&ftdi->u132_lock); 1322 command_size = ftdi->command_next - ftdi->command_head; 1323 if (command_size < COMMAND_SIZE) { 1324 struct u132_command *command = &ftdi->command[ 1325 COMMAND_MASK & ftdi->command_next]; 1326 command->header = 0x00 | (cPCImemwr & 0x0F); 1327 command->length = 0x04; 1328 command->address = addressofs; 1329 command->width = 0x00 | (width & 0x0F); 1330 command->follows = 4; 1331 command->value = data; 1332 command->buffer = &command->value; 1333 ftdi->command_next += 1; 1334 ftdi_elan_kick_command_queue(ftdi); 1335 mutex_unlock(&ftdi->u132_lock); 1336 return 0; 1337 } else { 1338 mutex_unlock(&ftdi->u132_lock); 1339 msleep(100); 1340 goto wait; 1341 } 1342 } 1343} 1344 1345int usb_ftdi_elan_write_pcimem(struct platform_device *pdev, int mem_offset, 1346 u8 width, u32 data) 1347{ 1348 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev); 1349 return ftdi_elan_write_pcimem(ftdi, mem_offset, width, data); 1350} 1351 1352 1353EXPORT_SYMBOL_GPL(usb_ftdi_elan_write_pcimem); 1354static int ftdi_elan_read_reg(struct usb_ftdi *ftdi, u32 *data) 1355{ 1356 wait:if (ftdi->disconnected > 0) { 1357 return -ENODEV; 1358 } else { 1359 int command_size; 1360 int respond_size; 1361 mutex_lock(&ftdi->u132_lock); 1362 command_size = ftdi->command_next - ftdi->command_head; 1363 respond_size = ftdi->respond_next - ftdi->respond_head; 1364 if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE) 1365 { 1366 struct u132_command *command = &ftdi->command[ 1367 COMMAND_MASK & ftdi->command_next]; 1368 struct u132_respond *respond = &ftdi->respond[ 1369 RESPOND_MASK & ftdi->respond_next]; 1370 int result = -ENODEV; 1371 respond->result = &result; 1372 respond->header = command->header = 0x00 | cPCIu132rd; 1373 command->length = 0x04; 1374 respond->address = command->address = cU132cmd_status; 1375 command->width = 0x00; 1376 command->follows = 0; 1377 command->value = 0; 1378 command->buffer = NULL; 1379 respond->value = data; 1380 init_completion(&respond->wait_completion); 1381 ftdi->command_next += 1; 1382 ftdi->respond_next += 1; 1383 ftdi_elan_kick_command_queue(ftdi); 1384 mutex_unlock(&ftdi->u132_lock); 1385 wait_for_completion(&respond->wait_completion); 1386 return result; 1387 } else { 1388 mutex_unlock(&ftdi->u132_lock); 1389 msleep(100); 1390 goto wait; 1391 } 1392 } 1393} 1394 1395static int ftdi_elan_read_config(struct usb_ftdi *ftdi, int config_offset, 1396 u8 width, u32 *data) 1397{ 1398 u8 addressofs = config_offset / 4; 1399 wait:if (ftdi->disconnected > 0) { 1400 return -ENODEV; 1401 } else { 1402 int command_size; 1403 int respond_size; 1404 mutex_lock(&ftdi->u132_lock); 1405 command_size = ftdi->command_next - ftdi->command_head; 1406 respond_size = ftdi->respond_next - ftdi->respond_head; 1407 if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE) 1408 { 1409 struct u132_command *command = &ftdi->command[ 1410 COMMAND_MASK & ftdi->command_next]; 1411 struct u132_respond *respond = &ftdi->respond[ 1412 RESPOND_MASK & ftdi->respond_next]; 1413 int result = -ENODEV; 1414 respond->result = &result; 1415 respond->header = command->header = 0x00 | (cPCIcfgrd & 1416 0x0F); 1417 command->length = 0x04; 1418 respond->address = command->address = addressofs; 1419 command->width = 0x00 | (width & 0x0F); 1420 command->follows = 0; 1421 command->value = 0; 1422 command->buffer = NULL; 1423 respond->value = data; 1424 init_completion(&respond->wait_completion); 1425 ftdi->command_next += 1; 1426 ftdi->respond_next += 1; 1427 ftdi_elan_kick_command_queue(ftdi); 1428 mutex_unlock(&ftdi->u132_lock); 1429 wait_for_completion(&respond->wait_completion); 1430 return result; 1431 } else { 1432 mutex_unlock(&ftdi->u132_lock); 1433 msleep(100); 1434 goto wait; 1435 } 1436 } 1437} 1438 1439static int ftdi_elan_read_pcimem(struct usb_ftdi *ftdi, int mem_offset, 1440 u8 width, u32 *data) 1441{ 1442 u8 addressofs = mem_offset / 4; 1443 wait:if (ftdi->disconnected > 0) { 1444 return -ENODEV; 1445 } else { 1446 int command_size; 1447 int respond_size; 1448 mutex_lock(&ftdi->u132_lock); 1449 command_size = ftdi->command_next - ftdi->command_head; 1450 respond_size = ftdi->respond_next - ftdi->respond_head; 1451 if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE) 1452 { 1453 struct u132_command *command = &ftdi->command[ 1454 COMMAND_MASK & ftdi->command_next]; 1455 struct u132_respond *respond = &ftdi->respond[ 1456 RESPOND_MASK & ftdi->respond_next]; 1457 int result = -ENODEV; 1458 respond->result = &result; 1459 respond->header = command->header = 0x00 | (cPCImemrd & 1460 0x0F); 1461 command->length = 0x04; 1462 respond->address = command->address = addressofs; 1463 command->width = 0x00 | (width & 0x0F); 1464 command->follows = 0; 1465 command->value = 0; 1466 command->buffer = NULL; 1467 respond->value = data; 1468 init_completion(&respond->wait_completion); 1469 ftdi->command_next += 1; 1470 ftdi->respond_next += 1; 1471 ftdi_elan_kick_command_queue(ftdi); 1472 mutex_unlock(&ftdi->u132_lock); 1473 wait_for_completion(&respond->wait_completion); 1474 return result; 1475 } else { 1476 mutex_unlock(&ftdi->u132_lock); 1477 msleep(100); 1478 goto wait; 1479 } 1480 } 1481} 1482 1483int usb_ftdi_elan_read_pcimem(struct platform_device *pdev, int mem_offset, 1484 u8 width, u32 *data) 1485{ 1486 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev); 1487 if (ftdi->initialized == 0) { 1488 return -ENODEV; 1489 } else 1490 return ftdi_elan_read_pcimem(ftdi, mem_offset, width, data); 1491} 1492 1493 1494EXPORT_SYMBOL_GPL(usb_ftdi_elan_read_pcimem); 1495static int ftdi_elan_edset_setup(struct usb_ftdi *ftdi, u8 ed_number, 1496 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits, 1497 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 1498 int toggle_bits, int error_count, int condition_code, int repeat_number, 1499 int halted, int skipped, int actual, int non_null)) 1500{ 1501 u8 ed = ed_number - 1; 1502 wait:if (ftdi->disconnected > 0) { 1503 return -ENODEV; 1504 } else if (ftdi->initialized == 0) { 1505 return -ENODEV; 1506 } else { 1507 int command_size; 1508 mutex_lock(&ftdi->u132_lock); 1509 command_size = ftdi->command_next - ftdi->command_head; 1510 if (command_size < COMMAND_SIZE) { 1511 struct u132_target *target = &ftdi->target[ed]; 1512 struct u132_command *command = &ftdi->command[ 1513 COMMAND_MASK & ftdi->command_next]; 1514 command->header = 0x80 | (ed << 5); 1515 command->length = 0x8007; 1516 command->address = (toggle_bits << 6) | (ep_number << 2) 1517 | (address << 0); 1518 command->width = usb_maxpacket(urb->dev, urb->pipe, 1519 usb_pipeout(urb->pipe)); 1520 command->follows = 8; 1521 command->value = 0; 1522 command->buffer = urb->setup_packet; 1523 target->callback = callback; 1524 target->endp = endp; 1525 target->urb = urb; 1526 target->active = 1; 1527 ftdi->command_next += 1; 1528 ftdi_elan_kick_command_queue(ftdi); 1529 mutex_unlock(&ftdi->u132_lock); 1530 return 0; 1531 } else { 1532 mutex_unlock(&ftdi->u132_lock); 1533 msleep(100); 1534 goto wait; 1535 } 1536 } 1537} 1538 1539int usb_ftdi_elan_edset_setup(struct platform_device *pdev, u8 ed_number, 1540 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits, 1541 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 1542 int toggle_bits, int error_count, int condition_code, int repeat_number, 1543 int halted, int skipped, int actual, int non_null)) 1544{ 1545 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev); 1546 return ftdi_elan_edset_setup(ftdi, ed_number, endp, urb, address, 1547 ep_number, toggle_bits, callback); 1548} 1549 1550 1551EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_setup); 1552static int ftdi_elan_edset_input(struct usb_ftdi *ftdi, u8 ed_number, 1553 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits, 1554 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 1555 int toggle_bits, int error_count, int condition_code, int repeat_number, 1556 int halted, int skipped, int actual, int non_null)) 1557{ 1558 u8 ed = ed_number - 1; 1559 wait:if (ftdi->disconnected > 0) { 1560 return -ENODEV; 1561 } else if (ftdi->initialized == 0) { 1562 return -ENODEV; 1563 } else { 1564 int command_size; 1565 mutex_lock(&ftdi->u132_lock); 1566 command_size = ftdi->command_next - ftdi->command_head; 1567 if (command_size < COMMAND_SIZE) { 1568 struct u132_target *target = &ftdi->target[ed]; 1569 struct u132_command *command = &ftdi->command[ 1570 COMMAND_MASK & ftdi->command_next]; 1571 u32 remaining_length = urb->transfer_buffer_length - 1572 urb->actual_length; 1573 command->header = 0x82 | (ed << 5); 1574 if (remaining_length == 0) { 1575 command->length = 0x0000; 1576 } else if (remaining_length > 1024) { 1577 command->length = 0x8000 | 1023; 1578 } else 1579 command->length = 0x8000 | (remaining_length - 1580 1); 1581 command->address = (toggle_bits << 6) | (ep_number << 2) 1582 | (address << 0); 1583 command->width = usb_maxpacket(urb->dev, urb->pipe, 1584 usb_pipeout(urb->pipe)); 1585 command->follows = 0; 1586 command->value = 0; 1587 command->buffer = NULL; 1588 target->callback = callback; 1589 target->endp = endp; 1590 target->urb = urb; 1591 target->active = 1; 1592 ftdi->command_next += 1; 1593 ftdi_elan_kick_command_queue(ftdi); 1594 mutex_unlock(&ftdi->u132_lock); 1595 return 0; 1596 } else { 1597 mutex_unlock(&ftdi->u132_lock); 1598 msleep(100); 1599 goto wait; 1600 } 1601 } 1602} 1603 1604int usb_ftdi_elan_edset_input(struct platform_device *pdev, u8 ed_number, 1605 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits, 1606 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 1607 int toggle_bits, int error_count, int condition_code, int repeat_number, 1608 int halted, int skipped, int actual, int non_null)) 1609{ 1610 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev); 1611 return ftdi_elan_edset_input(ftdi, ed_number, endp, urb, address, 1612 ep_number, toggle_bits, callback); 1613} 1614 1615 1616EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_input); 1617static int ftdi_elan_edset_empty(struct usb_ftdi *ftdi, u8 ed_number, 1618 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits, 1619 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 1620 int toggle_bits, int error_count, int condition_code, int repeat_number, 1621 int halted, int skipped, int actual, int non_null)) 1622{ 1623 u8 ed = ed_number - 1; 1624 wait:if (ftdi->disconnected > 0) { 1625 return -ENODEV; 1626 } else if (ftdi->initialized == 0) { 1627 return -ENODEV; 1628 } else { 1629 int command_size; 1630 mutex_lock(&ftdi->u132_lock); 1631 command_size = ftdi->command_next - ftdi->command_head; 1632 if (command_size < COMMAND_SIZE) { 1633 struct u132_target *target = &ftdi->target[ed]; 1634 struct u132_command *command = &ftdi->command[ 1635 COMMAND_MASK & ftdi->command_next]; 1636 command->header = 0x81 | (ed << 5); 1637 command->length = 0x0000; 1638 command->address = (toggle_bits << 6) | (ep_number << 2) 1639 | (address << 0); 1640 command->width = usb_maxpacket(urb->dev, urb->pipe, 1641 usb_pipeout(urb->pipe)); 1642 command->follows = 0; 1643 command->value = 0; 1644 command->buffer = NULL; 1645 target->callback = callback; 1646 target->endp = endp; 1647 target->urb = urb; 1648 target->active = 1; 1649 ftdi->command_next += 1; 1650 ftdi_elan_kick_command_queue(ftdi); 1651 mutex_unlock(&ftdi->u132_lock); 1652 return 0; 1653 } else { 1654 mutex_unlock(&ftdi->u132_lock); 1655 msleep(100); 1656 goto wait; 1657 } 1658 } 1659} 1660 1661int usb_ftdi_elan_edset_empty(struct platform_device *pdev, u8 ed_number, 1662 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits, 1663 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 1664 int toggle_bits, int error_count, int condition_code, int repeat_number, 1665 int halted, int skipped, int actual, int non_null)) 1666{ 1667 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev); 1668 return ftdi_elan_edset_empty(ftdi, ed_number, endp, urb, address, 1669 ep_number, toggle_bits, callback); 1670} 1671 1672 1673EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_empty); 1674static int ftdi_elan_edset_output(struct usb_ftdi *ftdi, u8 ed_number, 1675 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits, 1676 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 1677 int toggle_bits, int error_count, int condition_code, int repeat_number, 1678 int halted, int skipped, int actual, int non_null)) 1679{ 1680 u8 ed = ed_number - 1; 1681 wait:if (ftdi->disconnected > 0) { 1682 return -ENODEV; 1683 } else if (ftdi->initialized == 0) { 1684 return -ENODEV; 1685 } else { 1686 int command_size; 1687 mutex_lock(&ftdi->u132_lock); 1688 command_size = ftdi->command_next - ftdi->command_head; 1689 if (command_size < COMMAND_SIZE) { 1690 u8 *b; 1691 u16 urb_size; 1692 int i = 0; 1693 char data[30 *3 + 4]; 1694 char *d = data; 1695 int m = (sizeof(data) - 1) / 3; 1696 int l = 0; 1697 struct u132_target *target = &ftdi->target[ed]; 1698 struct u132_command *command = &ftdi->command[ 1699 COMMAND_MASK & ftdi->command_next]; 1700 command->header = 0x81 | (ed << 5); 1701 command->address = (toggle_bits << 6) | (ep_number << 2) 1702 | (address << 0); 1703 command->width = usb_maxpacket(urb->dev, urb->pipe, 1704 usb_pipeout(urb->pipe)); 1705 command->follows = min_t(u32, 1024, 1706 urb->transfer_buffer_length - 1707 urb->actual_length); 1708 command->value = 0; 1709 command->buffer = urb->transfer_buffer + 1710 urb->actual_length; 1711 command->length = 0x8000 | (command->follows - 1); 1712 b = command->buffer; 1713 urb_size = command->follows; 1714 data[0] = 0; 1715 while (urb_size-- > 0) { 1716 if (i > m) { 1717 } else if (i++ < m) { 1718 int w = sprintf(d, " %02X", *b++); 1719 d += w; 1720 l += w; 1721 } else 1722 d += sprintf(d, " .."); 1723 } 1724 target->callback = callback; 1725 target->endp = endp; 1726 target->urb = urb; 1727 target->active = 1; 1728 ftdi->command_next += 1; 1729 ftdi_elan_kick_command_queue(ftdi); 1730 mutex_unlock(&ftdi->u132_lock); 1731 return 0; 1732 } else { 1733 mutex_unlock(&ftdi->u132_lock); 1734 msleep(100); 1735 goto wait; 1736 } 1737 } 1738} 1739 1740int usb_ftdi_elan_edset_output(struct platform_device *pdev, u8 ed_number, 1741 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits, 1742 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 1743 int toggle_bits, int error_count, int condition_code, int repeat_number, 1744 int halted, int skipped, int actual, int non_null)) 1745{ 1746 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev); 1747 return ftdi_elan_edset_output(ftdi, ed_number, endp, urb, address, 1748 ep_number, toggle_bits, callback); 1749} 1750 1751 1752EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_output); 1753static int ftdi_elan_edset_single(struct usb_ftdi *ftdi, u8 ed_number, 1754 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits, 1755 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 1756 int toggle_bits, int error_count, int condition_code, int repeat_number, 1757 int halted, int skipped, int actual, int non_null)) 1758{ 1759 u8 ed = ed_number - 1; 1760 wait:if (ftdi->disconnected > 0) { 1761 return -ENODEV; 1762 } else if (ftdi->initialized == 0) { 1763 return -ENODEV; 1764 } else { 1765 int command_size; 1766 mutex_lock(&ftdi->u132_lock); 1767 command_size = ftdi->command_next - ftdi->command_head; 1768 if (command_size < COMMAND_SIZE) { 1769 u32 remaining_length = urb->transfer_buffer_length - 1770 urb->actual_length; 1771 struct u132_target *target = &ftdi->target[ed]; 1772 struct u132_command *command = &ftdi->command[ 1773 COMMAND_MASK & ftdi->command_next]; 1774 command->header = 0x83 | (ed << 5); 1775 if (remaining_length == 0) { 1776 command->length = 0x0000; 1777 } else if (remaining_length > 1024) { 1778 command->length = 0x8000 | 1023; 1779 } else 1780 command->length = 0x8000 | (remaining_length - 1781 1); 1782 command->address = (toggle_bits << 6) | (ep_number << 2) 1783 | (address << 0); 1784 command->width = usb_maxpacket(urb->dev, urb->pipe, 1785 usb_pipeout(urb->pipe)); 1786 command->follows = 0; 1787 command->value = 0; 1788 command->buffer = NULL; 1789 target->callback = callback; 1790 target->endp = endp; 1791 target->urb = urb; 1792 target->active = 1; 1793 ftdi->command_next += 1; 1794 ftdi_elan_kick_command_queue(ftdi); 1795 mutex_unlock(&ftdi->u132_lock); 1796 return 0; 1797 } else { 1798 mutex_unlock(&ftdi->u132_lock); 1799 msleep(100); 1800 goto wait; 1801 } 1802 } 1803} 1804 1805int usb_ftdi_elan_edset_single(struct platform_device *pdev, u8 ed_number, 1806 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits, 1807 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len, 1808 int toggle_bits, int error_count, int condition_code, int repeat_number, 1809 int halted, int skipped, int actual, int non_null)) 1810{ 1811 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev); 1812 return ftdi_elan_edset_single(ftdi, ed_number, endp, urb, address, 1813 ep_number, toggle_bits, callback); 1814} 1815 1816 1817EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_single); 1818static int ftdi_elan_edset_flush(struct usb_ftdi *ftdi, u8 ed_number, 1819 void *endp) 1820{ 1821 u8 ed = ed_number - 1; 1822 if (ftdi->disconnected > 0) { 1823 return -ENODEV; 1824 } else if (ftdi->initialized == 0) { 1825 return -ENODEV; 1826 } else { 1827 struct u132_target *target = &ftdi->target[ed]; 1828 mutex_lock(&ftdi->u132_lock); 1829 if (target->abandoning > 0) { 1830 mutex_unlock(&ftdi->u132_lock); 1831 return 0; 1832 } else { 1833 target->abandoning = 1; 1834 wait_1:if (target->active == 1) { 1835 int command_size = ftdi->command_next - 1836 ftdi->command_head; 1837 if (command_size < COMMAND_SIZE) { 1838 struct u132_command *command = 1839 &ftdi->command[COMMAND_MASK & 1840 ftdi->command_next]; 1841 command->header = 0x80 | (ed << 5) | 1842 0x4; 1843 command->length = 0x00; 1844 command->address = 0x00; 1845 command->width = 0x00; 1846 command->follows = 0; 1847 command->value = 0; 1848 command->buffer = &command->value; 1849 ftdi->command_next += 1; 1850 ftdi_elan_kick_command_queue(ftdi); 1851 } else { 1852 mutex_unlock(&ftdi->u132_lock); 1853 msleep(100); 1854 mutex_lock(&ftdi->u132_lock); 1855 goto wait_1; 1856 } 1857 } 1858 mutex_unlock(&ftdi->u132_lock); 1859 return 0; 1860 } 1861 } 1862} 1863 1864int usb_ftdi_elan_edset_flush(struct platform_device *pdev, u8 ed_number, 1865 void *endp) 1866{ 1867 struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev); 1868 return ftdi_elan_edset_flush(ftdi, ed_number, endp); 1869} 1870 1871 1872EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_flush); 1873static int ftdi_elan_flush_input_fifo(struct usb_ftdi *ftdi) 1874{ 1875 int retry_on_empty = 10; 1876 int retry_on_timeout = 5; 1877 int retry_on_status = 20; 1878 more:{ 1879 int packet_bytes = 0; 1880 int retval = usb_bulk_msg(ftdi->udev, 1881 usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr), 1882 ftdi->bulk_in_buffer, ftdi->bulk_in_size, 1883 &packet_bytes, 100); 1884 if (packet_bytes > 2) { 1885 char diag[30 *3 + 4]; 1886 char *d = diag; 1887 int m = (sizeof(diag) - 1) / 3; 1888 char *b = ftdi->bulk_in_buffer; 1889 int bytes_read = 0; 1890 diag[0] = 0; 1891 while (packet_bytes-- > 0) { 1892 char c = *b++; 1893 if (bytes_read < m) { 1894 d += sprintf(d, " %02X", 1895 0x000000FF & c); 1896 } else if (bytes_read > m) { 1897 } else 1898 d += sprintf(d, " .."); 1899 bytes_read += 1; 1900 continue; 1901 } 1902 goto more; 1903 } else if (packet_bytes > 1) { 1904 char s1 = ftdi->bulk_in_buffer[0]; 1905 char s2 = ftdi->bulk_in_buffer[1]; 1906 if (s1 == 0x31 && s2 == 0x60) { 1907 return 0; 1908 } else if (retry_on_status-- > 0) { 1909 goto more; 1910 } else { 1911 dev_err(&ftdi->udev->dev, "STATUS ERROR retry l" 1912 "imit reached\n"); 1913 return -EFAULT; 1914 } 1915 } else if (packet_bytes > 0) { 1916 char b1 = ftdi->bulk_in_buffer[0]; 1917 dev_err(&ftdi->udev->dev, "only one byte flushed from F" 1918 "TDI = %02X\n", b1); 1919 if (retry_on_status-- > 0) { 1920 goto more; 1921 } else { 1922 dev_err(&ftdi->udev->dev, "STATUS ERROR retry l" 1923 "imit reached\n"); 1924 return -EFAULT; 1925 } 1926 } else if (retval == -ETIMEDOUT) { 1927 if (retry_on_timeout-- > 0) { 1928 goto more; 1929 } else { 1930 dev_err(&ftdi->udev->dev, "TIMED OUT retry limi" 1931 "t reached\n"); 1932 return -ENOMEM; 1933 } 1934 } else if (retval == 0) { 1935 if (retry_on_empty-- > 0) { 1936 goto more; 1937 } else { 1938 dev_err(&ftdi->udev->dev, "empty packet retry l" 1939 "imit reached\n"); 1940 return -ENOMEM; 1941 } 1942 } else { 1943 dev_err(&ftdi->udev->dev, "error = %d\n", retval); 1944 return retval; 1945 } 1946 } 1947 return -1; 1948} 1949 1950 1951/* 1952* send the long flush sequence 1953* 1954*/ 1955static int ftdi_elan_synchronize_flush(struct usb_ftdi *ftdi) 1956{ 1957 int retval; 1958 struct urb *urb; 1959 char *buf; 1960 int I = 257; 1961 int i = 0; 1962 urb = usb_alloc_urb(0, GFP_KERNEL); 1963 if (!urb) { 1964 dev_err(&ftdi->udev->dev, "could not alloc a urb for flush sequ" 1965 "ence\n"); 1966 return -ENOMEM; 1967 } 1968 buf = usb_buffer_alloc(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma); 1969 if (!buf) { 1970 dev_err(&ftdi->udev->dev, "could not get a buffer for flush seq" 1971 "uence\n"); 1972 usb_free_urb(urb); 1973 return -ENOMEM; 1974 } 1975 while (I-- > 0) 1976 buf[i++] = 0x55; 1977 usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev, 1978 ftdi->bulk_out_endpointAddr), buf, i, 1979 ftdi_elan_write_bulk_callback, ftdi); 1980 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1981 retval = usb_submit_urb(urb, GFP_KERNEL); 1982 if (retval) { 1983 dev_err(&ftdi->udev->dev, "failed to submit urb containing the " 1984 "flush sequence\n"); 1985 usb_buffer_free(ftdi->udev, i, buf, urb->transfer_dma); 1986 usb_free_urb(urb); 1987 return -ENOMEM; 1988 } 1989 usb_free_urb(urb); 1990 return 0; 1991} 1992 1993 1994/* 1995* send the reset sequence 1996* 1997*/ 1998static int ftdi_elan_synchronize_reset(struct usb_ftdi *ftdi) 1999{ 2000 int retval; 2001 struct urb *urb; 2002 char *buf; 2003 int I = 4; 2004 int i = 0; 2005 urb = usb_alloc_urb(0, GFP_KERNEL); 2006 if (!urb) { 2007 dev_err(&ftdi->udev->dev, "could not get a urb for the reset se" 2008 "quence\n"); 2009 return -ENOMEM; 2010 } 2011 buf = usb_buffer_alloc(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma); 2012 if (!buf) { 2013 dev_err(&ftdi->udev->dev, "could not get a buffer for the reset" 2014 " sequence\n"); 2015 usb_free_urb(urb); 2016 return -ENOMEM; 2017 } 2018 buf[i++] = 0x55; 2019 buf[i++] = 0xAA; 2020 buf[i++] = 0x5A; 2021 buf[i++] = 0xA5; 2022 usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev, 2023 ftdi->bulk_out_endpointAddr), buf, i, 2024 ftdi_elan_write_bulk_callback, ftdi); 2025 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 2026 retval = usb_submit_urb(urb, GFP_KERNEL); 2027 if (retval) { 2028 dev_err(&ftdi->udev->dev, "failed to submit urb containing the " 2029 "reset sequence\n"); 2030 usb_buffer_free(ftdi->udev, i, buf, urb->transfer_dma); 2031 usb_free_urb(urb); 2032 return -ENOMEM; 2033 } 2034 usb_free_urb(urb); 2035 return 0; 2036} 2037 2038static int ftdi_elan_synchronize(struct usb_ftdi *ftdi) 2039{ 2040 int retval; 2041 int long_stop = 10; 2042 int retry_on_timeout = 5; 2043 int retry_on_empty = 10; 2044 int err_count = 0; 2045 retval = ftdi_elan_flush_input_fifo(ftdi); 2046 if (retval) 2047 return retval; 2048 ftdi->bulk_in_left = 0; 2049 ftdi->bulk_in_last = -1; 2050 while (long_stop-- > 0) { 2051 int read_stop; 2052 int read_stuck; 2053 retval = ftdi_elan_synchronize_flush(ftdi); 2054 if (retval) 2055 return retval; 2056 retval = ftdi_elan_flush_input_fifo(ftdi); 2057 if (retval) 2058 return retval; 2059 reset:retval = ftdi_elan_synchronize_reset(ftdi); 2060 if (retval) 2061 return retval; 2062 read_stop = 100; 2063 read_stuck = 10; 2064 read:{ 2065 int packet_bytes = 0; 2066 retval = usb_bulk_msg(ftdi->udev, 2067 usb_rcvbulkpipe(ftdi->udev, 2068 ftdi->bulk_in_endpointAddr), 2069 ftdi->bulk_in_buffer, ftdi->bulk_in_size, 2070 &packet_bytes, 500); 2071 if (packet_bytes > 2) { 2072 char diag[30 *3 + 4]; 2073 char *d = diag; 2074 int m = (sizeof(diag) - 1) / 3; 2075 char *b = ftdi->bulk_in_buffer; 2076 int bytes_read = 0; 2077 unsigned char c = 0; 2078 diag[0] = 0; 2079 while (packet_bytes-- > 0) { 2080 c = *b++; 2081 if (bytes_read < m) { 2082 d += sprintf(d, " %02X", c); 2083 } else if (bytes_read > m) { 2084 } else 2085 d += sprintf(d, " .."); 2086 bytes_read += 1; 2087 continue; 2088 } 2089 if (c == 0x7E) { 2090 return 0; 2091 } else { 2092 if (c == 0x55) { 2093 goto read; 2094 } else if (read_stop-- > 0) { 2095 goto read; 2096 } else { 2097 dev_err(&ftdi->udev->dev, "retr" 2098 "y limit reached\n"); 2099 continue; 2100 } 2101 } 2102 } else if (packet_bytes > 1) { 2103 unsigned char s1 = ftdi->bulk_in_buffer[0]; 2104 unsigned char s2 = ftdi->bulk_in_buffer[1]; 2105 if (s1 == 0x31 && s2 == 0x00) { 2106 if (read_stuck-- > 0) { 2107 goto read; 2108 } else 2109 goto reset; 2110 } else if (s1 == 0x31 && s2 == 0x60) { 2111 if (read_stop-- > 0) { 2112 goto read; 2113 } else { 2114 dev_err(&ftdi->udev->dev, "retr" 2115 "y limit reached\n"); 2116 continue; 2117 } 2118 } else { 2119 if (read_stop-- > 0) { 2120 goto read; 2121 } else { 2122 dev_err(&ftdi->udev->dev, "retr" 2123 "y limit reached\n"); 2124 continue; 2125 } 2126 } 2127 } else if (packet_bytes > 0) { 2128 if (read_stop-- > 0) { 2129 goto read; 2130 } else { 2131 dev_err(&ftdi->udev->dev, "retry limit " 2132 "reached\n"); 2133 continue; 2134 } 2135 } else if (retval == -ETIMEDOUT) { 2136 if (retry_on_timeout-- > 0) { 2137 goto read; 2138 } else { 2139 dev_err(&ftdi->udev->dev, "TIMED OUT re" 2140 "try limit reached\n"); 2141 continue; 2142 } 2143 } else if (retval == 0) { 2144 if (retry_on_empty-- > 0) { 2145 goto read; 2146 } else { 2147 dev_err(&ftdi->udev->dev, "empty packet" 2148 " retry limit reached\n"); 2149 continue; 2150 } 2151 } else { 2152 err_count += 1; 2153 dev_err(&ftdi->udev->dev, "error = %d\n", 2154 retval); 2155 if (read_stop-- > 0) { 2156 goto read; 2157 } else { 2158 dev_err(&ftdi->udev->dev, "retry limit " 2159 "reached\n"); 2160 continue; 2161 } 2162 } 2163 } 2164 } 2165 dev_err(&ftdi->udev->dev, "failed to synchronize\n"); 2166 return -EFAULT; 2167} 2168 2169static int ftdi_elan_stuck_waiting(struct usb_ftdi *ftdi) 2170{ 2171 int retry_on_empty = 10; 2172 int retry_on_timeout = 5; 2173 int retry_on_status = 50; 2174 more:{ 2175 int packet_bytes = 0; 2176 int retval = usb_bulk_msg(ftdi->udev, 2177 usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr), 2178 ftdi->bulk_in_buffer, ftdi->bulk_in_size, 2179 &packet_bytes, 1000); 2180 if (packet_bytes > 2) { 2181 char diag[30 *3 + 4]; 2182 char *d = diag; 2183 int m = (sizeof(diag) - 1) / 3; 2184 char *b = ftdi->bulk_in_buffer; 2185 int bytes_read = 0; 2186 diag[0] = 0; 2187 while (packet_bytes-- > 0) { 2188 char c = *b++; 2189 if (bytes_read < m) { 2190 d += sprintf(d, " %02X", 2191 0x000000FF & c); 2192 } else if (bytes_read > m) { 2193 } else 2194 d += sprintf(d, " .."); 2195 bytes_read += 1; 2196 continue; 2197 } 2198 goto more; 2199 } else if (packet_bytes > 1) { 2200 char s1 = ftdi->bulk_in_buffer[0]; 2201 char s2 = ftdi->bulk_in_buffer[1]; 2202 if (s1 == 0x31 && s2 == 0x60) { 2203 return 0; 2204 } else if (retry_on_status-- > 0) { 2205 msleep(5); 2206 goto more; 2207 } else 2208 return -EFAULT; 2209 } else if (packet_bytes > 0) { 2210 char b1 = ftdi->bulk_in_buffer[0]; 2211 dev_err(&ftdi->udev->dev, "only one byte flushed from F" 2212 "TDI = %02X\n", b1); 2213 if (retry_on_status-- > 0) { 2214 msleep(5); 2215 goto more; 2216 } else { 2217 dev_err(&ftdi->udev->dev, "STATUS ERROR retry l" 2218 "imit reached\n"); 2219 return -EFAULT; 2220 } 2221 } else if (retval == -ETIMEDOUT) { 2222 if (retry_on_timeout-- > 0) { 2223 goto more; 2224 } else { 2225 dev_err(&ftdi->udev->dev, "TIMED OUT retry limi" 2226 "t reached\n"); 2227 return -ENOMEM; 2228 } 2229 } else if (retval == 0) { 2230 if (retry_on_empty-- > 0) { 2231 goto more; 2232 } else { 2233 dev_err(&ftdi->udev->dev, "empty packet retry l" 2234 "imit reached\n"); 2235 return -ENOMEM; 2236 } 2237 } else { 2238 dev_err(&ftdi->udev->dev, "error = %d\n", retval); 2239 return -ENOMEM; 2240 } 2241 } 2242 return -1; 2243} 2244 2245static int ftdi_elan_checkingPCI(struct usb_ftdi *ftdi) 2246{ 2247 int UxxxStatus = ftdi_elan_read_reg(ftdi, &ftdi->controlreg); 2248 if (UxxxStatus) 2249 return UxxxStatus; 2250 if (ftdi->controlreg & 0x00400000) { 2251 if (ftdi->card_ejected) { 2252 } else { 2253 ftdi->card_ejected = 1; 2254 dev_err(&ftdi->udev->dev, "CARD EJECTED - controlreg = " 2255 "%08X\n", ftdi->controlreg); 2256 } 2257 return -ENODEV; 2258 } else { 2259 u8 fn = ftdi->function - 1; 2260 int activePCIfn = fn << 8; 2261 u32 pcidata; 2262 u32 pciVID; 2263 u32 pciPID; 2264 int reg = 0; 2265 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2266 &pcidata); 2267 if (UxxxStatus) 2268 return UxxxStatus; 2269 pciVID = pcidata & 0xFFFF; 2270 pciPID = (pcidata >> 16) & 0xFFFF; 2271 if (pciVID == ftdi->platform_data.vendor && pciPID == 2272 ftdi->platform_data.device) { 2273 return 0; 2274 } else { 2275 dev_err(&ftdi->udev->dev, "vendor=%04X pciVID=%04X devi" 2276 "ce=%04X pciPID=%04X\n", 2277 ftdi->platform_data.vendor, pciVID, 2278 ftdi->platform_data.device, pciPID); 2279 return -ENODEV; 2280 } 2281 } 2282} 2283 2284 2285#define ftdi_read_pcimem(ftdi, member, data) ftdi_elan_read_pcimem(ftdi, \ 2286 offsetof(struct ohci_regs, member), 0, data); 2287#define ftdi_write_pcimem(ftdi, member, data) ftdi_elan_write_pcimem(ftdi, \ 2288 offsetof(struct ohci_regs, member), 0, data); 2289 2290#define OHCI_CONTROL_INIT OHCI_CTRL_CBSR 2291#define OHCI_INTR_INIT (OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_RD | \ 2292 OHCI_INTR_WDH) 2293static int ftdi_elan_check_controller(struct usb_ftdi *ftdi, int quirk) 2294{ 2295 int devices = 0; 2296 int retval; 2297 u32 hc_control; 2298 int num_ports; 2299 u32 control; 2300 u32 rh_a = -1; 2301 u32 status; 2302 u32 fminterval; 2303 u32 hc_fminterval; 2304 u32 periodicstart; 2305 u32 cmdstatus; 2306 u32 roothub_a; 2307 int mask = OHCI_INTR_INIT; 2308 int sleep_time = 0; 2309 int reset_timeout = 30; /* ... allow extra time */ 2310 int temp; 2311 retval = ftdi_write_pcimem(ftdi, intrdisable, OHCI_INTR_MIE); 2312 if (retval) 2313 return retval; 2314 retval = ftdi_read_pcimem(ftdi, control, &control); 2315 if (retval) 2316 return retval; 2317 retval = ftdi_read_pcimem(ftdi, roothub.a, &rh_a); 2318 if (retval) 2319 return retval; 2320 num_ports = rh_a & RH_A_NDP; 2321 retval = ftdi_read_pcimem(ftdi, fminterval, &hc_fminterval); 2322 if (retval) 2323 return retval; 2324 hc_fminterval &= 0x3fff; 2325 if (hc_fminterval != FI) { 2326 } 2327 hc_fminterval |= FSMP(hc_fminterval) << 16; 2328 retval = ftdi_read_pcimem(ftdi, control, &hc_control); 2329 if (retval) 2330 return retval; 2331 switch (hc_control & OHCI_CTRL_HCFS) { 2332 case OHCI_USB_OPER: 2333 sleep_time = 0; 2334 break; 2335 case OHCI_USB_SUSPEND: 2336 case OHCI_USB_RESUME: 2337 hc_control &= OHCI_CTRL_RWC; 2338 hc_control |= OHCI_USB_RESUME; 2339 sleep_time = 10; 2340 break; 2341 default: 2342 hc_control &= OHCI_CTRL_RWC; 2343 hc_control |= OHCI_USB_RESET; 2344 sleep_time = 50; 2345 break; 2346 } 2347 retval = ftdi_write_pcimem(ftdi, control, hc_control); 2348 if (retval) 2349 return retval; 2350 retval = ftdi_read_pcimem(ftdi, control, &control); 2351 if (retval) 2352 return retval; 2353 msleep(sleep_time); 2354 retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a); 2355 if (retval) 2356 return retval; 2357 if (!(roothub_a & RH_A_NPS)) { /* power down each port */ 2358 for (temp = 0; temp < num_ports; temp++) { 2359 retval = ftdi_write_pcimem(ftdi, 2360 roothub.portstatus[temp], RH_PS_LSDA); 2361 if (retval) 2362 return retval; 2363 } 2364 } 2365 retval = ftdi_read_pcimem(ftdi, control, &control); 2366 if (retval) 2367 return retval; 2368 retry:retval = ftdi_read_pcimem(ftdi, cmdstatus, &status); 2369 if (retval) 2370 return retval; 2371 retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_HCR); 2372 if (retval) 2373 return retval; 2374 extra:{ 2375 retval = ftdi_read_pcimem(ftdi, cmdstatus, &status); 2376 if (retval) 2377 return retval; 2378 if (0 != (status & OHCI_HCR)) { 2379 if (--reset_timeout == 0) { 2380 dev_err(&ftdi->udev->dev, "USB HC reset timed o" 2381 "ut!\n"); 2382 return -ENODEV; 2383 } else { 2384 msleep(5); 2385 goto extra; 2386 } 2387 } 2388 } 2389 if (quirk & OHCI_QUIRK_INITRESET) { 2390 retval = ftdi_write_pcimem(ftdi, control, hc_control); 2391 if (retval) 2392 return retval; 2393 retval = ftdi_read_pcimem(ftdi, control, &control); 2394 if (retval) 2395 return retval; 2396 } 2397 retval = ftdi_write_pcimem(ftdi, ed_controlhead, 0x00000000); 2398 if (retval) 2399 return retval; 2400 retval = ftdi_write_pcimem(ftdi, ed_bulkhead, 0x11000000); 2401 if (retval) 2402 return retval; 2403 retval = ftdi_write_pcimem(ftdi, hcca, 0x00000000); 2404 if (retval) 2405 return retval; 2406 retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval); 2407 if (retval) 2408 return retval; 2409 retval = ftdi_write_pcimem(ftdi, fminterval, 2410 ((fminterval & FIT) ^ FIT) | hc_fminterval); 2411 if (retval) 2412 return retval; 2413 retval = ftdi_write_pcimem(ftdi, periodicstart, 2414 ((9 *hc_fminterval) / 10) & 0x3fff); 2415 if (retval) 2416 return retval; 2417 retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval); 2418 if (retval) 2419 return retval; 2420 retval = ftdi_read_pcimem(ftdi, periodicstart, &periodicstart); 2421 if (retval) 2422 return retval; 2423 if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) { 2424 if (!(quirk & OHCI_QUIRK_INITRESET)) { 2425 quirk |= OHCI_QUIRK_INITRESET; 2426 goto retry; 2427 } else 2428 dev_err(&ftdi->udev->dev, "init err(%08x %04x)\n", 2429 fminterval, periodicstart); 2430 } /* start controller operations */ 2431 hc_control &= OHCI_CTRL_RWC; 2432 hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER; 2433 retval = ftdi_write_pcimem(ftdi, control, hc_control); 2434 if (retval) 2435 return retval; 2436 retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_BLF); 2437 if (retval) 2438 return retval; 2439 retval = ftdi_read_pcimem(ftdi, cmdstatus, &cmdstatus); 2440 if (retval) 2441 return retval; 2442 retval = ftdi_read_pcimem(ftdi, control, &control); 2443 if (retval) 2444 return retval; 2445 retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_DRWE); 2446 if (retval) 2447 return retval; 2448 retval = ftdi_write_pcimem(ftdi, intrstatus, mask); 2449 if (retval) 2450 return retval; 2451 retval = ftdi_write_pcimem(ftdi, intrdisable, 2452 OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO | 2453 OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH | 2454 OHCI_INTR_SO); 2455 if (retval) 2456 return retval; /* handle root hub init quirks ... */ 2457 retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a); 2458 if (retval) 2459 return retval; 2460 roothub_a &= ~(RH_A_PSM | RH_A_OCPM); 2461 if (quirk & OHCI_QUIRK_SUPERIO) { 2462 roothub_a |= RH_A_NOCP; 2463 roothub_a &= ~(RH_A_POTPGT | RH_A_NPS); 2464 retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a); 2465 if (retval) 2466 return retval; 2467 } else if ((quirk & OHCI_QUIRK_AMD756) || distrust_firmware) { 2468 roothub_a |= RH_A_NPS; 2469 retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a); 2470 if (retval) 2471 return retval; 2472 } 2473 retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_LPSC); 2474 if (retval) 2475 return retval; 2476 retval = ftdi_write_pcimem(ftdi, roothub.b, 2477 (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM); 2478 if (retval) 2479 return retval; 2480 retval = ftdi_read_pcimem(ftdi, control, &control); 2481 if (retval) 2482 return retval; 2483 mdelay((roothub_a >> 23) & 0x1fe); 2484 for (temp = 0; temp < num_ports; temp++) { 2485 u32 portstatus; 2486 retval = ftdi_read_pcimem(ftdi, roothub.portstatus[temp], 2487 &portstatus); 2488 if (retval) 2489 return retval; 2490 if (1 & portstatus) 2491 devices += 1; 2492 } 2493 return devices; 2494} 2495 2496static int ftdi_elan_setup_controller(struct usb_ftdi *ftdi, int fn) 2497{ 2498 u32 latence_timer; 2499 int UxxxStatus; 2500 u32 pcidata; 2501 int reg = 0; 2502 int activePCIfn = fn << 8; 2503 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800); 2504 if (UxxxStatus) 2505 return UxxxStatus; 2506 reg = 16; 2507 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0, 2508 0xFFFFFFFF); 2509 if (UxxxStatus) 2510 return UxxxStatus; 2511 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2512 &pcidata); 2513 if (UxxxStatus) 2514 return UxxxStatus; 2515 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0, 2516 0xF0000000); 2517 if (UxxxStatus) 2518 return UxxxStatus; 2519 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2520 &pcidata); 2521 if (UxxxStatus) 2522 return UxxxStatus; 2523 reg = 12; 2524 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2525 &latence_timer); 2526 if (UxxxStatus) 2527 return UxxxStatus; 2528 latence_timer &= 0xFFFF00FF; 2529 latence_timer |= 0x00001600; 2530 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00, 2531 latence_timer); 2532 if (UxxxStatus) 2533 return UxxxStatus; 2534 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2535 &pcidata); 2536 if (UxxxStatus) 2537 return UxxxStatus; 2538 reg = 4; 2539 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00, 2540 0x06); 2541 if (UxxxStatus) 2542 return UxxxStatus; 2543 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2544 &pcidata); 2545 if (UxxxStatus) 2546 return UxxxStatus; 2547 for (reg = 0; reg <= 0x54; reg += 4) { 2548 UxxxStatus = ftdi_elan_read_pcimem(ftdi, reg, 0, &pcidata); 2549 if (UxxxStatus) 2550 return UxxxStatus; 2551 } 2552 return 0; 2553} 2554 2555static int ftdi_elan_close_controller(struct usb_ftdi *ftdi, int fn) 2556{ 2557 u32 latence_timer; 2558 int UxxxStatus; 2559 u32 pcidata; 2560 int reg = 0; 2561 int activePCIfn = fn << 8; 2562 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800); 2563 if (UxxxStatus) 2564 return UxxxStatus; 2565 reg = 16; 2566 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0, 2567 0xFFFFFFFF); 2568 if (UxxxStatus) 2569 return UxxxStatus; 2570 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2571 &pcidata); 2572 if (UxxxStatus) 2573 return UxxxStatus; 2574 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0, 2575 0x00000000); 2576 if (UxxxStatus) 2577 return UxxxStatus; 2578 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2579 &pcidata); 2580 if (UxxxStatus) 2581 return UxxxStatus; 2582 reg = 12; 2583 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2584 &latence_timer); 2585 if (UxxxStatus) 2586 return UxxxStatus; 2587 latence_timer &= 0xFFFF00FF; 2588 latence_timer |= 0x00001600; 2589 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00, 2590 latence_timer); 2591 if (UxxxStatus) 2592 return UxxxStatus; 2593 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2594 &pcidata); 2595 if (UxxxStatus) 2596 return UxxxStatus; 2597 reg = 4; 2598 UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00, 2599 0x00); 2600 if (UxxxStatus) 2601 return UxxxStatus; 2602 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2603 &pcidata); 2604 if (UxxxStatus) 2605 return UxxxStatus; 2606 return 0; 2607} 2608 2609static int ftdi_elan_found_controller(struct usb_ftdi *ftdi, int fn, int quirk) 2610{ 2611 int result; 2612 int UxxxStatus; 2613 UxxxStatus = ftdi_elan_setup_controller(ftdi, fn); 2614 if (UxxxStatus) 2615 return UxxxStatus; 2616 result = ftdi_elan_check_controller(ftdi, quirk); 2617 UxxxStatus = ftdi_elan_close_controller(ftdi, fn); 2618 if (UxxxStatus) 2619 return UxxxStatus; 2620 return result; 2621} 2622 2623static int ftdi_elan_enumeratePCI(struct usb_ftdi *ftdi) 2624{ 2625 u32 controlreg; 2626 u8 sensebits; 2627 int UxxxStatus; 2628 UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg); 2629 if (UxxxStatus) 2630 return UxxxStatus; 2631 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000000L); 2632 if (UxxxStatus) 2633 return UxxxStatus; 2634 msleep(750); 2635 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x100); 2636 if (UxxxStatus) 2637 return UxxxStatus; 2638 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x500); 2639 if (UxxxStatus) 2640 return UxxxStatus; 2641 UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg); 2642 if (UxxxStatus) 2643 return UxxxStatus; 2644 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020CL | 0x000); 2645 if (UxxxStatus) 2646 return UxxxStatus; 2647 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020DL | 0x000); 2648 if (UxxxStatus) 2649 return UxxxStatus; 2650 msleep(250); 2651 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020FL | 0x000); 2652 if (UxxxStatus) 2653 return UxxxStatus; 2654 UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg); 2655 if (UxxxStatus) 2656 return UxxxStatus; 2657 UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x800); 2658 if (UxxxStatus) 2659 return UxxxStatus; 2660 UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg); 2661 if (UxxxStatus) 2662 return UxxxStatus; 2663 UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg); 2664 if (UxxxStatus) 2665 return UxxxStatus; 2666 msleep(1000); 2667 sensebits = (controlreg >> 16) & 0x000F; 2668 if (0x0D == sensebits) 2669 return 0; 2670 else 2671 return - ENXIO; 2672} 2673 2674static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi) 2675{ 2676 int UxxxStatus; 2677 u32 pcidata; 2678 int reg = 0; 2679 u8 fn; 2680 int activePCIfn = 0; 2681 int max_devices = 0; 2682 int controllers = 0; 2683 int unrecognized = 0; 2684 ftdi->function = 0; 2685 for (fn = 0; (fn < 4); fn++) { 2686 u32 pciVID = 0; 2687 u32 pciPID = 0; 2688 int devices = 0; 2689 activePCIfn = fn << 8; 2690 UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0, 2691 &pcidata); 2692 if (UxxxStatus) 2693 return UxxxStatus; 2694 pciVID = pcidata & 0xFFFF; 2695 pciPID = (pcidata >> 16) & 0xFFFF; 2696 if ((pciVID == PCI_VENDOR_ID_OPTI) && (pciPID == 0xc861)) { 2697 devices = ftdi_elan_found_controller(ftdi, fn, 0); 2698 controllers += 1; 2699 } else if ((pciVID == PCI_VENDOR_ID_NEC) && (pciPID == 0x0035)) 2700 { 2701 devices = ftdi_elan_found_controller(ftdi, fn, 0); 2702 controllers += 1; 2703 } else if ((pciVID == PCI_VENDOR_ID_AL) && (pciPID == 0x5237)) { 2704 devices = ftdi_elan_found_controller(ftdi, fn, 0); 2705 controllers += 1; 2706 } else if ((pciVID == PCI_VENDOR_ID_ATT) && (pciPID == 0x5802)) 2707 { 2708 devices = ftdi_elan_found_controller(ftdi, fn, 0); 2709 controllers += 1; 2710 } else if (pciVID == PCI_VENDOR_ID_AMD && pciPID == 0x740c) { 2711 devices = ftdi_elan_found_controller(ftdi, fn, 2712 OHCI_QUIRK_AMD756); 2713 controllers += 1; 2714 } else if (pciVID == PCI_VENDOR_ID_COMPAQ && pciPID == 0xa0f8) { 2715 devices = ftdi_elan_found_controller(ftdi, fn, 2716 OHCI_QUIRK_ZFMICRO); 2717 controllers += 1; 2718 } else if (0 == pcidata) { 2719 } else 2720 unrecognized += 1; 2721 if (devices > max_devices) { 2722 max_devices = devices; 2723 ftdi->function = fn + 1; 2724 ftdi->platform_data.vendor = pciVID; 2725 ftdi->platform_data.device = pciPID; 2726 } 2727 } 2728 if (ftdi->function > 0) { 2729 UxxxStatus = ftdi_elan_setup_controller(ftdi, 2730 ftdi->function - 1); 2731 if (UxxxStatus) 2732 return UxxxStatus; 2733 return 0; 2734 } else if (controllers > 0) { 2735 return -ENXIO; 2736 } else if (unrecognized > 0) { 2737 return -ENXIO; 2738 } else { 2739 ftdi->enumerated = 0; 2740 return -ENXIO; 2741 } 2742} 2743 2744 2745/* 2746* we use only the first bulk-in and bulk-out endpoints 2747*/ 2748static int ftdi_elan_probe(struct usb_interface *interface, 2749 const struct usb_device_id *id) 2750{ 2751 struct usb_host_interface *iface_desc; 2752 struct usb_endpoint_descriptor *endpoint; 2753 size_t buffer_size; 2754 int i; 2755 int retval = -ENOMEM; 2756 struct usb_ftdi *ftdi; 2757 2758 ftdi = kzalloc(sizeof(struct usb_ftdi), GFP_KERNEL); 2759 if (!ftdi) { 2760 printk(KERN_ERR "Out of memory\n"); 2761 return -ENOMEM; 2762 } 2763 2764 mutex_lock(&ftdi_module_lock); 2765 list_add_tail(&ftdi->ftdi_list, &ftdi_static_list); 2766 ftdi->sequence_num = ++ftdi_instances; 2767 mutex_unlock(&ftdi_module_lock); 2768 ftdi_elan_init_kref(ftdi); 2769 init_MUTEX(&ftdi->sw_lock); 2770 ftdi->udev = usb_get_dev(interface_to_usbdev(interface)); 2771 ftdi->interface = interface; 2772 mutex_init(&ftdi->u132_lock); 2773 ftdi->expected = 4; 2774 iface_desc = interface->cur_altsetting; 2775 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 2776 endpoint = &iface_desc->endpoint[i].desc; 2777 if (!ftdi->bulk_in_endpointAddr && 2778 usb_endpoint_is_bulk_in(endpoint)) { 2779 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 2780 ftdi->bulk_in_size = buffer_size; 2781 ftdi->bulk_in_endpointAddr = endpoint->bEndpointAddress; 2782 ftdi->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL); 2783 if (!ftdi->bulk_in_buffer) { 2784 dev_err(&ftdi->udev->dev, "Could not allocate b" 2785 "ulk_in_buffer\n"); 2786 retval = -ENOMEM; 2787 goto error; 2788 } 2789 } 2790 if (!ftdi->bulk_out_endpointAddr && 2791 usb_endpoint_is_bulk_out(endpoint)) { 2792 ftdi->bulk_out_endpointAddr = 2793 endpoint->bEndpointAddress; 2794 } 2795 } 2796 if (!(ftdi->bulk_in_endpointAddr && ftdi->bulk_out_endpointAddr)) { 2797 dev_err(&ftdi->udev->dev, "Could not find both bulk-in and bulk" 2798 "-out endpoints\n"); 2799 retval = -ENODEV; 2800 goto error; 2801 } 2802 dev_info(&ftdi->udev->dev, "interface %d has I=%02X O=%02X\n", 2803 iface_desc->desc.bInterfaceNumber, ftdi->bulk_in_endpointAddr, 2804 ftdi->bulk_out_endpointAddr); 2805 usb_set_intfdata(interface, ftdi); 2806 if (iface_desc->desc.bInterfaceNumber == 0 && 2807 ftdi->bulk_in_endpointAddr == 0x81 && 2808 ftdi->bulk_out_endpointAddr == 0x02) { 2809 retval = usb_register_dev(interface, &ftdi_elan_jtag_class); 2810 if (retval) { 2811 dev_err(&ftdi->udev->dev, "Not able to get a minor for " 2812 "this device.\n"); 2813 usb_set_intfdata(interface, NULL); 2814 retval = -ENOMEM; 2815 goto error; 2816 } else { 2817 ftdi->class = &ftdi_elan_jtag_class; 2818 dev_info(&ftdi->udev->dev, "USB FDTI=%p JTAG interface " 2819 "%d now attached to ftdi%d\n", ftdi, 2820 iface_desc->desc.bInterfaceNumber, 2821 interface->minor); 2822 return 0; 2823 } 2824 } else if (iface_desc->desc.bInterfaceNumber == 1 && 2825 ftdi->bulk_in_endpointAddr == 0x83 && 2826 ftdi->bulk_out_endpointAddr == 0x04) { 2827 ftdi->class = NULL; 2828 dev_info(&ftdi->udev->dev, "USB FDTI=%p ELAN interface %d now a" 2829 "ctivated\n", ftdi, iface_desc->desc.bInterfaceNumber); 2830 INIT_DELAYED_WORK(&ftdi->status_work, ftdi_elan_status_work); 2831 INIT_DELAYED_WORK(&ftdi->command_work, ftdi_elan_command_work); 2832 INIT_DELAYED_WORK(&ftdi->respond_work, ftdi_elan_respond_work); 2833 ftdi_status_queue_work(ftdi, msecs_to_jiffies(3 *1000)); 2834 return 0; 2835 } else { 2836 dev_err(&ftdi->udev->dev, 2837 "Could not find ELAN's U132 device\n"); 2838 retval = -ENODEV; 2839 goto error; 2840 } 2841 error:if (ftdi) { 2842 ftdi_elan_put_kref(ftdi); 2843 } 2844 return retval; 2845} 2846 2847static void ftdi_elan_disconnect(struct usb_interface *interface) 2848{ 2849 struct usb_ftdi *ftdi = usb_get_intfdata(interface); 2850 ftdi->disconnected += 1; 2851 if (ftdi->class) { 2852 int minor = interface->minor; 2853 struct usb_class_driver *class = ftdi->class; 2854 usb_set_intfdata(interface, NULL); 2855 usb_deregister_dev(interface, class); 2856 dev_info(&ftdi->udev->dev, "USB FTDI U132 jtag interface on min" 2857 "or %d now disconnected\n", minor); 2858 } else { 2859 ftdi_status_cancel_work(ftdi); 2860 ftdi_command_cancel_work(ftdi); 2861 ftdi_response_cancel_work(ftdi); 2862 ftdi_elan_abandon_completions(ftdi); 2863 ftdi_elan_abandon_targets(ftdi); 2864 if (ftdi->registered) { 2865 platform_device_unregister(&ftdi->platform_dev); 2866 ftdi->synchronized = 0; 2867 ftdi->enumerated = 0; 2868 ftdi->initialized = 0; 2869 ftdi->registered = 0; 2870 } 2871 flush_workqueue(status_queue); 2872 flush_workqueue(command_queue); 2873 flush_workqueue(respond_queue); 2874 ftdi->disconnected += 1; 2875 usb_set_intfdata(interface, NULL); 2876 dev_info(&ftdi->udev->dev, "USB FTDI U132 host controller inter" 2877 "face now disconnected\n"); 2878 } 2879 ftdi_elan_put_kref(ftdi); 2880} 2881 2882static struct usb_driver ftdi_elan_driver = { 2883 .name = "ftdi-elan", 2884 .probe = ftdi_elan_probe, 2885 .disconnect = ftdi_elan_disconnect, 2886 .id_table = ftdi_elan_table, 2887}; 2888static int __init ftdi_elan_init(void) 2889{ 2890 int result; 2891 printk(KERN_INFO "driver %s built at %s on %s\n", ftdi_elan_driver.name, 2892 __TIME__, __DATE__); 2893 mutex_init(&ftdi_module_lock); 2894 INIT_LIST_HEAD(&ftdi_static_list); 2895 status_queue = create_singlethread_workqueue("ftdi-status-control"); 2896 if (!status_queue) 2897 goto err_status_queue; 2898 command_queue = create_singlethread_workqueue("ftdi-command-engine"); 2899 if (!command_queue) 2900 goto err_command_queue; 2901 respond_queue = create_singlethread_workqueue("ftdi-respond-engine"); 2902 if (!respond_queue) 2903 goto err_respond_queue; 2904 result = usb_register(&ftdi_elan_driver); 2905 if (result) { 2906 destroy_workqueue(status_queue); 2907 destroy_workqueue(command_queue); 2908 destroy_workqueue(respond_queue); 2909 printk(KERN_ERR "usb_register failed. Error number %d\n", 2910 result); 2911 } 2912 return result; 2913 2914 err_respond_queue: 2915 destroy_workqueue(command_queue); 2916 err_command_queue: 2917 destroy_workqueue(status_queue); 2918 err_status_queue: 2919 printk(KERN_ERR "%s couldn't create workqueue\n", ftdi_elan_driver.name); 2920 return -ENOMEM; 2921} 2922 2923static void __exit ftdi_elan_exit(void) 2924{ 2925 struct usb_ftdi *ftdi; 2926 struct usb_ftdi *temp; 2927 usb_deregister(&ftdi_elan_driver); 2928 printk(KERN_INFO "ftdi_u132 driver deregistered\n"); 2929 list_for_each_entry_safe(ftdi, temp, &ftdi_static_list, ftdi_list) { 2930 ftdi_status_cancel_work(ftdi); 2931 ftdi_command_cancel_work(ftdi); 2932 ftdi_response_cancel_work(ftdi); 2933 } flush_workqueue(status_queue); 2934 destroy_workqueue(status_queue); 2935 status_queue = NULL; 2936 flush_workqueue(command_queue); 2937 destroy_workqueue(command_queue); 2938 command_queue = NULL; 2939 flush_workqueue(respond_queue); 2940 destroy_workqueue(respond_queue); 2941 respond_queue = NULL; 2942} 2943 2944 2945module_init(ftdi_elan_init); 2946module_exit(ftdi_elan_exit); 2947