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