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