Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/usb/host/u132-hcd.c

  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)
 70 MODULE_AUTHOR("Tony Olech - Elan Digital Systems Limited");
 71 MODULE_DESCRIPTION("U132 USB Host Controller Driver");
 72 MODULE_LICENSE("GPL");
 73 #define INT_MODULE_PARM(n, v) static int n = v;module_param(n, int, 0444)
 74 INT_MODULE_PARM(testing, 0);
 75 /* Some boards misreport power switching/overcurrent*/
 76 static bool distrust_firmware = 1;
 77 module_param(distrust_firmware, bool, 0);
 78 MODULE_PARM_DESC(distrust_firmware, "true to distrust firmware power/overcurren"
 79         "t setup");
 80 static DECLARE_WAIT_QUEUE_HEAD(u132_hcd_wait);
 81 /*
 82 * u132_module_lock exists to protect access to global variables
 83 *
 84 */
 85 static struct mutex u132_module_lock;
 86 static int u132_exiting;
 87 static int u132_instances;
 88 static struct list_head u132_static_list;
 89 /*
 90 * end of the global variables protected by u132_module_lock
 91 */
 92 static 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
 98 static 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 };
116 struct u132_port {
117         struct u132 *u132;
118         int reset;
119         int enable;
120         int power;
121         int Status;
122 };
123 struct u132_addr {
124         u8 address;
125 };
126 struct 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)
139 struct u132_urbq {
140         struct list_head urb_more;
141         struct urb *urb;
142 };
143 struct u132_spin {
144         spinlock_t slock;
145 };
146 struct 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 };
174 struct 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 };
182 struct 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);
224 static 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 
230 static inline struct u132 *hcd_to_u132(struct usb_hcd *hcd)
231 {
232         return (struct u132 *)(hcd->hcd_priv);
233 }
234 
235 static inline struct usb_hcd *u132_to_hcd(struct u132 *u132)
236 {
237         return container_of((void *)u132, struct usb_hcd, hcd_priv);
238 }
239 
240 static 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"
250 static 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)
254 static 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 
269 static inline void u132_u132_put_kref(struct u132 *u132)
270 {
271         kref_put(&u132->kref, u132_hcd_delete);
272 }
273 
274 static inline void u132_u132_init_kref(struct u132 *u132)
275 {
276         kref_init(&u132->kref);
277 }
278 
279 static 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 
288 static inline void u132_udev_put_kref(struct u132 *u132, struct u132_udev *udev)
289 {
290         kref_put(&udev->kref, u132_udev_delete);
291 }
292 
293 static inline void u132_udev_get_kref(struct u132 *u132, struct u132_udev *udev)
294 {
295         kref_get(&udev->kref);
296 }
297 
298 static inline void u132_udev_init_kref(struct u132 *u132,
299         struct u132_udev *udev)
300 {
301         kref_init(&udev->kref);
302 }
303 
304 static inline void u132_ring_put_kref(struct u132 *u132, struct u132_ring *ring)
305 {
306         kref_put(&u132->kref, u132_hcd_delete);
307 }
308 
309 static 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 
320 static 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 
327 static 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 
333 static 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 
372 static inline void u132_endp_put_kref(struct u132 *u132, struct u132_endp *endp)
373 {
374         kref_put(&endp->kref, u132_endp_delete);
375 }
376 
377 static inline void u132_endp_get_kref(struct u132 *u132, struct u132_endp *endp)
378 {
379         kref_get(&endp->kref);
380 }
381 
382 static 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 
389 static 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 
396 static 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 
402 static inline void u132_monitor_put_kref(struct u132 *u132)
403 {
404         kref_put(&u132->kref, u132_hcd_delete);
405 }
406 
407 static 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 
413 static 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 
419 static 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 
425 static 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 
478 static 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 
511 static 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 
545 static 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 
551 static 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 
577 static 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 
587 static 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 
597 static 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 
607 static 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 */
622 static 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 
722 static 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 
773 static 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 
876 static 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 
913 static 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 
985 static 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 
1022 static 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 
1080 static 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 
1121 static 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 
1164 static 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 
1201 static 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 
1253 static 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 */
1301 static 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 *last_endp = ring->curr_endp;
1313                 struct list_head *scan;
1314                 struct list_head *head = &last_endp->endp_ring;
1315                 unsigned long wakeup = 0;
1316                 list_for_each(scan, head) {
1317                         struct u132_endp *endp = list_entry(scan,
1318                                 struct u132_endp, endp_ring);
1319                         if (endp->queue_next == endp->queue_last) {
1320                         } else if ((endp->delayed == 0)
1321                                 || time_after_eq(jiffies, endp->jiffies)) {
1322                                 ring->curr_endp = endp;
1323                                 u132_endp_cancel_work(u132, last_endp);
1324                                 u132_endp_queue_work(u132, last_endp, 0);
1325                                 mutex_unlock(&u132->scheduler_lock);
1326                                 u132_ring_put_kref(u132, ring);
1327                                 return;
1328                         } else {
1329                                 unsigned long delta = endp->jiffies - jiffies;
1330                                 if (delta > wakeup)
1331                                         wakeup = delta;
1332                         }
1333                 }
1334                 if (last_endp->queue_next == last_endp->queue_last) {
1335                 } else if ((last_endp->delayed == 0) || time_after_eq(jiffies,
1336                         last_endp->jiffies)) {
1337                         u132_endp_cancel_work(u132, last_endp);
1338                         u132_endp_queue_work(u132, last_endp, 0);
1339                         mutex_unlock(&u132->scheduler_lock);
1340                         u132_ring_put_kref(u132, ring);
1341                         return;
1342                 } else {
1343                         unsigned long delta = last_endp->jiffies - jiffies;
1344                         if (delta > wakeup)
1345                                 wakeup = delta;
1346                 }
1347                 if (wakeup > 0) {
1348                         u132_ring_requeue_work(u132, ring, wakeup);
1349                         mutex_unlock(&u132->scheduler_lock);
1350                         return;
1351                 } else {
1352                         mutex_unlock(&u132->scheduler_lock);
1353                         u132_ring_put_kref(u132, ring);
1354                         return;
1355                 }
1356         } else {
1357                 mutex_unlock(&u132->scheduler_lock);
1358                 u132_ring_put_kref(u132, ring);
1359                 return;
1360         }
1361 }
1362 
1363 static void u132_hcd_endp_work_scheduler(struct work_struct *work)
1364 {
1365         struct u132_ring *ring;
1366         struct u132_endp *endp =
1367                 container_of(work, struct u132_endp, scheduler.work);
1368         struct u132 *u132 = endp->u132;
1369         mutex_lock(&u132->scheduler_lock);
1370         ring = endp->ring;
1371         if (endp->edset_flush) {
1372                 endp->edset_flush = 0;
1373                 if (endp->dequeueing)
1374                         usb_ftdi_elan_edset_flush(u132->platform_dev,
1375                                 ring->number, endp);
1376                 mutex_unlock(&u132->scheduler_lock);
1377                 u132_endp_put_kref(u132, endp);
1378                 return;
1379         } else if (endp->active) {
1380                 mutex_unlock(&u132->scheduler_lock);
1381                 u132_endp_put_kref(u132, endp);
1382                 return;
1383         } else if (ring->in_use) {
1384                 mutex_unlock(&u132->scheduler_lock);
1385                 u132_endp_put_kref(u132, endp);
1386                 return;
1387         } else if (endp->queue_next == endp->queue_last) {
1388                 mutex_unlock(&u132->scheduler_lock);
1389                 u132_endp_put_kref(u132, endp);
1390                 return;
1391         } else if (endp->pipetype == PIPE_INTERRUPT) {
1392                 u8 address = u132->addr[endp->usb_addr].address;
1393                 if (ring->in_use) {
1394                         mutex_unlock(&u132->scheduler_lock);
1395                         u132_endp_put_kref(u132, endp);
1396                         return;
1397                 } else {
1398                         int retval;
1399                         struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1400                                 endp->queue_next];
1401                         endp->active = 1;
1402                         ring->curr_endp = endp;
1403                         ring->in_use = 1;
1404                         mutex_unlock(&u132->scheduler_lock);
1405                         retval = edset_single(u132, ring, endp, urb, address,
1406                                 endp->toggle_bits, u132_hcd_interrupt_recv);
1407                         if (retval != 0)
1408                                 u132_hcd_giveback_urb(u132, endp, urb, retval);
1409                         return;
1410                 }
1411         } else if (endp->pipetype == PIPE_CONTROL) {
1412                 u8 address = u132->addr[endp->usb_addr].address;
1413                 if (ring->in_use) {
1414                         mutex_unlock(&u132->scheduler_lock);
1415                         u132_endp_put_kref(u132, endp);
1416                         return;
1417                 } else if (address == 0) {
1418                         int retval;
1419                         struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1420                                 endp->queue_next];
1421                         endp->active = 1;
1422                         ring->curr_endp = endp;
1423                         ring->in_use = 1;
1424                         mutex_unlock(&u132->scheduler_lock);
1425                         retval = edset_setup(u132, ring, endp, urb, address,
1426                                 0x2, u132_hcd_initial_setup_sent);
1427                         if (retval != 0)
1428                                 u132_hcd_giveback_urb(u132, endp, urb, retval);
1429                         return;
1430                 } else if (endp->usb_addr == 0) {
1431                         int retval;
1432                         struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1433                                 endp->queue_next];
1434                         endp->active = 1;
1435                         ring->curr_endp = endp;
1436                         ring->in_use = 1;
1437                         mutex_unlock(&u132->scheduler_lock);
1438                         retval = edset_setup(u132, ring, endp, urb, 0, 0x2,
1439                                 u132_hcd_enumeration_address_sent);
1440                         if (retval != 0)
1441                                 u132_hcd_giveback_urb(u132, endp, urb, retval);
1442                         return;
1443                 } else {
1444                         int retval;
1445                         struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1446                                 endp->queue_next];
1447                         address = u132->addr[endp->usb_addr].address;
1448                         endp->active = 1;
1449                         ring->curr_endp = endp;
1450                         ring->in_use = 1;
1451                         mutex_unlock(&u132->scheduler_lock);
1452                         retval = edset_setup(u132, ring, endp, urb, address,
1453                                 0x2, u132_hcd_configure_setup_sent);
1454                         if (retval != 0)
1455                                 u132_hcd_giveback_urb(u132, endp, urb, retval);
1456                         return;
1457                 }
1458         } else {
1459                 if (endp->input) {
1460                         u8 address = u132->addr[endp->usb_addr].address;
1461                         if (ring->in_use) {
1462                                 mutex_unlock(&u132->scheduler_lock);
1463                                 u132_endp_put_kref(u132, endp);
1464                                 return;
1465                         } else {
1466                                 int retval;
1467                                 struct urb *urb = endp->urb_list[
1468                                         ENDP_QUEUE_MASK & endp->queue_next];
1469                                 endp->active = 1;
1470                                 ring->curr_endp = endp;
1471                                 ring->in_use = 1;
1472                                 mutex_unlock(&u132->scheduler_lock);
1473                                 retval = edset_input(u132, ring, endp, urb,
1474                                         address, endp->toggle_bits,
1475                                         u132_hcd_bulk_input_recv);
1476                                 if (retval == 0) {
1477                                 } else
1478                                         u132_hcd_giveback_urb(u132, endp, urb,
1479                                                 retval);
1480                                 return;
1481                         }
1482                 } else {        /* output pipe */
1483                         u8 address = u132->addr[endp->usb_addr].address;
1484                         if (ring->in_use) {
1485                                 mutex_unlock(&u132->scheduler_lock);
1486                                 u132_endp_put_kref(u132, endp);
1487                                 return;
1488                         } else {
1489                                 int retval;
1490                                 struct urb *urb = endp->urb_list[
1491                                         ENDP_QUEUE_MASK & endp->queue_next];
1492                                 endp->active = 1;
1493                                 ring->curr_endp = endp;
1494                                 ring->in_use = 1;
1495                                 mutex_unlock(&u132->scheduler_lock);
1496                                 retval = edset_output(u132, ring, endp, urb,
1497                                         address, endp->toggle_bits,
1498                                         u132_hcd_bulk_output_sent);
1499                                 if (retval == 0) {
1500                                 } else
1501                                         u132_hcd_giveback_urb(u132, endp, urb,
1502                                                 retval);
1503                                 return;
1504                         }
1505                 }
1506         }
1507 }
1508 #ifdef CONFIG_PM
1509 
1510 static void port_power(struct u132 *u132, int pn, int is_on)
1511 {
1512         u132->port[pn].power = is_on;
1513 }
1514 
1515 #endif
1516 
1517 static void u132_power(struct u132 *u132, int is_on)
1518 {
1519         struct usb_hcd *hcd = u132_to_hcd(u132)
1520                 ;       /* hub is inactive unless the port is powered */
1521         if (is_on) {
1522                 if (u132->power)
1523                         return;
1524                 u132->power = 1;
1525         } else {
1526                 u132->power = 0;
1527                 hcd->state = HC_STATE_HALT;
1528         }
1529 }
1530 
1531 static int u132_periodic_reinit(struct u132 *u132)
1532 {
1533         int retval;
1534         u32 fi = u132->hc_fminterval & 0x03fff;
1535         u32 fit;
1536         u32 fminterval;
1537         retval = u132_read_pcimem(u132, fminterval, &fminterval);
1538         if (retval)
1539                 return retval;
1540         fit = fminterval & FIT;
1541         retval = u132_write_pcimem(u132, fminterval,
1542                 (fit ^ FIT) | u132->hc_fminterval);
1543         if (retval)
1544                 return retval;
1545         retval = u132_write_pcimem(u132, periodicstart,
1546                 ((9 * fi) / 10) & 0x3fff);
1547         if (retval)
1548                 return retval;
1549         return 0;
1550 }
1551 
1552 static char *hcfs2string(int state)
1553 {
1554         switch (state) {
1555         case OHCI_USB_RESET:
1556                 return "reset";
1557         case OHCI_USB_RESUME:
1558                 return "resume";
1559         case OHCI_USB_OPER:
1560                 return "operational";
1561         case OHCI_USB_SUSPEND:
1562                 return "suspend";
1563         }
1564         return "?";
1565 }
1566 
1567 static int u132_init(struct u132 *u132)
1568 {
1569         int retval;
1570         u32 control;
1571         u132_disable(u132);
1572         u132->next_statechange = jiffies;
1573         retval = u132_write_pcimem(u132, intrdisable, OHCI_INTR_MIE);
1574         if (retval)
1575                 return retval;
1576         retval = u132_read_pcimem(u132, control, &control);
1577         if (retval)
1578                 return retval;
1579         if (u132->num_ports == 0) {
1580                 u32 rh_a = -1;
1581                 retval = u132_read_pcimem(u132, roothub.a, &rh_a);
1582                 if (retval)
1583                         return retval;
1584                 u132->num_ports = rh_a & RH_A_NDP;
1585                 retval = read_roothub_info(u132);
1586                 if (retval)
1587                         return retval;
1588         }
1589         if (u132->num_ports > MAX_U132_PORTS)
1590                 return -EINVAL;
1591 
1592         return 0;
1593 }
1594 
1595 
1596 /* Start an OHCI controller, set the BUS operational
1597 * resets USB and controller
1598 * enable interrupts
1599 */
1600 static int u132_run(struct u132 *u132)
1601 {
1602         int retval;
1603         u32 control;
1604         u32 status;
1605         u32 fminterval;
1606         u32 periodicstart;
1607         u32 cmdstatus;
1608         u32 roothub_a;
1609         int mask = OHCI_INTR_INIT;
1610         int first = u132->hc_fminterval == 0;
1611         int sleep_time = 0;
1612         int reset_timeout = 30; /* ... allow extra time */
1613         u132_disable(u132);
1614         if (first) {
1615                 u32 temp;
1616                 retval = u132_read_pcimem(u132, fminterval, &temp);
1617                 if (retval)
1618                         return retval;
1619                 u132->hc_fminterval = temp & 0x3fff;
1620                 u132->hc_fminterval |= FSMP(u132->hc_fminterval) << 16;
1621         }
1622         retval = u132_read_pcimem(u132, control, &u132->hc_control);
1623         if (retval)
1624                 return retval;
1625         dev_info(&u132->platform_dev->dev, "resetting from state '%s', control "
1626                 "= %08X\n", hcfs2string(u132->hc_control & OHCI_CTRL_HCFS),
1627                 u132->hc_control);
1628         switch (u132->hc_control & OHCI_CTRL_HCFS) {
1629         case OHCI_USB_OPER:
1630                 sleep_time = 0;
1631                 break;
1632         case OHCI_USB_SUSPEND:
1633         case OHCI_USB_RESUME:
1634                 u132->hc_control &= OHCI_CTRL_RWC;
1635                 u132->hc_control |= OHCI_USB_RESUME;
1636                 sleep_time = 10;
1637                 break;
1638         default:
1639                 u132->hc_control &= OHCI_CTRL_RWC;
1640                 u132->hc_control |= OHCI_USB_RESET;
1641                 sleep_time = 50;
1642                 break;
1643         }
1644         retval = u132_write_pcimem(u132, control, u132->hc_control);
1645         if (retval)
1646                 return retval;
1647         retval = u132_read_pcimem(u132, control, &control);
1648         if (retval)
1649                 return retval;
1650         msleep(sleep_time);
1651         retval = u132_read_pcimem(u132, roothub.a, &roothub_a);
1652         if (retval)
1653                 return retval;
1654         if (!(roothub_a & RH_A_NPS)) {
1655                 int temp;       /* power down each port */
1656                 for (temp = 0; temp < u132->num_ports; temp++) {
1657                         retval = u132_write_pcimem(u132,
1658                                 roothub.portstatus[temp], RH_PS_LSDA);
1659                         if (retval)
1660                                 return retval;
1661                 }
1662         }
1663         retval = u132_read_pcimem(u132, control, &control);
1664         if (retval)
1665                 return retval;
1666 retry:
1667         retval = u132_read_pcimem(u132, cmdstatus, &status);
1668         if (retval)
1669                 return retval;
1670         retval = u132_write_pcimem(u132, cmdstatus, OHCI_HCR);
1671         if (retval)
1672                 return retval;
1673 extra:  {
1674                 retval = u132_read_pcimem(u132, cmdstatus, &status);
1675                 if (retval)
1676                         return retval;
1677                 if (0 != (status & OHCI_HCR)) {
1678                         if (--reset_timeout == 0) {
1679                                 dev_err(&u132->platform_dev->dev, "USB HC reset"
1680                                         " timed out!\n");
1681                                 return -ENODEV;
1682                         } else {
1683                                 msleep(5);
1684                                 goto extra;
1685                         }
1686                 }
1687         }
1688         if (u132->flags & OHCI_QUIRK_INITRESET) {
1689                 retval = u132_write_pcimem(u132, control, u132->hc_control);
1690                 if (retval)
1691                         return retval;
1692                 retval = u132_read_pcimem(u132, control, &control);
1693                 if (retval)
1694                         return retval;
1695         }
1696         retval = u132_write_pcimem(u132, ed_controlhead, 0x00000000);
1697         if (retval)
1698                 return retval;
1699         retval = u132_write_pcimem(u132, ed_bulkhead, 0x11000000);
1700         if (retval)
1701                 return retval;
1702         retval = u132_write_pcimem(u132, hcca, 0x00000000);
1703         if (retval)
1704                 return retval;
1705         retval = u132_periodic_reinit(u132);
1706         if (retval)
1707                 return retval;
1708         retval = u132_read_pcimem(u132, fminterval, &fminterval);
1709         if (retval)
1710                 return retval;
1711         retval = u132_read_pcimem(u132, periodicstart, &periodicstart);
1712         if (retval)
1713                 return retval;
1714         if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) {
1715                 if (!(u132->flags & OHCI_QUIRK_INITRESET)) {
1716                         u132->flags |= OHCI_QUIRK_INITRESET;
1717                         goto retry;
1718                 } else
1719                         dev_err(&u132->platform_dev->dev, "init err(%08x %04x)"
1720                                 "\n", fminterval, periodicstart);
1721         }                       /* start controller operations */
1722         u132->hc_control &= OHCI_CTRL_RWC;
1723         u132->hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER;
1724         retval = u132_write_pcimem(u132, control, u132->hc_control);
1725         if (retval)
1726                 return retval;
1727         retval = u132_write_pcimem(u132, cmdstatus, OHCI_BLF);
1728         if (retval)
1729                 return retval;
1730         retval = u132_read_pcimem(u132, cmdstatus, &cmdstatus);
1731         if (retval)
1732                 return retval;
1733         retval = u132_read_pcimem(u132, control, &control);
1734         if (retval)
1735                 return retval;
1736         u132_to_hcd(u132)->state = HC_STATE_RUNNING;
1737         retval = u132_write_pcimem(u132, roothub.status, RH_HS_DRWE);
1738         if (retval)
1739                 return retval;
1740         retval = u132_write_pcimem(u132, intrstatus, mask);
1741         if (retval)
1742                 return retval;
1743         retval = u132_write_pcimem(u132, intrdisable,
1744                 OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO |
1745                 OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH |
1746                 OHCI_INTR_SO);
1747         if (retval)
1748                 return retval;  /* handle root hub init quirks ... */
1749         retval = u132_read_pcimem(u132, roothub.a, &roothub_a);
1750         if (retval)
1751                 return retval;
1752         roothub_a &= ~(RH_A_PSM | RH_A_OCPM);
1753         if (u132->flags & OHCI_QUIRK_SUPERIO) {
1754                 roothub_a |= RH_A_NOCP;
1755                 roothub_a &= ~(RH_A_POTPGT | RH_A_NPS);
1756                 retval = u132_write_pcimem(u132, roothub.a, roothub_a);
1757                 if (retval)
1758                         return retval;
1759         } else if ((u132->flags & OHCI_QUIRK_AMD756) || distrust_firmware) {
1760                 roothub_a |= RH_A_NPS;
1761                 retval = u132_write_pcimem(u132, roothub.a, roothub_a);
1762                 if (retval)
1763                         return retval;
1764         }
1765         retval = u132_write_pcimem(u132, roothub.status, RH_HS_LPSC);
1766         if (retval)
1767                 return retval;
1768         retval = u132_write_pcimem(u132, roothub.b,
1769                 (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM);
1770         if (retval)
1771                 return retval;
1772         retval = u132_read_pcimem(u132, control, &control);
1773         if (retval)
1774                 return retval;
1775         mdelay((roothub_a >> 23) & 0x1fe);
1776         u132_to_hcd(u132)->state = HC_STATE_RUNNING;
1777         return 0;
1778 }
1779 
1780 static void u132_hcd_stop(struct usb_hcd *hcd)
1781 {
1782         struct u132 *u132 = hcd_to_u132(hcd);
1783         if (u132->going > 1) {
1784                 dev_err(&u132->platform_dev->dev, "u132 device %p(hcd=%p) has b"
1785                         "een removed %d\n", u132, hcd, u132->going);
1786         } else if (u132->going > 0) {
1787                 dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
1788                         "ed\n", hcd);
1789         } else {
1790                 mutex_lock(&u132->sw_lock);
1791                 msleep(100);
1792                 u132_power(u132, 0);
1793                 mutex_unlock(&u132->sw_lock);
1794         }
1795 }
1796 
1797 static int u132_hcd_start(struct usb_hcd *hcd)
1798 {
1799         struct u132 *u132 = hcd_to_u132(hcd);
1800         if (u132->going > 1) {
1801                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1802                         , u132->going);
1803                 return -ENODEV;
1804         } else if (u132->going > 0) {
1805                 dev_err(&u132->platform_dev->dev, "device is being removed\n");
1806                 return -ESHUTDOWN;
1807         } else if (hcd->self.controller) {
1808                 int retval;
1809                 struct platform_device *pdev =
1810                         to_platform_device(hcd->self.controller);
1811                 u16 vendor = ((struct u132_platform_data *)
1812                         dev_get_platdata(&pdev->dev))->vendor;
1813                 u16 device = ((struct u132_platform_data *)
1814                         dev_get_platdata(&pdev->dev))->device;
1815                 mutex_lock(&u132->sw_lock);
1816                 msleep(10);
1817                 if (vendor == PCI_VENDOR_ID_AMD && device == 0x740c) {
1818                         u132->flags = OHCI_QUIRK_AMD756;
1819                 } else if (vendor == PCI_VENDOR_ID_OPTI && device == 0xc861) {
1820                         dev_err(&u132->platform_dev->dev, "WARNING: OPTi workar"
1821                                 "ounds unavailable\n");
1822                 } else if (vendor == PCI_VENDOR_ID_COMPAQ && device == 0xa0f8)
1823                         u132->flags |= OHCI_QUIRK_ZFMICRO;
1824                 retval = u132_run(u132);
1825                 if (retval) {
1826                         u132_disable(u132);
1827                         u132->going = 1;
1828                 }
1829                 msleep(100);
1830                 mutex_unlock(&u132->sw_lock);
1831                 return retval;
1832         } else {
1833                 dev_err(&u132->platform_dev->dev, "platform_device missing\n");
1834                 return -ENODEV;
1835         }
1836 }
1837 
1838 static int u132_hcd_reset(struct usb_hcd *hcd)
1839 {
1840         struct u132 *u132 = hcd_to_u132(hcd);
1841         if (u132->going > 1) {
1842                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1843                         , u132->going);
1844                 return -ENODEV;
1845         } else if (u132->going > 0) {
1846                 dev_err(&u132->platform_dev->dev, "device is being removed\n");
1847                 return -ESHUTDOWN;
1848         } else {
1849                 int retval;
1850                 mutex_lock(&u132->sw_lock);
1851                 retval = u132_init(u132);
1852                 if (retval) {
1853                         u132_disable(u132);
1854                         u132->going = 1;
1855                 }
1856                 mutex_unlock(&u132->sw_lock);
1857                 return retval;
1858         }
1859 }
1860 
1861 static int create_endpoint_and_queue_int(struct u132 *u132,
1862         struct u132_udev *udev, struct urb *urb,
1863         struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
1864         gfp_t mem_flags)
1865 {
1866         struct u132_ring *ring;
1867         unsigned long irqs;
1868         int rc;
1869         u8 endp_number;
1870         struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
1871 
1872         if (!endp)
1873                 return -ENOMEM;
1874 
1875         spin_lock_init(&endp->queue_lock.slock);
1876         spin_lock_irqsave(&endp->queue_lock.slock, irqs);
1877         rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
1878         if (rc) {
1879                 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1880                 kfree(endp);
1881                 return rc;
1882         }
1883 
1884         endp_number = ++u132->num_endpoints;
1885         urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
1886         INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
1887         INIT_LIST_HEAD(&endp->urb_more);
1888         ring = endp->ring = &u132->ring[0];
1889         if (ring->curr_endp) {
1890                 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
1891         } else {
1892                 INIT_LIST_HEAD(&endp->endp_ring);
1893                 ring->curr_endp = endp;
1894         }
1895         ring->length += 1;
1896         endp->dequeueing = 0;
1897         endp->edset_flush = 0;
1898         endp->active = 0;
1899         endp->delayed = 0;
1900         endp->endp_number = endp_number;
1901         endp->u132 = u132;
1902         endp->hep = urb->ep;
1903         endp->pipetype = usb_pipetype(urb->pipe);
1904         u132_endp_init_kref(u132, endp);
1905         if (usb_pipein(urb->pipe)) {
1906                 endp->toggle_bits = 0x2;
1907                 usb_settoggle(udev->usb_device, usb_endp, 0, 0);
1908                 endp->input = 1;
1909                 endp->output = 0;
1910                 udev->endp_number_in[usb_endp] = endp_number;
1911                 u132_udev_get_kref(u132, udev);
1912         } else {
1913                 endp->toggle_bits = 0x2;
1914                 usb_settoggle(udev->usb_device, usb_endp, 1, 0);
1915                 endp->input = 0;
1916                 endp->output = 1;
1917                 udev->endp_number_out[usb_endp] = endp_number;
1918                 u132_udev_get_kref(u132, udev);
1919         }
1920         urb->hcpriv = u132;
1921         endp->delayed = 1;
1922         endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
1923         endp->udev_number = address;
1924         endp->usb_addr = usb_addr;
1925         endp->usb_endp = usb_endp;
1926         endp->queue_size = 1;
1927         endp->queue_last = 0;
1928         endp->queue_next = 0;
1929         endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
1930         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1931         u132_endp_queue_work(u132, endp, msecs_to_jiffies(urb->interval));
1932         return 0;
1933 }
1934 
1935 static int queue_int_on_old_endpoint(struct u132 *u132,
1936         struct u132_udev *udev, struct urb *urb,
1937         struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
1938         u8 usb_endp, u8 address)
1939 {
1940         urb->hcpriv = u132;
1941         endp->delayed = 1;
1942         endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
1943         if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
1944                 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
1945         } else {
1946                 struct u132_urbq *urbq = kmalloc(sizeof(struct u132_urbq),
1947                         GFP_ATOMIC);
1948                 if (urbq == NULL) {
1949                         endp->queue_size -= 1;
1950                         return -ENOMEM;
1951                 } else {
1952                         list_add_tail(&urbq->urb_more, &endp->urb_more);
1953                         urbq->urb = urb;
1954                 }
1955         }
1956         return 0;
1957 }
1958 
1959 static int create_endpoint_and_queue_bulk(struct u132 *u132,
1960         struct u132_udev *udev, struct urb *urb,
1961         struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
1962         gfp_t mem_flags)
1963 {
1964         int ring_number;
1965         struct u132_ring *ring;
1966         unsigned long irqs;
1967         int rc;
1968         u8 endp_number;
1969         struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
1970 
1971         if (!endp)
1972                 return -ENOMEM;
1973 
1974         spin_lock_init(&endp->queue_lock.slock);
1975         spin_lock_irqsave(&endp->queue_lock.slock, irqs);
1976         rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
1977         if (rc) {
1978                 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1979                 kfree(endp);
1980                 return rc;
1981         }
1982 
1983         endp_number = ++u132->num_endpoints;
1984         urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
1985         INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
1986         INIT_LIST_HEAD(&endp->urb_more);
1987         endp->dequeueing = 0;
1988         endp->edset_flush = 0;
1989         endp->active = 0;
1990         endp->delayed = 0;
1991         endp->endp_number = endp_number;
1992         endp->u132 = u132;
1993         endp->hep = urb->ep;
1994         endp->pipetype = usb_pipetype(urb->pipe);
1995         u132_endp_init_kref(u132, endp);
1996         if (usb_pipein(urb->pipe)) {
1997                 endp->toggle_bits = 0x2;
1998                 usb_settoggle(udev->usb_device, usb_endp, 0, 0);
1999                 ring_number = 3;
2000                 endp->input = 1;
2001                 endp->output = 0;
2002                 udev->endp_number_in[usb_endp] = endp_number;
2003                 u132_udev_get_kref(u132, udev);
2004         } else {
2005                 endp->toggle_bits = 0x2;
2006                 usb_settoggle(udev->usb_device, usb_endp, 1, 0);
2007                 ring_number = 2;
2008                 endp->input = 0;
2009                 endp->output = 1;
2010                 udev->endp_number_out[usb_endp] = endp_number;
2011                 u132_udev_get_kref(u132, udev);
2012         }
2013         ring = endp->ring = &u132->ring[ring_number - 1];
2014         if (ring->curr_endp) {
2015                 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
2016         } else {
2017                 INIT_LIST_HEAD(&endp->endp_ring);
2018                 ring->curr_endp = endp;
2019         }
2020         ring->length += 1;
2021         urb->hcpriv = u132;
2022         endp->udev_number = address;
2023         endp->usb_addr = usb_addr;
2024         endp->usb_endp = usb_endp;
2025         endp->queue_size = 1;
2026         endp->queue_last = 0;
2027         endp->queue_next = 0;
2028         endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2029         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2030         u132_endp_queue_work(u132, endp, 0);
2031         return 0;
2032 }
2033 
2034 static int queue_bulk_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
2035         struct urb *urb,
2036         struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2037         u8 usb_endp, u8 address)
2038 {
2039         urb->hcpriv = u132;
2040         if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2041                 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2042         } else {
2043                 struct u132_urbq *urbq = kmalloc(sizeof(struct u132_urbq),
2044                         GFP_ATOMIC);
2045                 if (urbq == NULL) {
2046                         endp->queue_size -= 1;
2047                         return -ENOMEM;
2048                 } else {
2049                         list_add_tail(&urbq->urb_more, &endp->urb_more);
2050                         urbq->urb = urb;
2051                 }
2052         }
2053         return 0;
2054 }
2055 
2056 static int create_endpoint_and_queue_control(struct u132 *u132,
2057         struct urb *urb,
2058         struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp,
2059         gfp_t mem_flags)
2060 {
2061         struct u132_ring *ring;
2062         unsigned long irqs;
2063         int rc;
2064         u8 endp_number;
2065         struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
2066 
2067         if (!endp)
2068                 return -ENOMEM;
2069 
2070         spin_lock_init(&endp->queue_lock.slock);
2071         spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2072         rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
2073         if (rc) {
2074                 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2075                 kfree(endp);
2076                 return rc;
2077         }
2078 
2079         endp_number = ++u132->num_endpoints;
2080         urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
2081         INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
2082         INIT_LIST_HEAD(&endp->urb_more);
2083         ring = endp->ring = &u132->ring[0];
2084         if (ring->curr_endp) {
2085                 list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
2086         } else {
2087                 INIT_LIST_HEAD(&endp->endp_ring);
2088                 ring->curr_endp = endp;
2089         }
2090         ring->length += 1;
2091         endp->dequeueing = 0;
2092         endp->edset_flush = 0;
2093         endp->active = 0;
2094         endp->delayed = 0;
2095         endp->endp_number = endp_number;
2096         endp->u132 = u132;
2097         endp->hep = urb->ep;
2098         u132_endp_init_kref(u132, endp);
2099         u132_endp_get_kref(u132, endp);
2100         if (usb_addr == 0) {
2101                 u8 address = u132->addr[usb_addr].address;
2102                 struct u132_udev *udev = &u132->udev[address];
2103                 endp->udev_number = address;
2104                 endp->usb_addr = usb_addr;
2105                 endp->usb_endp = usb_endp;
2106                 endp->input = 1;
2107                 endp->output = 1;
2108                 endp->pipetype = usb_pipetype(urb->pipe);
2109                 u132_udev_init_kref(u132, udev);
2110                 u132_udev_get_kref(u132, udev);
2111                 udev->endp_number_in[usb_endp] = endp_number;
2112                 udev->endp_number_out[usb_endp] = endp_number;
2113                 urb->hcpriv = u132;
2114                 endp->queue_size = 1;
2115                 endp->queue_last = 0;
2116                 endp->queue_next = 0;
2117                 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2118                 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2119                 u132_endp_queue_work(u132, endp, 0);
2120                 return 0;
2121         } else {                /*(usb_addr > 0) */
2122                 u8 address = u132->addr[usb_addr].address;
2123                 struct u132_udev *udev = &u132->udev[address];
2124                 endp->udev_number = address;
2125                 endp->usb_addr = usb_addr;
2126                 endp->usb_endp = usb_endp;
2127                 endp->input = 1;
2128                 endp->output = 1;
2129                 endp->pipetype = usb_pipetype(urb->pipe);
2130                 u132_udev_get_kref(u132, udev);
2131                 udev->enumeration = 2;
2132                 udev->endp_number_in[usb_endp] = endp_number;
2133                 udev->endp_number_out[usb_endp] = endp_number;
2134                 urb->hcpriv = u132;
2135                 endp->queue_size = 1;
2136                 endp->queue_last = 0;
2137                 endp->queue_next = 0;
2138                 endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2139                 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2140                 u132_endp_queue_work(u132, endp, 0);
2141                 return 0;
2142         }
2143 }
2144 
2145 static int queue_control_on_old_endpoint(struct u132 *u132,
2146         struct urb *urb,
2147         struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2148         u8 usb_endp)
2149 {
2150         if (usb_addr == 0) {
2151                 if (usb_pipein(urb->pipe)) {
2152                         urb->hcpriv = u132;
2153                         if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2154                                 endp->urb_list[ENDP_QUEUE_MASK &
2155                                         endp->queue_last++] = urb;
2156                         } else {
2157                                 struct u132_urbq *urbq =
2158                                         kmalloc(sizeof(struct u132_urbq),
2159                                         GFP_ATOMIC);
2160                                 if (urbq == NULL) {
2161                                         endp->queue_size -= 1;
2162                                         return -ENOMEM;
2163                                 } else {
2164                                         list_add_tail(&urbq->urb_more,
2165                                                 &endp->urb_more);
2166                                         urbq->urb = urb;
2167                                 }
2168                         }
2169                         return 0;
2170                 } else {        /* usb_pipeout(urb->pipe) */
2171                         struct u132_addr *addr = &u132->addr[usb_dev->devnum];
2172                         int I = MAX_U132_UDEVS;
2173                         int i = 0;
2174                         while (--I > 0) {
2175                                 struct u132_udev *udev = &u132->udev[++i];
2176                                 if (udev->usb_device) {
2177                                         continue;
2178                                 } else {
2179                                         udev->enumeration = 1;
2180                                         u132->addr[0].address = i;
2181                                         endp->udev_number = i;
2182                                         udev->udev_number = i;
2183                                         udev->usb_addr = usb_dev->devnum;
2184                                         u132_udev_init_kref(u132, udev);
2185                                         udev->endp_number_in[usb_endp] =
2186                                                 endp->endp_number;
2187                                         u132_udev_get_kref(u132, udev);
2188                                         udev->endp_number_out[usb_endp] =
2189                                                 endp->endp_number;
2190                                         udev->usb_device = usb_dev;
2191                                         ((u8 *) (urb->setup_packet))[2] =
2192                                                 addr->address = i;
2193                                         u132_udev_get_kref(u132, udev);
2194                                         break;
2195                                 }
2196                         }
2197                         if (I == 0) {
2198                                 dev_err(&u132->platform_dev->dev, "run out of d"
2199                                         "evice space\n");
2200                                 return -EINVAL;
2201                         }
2202                         urb->hcpriv = u132;
2203                         if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2204                                 endp->urb_list[ENDP_QUEUE_MASK &
2205                                         endp->queue_last++] = urb;
2206                         } else {
2207                                 struct u132_urbq *urbq =
2208                                         kmalloc(sizeof(struct u132_urbq),
2209                                         GFP_ATOMIC);
2210                                 if (urbq == NULL) {
2211                                         endp->queue_size -= 1;
2212                                         return -ENOMEM;
2213                                 } else {
2214                                         list_add_tail(&urbq->urb_more,
2215                                                 &endp->urb_more);
2216                                         urbq->urb = urb;
2217                                 }
2218                         }
2219                         return 0;
2220                 }
2221         } else {                /*(usb_addr > 0) */
2222                 u8 address = u132->addr[usb_addr].address;
2223                 struct u132_udev *udev = &u132->udev[address];
2224                 urb->hcpriv = u132;
2225                 if (udev->enumeration != 2)
2226                         udev->enumeration = 2;
2227                 if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2228                         endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
2229                                 urb;
2230                 } else {
2231                         struct u132_urbq *urbq =
2232                                 kmalloc(sizeof(struct u132_urbq), GFP_ATOMIC);
2233                         if (urbq == NULL) {
2234                                 endp->queue_size -= 1;
2235                                 return -ENOMEM;
2236                         } else {
2237                                 list_add_tail(&urbq->urb_more, &endp->urb_more);
2238                                 urbq->urb = urb;
2239                         }
2240                 }
2241                 return 0;
2242         }
2243 }
2244 
2245 static int u132_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
2246                 gfp_t mem_flags)
2247 {
2248         struct u132 *u132 = hcd_to_u132(hcd);
2249         if (irqs_disabled()) {
2250                 if (__GFP_WAIT & mem_flags) {
2251                         printk(KERN_ERR "invalid context for function that migh"
2252                                 "t sleep\n");
2253                         return -EINVAL;
2254                 }
2255         }
2256         if (u132->going > 1) {
2257                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2258                         , u132->going);
2259                 return -ENODEV;
2260         } else if (u132->going > 0) {
2261                 dev_err(&u132->platform_dev->dev, "device is being removed "
2262                                 "urb=%p\n", urb);
2263                 return -ESHUTDOWN;
2264         } else {
2265                 u8 usb_addr = usb_pipedevice(urb->pipe);
2266                 u8 usb_endp = usb_pipeendpoint(urb->pipe);
2267                 struct usb_device *usb_dev = urb->dev;
2268                 if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
2269                         u8 address = u132->addr[usb_addr].address;
2270                         struct u132_udev *udev = &u132->udev[address];
2271                         struct u132_endp *endp = urb->ep->hcpriv;
2272                         urb->actual_length = 0;
2273                         if (endp) {
2274                                 unsigned long irqs;
2275                                 int retval;
2276                                 spin_lock_irqsave(&endp->queue_lock.slock,
2277                                         irqs);
2278                                 retval = usb_hcd_link_urb_to_ep(hcd, urb);
2279                                 if (retval == 0) {
2280                                         retval = queue_int_on_old_endpoint(
2281                                                         u132, udev, urb,
2282                                                         usb_dev, endp,
2283                                                         usb_addr, usb_endp,
2284                                                         address);
2285                                         if (retval)
2286                                                 usb_hcd_unlink_urb_from_ep(
2287         hcd, urb);
2288                                 }
2289                                 spin_unlock_irqrestore(&endp->queue_lock.slock,
2290                                         irqs);
2291                                 if (retval) {
2292                                         return retval;
2293                                 } else {
2294                                         u132_endp_queue_work(u132, endp,
2295                                                 msecs_to_jiffies(urb->interval))
2296                                                 ;
2297                                         return 0;
2298                                 }
2299                         } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2300                                 return -EINVAL;
2301                         } else {        /*(endp == NULL) */
2302                                 return create_endpoint_and_queue_int(u132, udev,
2303                                                 urb, usb_dev, usb_addr,
2304                                                 usb_endp, address, mem_flags);
2305                         }
2306                 } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
2307                         dev_err(&u132->platform_dev->dev, "the hardware does no"
2308                                 "t support PIPE_ISOCHRONOUS\n");
2309                         return -EINVAL;
2310                 } else if (usb_pipetype(urb->pipe) == PIPE_BULK) {
2311                         u8 address = u132->addr[usb_addr].address;
2312                         struct u132_udev *udev = &u132->udev[address];
2313                         struct u132_endp *endp = urb->ep->hcpriv;
2314                         urb->actual_length = 0;
2315                         if (endp) {
2316                                 unsigned long irqs;
2317                                 int retval;
2318                                 spin_lock_irqsave(&endp->queue_lock.slock,
2319                                         irqs);
2320                                 retval = usb_hcd_link_urb_to_ep(hcd, urb);
2321                                 if (retval == 0) {
2322                                         retval = queue_bulk_on_old_endpoint(
2323                                                         u132, udev, urb,
2324                                                         usb_dev, endp,
2325                                                         usb_addr, usb_endp,
2326                                                         address);
2327                                         if (retval)
2328                                                 usb_hcd_unlink_urb_from_ep(
2329         hcd, urb);
2330                                 }
2331                                 spin_unlock_irqrestore(&endp->queue_lock.slock,
2332                                         irqs);
2333                                 if (retval) {
2334                                         return retval;
2335                                 } else {
2336                                         u132_endp_queue_work(u132, endp, 0);
2337                                         return 0;
2338                                 }
2339                         } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2340                                 return -EINVAL;
2341                         } else
2342                                 return create_endpoint_and_queue_bulk(u132,
2343                                         udev, urb, usb_dev, usb_addr,
2344                                         usb_endp, address, mem_flags);
2345                 } else {
2346                         struct u132_endp *endp = urb->ep->hcpriv;
2347                         u16 urb_size = 8;
2348                         u8 *b = urb->setup_packet;
2349                         int i = 0;
2350                         char data[30 * 3 + 4];
2351                         char *d = data;
2352                         int m = (sizeof(data) - 1) / 3;
2353                         int l = 0;
2354                         data[0] = 0;
2355                         while (urb_size-- > 0) {
2356                                 if (i > m) {
2357                                 } else if (i++ < m) {
2358                                         int w = sprintf(d, " %02X", *b++);
2359                                         d += w;
2360                                         l += w;
2361                                 } else
2362                                         d += sprintf(d, " ..");
2363                         }
2364                         if (endp) {
2365                                 unsigned long irqs;
2366                                 int retval;
2367                                 spin_lock_irqsave(&endp->queue_lock.slock,
2368                                         irqs);
2369                                 retval = usb_hcd_link_urb_to_ep(hcd, urb);
2370                                 if (retval == 0) {
2371                                         retval = queue_control_on_old_endpoint(
2372                                                         u132, urb, usb_dev,
2373                                                         endp, usb_addr,
2374                                                         usb_endp);
2375                                         if (retval)
2376                                                 usb_hcd_unlink_urb_from_ep(
2377                                                                 hcd, urb);
2378                                 }
2379                                 spin_unlock_irqrestore(&endp->queue_lock.slock,
2380                                         irqs);
2381                                 if (retval) {
2382                                         return retval;
2383                                 } else {
2384                                         u132_endp_queue_work(u132, endp, 0);
2385                                         return 0;
2386                                 }
2387                         } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2388                                 return -EINVAL;
2389                         } else
2390                                 return create_endpoint_and_queue_control(u132,
2391                                         urb, usb_dev, usb_addr, usb_endp,
2392                                         mem_flags);
2393                 }
2394         }
2395 }
2396 
2397 static int dequeue_from_overflow_chain(struct u132 *u132,
2398         struct u132_endp *endp, struct urb *urb)
2399 {
2400         struct list_head *scan;
2401         struct list_head *head = &endp->urb_more;
2402         list_for_each(scan, head) {
2403                 struct u132_urbq *urbq = list_entry(scan, struct u132_urbq,
2404                         urb_more);
2405                 if (urbq->urb == urb) {
2406                         struct usb_hcd *hcd = u132_to_hcd(u132);
2407                         list_del(scan);
2408                         endp->queue_size -= 1;
2409                         urb->error_count = 0;
2410                         usb_hcd_giveback_urb(hcd, urb, 0);
2411                         return 0;
2412                 } else
2413                         continue;
2414         }
2415         dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]=%p ring"
2416                 "[%d] %c%c usb_endp=%d usb_addr=%d size=%d next=%04X last=%04X"
2417                 "\n", urb, endp->endp_number, endp, endp->ring->number,
2418                 endp->input ? 'I' : ' ', endp->output ? 'O' : ' ',
2419                 endp->usb_endp, endp->usb_addr, endp->queue_size,
2420                 endp->queue_next, endp->queue_last);
2421         return -EINVAL;
2422 }
2423 
2424 static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
2425                 struct urb *urb, int status)
2426 {
2427         unsigned long irqs;
2428         int rc;
2429 
2430         spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2431         rc = usb_hcd_check_unlink_urb(u132_to_hcd(u132), urb, status);
2432         if (rc) {
2433                 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2434                 return rc;
2435         }
2436         if (endp->queue_size == 0) {
2437                 dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]"
2438                         "=%p ring[%d] %c%c usb_endp=%d usb_addr=%d\n", urb,
2439                         endp->endp_number, endp, endp->ring->number,
2440                         endp->input ? 'I' : ' ', endp->output ? 'O' : ' ',
2441                         endp->usb_endp, endp->usb_addr);
2442                 spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2443                 return -EINVAL;
2444         }
2445         if (urb == endp->urb_list[ENDP_QUEUE_MASK & endp->queue_next]) {
2446                 if (endp->active) {
2447                         endp->dequeueing = 1;
2448                         endp->edset_flush = 1;
2449                         u132_endp_queue_work(u132, endp, 0);
2450                         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2451                         return 0;
2452                 } else {
2453                         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2454                         u132_hcd_abandon_urb(u132, endp, urb, status);
2455                         return 0;
2456                 }
2457         } else {
2458                 u16 queue_list = 0;
2459                 u16 queue_size = endp->queue_size;
2460                 u16 queue_scan = endp->queue_next;
2461                 struct urb **urb_slot = NULL;
2462                 while (++queue_list < ENDP_QUEUE_SIZE && --queue_size > 0) {
2463                         if (urb == endp->urb_list[ENDP_QUEUE_MASK &
2464                                 ++queue_scan]) {
2465                                 urb_slot = &endp->urb_list[ENDP_QUEUE_MASK &
2466                                         queue_scan];
2467                                 break;
2468                         } else
2469                                 continue;
2470                 }
2471                 while (++queue_list < ENDP_QUEUE_SIZE && --queue_size > 0) {
2472                         *urb_slot = endp->urb_list[ENDP_QUEUE_MASK &
2473                                 ++queue_scan];
2474                         urb_slot = &endp->urb_list[ENDP_QUEUE_MASK &
2475                                 queue_scan];
2476                 }
2477                 if (urb_slot) {
2478                         struct usb_hcd *hcd = u132_to_hcd(u132);
2479 
2480                         usb_hcd_unlink_urb_from_ep(hcd, urb);
2481                         endp->queue_size -= 1;
2482                         if (list_empty(&endp->urb_more)) {
2483                                 spin_unlock_irqrestore(&endp->queue_lock.slock,
2484                                         irqs);
2485                         } else {
2486                                 struct list_head *next = endp->urb_more.next;
2487                                 struct u132_urbq *urbq = list_entry(next,
2488                                         struct u132_urbq, urb_more);
2489                                 list_del(next);
2490                                 *urb_slot = urbq->urb;
2491                                 spin_unlock_irqrestore(&endp->queue_lock.slock,
2492                                         irqs);
2493                                 kfree(urbq);
2494                         } urb->error_count = 0;
2495                         usb_hcd_giveback_urb(hcd, urb, status);
2496                         return 0;
2497                 } else if (list_empty(&endp->urb_more)) {
2498                         dev_err(&u132->platform_dev->dev, "urb=%p not found in "
2499                                 "endp[%d]=%p ring[%d] %c%c usb_endp=%d usb_addr"
2500                                 "=%d size=%d next=%04X last=%04X\n", urb,
2501                                 endp->endp_number, endp, endp->ring->number,
2502                                 endp->input ? 'I' : ' ',
2503                                 endp->output ? 'O' : ' ', endp->usb_endp,
2504                                 endp->usb_addr, endp->queue_size,
2505                                 endp->queue_next, endp->queue_last);
2506                         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2507                         return -EINVAL;
2508                 } else {
2509                         int retval;
2510 
2511                         usb_hcd_unlink_urb_from_ep(u132_to_hcd(u132), urb);
2512                         retval = dequeue_from_overflow_chain(u132, endp,
2513                                 urb);
2514                         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2515                         return retval;
2516                 }
2517         }
2518 }
2519 
2520 static int u132_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
2521 {
2522         struct u132 *u132 = hcd_to_u132(hcd);
2523         if (u132->going > 2) {
2524                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2525                         , u132->going);
2526                 return -ENODEV;
2527         } else {
2528                 u8 usb_addr = usb_pipedevice(urb->pipe);
2529                 u8 usb_endp = usb_pipeendpoint(urb->pipe);
2530                 u8 address = u132->addr[usb_addr].address;
2531                 struct u132_udev *udev = &u132->udev[address];
2532                 if (usb_pipein(urb->pipe)) {
2533                         u8 endp_number = udev->endp_number_in[usb_endp];
2534                         struct u132_endp *endp = u132->endp[endp_number - 1];
2535                         return u132_endp_urb_dequeue(u132, endp, urb, status);
2536                 } else {
2537                         u8 endp_number = udev->endp_number_out[usb_endp];
2538                         struct u132_endp *endp = u132->endp[endp_number - 1];
2539                         return u132_endp_urb_dequeue(u132, endp, urb, status);
2540                 }
2541         }
2542 }
2543 
2544 static void u132_endpoint_disable(struct usb_hcd *hcd,
2545         struct usb_host_endpoint *hep)
2546 {
2547         struct u132 *u132 = hcd_to_u132(hcd);
2548         if (u132->going > 2) {
2549                 dev_err(&u132->platform_dev->dev, "u132 device %p(hcd=%p hep=%p"
2550                         ") has been removed %d\n", u132, hcd, hep,
2551                         u132->going);
2552         } else {
2553                 struct u132_endp *endp = hep->hcpriv;
2554                 if (endp)
2555                         u132_endp_put_kref(u132, endp);
2556         }
2557 }
2558 
2559 static int u132_get_frame(struct usb_hcd *hcd)
2560 {
2561         struct u132 *u132 = hcd_to_u132(hcd);
2562         if (u132->going > 1) {
2563                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2564                         , u132->going);
2565                 return -ENODEV;
2566         } else if (u132->going > 0) {
2567                 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2568                 return -ESHUTDOWN;
2569         } else {
2570                 int frame = 0;
2571                 dev_err(&u132->platform_dev->dev, "TODO: u132_get_frame\n");
2572                 msleep(100);
2573                 return frame;
2574         }
2575 }
2576 
2577 static int u132_roothub_descriptor(struct u132 *u132,
2578         struct usb_hub_descriptor *desc)
2579 {
2580         int retval;
2581         u16 temp;
2582         u32 rh_a = -1;
2583         u32 rh_b = -1;
2584         retval = u132_read_pcimem(u132, roothub.a, &rh_a);
2585         if (retval)
2586                 return retval;
2587         desc->bDescriptorType = 0x29;
2588         desc->bPwrOn2PwrGood = (rh_a & RH_A_POTPGT) >> 24;
2589         desc->bHubContrCurrent = 0;
2590         desc->bNbrPorts = u132->num_ports;
2591         temp = 1 + (u132->num_ports / 8);
2592         desc->bDescLength = 7 + 2 * temp;
2593         temp = 0;
2594         if (rh_a & RH_A_NPS)
2595                 temp |= 0x0002;
2596         if (rh_a & RH_A_PSM)
2597                 temp |= 0x0001;
2598         if (rh_a & RH_A_NOCP)
2599                 temp |= 0x0010;
2600         else if (rh_a & RH_A_OCPM)
2601                 temp |= 0x0008;
2602         desc->wHubCharacteristics = cpu_to_le16(temp);
2603         retval = u132_read_pcimem(u132, roothub.b, &rh_b);
2604         if (retval)
2605                 return retval;
2606         memset(desc->u.hs.DeviceRemovable, 0xff,
2607                         sizeof(desc->u.hs.DeviceRemovable));
2608         desc->u.hs.DeviceRemovable[0] = rh_b & RH_B_DR;
2609         if (u132->num_ports > 7) {
2610                 desc->u.hs.DeviceRemovable[1] = (rh_b & RH_B_DR) >> 8;
2611                 desc->u.hs.DeviceRemovable[2] = 0xff;
2612         } else
2613                 desc->u.hs.DeviceRemovable[1] = 0xff;
2614         return 0;
2615 }
2616 
2617 static int u132_roothub_status(struct u132 *u132, __le32 *desc)
2618 {
2619         u32 rh_status = -1;
2620         int ret_status = u132_read_pcimem(u132, roothub.status, &rh_status);
2621         *desc = cpu_to_le32(rh_status);
2622         return ret_status;
2623 }
2624 
2625 static int u132_roothub_portstatus(struct u132 *u132, __le32 *desc, u16 wIndex)
2626 {
2627         if (wIndex == 0 || wIndex > u132->num_ports) {
2628                 return -EINVAL;
2629         } else {
2630                 int port = wIndex - 1;
2631                 u32 rh_portstatus = -1;
2632                 int ret_portstatus = u132_read_pcimem(u132,
2633                         roothub.portstatus[port], &rh_portstatus);
2634                 *desc = cpu_to_le32(rh_portstatus);
2635                 if (*(u16 *) (desc + 2)) {
2636                         dev_info(&u132->platform_dev->dev, "Port %d Status Chan"
2637                                 "ge = %08X\n", port, *desc);
2638                 }
2639                 return ret_portstatus;
2640         }
2641 }
2642 
2643 
2644 /* this timer value might be vendor-specific ... */
2645 #define PORT_RESET_HW_MSEC 10
2646 #define PORT_RESET_MSEC 10
2647 /* wrap-aware logic morphed from <linux/jiffies.h> */
2648 #define tick_before(t1, t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
2649 static int u132_roothub_portreset(struct u132 *u132, int port_index)
2650 {
2651         int retval;
2652         u32 fmnumber;
2653         u16 now;
2654         u16 reset_done;
2655         retval = u132_read_pcimem(u132, fmnumber, &fmnumber);
2656         if (retval)
2657                 return retval;
2658         now = fmnumber;
2659         reset_done = now + PORT_RESET_MSEC;
2660         do {
2661                 u32 portstat;
2662                 do {
2663                         retval = u132_read_pcimem(u132,
2664                                 roothub.portstatus[port_index], &portstat);
2665                         if (retval)
2666                                 return retval;
2667                         if (RH_PS_PRS & portstat)
2668                                 continue;
2669                         else
2670                                 break;
2671                 } while (tick_before(now, reset_done));
2672                 if (RH_PS_PRS & portstat)
2673                         return -ENODEV;
2674                 if (RH_PS_CCS & portstat) {
2675                         if (RH_PS_PRSC & portstat) {
2676                                 retval = u132_write_pcimem(u132,
2677                                         roothub.portstatus[port_index],
2678                                         RH_PS_PRSC);
2679                                 if (retval)
2680                                         return retval;
2681                         }
2682                 } else
2683                         break;  /* start the next reset,
2684                                 sleep till it's probably done */
2685                 retval = u132_write_pcimem(u132, roothub.portstatus[port_index],
2686                          RH_PS_PRS);
2687                 if (retval)
2688                         return retval;
2689                 msleep(PORT_RESET_HW_MSEC);
2690                 retval = u132_read_pcimem(u132, fmnumber, &fmnumber);
2691                 if (retval)
2692                         return retval;
2693                 now = fmnumber;
2694         } while (tick_before(now, reset_done));
2695         return 0;
2696 }
2697 
2698 static int u132_roothub_setportfeature(struct u132 *u132, u16 wValue,
2699         u16 wIndex)
2700 {
2701         if (wIndex == 0 || wIndex > u132->num_ports) {
2702                 return -EINVAL;
2703         } else {
2704                 int retval;
2705                 int port_index = wIndex - 1;
2706                 struct u132_port *port = &u132->port[port_index];
2707                 port->Status &= ~(1 << wValue);
2708                 switch (wValue) {
2709                 case USB_PORT_FEAT_SUSPEND:
2710                         retval = u132_write_pcimem(u132,
2711                                 roothub.portstatus[port_index], RH_PS_PSS);
2712                         if (retval)
2713                                 return retval;
2714                         return 0;
2715                 case USB_PORT_FEAT_POWER:
2716                         retval = u132_write_pcimem(u132,
2717                                 roothub.portstatus[port_index], RH_PS_PPS);
2718                         if (retval)
2719                                 return retval;
2720                         return 0;
2721                 case USB_PORT_FEAT_RESET:
2722                         retval = u132_roothub_portreset(u132, port_index);
2723                         if (retval)
2724                                 return retval;
2725                         return 0;
2726                 default:
2727                         return -EPIPE;
2728                 }
2729         }
2730 }
2731 
2732 static int u132_roothub_clearportfeature(struct u132 *u132, u16 wValue,
2733         u16 wIndex)
2734 {
2735         if (wIndex == 0 || wIndex > u132->num_ports) {
2736                 return -EINVAL;
2737         } else {
2738                 int port_index = wIndex - 1;
2739                 u32 temp;
2740                 int retval;
2741                 struct u132_port *port = &u132->port[port_index];
2742                 port->Status &= ~(1 << wValue);
2743                 switch (wValue) {
2744                 case USB_PORT_FEAT_ENABLE:
2745                         temp = RH_PS_CCS;
2746                         break;
2747                 case USB_PORT_FEAT_C_ENABLE:
2748                         temp = RH_PS_PESC;
2749                         break;
2750                 case USB_PORT_FEAT_SUSPEND:
2751                         temp = RH_PS_POCI;
2752                         if ((u132->hc_control & OHCI_CTRL_HCFS)
2753                                 != OHCI_USB_OPER) {
2754                                 dev_err(&u132->platform_dev->dev, "TODO resume_"
2755                                         "root_hub\n");
2756                         }
2757                         break;
2758                 case USB_PORT_FEAT_C_SUSPEND:
2759                         temp = RH_PS_PSSC;
2760                         break;
2761                 case USB_PORT_FEAT_POWER:
2762                         temp = RH_PS_LSDA;
2763                         break;
2764                 case USB_PORT_FEAT_C_CONNECTION:
2765                         temp = RH_PS_CSC;
2766                         break;
2767                 case USB_PORT_FEAT_C_OVER_CURRENT:
2768                         temp = RH_PS_OCIC;
2769                         break;
2770                 case USB_PORT_FEAT_C_RESET:
2771                         temp = RH_PS_PRSC;
2772                         break;
2773                 default:
2774                         return -EPIPE;
2775                 }
2776                 retval = u132_write_pcimem(u132, roothub.portstatus[port_index],
2777                          temp);
2778                 if (retval)
2779                         return retval;
2780                 return 0;
2781         }
2782 }
2783 
2784 
2785 /* the virtual root hub timer IRQ checks for hub status*/
2786 static int u132_hub_status_data(struct usb_hcd *hcd, char *buf)
2787 {
2788         struct u132 *u132 = hcd_to_u132(hcd);
2789         if (u132->going > 1) {
2790                 dev_err(&u132->platform_dev->dev, "device hcd=%p has been remov"
2791                         "ed %d\n", hcd, u132->going);
2792                 return -ENODEV;
2793         } else if (u132->going > 0) {
2794                 dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
2795                         "ed\n", hcd);
2796                 return -ESHUTDOWN;
2797         } else {
2798                 int i, changed = 0, length = 1;
2799                 if (u132->flags & OHCI_QUIRK_AMD756) {
2800                         if ((u132->hc_roothub_a & RH_A_NDP) > MAX_ROOT_PORTS) {
2801                                 dev_err(&u132->platform_dev->dev, "bogus NDP, r"
2802                                         "ereads as NDP=%d\n",
2803                                         u132->hc_roothub_a & RH_A_NDP);
2804                                 goto done;
2805                         }
2806                 }
2807                 if (u132->hc_roothub_status & (RH_HS_LPSC | RH_HS_OCIC))
2808                         buf[0] = changed = 1;
2809                 else
2810                         buf[0] = 0;
2811                 if (u132->num_ports > 7) {
2812                         buf[1] = 0;
2813                         length++;
2814                 }
2815                 for (i = 0; i < u132->num_ports; i++) {
2816                         if (u132->hc_roothub_portstatus[i] & (RH_PS_CSC |
2817                                 RH_PS_PESC | RH_PS_PSSC | RH_PS_OCIC |
2818                                 RH_PS_PRSC)) {
2819                                 changed = 1;
2820                                 if (i < 7)
2821                                         buf[0] |= 1 << (i + 1);
2822                                 else
2823                                         buf[1] |= 1 << (i - 7);
2824                                 continue;
2825                         }
2826                         if (!(u132->hc_roothub_portstatus[i] & RH_PS_CCS))
2827                                 continue;
2828 
2829                         if ((u132->hc_roothub_portstatus[i] & RH_PS_PSS))
2830                                 continue;
2831                 }
2832 done:
2833                 return changed ? length : 0;
2834         }
2835 }
2836 
2837 static int u132_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
2838         u16 wIndex, char *buf, u16 wLength)
2839 {
2840         struct u132 *u132 = hcd_to_u132(hcd);
2841         if (u132->going > 1) {
2842                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2843                         , u132->going);
2844                 return -ENODEV;
2845         } else if (u132->going > 0) {
2846                 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2847                 return -ESHUTDOWN;
2848         } else {
2849                 int retval = 0;
2850                 mutex_lock(&u132->sw_lock);
2851                 switch (typeReq) {
2852                 case ClearHubFeature:
2853                         switch (wValue) {
2854                         case C_HUB_OVER_CURRENT:
2855                         case C_HUB_LOCAL_POWER:
2856                                 break;
2857                         default:
2858                                 goto stall;
2859                         }
2860                         break;
2861                 case SetHubFeature:
2862                         switch (wValue) {
2863                         case C_HUB_OVER_CURRENT:
2864                         case C_HUB_LOCAL_POWER:
2865                                 break;
2866                         default:
2867                                 goto stall;
2868                         }
2869                         break;
2870                 case ClearPortFeature:{
2871                                 retval = u132_roothub_clearportfeature(u132,
2872                                         wValue, wIndex);
2873                                 if (retval)
2874                                         goto error;
2875                                 break;
2876                         }
2877                 case GetHubDescriptor:{
2878                                 retval = u132_roothub_descriptor(u132,
2879                                         (struct usb_hub_descriptor *)buf);
2880                                 if (retval)
2881                                         goto error;
2882                                 break;
2883                         }
2884                 case GetHubStatus:{
2885                                 retval = u132_roothub_status(u132,
2886                                         (__le32 *) buf);
2887                                 if (retval)
2888                                         goto error;
2889                                 break;
2890                         }
2891                 case GetPortStatus:{
2892                                 retval = u132_roothub_portstatus(u132,
2893                                         (__le32 *) buf, wIndex);
2894                                 if (retval)
2895                                         goto error;
2896                                 break;
2897                         }
2898                 case SetPortFeature:{
2899                                 retval = u132_roothub_setportfeature(u132,
2900                                         wValue, wIndex);
2901                                 if (retval)
2902                                         goto error;
2903                                 break;
2904                         }
2905                 default:
2906                         goto stall;
2907                 error:
2908                         u132_disable(u132);
2909                         u132->going = 1;
2910                         break;
2911                 stall:
2912                         retval = -EPIPE;
2913                         break;
2914                 }
2915                 mutex_unlock(&u132->sw_lock);
2916                 return retval;
2917         }
2918 }
2919 
2920 static int u132_start_port_reset(struct usb_hcd *hcd, unsigned port_num)
2921 {
2922         struct u132 *u132 = hcd_to_u132(hcd);
2923         if (u132->going > 1) {
2924                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2925                         , u132->going);
2926                 return -ENODEV;
2927         } else if (u132->going > 0) {
2928                 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2929                 return -ESHUTDOWN;
2930         } else
2931                 return 0;
2932 }
2933 
2934 
2935 #ifdef CONFIG_PM
2936 static int u132_bus_suspend(struct usb_hcd *hcd)
2937 {
2938         struct u132 *u132 = hcd_to_u132(hcd);
2939         if (u132->going > 1) {
2940                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2941                         , u132->going);
2942                 return -ENODEV;
2943         } else if (u132->going > 0) {
2944                 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2945                 return -ESHUTDOWN;
2946         } else
2947                 return 0;
2948 }
2949 
2950 static int u132_bus_resume(struct usb_hcd *hcd)
2951 {
2952         struct u132 *u132 = hcd_to_u132(hcd);
2953         if (u132->going > 1) {
2954                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2955                         , u132->going);
2956                 return -ENODEV;
2957         } else if (u132->going > 0) {
2958                 dev_err(&u132->platform_dev->dev, "device is being removed\n");
2959                 return -ESHUTDOWN;
2960         } else
2961                 return 0;
2962 }
2963 
2964 #else
2965 #define u132_bus_suspend NULL
2966 #define u132_bus_resume NULL
2967 #endif
2968 static struct hc_driver u132_hc_driver = {
2969         .description = hcd_name,
2970         .hcd_priv_size = sizeof(struct u132),
2971         .irq = NULL,
2972         .flags = HCD_USB11 | HCD_MEMORY,
2973         .reset = u132_hcd_reset,
2974         .start = u132_hcd_start,
2975         .stop = u132_hcd_stop,
2976         .urb_enqueue = u132_urb_enqueue,
2977         .urb_dequeue = u132_urb_dequeue,
2978         .endpoint_disable = u132_endpoint_disable,
2979         .get_frame_number = u132_get_frame,
2980         .hub_status_data = u132_hub_status_data,
2981         .hub_control = u132_hub_control,
2982         .bus_suspend = u132_bus_suspend,
2983         .bus_resume = u132_bus_resume,
2984         .start_port_reset = u132_start_port_reset,
2985 };
2986 
2987 /*
2988 * This function may be called by the USB core whilst the "usb_all_devices_rwsem"
2989 * is held for writing, thus this module must not call usb_remove_hcd()
2990 * synchronously - but instead should immediately stop activity to the
2991 * device and asynchronously call usb_remove_hcd()
2992 */
2993 static int u132_remove(struct platform_device *pdev)
2994 {
2995         struct usb_hcd *hcd = platform_get_drvdata(pdev);
2996         if (hcd) {
2997                 struct u132 *u132 = hcd_to_u132(hcd);
2998                 if (u132->going++ > 1) {
2999                         dev_err(&u132->platform_dev->dev, "already being remove"
3000                                 "d\n");
3001                         return -ENODEV;
3002                 } else {
3003                         int rings = MAX_U132_RINGS;
3004                         int endps = MAX_U132_ENDPS;
3005                         dev_err(&u132->platform_dev->dev, "removing device u132"
3006                                 ".%d\n", u132->sequence_num);
3007                         msleep(100);
3008                         mutex_lock(&u132->sw_lock);
3009                         u132_monitor_cancel_work(u132);
3010                         while (rings-- > 0) {
3011                                 struct u132_ring *ring = &u132->ring[rings];
3012                                 u132_ring_cancel_work(u132, ring);
3013                         } while (endps-- > 0) {
3014                                 struct u132_endp *endp = u132->endp[endps];
3015                                 if (endp)
3016                                         u132_endp_cancel_work(u132, endp);
3017                         }
3018                         u132->going += 1;
3019                         printk(KERN_INFO "removing device u132.%d\n",
3020                                 u132->sequence_num);
3021                         mutex_unlock(&u132->sw_lock);
3022                         usb_remove_hcd(hcd);
3023                         u132_u132_put_kref(u132);
3024                         return 0;
3025                 }
3026         } else
3027                 return 0;
3028 }
3029 
3030 static void u132_initialise(struct u132 *u132, struct platform_device *pdev)
3031 {
3032         int rings = MAX_U132_RINGS;
3033         int ports = MAX_U132_PORTS;
3034         int addrs = MAX_U132_ADDRS;
3035         int udevs = MAX_U132_UDEVS;
3036         int endps = MAX_U132_ENDPS;
3037         u132->board = dev_get_platdata(&pdev->dev);
3038         u132->platform_dev = pdev;
3039         u132->power = 0;
3040         u132->reset = 0;
3041         mutex_init(&u132->sw_lock);
3042         mutex_init(&u132->scheduler_lock);
3043         while (rings-- > 0) {
3044                 struct u132_ring *ring = &u132->ring[rings];
3045                 ring->u132 = u132;
3046                 ring->number = rings + 1;
3047                 ring->length = 0;
3048                 ring->curr_endp = NULL;
3049                 INIT_DELAYED_WORK(&ring->scheduler,
3050                                   u132_hcd_ring_work_scheduler);
3051         }
3052         mutex_lock(&u132->sw_lock);
3053         INIT_DELAYED_WORK(&u132->monitor, u132_hcd_monitor_work);
3054         while (ports-- > 0) {
3055                 struct u132_port *port = &u132->port[ports];
3056                 port->u132 = u132;
3057                 port->reset = 0;
3058                 port->enable = 0;
3059                 port->power = 0;
3060                 port->Status = 0;
3061         }
3062         while (addrs-- > 0) {
3063                 struct u132_addr *addr = &u132->addr[addrs];
3064                 addr->address = 0;
3065         }
3066         while (udevs-- > 0) {
3067                 struct u132_udev *udev = &u132->udev[udevs];
3068                 int i = ARRAY_SIZE(udev->endp_number_in);
3069                 int o = ARRAY_SIZE(udev->endp_number_out);
3070                 udev->usb_device = NULL;
3071                 udev->udev_number = 0;
3072                 udev->usb_addr = 0;
3073                 udev->portnumber = 0;
3074                 while (i-- > 0)
3075                         udev->endp_number_in[i] = 0;
3076 
3077                 while (o-- > 0)
3078                         udev->endp_number_out[o] = 0;
3079 
3080         }
3081         while (endps-- > 0)
3082                 u132->endp[endps] = NULL;
3083 
3084         mutex_unlock(&u132->sw_lock);
3085 }
3086 
3087 static int u132_probe(struct platform_device *pdev)
3088 {
3089         struct usb_hcd *hcd;
3090         int retval;
3091         u32 control;
3092         u32 rh_a = -1;
3093         u32 num_ports;
3094 
3095         msleep(100);
3096         if (u132_exiting > 0)
3097                 return -ENODEV;
3098 
3099         retval = ftdi_write_pcimem(pdev, intrdisable, OHCI_INTR_MIE);
3100         if (retval)
3101                 return retval;
3102         retval = ftdi_read_pcimem(pdev, control, &control);
3103         if (retval)
3104                 return retval;
3105         retval = ftdi_read_pcimem(pdev, roothub.a, &rh_a);
3106         if (retval)
3107                 return retval;
3108         num_ports = rh_a & RH_A_NDP;    /* refuse to confuse usbcore */
3109         if (pdev->dev.dma_mask)
3110                 return -EINVAL;
3111 
3112         hcd = usb_create_hcd(&u132_hc_driver, &pdev->dev, dev_name(&pdev->dev));
3113         if (!hcd) {
3114                 printk(KERN_ERR "failed to create the usb hcd struct for U132\n"
3115                         );
3116                 ftdi_elan_gone_away(pdev);
3117                 return -ENOMEM;
3118         } else {
3119                 struct u132 *u132 = hcd_to_u132(hcd);
3120                 retval = 0;
3121                 hcd->rsrc_start = 0;
3122                 mutex_lock(&u132_module_lock);
3123                 list_add_tail(&u132->u132_list, &u132_static_list);
3124                 u132->sequence_num = ++u132_instances;
3125                 mutex_unlock(&u132_module_lock);
3126                 u132_u132_init_kref(u132);
3127                 u132_initialise(u132, pdev);
3128                 hcd->product_desc = "ELAN U132 Host Controller";
3129                 retval = usb_add_hcd(hcd, 0, 0);
3130                 if (retval != 0) {
3131                         dev_err(&u132->platform_dev->dev, "init error %d\n",
3132                                 retval);
3133                         u132_u132_put_kref(u132);
3134                         return retval;
3135                 } else {
3136                         device_wakeup_enable(hcd->self.controller);
3137                         u132_monitor_queue_work(u132, 100);
3138                         return 0;
3139                 }
3140         }
3141 }
3142 
3143 
3144 #ifdef CONFIG_PM
3145 /*
3146  * for this device there's no useful distinction between the controller
3147  * and its root hub, except that the root hub only gets direct PM calls
3148  * when CONFIG_PM_RUNTIME is enabled.
3149  */
3150 static int u132_suspend(struct platform_device *pdev, pm_message_t state)
3151 {
3152         struct usb_hcd *hcd = platform_get_drvdata(pdev);
3153         struct u132 *u132 = hcd_to_u132(hcd);
3154         if (u132->going > 1) {
3155                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3156                         , u132->going);
3157                 return -ENODEV;
3158         } else if (u132->going > 0) {
3159                 dev_err(&u132->platform_dev->dev, "device is being removed\n");
3160                 return -ESHUTDOWN;
3161         } else {
3162                 int retval = 0, ports;
3163 
3164                 switch (state.event) {
3165                 case PM_EVENT_FREEZE:
3166                         retval = u132_bus_suspend(hcd);
3167                         break;
3168                 case PM_EVENT_SUSPEND:
3169                 case PM_EVENT_HIBERNATE:
3170                         ports = MAX_U132_PORTS;
3171                         while (ports-- > 0) {
3172                                 port_power(u132, ports, 0);
3173                         }
3174                         break;
3175                 }
3176                 return retval;
3177         }
3178 }
3179 
3180 static int u132_resume(struct platform_device *pdev)
3181 {
3182         struct usb_hcd *hcd = platform_get_drvdata(pdev);
3183         struct u132 *u132 = hcd_to_u132(hcd);
3184         if (u132->going > 1) {
3185                 dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3186                         , u132->going);
3187                 return -ENODEV;
3188         } else if (u132->going > 0) {
3189                 dev_err(&u132->platform_dev->dev, "device is being removed\n");
3190                 return -ESHUTDOWN;
3191         } else {
3192                 int retval = 0;
3193                 if (!u132->port[0].power) {
3194                         int ports = MAX_U132_PORTS;
3195                         while (ports-- > 0) {
3196                                 port_power(u132, ports, 1);
3197                         }
3198                         retval = 0;
3199                 } else {
3200                         retval = u132_bus_resume(hcd);
3201                 }
3202                 return retval;
3203         }
3204 }
3205 
3206 #else
3207 #define u132_suspend NULL
3208 #define u132_resume NULL
3209 #endif
3210 /*
3211 * this driver is loaded explicitly by ftdi_u132
3212 *
3213 * the platform_driver struct is static because it is per type of module
3214 */
3215 static struct platform_driver u132_platform_driver = {
3216         .probe = u132_probe,
3217         .remove = u132_remove,
3218         .suspend = u132_suspend,
3219         .resume = u132_resume,
3220         .driver = {
3221                    .name = hcd_name,
3222                    .owner = THIS_MODULE,
3223                    },
3224 };
3225 static int __init u132_hcd_init(void)
3226 {
3227         int retval;
3228         INIT_LIST_HEAD(&u132_static_list);
3229         u132_instances = 0;
3230         u132_exiting = 0;
3231         mutex_init(&u132_module_lock);
3232         if (usb_disabled())
3233                 return -ENODEV;
3234         printk(KERN_INFO "driver %s\n", hcd_name);
3235         workqueue = create_singlethread_workqueue("u132");
3236         retval = platform_driver_register(&u132_platform_driver);
3237         return retval;
3238 }
3239 
3240 
3241 module_init(u132_hcd_init);
3242 static void __exit u132_hcd_exit(void)
3243 {
3244         struct u132 *u132;
3245         struct u132 *temp;
3246         mutex_lock(&u132_module_lock);
3247         u132_exiting += 1;
3248         mutex_unlock(&u132_module_lock);
3249         list_for_each_entry_safe(u132, temp, &u132_static_list, u132_list) {
3250                 platform_device_unregister(u132->platform_dev);
3251         }
3252         platform_driver_unregister(&u132_platform_driver);
3253         printk(KERN_INFO "u132-hcd driver deregistered\n");
3254         wait_event(u132_hcd_wait, u132_instances == 0);
3255         flush_workqueue(workqueue);
3256         destroy_workqueue(workqueue);
3257 }
3258 
3259 
3260 module_exit(u132_hcd_exit);
3261 MODULE_LICENSE("GPL");
3262 MODULE_ALIAS("platform:u132_hcd");
3263 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us