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