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