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