usb/host/u132-hcd.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003 * Host Controller Driver for the Elan Digital Systems U132 adapter
0004 *
0005 * Copyright(C) 2006 Elan Digital Systems Limited
0006 * http://www.elandigitalsystems.com
0007 *
0008 * Author and Maintainer - Tony Olech - Elan Digital Systems
0009 * tony.olech@elandigitalsystems.com
0010 *
0011 * This driver was written by Tony Olech(tony.olech@elandigitalsystems.com)
0012 * based on various USB host drivers in the 2.6.15 linux kernel
0013 * with constant reference to the 3rd Edition of Linux Device Drivers
0014 * published by O'Reilly
0015 *
0016 * The U132 adapter is a USB to CardBus adapter specifically designed
0017 * for PC cards that contain an OHCI host controller. Typical PC cards
0018 * are the Orange Mobile 3G Option GlobeTrotter Fusion card.
0019 *
0020 * The U132 adapter will *NOT *work with PC cards that do not contain
0021 * an OHCI controller. A simple way to test whether a PC card has an
0022 * OHCI controller as an interface is to insert the PC card directly
0023 * into a laptop(or desktop) with a CardBus slot and if "lspci" shows
0024 * a new USB controller and "lsusb -v" shows a new OHCI Host Controller
0025 * then there is a good chance that the U132 adapter will support the
0026 * PC card.(you also need the specific client driver for the PC card)
0027 *
0028 * Please inform the Author and Maintainer about any PC cards that
0029 * contain OHCI Host Controller and work when directly connected to
0030 * an embedded CardBus slot but do not work when they are connected
0031 * via an ELAN U132 adapter.
0032 *
0033 */
0034 #include <linux/kernel.h>
0035 #include <linux/module.h>
0036 #include <linux/moduleparam.h>
0037 #include <linux/delay.h>
0038 #include <linux/ioport.h>
0039 #include <linux/pci_ids.h>
0040 #include <linux/sched.h>
0041 #include <linux/slab.h>
0042 #include <linux/errno.h>
0043 #include <linux/init.h>
0044 #include <linux/timer.h>
0045 #include <linux/list.h>
0046 #include <linux/interrupt.h>
0047 #include <linux/usb.h>
0048 #include <linux/usb/hcd.h>
0049 #include <linux/workqueue.h>
0050 #include <linux/platform_device.h>
0051 #include <linux/mutex.h>
0052 #include <asm/io.h>
0053 #include <asm/irq.h>
0054 #include <asm/byteorder.h>
0055
0056     /* FIXME ohci.h is ONLY for internal use by the OHCI driver.
0057      * If you're going to try stuff like this, you need to split
0058      * out shareable stuff (register declarations?) into its own
0059      * file, maybe name <linux/usb/ohci.h>
0060      */
0061
0062 #include "ohci.h"
0063 #define OHCI_CONTROL_INIT OHCI_CTRL_CBSR
0064 #define OHCI_INTR_INIT (OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_RD | \
0065     OHCI_INTR_WDH)
0066 MODULE_AUTHOR("Tony Olech - Elan Digital Systems Limited");
0067 MODULE_DESCRIPTION("U132 USB Host Controller Driver");
0068 MODULE_LICENSE("GPL");
0069 #define INT_MODULE_PARM(n, v) static int n = v;module_param(n, int, 0444)
0070 INT_MODULE_PARM(testing, 0);
0071 /* Some boards misreport power switching/overcurrent*/
0072 static bool distrust_firmware = true;
0073 module_param(distrust_firmware, bool, 0);
0074 MODULE_PARM_DESC(distrust_firmware, "true to distrust firmware power/overcurrent"
0075     "t setup");
0076 static DECLARE_WAIT_QUEUE_HEAD(u132_hcd_wait);
0077 /*
0078 * u132_module_lock exists to protect access to global variables
0079 *
0080 */
0081 static DEFINE_MUTEX(u132_module_lock);
0082 static int u132_exiting;
0083 static int u132_instances;
0084 /*
0085 * end of the global variables protected by u132_module_lock
0086 */
0087 static struct workqueue_struct *workqueue;
0088 #define MAX_U132_PORTS 7
0089 #define MAX_U132_ADDRS 128
0090 #define MAX_U132_UDEVS 4
0091 #define MAX_U132_ENDPS 100
0092 #define MAX_U132_RINGS 4
0093 static const char *cc_to_text[16] = {
0094     "No Error ",
0095     "CRC Error ",
0096     "Bit Stuff ",
0097     "Data Togg ",
0098     "Stall ",
0099     "DevNotResp ",
0100     "PIDCheck ",
0101     "UnExpPID ",
0102     "DataOver ",
0103     "DataUnder ",
0104     "(for hw) ",
0105     "(for hw) ",
0106     "BufferOver ",
0107     "BuffUnder ",
0108     "(for HCD) ",
0109     "(for HCD) "
0110 };
0111 struct u132_port {
0112     struct u132 *u132;
0113     int reset;
0114     int enable;
0115     int power;
0116     int Status;
0117 };
0118 struct u132_addr {
0119     u8 address;
0120 };
0121 struct u132_udev {
0122     struct kref kref;
0123     struct usb_device *usb_device;
0124     u8 enumeration;
0125     u8 udev_number;
0126     u8 usb_addr;
0127     u8 portnumber;
0128     u8 endp_number_in[16];
0129     u8 endp_number_out[16];
0130 };
0131 #define ENDP_QUEUE_SHIFT 3
0132 #define ENDP_QUEUE_SIZE (1<<ENDP_QUEUE_SHIFT)
0133 #define ENDP_QUEUE_MASK (ENDP_QUEUE_SIZE-1)
0134 struct u132_urbq {
0135     struct list_head urb_more;
0136     struct urb *urb;
0137 };
0138 struct u132_spin {
0139     spinlock_t slock;
0140 };
0141 struct u132_endp {
0142     struct kref kref;
0143     u8 udev_number;
0144     u8 endp_number;
0145     u8 usb_addr;
0146     u8 usb_endp;
0147     struct u132 *u132;
0148     struct list_head endp_ring;
0149     struct u132_ring *ring;
0150     unsigned toggle_bits:2;
0151     unsigned active:1;
0152     unsigned delayed:1;
0153     unsigned input:1;
0154     unsigned output:1;
0155     unsigned pipetype:2;
0156     unsigned dequeueing:1;
0157     unsigned edset_flush:1;
0158     unsigned spare_bits:14;
0159     unsigned long jiffies;
0160     struct usb_host_endpoint *hep;
0161     struct u132_spin queue_lock;
0162     u16 queue_size;
0163     u16 queue_last;
0164     u16 queue_next;
0165     struct urb *urb_list[ENDP_QUEUE_SIZE];
0166     struct list_head urb_more;
0167     struct delayed_work scheduler;
0168 };
0169 struct u132_ring {
0170     unsigned in_use:1;
0171     unsigned length:7;
0172     u8 number;
0173     struct u132 *u132;
0174     struct u132_endp *curr_endp;
0175     struct delayed_work scheduler;
0176 };
0177 struct u132 {
0178     struct kref kref;
0179     struct mutex sw_lock;
0180     struct mutex scheduler_lock;
0181     struct u132_platform_data *board;
0182     struct platform_device *platform_dev;
0183     struct u132_ring ring[MAX_U132_RINGS];
0184     int sequence_num;
0185     int going;
0186     int power;
0187     int reset;
0188     int num_ports;
0189     u32 hc_control;
0190     u32 hc_fminterval;
0191     u32 hc_roothub_status;
0192     u32 hc_roothub_a;
0193     u32 hc_roothub_portstatus[MAX_ROOT_PORTS];
0194     int flags;
0195     unsigned long next_statechange;
0196     struct delayed_work monitor;
0197     int num_endpoints;
0198     struct u132_addr addr[MAX_U132_ADDRS];
0199     struct u132_udev udev[MAX_U132_UDEVS];
0200     struct u132_port port[MAX_U132_PORTS];
0201     struct u132_endp *endp[MAX_U132_ENDPS];
0202 };
0203
0204 /*
0205 * these cannot be inlines because we need the structure offset!!
0206 * Does anyone have a better way?????
0207 */
0208 #define ftdi_read_pcimem(pdev, member, data) usb_ftdi_elan_read_pcimem(pdev, \
0209     offsetof(struct ohci_regs, member), 0, data);
0210 #define ftdi_write_pcimem(pdev, member, data) usb_ftdi_elan_write_pcimem(pdev, \
0211     offsetof(struct ohci_regs, member), 0, data)
0212 #define u132_read_pcimem(u132, member, data) \
0213     usb_ftdi_elan_read_pcimem(u132->platform_dev, offsetof(struct \
0214     ohci_regs, member), 0, data)
0215 #define u132_write_pcimem(u132, member, data) \
0216     usb_ftdi_elan_write_pcimem(u132->platform_dev, offsetof(struct \
0217     ohci_regs, member), 0, data)
0218 static inline struct u132 *udev_to_u132(struct u132_udev *udev)
0219 {
0220     u8 udev_number = udev->udev_number;
0221     return container_of(udev, struct u132, udev[udev_number]);
0222 }
0223
0224 static inline struct u132 *hcd_to_u132(struct usb_hcd *hcd)
0225 {
0226     return (struct u132 *)(hcd->hcd_priv);
0227 }
0228
0229 static inline struct usb_hcd *u132_to_hcd(struct u132 *u132)
0230 {
0231     return container_of((void *)u132, struct usb_hcd, hcd_priv);
0232 }
0233
0234 static inline void u132_disable(struct u132 *u132)
0235 {
0236     u132_to_hcd(u132)->state = HC_STATE_HALT;
0237 }
0238
0239
0240 #define kref_to_u132(d) container_of(d, struct u132, kref)
0241 #define kref_to_u132_endp(d) container_of(d, struct u132_endp, kref)
0242 #define kref_to_u132_udev(d) container_of(d, struct u132_udev, kref)
0243 #include "../misc/usb_u132.h"
0244 static const char hcd_name[] = "u132_hcd";
0245 #define PORT_C_MASK ((USB_PORT_STAT_C_CONNECTION | USB_PORT_STAT_C_ENABLE | \
0246     USB_PORT_STAT_C_SUSPEND | USB_PORT_STAT_C_OVERCURRENT | \
0247     USB_PORT_STAT_C_RESET) << 16)
0248 static void u132_hcd_delete(struct kref *kref)
0249 {
0250     struct u132 *u132 = kref_to_u132(kref);
0251     struct platform_device *pdev = u132->platform_dev;
0252     struct usb_hcd *hcd = u132_to_hcd(u132);
0253     u132->going += 1;
0254     mutex_lock(&u132_module_lock);
0255     u132_instances -= 1;
0256     mutex_unlock(&u132_module_lock);
0257     dev_warn(&u132->platform_dev->dev, "FREEING the hcd=%p and thus the u13"
0258         "2=%p going=%d pdev=%p\n", hcd, u132, u132->going, pdev);
0259     usb_put_hcd(hcd);
0260 }
0261
0262 static inline void u132_u132_put_kref(struct u132 *u132)
0263 {
0264     kref_put(&u132->kref, u132_hcd_delete);
0265 }
0266
0267 static inline void u132_u132_init_kref(struct u132 *u132)
0268 {
0269     kref_init(&u132->kref);
0270 }
0271
0272 static void u132_udev_delete(struct kref *kref)
0273 {
0274     struct u132_udev *udev = kref_to_u132_udev(kref);
0275     udev->udev_number = 0;
0276     udev->usb_device = NULL;
0277     udev->usb_addr = 0;
0278     udev->enumeration = 0;
0279 }
0280
0281 static inline void u132_udev_put_kref(struct u132 *u132, struct u132_udev *udev)
0282 {
0283     kref_put(&udev->kref, u132_udev_delete);
0284 }
0285
0286 static inline void u132_udev_get_kref(struct u132 *u132, struct u132_udev *udev)
0287 {
0288     kref_get(&udev->kref);
0289 }
0290
0291 static inline void u132_udev_init_kref(struct u132 *u132,
0292     struct u132_udev *udev)
0293 {
0294     kref_init(&udev->kref);
0295 }
0296
0297 static inline void u132_ring_put_kref(struct u132 *u132, struct u132_ring *ring)
0298 {
0299     kref_put(&u132->kref, u132_hcd_delete);
0300 }
0301
0302 static void u132_ring_requeue_work(struct u132 *u132, struct u132_ring *ring,
0303     unsigned int delta)
0304 {
0305     if (delta > 0) {
0306         if (queue_delayed_work(workqueue, &ring->scheduler, delta))
0307             return;
0308     } else if (queue_delayed_work(workqueue, &ring->scheduler, 0))
0309         return;
0310     kref_put(&u132->kref, u132_hcd_delete);
0311 }
0312
0313 static void u132_ring_queue_work(struct u132 *u132, struct u132_ring *ring,
0314     unsigned int delta)
0315 {
0316     kref_get(&u132->kref);
0317     u132_ring_requeue_work(u132, ring, delta);
0318 }
0319
0320 static void u132_ring_cancel_work(struct u132 *u132, struct u132_ring *ring)
0321 {
0322     if (cancel_delayed_work(&ring->scheduler))
0323         kref_put(&u132->kref, u132_hcd_delete);
0324 }
0325
0326 static void u132_endp_delete(struct kref *kref)
0327 {
0328     struct u132_endp *endp = kref_to_u132_endp(kref);
0329     struct u132 *u132 = endp->u132;
0330     u8 usb_addr = endp->usb_addr;
0331     u8 usb_endp = endp->usb_endp;
0332     u8 address = u132->addr[usb_addr].address;
0333     struct u132_udev *udev = &u132->udev[address];
0334     u8 endp_number = endp->endp_number;
0335     struct usb_host_endpoint *hep = endp->hep;
0336     struct u132_ring *ring = endp->ring;
0337     struct list_head *head = &endp->endp_ring;
0338     ring->length -= 1;
0339     if (endp == ring->curr_endp) {
0340         if (list_empty(head)) {
0341             ring->curr_endp = NULL;
0342             list_del(head);
0343         } else {
0344             struct u132_endp *next_endp = list_entry(head->next,
0345                 struct u132_endp, endp_ring);
0346             ring->curr_endp = next_endp;
0347             list_del(head);
0348         }
0349     } else
0350         list_del(head);
0351     if (endp->input) {
0352         udev->endp_number_in[usb_endp] = 0;
0353         u132_udev_put_kref(u132, udev);
0354     }
0355     if (endp->output) {
0356         udev->endp_number_out[usb_endp] = 0;
0357         u132_udev_put_kref(u132, udev);
0358     }
0359     u132->endp[endp_number - 1] = NULL;
0360     hep->hcpriv = NULL;
0361     kfree(endp);
0362     u132_u132_put_kref(u132);
0363 }
0364
0365 static inline void u132_endp_put_kref(struct u132 *u132, struct u132_endp *endp)
0366 {
0367     kref_put(&endp->kref, u132_endp_delete);
0368 }
0369
0370 static inline void u132_endp_get_kref(struct u132 *u132, struct u132_endp *endp)
0371 {
0372     kref_get(&endp->kref);
0373 }
0374
0375 static inline void u132_endp_init_kref(struct u132 *u132,
0376     struct u132_endp *endp)
0377 {
0378     kref_init(&endp->kref);
0379     kref_get(&u132->kref);
0380 }
0381
0382 static void u132_endp_queue_work(struct u132 *u132, struct u132_endp *endp,
0383     unsigned int delta)
0384 {
0385     if (queue_delayed_work(workqueue, &endp->scheduler, delta))
0386         kref_get(&endp->kref);
0387 }
0388
0389 static void u132_endp_cancel_work(struct u132 *u132, struct u132_endp *endp)
0390 {
0391     if (cancel_delayed_work(&endp->scheduler))
0392         kref_put(&endp->kref, u132_endp_delete);
0393 }
0394
0395 static inline void u132_monitor_put_kref(struct u132 *u132)
0396 {
0397     kref_put(&u132->kref, u132_hcd_delete);
0398 }
0399
0400 static void u132_monitor_queue_work(struct u132 *u132, unsigned int delta)
0401 {
0402     if (queue_delayed_work(workqueue, &u132->monitor, delta))
0403         kref_get(&u132->kref);
0404 }
0405
0406 static void u132_monitor_requeue_work(struct u132 *u132, unsigned int delta)
0407 {
0408     if (!queue_delayed_work(workqueue, &u132->monitor, delta))
0409         kref_put(&u132->kref, u132_hcd_delete);
0410 }
0411
0412 static void u132_monitor_cancel_work(struct u132 *u132)
0413 {
0414     if (cancel_delayed_work(&u132->monitor))
0415         kref_put(&u132->kref, u132_hcd_delete);
0416 }
0417
0418 static int read_roothub_info(struct u132 *u132)
0419 {
0420     u32 revision;
0421     int retval;
0422     retval = u132_read_pcimem(u132, revision, &revision);
0423     if (retval) {
0424         dev_err(&u132->platform_dev->dev, "error %d accessing device co"
0425             "ntrol\n", retval);
0426         return retval;
0427     } else if ((revision & 0xFF) == 0x10) {
0428     } else if ((revision & 0xFF) == 0x11) {
0429     } else {
0430         dev_err(&u132->platform_dev->dev, "device revision is not valid"
0431             " %08X\n", revision);
0432         return -ENODEV;
0433     }
0434     retval = u132_read_pcimem(u132, control, &u132->hc_control);
0435     if (retval) {
0436         dev_err(&u132->platform_dev->dev, "error %d accessing device co"
0437             "ntrol\n", retval);
0438         return retval;
0439     }
0440     retval = u132_read_pcimem(u132, roothub.status,
0441         &u132->hc_roothub_status);
0442     if (retval) {
0443         dev_err(&u132->platform_dev->dev, "error %d accessing device re"
0444             "g roothub.status\n", retval);
0445         return retval;
0446     }
0447     retval = u132_read_pcimem(u132, roothub.a, &u132->hc_roothub_a);
0448     if (retval) {
0449         dev_err(&u132->platform_dev->dev, "error %d accessing device re"
0450             "g roothub.a\n", retval);
0451         return retval;
0452     }
0453     {
0454         int I = u132->num_ports;
0455         int i = 0;
0456         while (I-- > 0) {
0457             retval = u132_read_pcimem(u132, roothub.portstatus[i],
0458                 &u132->hc_roothub_portstatus[i]);
0459             if (retval) {
0460                 dev_err(&u132->platform_dev->dev, "error %d acc"
0461                     "essing device roothub.portstatus[%d]\n"
0462                     , retval, i);
0463                 return retval;
0464             } else
0465                 i += 1;
0466         }
0467     }
0468     return 0;
0469 }
0470
0471 static void u132_hcd_monitor_work(struct work_struct *work)
0472 {
0473     struct u132 *u132 = container_of(work, struct u132, monitor.work);
0474     if (u132->going > 1) {
0475         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
0476             , u132->going);
0477         u132_monitor_put_kref(u132);
0478         return;
0479     } else if (u132->going > 0) {
0480         dev_err(&u132->platform_dev->dev, "device is being removed\n");
0481         u132_monitor_put_kref(u132);
0482         return;
0483     } else {
0484         int retval;
0485         mutex_lock(&u132->sw_lock);
0486         retval = read_roothub_info(u132);
0487         if (retval) {
0488             struct usb_hcd *hcd = u132_to_hcd(u132);
0489             u132_disable(u132);
0490             u132->going = 1;
0491             mutex_unlock(&u132->sw_lock);
0492             usb_hc_died(hcd);
0493             ftdi_elan_gone_away(u132->platform_dev);
0494             u132_monitor_put_kref(u132);
0495             return;
0496         } else {
0497             u132_monitor_requeue_work(u132, 500);
0498             mutex_unlock(&u132->sw_lock);
0499             return;
0500         }
0501     }
0502 }
0503
0504 static void u132_hcd_giveback_urb(struct u132 *u132, struct u132_endp *endp,
0505     struct urb *urb, int status)
0506 {
0507     struct u132_ring *ring;
0508     unsigned long irqs;
0509     struct usb_hcd *hcd = u132_to_hcd(u132);
0510     urb->error_count = 0;
0511     spin_lock_irqsave(&endp->queue_lock.slock, irqs);
0512     usb_hcd_unlink_urb_from_ep(hcd, urb);
0513     endp->queue_next += 1;
0514     if (ENDP_QUEUE_SIZE > --endp->queue_size) {
0515         endp->active = 0;
0516         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
0517     } else {
0518         struct list_head *next = endp->urb_more.next;
0519         struct u132_urbq *urbq = list_entry(next, struct u132_urbq,
0520             urb_more);
0521         list_del(next);
0522         endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
0523             urbq->urb;
0524         endp->active = 0;
0525         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
0526         kfree(urbq);
0527     }
0528     mutex_lock(&u132->scheduler_lock);
0529     ring = endp->ring;
0530     ring->in_use = 0;
0531     u132_ring_cancel_work(u132, ring);
0532     u132_ring_queue_work(u132, ring, 0);
0533     mutex_unlock(&u132->scheduler_lock);
0534     u132_endp_put_kref(u132, endp);
0535     usb_hcd_giveback_urb(hcd, urb, status);
0536 }
0537
0538 static void u132_hcd_forget_urb(struct u132 *u132, struct u132_endp *endp,
0539     struct urb *urb, int status)
0540 {
0541     u132_endp_put_kref(u132, endp);
0542 }
0543
0544 static void u132_hcd_abandon_urb(struct u132 *u132, struct u132_endp *endp,
0545     struct urb *urb, int status)
0546 {
0547     unsigned long irqs;
0548     struct usb_hcd *hcd = u132_to_hcd(u132);
0549     urb->error_count = 0;
0550     spin_lock_irqsave(&endp->queue_lock.slock, irqs);
0551     usb_hcd_unlink_urb_from_ep(hcd, urb);
0552     endp->queue_next += 1;
0553     if (ENDP_QUEUE_SIZE > --endp->queue_size) {
0554         endp->active = 0;
0555         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
0556     } else {
0557         struct list_head *next = endp->urb_more.next;
0558         struct u132_urbq *urbq = list_entry(next, struct u132_urbq,
0559             urb_more);
0560         list_del(next);
0561         endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
0562             urbq->urb;
0563         endp->active = 0;
0564         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
0565         kfree(urbq);
0566     }
0567     usb_hcd_giveback_urb(hcd, urb, status);
0568 }
0569
0570 static inline int edset_input(struct u132 *u132, struct u132_ring *ring,
0571     struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
0572     void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
0573     int toggle_bits, int error_count, int condition_code, int repeat_number,
0574      int halted, int skipped, int actual, int non_null))
0575 {
0576     return usb_ftdi_elan_edset_input(u132->platform_dev, ring->number, endp,
0577          urb, address, endp->usb_endp, toggle_bits, callback);
0578 }
0579
0580 static inline int edset_setup(struct u132 *u132, struct u132_ring *ring,
0581     struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
0582     void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
0583     int toggle_bits, int error_count, int condition_code, int repeat_number,
0584      int halted, int skipped, int actual, int non_null))
0585 {
0586     return usb_ftdi_elan_edset_setup(u132->platform_dev, ring->number, endp,
0587          urb, address, endp->usb_endp, toggle_bits, callback);
0588 }
0589
0590 static inline int edset_single(struct u132 *u132, struct u132_ring *ring,
0591     struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
0592     void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
0593     int toggle_bits, int error_count, int condition_code, int repeat_number,
0594      int halted, int skipped, int actual, int non_null))
0595 {
0596     return usb_ftdi_elan_edset_single(u132->platform_dev, ring->number,
0597         endp, urb, address, endp->usb_endp, toggle_bits, callback);
0598 }
0599
0600 static inline int edset_output(struct u132 *u132, struct u132_ring *ring,
0601     struct u132_endp *endp, struct urb *urb, u8 address, u8 toggle_bits,
0602     void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
0603     int toggle_bits, int error_count, int condition_code, int repeat_number,
0604      int halted, int skipped, int actual, int non_null))
0605 {
0606     return usb_ftdi_elan_edset_output(u132->platform_dev, ring->number,
0607         endp, urb, address, endp->usb_endp, toggle_bits, callback);
0608 }
0609
0610
0611 /*
0612 * must not LOCK sw_lock
0613 *
0614 */
0615 static void u132_hcd_interrupt_recv(void *data, struct urb *urb, u8 *buf,
0616     int len, int toggle_bits, int error_count, int condition_code,
0617     int repeat_number, int halted, int skipped, int actual, int non_null)
0618 {
0619     struct u132_endp *endp = data;
0620     struct u132 *u132 = endp->u132;
0621     u8 address = u132->addr[endp->usb_addr].address;
0622     struct u132_udev *udev = &u132->udev[address];
0623     mutex_lock(&u132->scheduler_lock);
0624     if (u132->going > 1) {
0625         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
0626             , u132->going);
0627         mutex_unlock(&u132->scheduler_lock);
0628         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
0629         return;
0630     } else if (endp->dequeueing) {
0631         endp->dequeueing = 0;
0632         mutex_unlock(&u132->scheduler_lock);
0633         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
0634         return;
0635     } else if (u132->going > 0) {
0636         dev_err(&u132->platform_dev->dev, "device is being removed "
0637                 "urb=%p\n", urb);
0638         mutex_unlock(&u132->scheduler_lock);
0639         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
0640         return;
0641     } else if (!urb->unlinked) {
0642         struct u132_ring *ring = endp->ring;
0643         u8 *u = urb->transfer_buffer + urb->actual_length;
0644         u8 *b = buf;
0645         int L = len;
0646
0647         while (L-- > 0)
0648             *u++ = *b++;
0649
0650         urb->actual_length += len;
0651         if ((condition_code == TD_CC_NOERROR) &&
0652             (urb->transfer_buffer_length > urb->actual_length)) {
0653             endp->toggle_bits = toggle_bits;
0654             usb_settoggle(udev->usb_device, endp->usb_endp, 0,
0655                 1 & toggle_bits);
0656             if (urb->actual_length > 0) {
0657                 int retval;
0658                 mutex_unlock(&u132->scheduler_lock);
0659                 retval = edset_single(u132, ring, endp, urb,
0660                     address, endp->toggle_bits,
0661                     u132_hcd_interrupt_recv);
0662                 if (retval != 0)
0663                     u132_hcd_giveback_urb(u132, endp, urb,
0664                         retval);
0665             } else {
0666                 ring->in_use = 0;
0667                 endp->active = 0;
0668                 endp->jiffies = jiffies +
0669                     msecs_to_jiffies(urb->interval);
0670                 u132_ring_cancel_work(u132, ring);
0671                 u132_ring_queue_work(u132, ring, 0);
0672                 mutex_unlock(&u132->scheduler_lock);
0673                 u132_endp_put_kref(u132, endp);
0674             }
0675             return;
0676         } else if ((condition_code == TD_DATAUNDERRUN) &&
0677             ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0)) {
0678             endp->toggle_bits = toggle_bits;
0679             usb_settoggle(udev->usb_device, endp->usb_endp, 0,
0680                 1 & toggle_bits);
0681             mutex_unlock(&u132->scheduler_lock);
0682             u132_hcd_giveback_urb(u132, endp, urb, 0);
0683             return;
0684         } else {
0685             if (condition_code == TD_CC_NOERROR) {
0686                 endp->toggle_bits = toggle_bits;
0687                 usb_settoggle(udev->usb_device, endp->usb_endp,
0688                     0, 1 & toggle_bits);
0689             } else if (condition_code == TD_CC_STALL) {
0690                 endp->toggle_bits = 0x2;
0691                 usb_settoggle(udev->usb_device, endp->usb_endp,
0692                     0, 0);
0693             } else {
0694                 endp->toggle_bits = 0x2;
0695                 usb_settoggle(udev->usb_device, endp->usb_endp,
0696                     0, 0);
0697                 dev_err(&u132->platform_dev->dev, "urb=%p givin"
0698                     "g back INTERRUPT %s\n", urb,
0699                     cc_to_text[condition_code]);
0700             }
0701             mutex_unlock(&u132->scheduler_lock);
0702             u132_hcd_giveback_urb(u132, endp, urb,
0703                 cc_to_error[condition_code]);
0704             return;
0705         }
0706     } else {
0707         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
0708                 "unlinked=%d\n", urb, urb->unlinked);
0709         mutex_unlock(&u132->scheduler_lock);
0710         u132_hcd_giveback_urb(u132, endp, urb, 0);
0711         return;
0712     }
0713 }
0714
0715 static void u132_hcd_bulk_output_sent(void *data, struct urb *urb, u8 *buf,
0716     int len, int toggle_bits, int error_count, int condition_code,
0717     int repeat_number, int halted, int skipped, int actual, int non_null)
0718 {
0719     struct u132_endp *endp = data;
0720     struct u132 *u132 = endp->u132;
0721     u8 address = u132->addr[endp->usb_addr].address;
0722     mutex_lock(&u132->scheduler_lock);
0723     if (u132->going > 1) {
0724         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
0725             , u132->going);
0726         mutex_unlock(&u132->scheduler_lock);
0727         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
0728         return;
0729     } else if (endp->dequeueing) {
0730         endp->dequeueing = 0;
0731         mutex_unlock(&u132->scheduler_lock);
0732         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
0733         return;
0734     } else if (u132->going > 0) {
0735         dev_err(&u132->platform_dev->dev, "device is being removed "
0736                 "urb=%p\n", urb);
0737         mutex_unlock(&u132->scheduler_lock);
0738         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
0739         return;
0740     } else if (!urb->unlinked) {
0741         struct u132_ring *ring = endp->ring;
0742         urb->actual_length += len;
0743         endp->toggle_bits = toggle_bits;
0744         if (urb->transfer_buffer_length > urb->actual_length) {
0745             int retval;
0746             mutex_unlock(&u132->scheduler_lock);
0747             retval = edset_output(u132, ring, endp, urb, address,
0748                 endp->toggle_bits, u132_hcd_bulk_output_sent);
0749             if (retval != 0)
0750                 u132_hcd_giveback_urb(u132, endp, urb, retval);
0751             return;
0752         } else {
0753             mutex_unlock(&u132->scheduler_lock);
0754             u132_hcd_giveback_urb(u132, endp, urb, 0);
0755             return;
0756         }
0757     } else {
0758         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
0759                 "unlinked=%d\n", urb, urb->unlinked);
0760         mutex_unlock(&u132->scheduler_lock);
0761         u132_hcd_giveback_urb(u132, endp, urb, 0);
0762         return;
0763     }
0764 }
0765
0766 static void u132_hcd_bulk_input_recv(void *data, struct urb *urb, u8 *buf,
0767     int len, int toggle_bits, int error_count, int condition_code,
0768     int repeat_number, int halted, int skipped, int actual, int non_null)
0769 {
0770     struct u132_endp *endp = data;
0771     struct u132 *u132 = endp->u132;
0772     u8 address = u132->addr[endp->usb_addr].address;
0773     struct u132_udev *udev = &u132->udev[address];
0774     mutex_lock(&u132->scheduler_lock);
0775     if (u132->going > 1) {
0776         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
0777             , u132->going);
0778         mutex_unlock(&u132->scheduler_lock);
0779         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
0780         return;
0781     } else if (endp->dequeueing) {
0782         endp->dequeueing = 0;
0783         mutex_unlock(&u132->scheduler_lock);
0784         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
0785         return;
0786     } else if (u132->going > 0) {
0787         dev_err(&u132->platform_dev->dev, "device is being removed "
0788                 "urb=%p\n", urb);
0789         mutex_unlock(&u132->scheduler_lock);
0790         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
0791         return;
0792     } else if (!urb->unlinked) {
0793         struct u132_ring *ring = endp->ring;
0794         u8 *u = urb->transfer_buffer + urb->actual_length;
0795         u8 *b = buf;
0796         int L = len;
0797
0798         while (L-- > 0)
0799             *u++ = *b++;
0800
0801         urb->actual_length += len;
0802         if ((condition_code == TD_CC_NOERROR) &&
0803             (urb->transfer_buffer_length > urb->actual_length)) {
0804             int retval;
0805             endp->toggle_bits = toggle_bits;
0806             usb_settoggle(udev->usb_device, endp->usb_endp, 0,
0807                 1 & toggle_bits);
0808             mutex_unlock(&u132->scheduler_lock);
0809             retval = usb_ftdi_elan_edset_input(u132->platform_dev,
0810                 ring->number, endp, urb, address,
0811                 endp->usb_endp, endp->toggle_bits,
0812                 u132_hcd_bulk_input_recv);
0813             if (retval != 0)
0814                 u132_hcd_giveback_urb(u132, endp, urb, retval);
0815             return;
0816         } else if (condition_code == TD_CC_NOERROR) {
0817             endp->toggle_bits = toggle_bits;
0818             usb_settoggle(udev->usb_device, endp->usb_endp, 0,
0819                 1 & toggle_bits);
0820             mutex_unlock(&u132->scheduler_lock);
0821             u132_hcd_giveback_urb(u132, endp, urb,
0822                 cc_to_error[condition_code]);
0823             return;
0824         } else if ((condition_code == TD_DATAUNDERRUN) &&
0825             ((urb->transfer_flags & URB_SHORT_NOT_OK) == 0)) {
0826             endp->toggle_bits = toggle_bits;
0827             usb_settoggle(udev->usb_device, endp->usb_endp, 0,
0828                 1 & toggle_bits);
0829             mutex_unlock(&u132->scheduler_lock);
0830             u132_hcd_giveback_urb(u132, endp, urb, 0);
0831             return;
0832         } else if (condition_code == TD_DATAUNDERRUN) {
0833             endp->toggle_bits = toggle_bits;
0834             usb_settoggle(udev->usb_device, endp->usb_endp, 0,
0835                 1 & toggle_bits);
0836             dev_warn(&u132->platform_dev->dev, "urb=%p(SHORT NOT OK"
0837                 ") giving back BULK IN %s\n", urb,
0838                 cc_to_text[condition_code]);
0839             mutex_unlock(&u132->scheduler_lock);
0840             u132_hcd_giveback_urb(u132, endp, urb, 0);
0841             return;
0842         } else if (condition_code == TD_CC_STALL) {
0843             endp->toggle_bits = 0x2;
0844             usb_settoggle(udev->usb_device, endp->usb_endp, 0, 0);
0845             mutex_unlock(&u132->scheduler_lock);
0846             u132_hcd_giveback_urb(u132, endp, urb,
0847                 cc_to_error[condition_code]);
0848             return;
0849         } else {
0850             endp->toggle_bits = 0x2;
0851             usb_settoggle(udev->usb_device, endp->usb_endp, 0, 0);
0852             dev_err(&u132->platform_dev->dev, "urb=%p giving back B"
0853                 "ULK IN code=%d %s\n", urb, condition_code,
0854                 cc_to_text[condition_code]);
0855             mutex_unlock(&u132->scheduler_lock);
0856             u132_hcd_giveback_urb(u132, endp, urb,
0857                 cc_to_error[condition_code]);
0858             return;
0859         }
0860     } else {
0861         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
0862                 "unlinked=%d\n", urb, urb->unlinked);
0863         mutex_unlock(&u132->scheduler_lock);
0864         u132_hcd_giveback_urb(u132, endp, urb, 0);
0865         return;
0866     }
0867 }
0868
0869 static void u132_hcd_configure_empty_sent(void *data, struct urb *urb, u8 *buf,
0870     int len, int toggle_bits, int error_count, int condition_code,
0871     int repeat_number, int halted, int skipped, int actual, int non_null)
0872 {
0873     struct u132_endp *endp = data;
0874     struct u132 *u132 = endp->u132;
0875     mutex_lock(&u132->scheduler_lock);
0876     if (u132->going > 1) {
0877         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
0878             , u132->going);
0879         mutex_unlock(&u132->scheduler_lock);
0880         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
0881         return;
0882     } else if (endp->dequeueing) {
0883         endp->dequeueing = 0;
0884         mutex_unlock(&u132->scheduler_lock);
0885         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
0886         return;
0887     } else if (u132->going > 0) {
0888         dev_err(&u132->platform_dev->dev, "device is being removed "
0889                 "urb=%p\n", urb);
0890         mutex_unlock(&u132->scheduler_lock);
0891         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
0892         return;
0893     } else if (!urb->unlinked) {
0894         mutex_unlock(&u132->scheduler_lock);
0895         u132_hcd_giveback_urb(u132, endp, urb, 0);
0896         return;
0897     } else {
0898         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
0899                 "unlinked=%d\n", urb, urb->unlinked);
0900         mutex_unlock(&u132->scheduler_lock);
0901         u132_hcd_giveback_urb(u132, endp, urb, 0);
0902         return;
0903     }
0904 }
0905
0906 static void u132_hcd_configure_input_recv(void *data, struct urb *urb, u8 *buf,
0907     int len, int toggle_bits, int error_count, int condition_code,
0908     int repeat_number, int halted, int skipped, int actual, int non_null)
0909 {
0910     struct u132_endp *endp = data;
0911     struct u132 *u132 = endp->u132;
0912     u8 address = u132->addr[endp->usb_addr].address;
0913     mutex_lock(&u132->scheduler_lock);
0914     if (u132->going > 1) {
0915         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
0916             , u132->going);
0917         mutex_unlock(&u132->scheduler_lock);
0918         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
0919         return;
0920     } else if (endp->dequeueing) {
0921         endp->dequeueing = 0;
0922         mutex_unlock(&u132->scheduler_lock);
0923         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
0924         return;
0925     } else if (u132->going > 0) {
0926         dev_err(&u132->platform_dev->dev, "device is being removed "
0927                 "urb=%p\n", urb);
0928         mutex_unlock(&u132->scheduler_lock);
0929         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
0930         return;
0931     } else if (!urb->unlinked) {
0932         struct u132_ring *ring = endp->ring;
0933         u8 *u = urb->transfer_buffer;
0934         u8 *b = buf;
0935         int L = len;
0936
0937         while (L-- > 0)
0938             *u++ = *b++;
0939
0940         urb->actual_length = len;
0941         if ((condition_code == TD_CC_NOERROR) || ((condition_code ==
0942             TD_DATAUNDERRUN) && ((urb->transfer_flags &
0943             URB_SHORT_NOT_OK) == 0))) {
0944             int retval;
0945             mutex_unlock(&u132->scheduler_lock);
0946             retval = usb_ftdi_elan_edset_empty(u132->platform_dev,
0947                 ring->number, endp, urb, address,
0948                 endp->usb_endp, 0x3,
0949                 u132_hcd_configure_empty_sent);
0950             if (retval != 0)
0951                 u132_hcd_giveback_urb(u132, endp, urb, retval);
0952             return;
0953         } else if (condition_code == TD_CC_STALL) {
0954             mutex_unlock(&u132->scheduler_lock);
0955             dev_warn(&u132->platform_dev->dev, "giving back SETUP I"
0956                 "NPUT STALL urb %p\n", urb);
0957             u132_hcd_giveback_urb(u132, endp, urb,
0958                 cc_to_error[condition_code]);
0959             return;
0960         } else {
0961             mutex_unlock(&u132->scheduler_lock);
0962             dev_err(&u132->platform_dev->dev, "giving back SETUP IN"
0963                 "PUT %s urb %p\n", cc_to_text[condition_code],
0964                 urb);
0965             u132_hcd_giveback_urb(u132, endp, urb,
0966                 cc_to_error[condition_code]);
0967             return;
0968         }
0969     } else {
0970         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
0971                 "unlinked=%d\n", urb, urb->unlinked);
0972         mutex_unlock(&u132->scheduler_lock);
0973         u132_hcd_giveback_urb(u132, endp, urb, 0);
0974         return;
0975     }
0976 }
0977
0978 static void u132_hcd_configure_empty_recv(void *data, struct urb *urb, u8 *buf,
0979     int len, int toggle_bits, int error_count, int condition_code,
0980     int repeat_number, int halted, int skipped, int actual, int non_null)
0981 {
0982     struct u132_endp *endp = data;
0983     struct u132 *u132 = endp->u132;
0984     mutex_lock(&u132->scheduler_lock);
0985     if (u132->going > 1) {
0986         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
0987             , u132->going);
0988         mutex_unlock(&u132->scheduler_lock);
0989         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
0990         return;
0991     } else if (endp->dequeueing) {
0992         endp->dequeueing = 0;
0993         mutex_unlock(&u132->scheduler_lock);
0994         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
0995         return;
0996     } else if (u132->going > 0) {
0997         dev_err(&u132->platform_dev->dev, "device is being removed "
0998                 "urb=%p\n", urb);
0999         mutex_unlock(&u132->scheduler_lock);
1000         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1001         return;
1002     } else if (!urb->unlinked) {
1003         mutex_unlock(&u132->scheduler_lock);
1004         u132_hcd_giveback_urb(u132, endp, urb, 0);
1005         return;
1006     } else {
1007         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1008                 "unlinked=%d\n", urb, urb->unlinked);
1009         mutex_unlock(&u132->scheduler_lock);
1010         u132_hcd_giveback_urb(u132, endp, urb, 0);
1011         return;
1012     }
1013 }
1014
1015 static void u132_hcd_configure_setup_sent(void *data, struct urb *urb, u8 *buf,
1016     int len, int toggle_bits, int error_count, int condition_code,
1017     int repeat_number, int halted, int skipped, int actual, int non_null)
1018 {
1019     struct u132_endp *endp = data;
1020     struct u132 *u132 = endp->u132;
1021     u8 address = u132->addr[endp->usb_addr].address;
1022     mutex_lock(&u132->scheduler_lock);
1023     if (u132->going > 1) {
1024         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1025             , u132->going);
1026         mutex_unlock(&u132->scheduler_lock);
1027         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1028         return;
1029     } else if (endp->dequeueing) {
1030         endp->dequeueing = 0;
1031         mutex_unlock(&u132->scheduler_lock);
1032         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1033         return;
1034     } else if (u132->going > 0) {
1035         dev_err(&u132->platform_dev->dev, "device is being removed "
1036                 "urb=%p\n", urb);
1037         mutex_unlock(&u132->scheduler_lock);
1038         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1039         return;
1040     } else if (!urb->unlinked) {
1041         if (usb_pipein(urb->pipe)) {
1042             int retval;
1043             struct u132_ring *ring = endp->ring;
1044             mutex_unlock(&u132->scheduler_lock);
1045             retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1046                 ring->number, endp, urb, address,
1047                 endp->usb_endp, 0,
1048                 u132_hcd_configure_input_recv);
1049             if (retval != 0)
1050                 u132_hcd_giveback_urb(u132, endp, urb, retval);
1051             return;
1052         } else {
1053             int retval;
1054             struct u132_ring *ring = endp->ring;
1055             mutex_unlock(&u132->scheduler_lock);
1056             retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1057                 ring->number, endp, urb, address,
1058                 endp->usb_endp, 0,
1059                 u132_hcd_configure_empty_recv);
1060             if (retval != 0)
1061                 u132_hcd_giveback_urb(u132, endp, urb, retval);
1062             return;
1063         }
1064     } else {
1065         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1066                 "unlinked=%d\n", urb, urb->unlinked);
1067         mutex_unlock(&u132->scheduler_lock);
1068         u132_hcd_giveback_urb(u132, endp, urb, 0);
1069         return;
1070     }
1071 }
1072
1073 static void u132_hcd_enumeration_empty_recv(void *data, struct urb *urb,
1074     u8 *buf, int len, int toggle_bits, int error_count, int condition_code,
1075     int repeat_number, int halted, int skipped, int actual, int non_null)
1076 {
1077     struct u132_endp *endp = data;
1078     struct u132 *u132 = endp->u132;
1079     u8 address = u132->addr[endp->usb_addr].address;
1080     struct u132_udev *udev = &u132->udev[address];
1081     mutex_lock(&u132->scheduler_lock);
1082     if (u132->going > 1) {
1083         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1084             , u132->going);
1085         mutex_unlock(&u132->scheduler_lock);
1086         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1087         return;
1088     } else if (endp->dequeueing) {
1089         endp->dequeueing = 0;
1090         mutex_unlock(&u132->scheduler_lock);
1091         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1092         return;
1093     } else if (u132->going > 0) {
1094         dev_err(&u132->platform_dev->dev, "device is being removed "
1095                 "urb=%p\n", urb);
1096         mutex_unlock(&u132->scheduler_lock);
1097         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1098         return;
1099     } else if (!urb->unlinked) {
1100         u132->addr[0].address = 0;
1101         endp->usb_addr = udev->usb_addr;
1102         mutex_unlock(&u132->scheduler_lock);
1103         u132_hcd_giveback_urb(u132, endp, urb, 0);
1104         return;
1105     } else {
1106         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1107                 "unlinked=%d\n", urb, urb->unlinked);
1108         mutex_unlock(&u132->scheduler_lock);
1109         u132_hcd_giveback_urb(u132, endp, urb, 0);
1110         return;
1111     }
1112 }
1113
1114 static void u132_hcd_enumeration_address_sent(void *data, struct urb *urb,
1115     u8 *buf, int len, int toggle_bits, int error_count, int condition_code,
1116     int repeat_number, int halted, int skipped, int actual, int non_null)
1117 {
1118     struct u132_endp *endp = data;
1119     struct u132 *u132 = endp->u132;
1120     mutex_lock(&u132->scheduler_lock);
1121     if (u132->going > 1) {
1122         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1123             , u132->going);
1124         mutex_unlock(&u132->scheduler_lock);
1125         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1126         return;
1127     } else if (endp->dequeueing) {
1128         endp->dequeueing = 0;
1129         mutex_unlock(&u132->scheduler_lock);
1130         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1131         return;
1132     } else if (u132->going > 0) {
1133         dev_err(&u132->platform_dev->dev, "device is being removed "
1134                 "urb=%p\n", urb);
1135         mutex_unlock(&u132->scheduler_lock);
1136         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1137         return;
1138     } else if (!urb->unlinked) {
1139         int retval;
1140         struct u132_ring *ring = endp->ring;
1141         mutex_unlock(&u132->scheduler_lock);
1142         retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1143             ring->number, endp, urb, 0, endp->usb_endp, 0,
1144             u132_hcd_enumeration_empty_recv);
1145         if (retval != 0)
1146             u132_hcd_giveback_urb(u132, endp, urb, retval);
1147         return;
1148     } else {
1149         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1150                 "unlinked=%d\n", urb, urb->unlinked);
1151         mutex_unlock(&u132->scheduler_lock);
1152         u132_hcd_giveback_urb(u132, endp, urb, 0);
1153         return;
1154     }
1155 }
1156
1157 static void u132_hcd_initial_empty_sent(void *data, struct urb *urb, u8 *buf,
1158     int len, int toggle_bits, int error_count, int condition_code,
1159     int repeat_number, int halted, int skipped, int actual, int non_null)
1160 {
1161     struct u132_endp *endp = data;
1162     struct u132 *u132 = endp->u132;
1163     mutex_lock(&u132->scheduler_lock);
1164     if (u132->going > 1) {
1165         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1166             , u132->going);
1167         mutex_unlock(&u132->scheduler_lock);
1168         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1169         return;
1170     } else if (endp->dequeueing) {
1171         endp->dequeueing = 0;
1172         mutex_unlock(&u132->scheduler_lock);
1173         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1174         return;
1175     } else if (u132->going > 0) {
1176         dev_err(&u132->platform_dev->dev, "device is being removed "
1177                 "urb=%p\n", urb);
1178         mutex_unlock(&u132->scheduler_lock);
1179         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1180         return;
1181     } else if (!urb->unlinked) {
1182         mutex_unlock(&u132->scheduler_lock);
1183         u132_hcd_giveback_urb(u132, endp, urb, 0);
1184         return;
1185     } else {
1186         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1187                 "unlinked=%d\n", urb, urb->unlinked);
1188         mutex_unlock(&u132->scheduler_lock);
1189         u132_hcd_giveback_urb(u132, endp, urb, 0);
1190         return;
1191     }
1192 }
1193
1194 static void u132_hcd_initial_input_recv(void *data, struct urb *urb, u8 *buf,
1195     int len, int toggle_bits, int error_count, int condition_code,
1196     int repeat_number, int halted, int skipped, int actual, int non_null)
1197 {
1198     struct u132_endp *endp = data;
1199     struct u132 *u132 = endp->u132;
1200     u8 address = u132->addr[endp->usb_addr].address;
1201     mutex_lock(&u132->scheduler_lock);
1202     if (u132->going > 1) {
1203         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1204             , u132->going);
1205         mutex_unlock(&u132->scheduler_lock);
1206         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1207         return;
1208     } else if (endp->dequeueing) {
1209         endp->dequeueing = 0;
1210         mutex_unlock(&u132->scheduler_lock);
1211         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1212         return;
1213     } else if (u132->going > 0) {
1214         dev_err(&u132->platform_dev->dev, "device is being removed "
1215                 "urb=%p\n", urb);
1216         mutex_unlock(&u132->scheduler_lock);
1217         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1218         return;
1219     } else if (!urb->unlinked) {
1220         int retval;
1221         struct u132_ring *ring = endp->ring;
1222         u8 *u = urb->transfer_buffer;
1223         u8 *b = buf;
1224         int L = len;
1225
1226         while (L-- > 0)
1227             *u++ = *b++;
1228
1229         urb->actual_length = len;
1230         mutex_unlock(&u132->scheduler_lock);
1231         retval = usb_ftdi_elan_edset_empty(u132->platform_dev,
1232             ring->number, endp, urb, address, endp->usb_endp, 0x3,
1233             u132_hcd_initial_empty_sent);
1234         if (retval != 0)
1235             u132_hcd_giveback_urb(u132, endp, urb, retval);
1236         return;
1237     } else {
1238         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1239                 "unlinked=%d\n", urb, urb->unlinked);
1240         mutex_unlock(&u132->scheduler_lock);
1241         u132_hcd_giveback_urb(u132, endp, urb, 0);
1242         return;
1243     }
1244 }
1245
1246 static void u132_hcd_initial_setup_sent(void *data, struct urb *urb, u8 *buf,
1247     int len, int toggle_bits, int error_count, int condition_code,
1248     int repeat_number, int halted, int skipped, int actual, int non_null)
1249 {
1250     struct u132_endp *endp = data;
1251     struct u132 *u132 = endp->u132;
1252     u8 address = u132->addr[endp->usb_addr].address;
1253     mutex_lock(&u132->scheduler_lock);
1254     if (u132->going > 1) {
1255         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1256             , u132->going);
1257         mutex_unlock(&u132->scheduler_lock);
1258         u132_hcd_forget_urb(u132, endp, urb, -ENODEV);
1259         return;
1260     } else if (endp->dequeueing) {
1261         endp->dequeueing = 0;
1262         mutex_unlock(&u132->scheduler_lock);
1263         u132_hcd_giveback_urb(u132, endp, urb, -EINTR);
1264         return;
1265     } else if (u132->going > 0) {
1266         dev_err(&u132->platform_dev->dev, "device is being removed "
1267                 "urb=%p\n", urb);
1268         mutex_unlock(&u132->scheduler_lock);
1269         u132_hcd_giveback_urb(u132, endp, urb, -ENODEV);
1270         return;
1271     } else if (!urb->unlinked) {
1272         int retval;
1273         struct u132_ring *ring = endp->ring;
1274         mutex_unlock(&u132->scheduler_lock);
1275         retval = usb_ftdi_elan_edset_input(u132->platform_dev,
1276             ring->number, endp, urb, address, endp->usb_endp, 0,
1277             u132_hcd_initial_input_recv);
1278         if (retval != 0)
1279             u132_hcd_giveback_urb(u132, endp, urb, retval);
1280         return;
1281     } else {
1282         dev_err(&u132->platform_dev->dev, "CALLBACK called urb=%p "
1283                 "unlinked=%d\n", urb, urb->unlinked);
1284         mutex_unlock(&u132->scheduler_lock);
1285         u132_hcd_giveback_urb(u132, endp, urb, 0);
1286         return;
1287     }
1288 }
1289
1290 /*
1291 * this work function is only executed from the work queue
1292 *
1293 */
1294 static void u132_hcd_ring_work_scheduler(struct work_struct *work)
1295 {
1296     struct u132_ring *ring =
1297         container_of(work, struct u132_ring, scheduler.work);
1298     struct u132 *u132 = ring->u132;
1299     mutex_lock(&u132->scheduler_lock);
1300     if (ring->in_use) {
1301         mutex_unlock(&u132->scheduler_lock);
1302         u132_ring_put_kref(u132, ring);
1303         return;
1304     } else if (ring->curr_endp) {
1305         struct u132_endp *endp, *last_endp = ring->curr_endp;
1306         unsigned long wakeup = 0;
1307         list_for_each_entry(endp, &last_endp->endp_ring, endp_ring) {
1308             if (endp->queue_next == endp->queue_last) {
1309             } else if ((endp->delayed == 0)
1310                 || time_after_eq(jiffies, endp->jiffies)) {
1311                 ring->curr_endp = endp;
1312                 u132_endp_cancel_work(u132, last_endp);
1313                 u132_endp_queue_work(u132, last_endp, 0);
1314                 mutex_unlock(&u132->scheduler_lock);
1315                 u132_ring_put_kref(u132, ring);
1316                 return;
1317             } else {
1318                 unsigned long delta = endp->jiffies - jiffies;
1319                 if (delta > wakeup)
1320                     wakeup = delta;
1321             }
1322         }
1323         if (last_endp->queue_next == last_endp->queue_last) {
1324         } else if ((last_endp->delayed == 0) || time_after_eq(jiffies,
1325             last_endp->jiffies)) {
1326             u132_endp_cancel_work(u132, last_endp);
1327             u132_endp_queue_work(u132, last_endp, 0);
1328             mutex_unlock(&u132->scheduler_lock);
1329             u132_ring_put_kref(u132, ring);
1330             return;
1331         } else {
1332             unsigned long delta = last_endp->jiffies - jiffies;
1333             if (delta > wakeup)
1334                 wakeup = delta;
1335         }
1336         if (wakeup > 0) {
1337             u132_ring_requeue_work(u132, ring, wakeup);
1338             mutex_unlock(&u132->scheduler_lock);
1339             return;
1340         } else {
1341             mutex_unlock(&u132->scheduler_lock);
1342             u132_ring_put_kref(u132, ring);
1343             return;
1344         }
1345     } else {
1346         mutex_unlock(&u132->scheduler_lock);
1347         u132_ring_put_kref(u132, ring);
1348         return;
1349     }
1350 }
1351
1352 static void u132_hcd_endp_work_scheduler(struct work_struct *work)
1353 {
1354     struct u132_ring *ring;
1355     struct u132_endp *endp =
1356         container_of(work, struct u132_endp, scheduler.work);
1357     struct u132 *u132 = endp->u132;
1358     mutex_lock(&u132->scheduler_lock);
1359     ring = endp->ring;
1360     if (endp->edset_flush) {
1361         endp->edset_flush = 0;
1362         if (endp->dequeueing)
1363             usb_ftdi_elan_edset_flush(u132->platform_dev,
1364                 ring->number, endp);
1365         mutex_unlock(&u132->scheduler_lock);
1366         u132_endp_put_kref(u132, endp);
1367         return;
1368     } else if (endp->active) {
1369         mutex_unlock(&u132->scheduler_lock);
1370         u132_endp_put_kref(u132, endp);
1371         return;
1372     } else if (ring->in_use) {
1373         mutex_unlock(&u132->scheduler_lock);
1374         u132_endp_put_kref(u132, endp);
1375         return;
1376     } else if (endp->queue_next == endp->queue_last) {
1377         mutex_unlock(&u132->scheduler_lock);
1378         u132_endp_put_kref(u132, endp);
1379         return;
1380     } else if (endp->pipetype == PIPE_INTERRUPT) {
1381         u8 address = u132->addr[endp->usb_addr].address;
1382         if (ring->in_use) {
1383             mutex_unlock(&u132->scheduler_lock);
1384             u132_endp_put_kref(u132, endp);
1385             return;
1386         } else {
1387             int retval;
1388             struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1389                 endp->queue_next];
1390             endp->active = 1;
1391             ring->curr_endp = endp;
1392             ring->in_use = 1;
1393             mutex_unlock(&u132->scheduler_lock);
1394             retval = edset_single(u132, ring, endp, urb, address,
1395                 endp->toggle_bits, u132_hcd_interrupt_recv);
1396             if (retval != 0)
1397                 u132_hcd_giveback_urb(u132, endp, urb, retval);
1398             return;
1399         }
1400     } else if (endp->pipetype == PIPE_CONTROL) {
1401         u8 address = u132->addr[endp->usb_addr].address;
1402         if (ring->in_use) {
1403             mutex_unlock(&u132->scheduler_lock);
1404             u132_endp_put_kref(u132, endp);
1405             return;
1406         } else if (address == 0) {
1407             int retval;
1408             struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1409                 endp->queue_next];
1410             endp->active = 1;
1411             ring->curr_endp = endp;
1412             ring->in_use = 1;
1413             mutex_unlock(&u132->scheduler_lock);
1414             retval = edset_setup(u132, ring, endp, urb, address,
1415                 0x2, u132_hcd_initial_setup_sent);
1416             if (retval != 0)
1417                 u132_hcd_giveback_urb(u132, endp, urb, retval);
1418             return;
1419         } else if (endp->usb_addr == 0) {
1420             int retval;
1421             struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1422                 endp->queue_next];
1423             endp->active = 1;
1424             ring->curr_endp = endp;
1425             ring->in_use = 1;
1426             mutex_unlock(&u132->scheduler_lock);
1427             retval = edset_setup(u132, ring, endp, urb, 0, 0x2,
1428                 u132_hcd_enumeration_address_sent);
1429             if (retval != 0)
1430                 u132_hcd_giveback_urb(u132, endp, urb, retval);
1431             return;
1432         } else {
1433             int retval;
1434             struct urb *urb = endp->urb_list[ENDP_QUEUE_MASK &
1435                 endp->queue_next];
1436             address = u132->addr[endp->usb_addr].address;
1437             endp->active = 1;
1438             ring->curr_endp = endp;
1439             ring->in_use = 1;
1440             mutex_unlock(&u132->scheduler_lock);
1441             retval = edset_setup(u132, ring, endp, urb, address,
1442                 0x2, u132_hcd_configure_setup_sent);
1443             if (retval != 0)
1444                 u132_hcd_giveback_urb(u132, endp, urb, retval);
1445             return;
1446         }
1447     } else {
1448         if (endp->input) {
1449             u8 address = u132->addr[endp->usb_addr].address;
1450             if (ring->in_use) {
1451                 mutex_unlock(&u132->scheduler_lock);
1452                 u132_endp_put_kref(u132, endp);
1453                 return;
1454             } else {
1455                 int retval;
1456                 struct urb *urb = endp->urb_list[
1457                     ENDP_QUEUE_MASK & endp->queue_next];
1458                 endp->active = 1;
1459                 ring->curr_endp = endp;
1460                 ring->in_use = 1;
1461                 mutex_unlock(&u132->scheduler_lock);
1462                 retval = edset_input(u132, ring, endp, urb,
1463                     address, endp->toggle_bits,
1464                     u132_hcd_bulk_input_recv);
1465                 if (retval == 0) {
1466                 } else
1467                     u132_hcd_giveback_urb(u132, endp, urb,
1468                         retval);
1469                 return;
1470             }
1471         } else {    /* output pipe */
1472             u8 address = u132->addr[endp->usb_addr].address;
1473             if (ring->in_use) {
1474                 mutex_unlock(&u132->scheduler_lock);
1475                 u132_endp_put_kref(u132, endp);
1476                 return;
1477             } else {
1478                 int retval;
1479                 struct urb *urb = endp->urb_list[
1480                     ENDP_QUEUE_MASK & endp->queue_next];
1481                 endp->active = 1;
1482                 ring->curr_endp = endp;
1483                 ring->in_use = 1;
1484                 mutex_unlock(&u132->scheduler_lock);
1485                 retval = edset_output(u132, ring, endp, urb,
1486                     address, endp->toggle_bits,
1487                     u132_hcd_bulk_output_sent);
1488                 if (retval == 0) {
1489                 } else
1490                     u132_hcd_giveback_urb(u132, endp, urb,
1491                         retval);
1492                 return;
1493             }
1494         }
1495     }
1496 }
1497 #ifdef CONFIG_PM
1498
1499 static void port_power(struct u132 *u132, int pn, int is_on)
1500 {
1501     u132->port[pn].power = is_on;
1502 }
1503
1504 #endif
1505
1506 static void u132_power(struct u132 *u132, int is_on)
1507 {
1508     struct usb_hcd *hcd = u132_to_hcd(u132)
1509         ;   /* hub is inactive unless the port is powered */
1510     if (is_on) {
1511         if (u132->power)
1512             return;
1513         u132->power = 1;
1514     } else {
1515         u132->power = 0;
1516         hcd->state = HC_STATE_HALT;
1517     }
1518 }
1519
1520 static int u132_periodic_reinit(struct u132 *u132)
1521 {
1522     int retval;
1523     u32 fi = u132->hc_fminterval & 0x03fff;
1524     u32 fit;
1525     u32 fminterval;
1526     retval = u132_read_pcimem(u132, fminterval, &fminterval);
1527     if (retval)
1528         return retval;
1529     fit = fminterval & FIT;
1530     retval = u132_write_pcimem(u132, fminterval,
1531         (fit ^ FIT) | u132->hc_fminterval);
1532     if (retval)
1533         return retval;
1534     return u132_write_pcimem(u132, periodicstart,
1535            ((9 * fi) / 10) & 0x3fff);
1536 }
1537
1538 static char *hcfs2string(int state)
1539 {
1540     switch (state) {
1541     case OHCI_USB_RESET:
1542         return "reset";
1543     case OHCI_USB_RESUME:
1544         return "resume";
1545     case OHCI_USB_OPER:
1546         return "operational";
1547     case OHCI_USB_SUSPEND:
1548         return "suspend";
1549     }
1550     return "?";
1551 }
1552
1553 static int u132_init(struct u132 *u132)
1554 {
1555     int retval;
1556     u32 control;
1557     u132_disable(u132);
1558     u132->next_statechange = jiffies;
1559     retval = u132_write_pcimem(u132, intrdisable, OHCI_INTR_MIE);
1560     if (retval)
1561         return retval;
1562     retval = u132_read_pcimem(u132, control, &control);
1563     if (retval)
1564         return retval;
1565     if (u132->num_ports == 0) {
1566         u32 rh_a = -1;
1567         retval = u132_read_pcimem(u132, roothub.a, &rh_a);
1568         if (retval)
1569             return retval;
1570         u132->num_ports = rh_a & RH_A_NDP;
1571         retval = read_roothub_info(u132);
1572         if (retval)
1573             return retval;
1574     }
1575     if (u132->num_ports > MAX_U132_PORTS)
1576         return -EINVAL;
1577
1578     return 0;
1579 }
1580
1581
1582 /* Start an OHCI controller, set the BUS operational
1583 * resets USB and controller
1584 * enable interrupts
1585 */
1586 static int u132_run(struct u132 *u132)
1587 {
1588     int retval;
1589     u32 control;
1590     u32 status;
1591     u32 fminterval;
1592     u32 periodicstart;
1593     u32 cmdstatus;
1594     u32 roothub_a;
1595     int mask = OHCI_INTR_INIT;
1596     int first = u132->hc_fminterval == 0;
1597     int sleep_time = 0;
1598     int reset_timeout = 30; /* ... allow extra time */
1599     u132_disable(u132);
1600     if (first) {
1601         u32 temp;
1602         retval = u132_read_pcimem(u132, fminterval, &temp);
1603         if (retval)
1604             return retval;
1605         u132->hc_fminterval = temp & 0x3fff;
1606         u132->hc_fminterval |= FSMP(u132->hc_fminterval) << 16;
1607     }
1608     retval = u132_read_pcimem(u132, control, &u132->hc_control);
1609     if (retval)
1610         return retval;
1611     dev_info(&u132->platform_dev->dev, "resetting from state '%s', control "
1612         "= %08X\n", hcfs2string(u132->hc_control & OHCI_CTRL_HCFS),
1613         u132->hc_control);
1614     switch (u132->hc_control & OHCI_CTRL_HCFS) {
1615     case OHCI_USB_OPER:
1616         sleep_time = 0;
1617         break;
1618     case OHCI_USB_SUSPEND:
1619     case OHCI_USB_RESUME:
1620         u132->hc_control &= OHCI_CTRL_RWC;
1621         u132->hc_control |= OHCI_USB_RESUME;
1622         sleep_time = 10;
1623         break;
1624     default:
1625         u132->hc_control &= OHCI_CTRL_RWC;
1626         u132->hc_control |= OHCI_USB_RESET;
1627         sleep_time = 50;
1628         break;
1629     }
1630     retval = u132_write_pcimem(u132, control, u132->hc_control);
1631     if (retval)
1632         return retval;
1633     retval = u132_read_pcimem(u132, control, &control);
1634     if (retval)
1635         return retval;
1636     msleep(sleep_time);
1637     retval = u132_read_pcimem(u132, roothub.a, &roothub_a);
1638     if (retval)
1639         return retval;
1640     if (!(roothub_a & RH_A_NPS)) {
1641         int temp;   /* power down each port */
1642         for (temp = 0; temp < u132->num_ports; temp++) {
1643             retval = u132_write_pcimem(u132,
1644                 roothub.portstatus[temp], RH_PS_LSDA);
1645             if (retval)
1646                 return retval;
1647         }
1648     }
1649     retval = u132_read_pcimem(u132, control, &control);
1650     if (retval)
1651         return retval;
1652 retry:
1653     retval = u132_read_pcimem(u132, cmdstatus, &status);
1654     if (retval)
1655         return retval;
1656     retval = u132_write_pcimem(u132, cmdstatus, OHCI_HCR);
1657     if (retval)
1658         return retval;
1659 extra:  {
1660         retval = u132_read_pcimem(u132, cmdstatus, &status);
1661         if (retval)
1662             return retval;
1663         if (0 != (status & OHCI_HCR)) {
1664             if (--reset_timeout == 0) {
1665                 dev_err(&u132->platform_dev->dev, "USB HC reset"
1666                     " timed out!\n");
1667                 return -ENODEV;
1668             } else {
1669                 msleep(5);
1670                 goto extra;
1671             }
1672         }
1673     }
1674     if (u132->flags & OHCI_QUIRK_INITRESET) {
1675         retval = u132_write_pcimem(u132, control, u132->hc_control);
1676         if (retval)
1677             return retval;
1678         retval = u132_read_pcimem(u132, control, &control);
1679         if (retval)
1680             return retval;
1681     }
1682     retval = u132_write_pcimem(u132, ed_controlhead, 0x00000000);
1683     if (retval)
1684         return retval;
1685     retval = u132_write_pcimem(u132, ed_bulkhead, 0x11000000);
1686     if (retval)
1687         return retval;
1688     retval = u132_write_pcimem(u132, hcca, 0x00000000);
1689     if (retval)
1690         return retval;
1691     retval = u132_periodic_reinit(u132);
1692     if (retval)
1693         return retval;
1694     retval = u132_read_pcimem(u132, fminterval, &fminterval);
1695     if (retval)
1696         return retval;
1697     retval = u132_read_pcimem(u132, periodicstart, &periodicstart);
1698     if (retval)
1699         return retval;
1700     if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) {
1701         if (!(u132->flags & OHCI_QUIRK_INITRESET)) {
1702             u132->flags |= OHCI_QUIRK_INITRESET;
1703             goto retry;
1704         } else
1705             dev_err(&u132->platform_dev->dev, "init err(%08x %04x)"
1706                 "\n", fminterval, periodicstart);
1707     }           /* start controller operations */
1708     u132->hc_control &= OHCI_CTRL_RWC;
1709     u132->hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER;
1710     retval = u132_write_pcimem(u132, control, u132->hc_control);
1711     if (retval)
1712         return retval;
1713     retval = u132_write_pcimem(u132, cmdstatus, OHCI_BLF);
1714     if (retval)
1715         return retval;
1716     retval = u132_read_pcimem(u132, cmdstatus, &cmdstatus);
1717     if (retval)
1718         return retval;
1719     retval = u132_read_pcimem(u132, control, &control);
1720     if (retval)
1721         return retval;
1722     u132_to_hcd(u132)->state = HC_STATE_RUNNING;
1723     retval = u132_write_pcimem(u132, roothub.status, RH_HS_DRWE);
1724     if (retval)
1725         return retval;
1726     retval = u132_write_pcimem(u132, intrstatus, mask);
1727     if (retval)
1728         return retval;
1729     retval = u132_write_pcimem(u132, intrdisable,
1730         OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO |
1731         OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH |
1732         OHCI_INTR_SO);
1733     if (retval)
1734         return retval;  /* handle root hub init quirks ... */
1735     retval = u132_read_pcimem(u132, roothub.a, &roothub_a);
1736     if (retval)
1737         return retval;
1738     roothub_a &= ~(RH_A_PSM | RH_A_OCPM);
1739     if (u132->flags & OHCI_QUIRK_SUPERIO) {
1740         roothub_a |= RH_A_NOCP;
1741         roothub_a &= ~(RH_A_POTPGT | RH_A_NPS);
1742         retval = u132_write_pcimem(u132, roothub.a, roothub_a);
1743         if (retval)
1744             return retval;
1745     } else if ((u132->flags & OHCI_QUIRK_AMD756) || distrust_firmware) {
1746         roothub_a |= RH_A_NPS;
1747         retval = u132_write_pcimem(u132, roothub.a, roothub_a);
1748         if (retval)
1749             return retval;
1750     }
1751     retval = u132_write_pcimem(u132, roothub.status, RH_HS_LPSC);
1752     if (retval)
1753         return retval;
1754     retval = u132_write_pcimem(u132, roothub.b,
1755         (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM);
1756     if (retval)
1757         return retval;
1758     retval = u132_read_pcimem(u132, control, &control);
1759     if (retval)
1760         return retval;
1761     mdelay((roothub_a >> 23) & 0x1fe);
1762     u132_to_hcd(u132)->state = HC_STATE_RUNNING;
1763     return 0;
1764 }
1765
1766 static void u132_hcd_stop(struct usb_hcd *hcd)
1767 {
1768     struct u132 *u132 = hcd_to_u132(hcd);
1769     if (u132->going > 1) {
1770         dev_err(&u132->platform_dev->dev, "u132 device %p(hcd=%p) has b"
1771             "een removed %d\n", u132, hcd, u132->going);
1772     } else if (u132->going > 0) {
1773         dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
1774             "ed\n", hcd);
1775     } else {
1776         mutex_lock(&u132->sw_lock);
1777         msleep(100);
1778         u132_power(u132, 0);
1779         mutex_unlock(&u132->sw_lock);
1780     }
1781 }
1782
1783 static int u132_hcd_start(struct usb_hcd *hcd)
1784 {
1785     struct u132 *u132 = hcd_to_u132(hcd);
1786     if (u132->going > 1) {
1787         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1788             , u132->going);
1789         return -ENODEV;
1790     } else if (u132->going > 0) {
1791         dev_err(&u132->platform_dev->dev, "device is being removed\n");
1792         return -ESHUTDOWN;
1793     } else if (hcd->self.controller) {
1794         int retval;
1795         struct platform_device *pdev =
1796             to_platform_device(hcd->self.controller);
1797         u16 vendor = ((struct u132_platform_data *)
1798             dev_get_platdata(&pdev->dev))->vendor;
1799         u16 device = ((struct u132_platform_data *)
1800             dev_get_platdata(&pdev->dev))->device;
1801         mutex_lock(&u132->sw_lock);
1802         msleep(10);
1803         if (vendor == PCI_VENDOR_ID_AMD && device == 0x740c) {
1804             u132->flags = OHCI_QUIRK_AMD756;
1805         } else if (vendor == PCI_VENDOR_ID_OPTI && device == 0xc861) {
1806             dev_err(&u132->platform_dev->dev, "WARNING: OPTi workar"
1807                 "ounds unavailable\n");
1808         } else if (vendor == PCI_VENDOR_ID_COMPAQ && device == 0xa0f8)
1809             u132->flags |= OHCI_QUIRK_ZFMICRO;
1810         retval = u132_run(u132);
1811         if (retval) {
1812             u132_disable(u132);
1813             u132->going = 1;
1814         }
1815         msleep(100);
1816         mutex_unlock(&u132->sw_lock);
1817         return retval;
1818     } else {
1819         dev_err(&u132->platform_dev->dev, "platform_device missing\n");
1820         return -ENODEV;
1821     }
1822 }
1823
1824 static int u132_hcd_reset(struct usb_hcd *hcd)
1825 {
1826     struct u132 *u132 = hcd_to_u132(hcd);
1827     if (u132->going > 1) {
1828         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
1829             , u132->going);
1830         return -ENODEV;
1831     } else if (u132->going > 0) {
1832         dev_err(&u132->platform_dev->dev, "device is being removed\n");
1833         return -ESHUTDOWN;
1834     } else {
1835         int retval;
1836         mutex_lock(&u132->sw_lock);
1837         retval = u132_init(u132);
1838         if (retval) {
1839             u132_disable(u132);
1840             u132->going = 1;
1841         }
1842         mutex_unlock(&u132->sw_lock);
1843         return retval;
1844     }
1845 }
1846
1847 static int create_endpoint_and_queue_int(struct u132 *u132,
1848     struct u132_udev *udev, struct urb *urb,
1849     struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
1850     gfp_t mem_flags)
1851 {
1852     struct u132_ring *ring;
1853     unsigned long irqs;
1854     int rc;
1855     u8 endp_number;
1856     struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
1857
1858     if (!endp)
1859         return -ENOMEM;
1860
1861     spin_lock_init(&endp->queue_lock.slock);
1862     spin_lock_irqsave(&endp->queue_lock.slock, irqs);
1863     rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
1864     if (rc) {
1865         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1866         kfree(endp);
1867         return rc;
1868     }
1869
1870     endp_number = ++u132->num_endpoints;
1871     urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
1872     INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
1873     INIT_LIST_HEAD(&endp->urb_more);
1874     ring = endp->ring = &u132->ring[0];
1875     if (ring->curr_endp) {
1876         list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
1877     } else {
1878         INIT_LIST_HEAD(&endp->endp_ring);
1879         ring->curr_endp = endp;
1880     }
1881     ring->length += 1;
1882     endp->dequeueing = 0;
1883     endp->edset_flush = 0;
1884     endp->active = 0;
1885     endp->delayed = 0;
1886     endp->endp_number = endp_number;
1887     endp->u132 = u132;
1888     endp->hep = urb->ep;
1889     endp->pipetype = usb_pipetype(urb->pipe);
1890     u132_endp_init_kref(u132, endp);
1891     if (usb_pipein(urb->pipe)) {
1892         endp->toggle_bits = 0x2;
1893         usb_settoggle(udev->usb_device, usb_endp, 0, 0);
1894         endp->input = 1;
1895         endp->output = 0;
1896         udev->endp_number_in[usb_endp] = endp_number;
1897         u132_udev_get_kref(u132, udev);
1898     } else {
1899         endp->toggle_bits = 0x2;
1900         usb_settoggle(udev->usb_device, usb_endp, 1, 0);
1901         endp->input = 0;
1902         endp->output = 1;
1903         udev->endp_number_out[usb_endp] = endp_number;
1904         u132_udev_get_kref(u132, udev);
1905     }
1906     urb->hcpriv = u132;
1907     endp->delayed = 1;
1908     endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
1909     endp->udev_number = address;
1910     endp->usb_addr = usb_addr;
1911     endp->usb_endp = usb_endp;
1912     endp->queue_size = 1;
1913     endp->queue_last = 0;
1914     endp->queue_next = 0;
1915     endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
1916     spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1917     u132_endp_queue_work(u132, endp, msecs_to_jiffies(urb->interval));
1918     return 0;
1919 }
1920
1921 static int queue_int_on_old_endpoint(struct u132 *u132,
1922     struct u132_udev *udev, struct urb *urb,
1923     struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
1924     u8 usb_endp, u8 address)
1925 {
1926     urb->hcpriv = u132;
1927     endp->delayed = 1;
1928     endp->jiffies = jiffies + msecs_to_jiffies(urb->interval);
1929     if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
1930         endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
1931     } else {
1932         struct u132_urbq *urbq = kmalloc(sizeof(struct u132_urbq),
1933             GFP_ATOMIC);
1934         if (urbq == NULL) {
1935             endp->queue_size -= 1;
1936             return -ENOMEM;
1937         } else {
1938             list_add_tail(&urbq->urb_more, &endp->urb_more);
1939             urbq->urb = urb;
1940         }
1941     }
1942     return 0;
1943 }
1944
1945 static int create_endpoint_and_queue_bulk(struct u132 *u132,
1946     struct u132_udev *udev, struct urb *urb,
1947     struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp, u8 address,
1948     gfp_t mem_flags)
1949 {
1950     int ring_number;
1951     struct u132_ring *ring;
1952     unsigned long irqs;
1953     int rc;
1954     u8 endp_number;
1955     struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
1956
1957     if (!endp)
1958         return -ENOMEM;
1959
1960     spin_lock_init(&endp->queue_lock.slock);
1961     spin_lock_irqsave(&endp->queue_lock.slock, irqs);
1962     rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
1963     if (rc) {
1964         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
1965         kfree(endp);
1966         return rc;
1967     }
1968
1969     endp_number = ++u132->num_endpoints;
1970     urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
1971     INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
1972     INIT_LIST_HEAD(&endp->urb_more);
1973     endp->dequeueing = 0;
1974     endp->edset_flush = 0;
1975     endp->active = 0;
1976     endp->delayed = 0;
1977     endp->endp_number = endp_number;
1978     endp->u132 = u132;
1979     endp->hep = urb->ep;
1980     endp->pipetype = usb_pipetype(urb->pipe);
1981     u132_endp_init_kref(u132, endp);
1982     if (usb_pipein(urb->pipe)) {
1983         endp->toggle_bits = 0x2;
1984         usb_settoggle(udev->usb_device, usb_endp, 0, 0);
1985         ring_number = 3;
1986         endp->input = 1;
1987         endp->output = 0;
1988         udev->endp_number_in[usb_endp] = endp_number;
1989         u132_udev_get_kref(u132, udev);
1990     } else {
1991         endp->toggle_bits = 0x2;
1992         usb_settoggle(udev->usb_device, usb_endp, 1, 0);
1993         ring_number = 2;
1994         endp->input = 0;
1995         endp->output = 1;
1996         udev->endp_number_out[usb_endp] = endp_number;
1997         u132_udev_get_kref(u132, udev);
1998     }
1999     ring = endp->ring = &u132->ring[ring_number - 1];
2000     if (ring->curr_endp) {
2001         list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
2002     } else {
2003         INIT_LIST_HEAD(&endp->endp_ring);
2004         ring->curr_endp = endp;
2005     }
2006     ring->length += 1;
2007     urb->hcpriv = u132;
2008     endp->udev_number = address;
2009     endp->usb_addr = usb_addr;
2010     endp->usb_endp = usb_endp;
2011     endp->queue_size = 1;
2012     endp->queue_last = 0;
2013     endp->queue_next = 0;
2014     endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2015     spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2016     u132_endp_queue_work(u132, endp, 0);
2017     return 0;
2018 }
2019
2020 static int queue_bulk_on_old_endpoint(struct u132 *u132, struct u132_udev *udev,
2021     struct urb *urb,
2022     struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2023     u8 usb_endp, u8 address)
2024 {
2025     urb->hcpriv = u132;
2026     if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2027         endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2028     } else {
2029         struct u132_urbq *urbq = kmalloc(sizeof(struct u132_urbq),
2030             GFP_ATOMIC);
2031         if (urbq == NULL) {
2032             endp->queue_size -= 1;
2033             return -ENOMEM;
2034         } else {
2035             list_add_tail(&urbq->urb_more, &endp->urb_more);
2036             urbq->urb = urb;
2037         }
2038     }
2039     return 0;
2040 }
2041
2042 static int create_endpoint_and_queue_control(struct u132 *u132,
2043     struct urb *urb,
2044     struct usb_device *usb_dev, u8 usb_addr, u8 usb_endp,
2045     gfp_t mem_flags)
2046 {
2047     struct u132_ring *ring;
2048     unsigned long irqs;
2049     int rc;
2050     u8 endp_number;
2051     struct u132_endp *endp = kmalloc(sizeof(struct u132_endp), mem_flags);
2052
2053     if (!endp)
2054         return -ENOMEM;
2055
2056     spin_lock_init(&endp->queue_lock.slock);
2057     spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2058     rc = usb_hcd_link_urb_to_ep(u132_to_hcd(u132), urb);
2059     if (rc) {
2060         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2061         kfree(endp);
2062         return rc;
2063     }
2064
2065     endp_number = ++u132->num_endpoints;
2066     urb->ep->hcpriv = u132->endp[endp_number - 1] = endp;
2067     INIT_DELAYED_WORK(&endp->scheduler, u132_hcd_endp_work_scheduler);
2068     INIT_LIST_HEAD(&endp->urb_more);
2069     ring = endp->ring = &u132->ring[0];
2070     if (ring->curr_endp) {
2071         list_add_tail(&endp->endp_ring, &ring->curr_endp->endp_ring);
2072     } else {
2073         INIT_LIST_HEAD(&endp->endp_ring);
2074         ring->curr_endp = endp;
2075     }
2076     ring->length += 1;
2077     endp->dequeueing = 0;
2078     endp->edset_flush = 0;
2079     endp->active = 0;
2080     endp->delayed = 0;
2081     endp->endp_number = endp_number;
2082     endp->u132 = u132;
2083     endp->hep = urb->ep;
2084     u132_endp_init_kref(u132, endp);
2085     u132_endp_get_kref(u132, endp);
2086     if (usb_addr == 0) {
2087         u8 address = u132->addr[usb_addr].address;
2088         struct u132_udev *udev = &u132->udev[address];
2089         endp->udev_number = address;
2090         endp->usb_addr = usb_addr;
2091         endp->usb_endp = usb_endp;
2092         endp->input = 1;
2093         endp->output = 1;
2094         endp->pipetype = usb_pipetype(urb->pipe);
2095         u132_udev_init_kref(u132, udev);
2096         u132_udev_get_kref(u132, udev);
2097         udev->endp_number_in[usb_endp] = endp_number;
2098         udev->endp_number_out[usb_endp] = endp_number;
2099         urb->hcpriv = u132;
2100         endp->queue_size = 1;
2101         endp->queue_last = 0;
2102         endp->queue_next = 0;
2103         endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2104         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2105         u132_endp_queue_work(u132, endp, 0);
2106         return 0;
2107     } else {        /*(usb_addr > 0) */
2108         u8 address = u132->addr[usb_addr].address;
2109         struct u132_udev *udev = &u132->udev[address];
2110         endp->udev_number = address;
2111         endp->usb_addr = usb_addr;
2112         endp->usb_endp = usb_endp;
2113         endp->input = 1;
2114         endp->output = 1;
2115         endp->pipetype = usb_pipetype(urb->pipe);
2116         u132_udev_get_kref(u132, udev);
2117         udev->enumeration = 2;
2118         udev->endp_number_in[usb_endp] = endp_number;
2119         udev->endp_number_out[usb_endp] = endp_number;
2120         urb->hcpriv = u132;
2121         endp->queue_size = 1;
2122         endp->queue_last = 0;
2123         endp->queue_next = 0;
2124         endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] = urb;
2125         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2126         u132_endp_queue_work(u132, endp, 0);
2127         return 0;
2128     }
2129 }
2130
2131 static int queue_control_on_old_endpoint(struct u132 *u132,
2132     struct urb *urb,
2133     struct usb_device *usb_dev, struct u132_endp *endp, u8 usb_addr,
2134     u8 usb_endp)
2135 {
2136     if (usb_addr == 0) {
2137         if (usb_pipein(urb->pipe)) {
2138             urb->hcpriv = u132;
2139             if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2140                 endp->urb_list[ENDP_QUEUE_MASK &
2141                     endp->queue_last++] = urb;
2142             } else {
2143                 struct u132_urbq *urbq =
2144                     kmalloc(sizeof(struct u132_urbq),
2145                     GFP_ATOMIC);
2146                 if (urbq == NULL) {
2147                     endp->queue_size -= 1;
2148                     return -ENOMEM;
2149                 } else {
2150                     list_add_tail(&urbq->urb_more,
2151                         &endp->urb_more);
2152                     urbq->urb = urb;
2153                 }
2154             }
2155             return 0;
2156         } else {    /* usb_pipeout(urb->pipe) */
2157             struct u132_addr *addr = &u132->addr[usb_dev->devnum];
2158             int I = MAX_U132_UDEVS;
2159             int i = 0;
2160             while (--I > 0) {
2161                 struct u132_udev *udev = &u132->udev[++i];
2162                 if (udev->usb_device) {
2163                     continue;
2164                 } else {
2165                     udev->enumeration = 1;
2166                     u132->addr[0].address = i;
2167                     endp->udev_number = i;
2168                     udev->udev_number = i;
2169                     udev->usb_addr = usb_dev->devnum;
2170                     u132_udev_init_kref(u132, udev);
2171                     udev->endp_number_in[usb_endp] =
2172                         endp->endp_number;
2173                     u132_udev_get_kref(u132, udev);
2174                     udev->endp_number_out[usb_endp] =
2175                         endp->endp_number;
2176                     udev->usb_device = usb_dev;
2177                     ((u8 *) (urb->setup_packet))[2] =
2178                         addr->address = i;
2179                     u132_udev_get_kref(u132, udev);
2180                     break;
2181                 }
2182             }
2183             if (I == 0) {
2184                 dev_err(&u132->platform_dev->dev, "run out of d"
2185                     "evice space\n");
2186                 return -EINVAL;
2187             }
2188             urb->hcpriv = u132;
2189             if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2190                 endp->urb_list[ENDP_QUEUE_MASK &
2191                     endp->queue_last++] = urb;
2192             } else {
2193                 struct u132_urbq *urbq =
2194                     kmalloc(sizeof(struct u132_urbq),
2195                     GFP_ATOMIC);
2196                 if (urbq == NULL) {
2197                     endp->queue_size -= 1;
2198                     return -ENOMEM;
2199                 } else {
2200                     list_add_tail(&urbq->urb_more,
2201                         &endp->urb_more);
2202                     urbq->urb = urb;
2203                 }
2204             }
2205             return 0;
2206         }
2207     } else {        /*(usb_addr > 0) */
2208         u8 address = u132->addr[usb_addr].address;
2209         struct u132_udev *udev = &u132->udev[address];
2210         urb->hcpriv = u132;
2211         if (udev->enumeration != 2)
2212             udev->enumeration = 2;
2213         if (endp->queue_size++ < ENDP_QUEUE_SIZE) {
2214             endp->urb_list[ENDP_QUEUE_MASK & endp->queue_last++] =
2215                 urb;
2216         } else {
2217             struct u132_urbq *urbq =
2218                 kmalloc(sizeof(struct u132_urbq), GFP_ATOMIC);
2219             if (urbq == NULL) {
2220                 endp->queue_size -= 1;
2221                 return -ENOMEM;
2222             } else {
2223                 list_add_tail(&urbq->urb_more, &endp->urb_more);
2224                 urbq->urb = urb;
2225             }
2226         }
2227         return 0;
2228     }
2229 }
2230
2231 static int u132_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
2232         gfp_t mem_flags)
2233 {
2234     struct u132 *u132 = hcd_to_u132(hcd);
2235     if (irqs_disabled()) {
2236         if (gfpflags_allow_blocking(mem_flags)) {
2237             printk(KERN_ERR "invalid context for function that might sleep\n");
2238             return -EINVAL;
2239         }
2240     }
2241     if (u132->going > 1) {
2242         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2243             , u132->going);
2244         return -ENODEV;
2245     } else if (u132->going > 0) {
2246         dev_err(&u132->platform_dev->dev, "device is being removed "
2247                 "urb=%p\n", urb);
2248         return -ESHUTDOWN;
2249     } else {
2250         u8 usb_addr = usb_pipedevice(urb->pipe);
2251         u8 usb_endp = usb_pipeendpoint(urb->pipe);
2252         struct usb_device *usb_dev = urb->dev;
2253         if (usb_pipetype(urb->pipe) == PIPE_INTERRUPT) {
2254             u8 address = u132->addr[usb_addr].address;
2255             struct u132_udev *udev = &u132->udev[address];
2256             struct u132_endp *endp = urb->ep->hcpriv;
2257             urb->actual_length = 0;
2258             if (endp) {
2259                 unsigned long irqs;
2260                 int retval;
2261                 spin_lock_irqsave(&endp->queue_lock.slock,
2262                     irqs);
2263                 retval = usb_hcd_link_urb_to_ep(hcd, urb);
2264                 if (retval == 0) {
2265                     retval = queue_int_on_old_endpoint(
2266                             u132, udev, urb,
2267                             usb_dev, endp,
2268                             usb_addr, usb_endp,
2269                             address);
2270                     if (retval)
2271                         usb_hcd_unlink_urb_from_ep(
2272     hcd, urb);
2273                 }
2274                 spin_unlock_irqrestore(&endp->queue_lock.slock,
2275                     irqs);
2276                 if (retval) {
2277                     return retval;
2278                 } else {
2279                     u132_endp_queue_work(u132, endp,
2280                         msecs_to_jiffies(urb->interval))
2281                         ;
2282                     return 0;
2283                 }
2284             } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2285                 return -EINVAL;
2286             } else {    /*(endp == NULL) */
2287                 return create_endpoint_and_queue_int(u132, udev,
2288                         urb, usb_dev, usb_addr,
2289                         usb_endp, address, mem_flags);
2290             }
2291         } else if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
2292             dev_err(&u132->platform_dev->dev, "the hardware does no"
2293                 "t support PIPE_ISOCHRONOUS\n");
2294             return -EINVAL;
2295         } else if (usb_pipetype(urb->pipe) == PIPE_BULK) {
2296             u8 address = u132->addr[usb_addr].address;
2297             struct u132_udev *udev = &u132->udev[address];
2298             struct u132_endp *endp = urb->ep->hcpriv;
2299             urb->actual_length = 0;
2300             if (endp) {
2301                 unsigned long irqs;
2302                 int retval;
2303                 spin_lock_irqsave(&endp->queue_lock.slock,
2304                     irqs);
2305                 retval = usb_hcd_link_urb_to_ep(hcd, urb);
2306                 if (retval == 0) {
2307                     retval = queue_bulk_on_old_endpoint(
2308                             u132, udev, urb,
2309                             usb_dev, endp,
2310                             usb_addr, usb_endp,
2311                             address);
2312                     if (retval)
2313                         usb_hcd_unlink_urb_from_ep(
2314     hcd, urb);
2315                 }
2316                 spin_unlock_irqrestore(&endp->queue_lock.slock,
2317                     irqs);
2318                 if (retval) {
2319                     return retval;
2320                 } else {
2321                     u132_endp_queue_work(u132, endp, 0);
2322                     return 0;
2323                 }
2324             } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2325                 return -EINVAL;
2326             } else
2327                 return create_endpoint_and_queue_bulk(u132,
2328                     udev, urb, usb_dev, usb_addr,
2329                     usb_endp, address, mem_flags);
2330         } else {
2331             struct u132_endp *endp = urb->ep->hcpriv;
2332             u16 urb_size = 8;
2333             u8 *b = urb->setup_packet;
2334             int i = 0;
2335             char data[30 * 3 + 4];
2336             char *d = data;
2337             int m = (sizeof(data) - 1) / 3;
2338             int l = 0;
2339             data[0] = 0;
2340             while (urb_size-- > 0) {
2341                 if (i > m) {
2342                 } else if (i++ < m) {
2343                     int w = sprintf(d, " %02X", *b++);
2344                     d += w;
2345                     l += w;
2346                 } else
2347                     d += sprintf(d, " ..");
2348             }
2349             if (endp) {
2350                 unsigned long irqs;
2351                 int retval;
2352                 spin_lock_irqsave(&endp->queue_lock.slock,
2353                     irqs);
2354                 retval = usb_hcd_link_urb_to_ep(hcd, urb);
2355                 if (retval == 0) {
2356                     retval = queue_control_on_old_endpoint(
2357                             u132, urb, usb_dev,
2358                             endp, usb_addr,
2359                             usb_endp);
2360                     if (retval)
2361                         usb_hcd_unlink_urb_from_ep(
2362                                 hcd, urb);
2363                 }
2364                 spin_unlock_irqrestore(&endp->queue_lock.slock,
2365                     irqs);
2366                 if (retval) {
2367                     return retval;
2368                 } else {
2369                     u132_endp_queue_work(u132, endp, 0);
2370                     return 0;
2371                 }
2372             } else if (u132->num_endpoints == MAX_U132_ENDPS) {
2373                 return -EINVAL;
2374             } else
2375                 return create_endpoint_and_queue_control(u132,
2376                     urb, usb_dev, usb_addr, usb_endp,
2377                     mem_flags);
2378         }
2379     }
2380 }
2381
2382 static int dequeue_from_overflow_chain(struct u132 *u132,
2383     struct u132_endp *endp, struct urb *urb)
2384 {
2385     struct u132_urbq *urbq;
2386
2387     list_for_each_entry(urbq, &endp->urb_more, urb_more) {
2388         if (urbq->urb == urb) {
2389             struct usb_hcd *hcd = u132_to_hcd(u132);
2390             list_del(&urbq->urb_more);
2391             endp->queue_size -= 1;
2392             urb->error_count = 0;
2393             usb_hcd_giveback_urb(hcd, urb, 0);
2394             return 0;
2395         }
2396     }
2397     dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]=%p ring"
2398         "[%d] %c%c usb_endp=%d usb_addr=%d size=%d next=%04X last=%04X"
2399         "\n", urb, endp->endp_number, endp, endp->ring->number,
2400         endp->input ? 'I' : ' ', endp->output ? 'O' : ' ',
2401         endp->usb_endp, endp->usb_addr, endp->queue_size,
2402         endp->queue_next, endp->queue_last);
2403     return -EINVAL;
2404 }
2405
2406 static int u132_endp_urb_dequeue(struct u132 *u132, struct u132_endp *endp,
2407         struct urb *urb, int status)
2408 {
2409     unsigned long irqs;
2410     int rc;
2411
2412     spin_lock_irqsave(&endp->queue_lock.slock, irqs);
2413     rc = usb_hcd_check_unlink_urb(u132_to_hcd(u132), urb, status);
2414     if (rc) {
2415         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2416         return rc;
2417     }
2418     if (endp->queue_size == 0) {
2419         dev_err(&u132->platform_dev->dev, "urb=%p not found in endp[%d]"
2420             "=%p ring[%d] %c%c usb_endp=%d usb_addr=%d\n", urb,
2421             endp->endp_number, endp, endp->ring->number,
2422             endp->input ? 'I' : ' ', endp->output ? 'O' : ' ',
2423             endp->usb_endp, endp->usb_addr);
2424         spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2425         return -EINVAL;
2426     }
2427     if (urb == endp->urb_list[ENDP_QUEUE_MASK & endp->queue_next]) {
2428         if (endp->active) {
2429             endp->dequeueing = 1;
2430             endp->edset_flush = 1;
2431             u132_endp_queue_work(u132, endp, 0);
2432             spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2433             return 0;
2434         } else {
2435             spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2436             u132_hcd_abandon_urb(u132, endp, urb, status);
2437             return 0;
2438         }
2439     } else {
2440         u16 queue_list = 0;
2441         u16 queue_size = endp->queue_size;
2442         u16 queue_scan = endp->queue_next;
2443         struct urb **urb_slot = NULL;
2444         while (++queue_list < ENDP_QUEUE_SIZE && --queue_size > 0) {
2445             if (urb == endp->urb_list[ENDP_QUEUE_MASK &
2446                 ++queue_scan]) {
2447                 urb_slot = &endp->urb_list[ENDP_QUEUE_MASK &
2448                     queue_scan];
2449                 break;
2450             }
2451         }
2452         while (++queue_list < ENDP_QUEUE_SIZE && --queue_size > 0) {
2453             *urb_slot = endp->urb_list[ENDP_QUEUE_MASK &
2454                 ++queue_scan];
2455             urb_slot = &endp->urb_list[ENDP_QUEUE_MASK &
2456                 queue_scan];
2457         }
2458         if (urb_slot) {
2459             struct usb_hcd *hcd = u132_to_hcd(u132);
2460
2461             usb_hcd_unlink_urb_from_ep(hcd, urb);
2462             endp->queue_size -= 1;
2463             if (list_empty(&endp->urb_more)) {
2464                 spin_unlock_irqrestore(&endp->queue_lock.slock,
2465                     irqs);
2466             } else {
2467                 struct list_head *next = endp->urb_more.next;
2468                 struct u132_urbq *urbq = list_entry(next,
2469                     struct u132_urbq, urb_more);
2470                 list_del(next);
2471                 *urb_slot = urbq->urb;
2472                 spin_unlock_irqrestore(&endp->queue_lock.slock,
2473                     irqs);
2474                 kfree(urbq);
2475             }
2476             urb->error_count = 0;
2477             usb_hcd_giveback_urb(hcd, urb, status);
2478             return 0;
2479         } else if (list_empty(&endp->urb_more)) {
2480             dev_err(&u132->platform_dev->dev, "urb=%p not found in "
2481                 "endp[%d]=%p ring[%d] %c%c usb_endp=%d usb_addr"
2482                 "=%d size=%d next=%04X last=%04X\n", urb,
2483                 endp->endp_number, endp, endp->ring->number,
2484                 endp->input ? 'I' : ' ',
2485                 endp->output ? 'O' : ' ', endp->usb_endp,
2486                 endp->usb_addr, endp->queue_size,
2487                 endp->queue_next, endp->queue_last);
2488             spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2489             return -EINVAL;
2490         } else {
2491             int retval;
2492
2493             usb_hcd_unlink_urb_from_ep(u132_to_hcd(u132), urb);
2494             retval = dequeue_from_overflow_chain(u132, endp,
2495                 urb);
2496             spin_unlock_irqrestore(&endp->queue_lock.slock, irqs);
2497             return retval;
2498         }
2499     }
2500 }
2501
2502 static int u132_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
2503 {
2504     struct u132 *u132 = hcd_to_u132(hcd);
2505     if (u132->going > 2) {
2506         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2507             , u132->going);
2508         return -ENODEV;
2509     } else {
2510         u8 usb_addr = usb_pipedevice(urb->pipe);
2511         u8 usb_endp = usb_pipeendpoint(urb->pipe);
2512         u8 address = u132->addr[usb_addr].address;
2513         struct u132_udev *udev = &u132->udev[address];
2514         if (usb_pipein(urb->pipe)) {
2515             u8 endp_number = udev->endp_number_in[usb_endp];
2516             struct u132_endp *endp = u132->endp[endp_number - 1];
2517             return u132_endp_urb_dequeue(u132, endp, urb, status);
2518         } else {
2519             u8 endp_number = udev->endp_number_out[usb_endp];
2520             struct u132_endp *endp = u132->endp[endp_number - 1];
2521             return u132_endp_urb_dequeue(u132, endp, urb, status);
2522         }
2523     }
2524 }
2525
2526 static void u132_endpoint_disable(struct usb_hcd *hcd,
2527     struct usb_host_endpoint *hep)
2528 {
2529     struct u132 *u132 = hcd_to_u132(hcd);
2530     if (u132->going > 2) {
2531         dev_err(&u132->platform_dev->dev, "u132 device %p(hcd=%p hep=%p"
2532             ") has been removed %d\n", u132, hcd, hep,
2533             u132->going);
2534     } else {
2535         struct u132_endp *endp = hep->hcpriv;
2536         if (endp)
2537             u132_endp_put_kref(u132, endp);
2538     }
2539 }
2540
2541 static int u132_get_frame(struct usb_hcd *hcd)
2542 {
2543     struct u132 *u132 = hcd_to_u132(hcd);
2544     if (u132->going > 1) {
2545         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2546             , u132->going);
2547         return -ENODEV;
2548     } else if (u132->going > 0) {
2549         dev_err(&u132->platform_dev->dev, "device is being removed\n");
2550         return -ESHUTDOWN;
2551     } else {
2552         dev_err(&u132->platform_dev->dev, "TODO: u132_get_frame\n");
2553         mdelay(100);
2554         return 0;
2555     }
2556 }
2557
2558 static int u132_roothub_descriptor(struct u132 *u132,
2559     struct usb_hub_descriptor *desc)
2560 {
2561     int retval;
2562     u16 temp;
2563     u32 rh_a = -1;
2564     u32 rh_b = -1;
2565     retval = u132_read_pcimem(u132, roothub.a, &rh_a);
2566     if (retval)
2567         return retval;
2568     desc->bDescriptorType = USB_DT_HUB;
2569     desc->bPwrOn2PwrGood = (rh_a & RH_A_POTPGT) >> 24;
2570     desc->bHubContrCurrent = 0;
2571     desc->bNbrPorts = u132->num_ports;
2572     temp = 1 + (u132->num_ports / 8);
2573     desc->bDescLength = 7 + 2 * temp;
2574     temp = HUB_CHAR_COMMON_LPSM | HUB_CHAR_COMMON_OCPM;
2575     if (rh_a & RH_A_NPS)
2576         temp |= HUB_CHAR_NO_LPSM;
2577     if (rh_a & RH_A_PSM)
2578         temp |= HUB_CHAR_INDV_PORT_LPSM;
2579     if (rh_a & RH_A_NOCP)
2580         temp |= HUB_CHAR_NO_OCPM;
2581     else if (rh_a & RH_A_OCPM)
2582         temp |= HUB_CHAR_INDV_PORT_OCPM;
2583     desc->wHubCharacteristics = cpu_to_le16(temp);
2584     retval = u132_read_pcimem(u132, roothub.b, &rh_b);
2585     if (retval)
2586         return retval;
2587     memset(desc->u.hs.DeviceRemovable, 0xff,
2588             sizeof(desc->u.hs.DeviceRemovable));
2589     desc->u.hs.DeviceRemovable[0] = rh_b & RH_B_DR;
2590     if (u132->num_ports > 7) {
2591         desc->u.hs.DeviceRemovable[1] = (rh_b & RH_B_DR) >> 8;
2592         desc->u.hs.DeviceRemovable[2] = 0xff;
2593     } else
2594         desc->u.hs.DeviceRemovable[1] = 0xff;
2595     return 0;
2596 }
2597
2598 static int u132_roothub_status(struct u132 *u132, __le32 *desc)
2599 {
2600     u32 rh_status = -1;
2601     int ret_status = u132_read_pcimem(u132, roothub.status, &rh_status);
2602     *desc = cpu_to_le32(rh_status);
2603     return ret_status;
2604 }
2605
2606 static int u132_roothub_portstatus(struct u132 *u132, __le32 *desc, u16 wIndex)
2607 {
2608     if (wIndex == 0 || wIndex > u132->num_ports) {
2609         return -EINVAL;
2610     } else {
2611         int port = wIndex - 1;
2612         u32 rh_portstatus = -1;
2613         int ret_portstatus = u132_read_pcimem(u132,
2614             roothub.portstatus[port], &rh_portstatus);
2615         *desc = cpu_to_le32(rh_portstatus);
2616         if (*(u16 *) (desc + 2)) {
2617             dev_info(&u132->platform_dev->dev, "Port %d Status Chan"
2618                 "ge = %08X\n", port, *desc);
2619         }
2620         return ret_portstatus;
2621     }
2622 }
2623
2624
2625 /* this timer value might be vendor-specific ... */
2626 #define PORT_RESET_HW_MSEC 10
2627 #define PORT_RESET_MSEC 10
2628 /* wrap-aware logic morphed from <linux/jiffies.h> */
2629 #define tick_before(t1, t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
2630 static int u132_roothub_portreset(struct u132 *u132, int port_index)
2631 {
2632     int retval;
2633     u32 fmnumber;
2634     u16 now;
2635     u16 reset_done;
2636     retval = u132_read_pcimem(u132, fmnumber, &fmnumber);
2637     if (retval)
2638         return retval;
2639     now = fmnumber;
2640     reset_done = now + PORT_RESET_MSEC;
2641     do {
2642         u32 portstat;
2643         do {
2644             retval = u132_read_pcimem(u132,
2645                 roothub.portstatus[port_index], &portstat);
2646             if (retval)
2647                 return retval;
2648             if (RH_PS_PRS & portstat)
2649                 continue;
2650             else
2651                 break;
2652         } while (tick_before(now, reset_done));
2653         if (RH_PS_PRS & portstat)
2654             return -ENODEV;
2655         if (RH_PS_CCS & portstat) {
2656             if (RH_PS_PRSC & portstat) {
2657                 retval = u132_write_pcimem(u132,
2658                     roothub.portstatus[port_index],
2659                     RH_PS_PRSC);
2660                 if (retval)
2661                     return retval;
2662             }
2663         } else
2664             break;  /* start the next reset,
2665                 sleep till it's probably done */
2666         retval = u132_write_pcimem(u132, roothub.portstatus[port_index],
2667              RH_PS_PRS);
2668         if (retval)
2669             return retval;
2670         msleep(PORT_RESET_HW_MSEC);
2671         retval = u132_read_pcimem(u132, fmnumber, &fmnumber);
2672         if (retval)
2673             return retval;
2674         now = fmnumber;
2675     } while (tick_before(now, reset_done));
2676     return 0;
2677 }
2678
2679 static int u132_roothub_setportfeature(struct u132 *u132, u16 wValue,
2680     u16 wIndex)
2681 {
2682     if (wIndex == 0 || wIndex > u132->num_ports) {
2683         return -EINVAL;
2684     } else {
2685         int port_index = wIndex - 1;
2686         struct u132_port *port = &u132->port[port_index];
2687         port->Status &= ~(1 << wValue);
2688         switch (wValue) {
2689         case USB_PORT_FEAT_SUSPEND:
2690             return u132_write_pcimem(u132,
2691                    roothub.portstatus[port_index], RH_PS_PSS);
2692         case USB_PORT_FEAT_POWER:
2693             return u132_write_pcimem(u132,
2694                    roothub.portstatus[port_index], RH_PS_PPS);
2695         case USB_PORT_FEAT_RESET:
2696             return u132_roothub_portreset(u132, port_index);
2697         default:
2698             return -EPIPE;
2699         }
2700     }
2701 }
2702
2703 static int u132_roothub_clearportfeature(struct u132 *u132, u16 wValue,
2704     u16 wIndex)
2705 {
2706     if (wIndex == 0 || wIndex > u132->num_ports) {
2707         return -EINVAL;
2708     } else {
2709         int port_index = wIndex - 1;
2710         u32 temp;
2711         struct u132_port *port = &u132->port[port_index];
2712         port->Status &= ~(1 << wValue);
2713         switch (wValue) {
2714         case USB_PORT_FEAT_ENABLE:
2715             temp = RH_PS_CCS;
2716             break;
2717         case USB_PORT_FEAT_C_ENABLE:
2718             temp = RH_PS_PESC;
2719             break;
2720         case USB_PORT_FEAT_SUSPEND:
2721             temp = RH_PS_POCI;
2722             if ((u132->hc_control & OHCI_CTRL_HCFS)
2723                 != OHCI_USB_OPER) {
2724                 dev_err(&u132->platform_dev->dev, "TODO resume_"
2725                     "root_hub\n");
2726             }
2727             break;
2728         case USB_PORT_FEAT_C_SUSPEND:
2729             temp = RH_PS_PSSC;
2730             break;
2731         case USB_PORT_FEAT_POWER:
2732             temp = RH_PS_LSDA;
2733             break;
2734         case USB_PORT_FEAT_C_CONNECTION:
2735             temp = RH_PS_CSC;
2736             break;
2737         case USB_PORT_FEAT_C_OVER_CURRENT:
2738             temp = RH_PS_OCIC;
2739             break;
2740         case USB_PORT_FEAT_C_RESET:
2741             temp = RH_PS_PRSC;
2742             break;
2743         default:
2744             return -EPIPE;
2745         }
2746         return u132_write_pcimem(u132, roothub.portstatus[port_index],
2747                temp);
2748     }
2749 }
2750
2751
2752 /* the virtual root hub timer IRQ checks for hub status*/
2753 static int u132_hub_status_data(struct usb_hcd *hcd, char *buf)
2754 {
2755     struct u132 *u132 = hcd_to_u132(hcd);
2756     if (u132->going > 1) {
2757         dev_err(&u132->platform_dev->dev, "device hcd=%p has been remov"
2758             "ed %d\n", hcd, u132->going);
2759         return -ENODEV;
2760     } else if (u132->going > 0) {
2761         dev_err(&u132->platform_dev->dev, "device hcd=%p is being remov"
2762             "ed\n", hcd);
2763         return -ESHUTDOWN;
2764     } else {
2765         int i, changed = 0, length = 1;
2766         if (u132->flags & OHCI_QUIRK_AMD756) {
2767             if ((u132->hc_roothub_a & RH_A_NDP) > MAX_ROOT_PORTS) {
2768                 dev_err(&u132->platform_dev->dev, "bogus NDP, r"
2769                     "ereads as NDP=%d\n",
2770                     u132->hc_roothub_a & RH_A_NDP);
2771                 goto done;
2772             }
2773         }
2774         if (u132->hc_roothub_status & (RH_HS_LPSC | RH_HS_OCIC))
2775             buf[0] = changed = 1;
2776         else
2777             buf[0] = 0;
2778         if (u132->num_ports > 7) {
2779             buf[1] = 0;
2780             length++;
2781         }
2782         for (i = 0; i < u132->num_ports; i++) {
2783             if (u132->hc_roothub_portstatus[i] & (RH_PS_CSC |
2784                 RH_PS_PESC | RH_PS_PSSC | RH_PS_OCIC |
2785                 RH_PS_PRSC)) {
2786                 changed = 1;
2787                 if (i < 7)
2788                     buf[0] |= 1 << (i + 1);
2789                 else
2790                     buf[1] |= 1 << (i - 7);
2791                 continue;
2792             }
2793             if (!(u132->hc_roothub_portstatus[i] & RH_PS_CCS))
2794                 continue;
2795
2796             if ((u132->hc_roothub_portstatus[i] & RH_PS_PSS))
2797                 continue;
2798         }
2799 done:
2800         return changed ? length : 0;
2801     }
2802 }
2803
2804 static int u132_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
2805     u16 wIndex, char *buf, u16 wLength)
2806 {
2807     struct u132 *u132 = hcd_to_u132(hcd);
2808     if (u132->going > 1) {
2809         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2810             , u132->going);
2811         return -ENODEV;
2812     } else if (u132->going > 0) {
2813         dev_err(&u132->platform_dev->dev, "device is being removed\n");
2814         return -ESHUTDOWN;
2815     } else {
2816         int retval = 0;
2817         mutex_lock(&u132->sw_lock);
2818         switch (typeReq) {
2819         case ClearHubFeature:
2820             switch (wValue) {
2821             case C_HUB_OVER_CURRENT:
2822             case C_HUB_LOCAL_POWER:
2823                 break;
2824             default:
2825                 goto stall;
2826             }
2827             break;
2828         case SetHubFeature:
2829             switch (wValue) {
2830             case C_HUB_OVER_CURRENT:
2831             case C_HUB_LOCAL_POWER:
2832                 break;
2833             default:
2834                 goto stall;
2835             }
2836             break;
2837         case ClearPortFeature:{
2838                 retval = u132_roothub_clearportfeature(u132,
2839                     wValue, wIndex);
2840                 if (retval)
2841                     goto error;
2842                 break;
2843             }
2844         case GetHubDescriptor:{
2845                 retval = u132_roothub_descriptor(u132,
2846                     (struct usb_hub_descriptor *)buf);
2847                 if (retval)
2848                     goto error;
2849                 break;
2850             }
2851         case GetHubStatus:{
2852                 retval = u132_roothub_status(u132,
2853                     (__le32 *) buf);
2854                 if (retval)
2855                     goto error;
2856                 break;
2857             }
2858         case GetPortStatus:{
2859                 retval = u132_roothub_portstatus(u132,
2860                     (__le32 *) buf, wIndex);
2861                 if (retval)
2862                     goto error;
2863                 break;
2864             }
2865         case SetPortFeature:{
2866                 retval = u132_roothub_setportfeature(u132,
2867                     wValue, wIndex);
2868                 if (retval)
2869                     goto error;
2870                 break;
2871             }
2872         default:
2873             goto stall;
2874         error:
2875             u132_disable(u132);
2876             u132->going = 1;
2877             break;
2878         stall:
2879             retval = -EPIPE;
2880             break;
2881         }
2882         mutex_unlock(&u132->sw_lock);
2883         return retval;
2884     }
2885 }
2886
2887 static int u132_start_port_reset(struct usb_hcd *hcd, unsigned port_num)
2888 {
2889     struct u132 *u132 = hcd_to_u132(hcd);
2890     if (u132->going > 1) {
2891         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2892             , u132->going);
2893         return -ENODEV;
2894     } else if (u132->going > 0) {
2895         dev_err(&u132->platform_dev->dev, "device is being removed\n");
2896         return -ESHUTDOWN;
2897     } else
2898         return 0;
2899 }
2900
2901
2902 #ifdef CONFIG_PM
2903 static int u132_bus_suspend(struct usb_hcd *hcd)
2904 {
2905     struct u132 *u132 = hcd_to_u132(hcd);
2906     if (u132->going > 1) {
2907         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2908             , u132->going);
2909         return -ENODEV;
2910     } else if (u132->going > 0) {
2911         dev_err(&u132->platform_dev->dev, "device is being removed\n");
2912         return -ESHUTDOWN;
2913     } else
2914         return 0;
2915 }
2916
2917 static int u132_bus_resume(struct usb_hcd *hcd)
2918 {
2919     struct u132 *u132 = hcd_to_u132(hcd);
2920     if (u132->going > 1) {
2921         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
2922             , u132->going);
2923         return -ENODEV;
2924     } else if (u132->going > 0) {
2925         dev_err(&u132->platform_dev->dev, "device is being removed\n");
2926         return -ESHUTDOWN;
2927     } else
2928         return 0;
2929 }
2930
2931 #else
2932 #define u132_bus_suspend NULL
2933 #define u132_bus_resume NULL
2934 #endif
2935 static const struct hc_driver u132_hc_driver = {
2936     .description = hcd_name,
2937     .hcd_priv_size = sizeof(struct u132),
2938     .irq = NULL,
2939     .flags = HCD_USB11 | HCD_MEMORY,
2940     .reset = u132_hcd_reset,
2941     .start = u132_hcd_start,
2942     .stop = u132_hcd_stop,
2943     .urb_enqueue = u132_urb_enqueue,
2944     .urb_dequeue = u132_urb_dequeue,
2945     .endpoint_disable = u132_endpoint_disable,
2946     .get_frame_number = u132_get_frame,
2947     .hub_status_data = u132_hub_status_data,
2948     .hub_control = u132_hub_control,
2949     .bus_suspend = u132_bus_suspend,
2950     .bus_resume = u132_bus_resume,
2951     .start_port_reset = u132_start_port_reset,
2952 };
2953
2954 /*
2955 * This function may be called by the USB core whilst the "usb_all_devices_rwsem"
2956 * is held for writing, thus this module must not call usb_remove_hcd()
2957 * synchronously - but instead should immediately stop activity to the
2958 * device and asynchronously call usb_remove_hcd()
2959 */
2960 static int u132_remove(struct platform_device *pdev)
2961 {
2962     struct usb_hcd *hcd = platform_get_drvdata(pdev);
2963     if (hcd) {
2964         struct u132 *u132 = hcd_to_u132(hcd);
2965         if (u132->going++ > 1) {
2966             dev_err(&u132->platform_dev->dev, "already being remove"
2967                 "d\n");
2968             return -ENODEV;
2969         } else {
2970             int rings = MAX_U132_RINGS;
2971             int endps = MAX_U132_ENDPS;
2972             dev_err(&u132->platform_dev->dev, "removing device u132"
2973                 ".%d\n", u132->sequence_num);
2974             msleep(100);
2975             mutex_lock(&u132->sw_lock);
2976             u132_monitor_cancel_work(u132);
2977             while (rings-- > 0) {
2978                 struct u132_ring *ring = &u132->ring[rings];
2979                 u132_ring_cancel_work(u132, ring);
2980             }
2981             while (endps-- > 0) {
2982                 struct u132_endp *endp = u132->endp[endps];
2983                 if (endp)
2984                     u132_endp_cancel_work(u132, endp);
2985             }
2986             u132->going += 1;
2987             printk(KERN_INFO "removing device u132.%d\n",
2988                 u132->sequence_num);
2989             mutex_unlock(&u132->sw_lock);
2990             usb_remove_hcd(hcd);
2991             u132_u132_put_kref(u132);
2992             return 0;
2993         }
2994     } else
2995         return 0;
2996 }
2997
2998 static void u132_initialise(struct u132 *u132, struct platform_device *pdev)
2999 {
3000     int rings = MAX_U132_RINGS;
3001     int ports = MAX_U132_PORTS;
3002     int addrs = MAX_U132_ADDRS;
3003     int udevs = MAX_U132_UDEVS;
3004     int endps = MAX_U132_ENDPS;
3005     u132->board = dev_get_platdata(&pdev->dev);
3006     u132->platform_dev = pdev;
3007     u132->power = 0;
3008     u132->reset = 0;
3009     mutex_init(&u132->sw_lock);
3010     mutex_init(&u132->scheduler_lock);
3011     while (rings-- > 0) {
3012         struct u132_ring *ring = &u132->ring[rings];
3013         ring->u132 = u132;
3014         ring->number = rings + 1;
3015         ring->length = 0;
3016         ring->curr_endp = NULL;
3017         INIT_DELAYED_WORK(&ring->scheduler,
3018                   u132_hcd_ring_work_scheduler);
3019     }
3020     mutex_lock(&u132->sw_lock);
3021     INIT_DELAYED_WORK(&u132->monitor, u132_hcd_monitor_work);
3022     while (ports-- > 0) {
3023         struct u132_port *port = &u132->port[ports];
3024         port->u132 = u132;
3025         port->reset = 0;
3026         port->enable = 0;
3027         port->power = 0;
3028         port->Status = 0;
3029     }
3030     while (addrs-- > 0) {
3031         struct u132_addr *addr = &u132->addr[addrs];
3032         addr->address = 0;
3033     }
3034     while (udevs-- > 0) {
3035         struct u132_udev *udev = &u132->udev[udevs];
3036         int i = ARRAY_SIZE(udev->endp_number_in);
3037         int o = ARRAY_SIZE(udev->endp_number_out);
3038         udev->usb_device = NULL;
3039         udev->udev_number = 0;
3040         udev->usb_addr = 0;
3041         udev->portnumber = 0;
3042         while (i-- > 0)
3043             udev->endp_number_in[i] = 0;
3044
3045         while (o-- > 0)
3046             udev->endp_number_out[o] = 0;
3047
3048     }
3049     while (endps-- > 0)
3050         u132->endp[endps] = NULL;
3051
3052     mutex_unlock(&u132->sw_lock);
3053 }
3054
3055 static int u132_probe(struct platform_device *pdev)
3056 {
3057     struct usb_hcd *hcd;
3058     int retval;
3059     u32 control;
3060     u32 rh_a = -1;
3061
3062     msleep(100);
3063     if (u132_exiting > 0)
3064         return -ENODEV;
3065
3066     retval = ftdi_write_pcimem(pdev, intrdisable, OHCI_INTR_MIE);
3067     if (retval)
3068         return retval;
3069     retval = ftdi_read_pcimem(pdev, control, &control);
3070     if (retval)
3071         return retval;
3072     retval = ftdi_read_pcimem(pdev, roothub.a, &rh_a);
3073     if (retval)
3074         return retval;
3075
3076     hcd = usb_create_hcd(&u132_hc_driver, &pdev->dev, dev_name(&pdev->dev));
3077     if (!hcd) {
3078         printk(KERN_ERR "failed to create the usb hcd struct for U132\n"
3079             );
3080         ftdi_elan_gone_away(pdev);
3081         return -ENOMEM;
3082     } else {
3083         struct u132 *u132 = hcd_to_u132(hcd);
3084         retval = 0;
3085         hcd->rsrc_start = 0;
3086         mutex_lock(&u132_module_lock);
3087         u132->sequence_num = ++u132_instances;
3088         mutex_unlock(&u132_module_lock);
3089         u132_u132_init_kref(u132);
3090         u132_initialise(u132, pdev);
3091         hcd->product_desc = "ELAN U132 Host Controller";
3092         retval = usb_add_hcd(hcd, 0, 0);
3093         if (retval != 0) {
3094             dev_err(&u132->platform_dev->dev, "init error %d\n",
3095                 retval);
3096             u132_u132_put_kref(u132);
3097             return retval;
3098         } else {
3099             device_wakeup_enable(hcd->self.controller);
3100             u132_monitor_queue_work(u132, 100);
3101             return 0;
3102         }
3103     }
3104 }
3105
3106
3107 #ifdef CONFIG_PM
3108 /*
3109  * for this device there's no useful distinction between the controller
3110  * and its root hub.
3111  */
3112 static int u132_suspend(struct platform_device *pdev, pm_message_t state)
3113 {
3114     struct usb_hcd *hcd = platform_get_drvdata(pdev);
3115     struct u132 *u132 = hcd_to_u132(hcd);
3116     if (u132->going > 1) {
3117         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3118             , u132->going);
3119         return -ENODEV;
3120     } else if (u132->going > 0) {
3121         dev_err(&u132->platform_dev->dev, "device is being removed\n");
3122         return -ESHUTDOWN;
3123     } else {
3124         int retval = 0, ports;
3125
3126         switch (state.event) {
3127         case PM_EVENT_FREEZE:
3128             retval = u132_bus_suspend(hcd);
3129             break;
3130         case PM_EVENT_SUSPEND:
3131         case PM_EVENT_HIBERNATE:
3132             ports = MAX_U132_PORTS;
3133             while (ports-- > 0) {
3134                 port_power(u132, ports, 0);
3135             }
3136             break;
3137         }
3138         return retval;
3139     }
3140 }
3141
3142 static int u132_resume(struct platform_device *pdev)
3143 {
3144     struct usb_hcd *hcd = platform_get_drvdata(pdev);
3145     struct u132 *u132 = hcd_to_u132(hcd);
3146     if (u132->going > 1) {
3147         dev_err(&u132->platform_dev->dev, "device has been removed %d\n"
3148             , u132->going);
3149         return -ENODEV;
3150     } else if (u132->going > 0) {
3151         dev_err(&u132->platform_dev->dev, "device is being removed\n");
3152         return -ESHUTDOWN;
3153     } else {
3154         int retval = 0;
3155         if (!u132->port[0].power) {
3156             int ports = MAX_U132_PORTS;
3157             while (ports-- > 0) {
3158                 port_power(u132, ports, 1);
3159             }
3160             retval = 0;
3161         } else {
3162             retval = u132_bus_resume(hcd);
3163         }
3164         return retval;
3165     }
3166 }
3167
3168 #else
3169 #define u132_suspend NULL
3170 #define u132_resume NULL
3171 #endif
3172 /*
3173 * this driver is loaded explicitly by ftdi_u132
3174 *
3175 * the platform_driver struct is static because it is per type of module
3176 */
3177 static struct platform_driver u132_platform_driver = {
3178     .probe = u132_probe,
3179     .remove = u132_remove,
3180     .suspend = u132_suspend,
3181     .resume = u132_resume,
3182     .driver = {
3183            .name = hcd_name,
3184            },
3185 };
3186 static int __init u132_hcd_init(void)
3187 {
3188     int retval;
3189     u132_instances = 0;
3190     u132_exiting = 0;
3191     if (usb_disabled())
3192         return -ENODEV;
3193     printk(KERN_INFO "driver %s\n", hcd_name);
3194     workqueue = create_singlethread_workqueue("u132");
3195     if (!workqueue)
3196         return -ENOMEM;
3197     retval = platform_driver_register(&u132_platform_driver);
3198     if (retval)
3199         destroy_workqueue(workqueue);
3200
3201     return retval;
3202 }
3203
3204
3205 module_init(u132_hcd_init);
3206 static void __exit u132_hcd_exit(void)
3207 {
3208     mutex_lock(&u132_module_lock);
3209     u132_exiting += 1;
3210     mutex_unlock(&u132_module_lock);
3211     platform_driver_unregister(&u132_platform_driver);
3212     printk(KERN_INFO "u132-hcd driver deregistered\n");
3213     wait_event(u132_hcd_wait, u132_instances == 0);
3214     destroy_workqueue(workqueue);
3215 }
3216
3217
3218 module_exit(u132_hcd_exit);
3219 MODULE_LICENSE("GPL");
3220 MODULE_ALIAS("platform:u132_hcd");