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 static 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
];
210 * these cannot be inlines because we need the structure offset!!
211 * Does anyone have a better way?????
213 #define u132_read_pcimem(u132, member, data) \
214 usb_ftdi_elan_read_pcimem(u132->platform_dev, offsetof(struct \
215 ohci_regs, member), 0, data);
216 #define u132_write_pcimem(u132, member, data) \
217 usb_ftdi_elan_write_pcimem(u132->platform_dev, offsetof(struct \
218 ohci_regs, member), 0, data);
219 #define u132_write_pcimem_byte(u132, member, data) \
220 usb_ftdi_elan_write_pcimem(u132->platform_dev, offsetof(struct \
221 ohci_regs, member), 0x0e, data);
222 static inline struct u132
*udev_to_u132(struct u132_udev
*udev
)
224 u8 udev_number
= udev
->udev_number
;
225 return container_of(udev
, struct u132
, udev
[udev_number
]);
228 static inline struct u132
*hcd_to_u132(struct usb_hcd
*hcd
)
230 return (struct u132
*)(hcd
->hcd_priv
);
233 static inline struct usb_hcd
*u132_to_hcd(struct u132
*u132
)
235 return container_of((void *)u132
, struct usb_hcd
, hcd_priv
);
238 static inline void u132_disable(struct u132
*u132
)
240 u132_to_hcd(u132
)->state
= HC_STATE_HALT
;
244 #define kref_to_u132(d) container_of(d, struct u132, kref)
245 #define kref_to_u132_endp(d) container_of(d, struct u132_endp, kref)
246 #define kref_to_u132_udev(d) container_of(d, struct u132_udev, kref)
247 #include "../misc/usb_u132.h"
248 static const char hcd_name
[] = "u132_hcd";
249 #define PORT_C_MASK ((USB_PORT_STAT_C_CONNECTION | USB_PORT_STAT_C_ENABLE | \
250 USB_PORT_STAT_C_SUSPEND | USB_PORT_STAT_C_OVERCURRENT | \
251 USB_PORT_STAT_C_RESET) << 16)
252 static void u132_hcd_delete(struct kref
*kref
)
254 struct u132
*u132
= kref_to_u132(kref
);
255 struct platform_device
*pdev
= u132
->platform_dev
;
256 struct usb_hcd
*hcd
= u132_to_hcd(u132
);
258 down(&u132_module_lock
);
259 list_del_init(&u132
->u132_list
);
261 up(&u132_module_lock
);
262 dev_warn(&u132
->platform_dev
->dev
, "FREEING the hcd=%p and thus the u13"
263 "2=%p going=%d pdev=%p\n", hcd
, u132
, u132
->going
, pdev
);
267 static inline void u132_u132_put_kref(struct u132
*u132
)
269 kref_put(&u132
->kref
, u132_hcd_delete
);
272 static inline void u132_u132_init_kref(struct u132
*u132
)
274 kref_init(&u132
->kref
);
277 static void u132_udev_delete(struct kref
*kref
)
279 struct u132_udev
*udev
= kref_to_u132_udev(kref
);
280 udev
->udev_number
= 0;
281 udev
->usb_device
= NULL
;
283 udev
->enumeration
= 0;
286 static inline void u132_udev_put_kref(struct u132
*u132
, struct u132_udev
*udev
)
288 kref_put(&udev
->kref
, u132_udev_delete
);
291 static inline void u132_udev_get_kref(struct u132
*u132
, struct u132_udev
*udev
)
293 kref_get(&udev
->kref
);
296 static inline void u132_udev_init_kref(struct u132
*u132
,
297 struct u132_udev
*udev
)
299 kref_init(&udev
->kref
);
302 static inline void u132_ring_put_kref(struct u132
*u132
, struct u132_ring
*ring
)
304 kref_put(&u132
->kref
, u132_hcd_delete
);
307 static void u132_ring_requeue_work(struct u132
*u132
, struct u132_ring
*ring
,
311 if (queue_delayed_work(workqueue
, &ring
->scheduler
, delta
))
313 } else if (queue_work(workqueue
, &ring
->scheduler
))
315 kref_put(&u132
->kref
, u132_hcd_delete
);
319 static void u132_ring_queue_work(struct u132
*u132
, struct u132_ring
*ring
,
322 kref_get(&u132
->kref
);
323 u132_ring_requeue_work(u132
, ring
, delta
);
327 static void u132_ring_cancel_work(struct u132
*u132
, struct u132_ring
*ring
)
329 if (cancel_delayed_work(&ring
->scheduler
)) {
330 kref_put(&u132
->kref
, u132_hcd_delete
);
334 static void u132_endp_delete(struct kref
*kref
)
336 struct u132_endp
*endp
= kref_to_u132_endp(kref
);
337 struct u132
*u132
= endp
->u132
;
338 u8 usb_addr
= endp
->usb_addr
;
339 u8 usb_endp
= endp
->usb_endp
;
340 u8 address
= u132
->addr
[usb_addr
].address
;
341 struct u132_udev
*udev
= &u132
->udev
[address
];
342 u8 endp_number
= endp
->endp_number
;
343 struct usb_host_endpoint
*hep
= endp
->hep
;
344 struct u132_ring
*ring
= endp
->ring
;
345 struct list_head
*head
= &endp
->endp_ring
;
347 if (endp
== ring
->curr_endp
) {
348 if (list_empty(head
)) {
349 ring
->curr_endp
= NULL
;
352 struct u132_endp
*next_endp
= list_entry(head
->next
,
353 struct u132_endp
, endp_ring
);
354 ring
->curr_endp
= next_endp
;
359 udev
->endp_number_in
[usb_endp
] = 0;
360 u132_udev_put_kref(u132
, udev
);
363 udev
->endp_number_out
[usb_endp
] = 0;
364 u132_udev_put_kref(u132
, udev
);
366 u132
->endp
[endp_number
- 1] = NULL
;
369 u132_u132_put_kref(u132
);
372 static inline void u132_endp_put_kref(struct u132
*u132
, struct u132_endp
*endp
)
374 kref_put(&endp
->kref
, u132_endp_delete
);
377 static inline void u132_endp_get_kref(struct u132
*u132
, struct u132_endp
*endp
)
379 kref_get(&endp
->kref
);
382 static inline void u132_endp_init_kref(struct u132
*u132
,
383 struct u132_endp
*endp
)
385 kref_init(&endp
->kref
);
386 kref_get(&u132
->kref
);
389 static void u132_endp_queue_work(struct u132
*u132
, struct u132_endp
*endp
,
393 if (queue_delayed_work(workqueue
, &endp
->scheduler
, delta
))
394 kref_get(&endp
->kref
);
395 } else if (queue_work(workqueue
, &endp
->scheduler
))
396 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
)
414 if (queue_delayed_work(workqueue
, &u132
->monitor
, delta
)) {
415 kref_get(&u132
->kref
);
417 } else if (queue_work(workqueue
, &u132
->monitor
))
418 kref_get(&u132
->kref
);
422 static void u132_monitor_requeue_work(struct u132
*u132
, unsigned int delta
)
425 if (queue_delayed_work(workqueue
, &u132
->monitor
, delta
))
427 } else if (queue_work(workqueue
, &u132
->monitor
))
429 kref_put(&u132
->kref
, u132_hcd_delete
);
433 static void u132_monitor_cancel_work(struct u132
*u132
)
435 if (cancel_delayed_work(&u132
->monitor
))
436 kref_put(&u132
->kref
, u132_hcd_delete
);
439 static int read_roothub_info(struct u132
*u132
)
443 retval
= u132_read_pcimem(u132
, revision
, &revision
);
445 dev_err(&u132
->platform_dev
->dev
, "error %d accessing device co"
448 } else if ((revision
& 0xFF) == 0x10) {
449 } else if ((revision
& 0xFF) == 0x11) {
451 dev_err(&u132
->platform_dev
->dev
, "device revision is not valid"
452 " %08X\n", revision
);
455 retval
= u132_read_pcimem(u132
, control
, &u132
->hc_control
);
457 dev_err(&u132
->platform_dev
->dev
, "error %d accessing device co"
461 retval
= u132_read_pcimem(u132
, roothub
.status
,
462 &u132
->hc_roothub_status
);
464 dev_err(&u132
->platform_dev
->dev
, "error %d accessing device re"
465 "g roothub.status\n", retval
);
468 retval
= u132_read_pcimem(u132
, roothub
.a
, &u132
->hc_roothub_a
);
470 dev_err(&u132
->platform_dev
->dev
, "error %d accessing device re"
471 "g roothub.a\n", retval
);
475 int I
= u132
->num_ports
;
478 retval
= u132_read_pcimem(u132
, roothub
.portstatus
[i
],
479 &u132
->hc_roothub_portstatus
[i
]);
481 dev_err(&u132
->platform_dev
->dev
, "error %d acc"
482 "essing device roothub.portstatus[%d]\n"
492 static void u132_hcd_monitor_work(void *data
)
494 struct u132
*u132
= data
;
495 if (u132
->going
> 1) {
496 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
498 u132_monitor_put_kref(u132
);
500 } else if (u132
->going
> 0) {
501 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
502 u132_monitor_put_kref(u132
);
506 down(&u132
->sw_lock
);
507 retval
= read_roothub_info(u132
);
509 struct usb_hcd
*hcd
= u132_to_hcd(u132
);
514 ftdi_elan_gone_away(u132
->platform_dev
);
515 u132_monitor_put_kref(u132
);
518 u132_monitor_requeue_work(u132
, 500);
525 static void u132_hcd_giveback_urb(struct u132
*u132
, struct u132_endp
*endp
,
526 struct urb
*urb
, int status
)
528 struct u132_ring
*ring
;
530 struct usb_hcd
*hcd
= u132_to_hcd(u132
);
531 urb
->error_count
= 0;
532 urb
->status
= status
;
534 spin_lock_irqsave(&endp
->queue_lock
.slock
, irqs
);
535 endp
->queue_next
+= 1;
536 if (ENDP_QUEUE_SIZE
> --endp
->queue_size
) {
538 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
540 struct list_head
*next
= endp
->urb_more
.next
;
541 struct u132_urbq
*urbq
= list_entry(next
, struct u132_urbq
,
544 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] =
547 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
549 } down(&u132
->scheduler_lock
);
552 u132_ring_cancel_work(u132
, ring
);
553 u132_ring_queue_work(u132
, ring
, 0);
554 up(&u132
->scheduler_lock
);
555 u132_endp_put_kref(u132
, endp
);
556 usb_hcd_giveback_urb(hcd
, urb
);
560 static void u132_hcd_forget_urb(struct u132
*u132
, struct u132_endp
*endp
,
561 struct urb
*urb
, int status
)
563 u132_endp_put_kref(u132
, endp
);
566 static void u132_hcd_abandon_urb(struct u132
*u132
, struct u132_endp
*endp
,
567 struct urb
*urb
, int status
)
570 struct usb_hcd
*hcd
= u132_to_hcd(u132
);
571 urb
->error_count
= 0;
572 urb
->status
= status
;
574 spin_lock_irqsave(&endp
->queue_lock
.slock
, irqs
);
575 endp
->queue_next
+= 1;
576 if (ENDP_QUEUE_SIZE
> --endp
->queue_size
) {
578 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
580 struct list_head
*next
= endp
->urb_more
.next
;
581 struct u132_urbq
*urbq
= list_entry(next
, struct u132_urbq
,
584 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] =
587 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
589 } usb_hcd_giveback_urb(hcd
, urb
);
593 static inline int edset_input(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_input(u132
->platform_dev
, ring
->number
, endp
,
600 urb
, address
, endp
->usb_endp
, toggle_bits
, callback
);
603 static inline int edset_setup(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_setup(u132
->platform_dev
, ring
->number
, endp
,
610 urb
, address
, endp
->usb_endp
, toggle_bits
, callback
);
613 static inline int edset_single(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_single(u132
->platform_dev
, ring
->number
,
620 endp
, urb
, address
, endp
->usb_endp
, toggle_bits
, callback
);
623 static inline int edset_output(struct u132
*u132
, struct u132_ring
*ring
,
624 struct u132_endp
*endp
, struct urb
*urb
, u8 address
, u8 toggle_bits
,
625 void (*callback
) (void *endp
, struct urb
*urb
, u8
*buf
, int len
,
626 int toggle_bits
, int error_count
, int condition_code
, int repeat_number
,
627 int halted
, int skipped
, int actual
, int non_null
))
629 return usb_ftdi_elan_edset_output(u132
->platform_dev
, ring
->number
,
630 endp
, urb
, address
, endp
->usb_endp
, toggle_bits
, callback
);
635 * must not LOCK sw_lock
638 static void u132_hcd_interrupt_recv(void *data
, struct urb
*urb
, u8
*buf
,
639 int len
, int toggle_bits
, int error_count
, int condition_code
,
640 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
642 struct u132_endp
*endp
= data
;
643 struct u132
*u132
= endp
->u132
;
644 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
645 struct u132_udev
*udev
= &u132
->udev
[address
];
646 down(&u132
->scheduler_lock
);
647 if (u132
->going
> 1) {
648 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
650 up(&u132
->scheduler_lock
);
651 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
653 } else if (endp
->dequeueing
) {
654 endp
->dequeueing
= 0;
655 up(&u132
->scheduler_lock
);
656 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
658 } else if (u132
->going
> 0) {
659 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
660 "%p status=%d\n", urb
, urb
->status
);
661 up(&u132
->scheduler_lock
);
662 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
664 } else if (urb
->status
== -EINPROGRESS
) {
665 struct u132_ring
*ring
= endp
->ring
;
666 u8
*u
= urb
->transfer_buffer
+ urb
->actual_length
;
672 urb
->actual_length
+= len
;
673 if ((condition_code
== TD_CC_NOERROR
) &&
674 (urb
->transfer_buffer_length
> urb
->actual_length
)) {
675 endp
->toggle_bits
= toggle_bits
;
676 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0,
678 if (urb
->actual_length
> 0) {
680 up(&u132
->scheduler_lock
);
681 retval
= edset_single(u132
, ring
, endp
, urb
,
682 address
, endp
->toggle_bits
,
683 u132_hcd_interrupt_recv
);
686 u132_hcd_giveback_urb(u132
, endp
, urb
,
691 endp
->jiffies
= jiffies
+
692 msecs_to_jiffies(urb
->interval
);
693 u132_ring_cancel_work(u132
, ring
);
694 u132_ring_queue_work(u132
, ring
, 0);
695 up(&u132
->scheduler_lock
);
696 u132_endp_put_kref(u132
, endp
);
699 } else if ((condition_code
== TD_DATAUNDERRUN
) &&
700 ((urb
->transfer_flags
& URB_SHORT_NOT_OK
) == 0)) {
701 endp
->toggle_bits
= toggle_bits
;
702 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0,
704 up(&u132
->scheduler_lock
);
705 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
708 if (condition_code
== TD_CC_NOERROR
) {
709 endp
->toggle_bits
= toggle_bits
;
710 usb_settoggle(udev
->usb_device
, endp
->usb_endp
,
712 } else if (condition_code
== TD_CC_STALL
) {
713 endp
->toggle_bits
= 0x2;
714 usb_settoggle(udev
->usb_device
, endp
->usb_endp
,
717 endp
->toggle_bits
= 0x2;
718 usb_settoggle(udev
->usb_device
, endp
->usb_endp
,
720 dev_err(&u132
->platform_dev
->dev
, "urb=%p givin"
721 "g back INTERRUPT %s\n", urb
,
722 cc_to_text
[condition_code
]);
724 up(&u132
->scheduler_lock
);
725 u132_hcd_giveback_urb(u132
, endp
, urb
,
726 cc_to_error
[condition_code
]);
730 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
731 "s=%d\n", urb
, urb
->status
);
732 up(&u132
->scheduler_lock
);
733 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
738 static void u132_hcd_bulk_output_sent(void *data
, struct urb
*urb
, u8
*buf
,
739 int len
, int toggle_bits
, int error_count
, int condition_code
,
740 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
742 struct u132_endp
*endp
= data
;
743 struct u132
*u132
= endp
->u132
;
744 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
745 down(&u132
->scheduler_lock
);
746 if (u132
->going
> 1) {
747 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
749 up(&u132
->scheduler_lock
);
750 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
752 } else if (endp
->dequeueing
) {
753 endp
->dequeueing
= 0;
754 up(&u132
->scheduler_lock
);
755 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
757 } else if (u132
->going
> 0) {
758 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
759 "%p status=%d\n", urb
, urb
->status
);
760 up(&u132
->scheduler_lock
);
761 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
763 } else if (urb
->status
== -EINPROGRESS
) {
764 struct u132_ring
*ring
= endp
->ring
;
765 urb
->actual_length
+= len
;
766 endp
->toggle_bits
= toggle_bits
;
767 if (urb
->transfer_buffer_length
> urb
->actual_length
) {
769 up(&u132
->scheduler_lock
);
770 retval
= edset_output(u132
, ring
, endp
, urb
, address
,
771 endp
->toggle_bits
, u132_hcd_bulk_output_sent
);
774 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
777 up(&u132
->scheduler_lock
);
778 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
782 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
783 "s=%d\n", urb
, urb
->status
);
784 up(&u132
->scheduler_lock
);
785 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
790 static void u132_hcd_bulk_input_recv(void *data
, struct urb
*urb
, u8
*buf
,
791 int len
, int toggle_bits
, int error_count
, int condition_code
,
792 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
794 struct u132_endp
*endp
= data
;
795 struct u132
*u132
= endp
->u132
;
796 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
797 struct u132_udev
*udev
= &u132
->udev
[address
];
798 down(&u132
->scheduler_lock
);
799 if (u132
->going
> 1) {
800 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
802 up(&u132
->scheduler_lock
);
803 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
805 } else if (endp
->dequeueing
) {
806 endp
->dequeueing
= 0;
807 up(&u132
->scheduler_lock
);
808 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
810 } else if (u132
->going
> 0) {
811 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
812 "%p status=%d\n", urb
, urb
->status
);
813 up(&u132
->scheduler_lock
);
814 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
816 } else if (urb
->status
== -EINPROGRESS
) {
817 struct u132_ring
*ring
= endp
->ring
;
818 u8
*u
= urb
->transfer_buffer
+ urb
->actual_length
;
824 urb
->actual_length
+= len
;
825 if ((condition_code
== TD_CC_NOERROR
) &&
826 (urb
->transfer_buffer_length
> urb
->actual_length
)) {
828 endp
->toggle_bits
= toggle_bits
;
829 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0,
831 up(&u132
->scheduler_lock
);
832 retval
= usb_ftdi_elan_edset_input(u132
->platform_dev
,
833 ring
->number
, endp
, urb
, address
,
834 endp
->usb_endp
, endp
->toggle_bits
,
835 u132_hcd_bulk_input_recv
);
838 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
840 } else if (condition_code
== TD_CC_NOERROR
) {
841 endp
->toggle_bits
= toggle_bits
;
842 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0,
844 up(&u132
->scheduler_lock
);
845 u132_hcd_giveback_urb(u132
, endp
, urb
,
846 cc_to_error
[condition_code
]);
848 } else if ((condition_code
== TD_DATAUNDERRUN
) &&
849 ((urb
->transfer_flags
& URB_SHORT_NOT_OK
) == 0)) {
850 endp
->toggle_bits
= toggle_bits
;
851 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0,
853 up(&u132
->scheduler_lock
);
854 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
856 } else if (condition_code
== TD_DATAUNDERRUN
) {
857 endp
->toggle_bits
= toggle_bits
;
858 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0,
860 dev_warn(&u132
->platform_dev
->dev
, "urb=%p(SHORT NOT OK"
861 ") giving back BULK IN %s\n", urb
,
862 cc_to_text
[condition_code
]);
863 up(&u132
->scheduler_lock
);
864 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
866 } else if (condition_code
== TD_CC_STALL
) {
867 endp
->toggle_bits
= 0x2;
868 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0, 0);
869 up(&u132
->scheduler_lock
);
870 u132_hcd_giveback_urb(u132
, endp
, urb
,
871 cc_to_error
[condition_code
]);
874 endp
->toggle_bits
= 0x2;
875 usb_settoggle(udev
->usb_device
, endp
->usb_endp
, 0, 0);
876 dev_err(&u132
->platform_dev
->dev
, "urb=%p giving back B"
877 "ULK IN code=%d %s\n", urb
, condition_code
,
878 cc_to_text
[condition_code
]);
879 up(&u132
->scheduler_lock
);
880 u132_hcd_giveback_urb(u132
, endp
, urb
,
881 cc_to_error
[condition_code
]);
885 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
886 "s=%d\n", urb
, urb
->status
);
887 up(&u132
->scheduler_lock
);
888 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
893 static void u132_hcd_configure_empty_sent(void *data
, struct urb
*urb
, u8
*buf
,
894 int len
, int toggle_bits
, int error_count
, int condition_code
,
895 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
897 struct u132_endp
*endp
= data
;
898 struct u132
*u132
= endp
->u132
;
899 down(&u132
->scheduler_lock
);
900 if (u132
->going
> 1) {
901 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
903 up(&u132
->scheduler_lock
);
904 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
906 } else if (endp
->dequeueing
) {
907 endp
->dequeueing
= 0;
908 up(&u132
->scheduler_lock
);
909 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
911 } else if (u132
->going
> 0) {
912 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
913 "%p status=%d\n", urb
, urb
->status
);
914 up(&u132
->scheduler_lock
);
915 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
917 } else if (urb
->status
== -EINPROGRESS
) {
918 up(&u132
->scheduler_lock
);
919 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
922 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
923 "s=%d\n", urb
, urb
->status
);
924 up(&u132
->scheduler_lock
);
925 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
930 static void u132_hcd_configure_input_recv(void *data
, struct urb
*urb
, u8
*buf
,
931 int len
, int toggle_bits
, int error_count
, int condition_code
,
932 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
934 struct u132_endp
*endp
= data
;
935 struct u132
*u132
= endp
->u132
;
936 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
937 down(&u132
->scheduler_lock
);
938 if (u132
->going
> 1) {
939 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
941 up(&u132
->scheduler_lock
);
942 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
944 } else if (endp
->dequeueing
) {
945 endp
->dequeueing
= 0;
946 up(&u132
->scheduler_lock
);
947 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
949 } else if (u132
->going
> 0) {
950 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
951 "%p status=%d\n", urb
, urb
->status
);
952 up(&u132
->scheduler_lock
);
953 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
955 } else if (urb
->status
== -EINPROGRESS
) {
956 struct u132_ring
*ring
= endp
->ring
;
957 u8
*u
= urb
->transfer_buffer
;
963 urb
->actual_length
= len
;
964 if ((condition_code
== TD_CC_NOERROR
) || ((condition_code
==
965 TD_DATAUNDERRUN
) && ((urb
->transfer_flags
&
966 URB_SHORT_NOT_OK
) == 0))) {
968 up(&u132
->scheduler_lock
);
969 retval
= usb_ftdi_elan_edset_empty(u132
->platform_dev
,
970 ring
->number
, endp
, urb
, address
,
972 u132_hcd_configure_empty_sent
);
975 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
977 } else if (condition_code
== TD_CC_STALL
) {
978 up(&u132
->scheduler_lock
);
979 dev_warn(&u132
->platform_dev
->dev
, "giving back SETUP I"
980 "NPUT STALL urb %p\n", urb
);
981 u132_hcd_giveback_urb(u132
, endp
, urb
,
982 cc_to_error
[condition_code
]);
985 up(&u132
->scheduler_lock
);
986 dev_err(&u132
->platform_dev
->dev
, "giving back SETUP IN"
987 "PUT %s urb %p\n", cc_to_text
[condition_code
],
989 u132_hcd_giveback_urb(u132
, endp
, urb
,
990 cc_to_error
[condition_code
]);
994 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
995 "s=%d\n", urb
, urb
->status
);
996 up(&u132
->scheduler_lock
);
997 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
1002 static void u132_hcd_configure_empty_recv(void *data
, struct urb
*urb
, u8
*buf
,
1003 int len
, int toggle_bits
, int error_count
, int condition_code
,
1004 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
1006 struct u132_endp
*endp
= data
;
1007 struct u132
*u132
= endp
->u132
;
1008 down(&u132
->scheduler_lock
);
1009 if (u132
->going
> 1) {
1010 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
1012 up(&u132
->scheduler_lock
);
1013 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1015 } else if (endp
->dequeueing
) {
1016 endp
->dequeueing
= 0;
1017 up(&u132
->scheduler_lock
);
1018 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
1020 } else if (u132
->going
> 0) {
1021 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
1022 "%p status=%d\n", urb
, urb
->status
);
1023 up(&u132
->scheduler_lock
);
1024 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
1026 } else if (urb
->status
== -EINPROGRESS
) {
1027 up(&u132
->scheduler_lock
);
1028 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
1031 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
1032 "s=%d\n", urb
, urb
->status
);
1033 up(&u132
->scheduler_lock
);
1034 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
1039 static void u132_hcd_configure_setup_sent(void *data
, struct urb
*urb
, u8
*buf
,
1040 int len
, int toggle_bits
, int error_count
, int condition_code
,
1041 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
1043 struct u132_endp
*endp
= data
;
1044 struct u132
*u132
= endp
->u132
;
1045 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1046 down(&u132
->scheduler_lock
);
1047 if (u132
->going
> 1) {
1048 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
1050 up(&u132
->scheduler_lock
);
1051 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1053 } else if (endp
->dequeueing
) {
1054 endp
->dequeueing
= 0;
1055 up(&u132
->scheduler_lock
);
1056 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
1058 } else if (u132
->going
> 0) {
1059 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
1060 "%p status=%d\n", urb
, urb
->status
);
1061 up(&u132
->scheduler_lock
);
1062 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
1064 } else if (urb
->status
== -EINPROGRESS
) {
1065 if (usb_pipein(urb
->pipe
)) {
1067 struct u132_ring
*ring
= endp
->ring
;
1068 up(&u132
->scheduler_lock
);
1069 retval
= usb_ftdi_elan_edset_input(u132
->platform_dev
,
1070 ring
->number
, endp
, urb
, address
,
1072 u132_hcd_configure_input_recv
);
1075 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1079 struct u132_ring
*ring
= endp
->ring
;
1080 up(&u132
->scheduler_lock
);
1081 retval
= usb_ftdi_elan_edset_input(u132
->platform_dev
,
1082 ring
->number
, endp
, urb
, address
,
1084 u132_hcd_configure_empty_recv
);
1087 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1091 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
1092 "s=%d\n", urb
, urb
->status
);
1093 up(&u132
->scheduler_lock
);
1094 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
1099 static void u132_hcd_enumeration_empty_recv(void *data
, struct urb
*urb
,
1100 u8
*buf
, int len
, int toggle_bits
, int error_count
, int condition_code
,
1101 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
1103 struct u132_endp
*endp
= data
;
1104 struct u132
*u132
= endp
->u132
;
1105 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1106 struct u132_udev
*udev
= &u132
->udev
[address
];
1107 down(&u132
->scheduler_lock
);
1108 if (u132
->going
> 1) {
1109 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
1111 up(&u132
->scheduler_lock
);
1112 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1114 } else if (endp
->dequeueing
) {
1115 endp
->dequeueing
= 0;
1116 up(&u132
->scheduler_lock
);
1117 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
1119 } else if (u132
->going
> 0) {
1120 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
1121 "%p status=%d\n", urb
, urb
->status
);
1122 up(&u132
->scheduler_lock
);
1123 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
1125 } else if (urb
->status
== -EINPROGRESS
) {
1126 u132
->addr
[0].address
= 0;
1127 endp
->usb_addr
= udev
->usb_addr
;
1128 up(&u132
->scheduler_lock
);
1129 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
1132 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
1133 "s=%d\n", urb
, urb
->status
);
1134 up(&u132
->scheduler_lock
);
1135 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
1140 static void u132_hcd_enumeration_address_sent(void *data
, struct urb
*urb
,
1141 u8
*buf
, int len
, int toggle_bits
, int error_count
, int condition_code
,
1142 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
1144 struct u132_endp
*endp
= data
;
1145 struct u132
*u132
= endp
->u132
;
1146 down(&u132
->scheduler_lock
);
1147 if (u132
->going
> 1) {
1148 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
1150 up(&u132
->scheduler_lock
);
1151 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1153 } else if (endp
->dequeueing
) {
1154 endp
->dequeueing
= 0;
1155 up(&u132
->scheduler_lock
);
1156 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
1158 } else if (u132
->going
> 0) {
1159 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
1160 "%p status=%d\n", urb
, urb
->status
);
1161 up(&u132
->scheduler_lock
);
1162 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
1164 } else if (urb
->status
== -EINPROGRESS
) {
1166 struct u132_ring
*ring
= endp
->ring
;
1167 up(&u132
->scheduler_lock
);
1168 retval
= usb_ftdi_elan_edset_input(u132
->platform_dev
,
1169 ring
->number
, endp
, urb
, 0, endp
->usb_endp
, 0,
1170 u132_hcd_enumeration_empty_recv
);
1173 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1176 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
1177 "s=%d\n", urb
, urb
->status
);
1178 up(&u132
->scheduler_lock
);
1179 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
1184 static void u132_hcd_initial_empty_sent(void *data
, struct urb
*urb
, u8
*buf
,
1185 int len
, int toggle_bits
, int error_count
, int condition_code
,
1186 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
1188 struct u132_endp
*endp
= data
;
1189 struct u132
*u132
= endp
->u132
;
1190 down(&u132
->scheduler_lock
);
1191 if (u132
->going
> 1) {
1192 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
1194 up(&u132
->scheduler_lock
);
1195 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1197 } else if (endp
->dequeueing
) {
1198 endp
->dequeueing
= 0;
1199 up(&u132
->scheduler_lock
);
1200 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
1202 } else if (u132
->going
> 0) {
1203 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
1204 "%p status=%d\n", urb
, urb
->status
);
1205 up(&u132
->scheduler_lock
);
1206 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
1208 } else if (urb
->status
== -EINPROGRESS
) {
1209 up(&u132
->scheduler_lock
);
1210 u132_hcd_giveback_urb(u132
, endp
, urb
, 0);
1213 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
1214 "s=%d\n", urb
, urb
->status
);
1215 up(&u132
->scheduler_lock
);
1216 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
1221 static void u132_hcd_initial_input_recv(void *data
, struct urb
*urb
, u8
*buf
,
1222 int len
, int toggle_bits
, int error_count
, int condition_code
,
1223 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
1225 struct u132_endp
*endp
= data
;
1226 struct u132
*u132
= endp
->u132
;
1227 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1228 down(&u132
->scheduler_lock
);
1229 if (u132
->going
> 1) {
1230 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
1232 up(&u132
->scheduler_lock
);
1233 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1235 } else if (endp
->dequeueing
) {
1236 endp
->dequeueing
= 0;
1237 up(&u132
->scheduler_lock
);
1238 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
1240 } else if (u132
->going
> 0) {
1241 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
1242 "%p status=%d\n", urb
, urb
->status
);
1243 up(&u132
->scheduler_lock
);
1244 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
1246 } else if (urb
->status
== -EINPROGRESS
) {
1248 struct u132_ring
*ring
= endp
->ring
;
1249 u8
*u
= urb
->transfer_buffer
;
1255 urb
->actual_length
= len
;
1256 up(&u132
->scheduler_lock
);
1257 retval
= usb_ftdi_elan_edset_empty(u132
->platform_dev
,
1258 ring
->number
, endp
, urb
, address
, endp
->usb_endp
, 0x3,
1259 u132_hcd_initial_empty_sent
);
1262 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1265 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
1266 "s=%d\n", urb
, urb
->status
);
1267 up(&u132
->scheduler_lock
);
1268 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
1273 static void u132_hcd_initial_setup_sent(void *data
, struct urb
*urb
, u8
*buf
,
1274 int len
, int toggle_bits
, int error_count
, int condition_code
,
1275 int repeat_number
, int halted
, int skipped
, int actual
, int non_null
)
1277 struct u132_endp
*endp
= data
;
1278 struct u132
*u132
= endp
->u132
;
1279 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1280 down(&u132
->scheduler_lock
);
1281 if (u132
->going
> 1) {
1282 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
1284 up(&u132
->scheduler_lock
);
1285 u132_hcd_forget_urb(u132
, endp
, urb
, -ENODEV
);
1287 } else if (endp
->dequeueing
) {
1288 endp
->dequeueing
= 0;
1289 up(&u132
->scheduler_lock
);
1290 u132_hcd_giveback_urb(u132
, endp
, urb
, -EINTR
);
1292 } else if (u132
->going
> 0) {
1293 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
1294 "%p status=%d\n", urb
, urb
->status
);
1295 up(&u132
->scheduler_lock
);
1296 u132_hcd_giveback_urb(u132
, endp
, urb
, -ENODEV
);
1298 } else if (urb
->status
== -EINPROGRESS
) {
1300 struct u132_ring
*ring
= endp
->ring
;
1301 up(&u132
->scheduler_lock
);
1302 retval
= usb_ftdi_elan_edset_input(u132
->platform_dev
,
1303 ring
->number
, endp
, urb
, address
, endp
->usb_endp
, 0,
1304 u132_hcd_initial_input_recv
);
1307 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1310 dev_err(&u132
->platform_dev
->dev
, "CALLBACK called urb=%p statu"
1311 "s=%d\n", urb
, urb
->status
);
1312 up(&u132
->scheduler_lock
);
1313 u132_hcd_giveback_urb(u132
, endp
, urb
, urb
->status
);
1318 static void u132_hcd_ring_work_scheduler(void *data
);
1319 static void u132_hcd_endp_work_scheduler(void *data
);
1321 * this work function is only executed from the work queue
1324 static void u132_hcd_ring_work_scheduler(void *data
)
1326 struct u132_ring
*ring
= data
;
1327 struct u132
*u132
= ring
->u132
;
1328 down(&u132
->scheduler_lock
);
1330 up(&u132
->scheduler_lock
);
1331 u132_ring_put_kref(u132
, ring
);
1333 } else if (ring
->curr_endp
) {
1334 struct u132_endp
*last_endp
= ring
->curr_endp
;
1335 struct list_head
*scan
;
1336 struct list_head
*head
= &last_endp
->endp_ring
;
1337 unsigned long wakeup
= 0;
1338 list_for_each(scan
, head
) {
1339 struct u132_endp
*endp
= list_entry(scan
,
1340 struct u132_endp
, endp_ring
);
1341 if (endp
->queue_next
== endp
->queue_last
) {
1342 } else if ((endp
->delayed
== 0)
1343 || time_after_eq(jiffies
, endp
->jiffies
)) {
1344 ring
->curr_endp
= endp
;
1345 u132_endp_cancel_work(u132
, last_endp
);
1346 u132_endp_queue_work(u132
, last_endp
, 0);
1347 up(&u132
->scheduler_lock
);
1348 u132_ring_put_kref(u132
, ring
);
1351 unsigned long delta
= endp
->jiffies
- jiffies
;
1356 if (last_endp
->queue_next
== last_endp
->queue_last
) {
1357 } else if ((last_endp
->delayed
== 0) || time_after_eq(jiffies
,
1358 last_endp
->jiffies
)) {
1359 u132_endp_cancel_work(u132
, last_endp
);
1360 u132_endp_queue_work(u132
, last_endp
, 0);
1361 up(&u132
->scheduler_lock
);
1362 u132_ring_put_kref(u132
, ring
);
1365 unsigned long delta
= last_endp
->jiffies
- jiffies
;
1370 u132_ring_requeue_work(u132
, ring
, wakeup
);
1371 up(&u132
->scheduler_lock
);
1374 up(&u132
->scheduler_lock
);
1375 u132_ring_put_kref(u132
, ring
);
1379 up(&u132
->scheduler_lock
);
1380 u132_ring_put_kref(u132
, ring
);
1385 static void u132_hcd_endp_work_scheduler(void *data
)
1387 struct u132_ring
*ring
;
1388 struct u132_endp
*endp
= data
;
1389 struct u132
*u132
= endp
->u132
;
1390 down(&u132
->scheduler_lock
);
1392 if (endp
->edset_flush
) {
1393 endp
->edset_flush
= 0;
1394 if (endp
->dequeueing
)
1395 usb_ftdi_elan_edset_flush(u132
->platform_dev
,
1396 ring
->number
, endp
);
1397 up(&u132
->scheduler_lock
);
1398 u132_endp_put_kref(u132
, endp
);
1400 } else if (endp
->active
) {
1401 up(&u132
->scheduler_lock
);
1402 u132_endp_put_kref(u132
, endp
);
1404 } else if (ring
->in_use
) {
1405 up(&u132
->scheduler_lock
);
1406 u132_endp_put_kref(u132
, endp
);
1408 } else if (endp
->queue_next
== endp
->queue_last
) {
1409 up(&u132
->scheduler_lock
);
1410 u132_endp_put_kref(u132
, endp
);
1412 } else if (endp
->pipetype
== PIPE_INTERRUPT
) {
1413 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1415 up(&u132
->scheduler_lock
);
1416 u132_endp_put_kref(u132
, endp
);
1420 struct urb
*urb
= endp
->urb_list
[ENDP_QUEUE_MASK
&
1423 ring
->curr_endp
= endp
;
1425 up(&u132
->scheduler_lock
);
1426 retval
= edset_single(u132
, ring
, endp
, urb
, address
,
1427 endp
->toggle_bits
, u132_hcd_interrupt_recv
);
1430 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1433 } else if (endp
->pipetype
== PIPE_CONTROL
) {
1434 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1436 up(&u132
->scheduler_lock
);
1437 u132_endp_put_kref(u132
, endp
);
1439 } else if (address
== 0) {
1441 struct urb
*urb
= endp
->urb_list
[ENDP_QUEUE_MASK
&
1444 ring
->curr_endp
= endp
;
1446 up(&u132
->scheduler_lock
);
1447 retval
= edset_setup(u132
, ring
, endp
, urb
, address
,
1448 0x2, u132_hcd_initial_setup_sent
);
1451 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1453 } else if (endp
->usb_addr
== 0) {
1455 struct urb
*urb
= endp
->urb_list
[ENDP_QUEUE_MASK
&
1458 ring
->curr_endp
= endp
;
1460 up(&u132
->scheduler_lock
);
1461 retval
= edset_setup(u132
, ring
, endp
, urb
, 0, 0x2,
1462 u132_hcd_enumeration_address_sent
);
1465 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1469 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1470 struct urb
*urb
= endp
->urb_list
[ENDP_QUEUE_MASK
&
1473 ring
->curr_endp
= endp
;
1475 up(&u132
->scheduler_lock
);
1476 retval
= edset_setup(u132
, ring
, endp
, urb
, address
,
1477 0x2, u132_hcd_configure_setup_sent
);
1480 u132_hcd_giveback_urb(u132
, endp
, urb
, retval
);
1485 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1487 up(&u132
->scheduler_lock
);
1488 u132_endp_put_kref(u132
, endp
);
1492 struct urb
*urb
= endp
->urb_list
[
1493 ENDP_QUEUE_MASK
& endp
->queue_next
];
1495 ring
->curr_endp
= endp
;
1497 up(&u132
->scheduler_lock
);
1498 retval
= edset_input(u132
, ring
, endp
, urb
,
1499 address
, endp
->toggle_bits
,
1500 u132_hcd_bulk_input_recv
);
1503 u132_hcd_giveback_urb(u132
, endp
, urb
,
1507 } else { /* output pipe */
1508 u8 address
= u132
->addr
[endp
->usb_addr
].address
;
1510 up(&u132
->scheduler_lock
);
1511 u132_endp_put_kref(u132
, endp
);
1515 struct urb
*urb
= endp
->urb_list
[
1516 ENDP_QUEUE_MASK
& endp
->queue_next
];
1518 ring
->curr_endp
= endp
;
1520 up(&u132
->scheduler_lock
);
1521 retval
= edset_output(u132
, ring
, endp
, urb
,
1522 address
, endp
->toggle_bits
,
1523 u132_hcd_bulk_output_sent
);
1526 u132_hcd_giveback_urb(u132
, endp
, urb
,
1534 static void port_power(struct u132
*u132
, int pn
, int is_on
)
1536 u132
->port
[pn
].power
= is_on
;
1539 static void u132_power(struct u132
*u132
, int is_on
)
1541 struct usb_hcd
*hcd
= u132_to_hcd(u132
)
1542 ; /* hub is inactive unless the port is powered */
1547 hcd
->self
.controller
->power
.power_state
= PMSG_ON
;
1550 hcd
->state
= HC_STATE_HALT
;
1551 hcd
->self
.controller
->power
.power_state
= PMSG_SUSPEND
;
1555 static int u132_periodic_reinit(struct u132
*u132
)
1558 u32 fi
= u132
->hc_fminterval
& 0x03fff;
1561 retval
= u132_read_pcimem(u132
, fminterval
, &fminterval
);
1564 fit
= fminterval
& FIT
;
1565 retval
= u132_write_pcimem(u132
, fminterval
,
1566 (fit
^ FIT
) | u132
->hc_fminterval
);
1569 retval
= u132_write_pcimem(u132
, periodicstart
,
1570 ((9 *fi
) / 10) & 0x3fff);
1576 static char *hcfs2string(int state
)
1579 case OHCI_USB_RESET
:
1581 case OHCI_USB_RESUME
:
1584 return "operational";
1585 case OHCI_USB_SUSPEND
:
1591 static int u132_usb_reset(struct u132
*u132
)
1594 retval
= u132_read_pcimem(u132
, control
, &u132
->hc_control
);
1597 u132
->hc_control
&= OHCI_CTRL_RWC
;
1598 retval
= u132_write_pcimem(u132
, control
, u132
->hc_control
);
1604 static int u132_init(struct u132
*u132
)
1609 u132
->next_statechange
=
1610 jiffies
; /* SMM owns the HC? not for long! */ {
1612 retval
= u132_read_pcimem(u132
, control
, &control
);
1615 if (control
& OHCI_CTRL_IR
) {
1617 retval
= u132_write_pcimem(u132
, intrenable
,
1621 retval
= u132_write_pcimem_byte(u132
, cmdstatus
,
1626 retval
= u132_read_pcimem(u132
, control
,
1631 if (control
& OHCI_CTRL_IR
) {
1634 dev_err(&u132
->platform_dev
->dev
, "USB "
1635 "HC takeover failed!(BIOS/SMM b"
1636 "ug) control=%08X\n", control
);
1641 u132_usb_reset(u132
);
1644 retval
= u132_write_pcimem(u132
, intrdisable
, OHCI_INTR_MIE
);
1647 retval
= u132_read_pcimem(u132
, control
, &control
);
1650 if (u132
->num_ports
== 0) {
1652 retval
= u132_read_pcimem(u132
, roothub
.a
, &rh_a
);
1655 u132
->num_ports
= rh_a
& RH_A_NDP
;
1656 retval
= read_roothub_info(u132
);
1660 if (u132
->num_ports
> MAX_U132_PORTS
) {
1667 /* Start an OHCI controller, set the BUS operational
1668 * resets USB and controller
1671 static int u132_run(struct u132
*u132
)
1680 int mask
= OHCI_INTR_INIT
;
1681 int first
= u132
->hc_fminterval
== 0;
1683 int reset_timeout
= 30; /* ... allow extra time */
1687 retval
= u132_read_pcimem(u132
, fminterval
, &temp
);
1690 u132
->hc_fminterval
= temp
& 0x3fff;
1691 if (u132
->hc_fminterval
!= FI
) {
1693 u132
->hc_fminterval
|= FSMP(u132
->hc_fminterval
) << 16;
1695 retval
= u132_read_pcimem(u132
, control
, &u132
->hc_control
);
1698 dev_info(&u132
->platform_dev
->dev
, "resetting from state '%s', control "
1699 "= %08X\n", hcfs2string(u132
->hc_control
& OHCI_CTRL_HCFS
),
1701 switch (u132
->hc_control
& OHCI_CTRL_HCFS
) {
1705 case OHCI_USB_SUSPEND
:
1706 case OHCI_USB_RESUME
:
1707 u132
->hc_control
&= OHCI_CTRL_RWC
;
1708 u132
->hc_control
|= OHCI_USB_RESUME
;
1712 u132
->hc_control
&= OHCI_CTRL_RWC
;
1713 u132
->hc_control
|= OHCI_USB_RESET
;
1717 retval
= u132_write_pcimem(u132
, control
, u132
->hc_control
);
1720 retval
= u132_read_pcimem(u132
, control
, &control
);
1724 retval
= u132_read_pcimem(u132
, roothub
.a
, &roothub_a
);
1727 if (!(roothub_a
& RH_A_NPS
)) {
1728 int temp
; /* power down each port */
1729 for (temp
= 0; temp
< u132
->num_ports
; temp
++) {
1730 retval
= u132_write_pcimem(u132
,
1731 roothub
.portstatus
[temp
], RH_PS_LSDA
);
1736 retval
= u132_read_pcimem(u132
, control
, &control
);
1739 retry
:retval
= u132_read_pcimem(u132
, cmdstatus
, &status
);
1742 retval
= u132_write_pcimem_byte(u132
, cmdstatus
, OHCI_HCR
);
1746 retval
= u132_read_pcimem(u132
, cmdstatus
, &status
);
1749 if (0 != (status
& OHCI_HCR
)) {
1750 if (--reset_timeout
== 0) {
1751 dev_err(&u132
->platform_dev
->dev
, "USB HC reset"
1760 if (u132
->flags
& OHCI_QUIRK_INITRESET
) {
1761 retval
= u132_write_pcimem(u132
, control
, u132
->hc_control
);
1764 retval
= u132_read_pcimem(u132
, control
, &control
);
1768 retval
= u132_write_pcimem(u132
, ed_controlhead
, 0x00000000);
1771 retval
= u132_write_pcimem(u132
, ed_bulkhead
, 0x11000000);
1774 retval
= u132_write_pcimem(u132
, hcca
, 0x00000000);
1777 retval
= u132_periodic_reinit(u132
);
1780 retval
= u132_read_pcimem(u132
, fminterval
, &fminterval
);
1783 retval
= u132_read_pcimem(u132
, periodicstart
, &periodicstart
);
1786 if (0 == (fminterval
& 0x3fff0000) || 0 == periodicstart
) {
1787 if (!(u132
->flags
& OHCI_QUIRK_INITRESET
)) {
1788 u132
->flags
|= OHCI_QUIRK_INITRESET
;
1791 dev_err(&u132
->platform_dev
->dev
, "init err(%08x %04x)"
1792 "\n", fminterval
, periodicstart
);
1793 } /* start controller operations */
1794 u132
->hc_control
&= OHCI_CTRL_RWC
;
1795 u132
->hc_control
|= OHCI_CONTROL_INIT
| OHCI_CTRL_BLE
| OHCI_USB_OPER
;
1796 retval
= u132_write_pcimem(u132
, control
, u132
->hc_control
);
1799 retval
= u132_write_pcimem_byte(u132
, cmdstatus
, OHCI_BLF
);
1802 retval
= u132_read_pcimem(u132
, cmdstatus
, &cmdstatus
);
1805 retval
= u132_read_pcimem(u132
, control
, &control
);
1808 u132_to_hcd(u132
)->state
= HC_STATE_RUNNING
;
1809 retval
= u132_write_pcimem(u132
, roothub
.status
, RH_HS_DRWE
);
1812 retval
= u132_write_pcimem(u132
, intrstatus
, mask
);
1815 retval
= u132_write_pcimem(u132
, intrdisable
,
1816 OHCI_INTR_MIE
| OHCI_INTR_OC
| OHCI_INTR_RHSC
| OHCI_INTR_FNO
|
1817 OHCI_INTR_UE
| OHCI_INTR_RD
| OHCI_INTR_SF
| OHCI_INTR_WDH
|
1820 return retval
; /* handle root hub init quirks ... */
1821 retval
= u132_read_pcimem(u132
, roothub
.a
, &roothub_a
);
1824 roothub_a
&= ~(RH_A_PSM
| RH_A_OCPM
);
1825 if (u132
->flags
& OHCI_QUIRK_SUPERIO
) {
1826 roothub_a
|= RH_A_NOCP
;
1827 roothub_a
&= ~(RH_A_POTPGT
| RH_A_NPS
);
1828 retval
= u132_write_pcimem(u132
, roothub
.a
, roothub_a
);
1831 } else if ((u132
->flags
& OHCI_QUIRK_AMD756
) || distrust_firmware
) {
1832 roothub_a
|= RH_A_NPS
;
1833 retval
= u132_write_pcimem(u132
, roothub
.a
, roothub_a
);
1837 retval
= u132_write_pcimem(u132
, roothub
.status
, RH_HS_LPSC
);
1840 retval
= u132_write_pcimem(u132
, roothub
.b
,
1841 (roothub_a
& RH_A_NPS
) ? 0 : RH_B_PPCM
);
1844 retval
= u132_read_pcimem(u132
, control
, &control
);
1847 mdelay((roothub_a
>> 23) & 0x1fe);
1848 u132_to_hcd(u132
)->state
= HC_STATE_RUNNING
;
1852 static void u132_hcd_stop(struct usb_hcd
*hcd
)
1854 struct u132
*u132
= hcd_to_u132(hcd
);
1855 if (u132
->going
> 1) {
1856 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
1858 } else if (u132
->going
> 0) {
1859 dev_err(&u132
->platform_dev
->dev
, "device hcd=%p is being remov"
1862 down(&u132
->sw_lock
);
1864 u132_power(u132
, 0);
1869 static int u132_hcd_start(struct usb_hcd
*hcd
)
1871 struct u132
*u132
= hcd_to_u132(hcd
);
1872 if (u132
->going
> 1) {
1873 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
1876 } else if (u132
->going
> 0) {
1877 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
1879 } else if (hcd
->self
.controller
) {
1881 struct platform_device
*pdev
=
1882 to_platform_device(hcd
->self
.controller
);
1883 u16 vendor
= ((struct u132_platform_data
*)
1884 (pdev
->dev
.platform_data
))->vendor
;
1885 u16 device
= ((struct u132_platform_data
*)
1886 (pdev
->dev
.platform_data
))->device
;
1887 down(&u132
->sw_lock
);
1889 if (vendor
== PCI_VENDOR_ID_AMD
&& device
== 0x740c) {
1890 u132
->flags
= OHCI_QUIRK_AMD756
;
1891 } else if (vendor
== PCI_VENDOR_ID_OPTI
&& device
== 0xc861) {
1892 dev_err(&u132
->platform_dev
->dev
, "WARNING: OPTi workar"
1893 "ounds unavailable\n");
1894 } else if (vendor
== PCI_VENDOR_ID_COMPAQ
&& device
== 0xa0f8)
1895 u132
->flags
|= OHCI_QUIRK_ZFMICRO
;
1896 retval
= u132_run(u132
);
1905 dev_err(&u132
->platform_dev
->dev
, "platform_device missing\n");
1910 static int u132_hcd_reset(struct usb_hcd
*hcd
)
1912 struct u132
*u132
= hcd_to_u132(hcd
);
1913 if (u132
->going
> 1) {
1914 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
1917 } else if (u132
->going
> 0) {
1918 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
1922 down(&u132
->sw_lock
);
1923 retval
= u132_init(u132
);
1933 static int create_endpoint_and_queue_int(struct u132
*u132
,
1934 struct u132_udev
*udev
, struct usb_host_endpoint
*hep
, struct urb
*urb
,
1935 struct usb_device
*usb_dev
, u8 usb_addr
, u8 usb_endp
, u8 address
,
1938 struct u132_ring
*ring
;
1940 u8 endp_number
= ++u132
->num_endpoints
;
1941 struct u132_endp
*endp
= hep
->hcpriv
= u132
->endp
[endp_number
- 1] =
1942 kmalloc(sizeof(struct u132_endp
), mem_flags
);
1946 INIT_WORK(&endp
->scheduler
, u132_hcd_endp_work_scheduler
, (void *)endp
);
1947 spin_lock_init(&endp
->queue_lock
.slock
);
1948 INIT_LIST_HEAD(&endp
->urb_more
);
1949 ring
= endp
->ring
= &u132
->ring
[0];
1950 if (ring
->curr_endp
) {
1951 list_add_tail(&endp
->endp_ring
, &ring
->curr_endp
->endp_ring
);
1953 INIT_LIST_HEAD(&endp
->endp_ring
);
1954 ring
->curr_endp
= endp
;
1957 endp
->dequeueing
= 0;
1958 endp
->edset_flush
= 0;
1961 endp
->endp_number
= endp_number
;
1964 endp
->pipetype
= usb_pipetype(urb
->pipe
);
1965 u132_endp_init_kref(u132
, endp
);
1966 if (usb_pipein(urb
->pipe
)) {
1967 endp
->toggle_bits
= 0x2;
1968 usb_settoggle(udev
->usb_device
, usb_endp
, 0, 0);
1971 udev
->endp_number_in
[usb_endp
] = endp_number
;
1972 u132_udev_get_kref(u132
, udev
);
1974 endp
->toggle_bits
= 0x2;
1975 usb_settoggle(udev
->usb_device
, usb_endp
, 1, 0);
1978 udev
->endp_number_out
[usb_endp
] = endp_number
;
1979 u132_udev_get_kref(u132
, udev
);
1982 spin_lock_irqsave(&endp
->queue_lock
.slock
, irqs
);
1984 endp
->jiffies
= jiffies
+ msecs_to_jiffies(urb
->interval
);
1985 endp
->udev_number
= address
;
1986 endp
->usb_addr
= usb_addr
;
1987 endp
->usb_endp
= usb_endp
;
1988 endp
->queue_size
= 1;
1989 endp
->queue_last
= 0;
1990 endp
->queue_next
= 0;
1991 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] = urb
;
1992 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
1993 u132_endp_queue_work(u132
, endp
, msecs_to_jiffies(urb
->interval
));
1997 static int queue_int_on_old_endpoint(struct u132
*u132
, struct u132_udev
*udev
,
1998 struct usb_host_endpoint
*hep
, struct urb
*urb
,
1999 struct usb_device
*usb_dev
, struct u132_endp
*endp
, u8 usb_addr
,
2000 u8 usb_endp
, u8 address
)
2004 endp
->jiffies
= jiffies
+ msecs_to_jiffies(urb
->interval
);
2005 if (endp
->queue_size
++ < ENDP_QUEUE_SIZE
) {
2006 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] = urb
;
2008 struct u132_urbq
*urbq
= kmalloc(sizeof(struct u132_urbq
),
2011 endp
->queue_size
-= 1;
2014 list_add_tail(&urbq
->urb_more
, &endp
->urb_more
);
2021 static int create_endpoint_and_queue_bulk(struct u132
*u132
,
2022 struct u132_udev
*udev
, struct usb_host_endpoint
*hep
, struct urb
*urb
,
2023 struct usb_device
*usb_dev
, u8 usb_addr
, u8 usb_endp
, u8 address
,
2027 struct u132_ring
*ring
;
2029 u8 endp_number
= ++u132
->num_endpoints
;
2030 struct u132_endp
*endp
= hep
->hcpriv
= u132
->endp
[endp_number
- 1] =
2031 kmalloc(sizeof(struct u132_endp
), mem_flags
);
2035 INIT_WORK(&endp
->scheduler
, u132_hcd_endp_work_scheduler
, (void *)endp
);
2036 spin_lock_init(&endp
->queue_lock
.slock
);
2037 INIT_LIST_HEAD(&endp
->urb_more
);
2038 endp
->dequeueing
= 0;
2039 endp
->edset_flush
= 0;
2042 endp
->endp_number
= endp_number
;
2045 endp
->pipetype
= usb_pipetype(urb
->pipe
);
2046 u132_endp_init_kref(u132
, endp
);
2047 if (usb_pipein(urb
->pipe
)) {
2048 endp
->toggle_bits
= 0x2;
2049 usb_settoggle(udev
->usb_device
, usb_endp
, 0, 0);
2053 udev
->endp_number_in
[usb_endp
] = endp_number
;
2054 u132_udev_get_kref(u132
, udev
);
2056 endp
->toggle_bits
= 0x2;
2057 usb_settoggle(udev
->usb_device
, usb_endp
, 1, 0);
2061 udev
->endp_number_out
[usb_endp
] = endp_number
;
2062 u132_udev_get_kref(u132
, udev
);
2064 ring
= endp
->ring
= &u132
->ring
[ring_number
- 1];
2065 if (ring
->curr_endp
) {
2066 list_add_tail(&endp
->endp_ring
, &ring
->curr_endp
->endp_ring
);
2068 INIT_LIST_HEAD(&endp
->endp_ring
);
2069 ring
->curr_endp
= endp
;
2073 spin_lock_irqsave(&endp
->queue_lock
.slock
, irqs
);
2074 endp
->udev_number
= address
;
2075 endp
->usb_addr
= usb_addr
;
2076 endp
->usb_endp
= usb_endp
;
2077 endp
->queue_size
= 1;
2078 endp
->queue_last
= 0;
2079 endp
->queue_next
= 0;
2080 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] = urb
;
2081 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
2082 u132_endp_queue_work(u132
, endp
, 0);
2086 static int queue_bulk_on_old_endpoint(struct u132
*u132
, struct u132_udev
*udev
,
2087 struct usb_host_endpoint
*hep
, struct urb
*urb
,
2088 struct usb_device
*usb_dev
, struct u132_endp
*endp
, u8 usb_addr
,
2089 u8 usb_endp
, u8 address
)
2092 if (endp
->queue_size
++ < ENDP_QUEUE_SIZE
) {
2093 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] = urb
;
2095 struct u132_urbq
*urbq
= kmalloc(sizeof(struct u132_urbq
),
2098 endp
->queue_size
-= 1;
2101 list_add_tail(&urbq
->urb_more
, &endp
->urb_more
);
2108 static int create_endpoint_and_queue_control(struct u132
*u132
,
2109 struct usb_host_endpoint
*hep
, struct urb
*urb
,
2110 struct usb_device
*usb_dev
, u8 usb_addr
, u8 usb_endp
,
2113 struct u132_ring
*ring
;
2114 u8 endp_number
= ++u132
->num_endpoints
;
2115 struct u132_endp
*endp
= hep
->hcpriv
= u132
->endp
[endp_number
- 1] =
2116 kmalloc(sizeof(struct u132_endp
), mem_flags
);
2120 INIT_WORK(&endp
->scheduler
, u132_hcd_endp_work_scheduler
, (void *)endp
);
2121 spin_lock_init(&endp
->queue_lock
.slock
);
2122 INIT_LIST_HEAD(&endp
->urb_more
);
2123 ring
= endp
->ring
= &u132
->ring
[0];
2124 if (ring
->curr_endp
) {
2125 list_add_tail(&endp
->endp_ring
, &ring
->curr_endp
->endp_ring
);
2127 INIT_LIST_HEAD(&endp
->endp_ring
);
2128 ring
->curr_endp
= endp
;
2131 endp
->dequeueing
= 0;
2132 endp
->edset_flush
= 0;
2135 endp
->endp_number
= endp_number
;
2138 u132_endp_init_kref(u132
, endp
);
2139 u132_endp_get_kref(u132
, endp
);
2140 if (usb_addr
== 0) {
2142 u8 address
= u132
->addr
[usb_addr
].address
;
2143 struct u132_udev
*udev
= &u132
->udev
[address
];
2144 endp
->udev_number
= address
;
2145 endp
->usb_addr
= usb_addr
;
2146 endp
->usb_endp
= usb_endp
;
2149 endp
->pipetype
= usb_pipetype(urb
->pipe
);
2150 u132_udev_init_kref(u132
, udev
);
2151 u132_udev_get_kref(u132
, udev
);
2152 udev
->endp_number_in
[usb_endp
] = endp_number
;
2153 udev
->endp_number_out
[usb_endp
] = endp_number
;
2155 spin_lock_irqsave(&endp
->queue_lock
.slock
, irqs
);
2156 endp
->queue_size
= 1;
2157 endp
->queue_last
= 0;
2158 endp
->queue_next
= 0;
2159 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] = urb
;
2160 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
2161 u132_endp_queue_work(u132
, endp
, 0);
2163 } else { /*(usb_addr > 0) */
2165 u8 address
= u132
->addr
[usb_addr
].address
;
2166 struct u132_udev
*udev
= &u132
->udev
[address
];
2167 endp
->udev_number
= address
;
2168 endp
->usb_addr
= usb_addr
;
2169 endp
->usb_endp
= usb_endp
;
2172 endp
->pipetype
= usb_pipetype(urb
->pipe
);
2173 u132_udev_get_kref(u132
, udev
);
2174 udev
->enumeration
= 2;
2175 udev
->endp_number_in
[usb_endp
] = endp_number
;
2176 udev
->endp_number_out
[usb_endp
] = endp_number
;
2178 spin_lock_irqsave(&endp
->queue_lock
.slock
, irqs
);
2179 endp
->queue_size
= 1;
2180 endp
->queue_last
= 0;
2181 endp
->queue_next
= 0;
2182 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] = urb
;
2183 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
2184 u132_endp_queue_work(u132
, endp
, 0);
2189 static int queue_control_on_old_endpoint(struct u132
*u132
,
2190 struct usb_host_endpoint
*hep
, struct urb
*urb
,
2191 struct usb_device
*usb_dev
, struct u132_endp
*endp
, u8 usb_addr
,
2194 if (usb_addr
== 0) {
2195 if (usb_pipein(urb
->pipe
)) {
2197 if (endp
->queue_size
++ < ENDP_QUEUE_SIZE
) {
2198 endp
->urb_list
[ENDP_QUEUE_MASK
&
2199 endp
->queue_last
++] = urb
;
2201 struct u132_urbq
*urbq
=
2202 kmalloc(sizeof(struct u132_urbq
),
2205 endp
->queue_size
-= 1;
2208 list_add_tail(&urbq
->urb_more
,
2214 } else { /* usb_pipeout(urb->pipe) */
2215 struct u132_addr
*addr
= &u132
->addr
[usb_dev
->devnum
];
2216 int I
= MAX_U132_UDEVS
;
2219 struct u132_udev
*udev
= &u132
->udev
[++i
];
2220 if (udev
->usb_device
) {
2223 udev
->enumeration
= 1;
2224 u132
->addr
[0].address
= i
;
2225 endp
->udev_number
= i
;
2226 udev
->udev_number
= i
;
2227 udev
->usb_addr
= usb_dev
->devnum
;
2228 u132_udev_init_kref(u132
, udev
);
2229 udev
->endp_number_in
[usb_endp
] =
2231 u132_udev_get_kref(u132
, udev
);
2232 udev
->endp_number_out
[usb_endp
] =
2234 udev
->usb_device
= usb_dev
;
2235 ((u8
*) (urb
->setup_packet
))[2] =
2237 u132_udev_get_kref(u132
, udev
);
2242 dev_err(&u132
->platform_dev
->dev
, "run out of d"
2247 if (endp
->queue_size
++ < ENDP_QUEUE_SIZE
) {
2248 endp
->urb_list
[ENDP_QUEUE_MASK
&
2249 endp
->queue_last
++] = urb
;
2251 struct u132_urbq
*urbq
=
2252 kmalloc(sizeof(struct u132_urbq
),
2255 endp
->queue_size
-= 1;
2258 list_add_tail(&urbq
->urb_more
,
2265 } else { /*(usb_addr > 0) */
2266 u8 address
= u132
->addr
[usb_addr
].address
;
2267 struct u132_udev
*udev
= &u132
->udev
[address
];
2269 if (udev
->enumeration
== 2) {
2271 udev
->enumeration
= 2;
2272 if (endp
->queue_size
++ < ENDP_QUEUE_SIZE
) {
2273 endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_last
++] =
2276 struct u132_urbq
*urbq
=
2277 kmalloc(sizeof(struct u132_urbq
), GFP_ATOMIC
);
2279 endp
->queue_size
-= 1;
2282 list_add_tail(&urbq
->urb_more
, &endp
->urb_more
);
2290 static int u132_urb_enqueue(struct usb_hcd
*hcd
, struct usb_host_endpoint
*hep
,
2291 struct urb
*urb
, gfp_t mem_flags
)
2293 struct u132
*u132
= hcd_to_u132(hcd
);
2294 if (irqs_disabled()) {
2295 if (__GFP_WAIT
& mem_flags
) {
2296 printk(KERN_ERR
"invalid context for function that migh"
2301 if (u132
->going
> 1) {
2302 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
2305 } else if (u132
->going
> 0) {
2306 dev_err(&u132
->platform_dev
->dev
, "device is being removed urb="
2307 "%p status=%d\n", urb
, urb
->status
);
2310 u8 usb_addr
= usb_pipedevice(urb
->pipe
);
2311 u8 usb_endp
= usb_pipeendpoint(urb
->pipe
);
2312 struct usb_device
*usb_dev
= urb
->dev
;
2313 if (usb_pipetype(urb
->pipe
) == PIPE_INTERRUPT
) {
2314 u8 address
= u132
->addr
[usb_addr
].address
;
2315 struct u132_udev
*udev
= &u132
->udev
[address
];
2316 struct u132_endp
*endp
= hep
->hcpriv
;
2317 urb
->actual_length
= 0;
2321 spin_lock_irqsave(&endp
->queue_lock
.slock
,
2323 retval
= queue_int_on_old_endpoint(u132
, udev
,
2324 hep
, urb
, usb_dev
, endp
, usb_addr
,
2326 spin_unlock_irqrestore(&endp
->queue_lock
.slock
,
2331 u132_endp_queue_work(u132
, endp
,
2332 msecs_to_jiffies(urb
->interval
))
2336 } else if (u132
->num_endpoints
== MAX_U132_ENDPS
) {
2338 } else { /*(endp == NULL) */
2339 return create_endpoint_and_queue_int(u132
, udev
,
2340 hep
, urb
, usb_dev
, usb_addr
, usb_endp
,
2341 address
, mem_flags
);
2343 } else if (usb_pipetype(urb
->pipe
) == PIPE_ISOCHRONOUS
) {
2344 dev_err(&u132
->platform_dev
->dev
, "the hardware does no"
2345 "t support PIPE_ISOCHRONOUS\n");
2347 } else if (usb_pipetype(urb
->pipe
) == PIPE_BULK
) {
2348 u8 address
= u132
->addr
[usb_addr
].address
;
2349 struct u132_udev
*udev
= &u132
->udev
[address
];
2350 struct u132_endp
*endp
= hep
->hcpriv
;
2351 urb
->actual_length
= 0;
2355 spin_lock_irqsave(&endp
->queue_lock
.slock
,
2357 retval
= queue_bulk_on_old_endpoint(u132
, udev
,
2358 hep
, urb
, usb_dev
, endp
, usb_addr
,
2360 spin_unlock_irqrestore(&endp
->queue_lock
.slock
,
2365 u132_endp_queue_work(u132
, endp
, 0);
2368 } else if (u132
->num_endpoints
== MAX_U132_ENDPS
) {
2371 return create_endpoint_and_queue_bulk(u132
,
2372 udev
, hep
, urb
, usb_dev
, usb_addr
,
2373 usb_endp
, address
, mem_flags
);
2375 struct u132_endp
*endp
= hep
->hcpriv
;
2377 u8
*b
= urb
->setup_packet
;
2379 char data
[30 *3 + 4];
2381 int m
= (sizeof(data
) - 1) / 3;
2384 while (urb_size
-- > 0) {
2386 } else if (i
++ < m
) {
2387 int w
= sprintf(d
, " %02X", *b
++);
2391 d
+= sprintf(d
, " ..");
2396 spin_lock_irqsave(&endp
->queue_lock
.slock
,
2398 retval
= queue_control_on_old_endpoint(u132
,
2399 hep
, urb
, usb_dev
, endp
, usb_addr
,
2401 spin_unlock_irqrestore(&endp
->queue_lock
.slock
,
2406 u132_endp_queue_work(u132
, endp
, 0);
2409 } else if (u132
->num_endpoints
== MAX_U132_ENDPS
) {
2412 return create_endpoint_and_queue_control(u132
,
2413 hep
, urb
, usb_dev
, usb_addr
, usb_endp
,
2419 static int dequeue_from_overflow_chain(struct u132
*u132
,
2420 struct u132_endp
*endp
, struct urb
*urb
)
2422 struct list_head
*scan
;
2423 struct list_head
*head
= &endp
->urb_more
;
2424 list_for_each(scan
, head
) {
2425 struct u132_urbq
*urbq
= list_entry(scan
, struct u132_urbq
,
2427 if (urbq
->urb
== urb
) {
2428 struct usb_hcd
*hcd
= u132_to_hcd(u132
);
2430 endp
->queue_size
-= 1;
2431 urb
->error_count
= 0;
2433 usb_hcd_giveback_urb(hcd
, urb
);
2438 dev_err(&u132
->platform_dev
->dev
, "urb=%p not found in endp[%d]=%p ring"
2439 "[%d] %c%c usb_endp=%d usb_addr=%d size=%d next=%04X last=%04X"
2440 "\n", urb
, endp
->endp_number
, endp
, endp
->ring
->number
,
2441 endp
->input
? 'I' : ' ', endp
->output
? 'O' : ' ',
2442 endp
->usb_endp
, endp
->usb_addr
, endp
->queue_size
,
2443 endp
->queue_next
, endp
->queue_last
);
2447 static int u132_endp_urb_dequeue(struct u132
*u132
, struct u132_endp
*endp
,
2451 spin_lock_irqsave(&endp
->queue_lock
.slock
, irqs
);
2452 if (endp
->queue_size
== 0) {
2453 dev_err(&u132
->platform_dev
->dev
, "urb=%p not found in endp[%d]"
2454 "=%p ring[%d] %c%c usb_endp=%d usb_addr=%d\n", urb
,
2455 endp
->endp_number
, endp
, endp
->ring
->number
,
2456 endp
->input
? 'I' : ' ', endp
->output
? 'O' : ' ',
2457 endp
->usb_endp
, endp
->usb_addr
);
2458 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
2461 if (urb
== endp
->urb_list
[ENDP_QUEUE_MASK
& endp
->queue_next
]) {
2463 endp
->dequeueing
= 1;
2464 endp
->edset_flush
= 1;
2465 u132_endp_queue_work(u132
, endp
, 0);
2466 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
2470 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
2471 u132_hcd_abandon_urb(u132
, endp
, urb
, urb
->status
);
2476 u16 queue_size
= endp
->queue_size
;
2477 u16 queue_scan
= endp
->queue_next
;
2478 struct urb
**urb_slot
= NULL
;
2479 while (++queue_list
< ENDP_QUEUE_SIZE
&& --queue_size
> 0) {
2480 if (urb
== endp
->urb_list
[ENDP_QUEUE_MASK
&
2482 urb_slot
= &endp
->urb_list
[ENDP_QUEUE_MASK
&
2488 while (++queue_list
< ENDP_QUEUE_SIZE
&& --queue_size
> 0) {
2489 *urb_slot
= endp
->urb_list
[ENDP_QUEUE_MASK
&
2491 urb_slot
= &endp
->urb_list
[ENDP_QUEUE_MASK
&
2495 struct usb_hcd
*hcd
= u132_to_hcd(u132
);
2496 endp
->queue_size
-= 1;
2497 if (list_empty(&endp
->urb_more
)) {
2498 spin_unlock_irqrestore(&endp
->queue_lock
.slock
,
2501 struct list_head
*next
= endp
->urb_more
.next
;
2502 struct u132_urbq
*urbq
= list_entry(next
,
2503 struct u132_urbq
, urb_more
);
2505 *urb_slot
= urbq
->urb
;
2506 spin_unlock_irqrestore(&endp
->queue_lock
.slock
,
2509 } urb
->error_count
= 0;
2511 usb_hcd_giveback_urb(hcd
, urb
);
2513 } else if (list_empty(&endp
->urb_more
)) {
2514 dev_err(&u132
->platform_dev
->dev
, "urb=%p not found in "
2515 "endp[%d]=%p ring[%d] %c%c usb_endp=%d usb_addr"
2516 "=%d size=%d next=%04X last=%04X\n", urb
,
2517 endp
->endp_number
, endp
, endp
->ring
->number
,
2518 endp
->input
? 'I' : ' ',
2519 endp
->output
? 'O' : ' ', endp
->usb_endp
,
2520 endp
->usb_addr
, endp
->queue_size
,
2521 endp
->queue_next
, endp
->queue_last
);
2522 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
2525 int retval
= dequeue_from_overflow_chain(u132
, endp
,
2527 spin_unlock_irqrestore(&endp
->queue_lock
.slock
, irqs
);
2533 static int u132_urb_dequeue(struct usb_hcd
*hcd
, struct urb
*urb
)
2535 struct u132
*u132
= hcd_to_u132(hcd
);
2536 if (u132
->going
> 2) {
2537 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
2541 u8 usb_addr
= usb_pipedevice(urb
->pipe
);
2542 u8 usb_endp
= usb_pipeendpoint(urb
->pipe
);
2543 u8 address
= u132
->addr
[usb_addr
].address
;
2544 struct u132_udev
*udev
= &u132
->udev
[address
];
2545 if (usb_pipein(urb
->pipe
)) {
2546 u8 endp_number
= udev
->endp_number_in
[usb_endp
];
2547 struct u132_endp
*endp
= u132
->endp
[endp_number
- 1];
2548 return u132_endp_urb_dequeue(u132
, endp
, urb
);
2550 u8 endp_number
= udev
->endp_number_out
[usb_endp
];
2551 struct u132_endp
*endp
= u132
->endp
[endp_number
- 1];
2552 return u132_endp_urb_dequeue(u132
, endp
, urb
);
2557 static void u132_endpoint_disable(struct usb_hcd
*hcd
,
2558 struct usb_host_endpoint
*hep
)
2560 struct u132
*u132
= hcd_to_u132(hcd
);
2561 if (u132
->going
> 2) {
2562 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
2565 struct u132_endp
*endp
= hep
->hcpriv
;
2567 u132_endp_put_kref(u132
, endp
);
2571 static int u132_get_frame(struct usb_hcd
*hcd
)
2573 struct u132
*u132
= hcd_to_u132(hcd
);
2574 if (u132
->going
> 1) {
2575 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
2578 } else if (u132
->going
> 0) {
2579 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2583 dev_err(&u132
->platform_dev
->dev
, "TODO: u132_get_frame\n");
2589 static int u132_roothub_descriptor(struct u132
*u132
,
2590 struct usb_hub_descriptor
*desc
)
2596 retval
= u132_read_pcimem(u132
, roothub
.a
, &rh_a
);
2599 desc
->bDescriptorType
= 0x29;
2600 desc
->bPwrOn2PwrGood
= (rh_a
& RH_A_POTPGT
) >> 24;
2601 desc
->bHubContrCurrent
= 0;
2602 desc
->bNbrPorts
= u132
->num_ports
;
2603 temp
= 1 + (u132
->num_ports
/ 8);
2604 desc
->bDescLength
= 7 + 2 *temp
;
2606 if (rh_a
& RH_A_NPS
)
2608 if (rh_a
& RH_A_PSM
)
2610 if (rh_a
& RH_A_NOCP
) {
2612 } else if (rh_a
& RH_A_OCPM
)
2614 desc
->wHubCharacteristics
= cpu_to_le16(temp
);
2615 retval
= u132_read_pcimem(u132
, roothub
.b
, &rh_b
);
2618 memset(desc
->bitmap
, 0xff, sizeof(desc
->bitmap
));
2619 desc
->bitmap
[0] = rh_b
& RH_B_DR
;
2620 if (u132
->num_ports
> 7) {
2621 desc
->bitmap
[1] = (rh_b
& RH_B_DR
) >> 8;
2622 desc
->bitmap
[2] = 0xff;
2624 desc
->bitmap
[1] = 0xff;
2628 static int u132_roothub_status(struct u132
*u132
, __le32
*desc
)
2631 int ret_status
= u132_read_pcimem(u132
, roothub
.status
, &rh_status
);
2632 *desc
= cpu_to_le32(rh_status
);
2636 static int u132_roothub_portstatus(struct u132
*u132
, __le32
*desc
, u16 wIndex
)
2638 if (wIndex
== 0 || wIndex
> u132
->num_ports
) {
2641 int port
= wIndex
- 1;
2642 u32 rh_portstatus
= -1;
2643 int ret_portstatus
= u132_read_pcimem(u132
,
2644 roothub
.portstatus
[port
], &rh_portstatus
);
2645 *desc
= cpu_to_le32(rh_portstatus
);
2646 if (*(u16
*) (desc
+ 2)) {
2647 dev_info(&u132
->platform_dev
->dev
, "Port %d Status Chan"
2648 "ge = %08X\n", port
, *desc
);
2650 return ret_portstatus
;
2655 /* this timer value might be vendor-specific ... */
2656 #define PORT_RESET_HW_MSEC 10
2657 #define PORT_RESET_MSEC 10
2658 /* wrap-aware logic morphed from <linux/jiffies.h> */
2659 #define tick_before(t1, t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
2660 static int u132_roothub_portreset(struct u132
*u132
, int port_index
)
2666 retval
= u132_read_pcimem(u132
, fmnumber
, &fmnumber
);
2670 reset_done
= now
+ PORT_RESET_MSEC
;
2674 retval
= u132_read_pcimem(u132
,
2675 roothub
.portstatus
[port_index
], &portstat
);
2678 if (RH_PS_PRS
& portstat
) {
2682 } while (tick_before(now
, reset_done
));
2683 if (RH_PS_PRS
& portstat
)
2685 if (RH_PS_CCS
& portstat
) {
2686 if (RH_PS_PRSC
& portstat
) {
2687 retval
= u132_write_pcimem(u132
,
2688 roothub
.portstatus
[port_index
],
2694 break; /* start the next reset,
2695 sleep till it's probably done */
2696 retval
= u132_write_pcimem(u132
, roothub
.portstatus
[port_index
],
2700 msleep(PORT_RESET_HW_MSEC
);
2701 retval
= u132_read_pcimem(u132
, fmnumber
, &fmnumber
);
2705 } while (tick_before(now
, reset_done
));
2709 static int u132_roothub_setportfeature(struct u132
*u132
, u16 wValue
,
2712 if (wIndex
== 0 || wIndex
> u132
->num_ports
) {
2716 int port_index
= wIndex
- 1;
2717 struct u132_port
*port
= &u132
->port
[port_index
];
2718 port
->Status
&= ~(1 << wValue
);
2720 case USB_PORT_FEAT_SUSPEND
:
2721 retval
= u132_write_pcimem(u132
,
2722 roothub
.portstatus
[port_index
], RH_PS_PSS
);
2726 case USB_PORT_FEAT_POWER
:
2727 retval
= u132_write_pcimem(u132
,
2728 roothub
.portstatus
[port_index
], RH_PS_PPS
);
2732 case USB_PORT_FEAT_RESET
:
2733 retval
= u132_roothub_portreset(u132
, port_index
);
2743 static int u132_roothub_clearportfeature(struct u132
*u132
, u16 wValue
,
2746 if (wIndex
== 0 || wIndex
> u132
->num_ports
) {
2749 int port_index
= wIndex
- 1;
2752 struct u132_port
*port
= &u132
->port
[port_index
];
2753 port
->Status
&= ~(1 << wValue
);
2755 case USB_PORT_FEAT_ENABLE
:
2758 case USB_PORT_FEAT_C_ENABLE
:
2761 case USB_PORT_FEAT_SUSPEND
:
2763 if ((u132
->hc_control
& OHCI_CTRL_HCFS
)
2765 dev_err(&u132
->platform_dev
->dev
, "TODO resume_"
2769 case USB_PORT_FEAT_C_SUSPEND
:
2772 case USB_PORT_FEAT_POWER
:
2775 case USB_PORT_FEAT_C_CONNECTION
:
2778 case USB_PORT_FEAT_C_OVER_CURRENT
:
2781 case USB_PORT_FEAT_C_RESET
:
2787 retval
= u132_write_pcimem(u132
, roothub
.portstatus
[port_index
],
2796 /* the virtual root hub timer IRQ checks for hub status*/
2797 static int u132_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
2799 struct u132
*u132
= hcd_to_u132(hcd
);
2800 if (u132
->going
> 1) {
2801 dev_err(&u132
->platform_dev
->dev
, "device hcd=%p has been remov"
2802 "ed %d\n", hcd
, u132
->going
);
2804 } else if (u132
->going
> 0) {
2805 dev_err(&u132
->platform_dev
->dev
, "device hcd=%p is being remov"
2810 int i
, changed
= 0, length
= 1;
2811 if (u132
->flags
& OHCI_QUIRK_AMD756
) {
2812 if ((u132
->hc_roothub_a
& RH_A_NDP
) > MAX_ROOT_PORTS
) {
2813 dev_err(&u132
->platform_dev
->dev
, "bogus NDP, r"
2814 "ereads as NDP=%d\n",
2815 u132
->hc_roothub_a
& RH_A_NDP
);
2819 if (u132
->hc_roothub_status
& (RH_HS_LPSC
| RH_HS_OCIC
)) {
2820 buf
[0] = changed
= 1;
2823 if (u132
->num_ports
> 7) {
2827 for (i
= 0; i
< u132
->num_ports
; i
++) {
2828 if (u132
->hc_roothub_portstatus
[i
] & (RH_PS_CSC
|
2829 RH_PS_PESC
| RH_PS_PSSC
| RH_PS_OCIC
|
2833 buf
[0] |= 1 << (i
+ 1);
2835 buf
[1] |= 1 << (i
- 7);
2838 if (!(u132
->hc_roothub_portstatus
[i
] & RH_PS_CCS
)) {
2841 if ((u132
->hc_roothub_portstatus
[i
] & RH_PS_PSS
)) {
2845 done
:return changed
? length
: 0;
2849 static int u132_hub_control(struct usb_hcd
*hcd
, u16 typeReq
, u16 wValue
,
2850 u16 wIndex
, char *buf
, u16 wLength
)
2852 struct u132
*u132
= hcd_to_u132(hcd
);
2853 if (u132
->going
> 1) {
2854 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
2857 } else if (u132
->going
> 0) {
2858 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2862 down(&u132
->sw_lock
);
2864 case ClearHubFeature
:
2866 case C_HUB_OVER_CURRENT
:
2867 case C_HUB_LOCAL_POWER
:
2875 case C_HUB_OVER_CURRENT
:
2876 case C_HUB_LOCAL_POWER
:
2882 case ClearPortFeature
:{
2883 retval
= u132_roothub_clearportfeature(u132
,
2889 case GetHubDescriptor
:{
2890 retval
= u132_roothub_descriptor(u132
,
2891 (struct usb_hub_descriptor
*)buf
);
2897 retval
= u132_roothub_status(u132
,
2903 case GetPortStatus
:{
2904 retval
= u132_roothub_portstatus(u132
,
2905 (__le32
*) buf
, wIndex
);
2910 case SetPortFeature
:{
2911 retval
= u132_roothub_setportfeature(u132
,
2919 error
:u132_disable(u132
);
2922 stall
:retval
= -EPIPE
;
2930 static int u132_start_port_reset(struct usb_hcd
*hcd
, unsigned port_num
)
2932 struct u132
*u132
= hcd_to_u132(hcd
);
2933 if (u132
->going
> 1) {
2934 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
2937 } else if (u132
->going
> 0) {
2938 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2944 static void u132_hub_irq_enable(struct usb_hcd
*hcd
)
2946 struct u132
*u132
= hcd_to_u132(hcd
);
2947 if (u132
->going
> 1) {
2948 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
2950 } else if (u132
->going
> 0)
2951 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2956 static int u132_hcd_suspend(struct usb_hcd
*hcd
, pm_message_t message
)
2958 struct u132
*u132
= hcd_to_u132(hcd
);
2959 if (u132
->going
> 1) {
2960 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
2963 } else if (u132
->going
> 0) {
2964 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2970 static int u132_hcd_resume(struct usb_hcd
*hcd
)
2972 struct u132
*u132
= hcd_to_u132(hcd
);
2973 if (u132
->going
> 1) {
2974 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
2977 } else if (u132
->going
> 0) {
2978 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2984 static int u132_bus_suspend(struct usb_hcd
*hcd
)
2986 struct u132
*u132
= hcd_to_u132(hcd
);
2987 if (u132
->going
> 1) {
2988 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
2991 } else if (u132
->going
> 0) {
2992 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
2998 static int u132_bus_resume(struct usb_hcd
*hcd
)
3000 struct u132
*u132
= hcd_to_u132(hcd
);
3001 if (u132
->going
> 1) {
3002 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
3005 } else if (u132
->going
> 0) {
3006 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
3013 #define u132_hcd_suspend NULL
3014 #define u132_hcd_resume NULL
3015 #define u132_bus_suspend NULL
3016 #define u132_bus_resume NULL
3018 static struct hc_driver u132_hc_driver
= {
3019 .description
= hcd_name
,
3020 .hcd_priv_size
= sizeof(struct u132
),
3022 .flags
= HCD_USB11
| HCD_MEMORY
,
3023 .reset
= u132_hcd_reset
,
3024 .start
= u132_hcd_start
,
3025 .suspend
= u132_hcd_suspend
,
3026 .resume
= u132_hcd_resume
,
3027 .stop
= u132_hcd_stop
,
3028 .urb_enqueue
= u132_urb_enqueue
,
3029 .urb_dequeue
= u132_urb_dequeue
,
3030 .endpoint_disable
= u132_endpoint_disable
,
3031 .get_frame_number
= u132_get_frame
,
3032 .hub_status_data
= u132_hub_status_data
,
3033 .hub_control
= u132_hub_control
,
3034 .bus_suspend
= u132_bus_suspend
,
3035 .bus_resume
= u132_bus_resume
,
3036 .start_port_reset
= u132_start_port_reset
,
3037 .hub_irq_enable
= u132_hub_irq_enable
,
3041 * This function may be called by the USB core whilst the "usb_all_devices_rwsem"
3042 * is held for writing, thus this module must not call usb_remove_hcd()
3043 * synchronously - but instead should immediately stop activity to the
3044 * device and asynchronously call usb_remove_hcd()
3046 static int __devexit
u132_remove(struct platform_device
*pdev
)
3048 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
3050 struct u132
*u132
= hcd_to_u132(hcd
);
3052 if (u132
->going
++ > 1) {
3055 int rings
= MAX_U132_RINGS
;
3056 int endps
= MAX_U132_ENDPS
;
3058 down(&u132
->sw_lock
);
3059 u132_monitor_cancel_work(u132
);
3060 while (rings
-- > 0) {
3061 struct u132_ring
*ring
= &u132
->ring
[rings
];
3062 u132_ring_cancel_work(u132
, ring
);
3063 } while (endps
-- > 0) {
3064 struct u132_endp
*endp
= u132
->endp
[endps
];
3066 u132_endp_cancel_work(u132
, endp
);
3069 printk(KERN_INFO
"removing device u132.%d\n",
3070 u132
->sequence_num
);
3072 usb_remove_hcd(hcd
);
3073 u132_u132_put_kref(u132
);
3080 static void u132_initialise(struct u132
*u132
, struct platform_device
*pdev
)
3082 int rings
= MAX_U132_RINGS
;
3083 int ports
= MAX_U132_PORTS
;
3084 int addrs
= MAX_U132_ADDRS
;
3085 int udevs
= MAX_U132_UDEVS
;
3086 int endps
= MAX_U132_ENDPS
;
3087 u132
->board
= pdev
->dev
.platform_data
;
3088 u132
->platform_dev
= pdev
;
3091 init_MUTEX(&u132
->sw_lock
);
3092 init_MUTEX(&u132
->scheduler_lock
);
3093 while (rings
-- > 0) {
3094 struct u132_ring
*ring
= &u132
->ring
[rings
];
3096 ring
->number
= rings
+ 1;
3098 ring
->curr_endp
= NULL
;
3099 INIT_WORK(&ring
->scheduler
, u132_hcd_ring_work_scheduler
,
3101 } down(&u132
->sw_lock
);
3102 INIT_WORK(&u132
->monitor
, u132_hcd_monitor_work
, (void *)u132
);
3103 while (ports
-- > 0) {
3104 struct u132_port
*port
= &u132
->port
[ports
];
3110 } while (addrs
-- > 0) {
3111 struct u132_addr
*addr
= &u132
->addr
[addrs
];
3113 } while (udevs
-- > 0) {
3114 struct u132_udev
*udev
= &u132
->udev
[udevs
];
3115 int i
= ARRAY_SIZE(udev
->endp_number_in
);
3116 int o
= ARRAY_SIZE(udev
->endp_number_out
);
3117 udev
->usb_device
= NULL
;
3118 udev
->udev_number
= 0;
3120 udev
->portnumber
= 0;
3122 udev
->endp_number_in
[i
] = 0;
3125 udev
->endp_number_out
[o
] = 0;
3128 while (endps
-- > 0) {
3129 u132
->endp
[endps
] = NULL
;
3135 static int __devinit
u132_probe(struct platform_device
*pdev
)
3137 struct usb_hcd
*hcd
;
3139 if (u132_exiting
> 0) {
3141 } /* refuse to confuse usbcore */
3142 if (pdev
->dev
.dma_mask
) {
3145 hcd
= usb_create_hcd(&u132_hc_driver
, &pdev
->dev
, pdev
->dev
.bus_id
);
3147 printk(KERN_ERR
"failed to create the usb hcd struct for U132\n"
3149 ftdi_elan_gone_away(pdev
);
3153 struct u132
*u132
= hcd_to_u132(hcd
);
3154 hcd
->rsrc_start
= 0;
3155 down(&u132_module_lock
);
3156 list_add_tail(&u132
->u132_list
, &u132_static_list
);
3157 u132
->sequence_num
= ++u132_instances
;
3158 up(&u132_module_lock
);
3159 u132_u132_init_kref(u132
);
3160 u132_initialise(u132
, pdev
);
3161 hcd
->product_desc
= "ELAN U132 Host Controller";
3162 retval
= usb_add_hcd(hcd
, 0, 0);
3164 dev_err(&u132
->platform_dev
->dev
, "init error %d\n",
3166 u132_u132_put_kref(u132
);
3169 u132_monitor_queue_work(u132
, 100);
3177 /* for this device there's no useful distinction between the controller
3178 * and its root hub, except that the root hub only gets direct PM calls
3179 * when CONFIG_USB_SUSPEND is enabled.
3181 static int u132_suspend(struct platform_device
*pdev
, pm_message_t state
)
3183 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
3184 struct u132
*u132
= hcd_to_u132(hcd
);
3185 if (u132
->going
> 1) {
3186 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
3189 } else if (u132
->going
> 0) {
3190 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
3194 if (state
.event
== PM_EVENT_FREEZE
) {
3195 retval
= u132_bus_suspend(hcd
);
3196 } else if (state
.event
== PM_EVENT_SUSPEND
) {
3197 int ports
= MAX_U132_PORTS
;
3198 while (ports
-- > 0) {
3199 port_power(u132
, ports
, 0);
3203 pdev
->dev
.power
.power_state
= state
;
3208 static int u132_resume(struct platform_device
*pdev
)
3210 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
3211 struct u132
*u132
= hcd_to_u132(hcd
);
3212 if (u132
->going
> 1) {
3213 dev_err(&u132
->platform_dev
->dev
, "device has been removed %d\n"
3216 } else if (u132
->going
> 0) {
3217 dev_err(&u132
->platform_dev
->dev
, "device is being removed\n");
3221 if (pdev
->dev
.power
.power_state
.event
== PM_EVENT_SUSPEND
) {
3222 int ports
= MAX_U132_PORTS
;
3223 while (ports
-- > 0) {
3224 port_power(u132
, ports
, 1);
3228 pdev
->dev
.power
.power_state
= PMSG_ON
;
3229 retval
= u132_bus_resume(hcd
);
3236 #define u132_suspend NULL
3237 #define u132_resume NULL
3240 * this driver is loaded explicitly by ftdi_u132
3242 * the platform_driver struct is static because it is per type of module
3244 static struct platform_driver u132_platform_driver
= {
3245 .probe
= u132_probe
,
3246 .remove
= __devexit_p(u132_remove
),
3247 .suspend
= u132_suspend
,
3248 .resume
= u132_resume
,
3250 .name
= (char *)hcd_name
,
3251 .owner
= THIS_MODULE
,
3254 static int __init
u132_hcd_init(void)
3257 INIT_LIST_HEAD(&u132_static_list
);
3260 init_MUTEX(&u132_module_lock
);
3263 printk(KERN_INFO
"driver %s built at %s on %s\n", hcd_name
, __TIME__
,
3265 workqueue
= create_singlethread_workqueue("u132");
3266 retval
= platform_driver_register(&u132_platform_driver
);
3271 module_init(u132_hcd_init
);
3272 static void __exit
u132_hcd_exit(void)
3276 down(&u132_module_lock
);
3278 up(&u132_module_lock
);
3279 list_for_each_entry_safe(u132
, temp
, &u132_static_list
, u132_list
) {
3280 platform_device_unregister(u132
->platform_dev
);
3281 } platform_driver_unregister(&u132_platform_driver
);
3282 printk(KERN_INFO
"u132-hcd driver deregistered\n");
3283 wait_event(u132_hcd_wait
, u132_instances
== 0);
3284 flush_workqueue(workqueue
);
3285 destroy_workqueue(workqueue
);
3289 module_exit(u132_hcd_exit
);
3290 MODULE_LICENSE("GPL");