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