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