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 delayed_work scheduler
;
173 struct u132_endp
*curr_endp
;
174 struct delayed_work 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 delayed_work 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_delayed_work(workqueue
, &ring
->scheduler
, 0))
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
,
396 if (queue_delayed_work(workqueue
, &endp
->scheduler
, delta
))
397 kref_get(&endp
->kref
);
400 static void u132_endp_cancel_work(struct u132
*u132
, struct u132_endp
*endp
)
402 if (cancel_delayed_work(&endp
->scheduler
))
403 kref_put(&endp
->kref
, u132_endp_delete
);
406 static inline void u132_monitor_put_kref(struct u132
*u132
)
408 kref_put(&u132
->kref
, u132_hcd_delete
);
411 static void u132_monitor_queue_work(struct u132
*u132
, unsigned int delta
)
413 if (queue_delayed_work(workqueue
, &u132
->monitor
, delta
))
414 kref_get(&u132
->kref
);
417 static void u132_monitor_requeue_work(struct u132
*u132
, unsigned int delta
)
419 if (!queue_delayed_work(workqueue
, &u132
->monitor
, delta
))
420 kref_put(&u132
->kref
, u132_hcd_delete
);
423 static void u132_monitor_cancel_work(struct u132
*u132
)
425 if (cancel_delayed_work(&u132
->monitor
))
426 kref_put(&u132
->kref
, u132_hcd_delete
);
429 static int read_roothub_info(struct u132
*u132
)
433 retval
= u132_read_pcimem(u132
, revision
, &revision
);
435 dev_err(&u132
->platform_dev
->dev
, "error %d accessing device co"
438 } else if ((revision
& 0xFF) == 0x10) {
439 } else if ((revision
& 0xFF) == 0x11) {
441 dev_err(&u132
->platform_dev
->dev
, "device revision is not valid"
442 " %08X\n", revision
);
445 retval
= u132_read_pcimem(u132
, control
, &u132
->hc_control
);
447 dev_err(&u132
->platform_dev
->dev
, "error %d accessing device co"
451 retval
= u132_read_pcimem(u132
, roothub
.status
,
452 &u132
->hc_roothub_status
);
454 dev_err(&u132
->platform_dev
->dev
, "error %d accessing device re"
455 "g roothub.status\n", retval
);
458 retval
= u132_read_pcimem(u132
, roothub
.a
, &u132
->hc_roothub_a
);
460 dev_err(&u132
->platform_dev
->dev
, "error %d accessing device re"
461 "g roothub.a\n", retval
);
465 int I
= u132
->num_ports
;
468 retval
= u132_read_pcimem(u132
, roothub
.portstatus
[i
],
469 &u132
->hc_roothub_portstatus
[i
]);
471 dev_err(&u132
->platform_dev
->dev
, "error %d acc"
472 "essing device roothub.portstatus[%d]\n"
482 static void u132_hcd_monitor_work(struct work_struct
*work
)
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"
488 u132_monitor_put_kref(u132
);
490 } else if (u132
->going
> 0) {
491 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
492 u132_monitor_put_kref(u132
);
496 down(&u132
->sw_lock
);
497 retval
= read_roothub_info(u132
);
499 struct usb_hcd
*hcd
= u132_to_hcd(u132
);
504 ftdi_elan_gone_away(u132
->platform_dev
);
505 u132_monitor_put_kref(u132
);
508 u132_monitor_requeue_work(u132
, 500);
515 static void u132_hcd_giveback_urb(struct u132
*u132
, struct u132_endp
*endp
,
516 struct urb
*urb
, int status
)
518 struct u132_ring
*ring
;
520 struct usb_hcd
*hcd
= u132_to_hcd(u132
);
521 urb
->error_count
= 0;
522 urb
->status
= status
;
524 spin_lock_irqsave(&endp
->queue_lock
.slock
, irqs
);
525 endp
->queue_next
+= 1;
526 if (ENDP_QUEUE_SIZE
> --endp
->queue_size
) {
528 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
530 struct list_head
*next
= endp
->urb_more
.next
;
531 struct u132_urbq
*urbq
= list_entry(next
, struct u132_urbq
,
534 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] =
537 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
539 } down(&u132
->scheduler_lock
);
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
);
550 static void u132_hcd_forget_urb(struct u132
*u132
, struct u132_endp
*endp
,
551 struct urb
*urb
, int status
)
553 u132_endp_put_kref(u132
, endp
);
556 static void u132_hcd_abandon_urb(struct u132
*u132
, struct u132_endp
*endp
,
557 struct urb
*urb
, int status
)
560 struct usb_hcd
*hcd
= u132_to_hcd(u132
);
561 urb
->error_count
= 0;
562 urb
->status
= status
;
564 spin_lock_irqsave(&endp
->queue_lock
.slock
, irqs
);
565 endp
->queue_next
+= 1;
566 if (ENDP_QUEUE_SIZE
> --endp
->queue_size
) {
568 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
570 struct list_head
*next
= endp
->urb_more
.next
;
571 struct u132_urbq
*urbq
= list_entry(next
, struct u132_urbq
,
574 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] =
577 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
579 } usb_hcd_giveback_urb(hcd
, urb
);
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
))
589 return usb_ftdi_elan_edset_input(u132
->platform_dev
, ring
->number
, endp
,
590 urb
, address
, endp
->usb_endp
, toggle_bits
, callback
);
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
))
599 return usb_ftdi_elan_edset_setup(u132
->platform_dev
, ring
->number
, endp
,
600 urb
, address
, endp
->usb_endp
, toggle_bits
, callback
);
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
))
609 return usb_ftdi_elan_edset_single(u132
->platform_dev
, ring
->number
,
610 endp
, urb
, address
, endp
->usb_endp
, toggle_bits
, callback
);
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
))
619 return usb_ftdi_elan_edset_output(u132
->platform_dev
, ring
->number
,
620 endp
, urb
, address
, endp
->usb_endp
, toggle_bits
, callback
);
625 * must not LOCK sw_lock
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
)
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"
640 up(&u132
->scheduler_lock
);
641 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
643 } else if (endp
->dequeueing
) {
644 endp
->dequeueing
= 0;
645 up(&u132
->scheduler_lock
);
646 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
654 } else if (urb
->status
== -EINPROGRESS
) {
655 struct u132_ring
*ring
= endp
->ring
;
656 u8
*u
= urb
->transfer_buffer
+ urb
->actual_length
;
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,
668 if (urb
->actual_length
> 0) {
670 up(&u132
->scheduler_lock
);
671 retval
= edset_single(u132
, ring
, endp
, urb
,
672 address
, endp
->toggle_bits
,
673 u132_hcd_interrupt_recv
);
676 u132_hcd_giveback_urb(u132
, endp
, urb
,
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
);
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,
694 up(&u132
->scheduler_lock
);
695 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
698 if (condition_code
== TD_CC_NOERROR
) {
699 endp
->toggle_bits
= toggle_bits
;
700 usb_settoggle(udev
->usb_device
, endp
->usb_endp
,
702 } else if (condition_code
== TD_CC_STALL
) {
703 endp
->toggle_bits
= 0x2;
704 usb_settoggle(udev
->usb_device
, endp
->usb_endp
,
707 endp
->toggle_bits
= 0x2;
708 usb_settoggle(udev
->usb_device
, endp
->usb_endp
,
710 dev_err(&u132
->platform_dev
->dev
, "urb=%p givin"
711 "g back INTERRUPT %s\n", urb
,
712 cc_to_text
[condition_code
]);
714 up(&u132
->scheduler_lock
);
715 u132_hcd_giveback_urb(u132
, endp
, urb
,
716 cc_to_error
[condition_code
]);
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
);
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
)
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"
739 up(&u132
->scheduler_lock
);
740 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
742 } else if (endp
->dequeueing
) {
743 endp
->dequeueing
= 0;
744 up(&u132
->scheduler_lock
);
745 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
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
) {
759 up(&u132
->scheduler_lock
);
760 retval
= edset_output(u132
, ring
, endp
, urb
, address
,
761 endp
->toggle_bits
, u132_hcd_bulk_output_sent
);
764 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
767 up(&u132
->scheduler_lock
);
768 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
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
);
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
)
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"
792 up(&u132
->scheduler_lock
);
793 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
795 } else if (endp
->dequeueing
) {
796 endp
->dequeueing
= 0;
797 up(&u132
->scheduler_lock
);
798 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
806 } else if (urb
->status
== -EINPROGRESS
) {
807 struct u132_ring
*ring
= endp
->ring
;
808 u8
*u
= urb
->transfer_buffer
+ urb
->actual_length
;
814 urb
->actual_length
+= len
;
815 if ((condition_code
== TD_CC_NOERROR
) &&
816 (urb
->transfer_buffer_length
> urb
->actual_length
)) {
818 endp
->toggle_bits
= toggle_bits
;
819 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0,
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
);
828 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
830 } else if (condition_code
== TD_CC_NOERROR
) {
831 endp
->toggle_bits
= toggle_bits
;
832 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0,
834 up(&u132
->scheduler_lock
);
835 u132_hcd_giveback_urb(u132
, endp
, urb
,
836 cc_to_error
[condition_code
]);
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,
843 up(&u132
->scheduler_lock
);
844 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
846 } else if (condition_code
== TD_DATAUNDERRUN
) {
847 endp
->toggle_bits
= toggle_bits
;
848 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0,
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);
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
]);
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
]);
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
);
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
)
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"
893 up(&u132
->scheduler_lock
);
894 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
896 } else if (endp
->dequeueing
) {
897 endp
->dequeueing
= 0;
898 up(&u132
->scheduler_lock
);
899 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
907 } else if (urb
->status
== -EINPROGRESS
) {
908 up(&u132
->scheduler_lock
);
909 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
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
);
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
)
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"
931 up(&u132
->scheduler_lock
);
932 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
934 } else if (endp
->dequeueing
) {
935 endp
->dequeueing
= 0;
936 up(&u132
->scheduler_lock
);
937 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
945 } else if (urb
->status
== -EINPROGRESS
) {
946 struct u132_ring
*ring
= endp
->ring
;
947 u8
*u
= urb
->transfer_buffer
;
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))) {
958 up(&u132
->scheduler_lock
);
959 retval
= usb_ftdi_elan_edset_empty(u132
->platform_dev
,
960 ring
->number
, endp
, urb
, address
,
962 u132_hcd_configure_empty_sent
);
965 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
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
]);
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
],
979 u132_hcd_giveback_urb(u132
, endp
, urb
,
980 cc_to_error
[condition_code
]);
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
);
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
)
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"
1002 up(&u132
->scheduler_lock
);
1003 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1005 } else if (endp
->dequeueing
) {
1006 endp
->dequeueing
= 0;
1007 up(&u132
->scheduler_lock
);
1008 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
1016 } else if (urb
->status
== -EINPROGRESS
) {
1017 up(&u132
->scheduler_lock
);
1018 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
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
);
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
)
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"
1040 up(&u132
->scheduler_lock
);
1041 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1043 } else if (endp
->dequeueing
) {
1044 endp
->dequeueing
= 0;
1045 up(&u132
->scheduler_lock
);
1046 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
1054 } else if (urb
->status
== -EINPROGRESS
) {
1055 if (usb_pipein(urb
->pipe
)) {
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
,
1062 u132_hcd_configure_input_recv
);
1065 u132_hcd_giveback_urb(u132
, endp
, urb
, 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
,
1074 u132_hcd_configure_empty_recv
);
1077 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
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
);
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
)
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"
1101 up(&u132
->scheduler_lock
);
1102 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1104 } else if (endp
->dequeueing
) {
1105 endp
->dequeueing
= 0;
1106 up(&u132
->scheduler_lock
);
1107 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
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);
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
);
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
)
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"
1140 up(&u132
->scheduler_lock
);
1141 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1143 } else if (endp
->dequeueing
) {
1144 endp
->dequeueing
= 0;
1145 up(&u132
->scheduler_lock
);
1146 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
1154 } else if (urb
->status
== -EINPROGRESS
) {
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
);
1163 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
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
);
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
)
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"
1184 up(&u132
->scheduler_lock
);
1185 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1187 } else if (endp
->dequeueing
) {
1188 endp
->dequeueing
= 0;
1189 up(&u132
->scheduler_lock
);
1190 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
1198 } else if (urb
->status
== -EINPROGRESS
) {
1199 up(&u132
->scheduler_lock
);
1200 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
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
);
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
)
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"
1222 up(&u132
->scheduler_lock
);
1223 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1225 } else if (endp
->dequeueing
) {
1226 endp
->dequeueing
= 0;
1227 up(&u132
->scheduler_lock
);
1228 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
1236 } else if (urb
->status
== -EINPROGRESS
) {
1238 struct u132_ring
*ring
= endp
->ring
;
1239 u8
*u
= urb
->transfer_buffer
;
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
);
1252 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
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
);
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
)
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"
1274 up(&u132
->scheduler_lock
);
1275 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1277 } else if (endp
->dequeueing
) {
1278 endp
->dequeueing
= 0;
1279 up(&u132
->scheduler_lock
);
1280 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
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
);
1288 } else if (urb
->status
== -EINPROGRESS
) {
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
);
1297 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
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
);
1309 * this work function is only executed from the work queue
1312 static void u132_hcd_ring_work_scheduler(struct work_struct
*work
)
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
);
1319 up(&u132
->scheduler_lock
);
1320 u132_ring_put_kref(u132
, ring
);
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
);
1340 unsigned long delta
= endp
->jiffies
- jiffies
;
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
);
1354 unsigned long delta
= last_endp
->jiffies
- jiffies
;
1359 u132_ring_requeue_work(u132
, ring
, wakeup
);
1360 up(&u132
->scheduler_lock
);
1363 up(&u132
->scheduler_lock
);
1364 u132_ring_put_kref(u132
, ring
);
1368 up(&u132
->scheduler_lock
);
1369 u132_ring_put_kref(u132
, ring
);
1374 static void u132_hcd_endp_work_scheduler(struct work_struct
*work
)
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
);
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
);
1390 } else if (endp
->active
) {
1391 up(&u132
->scheduler_lock
);
1392 u132_endp_put_kref(u132
, endp
);
1394 } else if (ring
->in_use
) {
1395 up(&u132
->scheduler_lock
);
1396 u132_endp_put_kref(u132
, endp
);
1398 } else if (endp
->queue_next
== endp
->queue_last
) {
1399 up(&u132
->scheduler_lock
);
1400 u132_endp_put_kref(u132
, endp
);
1402 } else if (endp
->pipetype
== PIPE_INTERRUPT
) {
1403 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1405 up(&u132
->scheduler_lock
);
1406 u132_endp_put_kref(u132
, endp
);
1410 struct urb
*urb
= endp
->urb_list
[ENDP_QUEUE_MASK
&
1413 ring
->curr_endp
= endp
;
1415 up(&u132
->scheduler_lock
);
1416 retval
= edset_single(u132
, ring
, endp
, urb
, address
,
1417 endp
->toggle_bits
, u132_hcd_interrupt_recv
);
1420 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1423 } else if (endp
->pipetype
== PIPE_CONTROL
) {
1424 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1426 up(&u132
->scheduler_lock
);
1427 u132_endp_put_kref(u132
, endp
);
1429 } else if (address
== 0) {
1431 struct urb
*urb
= endp
->urb_list
[ENDP_QUEUE_MASK
&
1434 ring
->curr_endp
= endp
;
1436 up(&u132
->scheduler_lock
);
1437 retval
= edset_setup(u132
, ring
, endp
, urb
, address
,
1438 0x2, u132_hcd_initial_setup_sent
);
1441 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1443 } else if (endp
->usb_addr
== 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
, 0, 0x2,
1452 u132_hcd_enumeration_address_sent
);
1455 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1459 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1460 struct urb
*urb
= endp
->urb_list
[ENDP_QUEUE_MASK
&
1463 ring
->curr_endp
= endp
;
1465 up(&u132
->scheduler_lock
);
1466 retval
= edset_setup(u132
, ring
, endp
, urb
, address
,
1467 0x2, u132_hcd_configure_setup_sent
);
1470 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1475 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1477 up(&u132
->scheduler_lock
);
1478 u132_endp_put_kref(u132
, endp
);
1482 struct urb
*urb
= endp
->urb_list
[
1483 ENDP_QUEUE_MASK
& endp
->queue_next
];
1485 ring
->curr_endp
= endp
;
1487 up(&u132
->scheduler_lock
);
1488 retval
= edset_input(u132
, ring
, endp
, urb
,
1489 address
, endp
->toggle_bits
,
1490 u132_hcd_bulk_input_recv
);
1493 u132_hcd_giveback_urb(u132
, endp
, urb
,
1497 } else { /* output pipe */
1498 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1500 up(&u132
->scheduler_lock
);
1501 u132_endp_put_kref(u132
, endp
);
1505 struct urb
*urb
= endp
->urb_list
[
1506 ENDP_QUEUE_MASK
& endp
->queue_next
];
1508 ring
->curr_endp
= endp
;
1510 up(&u132
->scheduler_lock
);
1511 retval
= edset_output(u132
, ring
, endp
, urb
,
1512 address
, endp
->toggle_bits
,
1513 u132_hcd_bulk_output_sent
);
1516 u132_hcd_giveback_urb(u132
, endp
, urb
,
1524 static void port_power(struct u132
*u132
, int pn
, int is_on
)
1526 u132
->port
[pn
].power
= is_on
;
1529 static void u132_power(struct u132
*u132
, int is_on
)
1531 struct usb_hcd
*hcd
= u132_to_hcd(u132
)
1532 ; /* hub is inactive unless the port is powered */
1537 hcd
->self
.controller
->power
.power_state
= PMSG_ON
;
1540 hcd
->state
= HC_STATE_HALT
;
1541 hcd
->self
.controller
->power
.power_state
= PMSG_SUSPEND
;
1545 static int u132_periodic_reinit(struct u132
*u132
)
1548 u32 fi
= u132
->hc_fminterval
& 0x03fff;
1551 retval
= u132_read_pcimem(u132
, fminterval
, &fminterval
);
1554 fit
= fminterval
& FIT
;
1555 retval
= u132_write_pcimem(u132
, fminterval
,
1556 (fit
^ FIT
) | u132
->hc_fminterval
);
1559 retval
= u132_write_pcimem(u132
, periodicstart
,
1560 ((9 *fi
) / 10) & 0x3fff);
1566 static char *hcfs2string(int state
)
1569 case OHCI_USB_RESET
:
1571 case OHCI_USB_RESUME
:
1574 return "operational";
1575 case OHCI_USB_SUSPEND
:
1581 static int u132_usb_reset(struct u132
*u132
)
1584 retval
= u132_read_pcimem(u132
, control
, &u132
->hc_control
);
1587 u132
->hc_control
&= OHCI_CTRL_RWC
;
1588 retval
= u132_write_pcimem(u132
, control
, u132
->hc_control
);
1594 static int u132_init(struct u132
*u132
)
1599 u132
->next_statechange
=
1600 jiffies
; /* SMM owns the HC? not for long! */ {
1602 retval
= u132_read_pcimem(u132
, control
, &control
);
1605 if (control
& OHCI_CTRL_IR
) {
1607 retval
= u132_write_pcimem(u132
, intrenable
,
1611 retval
= u132_write_pcimem_byte(u132
, cmdstatus
,
1616 retval
= u132_read_pcimem(u132
, control
,
1621 if (control
& OHCI_CTRL_IR
) {
1624 dev_err(&u132
->platform_dev
->dev
, "USB "
1625 "HC takeover failed!(BIOS/SMM b"
1626 "ug) control=%08X\n", control
);
1631 u132_usb_reset(u132
);
1634 retval
= u132_write_pcimem(u132
, intrdisable
, OHCI_INTR_MIE
);
1637 retval
= u132_read_pcimem(u132
, control
, &control
);
1640 if (u132
->num_ports
== 0) {
1642 retval
= u132_read_pcimem(u132
, roothub
.a
, &rh_a
);
1645 u132
->num_ports
= rh_a
& RH_A_NDP
;
1646 retval
= read_roothub_info(u132
);
1650 if (u132
->num_ports
> MAX_U132_PORTS
) {
1657 /* Start an OHCI controller, set the BUS operational
1658 * resets USB and controller
1661 static int u132_run(struct u132
*u132
)
1670 int mask
= OHCI_INTR_INIT
;
1671 int first
= u132
->hc_fminterval
== 0;
1673 int reset_timeout
= 30; /* ... allow extra time */
1677 retval
= u132_read_pcimem(u132
, fminterval
, &temp
);
1680 u132
->hc_fminterval
= temp
& 0x3fff;
1681 if (u132
->hc_fminterval
!= FI
) {
1683 u132
->hc_fminterval
|= FSMP(u132
->hc_fminterval
) << 16;
1685 retval
= u132_read_pcimem(u132
, control
, &u132
->hc_control
);
1688 dev_info(&u132
->platform_dev
->dev
, "resetting from state '%s', control "
1689 "= %08X\n", hcfs2string(u132
->hc_control
& OHCI_CTRL_HCFS
),
1691 switch (u132
->hc_control
& OHCI_CTRL_HCFS
) {
1695 case OHCI_USB_SUSPEND
:
1696 case OHCI_USB_RESUME
:
1697 u132
->hc_control
&= OHCI_CTRL_RWC
;
1698 u132
->hc_control
|= OHCI_USB_RESUME
;
1702 u132
->hc_control
&= OHCI_CTRL_RWC
;
1703 u132
->hc_control
|= OHCI_USB_RESET
;
1707 retval
= u132_write_pcimem(u132
, control
, u132
->hc_control
);
1710 retval
= u132_read_pcimem(u132
, control
, &control
);
1714 retval
= u132_read_pcimem(u132
, roothub
.a
, &roothub_a
);
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
);
1726 retval
= u132_read_pcimem(u132
, control
, &control
);
1729 retry
:retval
= u132_read_pcimem(u132
, cmdstatus
, &status
);
1732 retval
= u132_write_pcimem_byte(u132
, cmdstatus
, OHCI_HCR
);
1736 retval
= u132_read_pcimem(u132
, cmdstatus
, &status
);
1739 if (0 != (status
& OHCI_HCR
)) {
1740 if (--reset_timeout
== 0) {
1741 dev_err(&u132
->platform_dev
->dev
, "USB HC reset"
1750 if (u132
->flags
& OHCI_QUIRK_INITRESET
) {
1751 retval
= u132_write_pcimem(u132
, control
, u132
->hc_control
);
1754 retval
= u132_read_pcimem(u132
, control
, &control
);
1758 retval
= u132_write_pcimem(u132
, ed_controlhead
, 0x00000000);
1761 retval
= u132_write_pcimem(u132
, ed_bulkhead
, 0x11000000);
1764 retval
= u132_write_pcimem(u132
, hcca
, 0x00000000);
1767 retval
= u132_periodic_reinit(u132
);
1770 retval
= u132_read_pcimem(u132
, fminterval
, &fminterval
);
1773 retval
= u132_read_pcimem(u132
, periodicstart
, &periodicstart
);
1776 if (0 == (fminterval
& 0x3fff0000) || 0 == periodicstart
) {
1777 if (!(u132
->flags
& OHCI_QUIRK_INITRESET
)) {
1778 u132
->flags
|= OHCI_QUIRK_INITRESET
;
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
);
1789 retval
= u132_write_pcimem_byte(u132
, cmdstatus
, OHCI_BLF
);
1792 retval
= u132_read_pcimem(u132
, cmdstatus
, &cmdstatus
);
1795 retval
= u132_read_pcimem(u132
, control
, &control
);
1798 u132_to_hcd(u132
)->state
= HC_STATE_RUNNING
;
1799 retval
= u132_write_pcimem(u132
, roothub
.status
, RH_HS_DRWE
);
1802 retval
= u132_write_pcimem(u132
, intrstatus
, mask
);
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
|
1810 return retval
; /* handle root hub init quirks ... */
1811 retval
= u132_read_pcimem(u132
, roothub
.a
, &roothub_a
);
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
);
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
);
1827 retval
= u132_write_pcimem(u132
, roothub
.status
, RH_HS_LPSC
);
1830 retval
= u132_write_pcimem(u132
, roothub
.b
,
1831 (roothub_a
& RH_A_NPS
) ? 0 : RH_B_PPCM
);
1834 retval
= u132_read_pcimem(u132
, control
, &control
);
1837 mdelay((roothub_a
>> 23) & 0x1fe);
1838 u132_to_hcd(u132
)->state
= HC_STATE_RUNNING
;
1842 static void u132_hcd_stop(struct usb_hcd
*hcd
)
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"
1848 } else if (u132
->going
> 0) {
1849 dev_err(&u132
->platform_dev
->dev
, "device hcd=%p is being remov"
1852 down(&u132
->sw_lock
);
1854 u132_power(u132
, 0);
1859 static int u132_hcd_start(struct usb_hcd
*hcd
)
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"
1866 } else if (u132
->going
> 0) {
1867 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
1869 } else if (hcd
->self
.controller
) {
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
);
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
);
1895 dev_err(&u132
->platform_dev
->dev
, "platform_device missing\n");
1900 static int u132_hcd_reset(struct usb_hcd
*hcd
)
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"
1907 } else if (u132
->going
> 0) {
1908 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
1912 down(&u132
->sw_lock
);
1913 retval
= u132_init(u132
);
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
,
1928 struct u132_ring
*ring
;
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
);
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
);
1943 INIT_LIST_HEAD(&endp
->endp_ring
);
1944 ring
->curr_endp
= endp
;
1947 endp
->dequeueing
= 0;
1948 endp
->edset_flush
= 0;
1951 endp
->endp_number
= endp_number
;
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);
1961 udev
->endp_number_in
[usb_endp
] = endp_number
;
1962 u132_udev_get_kref(u132
, udev
);
1964 endp
->toggle_bits
= 0x2;
1965 usb_settoggle(udev
->usb_device
, usb_endp
, 1, 0);
1968 udev
->endp_number_out
[usb_endp
] = endp_number
;
1969 u132_udev_get_kref(u132
, udev
);
1972 spin_lock_irqsave(&endp
->queue_lock
.slock
, irqs
);
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
));
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
)
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
;
1998 struct u132_urbq
*urbq
= kmalloc(sizeof(struct u132_urbq
),
2001 endp
->queue_size
-= 1;
2004 list_add_tail(&urbq
->urb_more
, &endp
->urb_more
);
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
,
2017 struct u132_ring
*ring
;
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
);
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;
2032 endp
->endp_number
= endp_number
;
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);
2043 udev
->endp_number_in
[usb_endp
] = endp_number
;
2044 u132_udev_get_kref(u132
, udev
);
2046 endp
->toggle_bits
= 0x2;
2047 usb_settoggle(udev
->usb_device
, usb_endp
, 1, 0);
2051 udev
->endp_number_out
[usb_endp
] = endp_number
;
2052 u132_udev_get_kref(u132
, udev
);
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
);
2058 INIT_LIST_HEAD(&endp
->endp_ring
);
2059 ring
->curr_endp
= endp
;
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);
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
)
2082 if (endp
->queue_size
++ < ENDP_QUEUE_SIZE
) {
2083 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] = urb
;
2085 struct u132_urbq
*urbq
= kmalloc(sizeof(struct u132_urbq
),
2088 endp
->queue_size
-= 1;
2091 list_add_tail(&urbq
->urb_more
, &endp
->urb_more
);
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
,
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
);
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
);
2117 INIT_LIST_HEAD(&endp
->endp_ring
);
2118 ring
->curr_endp
= endp
;
2121 endp
->dequeueing
= 0;
2122 endp
->edset_flush
= 0;
2125 endp
->endp_number
= endp_number
;
2128 u132_endp_init_kref(u132
, endp
);
2129 u132_endp_get_kref(u132
, endp
);
2130 if (usb_addr
== 0) {
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
;
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
;
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);
2153 } else { /*(usb_addr > 0) */
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
;
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
;
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);
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
,
2184 if (usb_addr
== 0) {
2185 if (usb_pipein(urb
->pipe
)) {
2187 if (endp
->queue_size
++ < ENDP_QUEUE_SIZE
) {
2188 endp
->urb_list
[ENDP_QUEUE_MASK
&
2189 endp
->queue_last
++] = urb
;
2191 struct u132_urbq
*urbq
=
2192 kmalloc(sizeof(struct u132_urbq
),
2195 endp
->queue_size
-= 1;
2198 list_add_tail(&urbq
->urb_more
,
2204 } else { /* usb_pipeout(urb->pipe) */
2205 struct u132_addr
*addr
= &u132
->addr
[usb_dev
->devnum
];
2206 int I
= MAX_U132_UDEVS
;
2209 struct u132_udev
*udev
= &u132
->udev
[++i
];
2210 if (udev
->usb_device
) {
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
] =
2221 u132_udev_get_kref(u132
, udev
);
2222 udev
->endp_number_out
[usb_endp
] =
2224 udev
->usb_device
= usb_dev
;
2225 ((u8
*) (urb
->setup_packet
))[2] =
2227 u132_udev_get_kref(u132
, udev
);
2232 dev_err(&u132
->platform_dev
->dev
, "run out of d"
2237 if (endp
->queue_size
++ < ENDP_QUEUE_SIZE
) {
2238 endp
->urb_list
[ENDP_QUEUE_MASK
&
2239 endp
->queue_last
++] = urb
;
2241 struct u132_urbq
*urbq
=
2242 kmalloc(sizeof(struct u132_urbq
),
2245 endp
->queue_size
-= 1;
2248 list_add_tail(&urbq
->urb_more
,
2255 } else { /*(usb_addr > 0) */
2256 u8 address
= u132
->addr
[usb_addr
].address
;
2257 struct u132_udev
*udev
= &u132
->udev
[address
];
2259 if (udev
->enumeration
== 2) {
2261 udev
->enumeration
= 2;
2262 if (endp
->queue_size
++ < ENDP_QUEUE_SIZE
) {
2263 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] =
2266 struct u132_urbq
*urbq
=
2267 kmalloc(sizeof(struct u132_urbq
), GFP_ATOMIC
);
2269 endp
->queue_size
-= 1;
2272 list_add_tail(&urbq
->urb_more
, &endp
->urb_more
);
2280 static int u132_urb_enqueue(struct usb_hcd
*hcd
, struct usb_host_endpoint
*hep
,
2281 struct urb
*urb
, gfp_t mem_flags
)
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"
2291 if (u132
->going
> 1) {
2292 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
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
);
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;
2311 spin_lock_irqsave(&endp
->queue_lock
.slock
,
2313 retval
= queue_int_on_old_endpoint(u132
, udev
,
2314 hep
, urb
, usb_dev
, endp
, usb_addr
,
2316 spin_unlock_irqrestore(&endp
->queue_lock
.slock
,
2321 u132_endp_queue_work(u132
, endp
,
2322 msecs_to_jiffies(urb
->interval
))
2326 } else if (u132
->num_endpoints
== MAX_U132_ENDPS
) {
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
);
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");
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;
2345 spin_lock_irqsave(&endp
->queue_lock
.slock
,
2347 retval
= queue_bulk_on_old_endpoint(u132
, udev
,
2348 hep
, urb
, usb_dev
, endp
, usb_addr
,
2350 spin_unlock_irqrestore(&endp
->queue_lock
.slock
,
2355 u132_endp_queue_work(u132
, endp
, 0);
2358 } else if (u132
->num_endpoints
== MAX_U132_ENDPS
) {
2361 return create_endpoint_and_queue_bulk(u132
,
2362 udev
, hep
, urb
, usb_dev
, usb_addr
,
2363 usb_endp
, address
, mem_flags
);
2365 struct u132_endp
*endp
= hep
->hcpriv
;
2367 u8
*b
= urb
->setup_packet
;
2369 char data
[30 *3 + 4];
2371 int m
= (sizeof(data
) - 1) / 3;
2374 while (urb_size
-- > 0) {
2376 } else if (i
++ < m
) {
2377 int w
= sprintf(d
, " %02X", *b
++);
2381 d
+= sprintf(d
, " ..");
2386 spin_lock_irqsave(&endp
->queue_lock
.slock
,
2388 retval
= queue_control_on_old_endpoint(u132
,
2389 hep
, urb
, usb_dev
, endp
, usb_addr
,
2391 spin_unlock_irqrestore(&endp
->queue_lock
.slock
,
2396 u132_endp_queue_work(u132
, endp
, 0);
2399 } else if (u132
->num_endpoints
== MAX_U132_ENDPS
) {
2402 return create_endpoint_and_queue_control(u132
,
2403 hep
, urb
, usb_dev
, usb_addr
, usb_endp
,
2409 static int dequeue_from_overflow_chain(struct u132
*u132
,
2410 struct u132_endp
*endp
, struct urb
*urb
)
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
,
2417 if (urbq
->urb
== urb
) {
2418 struct usb_hcd
*hcd
= u132_to_hcd(u132
);
2420 endp
->queue_size
-= 1;
2421 urb
->error_count
= 0;
2423 usb_hcd_giveback_urb(hcd
, urb
);
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
);
2437 static int u132_endp_urb_dequeue(struct u132
*u132
, struct u132_endp
*endp
,
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
);
2451 if (urb
== endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_next
]) {
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
);
2460 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
2461 u132_hcd_abandon_urb(u132
, endp
, urb
, urb
->status
);
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
&
2472 urb_slot
= &endp
->urb_list
[ENDP_QUEUE_MASK
&
2478 while (++queue_list
< ENDP_QUEUE_SIZE
&& --queue_size
> 0) {
2479 *urb_slot
= endp
->urb_list
[ENDP_QUEUE_MASK
&
2481 urb_slot
= &endp
->urb_list
[ENDP_QUEUE_MASK
&
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
,
2491 struct list_head
*next
= endp
->urb_more
.next
;
2492 struct u132_urbq
*urbq
= list_entry(next
,
2493 struct u132_urbq
, urb_more
);
2495 *urb_slot
= urbq
->urb
;
2496 spin_unlock_irqrestore(&endp
->queue_lock
.slock
,
2499 } urb
->error_count
= 0;
2501 usb_hcd_giveback_urb(hcd
, urb
);
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
);
2515 int retval
= dequeue_from_overflow_chain(u132
, endp
,
2517 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
2523 static int u132_urb_dequeue(struct usb_hcd
*hcd
, struct urb
*urb
)
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"
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
);
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
);
2547 static void u132_endpoint_disable(struct usb_hcd
*hcd
,
2548 struct usb_host_endpoint
*hep
)
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"
2555 struct u132_endp
*endp
= hep
->hcpriv
;
2557 u132_endp_put_kref(u132
, endp
);
2561 static int u132_get_frame(struct usb_hcd
*hcd
)
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"
2568 } else if (u132
->going
> 0) {
2569 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2573 dev_err(&u132
->platform_dev
->dev
, "TODO: u132_get_frame\n");
2579 static int u132_roothub_descriptor(struct u132
*u132
,
2580 struct usb_hub_descriptor
*desc
)
2586 retval
= u132_read_pcimem(u132
, roothub
.a
, &rh_a
);
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
;
2596 if (rh_a
& RH_A_NPS
)
2598 if (rh_a
& RH_A_PSM
)
2600 if (rh_a
& RH_A_NOCP
) {
2602 } else if (rh_a
& RH_A_OCPM
)
2604 desc
->wHubCharacteristics
= cpu_to_le16(temp
);
2605 retval
= u132_read_pcimem(u132
, roothub
.b
, &rh_b
);
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;
2614 desc
->bitmap
[1] = 0xff;
2618 static int u132_roothub_status(struct u132
*u132
, __le32
*desc
)
2621 int ret_status
= u132_read_pcimem(u132
, roothub
.status
, &rh_status
);
2622 *desc
= cpu_to_le32(rh_status
);
2626 static int u132_roothub_portstatus(struct u132
*u132
, __le32
*desc
, u16 wIndex
)
2628 if (wIndex
== 0 || wIndex
> u132
->num_ports
) {
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
);
2640 return ret_portstatus
;
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
)
2656 retval
= u132_read_pcimem(u132
, fmnumber
, &fmnumber
);
2660 reset_done
= now
+ PORT_RESET_MSEC
;
2664 retval
= u132_read_pcimem(u132
,
2665 roothub
.portstatus
[port_index
], &portstat
);
2668 if (RH_PS_PRS
& portstat
) {
2672 } while (tick_before(now
, reset_done
));
2673 if (RH_PS_PRS
& portstat
)
2675 if (RH_PS_CCS
& portstat
) {
2676 if (RH_PS_PRSC
& portstat
) {
2677 retval
= u132_write_pcimem(u132
,
2678 roothub
.portstatus
[port_index
],
2684 break; /* start the next reset,
2685 sleep till it's probably done */
2686 retval
= u132_write_pcimem(u132
, roothub
.portstatus
[port_index
],
2690 msleep(PORT_RESET_HW_MSEC
);
2691 retval
= u132_read_pcimem(u132
, fmnumber
, &fmnumber
);
2695 } while (tick_before(now
, reset_done
));
2699 static int u132_roothub_setportfeature(struct u132
*u132
, u16 wValue
,
2702 if (wIndex
== 0 || wIndex
> u132
->num_ports
) {
2706 int port_index
= wIndex
- 1;
2707 struct u132_port
*port
= &u132
->port
[port_index
];
2708 port
->Status
&= ~(1 << wValue
);
2710 case USB_PORT_FEAT_SUSPEND
:
2711 retval
= u132_write_pcimem(u132
,
2712 roothub
.portstatus
[port_index
], RH_PS_PSS
);
2716 case USB_PORT_FEAT_POWER
:
2717 retval
= u132_write_pcimem(u132
,
2718 roothub
.portstatus
[port_index
], RH_PS_PPS
);
2722 case USB_PORT_FEAT_RESET
:
2723 retval
= u132_roothub_portreset(u132
, port_index
);
2733 static int u132_roothub_clearportfeature(struct u132
*u132
, u16 wValue
,
2736 if (wIndex
== 0 || wIndex
> u132
->num_ports
) {
2739 int port_index
= wIndex
- 1;
2742 struct u132_port
*port
= &u132
->port
[port_index
];
2743 port
->Status
&= ~(1 << wValue
);
2745 case USB_PORT_FEAT_ENABLE
:
2748 case USB_PORT_FEAT_C_ENABLE
:
2751 case USB_PORT_FEAT_SUSPEND
:
2753 if ((u132
->hc_control
& OHCI_CTRL_HCFS
)
2755 dev_err(&u132
->platform_dev
->dev
, "TODO resume_"
2759 case USB_PORT_FEAT_C_SUSPEND
:
2762 case USB_PORT_FEAT_POWER
:
2765 case USB_PORT_FEAT_C_CONNECTION
:
2768 case USB_PORT_FEAT_C_OVER_CURRENT
:
2771 case USB_PORT_FEAT_C_RESET
:
2777 retval
= u132_write_pcimem(u132
, roothub
.portstatus
[port_index
],
2786 /* the virtual root hub timer IRQ checks for hub status*/
2787 static int u132_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
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
);
2794 } else if (u132
->going
> 0) {
2795 dev_err(&u132
->platform_dev
->dev
, "device hcd=%p is being remov"
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
);
2809 if (u132
->hc_roothub_status
& (RH_HS_LPSC
| RH_HS_OCIC
)) {
2810 buf
[0] = changed
= 1;
2813 if (u132
->num_ports
> 7) {
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
|
2823 buf
[0] |= 1 << (i
+ 1);
2825 buf
[1] |= 1 << (i
- 7);
2828 if (!(u132
->hc_roothub_portstatus
[i
] & RH_PS_CCS
)) {
2831 if ((u132
->hc_roothub_portstatus
[i
] & RH_PS_PSS
)) {
2835 done
:return changed
? length
: 0;
2839 static int u132_hub_control(struct usb_hcd
*hcd
, u16 typeReq
, u16 wValue
,
2840 u16 wIndex
, char *buf
, u16 wLength
)
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"
2847 } else if (u132
->going
> 0) {
2848 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2852 down(&u132
->sw_lock
);
2854 case ClearHubFeature
:
2856 case C_HUB_OVER_CURRENT
:
2857 case C_HUB_LOCAL_POWER
:
2865 case C_HUB_OVER_CURRENT
:
2866 case C_HUB_LOCAL_POWER
:
2872 case ClearPortFeature
:{
2873 retval
= u132_roothub_clearportfeature(u132
,
2879 case GetHubDescriptor
:{
2880 retval
= u132_roothub_descriptor(u132
,
2881 (struct usb_hub_descriptor
*)buf
);
2887 retval
= u132_roothub_status(u132
,
2893 case GetPortStatus
:{
2894 retval
= u132_roothub_portstatus(u132
,
2895 (__le32
*) buf
, wIndex
);
2900 case SetPortFeature
:{
2901 retval
= u132_roothub_setportfeature(u132
,
2909 error
:u132_disable(u132
);
2912 stall
:retval
= -EPIPE
;
2920 static int u132_start_port_reset(struct usb_hcd
*hcd
, unsigned port_num
)
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"
2927 } else if (u132
->going
> 0) {
2928 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2934 static void u132_hub_irq_enable(struct usb_hcd
*hcd
)
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"
2940 } else if (u132
->going
> 0)
2941 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2946 static int u132_hcd_suspend(struct usb_hcd
*hcd
, pm_message_t message
)
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"
2953 } else if (u132
->going
> 0) {
2954 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2960 static int u132_hcd_resume(struct usb_hcd
*hcd
)
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_bus_suspend(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_resume(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");
3003 #define u132_hcd_suspend NULL
3004 #define u132_hcd_resume NULL
3005 #define u132_bus_suspend NULL
3006 #define u132_bus_resume NULL
3008 static struct hc_driver u132_hc_driver
= {
3009 .description
= hcd_name
,
3010 .hcd_priv_size
= sizeof(struct u132
),
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
,
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()
3036 static int __devexit
u132_remove(struct platform_device
*pdev
)
3038 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
3040 struct u132
*u132
= hcd_to_u132(hcd
);
3042 if (u132
->going
++ > 1) {
3045 int rings
= MAX_U132_RINGS
;
3046 int endps
= MAX_U132_ENDPS
;
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
];
3056 u132_endp_cancel_work(u132
, endp
);
3059 printk(KERN_INFO
"removing device u132.%d\n",
3060 u132
->sequence_num
);
3062 usb_remove_hcd(hcd
);
3063 u132_u132_put_kref(u132
);
3070 static void u132_initialise(struct u132
*u132
, struct platform_device
*pdev
)
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
;
3081 init_MUTEX(&u132
->sw_lock
);
3082 init_MUTEX(&u132
->scheduler_lock
);
3083 while (rings
-- > 0) {
3084 struct u132_ring
*ring
= &u132
->ring
[rings
];
3086 ring
->number
= rings
+ 1;
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
];
3100 } while (addrs
-- > 0) {
3101 struct u132_addr
*addr
= &u132
->addr
[addrs
];
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;
3110 udev
->portnumber
= 0;
3112 udev
->endp_number_in
[i
] = 0;
3115 udev
->endp_number_out
[o
] = 0;
3118 while (endps
-- > 0) {
3119 u132
->endp
[endps
] = NULL
;
3125 static int __devinit
u132_probe(struct platform_device
*pdev
)
3127 struct usb_hcd
*hcd
;
3129 if (u132_exiting
> 0) {
3131 } /* refuse to confuse usbcore */
3132 if (pdev
->dev
.dma_mask
) {
3135 hcd
= usb_create_hcd(&u132_hc_driver
, &pdev
->dev
, pdev
->dev
.bus_id
);
3137 printk(KERN_ERR
"failed to create the usb hcd struct for U132\n"
3139 ftdi_elan_gone_away(pdev
);
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);
3154 dev_err(&u132
->platform_dev
->dev
, "init error %d\n",
3156 u132_u132_put_kref(u132
);
3159 u132_monitor_queue_work(u132
, 100);
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.
3171 static int u132_suspend(struct platform_device
*pdev
, pm_message_t state
)
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"
3179 } else if (u132
->going
> 0) {
3180 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
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);
3193 pdev
->dev
.power
.power_state
= state
;
3198 static int u132_resume(struct platform_device
*pdev
)
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"
3206 } else if (u132
->going
> 0) {
3207 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
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);
3218 pdev
->dev
.power
.power_state
= PMSG_ON
;
3219 retval
= u132_bus_resume(hcd
);
3226 #define u132_suspend NULL
3227 #define u132_resume NULL
3230 * this driver is loaded explicitely by ftdi_u132
3232 * the platform_driver struct is static because it is per type of module
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
,
3240 .name
= (char *)hcd_name
,
3241 .owner
= THIS_MODULE
,
3244 static int __init
u132_hcd_init(void)
3247 INIT_LIST_HEAD(&u132_static_list
);
3250 init_MUTEX(&u132_module_lock
);
3253 printk(KERN_INFO
"driver %s built at %s on %s\n", hcd_name
, __TIME__
,
3255 workqueue
= create_singlethread_workqueue("u132");
3256 retval
= platform_driver_register(&u132_platform_driver
);
3261 module_init(u132_hcd_init
);
3262 static void __exit
u132_hcd_exit(void)
3266 down(&u132_module_lock
);
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
);
3279 module_exit(u132_hcd_exit
);
3280 MODULE_LICENSE("GPL");