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