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