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