?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6/kmemtrace.git] / drivers / usb / host / u132-hcd.c
bloba9d7119e3176921958aeafcf977aa4cb5bd17573
1 /*
2 * Host Controller Driver for the Elan Digital Systems U132 adapter
3 *
4 * Copyright(C) 2006 Elan Digital Systems Limited
5 * http://www.elandigitalsystems.com
6 *
7 * Author and Maintainer - Tony Olech - Elan Digital Systems
8 * tony.olech@elandigitalsystems.com
9 *
10 * This program is free software;you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation, version 2.
13 *
14 *
15 * This driver was written by Tony Olech(tony.olech@elandigitalsystems.com)
16 * based on various USB host drivers in the 2.6.15 linux kernel
17 * with constant reference to the 3rd Edition of Linux Device Drivers
18 * published by O'Reilly
19 *
20 * The U132 adapter is a USB to CardBus adapter specifically designed
21 * for PC cards that contain an OHCI host controller. Typical PC cards
22 * are the Orange Mobile 3G Option GlobeTrotter Fusion card.
23 *
24 * The U132 adapter will *NOT *work with PC cards that do not contain
25 * an OHCI controller. A simple way to test whether a PC card has an
26 * OHCI controller as an interface is to insert the PC card directly
27 * into a laptop(or desktop) with a CardBus slot and if "lspci" shows
28 * a new USB controller and "lsusb -v" shows a new OHCI Host Controller
29 * then there is a good chance that the U132 adapter will support the
30 * PC card.(you also need the specific client driver for the PC card)
31 *
32 * Please inform the Author and Maintainer about any PC cards that
33 * contain OHCI Host Controller and work when directly connected to
34 * an embedded CardBus slot but do not work when they are connected
35 * via an ELAN U132 adapter.
36 *
37 */
38 #include <linux/kernel.h>
39 #include <linux/module.h>
40 #include <linux/moduleparam.h>
41 #include <linux/delay.h>
42 #include <linux/ioport.h>
43 #include <linux/sched.h>
44 #include <linux/slab.h>
45 #include <linux/smp_lock.h>
46 #include <linux/errno.h>
47 #include <linux/init.h>
48 #include <linux/timer.h>
49 #include <linux/list.h>
50 #include <linux/interrupt.h>
51 #include <linux/usb.h>
52 #include <linux/workqueue.h>
53 #include <linux/platform_device.h>
54 #include <linux/pci_ids.h>
55 #include <asm/io.h>
56 #include <asm/irq.h>
57 #include <asm/system.h>
58 #include <asm/byteorder.h>
59 #include "../core/hcd.h"
60 #include "ohci.h"
61 #define OHCI_CONTROL_INIT OHCI_CTRL_CBSR
62 #define OHCI_INTR_INIT (OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_RD | \
63 OHCI_INTR_WDH)
64 MODULE_AUTHOR("Tony Olech - Elan Digital Systems Limited");
65 MODULE_DESCRIPTION("U132 USB Host Controller Driver");
66 MODULE_LICENSE("GPL");
67 #define INT_MODULE_PARM(n, v) static int n = v;module_param(n, int, 0444)
68 INT_MODULE_PARM(testing, 0);
69 /* Some boards misreport power switching/overcurrent*/
70 static int distrust_firmware = 1;
71 module_param(distrust_firmware, bool, 0);
72 MODULE_PARM_DESC(distrust_firmware, "true to distrust firmware power/overcurren"
73 "t setup");
74 static DECLARE_WAIT_QUEUE_HEAD(u132_hcd_wait);
75 /*
76 * u132_module_lock exists to protect access to global variables
77 *
78 */
79 static struct semaphore u132_module_lock;
80 static int u132_exiting = 0;
81 static int u132_instances = 0;
82 static struct list_head u132_static_list;
83 /*
84 * end of the global variables protected by u132_module_lock
85 */
86 static struct workqueue_struct *workqueue;
87 #define MAX_U132_PORTS 7
88 #define MAX_U132_ADDRS 128
89 #define MAX_U132_UDEVS 4
90 #define MAX_U132_ENDPS 100
91 #define MAX_U132_RINGS 4
92 static const char *cc_to_text[16] = {
93 "No Error ",
94 "CRC Error ",
95 "Bit Stuff ",
96 "Data Togg ",
97 "Stall ",
98 "DevNotResp ",
99 "PIDCheck ",
100 "UnExpPID ",
101 "DataOver ",
102 "DataUnder ",
103 "(for hw) ",
104 "(for hw) ",
105 "BufferOver ",
106 "BuffUnder ",
107 "(for HCD) ",
108 "(for HCD) "
109 };
110 struct u132_port {
111 struct u132 *u132;
112 int reset;
113 int enable;
114 int power;
115 int Status;
116 };
117 struct u132_addr {
118 u8 address;
119 };
120 struct u132_udev {
121 struct kref kref;
122 struct usb_device *usb_device;
123 u8 enumeration;
124 u8 udev_number;
125 u8 usb_addr;
126 u8 portnumber;
127 u8 endp_number_in[16];
128 u8 endp_number_out[16];
129 };
130 #define ENDP_QUEUE_SHIFT 3
131 #define ENDP_QUEUE_SIZE (1<<ENDP_QUEUE_SHIFT)
132 #define ENDP_QUEUE_MASK (ENDP_QUEUE_SIZE-1)
133 struct u132_urbq {
134 struct list_head urb_more;
135 struct urb *urb;
136 };
137 struct u132_spin {
138 spinlock_t slock;
139 };
140 struct u132_endp {
141 struct kref kref;
142 u8 udev_number;
143 u8 endp_number;
144 u8 usb_addr;
145 u8 usb_endp;
146 struct u132 *u132;
147 struct list_head endp_ring;
148 struct u132_ring *ring;
149 unsigned toggle_bits:2;
150 unsigned active:1;
151 unsigned delayed:1;
152 unsigned input:1;
153 unsigned output:1;
154 unsigned pipetype:2;
155 unsigned dequeueing:1;
156 unsigned edset_flush:1;
157 unsigned spare_bits:14;
158 unsigned long jiffies;
159 struct usb_host_endpoint *hep;
160 struct u132_spin queue_lock;
161 u16 queue_size;
162 u16 queue_last;
163 u16 queue_next;
164 struct urb *urb_list[ENDP_QUEUE_SIZE];
165 struct list_head urb_more;
166 struct delayed_work scheduler;
167 };
168 struct u132_ring {
169 unsigned in_use:1;
170 unsigned length:7;
171 u8 number;
172 struct u132 *u132;
173 struct u132_endp *curr_endp;
174 struct delayed_work scheduler;
175 };
176 #define OHCI_QUIRK_AMD756 0x01
177 #define OHCI_QUIRK_SUPERIO 0x02
178 #define OHCI_QUIRK_INITRESET 0x04
179 #define OHCI_BIG_ENDIAN 0x08
180 #define OHCI_QUIRK_ZFMICRO 0x10
181 struct u132 {
182 struct kref kref;
183 struct list_head u132_list;
184 struct semaphore sw_lock;
185 struct semaphore scheduler_lock;
186 struct u132_platform_data *board;
187 struct platform_device *platform_dev;
188 struct u132_ring ring[MAX_U132_RINGS];
189 int sequence_num;
190 int going;
191 int power;
192 int reset;
193 int num_ports;
194 u32 hc_control;
195 u32 hc_fminterval;
196 u32 hc_roothub_status;
197 u32 hc_roothub_a;
198 u32 hc_roothub_portstatus[MAX_ROOT_PORTS];
199 int flags;
200 unsigned long next_statechange;
201 struct delayed_work monitor;
202 int num_endpoints;
203 struct u132_addr addr[MAX_U132_ADDRS];
204 struct u132_udev udev[MAX_U132_UDEVS];
205 struct u132_port port[MAX_U132_PORTS];
206 struct u132_endp *endp[MAX_U132_ENDPS];
207 };
208
209 /*
210 * these cannot be inlines because we need the structure offset!!
211 * Does anyone have a better way?????
212 */
213 #define u132_read_pcimem(u132, member, data) \
214 usb_ftdi_elan_read_pcimem(u132->platform_dev, offsetof(struct \
215 ohci_regs, member), 0, data);
216 #define u132_write_pcimem(u132, member, data) \
217 usb_ftdi_elan_write_pcimem(u132->platform_dev, offsetof(struct \
218 ohci_regs, member), 0, data);
219 #define u132_write_pcimem_byte(u132, member, data) \
220 usb_ftdi_elan_write_pcimem(u132->platform_dev, offsetof(struct \
221 ohci_regs, member), 0x0e, data);
222 static inline struct u132 *udev_to_u132(struct u132_udev *udev)
223 {
224 u8 udev_number = udev->udev_number;
225 return container_of(udev, struct u132, udev[udev_number]);
226 }
227
228 static inline struct u132 *hcd_to_u132(struct usb_hcd *hcd)
229 {
230 return (struct u132 *)(hcd->hcd_priv);
231 }
232
233 static inline struct usb_hcd *u132_to_hcd(struct u132 *u132)
234 {
235 return container_of((void *)u132, struct usb_hcd, hcd_priv);
236 }
237
238 static inline void u132_disable(struct u132 *u132)
239 {
240 u132_to_hcd(u132)->state = HC_STATE_HALT;
241 }
242
243
244 #define kref_to_u132(d) container_of(d, struct u132, kref)
245 #define kref_to_u132_endp(d) container_of(d, struct u132_endp, kref)
246 #define kref_to_u132_udev(d) container_of(d, struct u132_udev, kref)
247 #include "../misc/usb_u132.h"
248 static const char hcd_name[] = "u132_hcd";
249 #define PORT_C_MASK ((USB_PORT_STAT_C_CONNECTION | USB_PORT_STAT_C_ENABLE | \
250 USB_PORT_STAT_C_SUSPEND | USB_PORT_STAT_C_OVERCURRENT | \
251 USB_PORT_STAT_C_RESET) << 16)
252 static void u132_hcd_delete(struct kref *kref)
253 {
254 struct u132 *u132 = kref_to_u132(kref);
255 struct platform_device *pdev = u132->platform_dev;
256 struct usb_hcd *hcd = u132_to_hcd(u132);
257 u132->going += 1;
258 down(&u132_module_lock);
259 list_del_init(&u132->u132_list);
260 u132_instances -= 1;
261 up(&u132_module_lock);
262 dev_warn(&u132->platform_dev->dev, "FREEING the hcd=%p and thus the u13"
263 "2=%p going=%d pdev=%p\n", hcd, u132, u132->going, pdev);
264 usb_put_hcd(hcd);
265 }
266
267 static inline void u132_u132_put_kref(struct u132 *u132)
268 {
269 kref_put(&u132->kref, u132_hcd_delete);
270 }
271
272 static inline void u132_u132_init_kref(struct u132 *u132)
273 {
274 kref_init(&u132->kref);
275 }
276
277 static void u132_udev_delete(struct kref *kref)
278 {
279 struct u132_udev *udev = kref_to_u132_udev(kref);
280 udev->udev_number = 0;
281 udev->usb_device = NULL;
282 udev->usb_addr = 0;
283 udev->enumeration = 0;
284 }
285
286 static inline void u132_udev_put_kref(struct u132 *u132, struct u132_udev *udev)
287 {
288 kref_put(&udev->kref, u132_udev_delete);
289 }
290
291 static inline void u132_udev_get_kref(struct u132 *u132, struct u132_udev *udev)
292 {
293 kref_get(&udev->kref);
294 }
295
296 static inline void u132_udev_init_kref(struct u132 *u132,
297 struct u132_udev *udev)
298 {
299 kref_init(&udev->kref);
300 }
301
302 static inline void u132_ring_put_kref(struct u132 *u132, struct u132_ring *ring)
303 {
304 kref_put(&u132->kref, u132_hcd_delete);
305 }
306
307 static void u132_ring_requeue_work(struct u132 *u132, struct u132_ring *ring,
308 unsigned int delta)
309 {
310 if (delta > 0) {
311 if (queue_delayed_work(workqueue, &ring->scheduler, delta))
312 return;
313 } else if (queue_delayed_work(workqueue, &ring->scheduler, 0))
314 return;
315 kref_put(&u132->kref, u132_hcd_delete);
316 return;
317 }
318
319 static void u132_ring_queue_work(struct u132 *u132, struct u132_ring *ring,
320 unsigned int delta)
321 {
322 kref_get(&u132->kref);
323 u132_ring_requeue_work(u132, ring, delta);
324 return;
325 }
326
327 static void u132_ring_cancel_work(struct u132 *u132, struct u132_ring *ring)
328 {
329 if (cancel_delayed_work(&ring->scheduler)) {
330 kref_put(&u132->kref, u132_hcd_delete);
331 }
332 }
333
334 static void u132_endp_delete(struct kref *kref)
335 {
336 struct u132_endp *endp = kref_to_u132_endp(kref);
337 struct u132 *u132 = endp->u132;
338 u8 usb_addr = endp->usb_addr;
339 u8 usb_endp = endp->usb_endp;
340 u8 address = u132->addr[usb_addr].address;
341 struct u132_udev *udev = &u132->udev[address];
342 u8 endp_number = endp->endp_number;
343 struct usb_host_endpoint *hep = endp->hep;
344 struct u132_ring *ring = endp->ring;
345 struct list_head *head = &endp->endp_ring;
346 ring->length -= 1;
347 if (endp == ring->curr_endp) {
348 if (list_empty(head)) {
349 ring->curr_endp = NULL;
350 list_del(head);
351 } else {
352 struct u132_endp *next_endp = list_entry(head->next,
353 struct u132_endp, endp_ring);
354 ring->curr_endp = next_endp;
355 list_del(head);
356 }} else
357 list_del(head);
358 if (endp->input) {
359 udev->endp_number_in[usb_endp] = 0;
360 u132_udev_put_kref(u132, udev);
361 }
362 if (endp->output) {
363 udev->endp_number_out[usb_endp] = 0;
364 u132_udev_put_kref(u132, udev);
365 }
366 u132->endp[endp_number - 1] = NULL;
367 hep->hcpriv = NULL;
368 kfree(endp);
369 u132_u132_put_kref(u132);
370 }
371
372 static inline void u132_endp_put_kref(struct u132 *u132, struct u132_endp *endp)
373 {
374 kref_put(&endp->kref, u132_endp_delete);
375 }
376
377 static inline void u132_endp_get_kref(struct u132 *u132, struct u132_endp *endp)
378 {
379 kref_get(&endp->kref);
380 }
381
382 static inline void u132_endp_init_kref(struct u132 *u132,
383 struct u132_endp *endp)
384 {
385 kref_init(&endp->kref);
386 kref_get(&u132->kref);
387 }
388
389 static void u132_endp_queue_work(struct u132 *u132, struct u132_endp *endp,
390 unsigned int delta)
391 {
392 if (queue_delayed_work(workqueue, &endp->scheduler, delta))
393 kref_get(&endp->kref);
394 }
395
396 static void u132_endp_cancel_work(struct u132 *u132, struct u132_endp *endp)
397 {
398 if (cancel_delayed_work(&endp->scheduler))
399 kref_put(&endp->kref, u132_endp_delete);
400 }
401
402 static inline void u132_monitor_put_kref(struct u132 *u132)
403 {
404 kref_put(&u132->kref, u132_hcd_delete);
405 }
406
407 static void u132_monitor_queue_work(struct u132 *u132, unsigned int delta)
408 {
409 if (queue_delayed_work(workqueue, &u132->monitor, delta))
410 kref_get(&u132->kref);
411 }
412
413 static void u132_monitor_requeue_work(struct u132 *u132, unsigned int delta)
414 {
415 if (!queue_delayed_work(workqueue, &u132->monitor, delta))
416 kref_put(&u132->kref, u132_hcd_delete);
417 }
418
419 static void u132_monitor_cancel_work(struct u132 *u132)
420 {
421 if (cancel_delayed_work(&u132->monitor))
422 kref_put(&u132->kref, u132_hcd_delete);
423 }
424
425 static int read_roothub_info(struct u132 *u132)
426 {
427 u32 revision;
428 int retval;
429 retval = u132_read_pcimem(u132, revision, &revision);
430 if (retval) {
431 dev_err(&u132->platform_dev->dev, "error %d accessing device co"
432 "ntrol\n", retval);
433 return retval;
434 } else if ((revision & 0xFF) == 0x10) {
435 } else if ((revision & 0xFF) == 0x11) {
436 } else {
437 dev_err(&u132->platform_dev->dev, "device revision is not valid"
438 " %08X\n", revision);
439 return -ENODEV;
440 }
441 retval = u132_read_pcimem(u132, control, &u132->hc_control);
442 if (retval) {
443 dev_err(&u132->platform_dev->dev, "error %d accessing device co"
444 "ntrol\n", retval);
445 return retval;
446 }
447 retval = u132_read_pcimem(u132, roothub.status,
448 &u132->hc_roothub_status);
449 if (retval) {
450 dev_err(&u132->platform_dev->dev, "error %d accessing device re"
451 "g roothub.status\n", retval);
452 return retval;
453 }
454 retval = u132_read_pcimem(u132, roothub.a, &u132->hc_roothub_a);
455 if (retval) {
456 dev_err(&u132->platform_dev->dev, "error %d accessing device re"
457 "g roothub.a\n", retval);
458 return retval;
459 }
460 {
461 int I = u132->num_ports;
462 int i = 0;
463 while (I-- > 0) {
464 retval = u132_read_pcimem(u132, roothub.portstatus[i],
465 &u132->hc_roothub_portstatus[i]);
466 if (retval) {
467 dev_err(&u132->platform_dev->dev, "error %d acc"
468 "essing device roothub.portstatus[%d]\n"
469 , retval, i);
470 return retval;
471 } else
472 i += 1;
473 }
474 }
475 return 0;
476 }
477
478 static void u132_hcd_monitor_work(struct work_struct *work)
479 {
480 struct u132 *u132 = container_of(work, struct u132, monitor.work);
481 if (u132->going > 1) {
482 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
483 , u132->going);
484 u132_monitor_put_kref(u132);
485 return;
486 } else if (u132->going > 0) {
487 dev_err(&u132->platform_dev->dev, "device is being removed\n");
488 u132_monitor_put_kref(u132);
489 return;
490 } else {
491 int retval;
492 down(&u132->sw_lock);
493 retval = read_roothub_info(u132);
494 if (retval) {
495 struct usb_hcd *hcd = u132_to_hcd(u132);
496 u132_disable(u132);
497 u132->going = 1;
498 up(&u132->sw_lock);
499 usb_hc_died(hcd);
500 ftdi_elan_gone_away(u132->platform_dev);
501 u132_monitor_put_kref(u132);
502 return;
503 } else {
504 u132_monitor_requeue_work(u132, 500);
505 up(&u132->sw_lock);
506 return;
507 }
508 }
509 }
510
511 static void u132_hcd_giveback_urb(struct u132 *u132, struct u132_endp *endp,
512 struct urb *urb, int status)
513 {
514 struct u132_ring *ring;
515 unsigned long irqs;
516 struct usb_hcd *hcd = u132_to_hcd(u132);
517 urb->error_count = 0;
518 urb->status = status;
519 urb->hcpriv = NULL;
520 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
521 endp->queue_next += 1;
522 if (ENDP_QUEUE_SIZE > --endp->queue_size) {
523 endp->active = 0;
524 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
525 } else {
526 struct list_head *next = endp->urb_more.next;
527 struct u132_urbq *urbq = list_entry(next, struct u132_urbq,
528 urb_more);
529 list_del(next);
530 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
531 urbq->urb;
532 endp->active = 0;
533 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
534 kfree(urbq);
535 } down(&u132->scheduler_lock);
536 ring = endp->ring;
537 ring->in_use = 0;
538 u132_ring_cancel_work(u132, ring);
539 u132_ring_queue_work(u132, ring, 0);
540 up(&u132->scheduler_lock);
541 u132_endp_put_kref(u132, endp);
542 usb_hcd_giveback_urb(hcd, urb);
543 return;
544 }
545
546 static void u132_hcd_forget_urb(struct u132 *u132, struct u132_endp *endp,
547 struct urb *urb, int status)
548 {
549 u132_endp_put_kref(u132, endp);
550 }
551
552 static void u132_hcd_abandon_urb(struct u132 *u132, struct u132_endp *endp,
553 struct urb *urb, int status)
554 {
555 unsigned long irqs;
556 struct usb_hcd *hcd = u132_to_hcd(u132);
557 urb->error_count = 0;
558 urb->status = status;
559 urb->hcpriv = NULL;
560 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
561 endp->queue_next += 1;
562 if (ENDP_QUEUE_SIZE > --endp->queue_size) {
563 endp->active = 0;
564 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
565 } else {
566 struct list_head *next = endp->urb_more.next;
567 struct u132_urbq *urbq = list_entry(next, struct u132_urbq,
568 urb_more);
569 list_del(next);
570 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
571 urbq->urb;
572 endp->active = 0;
573 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
574 kfree(urbq);
575 } usb_hcd_giveback_urb(hcd, urb);
576 return;
577 }
578
579 static inline int edset_input(struct u132 *u132, struct u132_ring *ring,
580 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
581 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
582 int toggle_bits, int error_count, int condition_code, int repeat_number,
583 int halted, int skipped, int actual, int non_null))
584 {
585 return usb_ftdi_elan_edset_input(u132->platform_dev, ring->number, endp,
586 urb, address, endp->usb_endp, toggle_bits, callback);
587 }
588
589 static inline int edset_setup(struct u132 *u132, struct u132_ring *ring,
590 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
591 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
592 int toggle_bits, int error_count, int condition_code, int repeat_number,
593 int halted, int skipped, int actual, int non_null))
594 {
595 return usb_ftdi_elan_edset_setup(u132->platform_dev, ring->number, endp,
596 urb, address, endp->usb_endp, toggle_bits, callback);
597 }
598
599 static inline int edset_single(struct u132 *u132, struct u132_ring *ring,
600 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
601 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
602 int toggle_bits, int error_count, int condition_code, int repeat_number,
603 int halted, int skipped, int actual, int non_null))
604 {
605 return usb_ftdi_elan_edset_single(u132->platform_dev, ring->number,
606 endp, urb, address, endp->usb_endp, toggle_bits, callback);
607 }
608
609 static inline int edset_output(struct u132 *u132, struct u132_ring *ring,
610 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
611 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
612 int toggle_bits, int error_count, int condition_code, int repeat_number,
613 int halted, int skipped, int actual, int non_null))
614 {
615 return usb_ftdi_elan_edset_output(u132->platform_dev, ring->number,
616 endp, urb, address, endp->usb_endp, toggle_bits, callback);
617 }
618
619
620 /*
621 * must not LOCK sw_lock
622 *
623 */
624 static void u132_hcd_interrupt_recv(void *data, struct urb *urb, u8 *buf,
625 int len, int toggle_bits, int error_count, int condition_code,
626 int repeat_number, int halted, int skipped, int actual, int non_null)
627 {
628 struct u132_endp *endp = data;
629 struct u132 *u132 = endp->u132;
630 u8 address = u132->addr[endp->usb_addr].address;
631 struct u132_udev *udev = &u132->udev[address];
632 down(&u132->scheduler_lock);
633 if (u132->going > 1) {
634 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
635 , u132->going);
636 up(&u132->scheduler_lock);
637 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
638 return;
639 } else if (endp->dequeueing) {
640 endp->dequeueing = 0;
641 up(&u132->scheduler_lock);
642 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
643 return;
644 } else if (u132->going > 0) {
645 dev_err(&u132->platform_dev->dev, "device is being removed urb="
646 "%p status=%d\n", urb, urb->status);
647 up(&u132->scheduler_lock);
648 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
649 return;
650 } else if (urb->status == -EINPROGRESS) {
651 struct u132_ring *ring = endp->ring;
652 u8 *u = urb->transfer_buffer + urb->actual_length;
653 u8 *b = buf;
654 int L = len;
655 while (L-- > 0) {
656 *u++ = *b++;
657 }
658 urb->actual_length += len;
659 if ((condition_code == TD_CC_NOERROR) &&
660 (urb->transfer_buffer_length > urb->actual_length)) {
661 endp->toggle_bits = toggle_bits;
662 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
663 1 & toggle_bits);
664 if (urb->actual_length > 0) {
665 int retval;
666 up(&u132->scheduler_lock);
667 retval = edset_single(u132, ring, endp, urb,
668 address, endp->toggle_bits,
669 u132_hcd_interrupt_recv);
670 if (retval == 0) {
671 } else
672 u132_hcd_giveback_urb(u132, endp, urb,
673 retval);
674 } else {
675 ring->in_use = 0;
676 endp->active = 0;
677 endp->jiffies = jiffies +
678 msecs_to_jiffies(urb->interval);
679 u132_ring_cancel_work(u132, ring);
680 u132_ring_queue_work(u132, ring, 0);
681 up(&u132->scheduler_lock);
682 u132_endp_put_kref(u132, endp);
683 }
684 return;
685 } else if ((condition_code == TD_DATAUNDERRUN) &&
686 ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0)) {
687 endp->toggle_bits = toggle_bits;
688 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
689 1 & toggle_bits);
690 up(&u132->scheduler_lock);
691 u132_hcd_giveback_urb(u132, endp, urb, 0);
692 return;
693 } else {
694 if (condition_code == TD_CC_NOERROR) {
695 endp->toggle_bits = toggle_bits;
696 usb_settoggle(udev->usb_device, endp->usb_endp,
697 0, 1 & toggle_bits);
698 } else if (condition_code == TD_CC_STALL) {
699 endp->toggle_bits = 0x2;
700 usb_settoggle(udev->usb_device, endp->usb_endp,
701 0, 0);
702 } else {
703 endp->toggle_bits = 0x2;
704 usb_settoggle(udev->usb_device, endp->usb_endp,
705 0, 0);
706 dev_err(&u132->platform_dev->dev, "urb=%p givin"
707 "g back INTERRUPT %s\n", urb,
708 cc_to_text[condition_code]);
709 }
710 up(&u132->scheduler_lock);
711 u132_hcd_giveback_urb(u132, endp, urb,
712 cc_to_error[condition_code]);
713 return;
714 }
715 } else {
716 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
717 "s=%d\n", urb, urb->status);
718 up(&u132->scheduler_lock);
719 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
720 return;
721 }
722 }
723
724 static void u132_hcd_bulk_output_sent(void *data, struct urb *urb, u8 *buf,
725 int len, int toggle_bits, int error_count, int condition_code,
726 int repeat_number, int halted, int skipped, int actual, int non_null)
727 {
728 struct u132_endp *endp = data;
729 struct u132 *u132 = endp->u132;
730 u8 address = u132->addr[endp->usb_addr].address;
731 down(&u132->scheduler_lock);
732 if (u132->going > 1) {
733 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
734 , u132->going);
735 up(&u132->scheduler_lock);
736 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
737 return;
738 } else if (endp->dequeueing) {
739 endp->dequeueing = 0;
740 up(&u132->scheduler_lock);
741 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
742 return;
743 } else if (u132->going > 0) {
744 dev_err(&u132->platform_dev->dev, "device is being removed urb="
745 "%p status=%d\n", urb, urb->status);
746 up(&u132->scheduler_lock);
747 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
748 return;
749 } else if (urb->status == -EINPROGRESS) {
750 struct u132_ring *ring = endp->ring;
751 urb->actual_length += len;
752 endp->toggle_bits = toggle_bits;
753 if (urb->transfer_buffer_length > urb->actual_length) {
754 int retval;
755 up(&u132->scheduler_lock);
756 retval = edset_output(u132, ring, endp, urb, address,
757 endp->toggle_bits, u132_hcd_bulk_output_sent);
758 if (retval == 0) {
759 } else
760 u132_hcd_giveback_urb(u132, endp, urb, retval);
761 return;
762 } else {
763 up(&u132->scheduler_lock);
764 u132_hcd_giveback_urb(u132, endp, urb, 0);
765 return;
766 }
767 } else {
768 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
769 "s=%d\n", urb, urb->status);
770 up(&u132->scheduler_lock);
771 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
772 return;
773 }
774 }
775
776 static void u132_hcd_bulk_input_recv(void *data, struct urb *urb, u8 *buf,
777 int len, int toggle_bits, int error_count, int condition_code,
778 int repeat_number, int halted, int skipped, int actual, int non_null)
779 {
780 struct u132_endp *endp = data;
781 struct u132 *u132 = endp->u132;
782 u8 address = u132->addr[endp->usb_addr].address;
783 struct u132_udev *udev = &u132->udev[address];
784 down(&u132->scheduler_lock);
785 if (u132->going > 1) {
786 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
787 , u132->going);
788 up(&u132->scheduler_lock);
789 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
790 return;
791 } else if (endp->dequeueing) {
792 endp->dequeueing = 0;
793 up(&u132->scheduler_lock);
794 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
795 return;
796 } else if (u132->going > 0) {
797 dev_err(&u132->platform_dev->dev, "device is being removed urb="
798 "%p status=%d\n", urb, urb->status);
799 up(&u132->scheduler_lock);
800 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
801 return;
802 } else if (urb->status == -EINPROGRESS) {
803 struct u132_ring *ring = endp->ring;
804 u8 *u = urb->transfer_buffer + urb->actual_length;
805 u8 *b = buf;
806 int L = len;
807 while (L-- > 0) {
808 *u++ = *b++;
809 }
810 urb->actual_length += len;
811 if ((condition_code == TD_CC_NOERROR) &&
812 (urb->transfer_buffer_length > urb->actual_length)) {
813 int retval;
814 endp->toggle_bits = toggle_bits;
815 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
816 1 & toggle_bits);
817 up(&u132->scheduler_lock);
818 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
819 ring->number, endp, urb, address,
820 endp->usb_endp, endp->toggle_bits,
821 u132_hcd_bulk_input_recv);
822 if (retval == 0) {
823 } else
824 u132_hcd_giveback_urb(u132, endp, urb, retval);
825 return;
826 } else if (condition_code == TD_CC_NOERROR) {
827 endp->toggle_bits = toggle_bits;
828 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
829 1 & toggle_bits);
830 up(&u132->scheduler_lock);
831 u132_hcd_giveback_urb(u132, endp, urb,
832 cc_to_error[condition_code]);
833 return;
834 } else if ((condition_code == TD_DATAUNDERRUN) &&
835 ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0)) {
836 endp->toggle_bits = toggle_bits;
837 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
838 1 & toggle_bits);
839 up(&u132->scheduler_lock);
840 u132_hcd_giveback_urb(u132, endp, urb, 0);
841 return;
842 } else if (condition_code == TD_DATAUNDERRUN) {
843 endp->toggle_bits = toggle_bits;
844 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
845 1 & toggle_bits);
846 dev_warn(&u132->platform_dev->dev, "urb=%p(SHORT NOT OK"
847 ") giving back BULK IN %s\n", urb,
848 cc_to_text[condition_code]);
849 up(&u132->scheduler_lock);
850 u132_hcd_giveback_urb(u132, endp, urb, 0);
851 return;
852 } else if (condition_code == TD_CC_STALL) {
853 endp->toggle_bits = 0x2;
854 usb_settoggle(udev->usb_device, endp->usb_endp, 0, 0);
855 up(&u132->scheduler_lock);
856 u132_hcd_giveback_urb(u132, endp, urb,
857 cc_to_error[condition_code]);
858 return;
859 } else {
860 endp->toggle_bits = 0x2;
861 usb_settoggle(udev->usb_device, endp->usb_endp, 0, 0);
862 dev_err(&u132->platform_dev->dev, "urb=%p giving back B"
863 "ULK IN code=%d %s\n", urb, condition_code,
864 cc_to_text[condition_code]);
865 up(&u132->scheduler_lock);
866 u132_hcd_giveback_urb(u132, endp, urb,
867 cc_to_error[condition_code]);
868 return;
869 }
870 } else {
871 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
872 "s=%d\n", urb, urb->status);
873 up(&u132->scheduler_lock);
874 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
875 return;
876 }
877 }
878
879 static void u132_hcd_configure_empty_sent(void *data, struct urb *urb, u8 *buf,
880 int len, int toggle_bits, int error_count, int condition_code,
881 int repeat_number, int halted, int skipped, int actual, int non_null)
882 {
883 struct u132_endp *endp = data;
884 struct u132 *u132 = endp->u132;
885 down(&u132->scheduler_lock);
886 if (u132->going > 1) {
887 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
888 , u132->going);
889 up(&u132->scheduler_lock);
890 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
891 return;
892 } else if (endp->dequeueing) {
893 endp->dequeueing = 0;
894 up(&u132->scheduler_lock);
895 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
896 return;
897 } else if (u132->going > 0) {
898 dev_err(&u132->platform_dev->dev, "device is being removed urb="
899 "%p status=%d\n", urb, urb->status);
900 up(&u132->scheduler_lock);
901 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
902 return;
903 } else if (urb->status == -EINPROGRESS) {
904 up(&u132->scheduler_lock);
905 u132_hcd_giveback_urb(u132, endp, urb, 0);
906 return;
907 } else {
908 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
909 "s=%d\n", urb, urb->status);
910 up(&u132->scheduler_lock);
911 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
912 return;
913 }
914 }
915
916 static void u132_hcd_configure_input_recv(void *data, struct urb *urb, u8 *buf,
917 int len, int toggle_bits, int error_count, int condition_code,
918 int repeat_number, int halted, int skipped, int actual, int non_null)
919 {
920 struct u132_endp *endp = data;
921 struct u132 *u132 = endp->u132;
922 u8 address = u132->addr[endp->usb_addr].address;
923 down(&u132->scheduler_lock);
924 if (u132->going > 1) {
925 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
926 , u132->going);
927 up(&u132->scheduler_lock);
928 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
929 return;
930 } else if (endp->dequeueing) {
931 endp->dequeueing = 0;
932 up(&u132->scheduler_lock);
933 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
934 return;
935 } else if (u132->going > 0) {
936 dev_err(&u132->platform_dev->dev, "device is being removed urb="
937 "%p status=%d\n", urb, urb->status);
938 up(&u132->scheduler_lock);
939 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
940 return;
941 } else if (urb->status == -EINPROGRESS) {
942 struct u132_ring *ring = endp->ring;
943 u8 *u = urb->transfer_buffer;
944 u8 *b = buf;
945 int L = len;
946 while (L-- > 0) {
947 *u++ = *b++;
948 }
949 urb->actual_length = len;
950 if ((condition_code == TD_CC_NOERROR) || ((condition_code ==
951 TD_DATAUNDERRUN) && ((urb->transfer_flags &
952 URB_SHORT_NOT_OK) == 0))) {
953 int retval;
954 up(&u132->scheduler_lock);
955 retval = usb_ftdi_elan_edset_empty(u132->platform_dev,
956 ring->number, endp, urb, address,
957 endp->usb_endp, 0x3,
958 u132_hcd_configure_empty_sent);
959 if (retval == 0) {
960 } else
961 u132_hcd_giveback_urb(u132, endp, urb, retval);
962 return;
963 } else if (condition_code == TD_CC_STALL) {
964 up(&u132->scheduler_lock);
965 dev_warn(&u132->platform_dev->dev, "giving back SETUP I"
966 "NPUT STALL urb %p\n", urb);
967 u132_hcd_giveback_urb(u132, endp, urb,
968 cc_to_error[condition_code]);
969 return;
970 } else {
971 up(&u132->scheduler_lock);
972 dev_err(&u132->platform_dev->dev, "giving back SETUP IN"
973 "PUT %s urb %p\n", cc_to_text[condition_code],
974 urb);
975 u132_hcd_giveback_urb(u132, endp, urb,
976 cc_to_error[condition_code]);
977 return;
978 }
979 } else {
980 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
981 "s=%d\n", urb, urb->status);
982 up(&u132->scheduler_lock);
983 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
984 return;
985 }
986 }
987
988 static void u132_hcd_configure_empty_recv(void *data, struct urb *urb, u8 *buf,
989 int len, int toggle_bits, int error_count, int condition_code,
990 int repeat_number, int halted, int skipped, int actual, int non_null)
991 {
992 struct u132_endp *endp = data;
993 struct u132 *u132 = endp->u132;
994 down(&u132->scheduler_lock);
995 if (u132->going > 1) {
996 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
997 , u132->going);
998 up(&u132->scheduler_lock);
999 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1000 return;
1001 } else if (endp->dequeueing) {
1002 endp->dequeueing = 0;
1003 up(&u132->scheduler_lock);
1004 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1005 return;
1006 } else if (u132->going > 0) {
1007 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1008 "%p status=%d\n", urb, urb->status);
1009 up(&u132->scheduler_lock);
1010 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1011 return;
1012 } else if (urb->status == -EINPROGRESS) {
1013 up(&u132->scheduler_lock);
1014 u132_hcd_giveback_urb(u132, endp, urb, 0);
1015 return;
1016 } else {
1017 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1018 "s=%d\n", urb, urb->status);
1019 up(&u132->scheduler_lock);
1020 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1021 return;
1022 }
1023 }
1024
1025 static void u132_hcd_configure_setup_sent(void *data, struct urb *urb, u8 *buf,
1026 int len, int toggle_bits, int error_count, int condition_code,
1027 int repeat_number, int halted, int skipped, int actual, int non_null)
1028 {
1029 struct u132_endp *endp = data;
1030 struct u132 *u132 = endp->u132;
1031 u8 address = u132->addr[endp->usb_addr].address;
1032 down(&u132->scheduler_lock);
1033 if (u132->going > 1) {
1034 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1035 , u132->going);
1036 up(&u132->scheduler_lock);
1037 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1038 return;
1039 } else if (endp->dequeueing) {
1040 endp->dequeueing = 0;
1041 up(&u132->scheduler_lock);
1042 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1043 return;
1044 } else if (u132->going > 0) {
1045 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1046 "%p status=%d\n", urb, urb->status);
1047 up(&u132->scheduler_lock);
1048 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1049 return;
1050 } else if (urb->status == -EINPROGRESS) {
1051 if (usb_pipein(urb->pipe)) {
1052 int retval;
1053 struct u132_ring *ring = endp->ring;
1054 up(&u132->scheduler_lock);
1055 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1056 ring->number, endp, urb, address,
1057 endp->usb_endp, 0,
1058 u132_hcd_configure_input_recv);
1059 if (retval == 0) {
1060 } else
1061 u132_hcd_giveback_urb(u132, endp, urb, retval);
1062 return;
1063 } else {
1064 int retval;
1065 struct u132_ring *ring = endp->ring;
1066 up(&u132->scheduler_lock);
1067 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1068 ring->number, endp, urb, address,
1069 endp->usb_endp, 0,
1070 u132_hcd_configure_empty_recv);
1071 if (retval == 0) {
1072 } else
1073 u132_hcd_giveback_urb(u132, endp, urb, retval);
1074 return;
1075 }
1076 } else {
1077 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1078 "s=%d\n", urb, urb->status);
1079 up(&u132->scheduler_lock);
1080 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1081 return;
1082 }
1083 }
1084
1085 static void u132_hcd_enumeration_empty_recv(void *data, struct urb *urb,
1086 u8 *buf, int len, int toggle_bits, int error_count, int condition_code,
1087 int repeat_number, int halted, int skipped, int actual, int non_null)
1088 {
1089 struct u132_endp *endp = data;
1090 struct u132 *u132 = endp->u132;
1091 u8 address = u132->addr[endp->usb_addr].address;
1092 struct u132_udev *udev = &u132->udev[address];
1093 down(&u132->scheduler_lock);
1094 if (u132->going > 1) {
1095 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1096 , u132->going);
1097 up(&u132->scheduler_lock);
1098 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1099 return;
1100 } else if (endp->dequeueing) {
1101 endp->dequeueing = 0;
1102 up(&u132->scheduler_lock);
1103 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1104 return;
1105 } else if (u132->going > 0) {
1106 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1107 "%p status=%d\n", urb, urb->status);
1108 up(&u132->scheduler_lock);
1109 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1110 return;
1111 } else if (urb->status == -EINPROGRESS) {
1112 u132->addr[0].address = 0;
1113 endp->usb_addr = udev->usb_addr;
1114 up(&u132->scheduler_lock);
1115 u132_hcd_giveback_urb(u132, endp, urb, 0);
1116 return;
1117 } else {
1118 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1119 "s=%d\n", urb, urb->status);
1120 up(&u132->scheduler_lock);
1121 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1122 return;
1123 }
1124 }
1125
1126 static void u132_hcd_enumeration_address_sent(void *data, struct urb *urb,
1127 u8 *buf, int len, int toggle_bits, int error_count, int condition_code,
1128 int repeat_number, int halted, int skipped, int actual, int non_null)
1129 {
1130 struct u132_endp *endp = data;
1131 struct u132 *u132 = endp->u132;
1132 down(&u132->scheduler_lock);
1133 if (u132->going > 1) {
1134 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1135 , u132->going);
1136 up(&u132->scheduler_lock);
1137 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1138 return;
1139 } else if (endp->dequeueing) {
1140 endp->dequeueing = 0;
1141 up(&u132->scheduler_lock);
1142 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1143 return;
1144 } else if (u132->going > 0) {
1145 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1146 "%p status=%d\n", urb, urb->status);
1147 up(&u132->scheduler_lock);
1148 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1149 return;
1150 } else if (urb->status == -EINPROGRESS) {
1151 int retval;
1152 struct u132_ring *ring = endp->ring;
1153 up(&u132->scheduler_lock);
1154 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1155 ring->number, endp, urb, 0, endp->usb_endp, 0,
1156 u132_hcd_enumeration_empty_recv);
1157 if (retval == 0) {
1158 } else
1159 u132_hcd_giveback_urb(u132, endp, urb, retval);
1160 return;
1161 } else {
1162 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1163 "s=%d\n", urb, urb->status);
1164 up(&u132->scheduler_lock);
1165 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1166 return;
1167 }
1168 }
1169
1170 static void u132_hcd_initial_empty_sent(void *data, struct urb *urb, u8 *buf,
1171 int len, int toggle_bits, int error_count, int condition_code,
1172 int repeat_number, int halted, int skipped, int actual, int non_null)
1173 {
1174 struct u132_endp *endp = data;
1175 struct u132 *u132 = endp->u132;
1176 down(&u132->scheduler_lock);
1177 if (u132->going > 1) {
1178 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1179 , u132->going);
1180 up(&u132->scheduler_lock);
1181 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1182 return;
1183 } else if (endp->dequeueing) {
1184 endp->dequeueing = 0;
1185 up(&u132->scheduler_lock);
1186 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1187 return;
1188 } else if (u132->going > 0) {
1189 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1190 "%p status=%d\n", urb, urb->status);
1191 up(&u132->scheduler_lock);
1192 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1193 return;
1194 } else if (urb->status == -EINPROGRESS) {
1195 up(&u132->scheduler_lock);
1196 u132_hcd_giveback_urb(u132, endp, urb, 0);
1197 return;
1198 } else {
1199 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1200 "s=%d\n", urb, urb->status);
1201 up(&u132->scheduler_lock);
1202 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1203 return;
1204 }
1205 }
1206
1207 static void u132_hcd_initial_input_recv(void *data, struct urb *urb, u8 *buf,
1208 int len, int toggle_bits, int error_count, int condition_code,
1209 int repeat_number, int halted, int skipped, int actual, int non_null)
1210 {
1211 struct u132_endp *endp = data;
1212 struct u132 *u132 = endp->u132;
1213 u8 address = u132->addr[endp->usb_addr].address;
1214 down(&u132->scheduler_lock);
1215 if (u132->going > 1) {
1216 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1217 , u132->going);
1218 up(&u132->scheduler_lock);
1219 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1220 return;
1221 } else if (endp->dequeueing) {
1222 endp->dequeueing = 0;
1223 up(&u132->scheduler_lock);
1224 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1225 return;
1226 } else if (u132->going > 0) {
1227 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1228 "%p status=%d\n", urb, urb->status);
1229 up(&u132->scheduler_lock);
1230 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1231 return;
1232 } else if (urb->status == -EINPROGRESS) {
1233 int retval;
1234 struct u132_ring *ring = endp->ring;
1235 u8 *u = urb->transfer_buffer;
1236 u8 *b = buf;
1237 int L = len;
1238 while (L-- > 0) {
1239 *u++ = *b++;
1240 }
1241 urb->actual_length = len;
1242 up(&u132->scheduler_lock);
1243 retval = usb_ftdi_elan_edset_empty(u132->platform_dev,
1244 ring->number, endp, urb, address, endp->usb_endp, 0x3,
1245 u132_hcd_initial_empty_sent);
1246 if (retval == 0) {
1247 } else
1248 u132_hcd_giveback_urb(u132, endp, urb, retval);
1249 return;
1250 } else {
1251 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1252 "s=%d\n", urb, urb->status);
1253 up(&u132->scheduler_lock);
1254 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1255 return;
1256 }
1257 }
1258
1259 static void u132_hcd_initial_setup_sent(void *data, struct urb *urb, u8 *buf,
1260 int len, int toggle_bits, int error_count, int condition_code,
1261 int repeat_number, int halted, int skipped, int actual, int non_null)
1262 {
1263 struct u132_endp *endp = data;
1264 struct u132 *u132 = endp->u132;
1265 u8 address = u132->addr[endp->usb_addr].address;
1266 down(&u132->scheduler_lock);
1267 if (u132->going > 1) {
1268 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1269 , u132->going);
1270 up(&u132->scheduler_lock);
1271 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1272 return;
1273 } else if (endp->dequeueing) {
1274 endp->dequeueing = 0;
1275 up(&u132->scheduler_lock);
1276 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1277 return;
1278 } else if (u132->going > 0) {
1279 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1280 "%p status=%d\n", urb, urb->status);
1281 up(&u132->scheduler_lock);
1282 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1283 return;
1284 } else if (urb->status == -EINPROGRESS) {
1285 int retval;
1286 struct u132_ring *ring = endp->ring;
1287 up(&u132->scheduler_lock);
1288 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1289 ring->number, endp, urb, address, endp->usb_endp, 0,
1290 u132_hcd_initial_input_recv);
1291 if (retval == 0) {
1292 } else
1293 u132_hcd_giveback_urb(u132, endp, urb, retval);
1294 return;
1295 } else {
1296 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1297 "s=%d\n", urb, urb->status);
1298 up(&u132->scheduler_lock);
1299 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1300 return;
1301 }
1302 }
1303
1304 /*
1305 * this work function is only executed from the work queue
1306 *
1307 */
1308 static void u132_hcd_ring_work_scheduler(struct work_struct *work)
1309 {
1310 struct u132_ring *ring =
1311 container_of(work, struct u132_ring, scheduler.work);
1312 struct u132 *u132 = ring->u132;
1313 down(&u132->scheduler_lock);
1314 if (ring->in_use) {
1315 up(&u132->scheduler_lock);
1316 u132_ring_put_kref(u132, ring);
1317 return;
1318 } else if (ring->curr_endp) {
1319 struct u132_endp *last_endp = ring->curr_endp;
1320 struct list_head *scan;
1321 struct list_head *head = &last_endp->endp_ring;
1322 unsigned long wakeup = 0;
1323 list_for_each(scan, head) {
1324 struct u132_endp *endp = list_entry(scan,
1325 struct u132_endp, endp_ring);
1326 if (endp->queue_next == endp->queue_last) {
1327 } else if ((endp->delayed == 0)
1328 || time_after_eq(jiffies, endp->jiffies)) {
1329 ring->curr_endp = endp;
1330 u132_endp_cancel_work(u132, last_endp);
1331 u132_endp_queue_work(u132, last_endp, 0);
1332 up(&u132->scheduler_lock);
1333 u132_ring_put_kref(u132, ring);
1334 return;
1335 } else {
1336 unsigned long delta = endp->jiffies - jiffies;
1337 if (delta > wakeup)
1338 wakeup = delta;
1339 }
1340 }
1341 if (last_endp->queue_next == last_endp->queue_last) {
1342 } else if ((last_endp->delayed == 0) || time_after_eq(jiffies,
1343 last_endp->jiffies)) {
1344 u132_endp_cancel_work(u132, last_endp);
1345 u132_endp_queue_work(u132, last_endp, 0);
1346 up(&u132->scheduler_lock);
1347 u132_ring_put_kref(u132, ring);
1348 return;
1349 } else {
1350 unsigned long delta = last_endp->jiffies - jiffies;
1351 if (delta > wakeup)
1352 wakeup = delta;
1353 }
1354 if (wakeup > 0) {
1355 u132_ring_requeue_work(u132, ring, wakeup);
1356 up(&u132->scheduler_lock);
1357 return;
1358 } else {
1359 up(&u132->scheduler_lock);
1360 u132_ring_put_kref(u132, ring);
1361 return;
1362 }
1363 } else {
1364 up(&u132->scheduler_lock);
1365 u132_ring_put_kref(u132, ring);
1366 return;
1367 }
1368 }
1369
1370 static void u132_hcd_endp_work_scheduler(struct work_struct *work)
1371 {
1372 struct u132_ring *ring;
1373 struct u132_endp *endp =
1374 container_of(work, struct u132_endp, scheduler.work);
1375 struct u132 *u132 = endp->u132;
1376 down(&u132->scheduler_lock);
1377 ring = endp->ring;
1378 if (endp->edset_flush) {
1379 endp->edset_flush = 0;
1380 if (endp->dequeueing)
1381 usb_ftdi_elan_edset_flush(u132->platform_dev,
1382 ring->number, endp);
1383 up(&u132->scheduler_lock);
1384 u132_endp_put_kref(u132, endp);
1385 return;
1386 } else if (endp->active) {
1387 up(&u132->scheduler_lock);
1388 u132_endp_put_kref(u132, endp);
1389 return;
1390 } else if (ring->in_use) {
1391 up(&u132->scheduler_lock);
1392 u132_endp_put_kref(u132, endp);
1393 return;
1394 } else if (endp->queue_next == endp->queue_last) {
1395 up(&u132->scheduler_lock);
1396 u132_endp_put_kref(u132, endp);
1397 return;
1398 } else if (endp->pipetype == PIPE_INTERRUPT) {
1399 u8 address = u132->addr[endp->usb_addr].address;
1400 if (ring->in_use) {
1401 up(&u132->scheduler_lock);
1402 u132_endp_put_kref(u132, endp);
1403 return;
1404 } else {
1405 int retval;
1406 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1407 endp->queue_next];
1408 endp->active = 1;
1409 ring->curr_endp = endp;
1410 ring->in_use = 1;
1411 up(&u132->scheduler_lock);
1412 retval = edset_single(u132, ring, endp, urb, address,
1413 endp->toggle_bits, u132_hcd_interrupt_recv);
1414 if (retval == 0) {
1415 } else
1416 u132_hcd_giveback_urb(u132, endp, urb, retval);
1417 return;
1418 }
1419 } else if (endp->pipetype == PIPE_CONTROL) {
1420 u8 address = u132->addr[endp->usb_addr].address;
1421 if (ring->in_use) {
1422 up(&u132->scheduler_lock);
1423 u132_endp_put_kref(u132, endp);
1424 return;
1425 } else if (address == 0) {
1426 int retval;
1427 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1428 endp->queue_next];
1429 endp->active = 1;
1430 ring->curr_endp = endp;
1431 ring->in_use = 1;
1432 up(&u132->scheduler_lock);
1433 retval = edset_setup(u132, ring, endp, urb, address,
1434 0x2, u132_hcd_initial_setup_sent);
1435 if (retval == 0) {
1436 } else
1437 u132_hcd_giveback_urb(u132, endp, urb, retval);
1438 return;
1439 } else if (endp->usb_addr == 0) {
1440 int retval;
1441 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1442 endp->queue_next];
1443 endp->active = 1;
1444 ring->curr_endp = endp;
1445 ring->in_use = 1;
1446 up(&u132->scheduler_lock);
1447 retval = edset_setup(u132, ring, endp, urb, 0, 0x2,
1448 u132_hcd_enumeration_address_sent);
1449 if (retval == 0) {
1450 } else
1451 u132_hcd_giveback_urb(u132, endp, urb, retval);
1452 return;
1453 } else {
1454 int retval;
1455 u8 address = u132->addr[endp->usb_addr].address;
1456 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1457 endp->queue_next];
1458 endp->active = 1;
1459 ring->curr_endp = endp;
1460 ring->in_use = 1;
1461 up(&u132->scheduler_lock);
1462 retval = edset_setup(u132, ring, endp, urb, address,
1463 0x2, u132_hcd_configure_setup_sent);
1464 if (retval == 0) {
1465 } else
1466 u132_hcd_giveback_urb(u132, endp, urb, retval);
1467 return;
1468 }
1469 } else {
1470 if (endp->input) {
1471 u8 address = u132->addr[endp->usb_addr].address;
1472 if (ring->in_use) {
1473 up(&u132->scheduler_lock);
1474 u132_endp_put_kref(u132, endp);
1475 return;
1476 } else {
1477 int retval;
1478 struct urb *urb = endp->urb_list[
1479 ENDP_QUEUE_MASK & endp->queue_next];
1480 endp->active = 1;
1481 ring->curr_endp = endp;
1482 ring->in_use = 1;
1483 up(&u132->scheduler_lock);
1484 retval = edset_input(u132, ring, endp, urb,
1485 address, endp->toggle_bits,
1486 u132_hcd_bulk_input_recv);
1487 if (retval == 0) {
1488 } else
1489 u132_hcd_giveback_urb(u132, endp, urb,
1490 retval);
1491 return;
1492 }
1493 } else { /* output pipe */
1494 u8 address = u132->addr[endp->usb_addr].address;
1495 if (ring->in_use) {
1496 up(&u132->scheduler_lock);
1497 u132_endp_put_kref(u132, endp);
1498 return;
1499 } else {
1500 int retval;
1501 struct urb *urb = endp->urb_list[
1502 ENDP_QUEUE_MASK & endp->queue_next];
1503 endp->active = 1;
1504 ring->curr_endp = endp;
1505 ring->in_use = 1;
1506 up(&u132->scheduler_lock);
1507 retval = edset_output(u132, ring, endp, urb,
1508 address, endp->toggle_bits,
1509 u132_hcd_bulk_output_sent);
1510 if (retval == 0) {
1511 } else
1512 u132_hcd_giveback_urb(u132, endp, urb,
1513 retval);
1514 return;
1515 }
1516 }
1517 }
1518 }
1519
1520 static void port_power(struct u132 *u132, int pn, int is_on)
1521 {
1522 u132->port[pn].power = is_on;
1523 }
1524
1525 static void u132_power(struct u132 *u132, int is_on)
1526 {
1527 struct usb_hcd *hcd = u132_to_hcd(u132)
1528 ; /* hub is inactive unless the port is powered */
1529 if (is_on) {
1530 if (u132->power)
1531 return;
1532 u132->power = 1;
1533 hcd->self.controller->power.power_state = PMSG_ON;
1534 } else {
1535 u132->power = 0;
1536 hcd->state = HC_STATE_HALT;
1537 hcd->self.controller->power.power_state = PMSG_SUSPEND;
1538 }
1539 }
1540
1541 static int u132_periodic_reinit(struct u132 *u132)
1542 {
1543 int retval;
1544 u32 fi = u132->hc_fminterval & 0x03fff;
1545 u32 fit;
1546 u32 fminterval;
1547 retval = u132_read_pcimem(u132, fminterval, &fminterval);
1548 if (retval)
1549 return retval;
1550 fit = fminterval & FIT;
1551 retval = u132_write_pcimem(u132, fminterval,
1552 (fit ^ FIT) | u132->hc_fminterval);
1553 if (retval)
1554 return retval;
1555 retval = u132_write_pcimem(u132, periodicstart,
1556 ((9 *fi) / 10) & 0x3fff);
1557 if (retval)
1558 return retval;
1559 return 0;
1560 }
1561
1562 static char *hcfs2string(int state)
1563 {
1564 switch (state) {
1565 case OHCI_USB_RESET:
1566 return "reset";
1567 case OHCI_USB_RESUME:
1568 return "resume";
1569 case OHCI_USB_OPER:
1570 return "operational";
1571 case OHCI_USB_SUSPEND:
1572 return "suspend";
1573 }
1574 return "?";
1575 }
1576
1577 static int u132_usb_reset(struct u132 *u132)
1578 {
1579 int retval;
1580 retval = u132_read_pcimem(u132, control, &u132->hc_control);
1581 if (retval)
1582 return retval;
1583 u132->hc_control &= OHCI_CTRL_RWC;
1584 retval = u132_write_pcimem(u132, control, u132->hc_control);
1585 if (retval)
1586 return retval;
1587 return 0;
1588 }
1589
1590 static int u132_init(struct u132 *u132)
1591 {
1592 int retval;
1593 u32 control;
1594 u132_disable(u132);
1595 u132->next_statechange =
1596 jiffies; /* SMM owns the HC? not for long! */ {
1597 u32 control;
1598 retval = u132_read_pcimem(u132, control, &control);
1599 if (retval)
1600 return retval;
1601 if (control & OHCI_CTRL_IR) {
1602 u32 temp = 50;
1603 retval = u132_write_pcimem(u132, intrenable,
1604 OHCI_INTR_OC);
1605 if (retval)
1606 return retval;
1607 retval = u132_write_pcimem_byte(u132, cmdstatus,
1608 OHCI_OCR);
1609 if (retval)
1610 return retval;
1611 check:{
1612 retval = u132_read_pcimem(u132, control,
1613 &control);
1614 if (retval)
1615 return retval;
1616 }
1617 if (control & OHCI_CTRL_IR) {
1618 msleep(10);
1619 if (--temp == 0) {
1620 dev_err(&u132->platform_dev->dev, "USB "
1621 "HC takeover failed!(BIOS/SMM b"
1622 "ug) control=%08X\n", control);
1623 return -EBUSY;
1624 }
1625 goto check;
1626 }
1627 u132_usb_reset(u132);
1628 }
1629 }
1630 retval = u132_write_pcimem(u132, intrdisable, OHCI_INTR_MIE);
1631 if (retval)
1632 return retval;
1633 retval = u132_read_pcimem(u132, control, &control);
1634 if (retval)
1635 return retval;
1636 if (u132->num_ports == 0) {
1637 u32 rh_a = -1;
1638 retval = u132_read_pcimem(u132, roothub.a, &rh_a);
1639 if (retval)
1640 return retval;
1641 u132->num_ports = rh_a & RH_A_NDP;
1642 retval = read_roothub_info(u132);
1643 if (retval)
1644 return retval;
1645 }
1646 if (u132->num_ports > MAX_U132_PORTS) {
1647 return -EINVAL;
1648 }
1649 return 0;
1650 }
1651
1652
1653 /* Start an OHCI controller, set the BUS operational
1654 * resets USB and controller
1655 * enable interrupts
1656 */
1657 static int u132_run(struct u132 *u132)
1658 {
1659 int retval;
1660 u32 control;
1661 u32 status;
1662 u32 fminterval;
1663 u32 periodicstart;
1664 u32 cmdstatus;
1665 u32 roothub_a;
1666 int mask = OHCI_INTR_INIT;
1667 int first = u132->hc_fminterval == 0;
1668 int sleep_time = 0;
1669 int reset_timeout = 30; /* ... allow extra time */
1670 u132_disable(u132);
1671 if (first) {
1672 u32 temp;
1673 retval = u132_read_pcimem(u132, fminterval, &temp);
1674 if (retval)
1675 return retval;
1676 u132->hc_fminterval = temp & 0x3fff;
1677 if (u132->hc_fminterval != FI) {
1678 }
1679 u132->hc_fminterval |= FSMP(u132->hc_fminterval) << 16;
1680 }
1681 retval = u132_read_pcimem(u132, control, &u132->hc_control);
1682 if (retval)
1683 return retval;
1684 dev_info(&u132->platform_dev->dev, "resetting from state '%s', control "
1685 "= %08X\n", hcfs2string(u132->hc_control & OHCI_CTRL_HCFS),
1686 u132->hc_control);
1687 switch (u132->hc_control & OHCI_CTRL_HCFS) {
1688 case OHCI_USB_OPER:
1689 sleep_time = 0;
1690 break;
1691 case OHCI_USB_SUSPEND:
1692 case OHCI_USB_RESUME:
1693 u132->hc_control &= OHCI_CTRL_RWC;
1694 u132->hc_control |= OHCI_USB_RESUME;
1695 sleep_time = 10;
1696 break;
1697 default:
1698 u132->hc_control &= OHCI_CTRL_RWC;
1699 u132->hc_control |= OHCI_USB_RESET;
1700 sleep_time = 50;
1701 break;
1702 }
1703 retval = u132_write_pcimem(u132, control, u132->hc_control);
1704 if (retval)
1705 return retval;
1706 retval = u132_read_pcimem(u132, control, &control);
1707 if (retval)
1708 return retval;
1709 msleep(sleep_time);
1710 retval = u132_read_pcimem(u132, roothub.a, &roothub_a);
1711 if (retval)
1712 return retval;
1713 if (!(roothub_a & RH_A_NPS)) {
1714 int temp; /* power down each port */
1715 for (temp = 0; temp < u132->num_ports; temp++) {
1716 retval = u132_write_pcimem(u132,
1717 roothub.portstatus[temp], RH_PS_LSDA);
1718 if (retval)
1719 return retval;
1720 }
1721 }
1722 retval = u132_read_pcimem(u132, control, &control);
1723 if (retval)
1724 return retval;
1725 retry:retval = u132_read_pcimem(u132, cmdstatus, &status);
1726 if (retval)
1727 return retval;
1728 retval = u132_write_pcimem_byte(u132, cmdstatus, OHCI_HCR);
1729 if (retval)
1730 return retval;
1731 extra:{
1732 retval = u132_read_pcimem(u132, cmdstatus, &status);
1733 if (retval)
1734 return retval;
1735 if (0 != (status & OHCI_HCR)) {
1736 if (--reset_timeout == 0) {
1737 dev_err(&u132->platform_dev->dev, "USB HC reset"
1738 " timed out!\n");
1739 return -ENODEV;
1740 } else {
1741 msleep(5);
1742 goto extra;
1743 }
1744 }
1745 }
1746 if (u132->flags & OHCI_QUIRK_INITRESET) {
1747 retval = u132_write_pcimem(u132, control, u132->hc_control);
1748 if (retval)
1749 return retval;
1750 retval = u132_read_pcimem(u132, control, &control);
1751 if (retval)
1752 return retval;
1753 }
1754 retval = u132_write_pcimem(u132, ed_controlhead, 0x00000000);
1755 if (retval)
1756 return retval;
1757 retval = u132_write_pcimem(u132, ed_bulkhead, 0x11000000);
1758 if (retval)
1759 return retval;
1760 retval = u132_write_pcimem(u132, hcca, 0x00000000);
1761 if (retval)
1762 return retval;
1763 retval = u132_periodic_reinit(u132);
1764 if (retval)
1765 return retval;
1766 retval = u132_read_pcimem(u132, fminterval, &fminterval);
1767 if (retval)
1768 return retval;
1769 retval = u132_read_pcimem(u132, periodicstart, &periodicstart);
1770 if (retval)
1771 return retval;
1772 if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) {
1773 if (!(u132->flags & OHCI_QUIRK_INITRESET)) {
1774 u132->flags |= OHCI_QUIRK_INITRESET;
1775 goto retry;
1776 } else
1777 dev_err(&u132->platform_dev->dev, "init err(%08x %04x)"
1778 "\n", fminterval, periodicstart);
1779 } /* start controller operations */
1780 u132->hc_control &= OHCI_CTRL_RWC;
1781 u132->hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER;
1782 retval = u132_write_pcimem(u132, control, u132->hc_control);
1783 if (retval)
1784 return retval;
1785 retval = u132_write_pcimem_byte(u132, cmdstatus, OHCI_BLF);
1786 if (retval)
1787 return retval;
1788 retval = u132_read_pcimem(u132, cmdstatus, &cmdstatus);
1789 if (retval)
1790 return retval;
1791 retval = u132_read_pcimem(u132, control, &control);
1792 if (retval)
1793 return retval;
1794 u132_to_hcd(u132)->state = HC_STATE_RUNNING;
1795 retval = u132_write_pcimem(u132, roothub.status, RH_HS_DRWE);
1796 if (retval)
1797 return retval;
1798 retval = u132_write_pcimem(u132, intrstatus, mask);
1799 if (retval)
1800 return retval;
1801 retval = u132_write_pcimem(u132, intrdisable,
1802 OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO |
1803 OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH |
1804 OHCI_INTR_SO);
1805 if (retval)
1806 return retval; /* handle root hub init quirks ... */
1807 retval = u132_read_pcimem(u132, roothub.a, &roothub_a);
1808 if (retval)
1809 return retval;
1810 roothub_a &= ~(RH_A_PSM | RH_A_OCPM);
1811 if (u132->flags & OHCI_QUIRK_SUPERIO) {
1812 roothub_a |= RH_A_NOCP;
1813 roothub_a &= ~(RH_A_POTPGT | RH_A_NPS);
1814 retval = u132_write_pcimem(u132, roothub.a, roothub_a);
1815 if (retval)
1816 return retval;
1817 } else if ((u132->flags & OHCI_QUIRK_AMD756) || distrust_firmware) {
1818 roothub_a |= RH_A_NPS;
1819 retval = u132_write_pcimem(u132, roothub.a, roothub_a);
1820 if (retval)
1821 return retval;
1822 }
1823 retval = u132_write_pcimem(u132, roothub.status, RH_HS_LPSC);
1824 if (retval)
1825 return retval;
1826 retval = u132_write_pcimem(u132, roothub.b,
1827 (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM);
1828 if (retval)
1829 return retval;
1830 retval = u132_read_pcimem(u132, control, &control);
1831 if (retval)
1832 return retval;
1833 mdelay((roothub_a >> 23) & 0x1fe);
1834 u132_to_hcd(u132)->state = HC_STATE_RUNNING;
1835 return 0;
1836 }
1837
1838 static void u132_hcd_stop(struct usb_hcd *hcd)
1839 {
1840 struct u132 *u132 = hcd_to_u132(hcd);
1841 if (u132->going > 1) {
1842 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1843 , u132->going);
1844 } else if (u132->going > 0) {
1845 dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
1846 "ed\n", hcd);
1847 } else {
1848 down(&u132->sw_lock);
1849 msleep(100);
1850 u132_power(u132, 0);
1851 up(&u132->sw_lock);
1852 }
1853 }
1854
1855 static int u132_hcd_start(struct usb_hcd *hcd)
1856 {
1857 struct u132 *u132 = hcd_to_u132(hcd);
1858 if (u132->going > 1) {
1859 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1860 , u132->going);
1861 return -ENODEV;
1862 } else if (u132->going > 0) {
1863 dev_err(&u132->platform_dev->dev, "device is being removed\n");
1864 return -ESHUTDOWN;
1865 } else if (hcd->self.controller) {
1866 int retval;
1867 struct platform_device *pdev =
1868 to_platform_device(hcd->self.controller);
1869 u16 vendor = ((struct u132_platform_data *)
1870 (pdev->dev.platform_data))->vendor;
1871 u16 device = ((struct u132_platform_data *)
1872 (pdev->dev.platform_data))->device;
1873 down(&u132->sw_lock);
1874 msleep(10);
1875 if (vendor == PCI_VENDOR_ID_AMD && device == 0x740c) {
1876 u132->flags = OHCI_QUIRK_AMD756;
1877 } else if (vendor == PCI_VENDOR_ID_OPTI && device == 0xc861) {
1878 dev_err(&u132->platform_dev->dev, "WARNING: OPTi workar"
1879 "ounds unavailable\n");
1880 } else if (vendor == PCI_VENDOR_ID_COMPAQ && device == 0xa0f8)
1881 u132->flags |= OHCI_QUIRK_ZFMICRO;
1882 retval = u132_run(u132);
1883 if (retval) {
1884 u132_disable(u132);
1885 u132->going = 1;
1886 }
1887 msleep(100);
1888 up(&u132->sw_lock);
1889 return retval;
1890 } else {
1891 dev_err(&u132->platform_dev->dev, "platform_device missing\n");
1892 return -ENODEV;
1893 }
1894 }
1895
1896 static int u132_hcd_reset(struct usb_hcd *hcd)
1897 {
1898 struct u132 *u132 = hcd_to_u132(hcd);
1899 if (u132->going > 1) {
1900 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1901 , u132->going);
1902 return -ENODEV;
1903 } else if (u132->going > 0) {
1904 dev_err(&u132->platform_dev->dev, "device is being removed\n");
1905 return -ESHUTDOWN;
1906 } else {
1907 int retval;
1908 down(&u132->sw_lock);
1909 retval = u132_init(u132);
1910 if (retval) {
1911 u132_disable(u132);
1912 u132->going = 1;
1913 }
1914 up(&u132->sw_lock);
1915 return retval;
1916 }
1917 }
1918
1919 static int create_endpoint_and_queue_int(struct u132 *u132,
1920 struct u132_udev *udev, struct usb_host_endpoint *hep, struct urb *urb,
1921 struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
1922 gfp_t mem_flags)
1923 {
1924 struct u132_ring *ring;
1925 unsigned long irqs;
1926 u8 endp_number = ++u132->num_endpoints;
1927 struct u132_endp *endp = hep->hcpriv = u132->endp[endp_number - 1] =
1928 kmalloc(sizeof(struct u132_endp), mem_flags);
1929 if (!endp) {
1930 return -ENOMEM;
1931 }
1932 INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
1933 spin_lock_init(&endp->queue_lock.slock);
1934 INIT_LIST_HEAD(&endp->urb_more);
1935 ring = endp->ring = &u132->ring[0];
1936 if (ring->curr_endp) {
1937 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
1938 } else {
1939 INIT_LIST_HEAD(&endp->endp_ring);
1940 ring->curr_endp = endp;
1941 }
1942 ring->length += 1;
1943 endp->dequeueing = 0;
1944 endp->edset_flush = 0;
1945 endp->active = 0;
1946 endp->delayed = 0;
1947 endp->endp_number = endp_number;
1948 endp->u132 = u132;
1949 endp->hep = hep;
1950 endp->pipetype = usb_pipetype(urb->pipe);
1951 u132_endp_init_kref(u132, endp);
1952 if (usb_pipein(urb->pipe)) {
1953 endp->toggle_bits = 0x2;
1954 usb_settoggle(udev->usb_device, usb_endp, 0, 0);
1955 endp->input = 1;
1956 endp->output = 0;
1957 udev->endp_number_in[usb_endp] = endp_number;
1958 u132_udev_get_kref(u132, udev);
1959 } else {
1960 endp->toggle_bits = 0x2;
1961 usb_settoggle(udev->usb_device, usb_endp, 1, 0);
1962 endp->input = 0;
1963 endp->output = 1;
1964 udev->endp_number_out[usb_endp] = endp_number;
1965 u132_udev_get_kref(u132, udev);
1966 }
1967 urb->hcpriv = u132;
1968 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
1969 endp->delayed = 1;
1970 endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
1971 endp->udev_number = address;
1972 endp->usb_addr = usb_addr;
1973 endp->usb_endp = usb_endp;
1974 endp->queue_size = 1;
1975 endp->queue_last = 0;
1976 endp->queue_next = 0;
1977 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
1978 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1979 u132_endp_queue_work(u132, endp, msecs_to_jiffies(urb->interval));
1980 return 0;
1981 }
1982
1983 static int queue_int_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
1984 struct usb_host_endpoint *hep, struct urb *urb,
1985 struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
1986 u8 usb_endp, u8 address)
1987 {
1988 urb->hcpriv = u132;
1989 endp->delayed = 1;
1990 endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
1991 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
1992 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
1993 } else {
1994 struct u132_urbq *urbq = kmalloc(sizeof(struct u132_urbq),
1995 GFP_ATOMIC);
1996 if (urbq == NULL) {
1997 endp->queue_size -= 1;
1998 return -ENOMEM;
1999 } else {
2000 list_add_tail(&urbq->urb_more, &endp->urb_more);
2001 urbq->urb = urb;
2002 }
2003 }
2004 return 0;
2005 }
2006
2007 static int create_endpoint_and_queue_bulk(struct u132 *u132,
2008 struct u132_udev *udev, struct usb_host_endpoint *hep, struct urb *urb,
2009 struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
2010 gfp_t mem_flags)
2011 {
2012 int ring_number;
2013 struct u132_ring *ring;
2014 unsigned long irqs;
2015 u8 endp_number = ++u132->num_endpoints;
2016 struct u132_endp *endp = hep->hcpriv = u132->endp[endp_number - 1] =
2017 kmalloc(sizeof(struct u132_endp), mem_flags);
2018 if (!endp) {
2019 return -ENOMEM;
2020 }
2021 INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
2022 spin_lock_init(&endp->queue_lock.slock);
2023 INIT_LIST_HEAD(&endp->urb_more);
2024 endp->dequeueing = 0;
2025 endp->edset_flush = 0;
2026 endp->active = 0;
2027 endp->delayed = 0;
2028 endp->endp_number = endp_number;
2029 endp->u132 = u132;
2030 endp->hep = hep;
2031 endp->pipetype = usb_pipetype(urb->pipe);
2032 u132_endp_init_kref(u132, endp);
2033 if (usb_pipein(urb->pipe)) {
2034 endp->toggle_bits = 0x2;
2035 usb_settoggle(udev->usb_device, usb_endp, 0, 0);
2036 ring_number = 3;
2037 endp->input = 1;
2038 endp->output = 0;
2039 udev->endp_number_in[usb_endp] = endp_number;
2040 u132_udev_get_kref(u132, udev);
2041 } else {
2042 endp->toggle_bits = 0x2;
2043 usb_settoggle(udev->usb_device, usb_endp, 1, 0);
2044 ring_number = 2;
2045 endp->input = 0;
2046 endp->output = 1;
2047 udev->endp_number_out[usb_endp] = endp_number;
2048 u132_udev_get_kref(u132, udev);
2049 }
2050 ring = endp->ring = &u132->ring[ring_number - 1];
2051 if (ring->curr_endp) {
2052 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
2053 } else {
2054 INIT_LIST_HEAD(&endp->endp_ring);
2055 ring->curr_endp = endp;
2056 }
2057 ring->length += 1;
2058 urb->hcpriv = u132;
2059 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2060 endp->udev_number = address;
2061 endp->usb_addr = usb_addr;
2062 endp->usb_endp = usb_endp;
2063 endp->queue_size = 1;
2064 endp->queue_last = 0;
2065 endp->queue_next = 0;
2066 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2067 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2068 u132_endp_queue_work(u132, endp, 0);
2069 return 0;
2070 }
2071
2072 static int queue_bulk_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
2073 struct usb_host_endpoint *hep, struct urb *urb,
2074 struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2075 u8 usb_endp, u8 address)
2076 {
2077 urb->hcpriv = u132;
2078 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2079 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2080 } else {
2081 struct u132_urbq *urbq = kmalloc(sizeof(struct u132_urbq),
2082 GFP_ATOMIC);
2083 if (urbq == NULL) {
2084 endp->queue_size -= 1;
2085 return -ENOMEM;
2086 } else {
2087 list_add_tail(&urbq->urb_more, &endp->urb_more);
2088 urbq->urb = urb;
2089 }
2090 }
2091 return 0;
2092 }
2093
2094 static int create_endpoint_and_queue_control(struct u132 *u132,
2095 struct usb_host_endpoint *hep, struct urb *urb,
2096 struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp,
2097 gfp_t mem_flags)
2098 {
2099 struct u132_ring *ring;
2100 u8 endp_number = ++u132->num_endpoints;
2101 struct u132_endp *endp = hep->hcpriv = u132->endp[endp_number - 1] =
2102 kmalloc(sizeof(struct u132_endp), mem_flags);
2103 if (!endp) {
2104 return -ENOMEM;
2105 }
2106 INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
2107 spin_lock_init(&endp->queue_lock.slock);
2108 INIT_LIST_HEAD(&endp->urb_more);
2109 ring = endp->ring = &u132->ring[0];
2110 if (ring->curr_endp) {
2111 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
2112 } else {
2113 INIT_LIST_HEAD(&endp->endp_ring);
2114 ring->curr_endp = endp;
2115 }
2116 ring->length += 1;
2117 endp->dequeueing = 0;
2118 endp->edset_flush = 0;
2119 endp->active = 0;
2120 endp->delayed = 0;
2121 endp->endp_number = endp_number;
2122 endp->u132 = u132;
2123 endp->hep = hep;
2124 u132_endp_init_kref(u132, endp);
2125 u132_endp_get_kref(u132, endp);
2126 if (usb_addr == 0) {
2127 unsigned long irqs;
2128 u8 address = u132->addr[usb_addr].address;
2129 struct u132_udev *udev = &u132->udev[address];
2130 endp->udev_number = address;
2131 endp->usb_addr = usb_addr;
2132 endp->usb_endp = usb_endp;
2133 endp->input = 1;
2134 endp->output = 1;
2135 endp->pipetype = usb_pipetype(urb->pipe);
2136 u132_udev_init_kref(u132, udev);
2137 u132_udev_get_kref(u132, udev);
2138 udev->endp_number_in[usb_endp] = endp_number;
2139 udev->endp_number_out[usb_endp] = endp_number;
2140 urb->hcpriv = u132;
2141 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2142 endp->queue_size = 1;
2143 endp->queue_last = 0;
2144 endp->queue_next = 0;
2145 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2146 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2147 u132_endp_queue_work(u132, endp, 0);
2148 return 0;
2149 } else { /*(usb_addr > 0) */
2150 unsigned long irqs;
2151 u8 address = u132->addr[usb_addr].address;
2152 struct u132_udev *udev = &u132->udev[address];
2153 endp->udev_number = address;
2154 endp->usb_addr = usb_addr;
2155 endp->usb_endp = usb_endp;
2156 endp->input = 1;
2157 endp->output = 1;
2158 endp->pipetype = usb_pipetype(urb->pipe);
2159 u132_udev_get_kref(u132, udev);
2160 udev->enumeration = 2;
2161 udev->endp_number_in[usb_endp] = endp_number;
2162 udev->endp_number_out[usb_endp] = endp_number;
2163 urb->hcpriv = u132;
2164 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2165 endp->queue_size = 1;
2166 endp->queue_last = 0;
2167 endp->queue_next = 0;
2168 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2169 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2170 u132_endp_queue_work(u132, endp, 0);
2171 return 0;
2172 }
2173 }
2174
2175 static int queue_control_on_old_endpoint(struct u132 *u132,
2176 struct usb_host_endpoint *hep, struct urb *urb,
2177 struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2178 u8 usb_endp)
2179 {
2180 if (usb_addr == 0) {
2181 if (usb_pipein(urb->pipe)) {
2182 urb->hcpriv = u132;
2183 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2184 endp->urb_list[ENDP_QUEUE_MASK &
2185 endp->queue_last++] = urb;
2186 } else {
2187 struct u132_urbq *urbq =
2188 kmalloc(sizeof(struct u132_urbq),
2189 GFP_ATOMIC);
2190 if (urbq == NULL) {
2191 endp->queue_size -= 1;
2192 return -ENOMEM;
2193 } else {
2194 list_add_tail(&urbq->urb_more,
2195 &endp->urb_more);
2196 urbq->urb = urb;
2197 }
2198 }
2199 return 0;
2200 } else { /* usb_pipeout(urb->pipe) */
2201 struct u132_addr *addr = &u132->addr[usb_dev->devnum];
2202 int I = MAX_U132_UDEVS;
2203 int i = 0;
2204 while (--I > 0) {
2205 struct u132_udev *udev = &u132->udev[++i];
2206 if (udev->usb_device) {
2207 continue;
2208 } else {
2209 udev->enumeration = 1;
2210 u132->addr[0].address = i;
2211 endp->udev_number = i;
2212 udev->udev_number = i;
2213 udev->usb_addr = usb_dev->devnum;
2214 u132_udev_init_kref(u132, udev);
2215 udev->endp_number_in[usb_endp] =
2216 endp->endp_number;
2217 u132_udev_get_kref(u132, udev);
2218 udev->endp_number_out[usb_endp] =
2219 endp->endp_number;
2220 udev->usb_device = usb_dev;
2221 ((u8 *) (urb->setup_packet))[2] =
2222 addr->address = i;
2223 u132_udev_get_kref(u132, udev);
2224 break;
2225 }
2226 }
2227 if (I == 0) {
2228 dev_err(&u132->platform_dev->dev, "run out of d"
2229 "evice space\n");
2230 return -EINVAL;
2231 }
2232 urb->hcpriv = u132;
2233 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2234 endp->urb_list[ENDP_QUEUE_MASK &
2235 endp->queue_last++] = urb;
2236 } else {
2237 struct u132_urbq *urbq =
2238 kmalloc(sizeof(struct u132_urbq),
2239 GFP_ATOMIC);
2240 if (urbq == NULL) {
2241 endp->queue_size -= 1;
2242 return -ENOMEM;
2243 } else {
2244 list_add_tail(&urbq->urb_more,
2245 &endp->urb_more);
2246 urbq->urb = urb;
2247 }
2248 }
2249 return 0;
2250 }
2251 } else { /*(usb_addr > 0) */
2252 u8 address = u132->addr[usb_addr].address;
2253 struct u132_udev *udev = &u132->udev[address];
2254 urb->hcpriv = u132;
2255 if (udev->enumeration == 2) {
2256 } else
2257 udev->enumeration = 2;
2258 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2259 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
2260 urb;
2261 } else {
2262 struct u132_urbq *urbq =
2263 kmalloc(sizeof(struct u132_urbq), GFP_ATOMIC);
2264 if (urbq == NULL) {
2265 endp->queue_size -= 1;
2266 return -ENOMEM;
2267 } else {
2268 list_add_tail(&urbq->urb_more, &endp->urb_more);
2269 urbq->urb = urb;
2270 }
2271 }
2272 return 0;
2273 }
2274 }
2275
2276 static int u132_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *hep,
2277 struct urb *urb, gfp_t mem_flags)
2278 {
2279 struct u132 *u132 = hcd_to_u132(hcd);
2280 if (irqs_disabled()) {
2281 if (__GFP_WAIT & mem_flags) {
2282 printk(KERN_ERR "invalid context for function that migh"
2283 "t sleep\n");
2284 return -EINVAL;
2285 }
2286 }
2287 if (u132->going > 1) {
2288 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2289 , u132->going);
2290 return -ENODEV;
2291 } else if (u132->going > 0) {
2292 dev_err(&u132->platform_dev->dev, "device is being removed urb="
2293 "%p status=%d\n", urb, urb->status);
2294 return -ESHUTDOWN;
2295 } else {
2296 u8 usb_addr = usb_pipedevice(urb->pipe);
2297 u8 usb_endp = usb_pipeendpoint(urb->pipe);
2298 struct usb_device *usb_dev = urb->dev;
2299 if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
2300 u8 address = u132->addr[usb_addr].address;
2301 struct u132_udev *udev = &u132->udev[address];
2302 struct u132_endp *endp = hep->hcpriv;
2303 urb->actual_length = 0;
2304 if (endp) {
2305 unsigned long irqs;
2306 int retval;
2307 spin_lock_irqsave(&endp->queue_lock.slock,
2308 irqs);
2309 retval = queue_int_on_old_endpoint(u132, udev,
2310 hep, urb, usb_dev, endp, usb_addr,
2311 usb_endp, address);
2312 spin_unlock_irqrestore(&endp->queue_lock.slock,
2313 irqs);
2314 if (retval) {
2315 return retval;
2316 } else {
2317 u132_endp_queue_work(u132, endp,
2318 msecs_to_jiffies(urb->interval))
2319 ;
2320 return 0;
2321 }
2322 } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2323 return -EINVAL;
2324 } else { /*(endp == NULL) */
2325 return create_endpoint_and_queue_int(u132, udev,
2326 hep, urb, usb_dev, usb_addr, usb_endp,
2327 address, mem_flags);
2328 }
2329 } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
2330 dev_err(&u132->platform_dev->dev, "the hardware does no"
2331 "t support PIPE_ISOCHRONOUS\n");
2332 return -EINVAL;
2333 } else if (usb_pipetype(urb->pipe) == PIPE_BULK) {
2334 u8 address = u132->addr[usb_addr].address;
2335 struct u132_udev *udev = &u132->udev[address];
2336 struct u132_endp *endp = hep->hcpriv;
2337 urb->actual_length = 0;
2338 if (endp) {
2339 unsigned long irqs;
2340 int retval;
2341 spin_lock_irqsave(&endp->queue_lock.slock,
2342 irqs);
2343 retval = queue_bulk_on_old_endpoint(u132, udev,
2344 hep, urb, usb_dev, endp, usb_addr,
2345 usb_endp, address);
2346 spin_unlock_irqrestore(&endp->queue_lock.slock,
2347 irqs);
2348 if (retval) {
2349 return retval;
2350 } else {
2351 u132_endp_queue_work(u132, endp, 0);
2352 return 0;
2353 }
2354 } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2355 return -EINVAL;
2356 } else
2357 return create_endpoint_and_queue_bulk(u132,
2358 udev, hep, urb, usb_dev, usb_addr,
2359 usb_endp, address, mem_flags);
2360 } else {
2361 struct u132_endp *endp = hep->hcpriv;
2362 u16 urb_size = 8;
2363 u8 *b = urb->setup_packet;
2364 int i = 0;
2365 char data[30 *3 + 4];
2366 char *d = data;
2367 int m = (sizeof(data) - 1) / 3;
2368 int l = 0;
2369 data[0] = 0;
2370 while (urb_size-- > 0) {
2371 if (i > m) {
2372 } else if (i++ < m) {
2373 int w = sprintf(d, " %02X", *b++);
2374 d += w;
2375 l += w;
2376 } else
2377 d += sprintf(d, " ..");
2378 }
2379 if (endp) {
2380 unsigned long irqs;
2381 int retval;
2382 spin_lock_irqsave(&endp->queue_lock.slock,
2383 irqs);
2384 retval = queue_control_on_old_endpoint(u132,
2385 hep, urb, usb_dev, endp, usb_addr,
2386 usb_endp);
2387 spin_unlock_irqrestore(&endp->queue_lock.slock,
2388 irqs);
2389 if (retval) {
2390 return retval;
2391 } else {
2392 u132_endp_queue_work(u132, endp, 0);
2393 return 0;
2394 }
2395 } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2396 return -EINVAL;
2397 } else
2398 return create_endpoint_and_queue_control(u132,
2399 hep, urb, usb_dev, usb_addr, usb_endp,
2400 mem_flags);
2401 }
2402 }
2403 }
2404
2405 static int dequeue_from_overflow_chain(struct u132 *u132,
2406 struct u132_endp *endp, struct urb *urb)
2407 {
2408 struct list_head *scan;
2409 struct list_head *head = &endp->urb_more;
2410 list_for_each(scan, head) {
2411 struct u132_urbq *urbq = list_entry(scan, struct u132_urbq,
2412 urb_more);
2413 if (urbq->urb == urb) {
2414 struct usb_hcd *hcd = u132_to_hcd(u132);
2415 list_del(scan);
2416 endp->queue_size -= 1;
2417 urb->error_count = 0;
2418 urb->hcpriv = NULL;
2419 usb_hcd_giveback_urb(hcd, urb);
2420 return 0;
2421 } else
2422 continue;
2423 }
2424 dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]=%p ring"
2425 "[%d] %c%c usb_endp=%d usb_addr=%d size=%d next=%04X last=%04X"
2426 "\n", urb, endp->endp_number, endp, endp->ring->number,
2427 endp->input ? 'I' : ' ', endp->output ? 'O' : ' ',
2428 endp->usb_endp, endp->usb_addr, endp->queue_size,
2429 endp->queue_next, endp->queue_last);
2430 return -EINVAL;
2431 }
2432
2433 static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
2434 struct urb *urb)
2435 {
2436 unsigned long irqs;
2437 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2438 if (endp->queue_size == 0) {
2439 dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]"
2440 "=%p ring[%d] %c%c usb_endp=%d usb_addr=%d\n", urb,
2441 endp->endp_number, endp, endp->ring->number,
2442 endp->input ? 'I' : ' ', endp->output ? 'O' : ' ',
2443 endp->usb_endp, endp->usb_addr);
2444 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2445 return -EINVAL;
2446 }
2447 if (urb == endp->urb_list[ENDP_QUEUE_MASK & endp->queue_next]) {
2448 if (endp->active) {
2449 endp->dequeueing = 1;
2450 endp->edset_flush = 1;
2451 u132_endp_queue_work(u132, endp, 0);
2452 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2453 urb->hcpriv = NULL;
2454 return 0;
2455 } else {
2456 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2457 u132_hcd_abandon_urb(u132, endp, urb, urb->status);
2458 return 0;
2459 }
2460 } else {
2461 u16 queue_list = 0;
2462 u16 queue_size = endp->queue_size;
2463 u16 queue_scan = endp->queue_next;
2464 struct urb **urb_slot = NULL;
2465 while (++queue_list < ENDP_QUEUE_SIZE && --queue_size > 0) {
2466 if (urb == endp->urb_list[ENDP_QUEUE_MASK &
2467 ++queue_scan]) {
2468 urb_slot = &endp->urb_list[ENDP_QUEUE_MASK &
2469 queue_scan];
2470 break;
2471 } else
2472 continue;
2473 }
2474 while (++queue_list < ENDP_QUEUE_SIZE && --queue_size > 0) {
2475 *urb_slot = endp->urb_list[ENDP_QUEUE_MASK &
2476 ++queue_scan];
2477 urb_slot = &endp->urb_list[ENDP_QUEUE_MASK &
2478 queue_scan];
2479 }
2480 if (urb_slot) {
2481 struct usb_hcd *hcd = u132_to_hcd(u132);
2482 endp->queue_size -= 1;
2483 if (list_empty(&endp->urb_more)) {
2484 spin_unlock_irqrestore(&endp->queue_lock.slock,
2485 irqs);
2486 } else {
2487 struct list_head *next = endp->urb_more.next;
2488 struct u132_urbq *urbq = list_entry(next,
2489 struct u132_urbq, urb_more);
2490 list_del(next);
2491 *urb_slot = urbq->urb;
2492 spin_unlock_irqrestore(&endp->queue_lock.slock,
2493 irqs);
2494 kfree(urbq);
2495 } urb->error_count = 0;
2496 urb->hcpriv = NULL;
2497 usb_hcd_giveback_urb(hcd, urb);
2498 return 0;
2499 } else if (list_empty(&endp->urb_more)) {
2500 dev_err(&u132->platform_dev->dev, "urb=%p not found in "
2501 "endp[%d]=%p ring[%d] %c%c usb_endp=%d usb_addr"
2502 "=%d size=%d next=%04X last=%04X\n", urb,
2503 endp->endp_number, endp, endp->ring->number,
2504 endp->input ? 'I' : ' ',
2505 endp->output ? 'O' : ' ', endp->usb_endp,
2506 endp->usb_addr, endp->queue_size,
2507 endp->queue_next, endp->queue_last);
2508 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2509 return -EINVAL;
2510 } else {
2511 int retval = dequeue_from_overflow_chain(u132, endp,
2512 urb);
2513 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2514 return retval;
2515 }
2516 }
2517 }
2518
2519 static int u132_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
2520 {
2521 struct u132 *u132 = hcd_to_u132(hcd);
2522 if (u132->going > 2) {
2523 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2524 , u132->going);
2525 return -ENODEV;
2526 } else {
2527 u8 usb_addr = usb_pipedevice(urb->pipe);
2528 u8 usb_endp = usb_pipeendpoint(urb->pipe);
2529 u8 address = u132->addr[usb_addr].address;
2530 struct u132_udev *udev = &u132->udev[address];
2531 if (usb_pipein(urb->pipe)) {
2532 u8 endp_number = udev->endp_number_in[usb_endp];
2533 struct u132_endp *endp = u132->endp[endp_number - 1];
2534 return u132_endp_urb_dequeue(u132, endp, urb);
2535 } else {
2536 u8 endp_number = udev->endp_number_out[usb_endp];
2537 struct u132_endp *endp = u132->endp[endp_number - 1];
2538 return u132_endp_urb_dequeue(u132, endp, urb);
2539 }
2540 }
2541 }
2542
2543 static void u132_endpoint_disable(struct usb_hcd *hcd,
2544 struct usb_host_endpoint *hep)
2545 {
2546 struct u132 *u132 = hcd_to_u132(hcd);
2547 if (u132->going > 2) {
2548 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2549 , u132->going);
2550 } else {
2551 struct u132_endp *endp = hep->hcpriv;
2552 if (endp)
2553 u132_endp_put_kref(u132, endp);
2554 }
2555 }
2556
2557 static int u132_get_frame(struct usb_hcd *hcd)
2558 {
2559 struct u132 *u132 = hcd_to_u132(hcd);
2560 if (u132->going > 1) {
2561 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2562 , u132->going);
2563 return -ENODEV;
2564 } else if (u132->going > 0) {
2565 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2566 return -ESHUTDOWN;
2567 } else {
2568 int frame = 0;
2569 dev_err(&u132->platform_dev->dev, "TODO: u132_get_frame\n");
2570 msleep(100);
2571 return frame;
2572 }
2573 }
2574
2575 static int u132_roothub_descriptor(struct u132 *u132,
2576 struct usb_hub_descriptor *desc)
2577 {
2578 int retval;
2579 u16 temp;
2580 u32 rh_a = -1;
2581 u32 rh_b = -1;
2582 retval = u132_read_pcimem(u132, roothub.a, &rh_a);
2583 if (retval)
2584 return retval;
2585 desc->bDescriptorType = 0x29;
2586 desc->bPwrOn2PwrGood = (rh_a & RH_A_POTPGT) >> 24;
2587 desc->bHubContrCurrent = 0;
2588 desc->bNbrPorts = u132->num_ports;
2589 temp = 1 + (u132->num_ports / 8);
2590 desc->bDescLength = 7 + 2 *temp;
2591 temp = 0;
2592 if (rh_a & RH_A_NPS)
2593 temp |= 0x0002;
2594 if (rh_a & RH_A_PSM)
2595 temp |= 0x0001;
2596 if (rh_a & RH_A_NOCP) {
2597 temp |= 0x0010;
2598 } else if (rh_a & RH_A_OCPM)
2599 temp |= 0x0008;
2600 desc->wHubCharacteristics = cpu_to_le16(temp);
2601 retval = u132_read_pcimem(u132, roothub.b, &rh_b);
2602 if (retval)
2603 return retval;
2604 memset(desc->bitmap, 0xff, sizeof(desc->bitmap));
2605 desc->bitmap[0] = rh_b & RH_B_DR;
2606 if (u132->num_ports > 7) {
2607 desc->bitmap[1] = (rh_b & RH_B_DR) >> 8;
2608 desc->bitmap[2] = 0xff;
2609 } else
2610 desc->bitmap[1] = 0xff;
2611 return 0;
2612 }
2613
2614 static int u132_roothub_status(struct u132 *u132, __le32 *desc)
2615 {
2616 u32 rh_status = -1;
2617 int ret_status = u132_read_pcimem(u132, roothub.status, &rh_status);
2618 *desc = cpu_to_le32(rh_status);
2619 return ret_status;
2620 }
2621
2622 static int u132_roothub_portstatus(struct u132 *u132, __le32 *desc, u16 wIndex)
2623 {
2624 if (wIndex == 0 || wIndex > u132->num_ports) {
2625 return -EINVAL;
2626 } else {
2627 int port = wIndex - 1;
2628 u32 rh_portstatus = -1;
2629 int ret_portstatus = u132_read_pcimem(u132,
2630 roothub.portstatus[port], &rh_portstatus);
2631 *desc = cpu_to_le32(rh_portstatus);
2632 if (*(u16 *) (desc + 2)) {
2633 dev_info(&u132->platform_dev->dev, "Port %d Status Chan"
2634 "ge = %08X\n", port, *desc);
2635 }
2636 return ret_portstatus;
2637 }
2638 }
2639
2640
2641 /* this timer value might be vendor-specific ... */
2642 #define PORT_RESET_HW_MSEC 10
2643 #define PORT_RESET_MSEC 10
2644 /* wrap-aware logic morphed from <linux/jiffies.h> */
2645 #define tick_before(t1, t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
2646 static int u132_roothub_portreset(struct u132 *u132, int port_index)
2647 {
2648 int retval;
2649 u32 fmnumber;
2650 u16 now;
2651 u16 reset_done;
2652 retval = u132_read_pcimem(u132, fmnumber, &fmnumber);
2653 if (retval)
2654 return retval;
2655 now = fmnumber;
2656 reset_done = now + PORT_RESET_MSEC;
2657 do {
2658 u32 portstat;
2659 do {
2660 retval = u132_read_pcimem(u132,
2661 roothub.portstatus[port_index], &portstat);
2662 if (retval)
2663 return retval;
2664 if (RH_PS_PRS & portstat) {
2665 continue;
2666 } else
2667 break;
2668 } while (tick_before(now, reset_done));
2669 if (RH_PS_PRS & portstat)
2670 return -ENODEV;
2671 if (RH_PS_CCS & portstat) {
2672 if (RH_PS_PRSC & portstat) {
2673 retval = u132_write_pcimem(u132,
2674 roothub.portstatus[port_index],
2675 RH_PS_PRSC);
2676 if (retval)
2677 return retval;
2678 }
2679 } else
2680 break; /* start the next reset,
2681 sleep till it's probably done */
2682 retval = u132_write_pcimem(u132, roothub.portstatus[port_index],
2683 RH_PS_PRS);
2684 if (retval)
2685 return retval;
2686 msleep(PORT_RESET_HW_MSEC);
2687 retval = u132_read_pcimem(u132, fmnumber, &fmnumber);
2688 if (retval)
2689 return retval;
2690 now = fmnumber;
2691 } while (tick_before(now, reset_done));
2692 return 0;
2693 }
2694
2695 static int u132_roothub_setportfeature(struct u132 *u132, u16 wValue,
2696 u16 wIndex)
2697 {
2698 if (wIndex == 0 || wIndex > u132->num_ports) {
2699 return -EINVAL;
2700 } else {
2701 int retval;
2702 int port_index = wIndex - 1;
2703 struct u132_port *port = &u132->port[port_index];
2704 port->Status &= ~(1 << wValue);
2705 switch (wValue) {
2706 case USB_PORT_FEAT_SUSPEND:
2707 retval = u132_write_pcimem(u132,
2708 roothub.portstatus[port_index], RH_PS_PSS);
2709 if (retval)
2710 return retval;
2711 return 0;
2712 case USB_PORT_FEAT_POWER:
2713 retval = u132_write_pcimem(u132,
2714 roothub.portstatus[port_index], RH_PS_PPS);
2715 if (retval)
2716 return retval;
2717 return 0;
2718 case USB_PORT_FEAT_RESET:
2719 retval = u132_roothub_portreset(u132, port_index);
2720 if (retval)
2721 return retval;
2722 return 0;
2723 default:
2724 return -EPIPE;
2725 }
2726 }
2727 }
2728
2729 static int u132_roothub_clearportfeature(struct u132 *u132, u16 wValue,
2730 u16 wIndex)
2731 {
2732 if (wIndex == 0 || wIndex > u132->num_ports) {
2733 return -EINVAL;
2734 } else {
2735 int port_index = wIndex - 1;
2736 u32 temp;
2737 int retval;
2738 struct u132_port *port = &u132->port[port_index];
2739 port->Status &= ~(1 << wValue);
2740 switch (wValue) {
2741 case USB_PORT_FEAT_ENABLE:
2742 temp = RH_PS_CCS;
2743 break;
2744 case USB_PORT_FEAT_C_ENABLE:
2745 temp = RH_PS_PESC;
2746 break;
2747 case USB_PORT_FEAT_SUSPEND:
2748 temp = RH_PS_POCI;
2749 if ((u132->hc_control & OHCI_CTRL_HCFS)
2750 != OHCI_USB_OPER) {
2751 dev_err(&u132->platform_dev->dev, "TODO resume_"
2752 "root_hub\n");
2753 }
2754 break;
2755 case USB_PORT_FEAT_C_SUSPEND:
2756 temp = RH_PS_PSSC;
2757 break;
2758 case USB_PORT_FEAT_POWER:
2759 temp = RH_PS_LSDA;
2760 break;
2761 case USB_PORT_FEAT_C_CONNECTION:
2762 temp = RH_PS_CSC;
2763 break;
2764 case USB_PORT_FEAT_C_OVER_CURRENT:
2765 temp = RH_PS_OCIC;
2766 break;
2767 case USB_PORT_FEAT_C_RESET:
2768 temp = RH_PS_PRSC;
2769 break;
2770 default:
2771 return -EPIPE;
2772 }
2773 retval = u132_write_pcimem(u132, roothub.portstatus[port_index],
2774 temp);
2775 if (retval)
2776 return retval;
2777 return 0;
2778 }
2779 }
2780
2781
2782 /* the virtual root hub timer IRQ checks for hub status*/
2783 static int u132_hub_status_data(struct usb_hcd *hcd, char *buf)
2784 {
2785 struct u132 *u132 = hcd_to_u132(hcd);
2786 if (u132->going > 1) {
2787 dev_err(&u132->platform_dev->dev, "device hcd=%p has been remov"
2788 "ed %d\n", hcd, u132->going);
2789 return -ENODEV;
2790 } else if (u132->going > 0) {
2791 dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
2792 "ed\n", hcd);
2793 dump_stack();
2794 return -ESHUTDOWN;
2795 } else {
2796 int i, changed = 0, length = 1;
2797 if (u132->flags & OHCI_QUIRK_AMD756) {
2798 if ((u132->hc_roothub_a & RH_A_NDP) > MAX_ROOT_PORTS) {
2799 dev_err(&u132->platform_dev->dev, "bogus NDP, r"
2800 "ereads as NDP=%d\n",
2801 u132->hc_roothub_a & RH_A_NDP);
2802 goto done;
2803 }
2804 }
2805 if (u132->hc_roothub_status & (RH_HS_LPSC | RH_HS_OCIC)) {
2806 buf[0] = changed = 1;
2807 } else
2808 buf[0] = 0;
2809 if (u132->num_ports > 7) {
2810 buf[1] = 0;
2811 length++;
2812 }
2813 for (i = 0; i < u132->num_ports; i++) {
2814 if (u132->hc_roothub_portstatus[i] & (RH_PS_CSC |
2815 RH_PS_PESC | RH_PS_PSSC | RH_PS_OCIC |
2816 RH_PS_PRSC)) {
2817 changed = 1;
2818 if (i < 7) {
2819 buf[0] |= 1 << (i + 1);
2820 } else
2821 buf[1] |= 1 << (i - 7);
2822 continue;
2823 }
2824 if (!(u132->hc_roothub_portstatus[i] & RH_PS_CCS)) {
2825 continue;
2826 }
2827 if ((u132->hc_roothub_portstatus[i] & RH_PS_PSS)) {
2828 continue;
2829 }
2830 }
2831 done:return changed ? length : 0;
2832 }
2833 }
2834
2835 static int u132_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
2836 u16 wIndex, char *buf, u16 wLength)
2837 {
2838 struct u132 *u132 = hcd_to_u132(hcd);
2839 if (u132->going > 1) {
2840 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2841 , u132->going);
2842 return -ENODEV;
2843 } else if (u132->going > 0) {
2844 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2845 return -ESHUTDOWN;
2846 } else {
2847 int retval = 0;
2848 down(&u132->sw_lock);
2849 switch (typeReq) {
2850 case ClearHubFeature:
2851 switch (wValue) {
2852 case C_HUB_OVER_CURRENT:
2853 case C_HUB_LOCAL_POWER:
2854 break;
2855 default:
2856 goto stall;
2857 }
2858 break;
2859 case SetHubFeature:
2860 switch (wValue) {
2861 case C_HUB_OVER_CURRENT:
2862 case C_HUB_LOCAL_POWER:
2863 break;
2864 default:
2865 goto stall;
2866 }
2867 break;
2868 case ClearPortFeature:{
2869 retval = u132_roothub_clearportfeature(u132,
2870 wValue, wIndex);
2871 if (retval)
2872 goto error;
2873 break;
2874 }
2875 case GetHubDescriptor:{
2876 retval = u132_roothub_descriptor(u132,
2877 (struct usb_hub_descriptor *)buf);
2878 if (retval)
2879 goto error;
2880 break;
2881 }
2882 case GetHubStatus:{
2883 retval = u132_roothub_status(u132,
2884 (__le32 *) buf);
2885 if (retval)
2886 goto error;
2887 break;
2888 }
2889 case GetPortStatus:{
2890 retval = u132_roothub_portstatus(u132,
2891 (__le32 *) buf, wIndex);
2892 if (retval)
2893 goto error;
2894 break;
2895 }
2896 case SetPortFeature:{
2897 retval = u132_roothub_setportfeature(u132,
2898 wValue, wIndex);
2899 if (retval)
2900 goto error;
2901 break;
2902 }
2903 default:
2904 goto stall;
2905 error:u132_disable(u132);
2906 u132->going = 1;
2907 break;
2908 stall:retval = -EPIPE;
2909 break;
2910 }
2911 up(&u132->sw_lock);
2912 return retval;
2913 }
2914 }
2915
2916 static int u132_start_port_reset(struct usb_hcd *hcd, unsigned port_num)
2917 {
2918 struct u132 *u132 = hcd_to_u132(hcd);
2919 if (u132->going > 1) {
2920 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2921 , u132->going);
2922 return -ENODEV;
2923 } else if (u132->going > 0) {
2924 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2925 return -ESHUTDOWN;
2926 } else
2927 return 0;
2928 }
2929
2930 static void u132_hub_irq_enable(struct usb_hcd *hcd)
2931 {
2932 struct u132 *u132 = hcd_to_u132(hcd);
2933 if (u132->going > 1) {
2934 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2935 , u132->going);
2936 } else if (u132->going > 0)
2937 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2938 }
2939
2940
2941 #ifdef CONFIG_PM
2942 static int u132_hcd_suspend(struct usb_hcd *hcd, pm_message_t message)
2943 {
2944 struct u132 *u132 = hcd_to_u132(hcd);
2945 if (u132->going > 1) {
2946 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2947 , u132->going);
2948 return -ENODEV;
2949 } else if (u132->going > 0) {
2950 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2951 return -ESHUTDOWN;
2952 } else
2953 return 0;
2954 }
2955
2956 static int u132_hcd_resume(struct usb_hcd *hcd)
2957 {
2958 struct u132 *u132 = hcd_to_u132(hcd);
2959 if (u132->going > 1) {
2960 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2961 , u132->going);
2962 return -ENODEV;
2963 } else if (u132->going > 0) {
2964 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2965 return -ESHUTDOWN;
2966 } else
2967 return 0;
2968 }
2969
2970 static int u132_bus_suspend(struct usb_hcd *hcd)
2971 {
2972 struct u132 *u132 = hcd_to_u132(hcd);
2973 if (u132->going > 1) {
2974 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2975 , u132->going);
2976 return -ENODEV;
2977 } else if (u132->going > 0) {
2978 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2979 return -ESHUTDOWN;
2980 } else
2981 return 0;
2982 }
2983
2984 static int u132_bus_resume(struct usb_hcd *hcd)
2985 {
2986 struct u132 *u132 = hcd_to_u132(hcd);
2987 if (u132->going > 1) {
2988 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2989 , u132->going);
2990 return -ENODEV;
2991 } else if (u132->going > 0) {
2992 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2993 return -ESHUTDOWN;
2994 } else
2995 return 0;
2996 }
2997
2998 #else
2999 #define u132_hcd_suspend NULL
3000 #define u132_hcd_resume NULL
3001 #define u132_bus_suspend NULL
3002 #define u132_bus_resume NULL
3003 #endif
3004 static struct hc_driver u132_hc_driver = {
3005 .description = hcd_name,
3006 .hcd_priv_size = sizeof(struct u132),
3007 .irq = NULL,
3008 .flags = HCD_USB11 | HCD_MEMORY,
3009 .reset = u132_hcd_reset,
3010 .start = u132_hcd_start,
3011 .suspend = u132_hcd_suspend,
3012 .resume = u132_hcd_resume,
3013 .stop = u132_hcd_stop,
3014 .urb_enqueue = u132_urb_enqueue,
3015 .urb_dequeue = u132_urb_dequeue,
3016 .endpoint_disable = u132_endpoint_disable,
3017 .get_frame_number = u132_get_frame,
3018 .hub_status_data = u132_hub_status_data,
3019 .hub_control = u132_hub_control,
3020 .bus_suspend = u132_bus_suspend,
3021 .bus_resume = u132_bus_resume,
3022 .start_port_reset = u132_start_port_reset,
3023 .hub_irq_enable = u132_hub_irq_enable,
3024 };
3025
3026 /*
3027 * This function may be called by the USB core whilst the "usb_all_devices_rwsem"
3028 * is held for writing, thus this module must not call usb_remove_hcd()
3029 * synchronously - but instead should immediately stop activity to the
3030 * device and asynchronously call usb_remove_hcd()
3031 */
3032 static int __devexit u132_remove(struct platform_device *pdev)
3033 {
3034 struct usb_hcd *hcd = platform_get_drvdata(pdev);
3035 if (hcd) {
3036 struct u132 *u132 = hcd_to_u132(hcd);
3037 dump_stack();
3038 if (u132->going++ > 1) {
3039 return -ENODEV;
3040 } else {
3041 int rings = MAX_U132_RINGS;
3042 int endps = MAX_U132_ENDPS;
3043 msleep(100);
3044 down(&u132->sw_lock);
3045 u132_monitor_cancel_work(u132);
3046 while (rings-- > 0) {
3047 struct u132_ring *ring = &u132->ring[rings];
3048 u132_ring_cancel_work(u132, ring);
3049 } while (endps-- > 0) {
3050 struct u132_endp *endp = u132->endp[endps];
3051 if (endp)
3052 u132_endp_cancel_work(u132, endp);
3053 }
3054 u132->going += 1;
3055 printk(KERN_INFO "removing device u132.%d\n",
3056 u132->sequence_num);
3057 up(&u132->sw_lock);
3058 usb_remove_hcd(hcd);
3059 u132_u132_put_kref(u132);
3060 return 0;
3061 }
3062 } else
3063 return 0;
3064 }
3065
3066 static void u132_initialise(struct u132 *u132, struct platform_device *pdev)
3067 {
3068 int rings = MAX_U132_RINGS;
3069 int ports = MAX_U132_PORTS;
3070 int addrs = MAX_U132_ADDRS;
3071 int udevs = MAX_U132_UDEVS;
3072 int endps = MAX_U132_ENDPS;
3073 u132->board = pdev->dev.platform_data;
3074 u132->platform_dev = pdev;
3075 u132->power = 0;
3076 u132->reset = 0;
3077 init_MUTEX(&u132->sw_lock);
3078 init_MUTEX(&u132->scheduler_lock);
3079 while (rings-- > 0) {
3080 struct u132_ring *ring = &u132->ring[rings];
3081 ring->u132 = u132;
3082 ring->number = rings + 1;
3083 ring->length = 0;
3084 ring->curr_endp = NULL;
3085 INIT_DELAYED_WORK(&ring->scheduler,
3086 u132_hcd_ring_work_scheduler);
3087 } down(&u132->sw_lock);
3088 INIT_DELAYED_WORK(&u132->monitor, u132_hcd_monitor_work);
3089 while (ports-- > 0) {
3090 struct u132_port *port = &u132->port[ports];
3091 port->u132 = u132;
3092 port->reset = 0;
3093 port->enable = 0;
3094 port->power = 0;
3095 port->Status = 0;
3096 } while (addrs-- > 0) {
3097 struct u132_addr *addr = &u132->addr[addrs];
3098 addr->address = 0;
3099 } while (udevs-- > 0) {
3100 struct u132_udev *udev = &u132->udev[udevs];
3101 int i = ARRAY_SIZE(udev->endp_number_in);
3102 int o = ARRAY_SIZE(udev->endp_number_out);
3103 udev->usb_device = NULL;
3104 udev->udev_number = 0;
3105 udev->usb_addr = 0;
3106 udev->portnumber = 0;
3107 while (i-- > 0) {
3108 udev->endp_number_in[i] = 0;
3109 }
3110 while (o-- > 0) {
3111 udev->endp_number_out[o] = 0;
3112 }
3113 }
3114 while (endps-- > 0) {
3115 u132->endp[endps] = NULL;
3116 }
3117 up(&u132->sw_lock);
3118 return;
3119 }
3120
3121 static int __devinit u132_probe(struct platform_device *pdev)
3122 {
3123 struct usb_hcd *hcd;
3124 msleep(100);
3125 if (u132_exiting > 0) {
3126 return -ENODEV;
3127 } /* refuse to confuse usbcore */
3128 if (pdev->dev.dma_mask) {
3129 return -EINVAL;
3130 }
3131 hcd = usb_create_hcd(&u132_hc_driver, &pdev->dev, pdev->dev.bus_id);
3132 if (!hcd) {
3133 printk(KERN_ERR "failed to create the usb hcd struct for U132\n"
3134 );
3135 ftdi_elan_gone_away(pdev);
3136 return -ENOMEM;
3137 } else {
3138 int retval = 0;
3139 struct u132 *u132 = hcd_to_u132(hcd);
3140 hcd->rsrc_start = 0;
3141 down(&u132_module_lock);
3142 list_add_tail(&u132->u132_list, &u132_static_list);
3143 u132->sequence_num = ++u132_instances;
3144 up(&u132_module_lock);
3145 u132_u132_init_kref(u132);
3146 u132_initialise(u132, pdev);
3147 hcd->product_desc = "ELAN U132 Host Controller";
3148 retval = usb_add_hcd(hcd, 0, 0);
3149 if (retval != 0) {
3150 dev_err(&u132->platform_dev->dev, "init error %d\n",
3151 retval);
3152 u132_u132_put_kref(u132);
3153 return retval;
3154 } else {
3155 u132_monitor_queue_work(u132, 100);
3156 return 0;
3157 }
3158 }
3159 }
3160
3161
3162 #ifdef CONFIG_PM
3163 /* for this device there's no useful distinction between the controller
3164 * and its root hub, except that the root hub only gets direct PM calls
3165 * when CONFIG_USB_SUSPEND is enabled.
3166 */
3167 static int u132_suspend(struct platform_device *pdev, pm_message_t state)
3168 {
3169 struct usb_hcd *hcd = platform_get_drvdata(pdev);
3170 struct u132 *u132 = hcd_to_u132(hcd);
3171 if (u132->going > 1) {
3172 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3173 , u132->going);
3174 return -ENODEV;
3175 } else if (u132->going > 0) {
3176 dev_err(&u132->platform_dev->dev, "device is being removed\n");
3177 return -ESHUTDOWN;
3178 } else {
3179 int retval = 0;
3180 if (state.event == PM_EVENT_FREEZE) {
3181 retval = u132_bus_suspend(hcd);
3182 } else if (state.event == PM_EVENT_SUSPEND) {
3183 int ports = MAX_U132_PORTS;
3184 while (ports-- > 0) {
3185 port_power(u132, ports, 0);
3186 }
3187 }
3188 if (retval == 0)
3189 pdev->dev.power.power_state = state;
3190 return retval;
3191 }
3192 }
3193
3194 static int u132_resume(struct platform_device *pdev)
3195 {
3196 struct usb_hcd *hcd = platform_get_drvdata(pdev);
3197 struct u132 *u132 = hcd_to_u132(hcd);
3198 if (u132->going > 1) {
3199 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3200 , u132->going);
3201 return -ENODEV;
3202 } else if (u132->going > 0) {
3203 dev_err(&u132->platform_dev->dev, "device is being removed\n");
3204 return -ESHUTDOWN;
3205 } else {
3206 int retval = 0;
3207 if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
3208 int ports = MAX_U132_PORTS;
3209 while (ports-- > 0) {
3210 port_power(u132, ports, 1);
3211 }
3212 retval = 0;
3213 } else {
3214 pdev->dev.power.power_state = PMSG_ON;
3215 retval = u132_bus_resume(hcd);
3216 }
3217 return retval;
3218 }
3219 }
3220
3221 #else
3222 #define u132_suspend NULL
3223 #define u132_resume NULL
3224 #endif
3225 /*
3226 * this driver is loaded explicitly by ftdi_u132
3227 *
3228 * the platform_driver struct is static because it is per type of module
3229 */
3230 static struct platform_driver u132_platform_driver = {
3231 .probe = u132_probe,
3232 .remove = __devexit_p(u132_remove),
3233 .suspend = u132_suspend,
3234 .resume = u132_resume,
3235 .driver = {
3236 .name = (char *)hcd_name,
3237 .owner = THIS_MODULE,
3238 },
3239 };
3240 static int __init u132_hcd_init(void)
3241 {
3242 int retval;
3243 INIT_LIST_HEAD(&u132_static_list);
3244 u132_instances = 0;
3245 u132_exiting = 0;
3246 init_MUTEX(&u132_module_lock);
3247 if (usb_disabled())
3248 return -ENODEV;
3249 printk(KERN_INFO "driver %s built at %s on %s\n", hcd_name, __TIME__,
3250 __DATE__);
3251 workqueue = create_singlethread_workqueue("u132");
3252 retval = platform_driver_register(&u132_platform_driver);
3253 return retval;
3254 }
3255
3256
3257 module_init(u132_hcd_init);
3258 static void __exit u132_hcd_exit(void)
3259 {
3260 struct u132 *u132;
3261 struct u132 *temp;
3262 down(&u132_module_lock);
3263 u132_exiting += 1;
3264 up(&u132_module_lock);
3265 list_for_each_entry_safe(u132, temp, &u132_static_list, u132_list) {
3266 platform_device_unregister(u132->platform_dev);
3267 } platform_driver_unregister(&u132_platform_driver);
3268 printk(KERN_INFO "u132-hcd driver deregistered\n");
3269 wait_event(u132_hcd_wait, u132_instances == 0);
3270 flush_workqueue(workqueue);
3271 destroy_workqueue(workqueue);
3272 }
3273
3274
3275 module_exit(u132_hcd_exit);
3276 MODULE_LICENSE("GPL");
kmemtrace - Kernel memory tracer