drivers/usb/host/u132-hcd.c

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