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