drivers/usb/host/u132-hcd.c

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