Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

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

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