drivers/usb/misc/ftdi-elan.c

   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>
  51 MODULE_AUTHOR("Tony Olech");
  52 MODULE_DESCRIPTION("FTDI ELAN driver");
  53 MODULE_LICENSE("GPL");
  54 #define INT_MODULE_PARM(n, v) static int n = v;module_param(n, int, 0444)
  55 static int distrust_firmware = 1;
  56 module_param(distrust_firmware, bool, 0);
  57 MODULE_PARM_DESC(distrust_firmware, "true to distrust firmware power/overcurren"
  58         "t setup");
  59 extern struct platform_driver u132_platform_driver;
  60 static struct workqueue_struct *status_queue;
  61 static struct workqueue_struct *command_queue;
  62 static struct workqueue_struct *respond_queue;
  63 /*
  64 * ftdi_module_lock exists to protect access to global variables
  65 *
  66 */
  67 static struct semaphore ftdi_module_lock;
  68 static int ftdi_instances = 0;
  69 static 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*/
  81 static 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
  86 MODULE_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)
 102 struct 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)
 114 struct u132_respond {
 115         u8 header;
 116         u8 address;
 117         u32 *value;
 118         int *result;
 119         struct completion wait_completion;
 120 };
 121 struct 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*/
 140 struct 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)
 188 static struct usb_driver ftdi_elan_driver;
 189 static 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
 203 static void ftdi_elan_put_kref(struct usb_ftdi *ftdi)
 204 {
 205         kref_put(&ftdi->kref, ftdi_elan_delete);
 206 }
 207
 208 static void ftdi_elan_get_kref(struct usb_ftdi *ftdi)
 209 {
 210         kref_get(&ftdi->kref);
 211 }
 212
 213 static void ftdi_elan_init_kref(struct usb_ftdi *ftdi)
 214 {
 215         kref_init(&ftdi->kref);
 216 }
 217
 218 static 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
 224 static 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
 230 static 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
 236 static 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
 242 static 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
 248 static 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
 254 static 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
 261 static 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
 267 static 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
 273 void 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
 281 EXPORT_SYMBOL_GPL(ftdi_elan_gone_away);
 282 static void ftdi_release_platform_dev(struct device *dev)
 283 {
 284         dev->parent = NULL;
 285 }
 286
 287 static void ftdi_elan_do_callback(struct usb_ftdi *ftdi,
 288         struct u132_target *target, u8 *buffer, int length);
 289 static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi);
 290 static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi);
 291 static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi);
 292 static int ftdi_elan_checkingPCI(struct usb_ftdi *ftdi);
 293 static int ftdi_elan_enumeratePCI(struct usb_ftdi *ftdi);
 294 static int ftdi_elan_synchronize(struct usb_ftdi *ftdi);
 295 static int ftdi_elan_stuck_waiting(struct usb_ftdi *ftdi);
 296 static int ftdi_elan_command_engine(struct usb_ftdi *ftdi);
 297 static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi);
 298 static 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
 323 static 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
 335 static 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
 354 static 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
 412 static 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
 448 static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi)
 449 {
 450         ftdi_command_queue_work(ftdi, 0);
 451         return;
 452 }
 453
 454 static 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
 475 static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi)
 476 {
 477         ftdi_respond_queue_work(ftdi, 0);
 478         return;
 479 }
 480
 481 static 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 */
 516 static 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 */
 616 static 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
 640 static 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)
 653 static 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 */
 679 static 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
 739 static 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
 751 static 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
 778 static 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
 790 static 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
 853 static 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
 874 static 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
 936 static 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 */
 964 static 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 */
1160 static 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
1202 exit:
1203         return count;
1204 error_3:
1205         usb_buffer_free(ftdi->udev, count, buf, urb->transfer_dma);
1206 error_2:
1207         usb_free_urb(urb);
1208 error_1:
1209         return retval;
1210 }
1211
1212 static 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 */
1226 static 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
1265 static 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
1295 static 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
1327 static 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
1359 int 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
1367 EXPORT_SYMBOL_GPL(usb_ftdi_elan_write_pcimem);
1368 static 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
1409 static 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
1453 static 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
1497 int 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
1508 EXPORT_SYMBOL_GPL(usb_ftdi_elan_read_pcimem);
1509 static 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
1553 int 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
1565 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_setup);
1566 static 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
1618 int 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
1630 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_input);
1631 static 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
1675 int 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
1687 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_empty);
1688 static 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
1754 int 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
1766 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_output);
1767 static 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
1819 int 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
1831 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_single);
1832 static 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
1878 int 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
1886 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_flush);
1887 static 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 */
1969 static 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 */
2012 static 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
2052 static 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
2183 static 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
2259 static 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)
2311 static 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
2514 static 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
2573 static 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
2627 static 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
2641 static 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
2692 static 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 */
2766 static 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
2863 static 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
2898 static 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 };
2904 static 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
2921 static 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
2943 module_init(ftdi_elan_init);
2944 module_exit(ftdi_elan_exit);