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