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