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