drivers/usb/host/u132-hcd.c

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