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