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