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