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