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