drivers/usb/host/max3421-hcd.c

   1 /*
   2  * MAX3421 Host Controller driver for USB.
   3  *
   4  * Author: David Mosberger-Tang <davidm@egauge.net>
   5  *
   6  * (C) Copyright 2014 David Mosberger-Tang <davidm@egauge.net>
   7  *
   8  * MAX3421 is a chip implementing a USB 2.0 Full-/Low-Speed host
   9  * controller on a SPI bus.
  10  *
  11  * Based on:
  12  *      o MAX3421E datasheet
  13  *              http://datasheets.maximintegrated.com/en/ds/MAX3421E.pdf
  14  *      o MAX3421E Programming Guide
  15  *              http://www.hdl.co.jp/ftpdata/utl-001/AN3785.pdf
  16  *      o gadget/dummy_hcd.c
  17  *              For USB HCD implementation.
  18  *      o Arduino MAX3421 driver
  19  *           https://github.com/felis/USB_Host_Shield_2.0/blob/master/Usb.cpp
  20  *
  21  * This file is licenced under the GPL v2.
  22  *
  23  * Important note on worst-case (full-speed) packet size constraints
  24  * (See USB 2.0 Section 5.6.3 and following):
  25  *
  26  *      - control:        64 bytes
  27  *      - isochronous:  1023 bytes
  28  *      - interrupt:      64 bytes
  29  *      - bulk:           64 bytes
  30  *
  31  * Since the MAX3421 FIFO size is 64 bytes, we do not have to work about
  32  * multi-FIFO writes/reads for a single USB packet *except* for isochronous
  33  * transfers.  We don't support isochronous transfers at this time, so we
  34  * just assume that a USB packet always fits into a single FIFO buffer.
  35  *
  36  * NOTE: The June 2006 version of "MAX3421E Programming Guide"
  37  * (AN3785) has conflicting info for the RCVDAVIRQ bit:
  38  *
  39  *      The description of RCVDAVIRQ says "The CPU *must* clear
  40  *      this IRQ bit (by writing a 1 to it) before reading the
  41  *      RCVFIFO data.
  42  *
  43  * However, the earlier section on "Programming BULK-IN
  44  * Transfers" says * that:
  45  *
  46  *      After the CPU retrieves the data, it clears the
  47  *      RCVDAVIRQ bit.
  48  *
  49  * The December 2006 version has been corrected and it consistently
  50  * states the second behavior is the correct one.
  51  *
  52  * Synchronous SPI transactions sleep so we can't perform any such
  53  * transactions while holding a spin-lock (and/or while interrupts are
  54  * masked).  To achieve this, all SPI transactions are issued from a
  55  * single thread (max3421_spi_thread).
  56  */
  57
  58 #include <linux/jiffies.h>
  59 #include <linux/module.h>
  60 #include <linux/spi/spi.h>
  61 #include <linux/usb.h>
  62 #include <linux/usb/hcd.h>
  63
  64 #include <linux/platform_data/max3421-hcd.h>
  65
  66 #define DRIVER_DESC     "MAX3421 USB Host-Controller Driver"
  67 #define DRIVER_VERSION  "1.0"
  68
  69 /* 11-bit counter that wraps around (USB 2.0 Section 8.3.3): */
  70 #define USB_MAX_FRAME_NUMBER    0x7ff
  71 #define USB_MAX_RETRIES         3 /* # of retries before error is reported */
  72
  73 /*
  74  * Max. # of times we're willing to retransmit a request immediately in
  75  * resposne to a NAK.  Afterwards, we fall back on trying once a frame.
  76  */
  77 #define NAK_MAX_FAST_RETRANSMITS        2
  78
  79 #define POWER_BUDGET    500     /* in mA; use 8 for low-power port testing */
  80
  81 /* Port-change mask: */
  82 #define PORT_C_MASK     ((USB_PORT_STAT_C_CONNECTION |  \
  83                           USB_PORT_STAT_C_ENABLE |      \
  84                           USB_PORT_STAT_C_SUSPEND |     \
  85                           USB_PORT_STAT_C_OVERCURRENT | \
  86                           USB_PORT_STAT_C_RESET) << 16)
  87
  88 enum max3421_rh_state {
  89         MAX3421_RH_RESET,
  90         MAX3421_RH_SUSPENDED,
  91         MAX3421_RH_RUNNING
  92 };
  93
  94 enum pkt_state {
  95         PKT_STATE_SETUP,        /* waiting to send setup packet to ctrl pipe */
  96         PKT_STATE_TRANSFER,     /* waiting to xfer transfer_buffer */
  97         PKT_STATE_TERMINATE     /* waiting to terminate control transfer */
  98 };
  99
 100 enum scheduling_pass {
 101         SCHED_PASS_PERIODIC,
 102         SCHED_PASS_NON_PERIODIC,
 103         SCHED_PASS_DONE
 104 };
 105
 106 /* Bit numbers for max3421_hcd->todo: */
 107 enum {
 108         ENABLE_IRQ = 0,
 109         RESET_HCD,
 110         RESET_PORT,
 111         CHECK_UNLINK,
 112         IOPIN_UPDATE
 113 };
 114
 115 struct max3421_dma_buf {
 116         u8 data[2];
 117 };
 118
 119 struct max3421_hcd {
 120         spinlock_t lock;
 121
 122         struct task_struct *spi_thread;
 123
 124         enum max3421_rh_state rh_state;
 125         /* lower 16 bits contain port status, upper 16 bits the change mask: */
 126         u32 port_status;
 127
 128         unsigned active:1;
 129
 130         struct list_head ep_list;       /* list of EP's with work */
 131
 132         /*
 133          * The following are owned by spi_thread (may be accessed by
 134          * SPI-thread without acquiring the HCD lock:
 135          */
 136         u8 rev;                         /* chip revision */
 137         u16 frame_number;
 138         /*
 139          * kmalloc'd buffers guaranteed to be in separate (DMA)
 140          * cache-lines:
 141          */
 142         struct max3421_dma_buf *tx;
 143         struct max3421_dma_buf *rx;
 144         /*
 145          * URB we're currently processing.  Must not be reset to NULL
 146          * unless MAX3421E chip is idle:
 147          */
 148         struct urb *curr_urb;
 149         enum scheduling_pass sched_pass;
 150         int urb_done;                   /* > 0 -> no errors, < 0: errno */
 151         size_t curr_len;
 152         u8 hien;
 153         u8 mode;
 154         u8 iopins[2];
 155         unsigned long todo;
 156 #ifdef DEBUG
 157         unsigned long err_stat[16];
 158 #endif
 159 };
 160
 161 struct max3421_ep {
 162         struct usb_host_endpoint *ep;
 163         struct list_head ep_list;
 164         u32 naks;
 165         u16 last_active;                /* frame # this ep was last active */
 166         enum pkt_state pkt_state;
 167         u8 retries;
 168         u8 retransmit;                  /* packet needs retransmission */
 169 };
 170
 171 #define MAX3421_FIFO_SIZE       64
 172
 173 #define MAX3421_SPI_DIR_RD      0       /* read register from MAX3421 */
 174 #define MAX3421_SPI_DIR_WR      1       /* write register to MAX3421 */
 175
 176 /* SPI commands: */
 177 #define MAX3421_SPI_DIR_SHIFT   1
 178 #define MAX3421_SPI_REG_SHIFT   3
 179
 180 #define MAX3421_REG_RCVFIFO     1
 181 #define MAX3421_REG_SNDFIFO     2
 182 #define MAX3421_REG_SUDFIFO     4
 183 #define MAX3421_REG_RCVBC       6
 184 #define MAX3421_REG_SNDBC       7
 185 #define MAX3421_REG_USBIRQ      13
 186 #define MAX3421_REG_USBIEN      14
 187 #define MAX3421_REG_USBCTL      15
 188 #define MAX3421_REG_CPUCTL      16
 189 #define MAX3421_REG_PINCTL      17
 190 #define MAX3421_REG_REVISION    18
 191 #define MAX3421_REG_IOPINS1     20
 192 #define MAX3421_REG_IOPINS2     21
 193 #define MAX3421_REG_GPINIRQ     22
 194 #define MAX3421_REG_GPINIEN     23
 195 #define MAX3421_REG_GPINPOL     24
 196 #define MAX3421_REG_HIRQ        25
 197 #define MAX3421_REG_HIEN        26
 198 #define MAX3421_REG_MODE        27
 199 #define MAX3421_REG_PERADDR     28
 200 #define MAX3421_REG_HCTL        29
 201 #define MAX3421_REG_HXFR        30
 202 #define MAX3421_REG_HRSL        31
 203
 204 enum {
 205         MAX3421_USBIRQ_OSCOKIRQ_BIT = 0,
 206         MAX3421_USBIRQ_NOVBUSIRQ_BIT = 5,
 207         MAX3421_USBIRQ_VBUSIRQ_BIT
 208 };
 209
 210 enum {
 211         MAX3421_CPUCTL_IE_BIT = 0,
 212         MAX3421_CPUCTL_PULSEWID0_BIT = 6,
 213         MAX3421_CPUCTL_PULSEWID1_BIT
 214 };
 215
 216 enum {
 217         MAX3421_USBCTL_PWRDOWN_BIT = 4,
 218         MAX3421_USBCTL_CHIPRES_BIT
 219 };
 220
 221 enum {
 222         MAX3421_PINCTL_GPXA_BIT = 0,
 223         MAX3421_PINCTL_GPXB_BIT,
 224         MAX3421_PINCTL_POSINT_BIT,
 225         MAX3421_PINCTL_INTLEVEL_BIT,
 226         MAX3421_PINCTL_FDUPSPI_BIT,
 227         MAX3421_PINCTL_EP0INAK_BIT,
 228         MAX3421_PINCTL_EP2INAK_BIT,
 229         MAX3421_PINCTL_EP3INAK_BIT,
 230 };
 231
 232 enum {
 233         MAX3421_HI_BUSEVENT_BIT = 0,    /* bus-reset/-resume */
 234         MAX3421_HI_RWU_BIT,             /* remote wakeup */
 235         MAX3421_HI_RCVDAV_BIT,          /* receive FIFO data available */
 236         MAX3421_HI_SNDBAV_BIT,          /* send buffer available */
 237         MAX3421_HI_SUSDN_BIT,           /* suspend operation done */
 238         MAX3421_HI_CONDET_BIT,          /* peripheral connect/disconnect */
 239         MAX3421_HI_FRAME_BIT,           /* frame generator */
 240         MAX3421_HI_HXFRDN_BIT,          /* host transfer done */
 241 };
 242
 243 enum {
 244         MAX3421_HCTL_BUSRST_BIT = 0,
 245         MAX3421_HCTL_FRMRST_BIT,
 246         MAX3421_HCTL_SAMPLEBUS_BIT,
 247         MAX3421_HCTL_SIGRSM_BIT,
 248         MAX3421_HCTL_RCVTOG0_BIT,
 249         MAX3421_HCTL_RCVTOG1_BIT,
 250         MAX3421_HCTL_SNDTOG0_BIT,
 251         MAX3421_HCTL_SNDTOG1_BIT
 252 };
 253
 254 enum {
 255         MAX3421_MODE_HOST_BIT = 0,
 256         MAX3421_MODE_LOWSPEED_BIT,
 257         MAX3421_MODE_HUBPRE_BIT,
 258         MAX3421_MODE_SOFKAENAB_BIT,
 259         MAX3421_MODE_SEPIRQ_BIT,
 260         MAX3421_MODE_DELAYISO_BIT,
 261         MAX3421_MODE_DMPULLDN_BIT,
 262         MAX3421_MODE_DPPULLDN_BIT
 263 };
 264
 265 enum {
 266         MAX3421_HRSL_OK = 0,
 267         MAX3421_HRSL_BUSY,
 268         MAX3421_HRSL_BADREQ,
 269         MAX3421_HRSL_UNDEF,
 270         MAX3421_HRSL_NAK,
 271         MAX3421_HRSL_STALL,
 272         MAX3421_HRSL_TOGERR,
 273         MAX3421_HRSL_WRONGPID,
 274         MAX3421_HRSL_BADBC,
 275         MAX3421_HRSL_PIDERR,
 276         MAX3421_HRSL_PKTERR,
 277         MAX3421_HRSL_CRCERR,
 278         MAX3421_HRSL_KERR,
 279         MAX3421_HRSL_JERR,
 280         MAX3421_HRSL_TIMEOUT,
 281         MAX3421_HRSL_BABBLE,
 282         MAX3421_HRSL_RESULT_MASK = 0xf,
 283         MAX3421_HRSL_RCVTOGRD_BIT = 4,
 284         MAX3421_HRSL_SNDTOGRD_BIT,
 285         MAX3421_HRSL_KSTATUS_BIT,
 286         MAX3421_HRSL_JSTATUS_BIT
 287 };
 288
 289 /* Return same error-codes as ohci.h:cc_to_error: */
 290 static const int hrsl_to_error[] = {
 291         [MAX3421_HRSL_OK] =             0,
 292         [MAX3421_HRSL_BUSY] =           -EINVAL,
 293         [MAX3421_HRSL_BADREQ] =         -EINVAL,
 294         [MAX3421_HRSL_UNDEF] =          -EINVAL,
 295         [MAX3421_HRSL_NAK] =            -EAGAIN,
 296         [MAX3421_HRSL_STALL] =          -EPIPE,
 297         [MAX3421_HRSL_TOGERR] =         -EILSEQ,
 298         [MAX3421_HRSL_WRONGPID] =       -EPROTO,
 299         [MAX3421_HRSL_BADBC] =          -EREMOTEIO,
 300         [MAX3421_HRSL_PIDERR] =         -EPROTO,
 301         [MAX3421_HRSL_PKTERR] =         -EPROTO,
 302         [MAX3421_HRSL_CRCERR] =         -EILSEQ,
 303         [MAX3421_HRSL_KERR] =           -EIO,
 304         [MAX3421_HRSL_JERR] =           -EIO,
 305         [MAX3421_HRSL_TIMEOUT] =        -ETIME,
 306         [MAX3421_HRSL_BABBLE] =         -EOVERFLOW
 307 };
 308
 309 /*
 310  * See http://www.beyondlogic.org/usbnutshell/usb4.shtml#Control for a
 311  * reasonable overview of how control transfers use the the IN/OUT
 312  * tokens.
 313  */
 314 #define MAX3421_HXFR_BULK_IN(ep)        (0x00 | (ep))   /* bulk or interrupt */
 315 #define MAX3421_HXFR_SETUP               0x10
 316 #define MAX3421_HXFR_BULK_OUT(ep)       (0x20 | (ep))   /* bulk or interrupt */
 317 #define MAX3421_HXFR_ISO_IN(ep)         (0x40 | (ep))
 318 #define MAX3421_HXFR_ISO_OUT(ep)        (0x60 | (ep))
 319 #define MAX3421_HXFR_HS_IN               0x80           /* handshake in */
 320 #define MAX3421_HXFR_HS_OUT              0xa0           /* handshake out */
 321
 322 #define field(val, bit) ((val) << (bit))
 323
 324 static inline s16
 325 frame_diff(u16 left, u16 right)
 326 {
 327         return ((unsigned) (left - right)) % (USB_MAX_FRAME_NUMBER + 1);
 328 }
 329
 330 static inline struct max3421_hcd *
 331 hcd_to_max3421(struct usb_hcd *hcd)
 332 {
 333         return (struct max3421_hcd *) hcd->hcd_priv;
 334 }
 335
 336 static inline struct usb_hcd *
 337 max3421_to_hcd(struct max3421_hcd *max3421_hcd)
 338 {
 339         return container_of((void *) max3421_hcd, struct usb_hcd, hcd_priv);
 340 }
 341
 342 static u8
 343 spi_rd8(struct usb_hcd *hcd, unsigned int reg)
 344 {
 345         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 346         struct spi_device *spi = to_spi_device(hcd->self.controller);
 347         struct spi_transfer transfer;
 348         struct spi_message msg;
 349
 350         memset(&transfer, 0, sizeof(transfer));
 351
 352         spi_message_init(&msg);
 353
 354         max3421_hcd->tx->data[0] =
 355                 (field(reg, MAX3421_SPI_REG_SHIFT) |
 356                  field(MAX3421_SPI_DIR_RD, MAX3421_SPI_DIR_SHIFT));
 357
 358         transfer.tx_buf = max3421_hcd->tx->data;
 359         transfer.rx_buf = max3421_hcd->rx->data;
 360         transfer.len = 2;
 361
 362         spi_message_add_tail(&transfer, &msg);
 363         spi_sync(spi, &msg);
 364
 365         return max3421_hcd->rx->data[1];
 366 }
 367
 368 static void
 369 spi_wr8(struct usb_hcd *hcd, unsigned int reg, u8 val)
 370 {
 371         struct spi_device *spi = to_spi_device(hcd->self.controller);
 372         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 373         struct spi_transfer transfer;
 374         struct spi_message msg;
 375
 376         memset(&transfer, 0, sizeof(transfer));
 377
 378         spi_message_init(&msg);
 379
 380         max3421_hcd->tx->data[0] =
 381                 (field(reg, MAX3421_SPI_REG_SHIFT) |
 382                  field(MAX3421_SPI_DIR_WR, MAX3421_SPI_DIR_SHIFT));
 383         max3421_hcd->tx->data[1] = val;
 384
 385         transfer.tx_buf = max3421_hcd->tx->data;
 386         transfer.len = 2;
 387
 388         spi_message_add_tail(&transfer, &msg);
 389         spi_sync(spi, &msg);
 390 }
 391
 392 static void
 393 spi_rd_buf(struct usb_hcd *hcd, unsigned int reg, void *buf, size_t len)
 394 {
 395         struct spi_device *spi = to_spi_device(hcd->self.controller);
 396         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 397         struct spi_transfer transfer[2];
 398         struct spi_message msg;
 399
 400         memset(transfer, 0, sizeof(transfer));
 401
 402         spi_message_init(&msg);
 403
 404         max3421_hcd->tx->data[0] =
 405                 (field(reg, MAX3421_SPI_REG_SHIFT) |
 406                  field(MAX3421_SPI_DIR_RD, MAX3421_SPI_DIR_SHIFT));
 407         transfer[0].tx_buf = max3421_hcd->tx->data;
 408         transfer[0].len = 1;
 409
 410         transfer[1].rx_buf = buf;
 411         transfer[1].len = len;
 412
 413         spi_message_add_tail(&transfer[0], &msg);
 414         spi_message_add_tail(&transfer[1], &msg);
 415         spi_sync(spi, &msg);
 416 }
 417
 418 static void
 419 spi_wr_buf(struct usb_hcd *hcd, unsigned int reg, void *buf, size_t len)
 420 {
 421         struct spi_device *spi = to_spi_device(hcd->self.controller);
 422         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 423         struct spi_transfer transfer[2];
 424         struct spi_message msg;
 425
 426         memset(transfer, 0, sizeof(transfer));
 427
 428         spi_message_init(&msg);
 429
 430         max3421_hcd->tx->data[0] =
 431                 (field(reg, MAX3421_SPI_REG_SHIFT) |
 432                  field(MAX3421_SPI_DIR_WR, MAX3421_SPI_DIR_SHIFT));
 433
 434         transfer[0].tx_buf = max3421_hcd->tx->data;
 435         transfer[0].len = 1;
 436
 437         transfer[1].tx_buf = buf;
 438         transfer[1].len = len;
 439
 440         spi_message_add_tail(&transfer[0], &msg);
 441         spi_message_add_tail(&transfer[1], &msg);
 442         spi_sync(spi, &msg);
 443 }
 444
 445 /*
 446  * Figure out the correct setting for the LOWSPEED and HUBPRE mode
 447  * bits.  The HUBPRE bit needs to be set when MAX3421E operates at
 448  * full speed, but it's talking to a low-speed device (i.e., through a
 449  * hub).  Setting that bit ensures that every low-speed packet is
 450  * preceded by a full-speed PRE PID.  Possible configurations:
 451  *
 452  * Hub speed:   Device speed:   =>      LOWSPEED bit:   HUBPRE bit:
 453  *      FULL    FULL            =>      0               0
 454  *      FULL    LOW             =>      1               1
 455  *      LOW     LOW             =>      1               0
 456  *      LOW     FULL            =>      1               0
 457  */
 458 static void
 459 max3421_set_speed(struct usb_hcd *hcd, struct usb_device *dev)
 460 {
 461         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 462         u8 mode_lowspeed, mode_hubpre, mode = max3421_hcd->mode;
 463
 464         mode_lowspeed = BIT(MAX3421_MODE_LOWSPEED_BIT);
 465         mode_hubpre   = BIT(MAX3421_MODE_HUBPRE_BIT);
 466         if (max3421_hcd->port_status & USB_PORT_STAT_LOW_SPEED) {
 467                 mode |=  mode_lowspeed;
 468                 mode &= ~mode_hubpre;
 469         } else if (dev->speed == USB_SPEED_LOW) {
 470                 mode |= mode_lowspeed | mode_hubpre;
 471         } else {
 472                 mode &= ~(mode_lowspeed | mode_hubpre);
 473         }
 474         if (mode != max3421_hcd->mode) {
 475                 max3421_hcd->mode = mode;
 476                 spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
 477         }
 478
 479 }
 480
 481 /*
 482  * Caller must NOT hold HCD spinlock.
 483  */
 484 static void
 485 max3421_set_address(struct usb_hcd *hcd, struct usb_device *dev, int epnum)
 486 {
 487         int rcvtog, sndtog;
 488         u8 hctl;
 489
 490         /* setup new endpoint's toggle bits: */
 491         rcvtog = usb_gettoggle(dev, epnum, 0);
 492         sndtog = usb_gettoggle(dev, epnum, 1);
 493         hctl = (BIT(rcvtog + MAX3421_HCTL_RCVTOG0_BIT) |
 494                 BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT));
 495
 496         spi_wr8(hcd, MAX3421_REG_HCTL, hctl);
 497
 498         /*
 499          * Note: devnum for one and the same device can change during
 500          * address-assignment so it's best to just always load the
 501          * address whenever the end-point changed/was forced.
 502          */
 503         spi_wr8(hcd, MAX3421_REG_PERADDR, dev->devnum);
 504 }
 505
 506 static int
 507 max3421_ctrl_setup(struct usb_hcd *hcd, struct urb *urb)
 508 {
 509         spi_wr_buf(hcd, MAX3421_REG_SUDFIFO, urb->setup_packet, 8);
 510         return MAX3421_HXFR_SETUP;
 511 }
 512
 513 static int
 514 max3421_transfer_in(struct usb_hcd *hcd, struct urb *urb)
 515 {
 516         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 517         int epnum = usb_pipeendpoint(urb->pipe);
 518
 519         max3421_hcd->curr_len = 0;
 520         max3421_hcd->hien |= BIT(MAX3421_HI_RCVDAV_BIT);
 521         return MAX3421_HXFR_BULK_IN(epnum);
 522 }
 523
 524 static int
 525 max3421_transfer_out(struct usb_hcd *hcd, struct urb *urb, int fast_retransmit)
 526 {
 527         struct spi_device *spi = to_spi_device(hcd->self.controller);
 528         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 529         int epnum = usb_pipeendpoint(urb->pipe);
 530         u32 max_packet;
 531         void *src;
 532
 533         src = urb->transfer_buffer + urb->actual_length;
 534
 535         if (fast_retransmit) {
 536                 if (max3421_hcd->rev == 0x12) {
 537                         /* work around rev 0x12 bug: */
 538                         spi_wr8(hcd, MAX3421_REG_SNDBC, 0);
 539                         spi_wr8(hcd, MAX3421_REG_SNDFIFO, ((u8 *) src)[0]);
 540                         spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len);
 541                 }
 542                 return MAX3421_HXFR_BULK_OUT(epnum);
 543         }
 544
 545         max_packet = usb_maxpacket(urb->dev, urb->pipe, 1);
 546
 547         if (max_packet > MAX3421_FIFO_SIZE) {
 548                 /*
 549                  * We do not support isochronous transfers at this
 550                  * time.
 551                  */
 552                 dev_err(&spi->dev,
 553                         "%s: packet-size of %u too big (limit is %u bytes)",
 554                         __func__, max_packet, MAX3421_FIFO_SIZE);
 555                 max3421_hcd->urb_done = -EMSGSIZE;
 556                 return -EMSGSIZE;
 557         }
 558         max3421_hcd->curr_len = min((urb->transfer_buffer_length -
 559                                      urb->actual_length), max_packet);
 560
 561         spi_wr_buf(hcd, MAX3421_REG_SNDFIFO, src, max3421_hcd->curr_len);
 562         spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len);
 563         return MAX3421_HXFR_BULK_OUT(epnum);
 564 }
 565
 566 /*
 567  * Issue the next host-transfer command.
 568  * Caller must NOT hold HCD spinlock.
 569  */
 570 static void
 571 max3421_next_transfer(struct usb_hcd *hcd, int fast_retransmit)
 572 {
 573         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 574         struct urb *urb = max3421_hcd->curr_urb;
 575         struct max3421_ep *max3421_ep;
 576         int cmd = -EINVAL;
 577
 578         if (!urb)
 579                 return; /* nothing to do */
 580
 581         max3421_ep = urb->ep->hcpriv;
 582
 583         switch (max3421_ep->pkt_state) {
 584         case PKT_STATE_SETUP:
 585                 cmd = max3421_ctrl_setup(hcd, urb);
 586                 break;
 587
 588         case PKT_STATE_TRANSFER:
 589                 if (usb_urb_dir_in(urb))
 590                         cmd = max3421_transfer_in(hcd, urb);
 591                 else
 592                         cmd = max3421_transfer_out(hcd, urb, fast_retransmit);
 593                 break;
 594
 595         case PKT_STATE_TERMINATE:
 596                 /*
 597                  * IN transfers are terminated with HS_OUT token,
 598                  * OUT transfers with HS_IN:
 599                  */
 600                 if (usb_urb_dir_in(urb))
 601                         cmd = MAX3421_HXFR_HS_OUT;
 602                 else
 603                         cmd = MAX3421_HXFR_HS_IN;
 604                 break;
 605         }
 606
 607         if (cmd < 0)
 608                 return;
 609
 610         /* issue the command and wait for host-xfer-done interrupt: */
 611
 612         spi_wr8(hcd, MAX3421_REG_HXFR, cmd);
 613         max3421_hcd->hien |= BIT(MAX3421_HI_HXFRDN_BIT);
 614 }
 615
 616 /*
 617  * Find the next URB to process and start its execution.
 618  *
 619  * At this time, we do not anticipate ever connecting a USB hub to the
 620  * MAX3421 chip, so at most USB device can be connected and we can use
 621  * a simplistic scheduler: at the start of a frame, schedule all
 622  * periodic transfers.  Once that is done, use the remainder of the
 623  * frame to process non-periodic (bulk & control) transfers.
 624  *
 625  * Preconditions:
 626  * o Caller must NOT hold HCD spinlock.
 627  * o max3421_hcd->curr_urb MUST BE NULL.
 628  * o MAX3421E chip must be idle.
 629  */
 630 static int
 631 max3421_select_and_start_urb(struct usb_hcd *hcd)
 632 {
 633         struct spi_device *spi = to_spi_device(hcd->self.controller);
 634         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 635         struct urb *urb, *curr_urb = NULL;
 636         struct max3421_ep *max3421_ep;
 637         int epnum;
 638         struct usb_host_endpoint *ep;
 639         struct list_head *pos;
 640         unsigned long flags;
 641
 642         spin_lock_irqsave(&max3421_hcd->lock, flags);
 643
 644         for (;
 645              max3421_hcd->sched_pass < SCHED_PASS_DONE;
 646              ++max3421_hcd->sched_pass)
 647                 list_for_each(pos, &max3421_hcd->ep_list) {
 648                         urb = NULL;
 649                         max3421_ep = container_of(pos, struct max3421_ep,
 650                                                   ep_list);
 651                         ep = max3421_ep->ep;
 652
 653                         switch (usb_endpoint_type(&ep->desc)) {
 654                         case USB_ENDPOINT_XFER_ISOC:
 655                         case USB_ENDPOINT_XFER_INT:
 656                                 if (max3421_hcd->sched_pass !=
 657                                     SCHED_PASS_PERIODIC)
 658                                         continue;
 659                                 break;
 660
 661                         case USB_ENDPOINT_XFER_CONTROL:
 662                         case USB_ENDPOINT_XFER_BULK:
 663                                 if (max3421_hcd->sched_pass !=
 664                                     SCHED_PASS_NON_PERIODIC)
 665                                         continue;
 666                                 break;
 667                         }
 668
 669                         if (list_empty(&ep->urb_list))
 670                                 continue;       /* nothing to do */
 671                         urb = list_first_entry(&ep->urb_list, struct urb,
 672                                                urb_list);
 673                         if (urb->unlinked) {
 674                                 dev_dbg(&spi->dev, "%s: URB %p unlinked=%d",
 675                                         __func__, urb, urb->unlinked);
 676                                 max3421_hcd->curr_urb = urb;
 677                                 max3421_hcd->urb_done = 1;
 678                                 spin_unlock_irqrestore(&max3421_hcd->lock,
 679                                                        flags);
 680                                 return 1;
 681                         }
 682
 683                         switch (usb_endpoint_type(&ep->desc)) {
 684                         case USB_ENDPOINT_XFER_CONTROL:
 685                                 /*
 686                                  * Allow one control transaction per
 687                                  * frame per endpoint:
 688                                  */
 689                                 if (frame_diff(max3421_ep->last_active,
 690                                                max3421_hcd->frame_number) == 0)
 691                                         continue;
 692                                 break;
 693
 694                         case USB_ENDPOINT_XFER_BULK:
 695                                 if (max3421_ep->retransmit
 696                                     && (frame_diff(max3421_ep->last_active,
 697                                                    max3421_hcd->frame_number)
 698                                         == 0))
 699                                         /*
 700                                          * We already tried this EP
 701                                          * during this frame and got a
 702                                          * NAK or error; wait for next frame
 703                                          */
 704                                         continue;
 705                                 break;
 706
 707                         case USB_ENDPOINT_XFER_ISOC:
 708                         case USB_ENDPOINT_XFER_INT:
 709                                 if (frame_diff(max3421_hcd->frame_number,
 710                                                max3421_ep->last_active)
 711                                     < urb->interval)
 712                                         /*
 713                                          * We already processed this
 714                                          * end-point in the current
 715                                          * frame
 716                                          */
 717                                         continue;
 718                                 break;
 719                         }
 720
 721                         /* move current ep to tail: */
 722                         list_move_tail(pos, &max3421_hcd->ep_list);
 723                         curr_urb = urb;
 724                         goto done;
 725                 }
 726 done:
 727         if (!curr_urb) {
 728                 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
 729                 return 0;
 730         }
 731
 732         urb = max3421_hcd->curr_urb = curr_urb;
 733         epnum = usb_endpoint_num(&urb->ep->desc);
 734         if (max3421_ep->retransmit)
 735                 /* restart (part of) a USB transaction: */
 736                 max3421_ep->retransmit = 0;
 737         else {
 738                 /* start USB transaction: */
 739                 if (usb_endpoint_xfer_control(&ep->desc)) {
 740                         /*
 741                          * See USB 2.0 spec section 8.6.1
 742                          * Initialization via SETUP Token:
 743                          */
 744                         usb_settoggle(urb->dev, epnum, 0, 1);
 745                         usb_settoggle(urb->dev, epnum, 1, 1);
 746                         max3421_ep->pkt_state = PKT_STATE_SETUP;
 747                 } else
 748                         max3421_ep->pkt_state = PKT_STATE_TRANSFER;
 749         }
 750
 751         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
 752
 753         max3421_ep->last_active = max3421_hcd->frame_number;
 754         max3421_set_address(hcd, urb->dev, epnum);
 755         max3421_set_speed(hcd, urb->dev);
 756         max3421_next_transfer(hcd, 0);
 757         return 1;
 758 }
 759
 760 /*
 761  * Check all endpoints for URBs that got unlinked.
 762  *
 763  * Caller must NOT hold HCD spinlock.
 764  */
 765 static int
 766 max3421_check_unlink(struct usb_hcd *hcd)
 767 {
 768         struct spi_device *spi = to_spi_device(hcd->self.controller);
 769         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 770         struct max3421_ep *max3421_ep;
 771         struct usb_host_endpoint *ep;
 772         struct urb *urb, *next;
 773         unsigned long flags;
 774         int retval = 0;
 775
 776         spin_lock_irqsave(&max3421_hcd->lock, flags);
 777         list_for_each_entry(max3421_ep, &max3421_hcd->ep_list, ep_list) {
 778                 ep = max3421_ep->ep;
 779                 list_for_each_entry_safe(urb, next, &ep->urb_list, urb_list) {
 780                         if (urb->unlinked) {
 781                                 retval = 1;
 782                                 dev_dbg(&spi->dev, "%s: URB %p unlinked=%d",
 783                                         __func__, urb, urb->unlinked);
 784                                 usb_hcd_unlink_urb_from_ep(hcd, urb);
 785                                 spin_unlock_irqrestore(&max3421_hcd->lock,
 786                                                        flags);
 787                                 usb_hcd_giveback_urb(hcd, urb, 0);
 788                                 spin_lock_irqsave(&max3421_hcd->lock, flags);
 789                         }
 790                 }
 791         }
 792         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
 793         return retval;
 794 }
 795
 796 /*
 797  * Caller must NOT hold HCD spinlock.
 798  */
 799 static void
 800 max3421_slow_retransmit(struct usb_hcd *hcd)
 801 {
 802         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 803         struct urb *urb = max3421_hcd->curr_urb;
 804         struct max3421_ep *max3421_ep;
 805
 806         max3421_ep = urb->ep->hcpriv;
 807         max3421_ep->retransmit = 1;
 808         max3421_hcd->curr_urb = NULL;
 809 }
 810
 811 /*
 812  * Caller must NOT hold HCD spinlock.
 813  */
 814 static void
 815 max3421_recv_data_available(struct usb_hcd *hcd)
 816 {
 817         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 818         struct urb *urb = max3421_hcd->curr_urb;
 819         size_t remaining, transfer_size;
 820         u8 rcvbc;
 821
 822         rcvbc = spi_rd8(hcd, MAX3421_REG_RCVBC);
 823
 824         if (rcvbc > MAX3421_FIFO_SIZE)
 825                 rcvbc = MAX3421_FIFO_SIZE;
 826         if (urb->actual_length >= urb->transfer_buffer_length)
 827                 remaining = 0;
 828         else
 829                 remaining = urb->transfer_buffer_length - urb->actual_length;
 830         transfer_size = rcvbc;
 831         if (transfer_size > remaining)
 832                 transfer_size = remaining;
 833         if (transfer_size > 0) {
 834                 void *dst = urb->transfer_buffer + urb->actual_length;
 835
 836                 spi_rd_buf(hcd, MAX3421_REG_RCVFIFO, dst, transfer_size);
 837                 urb->actual_length += transfer_size;
 838                 max3421_hcd->curr_len = transfer_size;
 839         }
 840
 841         /* ack the RCVDAV irq now that the FIFO has been read: */
 842         spi_wr8(hcd, MAX3421_REG_HIRQ, BIT(MAX3421_HI_RCVDAV_BIT));
 843 }
 844
 845 static void
 846 max3421_handle_error(struct usb_hcd *hcd, u8 hrsl)
 847 {
 848         struct spi_device *spi = to_spi_device(hcd->self.controller);
 849         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 850         u8 result_code = hrsl & MAX3421_HRSL_RESULT_MASK;
 851         struct urb *urb = max3421_hcd->curr_urb;
 852         struct max3421_ep *max3421_ep = urb->ep->hcpriv;
 853         int switch_sndfifo;
 854
 855         /*
 856          * If an OUT command results in any response other than OK
 857          * (i.e., error or NAK), we have to perform a dummy-write to
 858          * SNDBC so the FIFO gets switched back to us.  Otherwise, we
 859          * get out of sync with the SNDFIFO double buffer.
 860          */
 861         switch_sndfifo = (max3421_ep->pkt_state == PKT_STATE_TRANSFER &&
 862                           usb_urb_dir_out(urb));
 863
 864         switch (result_code) {
 865         case MAX3421_HRSL_OK:
 866                 return;                 /* this shouldn't happen */
 867
 868         case MAX3421_HRSL_WRONGPID:     /* received wrong PID */
 869         case MAX3421_HRSL_BUSY:         /* SIE busy */
 870         case MAX3421_HRSL_BADREQ:       /* bad val in HXFR */
 871         case MAX3421_HRSL_UNDEF:        /* reserved */
 872         case MAX3421_HRSL_KERR:         /* K-state instead of response */
 873         case MAX3421_HRSL_JERR:         /* J-state instead of response */
 874                 /*
 875                  * packet experienced an error that we cannot recover
 876                  * from; report error
 877                  */
 878                 max3421_hcd->urb_done = hrsl_to_error[result_code];
 879                 dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
 880                         __func__, hrsl);
 881                 break;
 882
 883         case MAX3421_HRSL_TOGERR:
 884                 if (usb_urb_dir_in(urb))
 885                         ; /* don't do anything (device will switch toggle) */
 886                 else {
 887                         /* flip the send toggle bit: */
 888                         int sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1;
 889
 890                         sndtog ^= 1;
 891                         spi_wr8(hcd, MAX3421_REG_HCTL,
 892                                 BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT));
 893                 }
 894                 /* FALL THROUGH */
 895         case MAX3421_HRSL_BADBC:        /* bad byte count */
 896         case MAX3421_HRSL_PIDERR:       /* received PID is corrupted */
 897         case MAX3421_HRSL_PKTERR:       /* packet error (stuff, EOP) */
 898         case MAX3421_HRSL_CRCERR:       /* CRC error */
 899         case MAX3421_HRSL_BABBLE:       /* device talked too long */
 900         case MAX3421_HRSL_TIMEOUT:
 901                 if (max3421_ep->retries++ < USB_MAX_RETRIES)
 902                         /* retry the packet again in the next frame */
 903                         max3421_slow_retransmit(hcd);
 904                 else {
 905                         /* Based on ohci.h cc_to_err[]: */
 906                         max3421_hcd->urb_done = hrsl_to_error[result_code];
 907                         dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
 908                                 __func__, hrsl);
 909                 }
 910                 break;
 911
 912         case MAX3421_HRSL_STALL:
 913                 dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
 914                         __func__, hrsl);
 915                 max3421_hcd->urb_done = hrsl_to_error[result_code];
 916                 break;
 917
 918         case MAX3421_HRSL_NAK:
 919                 /*
 920                  * Device wasn't ready for data or has no data
 921                  * available: retry the packet again.
 922                  */
 923                 if (max3421_ep->naks++ < NAK_MAX_FAST_RETRANSMITS) {
 924                         max3421_next_transfer(hcd, 1);
 925                         switch_sndfifo = 0;
 926                 } else
 927                         max3421_slow_retransmit(hcd);
 928                 break;
 929         }
 930         if (switch_sndfifo)
 931                 spi_wr8(hcd, MAX3421_REG_SNDBC, 0);
 932 }
 933
 934 /*
 935  * Caller must NOT hold HCD spinlock.
 936  */
 937 static int
 938 max3421_transfer_in_done(struct usb_hcd *hcd, struct urb *urb)
 939 {
 940         struct spi_device *spi = to_spi_device(hcd->self.controller);
 941         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 942         u32 max_packet;
 943
 944         if (urb->actual_length >= urb->transfer_buffer_length)
 945                 return 1;       /* read is complete, so we're done */
 946
 947         /*
 948          * USB 2.0 Section 5.3.2 Pipes: packets must be full size
 949          * except for last one.
 950          */
 951         max_packet = usb_maxpacket(urb->dev, urb->pipe, 0);
 952         if (max_packet > MAX3421_FIFO_SIZE) {
 953                 /*
 954                  * We do not support isochronous transfers at this
 955                  * time...
 956                  */
 957                 dev_err(&spi->dev,
 958                         "%s: packet-size of %u too big (limit is %u bytes)",
 959                         __func__, max_packet, MAX3421_FIFO_SIZE);
 960                 return -EINVAL;
 961         }
 962
 963         if (max3421_hcd->curr_len < max_packet) {
 964                 if (urb->transfer_flags & URB_SHORT_NOT_OK) {
 965                         /*
 966                          * remaining > 0 and received an
 967                          * unexpected partial packet ->
 968                          * error
 969                          */
 970                         return -EREMOTEIO;
 971                 } else
 972                         /* short read, but it's OK */
 973                         return 1;
 974         }
 975         return 0;       /* not done */
 976 }
 977
 978 /*
 979  * Caller must NOT hold HCD spinlock.
 980  */
 981 static int
 982 max3421_transfer_out_done(struct usb_hcd *hcd, struct urb *urb)
 983 {
 984         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 985
 986         urb->actual_length += max3421_hcd->curr_len;
 987         if (urb->actual_length < urb->transfer_buffer_length)
 988                 return 0;
 989         if (urb->transfer_flags & URB_ZERO_PACKET) {
 990                 /*
 991                  * Some hardware needs a zero-size packet at the end
 992                  * of a bulk-out transfer if the last transfer was a
 993                  * full-sized packet (i.e., such hardware use <
 994                  * max_packet as an indicator that the end of the
 995                  * packet has been reached).
 996                  */
 997                 u32 max_packet = usb_maxpacket(urb->dev, urb->pipe, 1);
 998
 999                 if (max3421_hcd->curr_len == max_packet)
1000                         return 0;
1001         }
1002         return 1;
1003 }
1004
1005 /*
1006  * Caller must NOT hold HCD spinlock.
1007  */
1008 static void
1009 max3421_host_transfer_done(struct usb_hcd *hcd)
1010 {
1011         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1012         struct urb *urb = max3421_hcd->curr_urb;
1013         struct max3421_ep *max3421_ep;
1014         u8 result_code, hrsl;
1015         int urb_done = 0;
1016
1017         max3421_hcd->hien &= ~(BIT(MAX3421_HI_HXFRDN_BIT) |
1018                                BIT(MAX3421_HI_RCVDAV_BIT));
1019
1020         hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
1021         result_code = hrsl & MAX3421_HRSL_RESULT_MASK;
1022
1023 #ifdef DEBUG
1024         ++max3421_hcd->err_stat[result_code];
1025 #endif
1026
1027         max3421_ep = urb->ep->hcpriv;
1028
1029         if (unlikely(result_code != MAX3421_HRSL_OK)) {
1030                 max3421_handle_error(hcd, hrsl);
1031                 return;
1032         }
1033
1034         max3421_ep->naks = 0;
1035         max3421_ep->retries = 0;
1036         switch (max3421_ep->pkt_state) {
1037
1038         case PKT_STATE_SETUP:
1039                 if (urb->transfer_buffer_length > 0)
1040                         max3421_ep->pkt_state = PKT_STATE_TRANSFER;
1041                 else
1042                         max3421_ep->pkt_state = PKT_STATE_TERMINATE;
1043                 break;
1044
1045         case PKT_STATE_TRANSFER:
1046                 if (usb_urb_dir_in(urb))
1047                         urb_done = max3421_transfer_in_done(hcd, urb);
1048                 else
1049                         urb_done = max3421_transfer_out_done(hcd, urb);
1050                 if (urb_done > 0 && usb_pipetype(urb->pipe) == PIPE_CONTROL) {
1051                         /*
1052                          * We aren't really done - we still need to
1053                          * terminate the control transfer:
1054                          */
1055                         max3421_hcd->urb_done = urb_done = 0;
1056                         max3421_ep->pkt_state = PKT_STATE_TERMINATE;
1057                 }
1058                 break;
1059
1060         case PKT_STATE_TERMINATE:
1061                 urb_done = 1;
1062                 break;
1063         }
1064
1065         if (urb_done)
1066                 max3421_hcd->urb_done = urb_done;
1067         else
1068                 max3421_next_transfer(hcd, 0);
1069 }
1070
1071 /*
1072  * Caller must NOT hold HCD spinlock.
1073  */
1074 static void
1075 max3421_detect_conn(struct usb_hcd *hcd)
1076 {
1077         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1078         unsigned int jk, have_conn = 0;
1079         u32 old_port_status, chg;
1080         unsigned long flags;
1081         u8 hrsl, mode;
1082
1083         hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
1084
1085         jk = ((((hrsl >> MAX3421_HRSL_JSTATUS_BIT) & 1) << 0) |
1086               (((hrsl >> MAX3421_HRSL_KSTATUS_BIT) & 1) << 1));
1087
1088         mode = max3421_hcd->mode;
1089
1090         switch (jk) {
1091         case 0x0: /* SE0: disconnect */
1092                 /*
1093                  * Turn off SOFKAENAB bit to avoid getting interrupt
1094                  * every milli-second:
1095                  */
1096                 mode &= ~BIT(MAX3421_MODE_SOFKAENAB_BIT);
1097                 break;
1098
1099         case 0x1: /* J=0,K=1: low-speed (in full-speed or vice versa) */
1100         case 0x2: /* J=1,K=0: full-speed (in full-speed or vice versa) */
1101                 if (jk == 0x2)
1102                         /* need to switch to the other speed: */
1103                         mode ^= BIT(MAX3421_MODE_LOWSPEED_BIT);
1104                 /* turn on SOFKAENAB bit: */
1105                 mode |= BIT(MAX3421_MODE_SOFKAENAB_BIT);
1106                 have_conn = 1;
1107                 break;
1108
1109         case 0x3: /* illegal */
1110                 break;
1111         }
1112
1113         max3421_hcd->mode = mode;
1114         spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
1115
1116         spin_lock_irqsave(&max3421_hcd->lock, flags);
1117         old_port_status = max3421_hcd->port_status;
1118         if (have_conn)
1119                 max3421_hcd->port_status |=  USB_PORT_STAT_CONNECTION;
1120         else
1121                 max3421_hcd->port_status &= ~USB_PORT_STAT_CONNECTION;
1122         if (mode & BIT(MAX3421_MODE_LOWSPEED_BIT))
1123                 max3421_hcd->port_status |=  USB_PORT_STAT_LOW_SPEED;
1124         else
1125                 max3421_hcd->port_status &= ~USB_PORT_STAT_LOW_SPEED;
1126         chg = (old_port_status ^ max3421_hcd->port_status);
1127         max3421_hcd->port_status |= chg << 16;
1128         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1129 }
1130
1131 static irqreturn_t
1132 max3421_irq_handler(int irq, void *dev_id)
1133 {
1134         struct usb_hcd *hcd = dev_id;
1135         struct spi_device *spi = to_spi_device(hcd->self.controller);
1136         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1137
1138         if (max3421_hcd->spi_thread &&
1139             max3421_hcd->spi_thread->state != TASK_RUNNING)
1140                 wake_up_process(max3421_hcd->spi_thread);
1141         if (!test_and_set_bit(ENABLE_IRQ, &max3421_hcd->todo))
1142                 disable_irq_nosync(spi->irq);
1143         return IRQ_HANDLED;
1144 }
1145
1146 #ifdef DEBUG
1147
1148 static void
1149 dump_eps(struct usb_hcd *hcd)
1150 {
1151         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1152         struct max3421_ep *max3421_ep;
1153         struct usb_host_endpoint *ep;
1154         char ubuf[512], *dp, *end;
1155         unsigned long flags;
1156         struct urb *urb;
1157         int epnum, ret;
1158
1159         spin_lock_irqsave(&max3421_hcd->lock, flags);
1160         list_for_each_entry(max3421_ep, &max3421_hcd->ep_list, ep_list) {
1161                 ep = max3421_ep->ep;
1162
1163                 dp = ubuf;
1164                 end = dp + sizeof(ubuf);
1165                 *dp = '\0';
1166                 list_for_each_entry(urb, &ep->urb_list, urb_list) {
1167                         ret = snprintf(dp, end - dp, " %p(%d.%s %d/%d)", urb,
1168                                        usb_pipetype(urb->pipe),
1169                                        usb_urb_dir_in(urb) ? "IN" : "OUT",
1170                                        urb->actual_length,
1171                                        urb->transfer_buffer_length);
1172                         if (ret < 0 || ret >= end - dp)
1173                                 break;  /* error or buffer full */
1174                         dp += ret;
1175                 }
1176
1177                 epnum = usb_endpoint_num(&ep->desc);
1178                 pr_info("EP%0u %u lst %04u rtr %u nak %6u rxmt %u: %s\n",
1179                         epnum, max3421_ep->pkt_state, max3421_ep->last_active,
1180                         max3421_ep->retries, max3421_ep->naks,
1181                         max3421_ep->retransmit, ubuf);
1182         }
1183         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1184 }
1185
1186 #endif /* DEBUG */
1187
1188 /* Return zero if no work was performed, 1 otherwise.  */
1189 static int
1190 max3421_handle_irqs(struct usb_hcd *hcd)
1191 {
1192         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1193         u32 chg, old_port_status;
1194         unsigned long flags;
1195         u8 hirq;
1196
1197         /*
1198          * Read and ack pending interrupts (CPU must never
1199          * clear SNDBAV directly and RCVDAV must be cleared by
1200          * max3421_recv_data_available()!):
1201          */
1202         hirq = spi_rd8(hcd, MAX3421_REG_HIRQ);
1203         hirq &= max3421_hcd->hien;
1204         if (!hirq)
1205                 return 0;
1206
1207         spi_wr8(hcd, MAX3421_REG_HIRQ,
1208                 hirq & ~(BIT(MAX3421_HI_SNDBAV_BIT) |
1209                          BIT(MAX3421_HI_RCVDAV_BIT)));
1210
1211         if (hirq & BIT(MAX3421_HI_FRAME_BIT)) {
1212                 max3421_hcd->frame_number = ((max3421_hcd->frame_number + 1)
1213                                              & USB_MAX_FRAME_NUMBER);
1214                 max3421_hcd->sched_pass = SCHED_PASS_PERIODIC;
1215         }
1216
1217         if (hirq & BIT(MAX3421_HI_RCVDAV_BIT))
1218                 max3421_recv_data_available(hcd);
1219
1220         if (hirq & BIT(MAX3421_HI_HXFRDN_BIT))
1221                 max3421_host_transfer_done(hcd);
1222
1223         if (hirq & BIT(MAX3421_HI_CONDET_BIT))
1224                 max3421_detect_conn(hcd);
1225
1226         /*
1227          * Now process interrupts that may affect HCD state
1228          * other than the end-points:
1229          */
1230         spin_lock_irqsave(&max3421_hcd->lock, flags);
1231
1232         old_port_status = max3421_hcd->port_status;
1233         if (hirq & BIT(MAX3421_HI_BUSEVENT_BIT)) {
1234                 if (max3421_hcd->port_status & USB_PORT_STAT_RESET) {
1235                         /* BUSEVENT due to completion of Bus Reset */
1236                         max3421_hcd->port_status &= ~USB_PORT_STAT_RESET;
1237                         max3421_hcd->port_status |=  USB_PORT_STAT_ENABLE;
1238                 } else {
1239                         /* BUSEVENT due to completion of Bus Resume */
1240                         pr_info("%s: BUSEVENT Bus Resume Done\n", __func__);
1241                 }
1242         }
1243         if (hirq & BIT(MAX3421_HI_RWU_BIT))
1244                 pr_info("%s: RWU\n", __func__);
1245         if (hirq & BIT(MAX3421_HI_SUSDN_BIT))
1246                 pr_info("%s: SUSDN\n", __func__);
1247
1248         chg = (old_port_status ^ max3421_hcd->port_status);
1249         max3421_hcd->port_status |= chg << 16;
1250
1251         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1252
1253 #ifdef DEBUG
1254         {
1255                 static unsigned long last_time;
1256                 char sbuf[16 * 16], *dp, *end;
1257                 int i;
1258
1259                 if (time_after(jiffies, last_time + 5*HZ)) {
1260                         dp = sbuf;
1261                         end = sbuf + sizeof(sbuf);
1262                         *dp = '\0';
1263                         for (i = 0; i < 16; ++i) {
1264                                 int ret = snprintf(dp, end - dp, " %lu",
1265                                                    max3421_hcd->err_stat[i]);
1266                                 if (ret < 0 || ret >= end - dp)
1267                                         break;  /* error or buffer full */
1268                                 dp += ret;
1269                         }
1270                         pr_info("%s: hrsl_stats %s\n", __func__, sbuf);
1271                         memset(max3421_hcd->err_stat, 0,
1272                                sizeof(max3421_hcd->err_stat));
1273                         last_time = jiffies;
1274
1275                         dump_eps(hcd);
1276                 }
1277         }
1278 #endif
1279         return 1;
1280 }
1281
1282 static int
1283 max3421_reset_hcd(struct usb_hcd *hcd)
1284 {
1285         struct spi_device *spi = to_spi_device(hcd->self.controller);
1286         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1287         int timeout;
1288
1289         /* perform a chip reset and wait for OSCIRQ signal to appear: */
1290         spi_wr8(hcd, MAX3421_REG_USBCTL, BIT(MAX3421_USBCTL_CHIPRES_BIT));
1291         /* clear reset: */
1292         spi_wr8(hcd, MAX3421_REG_USBCTL, 0);
1293         timeout = 1000;
1294         while (1) {
1295                 if (spi_rd8(hcd, MAX3421_REG_USBIRQ)
1296                     & BIT(MAX3421_USBIRQ_OSCOKIRQ_BIT))
1297                         break;
1298                 if (--timeout < 0) {
1299                         dev_err(&spi->dev,
1300                                 "timed out waiting for oscillator OK signal");
1301                         return 1;
1302                 }
1303                 cond_resched();
1304         }
1305
1306         /*
1307          * Turn on host mode, automatic generation of SOF packets, and
1308          * enable pull-down registers on DM/DP:
1309          */
1310         max3421_hcd->mode = (BIT(MAX3421_MODE_HOST_BIT) |
1311                              BIT(MAX3421_MODE_SOFKAENAB_BIT) |
1312                              BIT(MAX3421_MODE_DMPULLDN_BIT) |
1313                              BIT(MAX3421_MODE_DPPULLDN_BIT));
1314         spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
1315
1316         /* reset frame-number: */
1317         max3421_hcd->frame_number = USB_MAX_FRAME_NUMBER;
1318         spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_FRMRST_BIT));
1319
1320         /* sample the state of the D+ and D- lines */
1321         spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_SAMPLEBUS_BIT));
1322         max3421_detect_conn(hcd);
1323
1324         /* enable frame, connection-detected, and bus-event interrupts: */
1325         max3421_hcd->hien = (BIT(MAX3421_HI_FRAME_BIT) |
1326                              BIT(MAX3421_HI_CONDET_BIT) |
1327                              BIT(MAX3421_HI_BUSEVENT_BIT));
1328         spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien);
1329
1330         /* enable interrupts: */
1331         spi_wr8(hcd, MAX3421_REG_CPUCTL, BIT(MAX3421_CPUCTL_IE_BIT));
1332         return 1;
1333 }
1334
1335 static int
1336 max3421_urb_done(struct usb_hcd *hcd)
1337 {
1338         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1339         unsigned long flags;
1340         struct urb *urb;
1341         int status;
1342
1343         status = max3421_hcd->urb_done;
1344         max3421_hcd->urb_done = 0;
1345         if (status > 0)
1346                 status = 0;
1347         urb = max3421_hcd->curr_urb;
1348         if (urb) {
1349                 /* save the old end-points toggles: */
1350                 u8 hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
1351                 int rcvtog = (hrsl >> MAX3421_HRSL_RCVTOGRD_BIT) & 1;
1352                 int sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1;
1353                 int epnum = usb_endpoint_num(&urb->ep->desc);
1354
1355                 /* no locking: HCD (i.e., we) own toggles, don't we? */
1356                 usb_settoggle(urb->dev, epnum, 0, rcvtog);
1357                 usb_settoggle(urb->dev, epnum, 1, sndtog);
1358
1359                 max3421_hcd->curr_urb = NULL;
1360                 spin_lock_irqsave(&max3421_hcd->lock, flags);
1361                 usb_hcd_unlink_urb_from_ep(hcd, urb);
1362                 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1363
1364                 /* must be called without the HCD spinlock: */
1365                 usb_hcd_giveback_urb(hcd, urb, status);
1366         }
1367         return 1;
1368 }
1369
1370 static int
1371 max3421_spi_thread(void *dev_id)
1372 {
1373         struct usb_hcd *hcd = dev_id;
1374         struct spi_device *spi = to_spi_device(hcd->self.controller);
1375         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1376         int i, i_worked = 1;
1377
1378         /* set full-duplex SPI mode, low-active interrupt pin: */
1379         spi_wr8(hcd, MAX3421_REG_PINCTL,
1380                 (BIT(MAX3421_PINCTL_FDUPSPI_BIT) |      /* full-duplex */
1381                  BIT(MAX3421_PINCTL_INTLEVEL_BIT)));    /* low-active irq */
1382
1383         while (!kthread_should_stop()) {
1384                 max3421_hcd->rev = spi_rd8(hcd, MAX3421_REG_REVISION);
1385                 if (max3421_hcd->rev == 0x12 || max3421_hcd->rev == 0x13)
1386                         break;
1387                 dev_err(&spi->dev, "bad rev 0x%02x", max3421_hcd->rev);
1388                 msleep(10000);
1389         }
1390         dev_info(&spi->dev, "rev 0x%x, SPI clk %dHz, bpw %u, irq %d\n",
1391                  max3421_hcd->rev, spi->max_speed_hz, spi->bits_per_word,
1392                  spi->irq);
1393
1394         while (!kthread_should_stop()) {
1395                 if (!i_worked) {
1396                         /*
1397                          * We'll be waiting for wakeups from the hard
1398                          * interrupt handler, so now is a good time to
1399                          * sync our hien with the chip:
1400                          */
1401                         spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien);
1402
1403                         set_current_state(TASK_INTERRUPTIBLE);
1404                         if (test_and_clear_bit(ENABLE_IRQ, &max3421_hcd->todo))
1405                                 enable_irq(spi->irq);
1406                         schedule();
1407                         __set_current_state(TASK_RUNNING);
1408                 }
1409
1410                 i_worked = 0;
1411
1412                 if (max3421_hcd->urb_done)
1413                         i_worked |= max3421_urb_done(hcd);
1414                 else if (max3421_handle_irqs(hcd))
1415                         i_worked = 1;
1416                 else if (!max3421_hcd->curr_urb)
1417                         i_worked |= max3421_select_and_start_urb(hcd);
1418
1419                 if (test_and_clear_bit(RESET_HCD, &max3421_hcd->todo))
1420                         /* reset the HCD: */
1421                         i_worked |= max3421_reset_hcd(hcd);
1422                 if (test_and_clear_bit(RESET_PORT, &max3421_hcd->todo)) {
1423                         /* perform a USB bus reset: */
1424                         spi_wr8(hcd, MAX3421_REG_HCTL,
1425                                 BIT(MAX3421_HCTL_BUSRST_BIT));
1426                         i_worked = 1;
1427                 }
1428                 if (test_and_clear_bit(CHECK_UNLINK, &max3421_hcd->todo))
1429                         i_worked |= max3421_check_unlink(hcd);
1430                 if (test_and_clear_bit(IOPIN_UPDATE, &max3421_hcd->todo)) {
1431                         /*
1432                          * IOPINS1/IOPINS2 do not auto-increment, so we can't
1433                          * use spi_wr_buf().
1434                          */
1435                         for (i = 0; i < ARRAY_SIZE(max3421_hcd->iopins); ++i) {
1436                                 u8 val = spi_rd8(hcd, MAX3421_REG_IOPINS1);
1437
1438                                 val = ((val & 0xf0) |
1439                                        (max3421_hcd->iopins[i] & 0x0f));
1440                                 spi_wr8(hcd, MAX3421_REG_IOPINS1 + i, val);
1441                                 max3421_hcd->iopins[i] = val;
1442                         }
1443                         i_worked = 1;
1444                 }
1445         }
1446         set_current_state(TASK_RUNNING);
1447         dev_info(&spi->dev, "SPI thread exiting");
1448         return 0;
1449 }
1450
1451 static int
1452 max3421_reset_port(struct usb_hcd *hcd)
1453 {
1454         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1455
1456         max3421_hcd->port_status &= ~(USB_PORT_STAT_ENABLE |
1457                                       USB_PORT_STAT_LOW_SPEED);
1458         max3421_hcd->port_status |= USB_PORT_STAT_RESET;
1459         set_bit(RESET_PORT, &max3421_hcd->todo);
1460         wake_up_process(max3421_hcd->spi_thread);
1461         return 0;
1462 }
1463
1464 static int
1465 max3421_reset(struct usb_hcd *hcd)
1466 {
1467         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1468
1469         hcd->self.sg_tablesize = 0;
1470         hcd->speed = HCD_USB2;
1471         hcd->self.root_hub->speed = USB_SPEED_FULL;
1472         set_bit(RESET_HCD, &max3421_hcd->todo);
1473         wake_up_process(max3421_hcd->spi_thread);
1474         return 0;
1475 }
1476
1477 static int
1478 max3421_start(struct usb_hcd *hcd)
1479 {
1480         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1481
1482         spin_lock_init(&max3421_hcd->lock);
1483         max3421_hcd->rh_state = MAX3421_RH_RUNNING;
1484
1485         INIT_LIST_HEAD(&max3421_hcd->ep_list);
1486
1487         hcd->power_budget = POWER_BUDGET;
1488         hcd->state = HC_STATE_RUNNING;
1489         hcd->uses_new_polling = 1;
1490         return 0;
1491 }
1492
1493 static void
1494 max3421_stop(struct usb_hcd *hcd)
1495 {
1496 }
1497
1498 static int
1499 max3421_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
1500 {
1501         struct spi_device *spi = to_spi_device(hcd->self.controller);
1502         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1503         struct max3421_ep *max3421_ep;
1504         unsigned long flags;
1505         int retval;
1506
1507         switch (usb_pipetype(urb->pipe)) {
1508         case PIPE_INTERRUPT:
1509         case PIPE_ISOCHRONOUS:
1510                 if (urb->interval < 0) {
1511                         dev_err(&spi->dev,
1512                           "%s: interval=%d for intr-/iso-pipe; expected > 0\n",
1513                                 __func__, urb->interval);
1514                         return -EINVAL;
1515                 }
1516         default:
1517                 break;
1518         }
1519
1520         spin_lock_irqsave(&max3421_hcd->lock, flags);
1521
1522         max3421_ep = urb->ep->hcpriv;
1523         if (!max3421_ep) {
1524                 /* gets freed in max3421_endpoint_disable: */
1525                 max3421_ep = kzalloc(sizeof(struct max3421_ep), GFP_ATOMIC);
1526                 if (!max3421_ep) {
1527                         retval = -ENOMEM;
1528                         goto out;
1529                 }
1530                 max3421_ep->ep = urb->ep;
1531                 max3421_ep->last_active = max3421_hcd->frame_number;
1532                 urb->ep->hcpriv = max3421_ep;
1533
1534                 list_add_tail(&max3421_ep->ep_list, &max3421_hcd->ep_list);
1535         }
1536
1537         retval = usb_hcd_link_urb_to_ep(hcd, urb);
1538         if (retval == 0) {
1539                 /* Since we added to the queue, restart scheduling: */
1540                 max3421_hcd->sched_pass = SCHED_PASS_PERIODIC;
1541                 wake_up_process(max3421_hcd->spi_thread);
1542         }
1543
1544 out:
1545         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1546         return retval;
1547 }
1548
1549 static int
1550 max3421_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1551 {
1552         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1553         unsigned long flags;
1554         int retval;
1555
1556         spin_lock_irqsave(&max3421_hcd->lock, flags);
1557
1558         /*
1559          * This will set urb->unlinked which in turn causes the entry
1560          * to be dropped at the next opportunity.
1561          */
1562         retval = usb_hcd_check_unlink_urb(hcd, urb, status);
1563         if (retval == 0) {
1564                 set_bit(CHECK_UNLINK, &max3421_hcd->todo);
1565                 wake_up_process(max3421_hcd->spi_thread);
1566         }
1567         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1568         return retval;
1569 }
1570
1571 static void
1572 max3421_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
1573 {
1574         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1575         unsigned long flags;
1576
1577         spin_lock_irqsave(&max3421_hcd->lock, flags);
1578
1579         if (ep->hcpriv) {
1580                 struct max3421_ep *max3421_ep = ep->hcpriv;
1581
1582                 /* remove myself from the ep_list: */
1583                 if (!list_empty(&max3421_ep->ep_list))
1584                         list_del(&max3421_ep->ep_list);
1585                 kfree(max3421_ep);
1586                 ep->hcpriv = NULL;
1587         }
1588
1589         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1590 }
1591
1592 static int
1593 max3421_get_frame_number(struct usb_hcd *hcd)
1594 {
1595         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1596         return max3421_hcd->frame_number;
1597 }
1598
1599 /*
1600  * Should return a non-zero value when any port is undergoing a resume
1601  * transition while the root hub is suspended.
1602  */
1603 static int
1604 max3421_hub_status_data(struct usb_hcd *hcd, char *buf)
1605 {
1606         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1607         unsigned long flags;
1608         int retval = 0;
1609
1610         spin_lock_irqsave(&max3421_hcd->lock, flags);
1611         if (!HCD_HW_ACCESSIBLE(hcd))
1612                 goto done;
1613
1614         *buf = 0;
1615         if ((max3421_hcd->port_status & PORT_C_MASK) != 0) {
1616                 *buf = (1 << 1); /* a hub over-current condition exists */
1617                 dev_dbg(hcd->self.controller,
1618                         "port status 0x%08x has changes\n",
1619                         max3421_hcd->port_status);
1620                 retval = 1;
1621                 if (max3421_hcd->rh_state == MAX3421_RH_SUSPENDED)
1622                         usb_hcd_resume_root_hub(hcd);
1623         }
1624 done:
1625         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1626         return retval;
1627 }
1628
1629 static inline void
1630 hub_descriptor(struct usb_hub_descriptor *desc)
1631 {
1632         memset(desc, 0, sizeof(*desc));
1633         /*
1634          * See Table 11-13: Hub Descriptor in USB 2.0 spec.
1635          */
1636         desc->bDescriptorType = USB_DT_HUB; /* hub descriptor */
1637         desc->bDescLength = 9;
1638         desc->wHubCharacteristics = cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM |
1639                                                 HUB_CHAR_COMMON_OCPM);
1640         desc->bNbrPorts = 1;
1641 }
1642
1643 /*
1644  * Set the MAX3421E general-purpose output with number PIN_NUMBER to
1645  * VALUE (0 or 1).  PIN_NUMBER may be in the range from 1-8.  For
1646  * any other value, this function acts as a no-op.
1647  */
1648 static void
1649 max3421_gpout_set_value(struct usb_hcd *hcd, u8 pin_number, u8 value)
1650 {
1651         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1652         u8 mask, idx;
1653
1654         --pin_number;
1655         if (pin_number > 7)
1656                 return;
1657
1658         mask = 1u << (pin_number % 4);
1659         idx = pin_number / 4;
1660
1661         if (value)
1662                 max3421_hcd->iopins[idx] |=  mask;
1663         else
1664                 max3421_hcd->iopins[idx] &= ~mask;
1665         set_bit(IOPIN_UPDATE, &max3421_hcd->todo);
1666         wake_up_process(max3421_hcd->spi_thread);
1667 }
1668
1669 static int
1670 max3421_hub_control(struct usb_hcd *hcd, u16 type_req, u16 value, u16 index,
1671                     char *buf, u16 length)
1672 {
1673         struct spi_device *spi = to_spi_device(hcd->self.controller);
1674         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1675         struct max3421_hcd_platform_data *pdata;
1676         unsigned long flags;
1677         int retval = 0;
1678
1679         spin_lock_irqsave(&max3421_hcd->lock, flags);
1680
1681         pdata = spi->dev.platform_data;
1682
1683         switch (type_req) {
1684         case ClearHubFeature:
1685                 break;
1686         case ClearPortFeature:
1687                 switch (value) {
1688                 case USB_PORT_FEAT_SUSPEND:
1689                         break;
1690                 case USB_PORT_FEAT_POWER:
1691                         dev_dbg(hcd->self.controller, "power-off\n");
1692                         max3421_gpout_set_value(hcd, pdata->vbus_gpout,
1693                                                 !pdata->vbus_active_level);
1694                         /* FALLS THROUGH */
1695                 default:
1696                         max3421_hcd->port_status &= ~(1 << value);
1697                 }
1698                 break;
1699         case GetHubDescriptor:
1700                 hub_descriptor((struct usb_hub_descriptor *) buf);
1701                 break;
1702
1703         case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
1704         case GetPortErrorCount:
1705         case SetHubDepth:
1706                 /* USB3 only */
1707                 goto error;
1708
1709         case GetHubStatus:
1710                 *(__le32 *) buf = cpu_to_le32(0);
1711                 break;
1712
1713         case GetPortStatus:
1714                 if (index != 1) {
1715                         retval = -EPIPE;
1716                         goto error;
1717                 }
1718                 ((__le16 *) buf)[0] = cpu_to_le16(max3421_hcd->port_status);
1719                 ((__le16 *) buf)[1] =
1720                         cpu_to_le16(max3421_hcd->port_status >> 16);
1721                 break;
1722
1723         case SetHubFeature:
1724                 retval = -EPIPE;
1725                 break;
1726
1727         case SetPortFeature:
1728                 switch (value) {
1729                 case USB_PORT_FEAT_LINK_STATE:
1730                 case USB_PORT_FEAT_U1_TIMEOUT:
1731                 case USB_PORT_FEAT_U2_TIMEOUT:
1732                 case USB_PORT_FEAT_BH_PORT_RESET:
1733                         goto error;
1734                 case USB_PORT_FEAT_SUSPEND:
1735                         if (max3421_hcd->active)
1736                                 max3421_hcd->port_status |=
1737                                         USB_PORT_STAT_SUSPEND;
1738                         break;
1739                 case USB_PORT_FEAT_POWER:
1740                         dev_dbg(hcd->self.controller, "power-on\n");
1741                         max3421_hcd->port_status |= USB_PORT_STAT_POWER;
1742                         max3421_gpout_set_value(hcd, pdata->vbus_gpout,
1743                                                 pdata->vbus_active_level);
1744                         break;
1745                 case USB_PORT_FEAT_RESET:
1746                         max3421_reset_port(hcd);
1747                         /* FALLS THROUGH */
1748                 default:
1749                         if ((max3421_hcd->port_status & USB_PORT_STAT_POWER)
1750                             != 0)
1751                                 max3421_hcd->port_status |= (1 << value);
1752                 }
1753                 break;
1754
1755         default:
1756                 dev_dbg(hcd->self.controller,
1757                         "hub control req%04x v%04x i%04x l%d\n",
1758                         type_req, value, index, length);
1759 error:          /* "protocol stall" on error */
1760                 retval = -EPIPE;
1761         }
1762
1763         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1764         return retval;
1765 }
1766
1767 static int
1768 max3421_bus_suspend(struct usb_hcd *hcd)
1769 {
1770         return -1;
1771 }
1772
1773 static int
1774 max3421_bus_resume(struct usb_hcd *hcd)
1775 {
1776         return -1;
1777 }
1778
1779 /*
1780  * The SPI driver already takes care of DMA-mapping/unmapping, so no
1781  * reason to do it twice.
1782  */
1783 static int
1784 max3421_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
1785 {
1786         return 0;
1787 }
1788
1789 static void
1790 max3421_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1791 {
1792 }
1793
1794 static struct hc_driver max3421_hcd_desc = {
1795         .description =          "max3421",
1796         .product_desc =         DRIVER_DESC,
1797         .hcd_priv_size =        sizeof(struct max3421_hcd),
1798         .flags =                HCD_USB11,
1799         .reset =                max3421_reset,
1800         .start =                max3421_start,
1801         .stop =                 max3421_stop,
1802         .get_frame_number =     max3421_get_frame_number,
1803         .urb_enqueue =          max3421_urb_enqueue,
1804         .urb_dequeue =          max3421_urb_dequeue,
1805         .map_urb_for_dma =      max3421_map_urb_for_dma,
1806         .unmap_urb_for_dma =    max3421_unmap_urb_for_dma,
1807         .endpoint_disable =     max3421_endpoint_disable,
1808         .hub_status_data =      max3421_hub_status_data,
1809         .hub_control =          max3421_hub_control,
1810         .bus_suspend =          max3421_bus_suspend,
1811         .bus_resume =           max3421_bus_resume,
1812 };
1813
1814 static int
1815 max3421_probe(struct spi_device *spi)
1816 {
1817         struct max3421_hcd *max3421_hcd;
1818         struct usb_hcd *hcd = NULL;
1819         int retval = -ENOMEM;
1820
1821         if (spi_setup(spi) < 0) {
1822                 dev_err(&spi->dev, "Unable to setup SPI bus");
1823                 return -EFAULT;
1824         }
1825
1826         hcd = usb_create_hcd(&max3421_hcd_desc, &spi->dev,
1827                              dev_name(&spi->dev));
1828         if (!hcd) {
1829                 dev_err(&spi->dev, "failed to create HCD structure\n");
1830                 goto error;
1831         }
1832         set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
1833         max3421_hcd = hcd_to_max3421(hcd);
1834         INIT_LIST_HEAD(&max3421_hcd->ep_list);
1835         spi_set_drvdata(spi, max3421_hcd);
1836
1837         max3421_hcd->tx = kmalloc(sizeof(*max3421_hcd->tx), GFP_KERNEL);
1838         if (!max3421_hcd->tx)
1839                 goto error;
1840         max3421_hcd->rx = kmalloc(sizeof(*max3421_hcd->rx), GFP_KERNEL);
1841         if (!max3421_hcd->rx)
1842                 goto error;
1843
1844         max3421_hcd->spi_thread = kthread_run(max3421_spi_thread, hcd,
1845                                               "max3421_spi_thread");
1846         if (max3421_hcd->spi_thread == ERR_PTR(-ENOMEM)) {
1847                 dev_err(&spi->dev,
1848                         "failed to create SPI thread (out of memory)\n");
1849                 goto error;
1850         }
1851
1852         retval = usb_add_hcd(hcd, 0, 0);
1853         if (retval) {
1854                 dev_err(&spi->dev, "failed to add HCD\n");
1855                 goto error;
1856         }
1857
1858         retval = request_irq(spi->irq, max3421_irq_handler,
1859                              IRQF_TRIGGER_LOW, "max3421", hcd);
1860         if (retval < 0) {
1861                 dev_err(&spi->dev, "failed to request irq %d\n", spi->irq);
1862                 goto error;
1863         }
1864         return 0;
1865
1866 error:
1867         if (hcd) {
1868                 kfree(max3421_hcd->tx);
1869                 kfree(max3421_hcd->rx);
1870                 if (max3421_hcd->spi_thread)
1871                         kthread_stop(max3421_hcd->spi_thread);
1872                 usb_put_hcd(hcd);
1873         }
1874         return retval;
1875 }
1876
1877 static int
1878 max3421_remove(struct spi_device *spi)
1879 {
1880         struct max3421_hcd *max3421_hcd;
1881         struct usb_hcd *hcd;
1882         unsigned long flags;
1883
1884         max3421_hcd = spi_get_drvdata(spi);
1885         hcd = max3421_to_hcd(max3421_hcd);
1886
1887         usb_remove_hcd(hcd);
1888
1889         spin_lock_irqsave(&max3421_hcd->lock, flags);
1890
1891         kthread_stop(max3421_hcd->spi_thread);
1892
1893         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1894
1895         free_irq(spi->irq, hcd);
1896
1897         usb_put_hcd(hcd);
1898         return 0;
1899 }
1900
1901 static struct spi_driver max3421_driver = {
1902         .probe          = max3421_probe,
1903         .remove         = max3421_remove,
1904         .driver         = {
1905                 .name   = "max3421-hcd",
1906         },
1907 };
1908
1909 module_spi_driver(max3421_driver);
1910
1911 MODULE_DESCRIPTION(DRIVER_DESC);
1912 MODULE_AUTHOR("David Mosberger <davidm@egauge.net>");
1913 MODULE_LICENSE("GPL");