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