2 * Host Controller Driver for the Elan Digital Systems U132 adapter
4 * Copyright(C) 2006 Elan Digital Systems Limited
5 * http://www.elandigitalsystems.com
7 * Author and Maintainer - Tony Olech - Elan Digital Systems
8 * tony.olech@elandigitalsystems.com
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.
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
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.
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)
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.
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>
57 #include <asm/system.h>
58 #include <asm/byteorder.h>
59 #include "../core/hcd.h"
61 #define OHCI_CONTROL_INIT OHCI_CTRL_CBSR
62 #define OHCI_INTR_INIT (OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_RD | \
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"
74 DECLARE_WAIT_QUEUE_HEAD(u132_hcd_wait);
76 * u132_module_lock exists to protect access to global variables
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;
84 * end of the global variables protected by u132_module_lock
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] = {
122 struct usb_device *usb_device;
127 u8 endp_number_in[16];
128 u8 endp_number_out[16];
130 #define ENDP_QUEUE_SHIFT 3
131 #define ENDP_QUEUE_SIZE (1<<ENDP_QUEUE_SHIFT)
132 #define ENDP_QUEUE_MASK (ENDP_QUEUE_SIZE-1)
134 struct list_head urb_more;
147 struct list_head endp_ring;
148 struct u132_ring *ring;
149 unsigned toggle_bits: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;
164 struct urb *urb_list[ENDP_QUEUE_SIZE];
165 struct list_head urb_more;
166 struct work_struct scheduler;
173 struct u132_endp *curr_endp;
174 struct work_struct scheduler;
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
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];
196 u32 hc_roothub_status;
198 u32 hc_roothub_portstatus[MAX_ROOT_PORTS];
200 unsigned long next_statechange;
201 struct work_struct monitor;
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];
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,
214 * these can not be inlines because we need the structure offset!!
215 * Does anyone have a better way?????
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)
228 u8 udev_number = udev->udev_number;
229 return container_of(udev, struct u132, udev[udev_number]);
232 static inline struct u132 *hcd_to_u132(struct usb_hcd *hcd)
234 return (struct u132 *)(hcd->hcd_priv);
237 static inline struct usb_hcd *u132_to_hcd(struct u132 *u132)
239 return container_of((void *)u132, struct usb_hcd, hcd_priv);
242 static inline void u132_disable(struct u132 *u132)
244 u132_to_hcd(u132)->state = HC_STATE_HALT;
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)
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);
262 down(&u132_module_lock);
263 list_del_init(&u132->u132_list);
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);
271 static inline void u132_u132_put_kref(struct u132 *u132)
273 kref_put(&u132->kref, u132_hcd_delete);
276 static inline void u132_u132_init_kref(struct u132 *u132)
278 kref_init(&u132->kref);
281 static void u132_udev_delete(struct kref *kref)
283 struct u132_udev *udev = kref_to_u132_udev(kref);
284 udev->udev_number = 0;
285 udev->usb_device = NULL;
287 udev->enumeration = 0;
290 static inline void u132_udev_put_kref(struct u132 *u132, struct u132_udev *udev)
292 kref_put(&udev->kref, u132_udev_delete);
295 static inline void u132_udev_get_kref(struct u132 *u132, struct u132_udev *udev)
297 kref_get(&udev->kref);
300 static inline void u132_udev_init_kref(struct u132 *u132,
301 struct u132_udev *udev)
303 kref_init(&udev->kref);
306 static inline void u132_ring_put_kref(struct u132 *u132, struct u132_ring *ring)
308 kref_put(&u132->kref, u132_hcd_delete);
311 static void u132_ring_requeue_work(struct u132 *u132, struct u132_ring *ring,
315 if (queue_delayed_work(workqueue, &ring->scheduler, delta))
317 } else if (queue_work(workqueue, &ring->scheduler))
319 kref_put(&u132->kref, u132_hcd_delete);
323 static void u132_ring_queue_work(struct u132 *u132, struct u132_ring *ring,
326 kref_get(&u132->kref);
327 u132_ring_requeue_work(u132, ring, delta);
331 static void u132_ring_cancel_work(struct u132 *u132, struct u132_ring *ring)
333 if (cancel_delayed_work(&ring->scheduler)) {
334 kref_put(&u132->kref, u132_hcd_delete);
338 static void u132_endp_delete(struct kref *kref)
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;
351 if (endp == ring->curr_endp) {
352 if (list_empty(head)) {
353 ring->curr_endp = NULL;
356 struct u132_endp *next_endp = list_entry(head->next,
357 struct u132_endp, endp_ring);
358 ring->curr_endp = next_endp;
363 udev->endp_number_in[usb_endp] = 0;
364 u132_udev_put_kref(u132, udev);
367 udev->endp_number_out[usb_endp] = 0;
368 u132_udev_put_kref(u132, udev);
370 u132->endp[endp_number - 1] = NULL;
373 u132_u132_put_kref(u132);
376 static inline void u132_endp_put_kref(struct u132 *u132, struct u132_endp *endp)
378 kref_put(&endp->kref, u132_endp_delete);
381 static inline void u132_endp_get_kref(struct u132 *u132, struct u132_endp *endp)
383 kref_get(&endp->kref);
386 static inline void u132_endp_init_kref(struct u132 *u132,
387 struct u132_endp *endp)
389 kref_init(&endp->kref);
390 kref_get(&u132->kref);
393 static void u132_endp_queue_work(struct u132 *u132, struct u132_endp *endp,
397 if (queue_delayed_work(workqueue, &endp->scheduler, delta))
398 kref_get(&endp->kref);
399 } else if (queue_work(workqueue, &endp->scheduler))
400 kref_get(&endp->kref);
404 static void u132_endp_cancel_work(struct u132 *u132, struct u132_endp *endp)
406 if (cancel_delayed_work(&endp->scheduler))
407 kref_put(&endp->kref, u132_endp_delete);
410 static inline void u132_monitor_put_kref(struct u132 *u132)
412 kref_put(&u132->kref, u132_hcd_delete);
415 static void u132_monitor_queue_work(struct u132 *u132, unsigned int delta)
418 if (queue_delayed_work(workqueue, &u132->monitor, delta)) {
419 kref_get(&u132->kref);
421 } else if (queue_work(workqueue, &u132->monitor))
422 kref_get(&u132->kref);
426 static void u132_monitor_requeue_work(struct u132 *u132, unsigned int delta)
429 if (queue_delayed_work(workqueue, &u132->monitor, delta))
431 } else if (queue_work(workqueue, &u132->monitor))
433 kref_put(&u132->kref, u132_hcd_delete);
437 static void u132_monitor_cancel_work(struct u132 *u132)
439 if (cancel_delayed_work(&u132->monitor))
440 kref_put(&u132->kref, u132_hcd_delete);
443 static int read_roothub_info(struct u132 *u132)
447 retval = u132_read_pcimem(u132, revision, &revision);
449 dev_err(&u132->platform_dev->dev, "error %d accessing device co"
452 } else if ((revision & 0xFF) == 0x10) {
453 } else if ((revision & 0xFF) == 0x11) {
455 dev_err(&u132->platform_dev->dev, "device revision is not valid"
456 " %08X\n", revision);
459 retval = u132_read_pcimem(u132, control, &u132->hc_control);
461 dev_err(&u132->platform_dev->dev, "error %d accessing device co"
465 retval = u132_read_pcimem(u132, roothub.status,
466 &u132->hc_roothub_status);
468 dev_err(&u132->platform_dev->dev, "error %d accessing device re"
469 "g roothub.status\n", retval);
472 retval = u132_read_pcimem(u132, roothub.a, &u132->hc_roothub_a);
474 dev_err(&u132->platform_dev->dev, "error %d accessing device re"
475 "g roothub.a\n", retval);
479 int I = u132->num_ports;
482 retval = u132_read_pcimem(u132, roothub.portstatus[i],
483 &u132->hc_roothub_portstatus[i]);
485 dev_err(&u132->platform_dev->dev, "error %d acc"
486 "essing device roothub.portstatus[%d]\n"
496 static void u132_hcd_monitor_work(void *data)
498 struct u132 *u132 = data;
499 if (u132->going > 1) {
500 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
502 u132_monitor_put_kref(u132);
504 } else if (u132->going > 0) {
505 dev_err(&u132->platform_dev->dev, "device is being removed\n");
506 u132_monitor_put_kref(u132);
510 down(&u132->sw_lock);
511 retval = read_roothub_info(u132);
513 struct usb_hcd *hcd = u132_to_hcd(u132);
518 ftdi_elan_gone_away(u132->platform_dev);
519 u132_monitor_put_kref(u132);
522 u132_monitor_requeue_work(u132, 500);
529 static void u132_hcd_giveback_urb(struct u132 *u132, struct u132_endp *endp,
530 struct urb *urb, int status)
532 struct u132_ring *ring;
534 struct usb_hcd *hcd = u132_to_hcd(u132);
535 urb->error_count = 0;
536 urb->status = status;
538 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
539 endp->queue_next += 1;
540 if (ENDP_QUEUE_SIZE > --endp->queue_size) {
542 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
544 struct list_head *next = endp->urb_more.next;
545 struct u132_urbq *urbq = list_entry(next, struct u132_urbq,
548 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
551 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
553 } down(&u132->scheduler_lock);
556 u132_ring_cancel_work(u132, ring);
557 u132_ring_queue_work(u132, ring, 0);
558 up(&u132->scheduler_lock);
559 u132_endp_put_kref(u132, endp);
560 usb_hcd_giveback_urb(hcd, urb);
564 static void u132_hcd_forget_urb(struct u132 *u132, struct u132_endp *endp,
565 struct urb *urb, int status)
567 u132_endp_put_kref(u132, endp);
570 static void u132_hcd_abandon_urb(struct u132 *u132, struct u132_endp *endp,
571 struct urb *urb, int status)
574 struct usb_hcd *hcd = u132_to_hcd(u132);
575 urb->error_count = 0;
576 urb->status = status;
578 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
579 endp->queue_next += 1;
580 if (ENDP_QUEUE_SIZE > --endp->queue_size) {
582 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
584 struct list_head *next = endp->urb_more.next;
585 struct u132_urbq *urbq = list_entry(next, struct u132_urbq,
588 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
591 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
593 } usb_hcd_giveback_urb(hcd, urb);
597 static inline int edset_input(struct u132 *u132, struct u132_ring *ring,
598 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
599 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
600 int toggle_bits, int error_count, int condition_code, int repeat_number,
601 int halted, int skipped, int actual, int non_null))
603 return usb_ftdi_elan_edset_input(u132->platform_dev, ring->number, endp,
604 urb, address, endp->usb_endp, toggle_bits, callback);
607 static inline int edset_setup(struct u132 *u132, struct u132_ring *ring,
608 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
609 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
610 int toggle_bits, int error_count, int condition_code, int repeat_number,
611 int halted, int skipped, int actual, int non_null))
613 return usb_ftdi_elan_edset_setup(u132->platform_dev, ring->number, endp,
614 urb, address, endp->usb_endp, toggle_bits, callback);
617 static inline int edset_single(struct u132 *u132, struct u132_ring *ring,
618 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
619 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
620 int toggle_bits, int error_count, int condition_code, int repeat_number,
621 int halted, int skipped, int actual, int non_null))
623 return usb_ftdi_elan_edset_single(u132->platform_dev, ring->number,
624 endp, urb, address, endp->usb_endp, toggle_bits, callback);
627 static inline int edset_output(struct u132 *u132, struct u132_ring *ring,
628 struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
629 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
630 int toggle_bits, int error_count, int condition_code, int repeat_number,
631 int halted, int skipped, int actual, int non_null))
633 return usb_ftdi_elan_edset_output(u132->platform_dev, ring->number,
634 endp, urb, address, endp->usb_endp, toggle_bits, callback);
639 * must not LOCK sw_lock
642 static void u132_hcd_interrupt_recv(void *data, struct urb *urb, u8 *buf,
643 int len, int toggle_bits, int error_count, int condition_code,
644 int repeat_number, int halted, int skipped, int actual, int non_null)
646 struct u132_endp *endp = data;
647 struct u132 *u132 = endp->u132;
648 u8 address = u132->addr[endp->usb_addr].address;
649 struct u132_udev *udev = &u132->udev[address];
650 down(&u132->scheduler_lock);
651 if (u132->going > 1) {
652 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
654 up(&u132->scheduler_lock);
655 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
657 } else if (endp->dequeueing) {
658 endp->dequeueing = 0;
659 up(&u132->scheduler_lock);
660 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
662 } else if (u132->going > 0) {
663 dev_err(&u132->platform_dev->dev, "device is being removed urb="
664 "%p status=%d\n", urb, urb->status);
665 up(&u132->scheduler_lock);
666 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
668 } else if (urb->status == -EINPROGRESS) {
669 struct u132_ring *ring = endp->ring;
670 u8 *u = urb->transfer_buffer + urb->actual_length;
676 urb->actual_length += len;
677 if ((condition_code == TD_CC_NOERROR) &&
678 (urb->transfer_buffer_length > urb->actual_length)) {
679 endp->toggle_bits = toggle_bits;
680 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
682 if (urb->actual_length > 0) {
684 up(&u132->scheduler_lock);
685 retval = edset_single(u132, ring, endp, urb,
686 address, endp->toggle_bits,
687 u132_hcd_interrupt_recv);
690 u132_hcd_giveback_urb(u132, endp, urb,
695 endp->jiffies = jiffies +
696 msecs_to_jiffies(urb->interval);
697 u132_ring_cancel_work(u132, ring);
698 u132_ring_queue_work(u132, ring, 0);
699 up(&u132->scheduler_lock);
700 u132_endp_put_kref(u132, endp);
703 } else if ((condition_code == TD_DATAUNDERRUN) &&
704 ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0)) {
705 endp->toggle_bits = toggle_bits;
706 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
708 up(&u132->scheduler_lock);
709 u132_hcd_giveback_urb(u132, endp, urb, 0);
712 if (condition_code == TD_CC_NOERROR) {
713 endp->toggle_bits = toggle_bits;
714 usb_settoggle(udev->usb_device, endp->usb_endp,
716 } else if (condition_code == TD_CC_STALL) {
717 endp->toggle_bits = 0x2;
718 usb_settoggle(udev->usb_device, endp->usb_endp,
721 endp->toggle_bits = 0x2;
722 usb_settoggle(udev->usb_device, endp->usb_endp,
724 dev_err(&u132->platform_dev->dev, "urb=%p givin"
725 "g back INTERRUPT %s\n", urb,
726 cc_to_text[condition_code]);
728 up(&u132->scheduler_lock);
729 u132_hcd_giveback_urb(u132, endp, urb,
730 cc_to_error[condition_code]);
734 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
735 "s=%d\n", urb, urb->status);
736 up(&u132->scheduler_lock);
737 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
742 static void u132_hcd_bulk_output_sent(void *data, struct urb *urb, u8 *buf,
743 int len, int toggle_bits, int error_count, int condition_code,
744 int repeat_number, int halted, int skipped, int actual, int non_null)
746 struct u132_endp *endp = data;
747 struct u132 *u132 = endp->u132;
748 u8 address = u132->addr[endp->usb_addr].address;
749 down(&u132->scheduler_lock);
750 if (u132->going > 1) {
751 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
753 up(&u132->scheduler_lock);
754 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
756 } else if (endp->dequeueing) {
757 endp->dequeueing = 0;
758 up(&u132->scheduler_lock);
759 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
761 } else if (u132->going > 0) {
762 dev_err(&u132->platform_dev->dev, "device is being removed urb="
763 "%p status=%d\n", urb, urb->status);
764 up(&u132->scheduler_lock);
765 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
767 } else if (urb->status == -EINPROGRESS) {
768 struct u132_ring *ring = endp->ring;
769 urb->actual_length += len;
770 endp->toggle_bits = toggle_bits;
771 if (urb->transfer_buffer_length > urb->actual_length) {
773 up(&u132->scheduler_lock);
774 retval = edset_output(u132, ring, endp, urb, address,
775 endp->toggle_bits, u132_hcd_bulk_output_sent);
778 u132_hcd_giveback_urb(u132, endp, urb, retval);
781 up(&u132->scheduler_lock);
782 u132_hcd_giveback_urb(u132, endp, urb, 0);
786 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
787 "s=%d\n", urb, urb->status);
788 up(&u132->scheduler_lock);
789 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
794 static void u132_hcd_bulk_input_recv(void *data, struct urb *urb, u8 *buf,
795 int len, int toggle_bits, int error_count, int condition_code,
796 int repeat_number, int halted, int skipped, int actual, int non_null)
798 struct u132_endp *endp = data;
799 struct u132 *u132 = endp->u132;
800 u8 address = u132->addr[endp->usb_addr].address;
801 struct u132_udev *udev = &u132->udev[address];
802 down(&u132->scheduler_lock);
803 if (u132->going > 1) {
804 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
806 up(&u132->scheduler_lock);
807 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
809 } else if (endp->dequeueing) {
810 endp->dequeueing = 0;
811 up(&u132->scheduler_lock);
812 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
814 } else if (u132->going > 0) {
815 dev_err(&u132->platform_dev->dev, "device is being removed urb="
816 "%p status=%d\n", urb, urb->status);
817 up(&u132->scheduler_lock);
818 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
820 } else if (urb->status == -EINPROGRESS) {
821 struct u132_ring *ring = endp->ring;
822 u8 *u = urb->transfer_buffer + urb->actual_length;
828 urb->actual_length += len;
829 if ((condition_code == TD_CC_NOERROR) &&
830 (urb->transfer_buffer_length > urb->actual_length)) {
832 endp->toggle_bits = toggle_bits;
833 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
835 up(&u132->scheduler_lock);
836 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
837 ring->number, endp, urb, address,
838 endp->usb_endp, endp->toggle_bits,
839 u132_hcd_bulk_input_recv);
842 u132_hcd_giveback_urb(u132, endp, urb, retval);
844 } else if (condition_code == TD_CC_NOERROR) {
845 endp->toggle_bits = toggle_bits;
846 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
848 up(&u132->scheduler_lock);
849 u132_hcd_giveback_urb(u132, endp, urb,
850 cc_to_error[condition_code]);
852 } else if ((condition_code == TD_DATAUNDERRUN) &&
853 ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0)) {
854 endp->toggle_bits = toggle_bits;
855 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
857 up(&u132->scheduler_lock);
858 u132_hcd_giveback_urb(u132, endp, urb, 0);
860 } else if (condition_code == TD_DATAUNDERRUN) {
861 endp->toggle_bits = toggle_bits;
862 usb_settoggle(udev->usb_device, endp->usb_endp, 0,
864 dev_warn(&u132->platform_dev->dev, "urb=%p(SHORT NOT OK"
865 ") giving back BULK IN %s\n", urb,
866 cc_to_text[condition_code]);
867 up(&u132->scheduler_lock);
868 u132_hcd_giveback_urb(u132, endp, urb, 0);
870 } else if (condition_code == TD_CC_STALL) {
871 endp->toggle_bits = 0x2;
872 usb_settoggle(udev->usb_device, endp->usb_endp, 0, 0);
873 up(&u132->scheduler_lock);
874 u132_hcd_giveback_urb(u132, endp, urb,
875 cc_to_error[condition_code]);
878 endp->toggle_bits = 0x2;
879 usb_settoggle(udev->usb_device, endp->usb_endp, 0, 0);
880 dev_err(&u132->platform_dev->dev, "urb=%p giving back B"
881 "ULK IN code=%d %s\n", urb, condition_code,
882 cc_to_text[condition_code]);
883 up(&u132->scheduler_lock);
884 u132_hcd_giveback_urb(u132, endp, urb,
885 cc_to_error[condition_code]);
889 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
890 "s=%d\n", urb, urb->status);
891 up(&u132->scheduler_lock);
892 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
897 static void u132_hcd_configure_empty_sent(void *data, struct urb *urb, u8 *buf,
898 int len, int toggle_bits, int error_count, int condition_code,
899 int repeat_number, int halted, int skipped, int actual, int non_null)
901 struct u132_endp *endp = data;
902 struct u132 *u132 = endp->u132;
903 down(&u132->scheduler_lock);
904 if (u132->going > 1) {
905 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
907 up(&u132->scheduler_lock);
908 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
910 } else if (endp->dequeueing) {
911 endp->dequeueing = 0;
912 up(&u132->scheduler_lock);
913 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
915 } else if (u132->going > 0) {
916 dev_err(&u132->platform_dev->dev, "device is being removed urb="
917 "%p status=%d\n", urb, urb->status);
918 up(&u132->scheduler_lock);
919 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
921 } else if (urb->status == -EINPROGRESS) {
922 up(&u132->scheduler_lock);
923 u132_hcd_giveback_urb(u132, endp, urb, 0);
926 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
927 "s=%d\n", urb, urb->status);
928 up(&u132->scheduler_lock);
929 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
934 static void u132_hcd_configure_input_recv(void *data, struct urb *urb, u8 *buf,
935 int len, int toggle_bits, int error_count, int condition_code,
936 int repeat_number, int halted, int skipped, int actual, int non_null)
938 struct u132_endp *endp = data;
939 struct u132 *u132 = endp->u132;
940 u8 address = u132->addr[endp->usb_addr].address;
941 down(&u132->scheduler_lock);
942 if (u132->going > 1) {
943 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
945 up(&u132->scheduler_lock);
946 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
948 } else if (endp->dequeueing) {
949 endp->dequeueing = 0;
950 up(&u132->scheduler_lock);
951 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
953 } else if (u132->going > 0) {
954 dev_err(&u132->platform_dev->dev, "device is being removed urb="
955 "%p status=%d\n", urb, urb->status);
956 up(&u132->scheduler_lock);
957 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
959 } else if (urb->status == -EINPROGRESS) {
960 struct u132_ring *ring = endp->ring;
961 u8 *u = urb->transfer_buffer;
967 urb->actual_length = len;
968 if ((condition_code == TD_CC_NOERROR) || ((condition_code ==
969 TD_DATAUNDERRUN) && ((urb->transfer_flags &
970 URB_SHORT_NOT_OK) == 0))) {
972 up(&u132->scheduler_lock);
973 retval = usb_ftdi_elan_edset_empty(u132->platform_dev,
974 ring->number, endp, urb, address,
976 u132_hcd_configure_empty_sent);
979 u132_hcd_giveback_urb(u132, endp, urb, retval);
981 } else if (condition_code == TD_CC_STALL) {
982 up(&u132->scheduler_lock);
983 dev_warn(&u132->platform_dev->dev, "giving back SETUP I"
984 "NPUT STALL urb %p\n", urb);
985 u132_hcd_giveback_urb(u132, endp, urb,
986 cc_to_error[condition_code]);
989 up(&u132->scheduler_lock);
990 dev_err(&u132->platform_dev->dev, "giving back SETUP IN"
991 "PUT %s urb %p\n", cc_to_text[condition_code],
993 u132_hcd_giveback_urb(u132, endp, urb,
994 cc_to_error[condition_code]);
998 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
999 "s=%d\n", urb, urb->status);
1000 up(&u132->scheduler_lock);
1001 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1006 static void u132_hcd_configure_empty_recv(void *data, struct urb *urb, u8 *buf,
1007 int len, int toggle_bits, int error_count, int condition_code,
1008 int repeat_number, int halted, int skipped, int actual, int non_null)
1010 struct u132_endp *endp = data;
1011 struct u132 *u132 = endp->u132;
1012 down(&u132->scheduler_lock);
1013 if (u132->going > 1) {
1014 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1016 up(&u132->scheduler_lock);
1017 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1019 } else if (endp->dequeueing) {
1020 endp->dequeueing = 0;
1021 up(&u132->scheduler_lock);
1022 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1024 } else if (u132->going > 0) {
1025 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1026 "%p status=%d\n", urb, urb->status);
1027 up(&u132->scheduler_lock);
1028 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1030 } else if (urb->status == -EINPROGRESS) {
1031 up(&u132->scheduler_lock);
1032 u132_hcd_giveback_urb(u132, endp, urb, 0);
1035 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1036 "s=%d\n", urb, urb->status);
1037 up(&u132->scheduler_lock);
1038 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1043 static void u132_hcd_configure_setup_sent(void *data, struct urb *urb, u8 *buf,
1044 int len, int toggle_bits, int error_count, int condition_code,
1045 int repeat_number, int halted, int skipped, int actual, int non_null)
1047 struct u132_endp *endp = data;
1048 struct u132 *u132 = endp->u132;
1049 u8 address = u132->addr[endp->usb_addr].address;
1050 down(&u132->scheduler_lock);
1051 if (u132->going > 1) {
1052 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1054 up(&u132->scheduler_lock);
1055 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1057 } else if (endp->dequeueing) {
1058 endp->dequeueing = 0;
1059 up(&u132->scheduler_lock);
1060 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1062 } else if (u132->going > 0) {
1063 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1064 "%p status=%d\n", urb, urb->status);
1065 up(&u132->scheduler_lock);
1066 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1068 } else if (urb->status == -EINPROGRESS) {
1069 if (usb_pipein(urb->pipe)) {
1071 struct u132_ring *ring = endp->ring;
1072 up(&u132->scheduler_lock);
1073 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1074 ring->number, endp, urb, address,
1076 u132_hcd_configure_input_recv);
1079 u132_hcd_giveback_urb(u132, endp, urb, retval);
1083 struct u132_ring *ring = endp->ring;
1084 up(&u132->scheduler_lock);
1085 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1086 ring->number, endp, urb, address,
1088 u132_hcd_configure_empty_recv);
1091 u132_hcd_giveback_urb(u132, endp, urb, retval);
1095 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1096 "s=%d\n", urb, urb->status);
1097 up(&u132->scheduler_lock);
1098 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1103 static void u132_hcd_enumeration_empty_recv(void *data, struct urb *urb,
1104 u8 *buf, int len, int toggle_bits, int error_count, int condition_code,
1105 int repeat_number, int halted, int skipped, int actual, int non_null)
1107 struct u132_endp *endp = data;
1108 struct u132 *u132 = endp->u132;
1109 u8 address = u132->addr[endp->usb_addr].address;
1110 struct u132_udev *udev = &u132->udev[address];
1111 down(&u132->scheduler_lock);
1112 if (u132->going > 1) {
1113 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1115 up(&u132->scheduler_lock);
1116 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1118 } else if (endp->dequeueing) {
1119 endp->dequeueing = 0;
1120 up(&u132->scheduler_lock);
1121 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1123 } else if (u132->going > 0) {
1124 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1125 "%p status=%d\n", urb, urb->status);
1126 up(&u132->scheduler_lock);
1127 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1129 } else if (urb->status == -EINPROGRESS) {
1130 u132->addr[0].address = 0;
1131 endp->usb_addr = udev->usb_addr;
1132 up(&u132->scheduler_lock);
1133 u132_hcd_giveback_urb(u132, endp, urb, 0);
1136 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1137 "s=%d\n", urb, urb->status);
1138 up(&u132->scheduler_lock);
1139 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1144 static void u132_hcd_enumeration_address_sent(void *data, struct urb *urb,
1145 u8 *buf, int len, int toggle_bits, int error_count, int condition_code,
1146 int repeat_number, int halted, int skipped, int actual, int non_null)
1148 struct u132_endp *endp = data;
1149 struct u132 *u132 = endp->u132;
1150 down(&u132->scheduler_lock);
1151 if (u132->going > 1) {
1152 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1154 up(&u132->scheduler_lock);
1155 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1157 } else if (endp->dequeueing) {
1158 endp->dequeueing = 0;
1159 up(&u132->scheduler_lock);
1160 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1162 } else if (u132->going > 0) {
1163 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1164 "%p status=%d\n", urb, urb->status);
1165 up(&u132->scheduler_lock);
1166 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1168 } else if (urb->status == -EINPROGRESS) {
1170 struct u132_ring *ring = endp->ring;
1171 up(&u132->scheduler_lock);
1172 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1173 ring->number, endp, urb, 0, endp->usb_endp, 0,
1174 u132_hcd_enumeration_empty_recv);
1177 u132_hcd_giveback_urb(u132, endp, urb, retval);
1180 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1181 "s=%d\n", urb, urb->status);
1182 up(&u132->scheduler_lock);
1183 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1188 static void u132_hcd_initial_empty_sent(void *data, struct urb *urb, u8 *buf,
1189 int len, int toggle_bits, int error_count, int condition_code,
1190 int repeat_number, int halted, int skipped, int actual, int non_null)
1192 struct u132_endp *endp = data;
1193 struct u132 *u132 = endp->u132;
1194 down(&u132->scheduler_lock);
1195 if (u132->going > 1) {
1196 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1198 up(&u132->scheduler_lock);
1199 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1201 } else if (endp->dequeueing) {
1202 endp->dequeueing = 0;
1203 up(&u132->scheduler_lock);
1204 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1206 } else if (u132->going > 0) {
1207 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1208 "%p status=%d\n", urb, urb->status);
1209 up(&u132->scheduler_lock);
1210 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1212 } else if (urb->status == -EINPROGRESS) {
1213 up(&u132->scheduler_lock);
1214 u132_hcd_giveback_urb(u132, endp, urb, 0);
1217 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1218 "s=%d\n", urb, urb->status);
1219 up(&u132->scheduler_lock);
1220 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1225 static void u132_hcd_initial_input_recv(void *data, struct urb *urb, u8 *buf,
1226 int len, int toggle_bits, int error_count, int condition_code,
1227 int repeat_number, int halted, int skipped, int actual, int non_null)
1229 struct u132_endp *endp = data;
1230 struct u132 *u132 = endp->u132;
1231 u8 address = u132->addr[endp->usb_addr].address;
1232 down(&u132->scheduler_lock);
1233 if (u132->going > 1) {
1234 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1236 up(&u132->scheduler_lock);
1237 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1239 } else if (endp->dequeueing) {
1240 endp->dequeueing = 0;
1241 up(&u132->scheduler_lock);
1242 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1244 } else if (u132->going > 0) {
1245 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1246 "%p status=%d\n", urb, urb->status);
1247 up(&u132->scheduler_lock);
1248 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1250 } else if (urb->status == -EINPROGRESS) {
1252 struct u132_ring *ring = endp->ring;
1253 u8 *u = urb->transfer_buffer;
1259 urb->actual_length = len;
1260 up(&u132->scheduler_lock);
1261 retval = usb_ftdi_elan_edset_empty(u132->platform_dev,
1262 ring->number, endp, urb, address, endp->usb_endp, 0x3,
1263 u132_hcd_initial_empty_sent);
1266 u132_hcd_giveback_urb(u132, endp, urb, retval);
1269 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1270 "s=%d\n", urb, urb->status);
1271 up(&u132->scheduler_lock);
1272 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1277 static void u132_hcd_initial_setup_sent(void *data, struct urb *urb, u8 *buf,
1278 int len, int toggle_bits, int error_count, int condition_code,
1279 int repeat_number, int halted, int skipped, int actual, int non_null)
1281 struct u132_endp *endp = data;
1282 struct u132 *u132 = endp->u132;
1283 u8 address = u132->addr[endp->usb_addr].address;
1284 down(&u132->scheduler_lock);
1285 if (u132->going > 1) {
1286 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1288 up(&u132->scheduler_lock);
1289 u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1291 } else if (endp->dequeueing) {
1292 endp->dequeueing = 0;
1293 up(&u132->scheduler_lock);
1294 u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1296 } else if (u132->going > 0) {
1297 dev_err(&u132->platform_dev->dev, "device is being removed urb="
1298 "%p status=%d\n", urb, urb->status);
1299 up(&u132->scheduler_lock);
1300 u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1302 } else if (urb->status == -EINPROGRESS) {
1304 struct u132_ring *ring = endp->ring;
1305 up(&u132->scheduler_lock);
1306 retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1307 ring->number, endp, urb, address, endp->usb_endp, 0,
1308 u132_hcd_initial_input_recv);
1311 u132_hcd_giveback_urb(u132, endp, urb, retval);
1314 dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p statu"
1315 "s=%d\n", urb, urb->status);
1316 up(&u132->scheduler_lock);
1317 u132_hcd_giveback_urb(u132, endp, urb, urb->status);
1322 static void u132_hcd_ring_work_scheduler(void *data);
1323 static void u132_hcd_endp_work_scheduler(void *data);
1325 * this work function is only executed from the work queue
1328 static void u132_hcd_ring_work_scheduler(void *data)
1330 struct u132_ring *ring = data;
1331 struct u132 *u132 = ring->u132;
1332 down(&u132->scheduler_lock);
1334 up(&u132->scheduler_lock);
1335 u132_ring_put_kref(u132, ring);
1337 } else if (ring->curr_endp) {
1338 struct u132_endp *last_endp = ring->curr_endp;
1339 struct list_head *scan;
1340 struct list_head *head = &last_endp->endp_ring;
1341 unsigned long wakeup = 0;
1342 list_for_each(scan, head) {
1343 struct u132_endp *endp = list_entry(scan,
1344 struct u132_endp, endp_ring);
1345 if (endp->queue_next == endp->queue_last) {
1346 } else if ((endp->delayed == 0)
1347 || time_after_eq(jiffies, endp->jiffies)) {
1348 ring->curr_endp = endp;
1349 u132_endp_cancel_work(u132, last_endp);
1350 u132_endp_queue_work(u132, last_endp, 0);
1351 up(&u132->scheduler_lock);
1352 u132_ring_put_kref(u132, ring);
1355 unsigned long delta = endp->jiffies - jiffies;
1360 if (last_endp->queue_next == last_endp->queue_last) {
1361 } else if ((last_endp->delayed == 0) || time_after_eq(jiffies,
1362 last_endp->jiffies)) {
1363 u132_endp_cancel_work(u132, last_endp);
1364 u132_endp_queue_work(u132, last_endp, 0);
1365 up(&u132->scheduler_lock);
1366 u132_ring_put_kref(u132, ring);
1369 unsigned long delta = last_endp->jiffies - jiffies;
1374 u132_ring_requeue_work(u132, ring, wakeup);
1375 up(&u132->scheduler_lock);
1378 up(&u132->scheduler_lock);
1379 u132_ring_put_kref(u132, ring);
1383 up(&u132->scheduler_lock);
1384 u132_ring_put_kref(u132, ring);
1389 static void u132_hcd_endp_work_scheduler(void *data)
1391 struct u132_ring *ring;
1392 struct u132_endp *endp = data;
1393 struct u132 *u132 = endp->u132;
1394 down(&u132->scheduler_lock);
1396 if (endp->edset_flush) {
1397 endp->edset_flush = 0;
1398 if (endp->dequeueing)
1399 usb_ftdi_elan_edset_flush(u132->platform_dev,
1400 ring->number, endp);
1401 up(&u132->scheduler_lock);
1402 u132_endp_put_kref(u132, endp);
1404 } else if (endp->active) {
1405 up(&u132->scheduler_lock);
1406 u132_endp_put_kref(u132, endp);
1408 } else if (ring->in_use) {
1409 up(&u132->scheduler_lock);
1410 u132_endp_put_kref(u132, endp);
1412 } else if (endp->queue_next == endp->queue_last) {
1413 up(&u132->scheduler_lock);
1414 u132_endp_put_kref(u132, endp);
1416 } else if (endp->pipetype == PIPE_INTERRUPT) {
1417 u8 address = u132->addr[endp->usb_addr].address;
1419 up(&u132->scheduler_lock);
1420 u132_endp_put_kref(u132, endp);
1424 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1427 ring->curr_endp = endp;
1429 up(&u132->scheduler_lock);
1430 retval = edset_single(u132, ring, endp, urb, address,
1431 endp->toggle_bits, u132_hcd_interrupt_recv);
1434 u132_hcd_giveback_urb(u132, endp, urb, retval);
1437 } else if (endp->pipetype == PIPE_CONTROL) {
1438 u8 address = u132->addr[endp->usb_addr].address;
1440 up(&u132->scheduler_lock);
1441 u132_endp_put_kref(u132, endp);
1443 } else if (address == 0) {
1445 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1448 ring->curr_endp = endp;
1450 up(&u132->scheduler_lock);
1451 retval = edset_setup(u132, ring, endp, urb, address,
1452 0x2, u132_hcd_initial_setup_sent);
1455 u132_hcd_giveback_urb(u132, endp, urb, retval);
1457 } else if (endp->usb_addr == 0) {
1459 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1462 ring->curr_endp = endp;
1464 up(&u132->scheduler_lock);
1465 retval = edset_setup(u132, ring, endp, urb, 0, 0x2,
1466 u132_hcd_enumeration_address_sent);
1469 u132_hcd_giveback_urb(u132, endp, urb, retval);
1473 u8 address = u132->addr[endp->usb_addr].address;
1474 struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1477 ring->curr_endp = endp;
1479 up(&u132->scheduler_lock);
1480 retval = edset_setup(u132, ring, endp, urb, address,
1481 0x2, u132_hcd_configure_setup_sent);
1484 u132_hcd_giveback_urb(u132, endp, urb, retval);
1489 u8 address = u132->addr[endp->usb_addr].address;
1491 up(&u132->scheduler_lock);
1492 u132_endp_put_kref(u132, endp);
1496 struct urb *urb = endp->urb_list[
1497 ENDP_QUEUE_MASK & endp->queue_next];
1499 ring->curr_endp = endp;
1501 up(&u132->scheduler_lock);
1502 retval = edset_input(u132, ring, endp, urb,
1503 address, endp->toggle_bits,
1504 u132_hcd_bulk_input_recv);
1507 u132_hcd_giveback_urb(u132, endp, urb,
1511 } else { /* output pipe */
1512 u8 address = u132->addr[endp->usb_addr].address;
1514 up(&u132->scheduler_lock);
1515 u132_endp_put_kref(u132, endp);
1519 struct urb *urb = endp->urb_list[
1520 ENDP_QUEUE_MASK & endp->queue_next];
1522 ring->curr_endp = endp;
1524 up(&u132->scheduler_lock);
1525 retval = edset_output(u132, ring, endp, urb,
1526 address, endp->toggle_bits,
1527 u132_hcd_bulk_output_sent);
1530 u132_hcd_giveback_urb(u132, endp, urb,
1538 static void port_power(struct u132 *u132, int pn, int is_on)
1540 u132->port[pn].power = is_on;
1543 static void u132_power(struct u132 *u132, int is_on)
1545 struct usb_hcd *hcd = u132_to_hcd(u132)
1546 ; /* hub is inactive unless the port is powered */
1551 hcd->self.controller->power.power_state = PMSG_ON;
1554 hcd->state = HC_STATE_HALT;
1555 hcd->self.controller->power.power_state = PMSG_SUSPEND;
1559 static int u132_periodic_reinit(struct u132 *u132)
1562 u32 fi = u132->hc_fminterval & 0x03fff;
1565 retval = u132_read_pcimem(u132, fminterval, &fminterval);
1568 fit = fminterval & FIT;
1569 retval = u132_write_pcimem(u132, fminterval,
1570 (fit ^ FIT) | u132->hc_fminterval);
1573 retval = u132_write_pcimem(u132, periodicstart,
1574 ((9 *fi) / 10) & 0x3fff);
1580 static char *hcfs2string(int state)
1583 case OHCI_USB_RESET:
1585 case OHCI_USB_RESUME:
1588 return "operational";
1589 case OHCI_USB_SUSPEND:
1595 static int u132_usb_reset(struct u132 *u132)
1598 retval = u132_read_pcimem(u132, control, &u132->hc_control);
1601 u132->hc_control &= OHCI_CTRL_RWC;
1602 retval = u132_write_pcimem(u132, control, u132->hc_control);
1608 static int u132_init(struct u132 *u132)
1613 u132->next_statechange =
1614 jiffies; /* SMM owns the HC? not for long! */ {
1616 retval = u132_read_pcimem(u132, control, &control);
1619 if (control & OHCI_CTRL_IR) {
1621 retval = u132_write_pcimem(u132, intrenable,
1625 retval = u132_write_pcimem_byte(u132, cmdstatus,
1630 retval = u132_read_pcimem(u132, control,
1635 if (control & OHCI_CTRL_IR) {
1638 dev_err(&u132->platform_dev->dev, "USB "
1639 "HC takeover failed!(BIOS/SMM b"
1640 "ug) control=%08X\n", control);
1645 u132_usb_reset(u132);
1648 retval = u132_write_pcimem(u132, intrdisable, OHCI_INTR_MIE);
1651 retval = u132_read_pcimem(u132, control, &control);
1654 if (u132->num_ports == 0) {
1656 retval = u132_read_pcimem(u132, roothub.a, &rh_a);
1659 u132->num_ports = rh_a & RH_A_NDP;
1660 retval = read_roothub_info(u132);
1664 if (u132->num_ports > MAX_U132_PORTS) {
1671 /* Start an OHCI controller, set the BUS operational
1672 * resets USB and controller
1675 static int u132_run(struct u132 *u132)
1684 int mask = OHCI_INTR_INIT;
1685 int first = u132->hc_fminterval == 0;
1687 int reset_timeout = 30; /* ... allow extra time */
1691 retval = u132_read_pcimem(u132, fminterval, &temp);
1694 u132->hc_fminterval = temp & 0x3fff;
1695 if (u132->hc_fminterval != FI) {
1697 u132->hc_fminterval |= FSMP(u132->hc_fminterval) << 16;
1699 retval = u132_read_pcimem(u132, control, &u132->hc_control);
1702 dev_info(&u132->platform_dev->dev, "resetting from state '%s', control "
1703 "= %08X\n", hcfs2string(u132->hc_control & OHCI_CTRL_HCFS),
1705 switch (u132->hc_control & OHCI_CTRL_HCFS) {
1709 case OHCI_USB_SUSPEND:
1710 case OHCI_USB_RESUME:
1711 u132->hc_control &= OHCI_CTRL_RWC;
1712 u132->hc_control |= OHCI_USB_RESUME;
1716 u132->hc_control &= OHCI_CTRL_RWC;
1717 u132->hc_control |= OHCI_USB_RESET;
1721 retval = u132_write_pcimem(u132, control, u132->hc_control);
1724 retval = u132_read_pcimem(u132, control, &control);
1728 retval = u132_read_pcimem(u132, roothub.a, &roothub_a);
1731 if (!(roothub_a & RH_A_NPS)) {
1732 int temp; /* power down each port */
1733 for (temp = 0; temp < u132->num_ports; temp++) {
1734 retval = u132_write_pcimem(u132,
1735 roothub.portstatus[temp], RH_PS_LSDA);
1740 retval = u132_read_pcimem(u132, control, &control);
1743 retry:retval = u132_read_pcimem(u132, cmdstatus, &status);
1746 retval = u132_write_pcimem_byte(u132, cmdstatus, OHCI_HCR);
1750 retval = u132_read_pcimem(u132, cmdstatus, &status);
1753 if (0 != (status & OHCI_HCR)) {
1754 if (--reset_timeout == 0) {
1755 dev_err(&u132->platform_dev->dev, "USB HC reset"
1764 if (u132->flags & OHCI_QUIRK_INITRESET) {
1765 retval = u132_write_pcimem(u132, control, u132->hc_control);
1768 retval = u132_read_pcimem(u132, control, &control);
1772 retval = u132_write_pcimem(u132, ed_controlhead, 0x00000000);
1775 retval = u132_write_pcimem(u132, ed_bulkhead, 0x11000000);
1778 retval = u132_write_pcimem(u132, hcca, 0x00000000);
1781 retval = u132_periodic_reinit(u132);
1784 retval = u132_read_pcimem(u132, fminterval, &fminterval);
1787 retval = u132_read_pcimem(u132, periodicstart, &periodicstart);
1790 if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) {
1791 if (!(u132->flags & OHCI_QUIRK_INITRESET)) {
1792 u132->flags |= OHCI_QUIRK_INITRESET;
1795 dev_err(&u132->platform_dev->dev, "init err(%08x %04x)"
1796 "\n", fminterval, periodicstart);
1797 } /* start controller operations */
1798 u132->hc_control &= OHCI_CTRL_RWC;
1799 u132->hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER;
1800 retval = u132_write_pcimem(u132, control, u132->hc_control);
1803 retval = u132_write_pcimem_byte(u132, cmdstatus, OHCI_BLF);
1806 retval = u132_read_pcimem(u132, cmdstatus, &cmdstatus);
1809 retval = u132_read_pcimem(u132, control, &control);
1812 u132_to_hcd(u132)->state = HC_STATE_RUNNING;
1813 retval = u132_write_pcimem(u132, roothub.status, RH_HS_DRWE);
1816 retval = u132_write_pcimem(u132, intrstatus, mask);
1819 retval = u132_write_pcimem(u132, intrdisable,
1820 OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO |
1821 OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH |
1824 return retval; /* handle root hub init quirks ... */
1825 retval = u132_read_pcimem(u132, roothub.a, &roothub_a);
1828 roothub_a &= ~(RH_A_PSM | RH_A_OCPM);
1829 if (u132->flags & OHCI_QUIRK_SUPERIO) {
1830 roothub_a |= RH_A_NOCP;
1831 roothub_a &= ~(RH_A_POTPGT | RH_A_NPS);
1832 retval = u132_write_pcimem(u132, roothub.a, roothub_a);
1835 } else if ((u132->flags & OHCI_QUIRK_AMD756) || distrust_firmware) {
1836 roothub_a |= RH_A_NPS;
1837 retval = u132_write_pcimem(u132, roothub.a, roothub_a);
1841 retval = u132_write_pcimem(u132, roothub.status, RH_HS_LPSC);
1844 retval = u132_write_pcimem(u132, roothub.b,
1845 (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM);
1848 retval = u132_read_pcimem(u132, control, &control);
1851 mdelay((roothub_a >> 23) & 0x1fe);
1852 u132_to_hcd(u132)->state = HC_STATE_RUNNING;
1856 static void u132_hcd_stop(struct usb_hcd *hcd)
1858 struct u132 *u132 = hcd_to_u132(hcd);
1859 if (u132->going > 1) {
1860 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1862 } else if (u132->going > 0) {
1863 dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
1866 down(&u132->sw_lock);
1868 u132_power(u132, 0);
1873 static int u132_hcd_start(struct usb_hcd *hcd)
1875 struct u132 *u132 = hcd_to_u132(hcd);
1876 if (u132->going > 1) {
1877 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1880 } else if (u132->going > 0) {
1881 dev_err(&u132->platform_dev->dev, "device is being removed\n");
1883 } else if (hcd->self.controller) {
1885 struct platform_device *pdev =
1886 to_platform_device(hcd->self.controller);
1887 u16 vendor = ((struct u132_platform_data *)
1888 (pdev->dev.platform_data))->vendor;
1889 u16 device = ((struct u132_platform_data *)
1890 (pdev->dev.platform_data))->device;
1891 down(&u132->sw_lock);
1893 if (vendor == PCI_VENDOR_ID_AMD && device == 0x740c) {
1894 u132->flags = OHCI_QUIRK_AMD756;
1895 } else if (vendor == PCI_VENDOR_ID_OPTI && device == 0xc861) {
1896 dev_err(&u132->platform_dev->dev, "WARNING: OPTi workar"
1897 "ounds unavailable\n");
1898 } else if (vendor == PCI_VENDOR_ID_COMPAQ && device == 0xa0f8)
1899 u132->flags |= OHCI_QUIRK_ZFMICRO;
1900 retval = u132_run(u132);
1909 dev_err(&u132->platform_dev->dev, "platform_device missing\n");
1914 static int u132_hcd_reset(struct usb_hcd *hcd)
1916 struct u132 *u132 = hcd_to_u132(hcd);
1917 if (u132->going > 1) {
1918 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1921 } else if (u132->going > 0) {
1922 dev_err(&u132->platform_dev->dev, "device is being removed\n");
1926 down(&u132->sw_lock);
1927 retval = u132_init(u132);
1937 static int create_endpoint_and_queue_int(struct u132 *u132,
1938 struct u132_udev *udev, struct usb_host_endpoint *hep, struct urb *urb,
1939 struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
1942 struct u132_ring *ring;
1944 u8 endp_number = ++u132->num_endpoints;
1945 struct u132_endp *endp = hep->hcpriv = u132->endp[endp_number - 1] =
1946 kmalloc(sizeof(struct u132_endp), mem_flags);
1950 INIT_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler, (void *)endp);
1951 spin_lock_init(&endp->queue_lock.slock);
1952 INIT_LIST_HEAD(&endp->urb_more);
1953 ring = endp->ring = &u132->ring[0];
1954 if (ring->curr_endp) {
1955 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
1957 INIT_LIST_HEAD(&endp->endp_ring);
1958 ring->curr_endp = endp;
1961 endp->dequeueing = 0;
1962 endp->edset_flush = 0;
1965 endp->endp_number = endp_number;
1968 endp->pipetype = usb_pipetype(urb->pipe);
1969 u132_endp_init_kref(u132, endp);
1970 if (usb_pipein(urb->pipe)) {
1971 endp->toggle_bits = 0x2;
1972 usb_settoggle(udev->usb_device, usb_endp, 0, 0);
1975 udev->endp_number_in[usb_endp] = endp_number;
1976 u132_udev_get_kref(u132, udev);
1978 endp->toggle_bits = 0x2;
1979 usb_settoggle(udev->usb_device, usb_endp, 1, 0);
1982 udev->endp_number_out[usb_endp] = endp_number;
1983 u132_udev_get_kref(u132, udev);
1986 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
1988 endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
1989 endp->udev_number = address;
1990 endp->usb_addr = usb_addr;
1991 endp->usb_endp = usb_endp;
1992 endp->queue_size = 1;
1993 endp->queue_last = 0;
1994 endp->queue_next = 0;
1995 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
1996 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1997 u132_endp_queue_work(u132, endp, msecs_to_jiffies(urb->interval));
2001 static int queue_int_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
2002 struct usb_host_endpoint *hep, struct urb *urb,
2003 struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2004 u8 usb_endp, u8 address)
2008 endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
2009 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2010 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2012 struct u132_urbq *urbq = kmalloc(sizeof(struct u132_urbq),
2015 endp->queue_size -= 1;
2018 list_add_tail(&urbq->urb_more, &endp->urb_more);
2025 static int create_endpoint_and_queue_bulk(struct u132 *u132,
2026 struct u132_udev *udev, struct usb_host_endpoint *hep, struct urb *urb,
2027 struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
2031 struct u132_ring *ring;
2033 u8 endp_number = ++u132->num_endpoints;
2034 struct u132_endp *endp = hep->hcpriv = u132->endp[endp_number - 1] =
2035 kmalloc(sizeof(struct u132_endp), mem_flags);
2039 INIT_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler, (void *)endp);
2040 spin_lock_init(&endp->queue_lock.slock);
2041 INIT_LIST_HEAD(&endp->urb_more);
2042 endp->dequeueing = 0;
2043 endp->edset_flush = 0;
2046 endp->endp_number = endp_number;
2049 endp->pipetype = usb_pipetype(urb->pipe);
2050 u132_endp_init_kref(u132, endp);
2051 if (usb_pipein(urb->pipe)) {
2052 endp->toggle_bits = 0x2;
2053 usb_settoggle(udev->usb_device, usb_endp, 0, 0);
2057 udev->endp_number_in[usb_endp] = endp_number;
2058 u132_udev_get_kref(u132, udev);
2060 endp->toggle_bits = 0x2;
2061 usb_settoggle(udev->usb_device, usb_endp, 1, 0);
2065 udev->endp_number_out[usb_endp] = endp_number;
2066 u132_udev_get_kref(u132, udev);
2068 ring = endp->ring = &u132->ring[ring_number - 1];
2069 if (ring->curr_endp) {
2070 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
2072 INIT_LIST_HEAD(&endp->endp_ring);
2073 ring->curr_endp = endp;
2077 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2078 endp->udev_number = address;
2079 endp->usb_addr = usb_addr;
2080 endp->usb_endp = usb_endp;
2081 endp->queue_size = 1;
2082 endp->queue_last = 0;
2083 endp->queue_next = 0;
2084 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2085 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2086 u132_endp_queue_work(u132, endp, 0);
2090 static int queue_bulk_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
2091 struct usb_host_endpoint *hep, struct urb *urb,
2092 struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2093 u8 usb_endp, u8 address)
2096 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2097 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2099 struct u132_urbq *urbq = kmalloc(sizeof(struct u132_urbq),
2102 endp->queue_size -= 1;
2105 list_add_tail(&urbq->urb_more, &endp->urb_more);
2112 static int create_endpoint_and_queue_control(struct u132 *u132,
2113 struct usb_host_endpoint *hep, struct urb *urb,
2114 struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp,
2117 struct u132_ring *ring;
2118 u8 endp_number = ++u132->num_endpoints;
2119 struct u132_endp *endp = hep->hcpriv = u132->endp[endp_number - 1] =
2120 kmalloc(sizeof(struct u132_endp), mem_flags);
2124 INIT_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler, (void *)endp);
2125 spin_lock_init(&endp->queue_lock.slock);
2126 INIT_LIST_HEAD(&endp->urb_more);
2127 ring = endp->ring = &u132->ring[0];
2128 if (ring->curr_endp) {
2129 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
2131 INIT_LIST_HEAD(&endp->endp_ring);
2132 ring->curr_endp = endp;
2135 endp->dequeueing = 0;
2136 endp->edset_flush = 0;
2139 endp->endp_number = endp_number;
2142 u132_endp_init_kref(u132, endp);
2143 u132_endp_get_kref(u132, endp);
2144 if (usb_addr == 0) {
2146 u8 address = u132->addr[usb_addr].address;
2147 struct u132_udev *udev = &u132->udev[address];
2148 endp->udev_number = address;
2149 endp->usb_addr = usb_addr;
2150 endp->usb_endp = usb_endp;
2153 endp->pipetype = usb_pipetype(urb->pipe);
2154 u132_udev_init_kref(u132, udev);
2155 u132_udev_get_kref(u132, udev);
2156 udev->endp_number_in[usb_endp] = endp_number;
2157 udev->endp_number_out[usb_endp] = endp_number;
2159 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2160 endp->queue_size = 1;
2161 endp->queue_last = 0;
2162 endp->queue_next = 0;
2163 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2164 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2165 u132_endp_queue_work(u132, endp, 0);
2167 } else { /*(usb_addr > 0) */
2169 u8 address = u132->addr[usb_addr].address;
2170 struct u132_udev *udev = &u132->udev[address];
2171 endp->udev_number = address;
2172 endp->usb_addr = usb_addr;
2173 endp->usb_endp = usb_endp;
2176 endp->pipetype = usb_pipetype(urb->pipe);
2177 u132_udev_get_kref(u132, udev);
2178 udev->enumeration = 2;
2179 udev->endp_number_in[usb_endp] = endp_number;
2180 udev->endp_number_out[usb_endp] = endp_number;
2182 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2183 endp->queue_size = 1;
2184 endp->queue_last = 0;
2185 endp->queue_next = 0;
2186 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2187 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2188 u132_endp_queue_work(u132, endp, 0);
2193 static int queue_control_on_old_endpoint(struct u132 *u132,
2194 struct usb_host_endpoint *hep, struct urb *urb,
2195 struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2198 if (usb_addr == 0) {
2199 if (usb_pipein(urb->pipe)) {
2201 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2202 endp->urb_list[ENDP_QUEUE_MASK &
2203 endp->queue_last++] = urb;
2205 struct u132_urbq *urbq =
2206 kmalloc(sizeof(struct u132_urbq),
2209 endp->queue_size -= 1;
2212 list_add_tail(&urbq->urb_more,
2218 } else { /* usb_pipeout(urb->pipe) */
2219 struct u132_addr *addr = &u132->addr[usb_dev->devnum];
2220 int I = MAX_U132_UDEVS;
2223 struct u132_udev *udev = &u132->udev[++i];
2224 if (udev->usb_device) {
2227 udev->enumeration = 1;
2228 u132->addr[0].address = i;
2229 endp->udev_number = i;
2230 udev->udev_number = i;
2231 udev->usb_addr = usb_dev->devnum;
2232 u132_udev_init_kref(u132, udev);
2233 udev->endp_number_in[usb_endp] =
2235 u132_udev_get_kref(u132, udev);
2236 udev->endp_number_out[usb_endp] =
2238 udev->usb_device = usb_dev;
2239 ((u8 *) (urb->setup_packet))[2] =
2241 u132_udev_get_kref(u132, udev);
2246 dev_err(&u132->platform_dev->dev, "run out of d"
2251 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2252 endp->urb_list[ENDP_QUEUE_MASK &
2253 endp->queue_last++] = urb;
2255 struct u132_urbq *urbq =
2256 kmalloc(sizeof(struct u132_urbq),
2259 endp->queue_size -= 1;
2262 list_add_tail(&urbq->urb_more,
2269 } else { /*(usb_addr > 0) */
2270 u8 address = u132->addr[usb_addr].address;
2271 struct u132_udev *udev = &u132->udev[address];
2273 if (udev->enumeration == 2) {
2275 udev->enumeration = 2;
2276 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2277 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
2280 struct u132_urbq *urbq =
2281 kmalloc(sizeof(struct u132_urbq), GFP_ATOMIC);
2283 endp->queue_size -= 1;
2286 list_add_tail(&urbq->urb_more, &endp->urb_more);
2294 static int u132_urb_enqueue(struct usb_hcd *hcd, struct usb_host_endpoint *hep,
2295 struct urb *urb, gfp_t mem_flags)
2297 struct u132 *u132 = hcd_to_u132(hcd);
2298 if (irqs_disabled()) {
2299 if (__GFP_WAIT & mem_flags) {
2300 printk(KERN_ERR "invalid context for function that migh"
2305 if (u132->going > 1) {
2306 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2309 } else if (u132->going > 0) {
2310 dev_err(&u132->platform_dev->dev, "device is being removed urb="
2311 "%p status=%d\n", urb, urb->status);
2314 u8 usb_addr = usb_pipedevice(urb->pipe);
2315 u8 usb_endp = usb_pipeendpoint(urb->pipe);
2316 struct usb_device *usb_dev = urb->dev;
2317 if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
2318 u8 address = u132->addr[usb_addr].address;
2319 struct u132_udev *udev = &u132->udev[address];
2320 struct u132_endp *endp = hep->hcpriv;
2321 urb->actual_length = 0;
2325 spin_lock_irqsave(&endp->queue_lock.slock,
2327 retval = queue_int_on_old_endpoint(u132, udev,
2328 hep, urb, usb_dev, endp, usb_addr,
2330 spin_unlock_irqrestore(&endp->queue_lock.slock,
2335 u132_endp_queue_work(u132, endp,
2336 msecs_to_jiffies(urb->interval))
2340 } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2342 } else { /*(endp == NULL) */
2343 return create_endpoint_and_queue_int(u132, udev,
2344 hep, urb, usb_dev, usb_addr, usb_endp,
2345 address, mem_flags);
2347 } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
2348 dev_err(&u132->platform_dev->dev, "the hardware does no"
2349 "t support PIPE_ISOCHRONOUS\n");
2351 } else if (usb_pipetype(urb->pipe) == PIPE_BULK) {
2352 u8 address = u132->addr[usb_addr].address;
2353 struct u132_udev *udev = &u132->udev[address];
2354 struct u132_endp *endp = hep->hcpriv;
2355 urb->actual_length = 0;
2359 spin_lock_irqsave(&endp->queue_lock.slock,
2361 retval = queue_bulk_on_old_endpoint(u132, udev,
2362 hep, urb, usb_dev, endp, usb_addr,
2364 spin_unlock_irqrestore(&endp->queue_lock.slock,
2369 u132_endp_queue_work(u132, endp, 0);
2372 } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2375 return create_endpoint_and_queue_bulk(u132,
2376 udev, hep, urb, usb_dev, usb_addr,
2377 usb_endp, address, mem_flags);
2379 struct u132_endp *endp = hep->hcpriv;
2381 u8 *b = urb->setup_packet;
2383 char data[30 *3 + 4];
2385 int m = (sizeof(data) - 1) / 3;
2388 while (urb_size-- > 0) {
2390 } else if (i++ < m) {
2391 int w = sprintf(d, " %02X", *b++);
2395 d += sprintf(d, " ..");
2400 spin_lock_irqsave(&endp->queue_lock.slock,
2402 retval = queue_control_on_old_endpoint(u132,
2403 hep, urb, usb_dev, endp, usb_addr,
2405 spin_unlock_irqrestore(&endp->queue_lock.slock,
2410 u132_endp_queue_work(u132, endp, 0);
2413 } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2416 return create_endpoint_and_queue_control(u132,
2417 hep, urb, usb_dev, usb_addr, usb_endp,
2423 static int dequeue_from_overflow_chain(struct u132 *u132,
2424 struct u132_endp *endp, struct urb *urb)
2426 struct list_head *scan;
2427 struct list_head *head = &endp->urb_more;
2428 list_for_each(scan, head) {
2429 struct u132_urbq *urbq = list_entry(scan, struct u132_urbq,
2431 if (urbq->urb == urb) {
2432 struct usb_hcd *hcd = u132_to_hcd(u132);
2434 endp->queue_size -= 1;
2435 urb->error_count = 0;
2437 usb_hcd_giveback_urb(hcd, urb);
2442 dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]=%p ring"
2443 "[%d] %c%c usb_endp=%d usb_addr=%d size=%d next=%04X last=%04X"
2444 "\n", urb, endp->endp_number, endp, endp->ring->number,
2445 endp->input ? 'I' : ' ', endp->output ? 'O' : ' ',
2446 endp->usb_endp, endp->usb_addr, endp->queue_size,
2447 endp->queue_next, endp->queue_last);
2451 static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
2455 spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2456 if (endp->queue_size == 0) {
2457 dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]"
2458 "=%p ring[%d] %c%c usb_endp=%d usb_addr=%d\n", urb,
2459 endp->endp_number, endp, endp->ring->number,
2460 endp->input ? 'I' : ' ', endp->output ? 'O' : ' ',
2461 endp->usb_endp, endp->usb_addr);
2462 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2465 if (urb == endp->urb_list[ENDP_QUEUE_MASK & endp->queue_next]) {
2467 endp->dequeueing = 1;
2468 endp->edset_flush = 1;
2469 u132_endp_queue_work(u132, endp, 0);
2470 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2474 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2475 u132_hcd_abandon_urb(u132, endp, urb, urb->status);
2480 u16 queue_size = endp->queue_size;
2481 u16 queue_scan = endp->queue_next;
2482 struct urb **urb_slot = NULL;
2483 while (++queue_list < ENDP_QUEUE_SIZE && --queue_size > 0) {
2484 if (urb == endp->urb_list[ENDP_QUEUE_MASK &
2486 urb_slot = &endp->urb_list[ENDP_QUEUE_MASK &
2492 while (++queue_list < ENDP_QUEUE_SIZE && --queue_size > 0) {
2493 *urb_slot = endp->urb_list[ENDP_QUEUE_MASK &
2495 urb_slot = &endp->urb_list[ENDP_QUEUE_MASK &
2499 struct usb_hcd *hcd = u132_to_hcd(u132);
2500 endp->queue_size -= 1;
2501 if (list_empty(&endp->urb_more)) {
2502 spin_unlock_irqrestore(&endp->queue_lock.slock,
2505 struct list_head *next = endp->urb_more.next;
2506 struct u132_urbq *urbq = list_entry(next,
2507 struct u132_urbq, urb_more);
2509 *urb_slot = urbq->urb;
2510 spin_unlock_irqrestore(&endp->queue_lock.slock,
2513 } urb->error_count = 0;
2515 usb_hcd_giveback_urb(hcd, urb);
2517 } else if (list_empty(&endp->urb_more)) {
2518 dev_err(&u132->platform_dev->dev, "urb=%p not found in "
2519 "endp[%d]=%p ring[%d] %c%c usb_endp=%d usb_addr"
2520 "=%d size=%d next=%04X last=%04X\n", urb,
2521 endp->endp_number, endp, endp->ring->number,
2522 endp->input ? 'I' : ' ',
2523 endp->output ? 'O' : ' ', endp->usb_endp,
2524 endp->usb_addr, endp->queue_size,
2525 endp->queue_next, endp->queue_last);
2526 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2529 int retval = dequeue_from_overflow_chain(u132, endp,
2531 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2537 static int u132_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
2539 struct u132 *u132 = hcd_to_u132(hcd);
2540 if (u132->going > 2) {
2541 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2545 u8 usb_addr = usb_pipedevice(urb->pipe);
2546 u8 usb_endp = usb_pipeendpoint(urb->pipe);
2547 u8 address = u132->addr[usb_addr].address;
2548 struct u132_udev *udev = &u132->udev[address];
2549 if (usb_pipein(urb->pipe)) {
2550 u8 endp_number = udev->endp_number_in[usb_endp];
2551 struct u132_endp *endp = u132->endp[endp_number - 1];
2552 return u132_endp_urb_dequeue(u132, endp, urb);
2554 u8 endp_number = udev->endp_number_out[usb_endp];
2555 struct u132_endp *endp = u132->endp[endp_number - 1];
2556 return u132_endp_urb_dequeue(u132, endp, urb);
2561 static void u132_endpoint_disable(struct usb_hcd *hcd,
2562 struct usb_host_endpoint *hep)
2564 struct u132 *u132 = hcd_to_u132(hcd);
2565 if (u132->going > 2) {
2566 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2569 struct u132_endp *endp = hep->hcpriv;
2571 u132_endp_put_kref(u132, endp);
2575 static int u132_get_frame(struct usb_hcd *hcd)
2577 struct u132 *u132 = hcd_to_u132(hcd);
2578 if (u132->going > 1) {
2579 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2582 } else if (u132->going > 0) {
2583 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2587 dev_err(&u132->platform_dev->dev, "TODO: u132_get_frame\n");
2593 static int u132_roothub_descriptor(struct u132 *u132,
2594 struct usb_hub_descriptor *desc)
2600 retval = u132_read_pcimem(u132, roothub.a, &rh_a);
2603 desc->bDescriptorType = 0x29;
2604 desc->bPwrOn2PwrGood = (rh_a & RH_A_POTPGT) >> 24;
2605 desc->bHubContrCurrent = 0;
2606 desc->bNbrPorts = u132->num_ports;
2607 temp = 1 + (u132->num_ports / 8);
2608 desc->bDescLength = 7 + 2 *temp;
2610 if (rh_a & RH_A_NPS)
2612 if (rh_a & RH_A_PSM)
2614 if (rh_a & RH_A_NOCP) {
2616 } else if (rh_a & RH_A_OCPM)
2618 desc->wHubCharacteristics = cpu_to_le16(temp);
2619 retval = u132_read_pcimem(u132, roothub.b, &rh_b);
2622 memset(desc->bitmap, 0xff, sizeof(desc->bitmap));
2623 desc->bitmap[0] = rh_b & RH_B_DR;
2624 if (u132->num_ports > 7) {
2625 desc->bitmap[1] = (rh_b & RH_B_DR) >> 8;
2626 desc->bitmap[2] = 0xff;
2628 desc->bitmap[1] = 0xff;
2632 static int u132_roothub_status(struct u132 *u132, __le32 *desc)
2635 int ret_status = u132_read_pcimem(u132, roothub.status, &rh_status);
2636 *desc = cpu_to_le32(rh_status);
2640 static int u132_roothub_portstatus(struct u132 *u132, __le32 *desc, u16 wIndex)
2642 if (wIndex == 0 || wIndex > u132->num_ports) {
2645 int port = wIndex - 1;
2646 u32 rh_portstatus = -1;
2647 int ret_portstatus = u132_read_pcimem(u132,
2648 roothub.portstatus[port], &rh_portstatus);
2649 *desc = cpu_to_le32(rh_portstatus);
2650 if (*(u16 *) (desc + 2)) {
2651 dev_info(&u132->platform_dev->dev, "Port %d Status Chan"
2652 "ge = %08X\n", port, *desc);
2654 return ret_portstatus;
2659 /* this timer value might be vendor-specific ... */
2660 #define PORT_RESET_HW_MSEC 10
2661 #define PORT_RESET_MSEC 10
2662 /* wrap-aware logic morphed from <linux/jiffies.h> */
2663 #define tick_before(t1, t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
2664 static int u132_roothub_portreset(struct u132 *u132, int port_index)
2670 retval = u132_read_pcimem(u132, fmnumber, &fmnumber);
2674 reset_done = now + PORT_RESET_MSEC;
2678 retval = u132_read_pcimem(u132,
2679 roothub.portstatus[port_index], &portstat);
2682 if (RH_PS_PRS & portstat) {
2686 } while (tick_before(now, reset_done));
2687 if (RH_PS_PRS & portstat)
2689 if (RH_PS_CCS & portstat) {
2690 if (RH_PS_PRSC & portstat) {
2691 retval = u132_write_pcimem(u132,
2692 roothub.portstatus[port_index],
2698 break; /* start the next reset,
2699 sleep till it's probably done */
2700 retval = u132_write_pcimem(u132, roothub.portstatus[port_index],
2704 msleep(PORT_RESET_HW_MSEC);
2705 retval = u132_read_pcimem(u132, fmnumber, &fmnumber);
2709 } while (tick_before(now, reset_done));
2713 static int u132_roothub_setportfeature(struct u132 *u132, u16 wValue,
2716 if (wIndex == 0 || wIndex > u132->num_ports) {
2720 int port_index = wIndex - 1;
2721 struct u132_port *port = &u132->port[port_index];
2722 port->Status &= ~(1 << wValue);
2724 case USB_PORT_FEAT_SUSPEND:
2725 retval = u132_write_pcimem(u132,
2726 roothub.portstatus[port_index], RH_PS_PSS);
2730 case USB_PORT_FEAT_POWER:
2731 retval = u132_write_pcimem(u132,
2732 roothub.portstatus[port_index], RH_PS_PPS);
2736 case USB_PORT_FEAT_RESET:
2737 retval = u132_roothub_portreset(u132, port_index);
2747 static int u132_roothub_clearportfeature(struct u132 *u132, u16 wValue,
2750 if (wIndex == 0 || wIndex > u132->num_ports) {
2753 int port_index = wIndex - 1;
2756 struct u132_port *port = &u132->port[port_index];
2757 port->Status &= ~(1 << wValue);
2759 case USB_PORT_FEAT_ENABLE:
2762 case USB_PORT_FEAT_C_ENABLE:
2765 case USB_PORT_FEAT_SUSPEND:
2767 if ((u132->hc_control & OHCI_CTRL_HCFS)
2769 dev_err(&u132->platform_dev->dev, "TODO resume_"
2773 case USB_PORT_FEAT_C_SUSPEND:
2776 case USB_PORT_FEAT_POWER:
2779 case USB_PORT_FEAT_C_CONNECTION:
2782 case USB_PORT_FEAT_C_OVER_CURRENT:
2785 case USB_PORT_FEAT_C_RESET:
2791 retval = u132_write_pcimem(u132, roothub.portstatus[port_index],
2800 /* the virtual root hub timer IRQ checks for hub status*/
2801 static int u132_hub_status_data(struct usb_hcd *hcd, char *buf)
2803 struct u132 *u132 = hcd_to_u132(hcd);
2804 if (u132->going > 1) {
2805 dev_err(&u132->platform_dev->dev, "device hcd=%p has been remov"
2806 "ed %d\n", hcd, u132->going);
2808 } else if (u132->going > 0) {
2809 dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
2814 int i, changed = 0, length = 1;
2815 if (u132->flags & OHCI_QUIRK_AMD756) {
2816 if ((u132->hc_roothub_a & RH_A_NDP) > MAX_ROOT_PORTS) {
2817 dev_err(&u132->platform_dev->dev, "bogus NDP, r"
2818 "ereads as NDP=%d\n",
2819 u132->hc_roothub_a & RH_A_NDP);
2823 if (u132->hc_roothub_status & (RH_HS_LPSC | RH_HS_OCIC)) {
2824 buf[0] = changed = 1;
2827 if (u132->num_ports > 7) {
2831 for (i = 0; i < u132->num_ports; i++) {
2832 if (u132->hc_roothub_portstatus[i] & (RH_PS_CSC |
2833 RH_PS_PESC | RH_PS_PSSC | RH_PS_OCIC |
2837 buf[0] |= 1 << (i + 1);
2839 buf[1] |= 1 << (i - 7);
2842 if (!(u132->hc_roothub_portstatus[i] & RH_PS_CCS)) {
2845 if ((u132->hc_roothub_portstatus[i] & RH_PS_PSS)) {
2849 done:return changed ? length : 0;
2853 static int u132_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
2854 u16 wIndex, char *buf, u16 wLength)
2856 struct u132 *u132 = hcd_to_u132(hcd);
2857 if (u132->going > 1) {
2858 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2861 } else if (u132->going > 0) {
2862 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2866 down(&u132->sw_lock);
2868 case ClearHubFeature:
2870 case C_HUB_OVER_CURRENT:
2871 case C_HUB_LOCAL_POWER:
2879 case C_HUB_OVER_CURRENT:
2880 case C_HUB_LOCAL_POWER:
2886 case ClearPortFeature:{
2887 retval = u132_roothub_clearportfeature(u132,
2893 case GetHubDescriptor:{
2894 retval = u132_roothub_descriptor(u132,
2895 (struct usb_hub_descriptor *)buf);
2901 retval = u132_roothub_status(u132,
2907 case GetPortStatus:{
2908 retval = u132_roothub_portstatus(u132,
2909 (__le32 *) buf, wIndex);
2914 case SetPortFeature:{
2915 retval = u132_roothub_setportfeature(u132,
2923 error:u132_disable(u132);
2926 stall:retval = -EPIPE;
2934 static int u132_start_port_reset(struct usb_hcd *hcd, unsigned port_num)
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"
2941 } else if (u132->going > 0) {
2942 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2948 static void u132_hub_irq_enable(struct usb_hcd *hcd)
2950 struct u132 *u132 = hcd_to_u132(hcd);
2951 if (u132->going > 1) {
2952 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2954 } else if (u132->going > 0)
2955 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2960 static int u132_hcd_suspend(struct usb_hcd *hcd, pm_message_t message)
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"
2967 } else if (u132->going > 0) {
2968 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2974 static int u132_hcd_resume(struct usb_hcd *hcd)
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"
2981 } else if (u132->going > 0) {
2982 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2988 static int u132_bus_suspend(struct usb_hcd *hcd)
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"
2995 } else if (u132->going > 0) {
2996 dev_err(&u132->platform_dev->dev, "device is being removed\n");
3002 static int u132_bus_resume(struct usb_hcd *hcd)
3004 struct u132 *u132 = hcd_to_u132(hcd);
3005 if (u132->going > 1) {
3006 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3009 } else if (u132->going > 0) {
3010 dev_err(&u132->platform_dev->dev, "device is being removed\n");
3017 #define u132_hcd_suspend NULL
3018 #define u132_hcd_resume NULL
3019 #define u132_bus_suspend NULL
3020 #define u132_bus_resume NULL
3022 static struct hc_driver u132_hc_driver = {
3023 .description = hcd_name,
3024 .hcd_priv_size = sizeof(struct u132),
3026 .flags = HCD_USB11 | HCD_MEMORY,
3027 .reset = u132_hcd_reset,
3028 .start = u132_hcd_start,
3029 .suspend = u132_hcd_suspend,
3030 .resume = u132_hcd_resume,
3031 .stop = u132_hcd_stop,
3032 .urb_enqueue = u132_urb_enqueue,
3033 .urb_dequeue = u132_urb_dequeue,
3034 .endpoint_disable = u132_endpoint_disable,
3035 .get_frame_number = u132_get_frame,
3036 .hub_status_data = u132_hub_status_data,
3037 .hub_control = u132_hub_control,
3038 .bus_suspend = u132_bus_suspend,
3039 .bus_resume = u132_bus_resume,
3040 .start_port_reset = u132_start_port_reset,
3041 .hub_irq_enable = u132_hub_irq_enable,
3045 * This function may be called by the USB core whilst the "usb_all_devices_rwsem"
3046 * is held for writing, thus this module must not call usb_remove_hcd()
3047 * synchronously - but instead should immediately stop activity to the
3048 * device and ansynchronously call usb_remove_hcd()
3050 static int __devexit u132_remove(struct platform_device *pdev)
3052 struct usb_hcd *hcd = platform_get_drvdata(pdev);
3054 struct u132 *u132 = hcd_to_u132(hcd);
3056 if (u132->going++ > 1) {
3059 int rings = MAX_U132_RINGS;
3060 int endps = MAX_U132_ENDPS;
3062 down(&u132->sw_lock);
3063 u132_monitor_cancel_work(u132);
3064 while (rings-- > 0) {
3065 struct u132_ring *ring = &u132->ring[rings];
3066 u132_ring_cancel_work(u132, ring);
3067 } while (endps-- > 0) {
3068 struct u132_endp *endp = u132->endp[endps];
3070 u132_endp_cancel_work(u132, endp);
3073 printk(KERN_INFO "removing device u132.%d\n",
3074 u132->sequence_num);
3076 usb_remove_hcd(hcd);
3077 u132_u132_put_kref(u132);
3084 static void u132_initialise(struct u132 *u132, struct platform_device *pdev)
3086 int rings = MAX_U132_RINGS;
3087 int ports = MAX_U132_PORTS;
3088 int addrs = MAX_U132_ADDRS;
3089 int udevs = MAX_U132_UDEVS;
3090 int endps = MAX_U132_ENDPS;
3091 u132->board = pdev->dev.platform_data;
3092 u132->platform_dev = pdev;
3095 init_MUTEX(&u132->sw_lock);
3096 init_MUTEX(&u132->scheduler_lock);
3097 while (rings-- > 0) {
3098 struct u132_ring *ring = &u132->ring[rings];
3100 ring->number = rings + 1;
3102 ring->curr_endp = NULL;
3103 INIT_WORK(&ring->scheduler, u132_hcd_ring_work_scheduler,
3105 } down(&u132->sw_lock);
3106 INIT_WORK(&u132->monitor, u132_hcd_monitor_work, (void *)u132);
3107 while (ports-- > 0) {
3108 struct u132_port *port = &u132->port[ports];
3114 } while (addrs-- > 0) {
3115 struct u132_addr *addr = &u132->addr[addrs];
3117 } while (udevs-- > 0) {
3118 struct u132_udev *udev = &u132->udev[udevs];
3119 int i = ARRAY_SIZE(udev->endp_number_in);
3120 int o = ARRAY_SIZE(udev->endp_number_out);
3121 udev->usb_device = NULL;
3122 udev->udev_number = 0;
3124 udev->portnumber = 0;
3126 udev->endp_number_in[i] = 0;
3129 udev->endp_number_out[o] = 0;
3132 while (endps-- > 0) {
3133 u132->endp[endps] = NULL;
3139 static int __devinit u132_probe(struct platform_device *pdev)
3141 struct usb_hcd *hcd;
3143 if (u132_exiting > 0) {
3145 } /* refuse to confuse usbcore */
3146 if (pdev->dev.dma_mask) {
3149 hcd = usb_create_hcd(&u132_hc_driver, &pdev->dev, pdev->dev.bus_id);
3151 printk(KERN_ERR "failed to create the usb hcd struct for U132\n"
3153 ftdi_elan_gone_away(pdev);
3157 struct u132 *u132 = hcd_to_u132(hcd);
3158 hcd->rsrc_start = 0;
3159 down(&u132_module_lock);
3160 list_add_tail(&u132->u132_list, &u132_static_list);
3161 u132->sequence_num = ++u132_instances;
3162 up(&u132_module_lock);
3163 u132_u132_init_kref(u132);
3164 u132_initialise(u132, pdev);
3165 hcd->product_desc = "ELAN U132 Host Controller";
3166 retval = usb_add_hcd(hcd, 0, 0);
3168 dev_err(&u132->platform_dev->dev, "init error %d\n",
3170 u132_u132_put_kref(u132);
3173 u132_monitor_queue_work(u132, 100);
3181 /* for this device there's no useful distinction between the controller
3182 * and its root hub, except that the root hub only gets direct PM calls
3183 * when CONFIG_USB_SUSPEND is enabled.
3185 static int u132_suspend(struct platform_device *pdev, pm_message_t state)
3187 struct usb_hcd *hcd = platform_get_drvdata(pdev);
3188 struct u132 *u132 = hcd_to_u132(hcd);
3189 if (u132->going > 1) {
3190 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3193 } else if (u132->going > 0) {
3194 dev_err(&u132->platform_dev->dev, "device is being removed\n");
3198 if (state.event == PM_EVENT_FREEZE) {
3199 retval = u132_bus_suspend(hcd);
3200 } else if (state.event == PM_EVENT_SUSPEND) {
3201 int ports = MAX_U132_PORTS;
3202 while (ports-- > 0) {
3203 port_power(u132, ports, 0);
3207 pdev->dev.power.power_state = state;
3212 static int u132_resume(struct platform_device *pdev)
3214 struct usb_hcd *hcd = platform_get_drvdata(pdev);
3215 struct u132 *u132 = hcd_to_u132(hcd);
3216 if (u132->going > 1) {
3217 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3220 } else if (u132->going > 0) {
3221 dev_err(&u132->platform_dev->dev, "device is being removed\n");
3225 if (pdev->dev.power.power_state.event == PM_EVENT_SUSPEND) {
3226 int ports = MAX_U132_PORTS;
3227 while (ports-- > 0) {
3228 port_power(u132, ports, 1);
3232 pdev->dev.power.power_state = PMSG_ON;
3233 retval = u132_bus_resume(hcd);
3240 #define u132_suspend NULL
3241 #define u132_resume NULL
3244 * this driver is loaded explicitely by ftdi_u132
3246 * the platform_driver struct is static because it is per type of module
3248 static struct platform_driver u132_platform_driver = {
3249 .probe = u132_probe,
3250 .remove = __devexit_p(u132_remove),
3251 .suspend = u132_suspend,
3252 .resume = u132_resume,
3254 .name = (char *)hcd_name,
3255 .owner = THIS_MODULE,
3258 static int __init u132_hcd_init(void)
3261 INIT_LIST_HEAD(&u132_static_list);
3264 init_MUTEX(&u132_module_lock);
3267 printk(KERN_INFO "driver %s built at %s on %s\n", hcd_name, __TIME__,
3269 workqueue = create_singlethread_workqueue("u132");
3270 retval = platform_driver_register(&u132_platform_driver);
3275 module_init(u132_hcd_init);
3276 static void __exit u132_hcd_exit(void)
3280 down(&u132_module_lock);
3282 up(&u132_module_lock);
3283 list_for_each_entry_safe(u132, temp, &u132_static_list, u132_list) {
3284 platform_device_unregister(u132->platform_dev);
3285 } platform_driver_unregister(&u132_platform_driver);
3286 printk(KERN_INFO "u132-hcd driver deregistered\n");
3287 wait_event(u132_hcd_wait, u132_instances == 0);
3288 flush_workqueue(workqueue);
3289 destroy_workqueue(workqueue);
3293 module_exit(u132_hcd_exit);
3294 MODULE_LICENSE("GPL");