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