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