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/module.h>
  59 #include <linux/spi/spi.h>
  60 #include <linux/usb.h>
  61 #include <linux/usb/hcd.h>
  62
  63 #include <linux/platform_data/max3421-hcd.h>
  64
  65 #define DRIVER_DESC     "MAX3421 USB Host-Controller Driver"
  66 #define DRIVER_VERSION  "1.0"
  67
  68 /* 11-bit counter that wraps around (USB 2.0 Section 8.3.3): */
  69 #define USB_MAX_FRAME_NUMBER    0x7ff
  70 #define USB_MAX_RETRIES         3 /* # of retries before error is reported */
  71
  72 /*
  73  * Max. # of times we're willing to retransmit a request immediately in
  74  * resposne to a NAK.  Afterwards, we fall back on trying once a frame.
  75  */
  76 #define NAK_MAX_FAST_RETRANSMITS        2
  77
  78 #define POWER_BUDGET    500     /* in mA; use 8 for low-power port testing */
  79
  80 /* Port-change mask: */
  81 #define PORT_C_MASK     ((USB_PORT_STAT_C_CONNECTION |  \
  82                           USB_PORT_STAT_C_ENABLE |      \
  83                           USB_PORT_STAT_C_SUSPEND |     \
  84                           USB_PORT_STAT_C_OVERCURRENT | \
  85                           USB_PORT_STAT_C_RESET) << 16)
  86
  87 enum max3421_rh_state {
  88         MAX3421_RH_RESET,
  89         MAX3421_RH_SUSPENDED,
  90         MAX3421_RH_RUNNING
  91 };
  92
  93 enum pkt_state {
  94         PKT_STATE_SETUP,        /* waiting to send setup packet to ctrl pipe */
  95         PKT_STATE_TRANSFER,     /* waiting to xfer transfer_buffer */
  96         PKT_STATE_TERMINATE     /* waiting to terminate control transfer */
  97 };
  98
  99 enum scheduling_pass {
 100         SCHED_PASS_PERIODIC,
 101         SCHED_PASS_NON_PERIODIC,
 102         SCHED_PASS_DONE
 103 };
 104
 105 struct max3421_dma_buf {
 106         u8 data[2];
 107 };
 108
 109 struct max3421_hcd {
 110         spinlock_t lock;
 111
 112         struct task_struct *spi_thread;
 113
 114         struct max3421_hcd *next;
 115
 116         enum max3421_rh_state rh_state;
 117         /* lower 16 bits contain port status, upper 16 bits the change mask: */
 118         u32 port_status;
 119
 120         unsigned active:1;
 121
 122         struct list_head ep_list;       /* list of EP's with work */
 123
 124         /*
 125          * The following are owned by spi_thread (may be accessed by
 126          * SPI-thread without acquiring the HCD lock:
 127          */
 128         u8 rev;                         /* chip revision */
 129         u16 frame_number;
 130         /*
 131          * kmalloc'd buffers guaranteed to be in separate (DMA)
 132          * cache-lines:
 133          */
 134         struct max3421_dma_buf *tx;
 135         struct max3421_dma_buf *rx;
 136         /*
 137          * URB we're currently processing.  Must not be reset to NULL
 138          * unless MAX3421E chip is idle:
 139          */
 140         struct urb *curr_urb;
 141         enum scheduling_pass sched_pass;
 142         struct usb_device *loaded_dev;  /* dev that's loaded into the chip */
 143         int loaded_epnum;               /* epnum whose toggles are loaded */
 144         int urb_done;                   /* > 0 -> no errors, < 0: errno */
 145         size_t curr_len;
 146         u8 hien;
 147         u8 mode;
 148         u8 iopins[2];
 149         unsigned int do_enable_irq:1;
 150         unsigned int do_reset_hcd:1;
 151         unsigned int do_reset_port:1;
 152         unsigned int do_check_unlink:1;
 153         unsigned int do_iopin_update:1;
 154 #ifdef DEBUG
 155         unsigned long err_stat[16];
 156 #endif
 157 };
 158
 159 struct max3421_ep {
 160         struct usb_host_endpoint *ep;
 161         struct list_head ep_list;
 162         u32 naks;
 163         u16 last_active;                /* frame # this ep was last active */
 164         enum pkt_state pkt_state;
 165         u8 retries;
 166         u8 retransmit;                  /* packet needs retransmission */
 167 };
 168
 169 static struct max3421_hcd *max3421_hcd_list;
 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                     int force_toggles)
 487 {
 488         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 489         int old_epnum, same_ep, rcvtog, sndtog;
 490         struct usb_device *old_dev;
 491         u8 hctl;
 492
 493         old_dev = max3421_hcd->loaded_dev;
 494         old_epnum = max3421_hcd->loaded_epnum;
 495
 496         same_ep = (dev == old_dev && epnum == old_epnum);
 497         if (same_ep && !force_toggles)
 498                 return;
 499
 500         if (old_dev && !same_ep) {
 501                 /* save the old end-points toggles: */
 502                 u8 hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
 503
 504                 rcvtog = (hrsl >> MAX3421_HRSL_RCVTOGRD_BIT) & 1;
 505                 sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1;
 506
 507                 /* no locking: HCD (i.e., we) own toggles, don't we? */
 508                 usb_settoggle(old_dev, old_epnum, 0, rcvtog);
 509                 usb_settoggle(old_dev, old_epnum, 1, sndtog);
 510         }
 511         /* setup new endpoint's toggle bits: */
 512         rcvtog = usb_gettoggle(dev, epnum, 0);
 513         sndtog = usb_gettoggle(dev, epnum, 1);
 514         hctl = (BIT(rcvtog + MAX3421_HCTL_RCVTOG0_BIT) |
 515                 BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT));
 516
 517         max3421_hcd->loaded_epnum = epnum;
 518         spi_wr8(hcd, MAX3421_REG_HCTL, hctl);
 519
 520         /*
 521          * Note: devnum for one and the same device can change during
 522          * address-assignment so it's best to just always load the
 523          * address whenever the end-point changed/was forced.
 524          */
 525         max3421_hcd->loaded_dev = dev;
 526         spi_wr8(hcd, MAX3421_REG_PERADDR, dev->devnum);
 527 }
 528
 529 static int
 530 max3421_ctrl_setup(struct usb_hcd *hcd, struct urb *urb)
 531 {
 532         spi_wr_buf(hcd, MAX3421_REG_SUDFIFO, urb->setup_packet, 8);
 533         return MAX3421_HXFR_SETUP;
 534 }
 535
 536 static int
 537 max3421_transfer_in(struct usb_hcd *hcd, struct urb *urb)
 538 {
 539         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 540         int epnum = usb_pipeendpoint(urb->pipe);
 541
 542         max3421_hcd->curr_len = 0;
 543         max3421_hcd->hien |= BIT(MAX3421_HI_RCVDAV_BIT);
 544         return MAX3421_HXFR_BULK_IN(epnum);
 545 }
 546
 547 static int
 548 max3421_transfer_out(struct usb_hcd *hcd, struct urb *urb, int fast_retransmit)
 549 {
 550         struct spi_device *spi = to_spi_device(hcd->self.controller);
 551         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 552         int epnum = usb_pipeendpoint(urb->pipe);
 553         u32 max_packet;
 554         void *src;
 555
 556         src = urb->transfer_buffer + urb->actual_length;
 557
 558         if (fast_retransmit) {
 559                 if (max3421_hcd->rev == 0x12) {
 560                         /* work around rev 0x12 bug: */
 561                         spi_wr8(hcd, MAX3421_REG_SNDBC, 0);
 562                         spi_wr8(hcd, MAX3421_REG_SNDFIFO, ((u8 *) src)[0]);
 563                         spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len);
 564                 }
 565                 return MAX3421_HXFR_BULK_OUT(epnum);
 566         }
 567
 568         max_packet = usb_maxpacket(urb->dev, urb->pipe, 1);
 569
 570         if (max_packet > MAX3421_FIFO_SIZE) {
 571                 /*
 572                  * We do not support isochronous transfers at this
 573                  * time.
 574                  */
 575                 dev_err(&spi->dev,
 576                         "%s: packet-size of %u too big (limit is %u bytes)",
 577                         __func__, max_packet, MAX3421_FIFO_SIZE);
 578                 max3421_hcd->urb_done = -EMSGSIZE;
 579                 return -EMSGSIZE;
 580         }
 581         max3421_hcd->curr_len = min((urb->transfer_buffer_length -
 582                                      urb->actual_length), max_packet);
 583
 584         spi_wr_buf(hcd, MAX3421_REG_SNDFIFO, src, max3421_hcd->curr_len);
 585         spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len);
 586         return MAX3421_HXFR_BULK_OUT(epnum);
 587 }
 588
 589 /*
 590  * Issue the next host-transfer command.
 591  * Caller must NOT hold HCD spinlock.
 592  */
 593 static void
 594 max3421_next_transfer(struct usb_hcd *hcd, int fast_retransmit)
 595 {
 596         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 597         struct urb *urb = max3421_hcd->curr_urb;
 598         struct max3421_ep *max3421_ep;
 599         int cmd = -EINVAL;
 600
 601         if (!urb)
 602                 return; /* nothing to do */
 603
 604         max3421_ep = urb->ep->hcpriv;
 605
 606         switch (max3421_ep->pkt_state) {
 607         case PKT_STATE_SETUP:
 608                 cmd = max3421_ctrl_setup(hcd, urb);
 609                 break;
 610
 611         case PKT_STATE_TRANSFER:
 612                 if (usb_urb_dir_in(urb))
 613                         cmd = max3421_transfer_in(hcd, urb);
 614                 else
 615                         cmd = max3421_transfer_out(hcd, urb, fast_retransmit);
 616                 break;
 617
 618         case PKT_STATE_TERMINATE:
 619                 /*
 620                  * IN transfers are terminated with HS_OUT token,
 621                  * OUT transfers with HS_IN:
 622                  */
 623                 if (usb_urb_dir_in(urb))
 624                         cmd = MAX3421_HXFR_HS_OUT;
 625                 else
 626                         cmd = MAX3421_HXFR_HS_IN;
 627                 break;
 628         }
 629
 630         if (cmd < 0)
 631                 return;
 632
 633         /* issue the command and wait for host-xfer-done interrupt: */
 634
 635         spi_wr8(hcd, MAX3421_REG_HXFR, cmd);
 636         max3421_hcd->hien |= BIT(MAX3421_HI_HXFRDN_BIT);
 637 }
 638
 639 /*
 640  * Find the next URB to process and start its execution.
 641  *
 642  * At this time, we do not anticipate ever connecting a USB hub to the
 643  * MAX3421 chip, so at most USB device can be connected and we can use
 644  * a simplistic scheduler: at the start of a frame, schedule all
 645  * periodic transfers.  Once that is done, use the remainder of the
 646  * frame to process non-periodic (bulk & control) transfers.
 647  *
 648  * Preconditions:
 649  * o Caller must NOT hold HCD spinlock.
 650  * o max3421_hcd->curr_urb MUST BE NULL.
 651  * o MAX3421E chip must be idle.
 652  */
 653 static int
 654 max3421_select_and_start_urb(struct usb_hcd *hcd)
 655 {
 656         struct spi_device *spi = to_spi_device(hcd->self.controller);
 657         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 658         struct urb *urb, *curr_urb = NULL;
 659         struct max3421_ep *max3421_ep;
 660         int epnum, force_toggles = 0;
 661         struct usb_host_endpoint *ep;
 662         struct list_head *pos;
 663         unsigned long flags;
 664
 665         spin_lock_irqsave(&max3421_hcd->lock, flags);
 666
 667         for (;
 668              max3421_hcd->sched_pass < SCHED_PASS_DONE;
 669              ++max3421_hcd->sched_pass)
 670                 list_for_each(pos, &max3421_hcd->ep_list) {
 671                         urb = NULL;
 672                         max3421_ep = container_of(pos, struct max3421_ep,
 673                                                   ep_list);
 674                         ep = max3421_ep->ep;
 675
 676                         switch (usb_endpoint_type(&ep->desc)) {
 677                         case USB_ENDPOINT_XFER_ISOC:
 678                         case USB_ENDPOINT_XFER_INT:
 679                                 if (max3421_hcd->sched_pass !=
 680                                     SCHED_PASS_PERIODIC)
 681                                         continue;
 682                                 break;
 683
 684                         case USB_ENDPOINT_XFER_CONTROL:
 685                         case USB_ENDPOINT_XFER_BULK:
 686                                 if (max3421_hcd->sched_pass !=
 687                                     SCHED_PASS_NON_PERIODIC)
 688                                         continue;
 689                                 break;
 690                         }
 691
 692                         if (list_empty(&ep->urb_list))
 693                                 continue;       /* nothing to do */
 694                         urb = list_first_entry(&ep->urb_list, struct urb,
 695                                                urb_list);
 696                         if (urb->unlinked) {
 697                                 dev_dbg(&spi->dev, "%s: URB %p unlinked=%d",
 698                                         __func__, urb, urb->unlinked);
 699                                 max3421_hcd->curr_urb = urb;
 700                                 max3421_hcd->urb_done = 1;
 701                                 spin_unlock_irqrestore(&max3421_hcd->lock,
 702                                                        flags);
 703                                 return 1;
 704                         }
 705
 706                         switch (usb_endpoint_type(&ep->desc)) {
 707                         case USB_ENDPOINT_XFER_CONTROL:
 708                                 /*
 709                                  * Allow one control transaction per
 710                                  * frame per endpoint:
 711                                  */
 712                                 if (frame_diff(max3421_ep->last_active,
 713                                                max3421_hcd->frame_number) == 0)
 714                                         continue;
 715                                 break;
 716
 717                         case USB_ENDPOINT_XFER_BULK:
 718                                 if (max3421_ep->retransmit
 719                                     && (frame_diff(max3421_ep->last_active,
 720                                                    max3421_hcd->frame_number)
 721                                         == 0))
 722                                         /*
 723                                          * We already tried this EP
 724                                          * during this frame and got a
 725                                          * NAK or error; wait for next frame
 726                                          */
 727                                         continue;
 728                                 break;
 729
 730                         case USB_ENDPOINT_XFER_ISOC:
 731                         case USB_ENDPOINT_XFER_INT:
 732                                 if (frame_diff(max3421_hcd->frame_number,
 733                                                max3421_ep->last_active)
 734                                     < urb->interval)
 735                                         /*
 736                                          * We already processed this
 737                                          * end-point in the current
 738                                          * frame
 739                                          */
 740                                         continue;
 741                                 break;
 742                         }
 743
 744                         /* move current ep to tail: */
 745                         list_move_tail(pos, &max3421_hcd->ep_list);
 746                         curr_urb = urb;
 747                         goto done;
 748                 }
 749 done:
 750         if (!curr_urb) {
 751                 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
 752                 return 0;
 753         }
 754
 755         urb = max3421_hcd->curr_urb = curr_urb;
 756         epnum = usb_endpoint_num(&urb->ep->desc);
 757         if (max3421_ep->retransmit)
 758                 /* restart (part of) a USB transaction: */
 759                 max3421_ep->retransmit = 0;
 760         else {
 761                 /* start USB transaction: */
 762                 if (usb_endpoint_xfer_control(&ep->desc)) {
 763                         /*
 764                          * See USB 2.0 spec section 8.6.1
 765                          * Initialization via SETUP Token:
 766                          */
 767                         usb_settoggle(urb->dev, epnum, 0, 1);
 768                         usb_settoggle(urb->dev, epnum, 1, 1);
 769                         max3421_ep->pkt_state = PKT_STATE_SETUP;
 770                         force_toggles = 1;
 771                 } else
 772                         max3421_ep->pkt_state = PKT_STATE_TRANSFER;
 773         }
 774
 775         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
 776
 777         max3421_ep->last_active = max3421_hcd->frame_number;
 778         max3421_set_address(hcd, urb->dev, epnum, force_toggles);
 779         max3421_set_speed(hcd, urb->dev);
 780         max3421_next_transfer(hcd, 0);
 781         return 1;
 782 }
 783
 784 /*
 785  * Check all endpoints for URBs that got unlinked.
 786  *
 787  * Caller must NOT hold HCD spinlock.
 788  */
 789 static int
 790 max3421_check_unlink(struct usb_hcd *hcd)
 791 {
 792         struct spi_device *spi = to_spi_device(hcd->self.controller);
 793         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 794         struct list_head *pos, *upos, *next_upos;
 795         struct max3421_ep *max3421_ep;
 796         struct usb_host_endpoint *ep;
 797         struct urb *urb;
 798         unsigned long flags;
 799         int retval = 0;
 800
 801         spin_lock_irqsave(&max3421_hcd->lock, flags);
 802         list_for_each(pos, &max3421_hcd->ep_list) {
 803                 max3421_ep = container_of(pos, struct max3421_ep, ep_list);
 804                 ep = max3421_ep->ep;
 805                 list_for_each_safe(upos, next_upos, &ep->urb_list) {
 806                         urb = container_of(upos, struct urb, urb_list);
 807                         if (urb->unlinked) {
 808                                 retval = 1;
 809                                 dev_dbg(&spi->dev, "%s: URB %p unlinked=%d",
 810                                         __func__, urb, urb->unlinked);
 811                                 usb_hcd_unlink_urb_from_ep(hcd, urb);
 812                                 spin_unlock_irqrestore(&max3421_hcd->lock,
 813                                                        flags);
 814                                 usb_hcd_giveback_urb(hcd, urb, 0);
 815                                 spin_lock_irqsave(&max3421_hcd->lock, flags);
 816                         }
 817                 }
 818         }
 819         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
 820         return retval;
 821 }
 822
 823 /*
 824  * Caller must NOT hold HCD spinlock.
 825  */
 826 static void
 827 max3421_slow_retransmit(struct usb_hcd *hcd)
 828 {
 829         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 830         struct urb *urb = max3421_hcd->curr_urb;
 831         struct max3421_ep *max3421_ep;
 832
 833         max3421_ep = urb->ep->hcpriv;
 834         max3421_ep->retransmit = 1;
 835         max3421_hcd->curr_urb = NULL;
 836 }
 837
 838 /*
 839  * Caller must NOT hold HCD spinlock.
 840  */
 841 static void
 842 max3421_recv_data_available(struct usb_hcd *hcd)
 843 {
 844         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 845         struct urb *urb = max3421_hcd->curr_urb;
 846         size_t remaining, transfer_size;
 847         u8 rcvbc;
 848
 849         rcvbc = spi_rd8(hcd, MAX3421_REG_RCVBC);
 850
 851         if (rcvbc > MAX3421_FIFO_SIZE)
 852                 rcvbc = MAX3421_FIFO_SIZE;
 853         if (urb->actual_length >= urb->transfer_buffer_length)
 854                 remaining = 0;
 855         else
 856                 remaining = urb->transfer_buffer_length - urb->actual_length;
 857         transfer_size = rcvbc;
 858         if (transfer_size > remaining)
 859                 transfer_size = remaining;
 860         if (transfer_size > 0) {
 861                 void *dst = urb->transfer_buffer + urb->actual_length;
 862
 863                 spi_rd_buf(hcd, MAX3421_REG_RCVFIFO, dst, transfer_size);
 864                 urb->actual_length += transfer_size;
 865                 max3421_hcd->curr_len = transfer_size;
 866         }
 867
 868         /* ack the RCVDAV irq now that the FIFO has been read: */
 869         spi_wr8(hcd, MAX3421_REG_HIRQ, BIT(MAX3421_HI_RCVDAV_BIT));
 870 }
 871
 872 static void
 873 max3421_handle_error(struct usb_hcd *hcd, u8 hrsl)
 874 {
 875         struct spi_device *spi = to_spi_device(hcd->self.controller);
 876         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 877         u8 result_code = hrsl & MAX3421_HRSL_RESULT_MASK;
 878         struct urb *urb = max3421_hcd->curr_urb;
 879         struct max3421_ep *max3421_ep = urb->ep->hcpriv;
 880         int switch_sndfifo;
 881
 882         /*
 883          * If an OUT command results in any response other than OK
 884          * (i.e., error or NAK), we have to perform a dummy-write to
 885          * SNDBC so the FIFO gets switched back to us.  Otherwise, we
 886          * get out of sync with the SNDFIFO double buffer.
 887          */
 888         switch_sndfifo = (max3421_ep->pkt_state == PKT_STATE_TRANSFER &&
 889                           usb_urb_dir_out(urb));
 890
 891         switch (result_code) {
 892         case MAX3421_HRSL_OK:
 893                 return;                 /* this shouldn't happen */
 894
 895         case MAX3421_HRSL_WRONGPID:     /* received wrong PID */
 896         case MAX3421_HRSL_BUSY:         /* SIE busy */
 897         case MAX3421_HRSL_BADREQ:       /* bad val in HXFR */
 898         case MAX3421_HRSL_UNDEF:        /* reserved */
 899         case MAX3421_HRSL_KERR:         /* K-state instead of response */
 900         case MAX3421_HRSL_JERR:         /* J-state instead of response */
 901                 /*
 902                  * packet experienced an error that we cannot recover
 903                  * from; report error
 904                  */
 905                 max3421_hcd->urb_done = hrsl_to_error[result_code];
 906                 dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
 907                         __func__, hrsl);
 908                 break;
 909
 910         case MAX3421_HRSL_TOGERR:
 911                 if (usb_urb_dir_in(urb))
 912                         ; /* don't do anything (device will switch toggle) */
 913                 else {
 914                         /* flip the send toggle bit: */
 915                         int sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1;
 916
 917                         sndtog ^= 1;
 918                         spi_wr8(hcd, MAX3421_REG_HCTL,
 919                                 BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT));
 920                 }
 921                 /* FALL THROUGH */
 922         case MAX3421_HRSL_BADBC:        /* bad byte count */
 923         case MAX3421_HRSL_PIDERR:       /* received PID is corrupted */
 924         case MAX3421_HRSL_PKTERR:       /* packet error (stuff, EOP) */
 925         case MAX3421_HRSL_CRCERR:       /* CRC error */
 926         case MAX3421_HRSL_BABBLE:       /* device talked too long */
 927         case MAX3421_HRSL_TIMEOUT:
 928                 if (max3421_ep->retries++ < USB_MAX_RETRIES)
 929                         /* retry the packet again in the next frame */
 930                         max3421_slow_retransmit(hcd);
 931                 else {
 932                         /* Based on ohci.h cc_to_err[]: */
 933                         max3421_hcd->urb_done = hrsl_to_error[result_code];
 934                         dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
 935                                 __func__, hrsl);
 936                 }
 937                 break;
 938
 939         case MAX3421_HRSL_STALL:
 940                 dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
 941                         __func__, hrsl);
 942                 max3421_hcd->urb_done = hrsl_to_error[result_code];
 943                 break;
 944
 945         case MAX3421_HRSL_NAK:
 946                 /*
 947                  * Device wasn't ready for data or has no data
 948                  * available: retry the packet again.
 949                  */
 950                 if (max3421_ep->naks++ < NAK_MAX_FAST_RETRANSMITS) {
 951                         max3421_next_transfer(hcd, 1);
 952                         switch_sndfifo = 0;
 953                 } else
 954                         max3421_slow_retransmit(hcd);
 955                 break;
 956         }
 957         if (switch_sndfifo)
 958                 spi_wr8(hcd, MAX3421_REG_SNDBC, 0);
 959 }
 960
 961 /*
 962  * Caller must NOT hold HCD spinlock.
 963  */
 964 static int
 965 max3421_transfer_in_done(struct usb_hcd *hcd, struct urb *urb)
 966 {
 967         struct spi_device *spi = to_spi_device(hcd->self.controller);
 968         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
 969         u32 max_packet;
 970
 971         if (urb->actual_length >= urb->transfer_buffer_length)
 972                 return 1;       /* read is complete, so we're done */
 973
 974         /*
 975          * USB 2.0 Section 5.3.2 Pipes: packets must be full size
 976          * except for last one.
 977          */
 978         max_packet = usb_maxpacket(urb->dev, urb->pipe, 0);
 979         if (max_packet > MAX3421_FIFO_SIZE) {
 980                 /*
 981                  * We do not support isochronous transfers at this
 982                  * time...
 983                  */
 984                 dev_err(&spi->dev,
 985                         "%s: packet-size of %u too big (limit is %u bytes)",
 986                         __func__, max_packet, MAX3421_FIFO_SIZE);
 987                 return -EINVAL;
 988         }
 989
 990         if (max3421_hcd->curr_len < max_packet) {
 991                 if (urb->transfer_flags & URB_SHORT_NOT_OK) {
 992                         /*
 993                          * remaining > 0 and received an
 994                          * unexpected partial packet ->
 995                          * error
 996                          */
 997                         return -EREMOTEIO;
 998                 } else
 999                         /* short read, but it's OK */
1000                         return 1;
1001         }
1002         return 0;       /* not done */
1003 }
1004
1005 /*
1006  * Caller must NOT hold HCD spinlock.
1007  */
1008 static int
1009 max3421_transfer_out_done(struct usb_hcd *hcd, struct urb *urb)
1010 {
1011         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1012
1013         urb->actual_length += max3421_hcd->curr_len;
1014         if (urb->actual_length < urb->transfer_buffer_length)
1015                 return 0;
1016         if (urb->transfer_flags & URB_ZERO_PACKET) {
1017                 /*
1018                  * Some hardware needs a zero-size packet at the end
1019                  * of a bulk-out transfer if the last transfer was a
1020                  * full-sized packet (i.e., such hardware use <
1021                  * max_packet as an indicator that the end of the
1022                  * packet has been reached).
1023                  */
1024                 u32 max_packet = usb_maxpacket(urb->dev, urb->pipe, 1);
1025
1026                 if (max3421_hcd->curr_len == max_packet)
1027                         return 0;
1028         }
1029         return 1;
1030 }
1031
1032 /*
1033  * Caller must NOT hold HCD spinlock.
1034  */
1035 static void
1036 max3421_host_transfer_done(struct usb_hcd *hcd)
1037 {
1038         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1039         struct urb *urb = max3421_hcd->curr_urb;
1040         struct max3421_ep *max3421_ep;
1041         u8 result_code, hrsl;
1042         int urb_done = 0;
1043
1044         max3421_hcd->hien &= ~(BIT(MAX3421_HI_HXFRDN_BIT) |
1045                                BIT(MAX3421_HI_RCVDAV_BIT));
1046
1047         hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
1048         result_code = hrsl & MAX3421_HRSL_RESULT_MASK;
1049
1050 #ifdef DEBUG
1051         ++max3421_hcd->err_stat[result_code];
1052 #endif
1053
1054         max3421_ep = urb->ep->hcpriv;
1055
1056         if (unlikely(result_code != MAX3421_HRSL_OK)) {
1057                 max3421_handle_error(hcd, hrsl);
1058                 return;
1059         }
1060
1061         max3421_ep->naks = 0;
1062         max3421_ep->retries = 0;
1063         switch (max3421_ep->pkt_state) {
1064
1065         case PKT_STATE_SETUP:
1066                 if (urb->transfer_buffer_length > 0)
1067                         max3421_ep->pkt_state = PKT_STATE_TRANSFER;
1068                 else
1069                         max3421_ep->pkt_state = PKT_STATE_TERMINATE;
1070                 break;
1071
1072         case PKT_STATE_TRANSFER:
1073                 if (usb_urb_dir_in(urb))
1074                         urb_done = max3421_transfer_in_done(hcd, urb);
1075                 else
1076                         urb_done = max3421_transfer_out_done(hcd, urb);
1077                 if (urb_done > 0 && usb_pipetype(urb->pipe) == PIPE_CONTROL) {
1078                         /*
1079                          * We aren't really done - we still need to
1080                          * terminate the control transfer:
1081                          */
1082                         max3421_hcd->urb_done = urb_done = 0;
1083                         max3421_ep->pkt_state = PKT_STATE_TERMINATE;
1084                 }
1085                 break;
1086
1087         case PKT_STATE_TERMINATE:
1088                 urb_done = 1;
1089                 break;
1090         }
1091
1092         if (urb_done)
1093                 max3421_hcd->urb_done = urb_done;
1094         else
1095                 max3421_next_transfer(hcd, 0);
1096 }
1097
1098 /*
1099  * Caller must NOT hold HCD spinlock.
1100  */
1101 static void
1102 max3421_detect_conn(struct usb_hcd *hcd)
1103 {
1104         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1105         unsigned int jk, have_conn = 0;
1106         u32 old_port_status, chg;
1107         unsigned long flags;
1108         u8 hrsl, mode;
1109
1110         hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
1111
1112         jk = ((((hrsl >> MAX3421_HRSL_JSTATUS_BIT) & 1) << 0) |
1113               (((hrsl >> MAX3421_HRSL_KSTATUS_BIT) & 1) << 1));
1114
1115         mode = max3421_hcd->mode;
1116
1117         switch (jk) {
1118         case 0x0: /* SE0: disconnect */
1119                 /*
1120                  * Turn off SOFKAENAB bit to avoid getting interrupt
1121                  * every milli-second:
1122                  */
1123                 mode &= ~BIT(MAX3421_MODE_SOFKAENAB_BIT);
1124                 break;
1125
1126         case 0x1: /* J=0,K=1: low-speed (in full-speed or vice versa) */
1127         case 0x2: /* J=1,K=0: full-speed (in full-speed or vice versa) */
1128                 if (jk == 0x2)
1129                         /* need to switch to the other speed: */
1130                         mode ^= BIT(MAX3421_MODE_LOWSPEED_BIT);
1131                 /* turn on SOFKAENAB bit: */
1132                 mode |= BIT(MAX3421_MODE_SOFKAENAB_BIT);
1133                 have_conn = 1;
1134                 break;
1135
1136         case 0x3: /* illegal */
1137                 break;
1138         }
1139
1140         max3421_hcd->mode = mode;
1141         spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
1142
1143         spin_lock_irqsave(&max3421_hcd->lock, flags);
1144         old_port_status = max3421_hcd->port_status;
1145         if (have_conn)
1146                 max3421_hcd->port_status |=  USB_PORT_STAT_CONNECTION;
1147         else
1148                 max3421_hcd->port_status &= ~USB_PORT_STAT_CONNECTION;
1149         if (mode & BIT(MAX3421_MODE_LOWSPEED_BIT))
1150                 max3421_hcd->port_status |=  USB_PORT_STAT_LOW_SPEED;
1151         else
1152                 max3421_hcd->port_status &= ~USB_PORT_STAT_LOW_SPEED;
1153         chg = (old_port_status ^ max3421_hcd->port_status);
1154         max3421_hcd->port_status |= chg << 16;
1155         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1156 }
1157
1158 static irqreturn_t
1159 max3421_irq_handler(int irq, void *dev_id)
1160 {
1161         struct usb_hcd *hcd = dev_id;
1162         struct spi_device *spi = to_spi_device(hcd->self.controller);
1163         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1164
1165         if (max3421_hcd->spi_thread &&
1166             max3421_hcd->spi_thread->state != TASK_RUNNING)
1167                 wake_up_process(max3421_hcd->spi_thread);
1168         if (!max3421_hcd->do_enable_irq) {
1169                 max3421_hcd->do_enable_irq = 1;
1170                 disable_irq_nosync(spi->irq);
1171         }
1172         return IRQ_HANDLED;
1173 }
1174
1175 #ifdef DEBUG
1176
1177 static void
1178 dump_eps(struct usb_hcd *hcd)
1179 {
1180         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1181         struct max3421_ep *max3421_ep;
1182         struct usb_host_endpoint *ep;
1183         struct list_head *pos, *upos;
1184         char ubuf[512], *dp, *end;
1185         unsigned long flags;
1186         struct urb *urb;
1187         int epnum, ret;
1188
1189         spin_lock_irqsave(&max3421_hcd->lock, flags);
1190         list_for_each(pos, &max3421_hcd->ep_list) {
1191                 max3421_ep = container_of(pos, struct max3421_ep, ep_list);
1192                 ep = max3421_ep->ep;
1193
1194                 dp = ubuf;
1195                 end = dp + sizeof(ubuf);
1196                 *dp = '\0';
1197                 list_for_each(upos, &ep->urb_list) {
1198                         urb = container_of(upos, struct urb, urb_list);
1199                         ret = snprintf(dp, end - dp, " %p(%d.%s %d/%d)", urb,
1200                                        usb_pipetype(urb->pipe),
1201                                        usb_urb_dir_in(urb) ? "IN" : "OUT",
1202                                        urb->actual_length,
1203                                        urb->transfer_buffer_length);
1204                         if (ret < 0 || ret >= end - dp)
1205                                 break;  /* error or buffer full */
1206                         dp += ret;
1207                 }
1208
1209                 epnum = usb_endpoint_num(&ep->desc);
1210                 pr_info("EP%0u %u lst %04u rtr %u nak %6u rxmt %u: %s\n",
1211                         epnum, max3421_ep->pkt_state, max3421_ep->last_active,
1212                         max3421_ep->retries, max3421_ep->naks,
1213                         max3421_ep->retransmit, ubuf);
1214         }
1215         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1216 }
1217
1218 #endif /* DEBUG */
1219
1220 /* Return zero if no work was performed, 1 otherwise.  */
1221 static int
1222 max3421_handle_irqs(struct usb_hcd *hcd)
1223 {
1224         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1225         u32 chg, old_port_status;
1226         unsigned long flags;
1227         u8 hirq;
1228
1229         /*
1230          * Read and ack pending interrupts (CPU must never
1231          * clear SNDBAV directly and RCVDAV must be cleared by
1232          * max3421_recv_data_available()!):
1233          */
1234         hirq = spi_rd8(hcd, MAX3421_REG_HIRQ);
1235         hirq &= max3421_hcd->hien;
1236         if (!hirq)
1237                 return 0;
1238
1239         spi_wr8(hcd, MAX3421_REG_HIRQ,
1240                 hirq & ~(BIT(MAX3421_HI_SNDBAV_BIT) |
1241                          BIT(MAX3421_HI_RCVDAV_BIT)));
1242
1243         if (hirq & BIT(MAX3421_HI_FRAME_BIT)) {
1244                 max3421_hcd->frame_number = ((max3421_hcd->frame_number + 1)
1245                                              & USB_MAX_FRAME_NUMBER);
1246                 max3421_hcd->sched_pass = SCHED_PASS_PERIODIC;
1247         }
1248
1249         if (hirq & BIT(MAX3421_HI_RCVDAV_BIT))
1250                 max3421_recv_data_available(hcd);
1251
1252         if (hirq & BIT(MAX3421_HI_HXFRDN_BIT))
1253                 max3421_host_transfer_done(hcd);
1254
1255         if (hirq & BIT(MAX3421_HI_CONDET_BIT))
1256                 max3421_detect_conn(hcd);
1257
1258         /*
1259          * Now process interrupts that may affect HCD state
1260          * other than the end-points:
1261          */
1262         spin_lock_irqsave(&max3421_hcd->lock, flags);
1263
1264         old_port_status = max3421_hcd->port_status;
1265         if (hirq & BIT(MAX3421_HI_BUSEVENT_BIT)) {
1266                 if (max3421_hcd->port_status & USB_PORT_STAT_RESET) {
1267                         /* BUSEVENT due to completion of Bus Reset */
1268                         max3421_hcd->port_status &= ~USB_PORT_STAT_RESET;
1269                         max3421_hcd->port_status |=  USB_PORT_STAT_ENABLE;
1270                 } else {
1271                         /* BUSEVENT due to completion of Bus Resume */
1272                         pr_info("%s: BUSEVENT Bus Resume Done\n", __func__);
1273                 }
1274         }
1275         if (hirq & BIT(MAX3421_HI_RWU_BIT))
1276                 pr_info("%s: RWU\n", __func__);
1277         if (hirq & BIT(MAX3421_HI_SUSDN_BIT))
1278                 pr_info("%s: SUSDN\n", __func__);
1279
1280         chg = (old_port_status ^ max3421_hcd->port_status);
1281         max3421_hcd->port_status |= chg << 16;
1282
1283         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1284
1285 #ifdef DEBUG
1286         {
1287                 static unsigned long last_time;
1288                 char sbuf[16 * 16], *dp, *end;
1289                 int i;
1290
1291                 if (jiffies - last_time > 5*HZ) {
1292                         dp = sbuf;
1293                         end = sbuf + sizeof(sbuf);
1294                         *dp = '\0';
1295                         for (i = 0; i < 16; ++i) {
1296                                 int ret = snprintf(dp, end - dp, " %lu",
1297                                                    max3421_hcd->err_stat[i]);
1298                                 if (ret < 0 || ret >= end - dp)
1299                                         break;  /* error or buffer full */
1300                                 dp += ret;
1301                         }
1302                         pr_info("%s: hrsl_stats %s\n", __func__, sbuf);
1303                         memset(max3421_hcd->err_stat, 0,
1304                                sizeof(max3421_hcd->err_stat));
1305                         last_time = jiffies;
1306
1307                         dump_eps(hcd);
1308                 }
1309         }
1310 #endif
1311         return 1;
1312 }
1313
1314 static int
1315 max3421_reset_hcd(struct usb_hcd *hcd)
1316 {
1317         struct spi_device *spi = to_spi_device(hcd->self.controller);
1318         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1319         int timeout;
1320
1321         /* perform a chip reset and wait for OSCIRQ signal to appear: */
1322         spi_wr8(hcd, MAX3421_REG_USBCTL, BIT(MAX3421_USBCTL_CHIPRES_BIT));
1323         /* clear reset: */
1324         spi_wr8(hcd, MAX3421_REG_USBCTL, 0);
1325         timeout = 1000;
1326         while (1) {
1327                 if (spi_rd8(hcd, MAX3421_REG_USBIRQ)
1328                     & BIT(MAX3421_USBIRQ_OSCOKIRQ_BIT))
1329                         break;
1330                 if (--timeout < 0) {
1331                         dev_err(&spi->dev,
1332                                 "timed out waiting for oscillator OK signal");
1333                         return 1;
1334                 }
1335                 cond_resched();
1336         }
1337
1338         /*
1339          * Turn on host mode, automatic generation of SOF packets, and
1340          * enable pull-down registers on DM/DP:
1341          */
1342         max3421_hcd->mode = (BIT(MAX3421_MODE_HOST_BIT) |
1343                              BIT(MAX3421_MODE_SOFKAENAB_BIT) |
1344                              BIT(MAX3421_MODE_DMPULLDN_BIT) |
1345                              BIT(MAX3421_MODE_DPPULLDN_BIT));
1346         spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
1347
1348         /* reset frame-number: */
1349         max3421_hcd->frame_number = USB_MAX_FRAME_NUMBER;
1350         spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_FRMRST_BIT));
1351
1352         /* sample the state of the D+ and D- lines */
1353         spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_SAMPLEBUS_BIT));
1354         max3421_detect_conn(hcd);
1355
1356         /* enable frame, connection-detected, and bus-event interrupts: */
1357         max3421_hcd->hien = (BIT(MAX3421_HI_FRAME_BIT) |
1358                              BIT(MAX3421_HI_CONDET_BIT) |
1359                              BIT(MAX3421_HI_BUSEVENT_BIT));
1360         spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien);
1361
1362         /* enable interrupts: */
1363         spi_wr8(hcd, MAX3421_REG_CPUCTL, BIT(MAX3421_CPUCTL_IE_BIT));
1364         return 1;
1365 }
1366
1367 static int
1368 max3421_urb_done(struct usb_hcd *hcd)
1369 {
1370         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1371         unsigned long flags;
1372         struct urb *urb;
1373         int status;
1374
1375         status = max3421_hcd->urb_done;
1376         max3421_hcd->urb_done = 0;
1377         if (status > 0)
1378                 status = 0;
1379         urb = max3421_hcd->curr_urb;
1380         if (urb) {
1381                 max3421_hcd->curr_urb = NULL;
1382                 spin_lock_irqsave(&max3421_hcd->lock, flags);
1383                 usb_hcd_unlink_urb_from_ep(hcd, urb);
1384                 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1385
1386                 /* must be called without the HCD spinlock: */
1387                 usb_hcd_giveback_urb(hcd, urb, status);
1388         }
1389         return 1;
1390 }
1391
1392 static int
1393 max3421_spi_thread(void *dev_id)
1394 {
1395         struct usb_hcd *hcd = dev_id;
1396         struct spi_device *spi = to_spi_device(hcd->self.controller);
1397         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1398         int i, i_worked = 1;
1399
1400         /* set full-duplex SPI mode, low-active interrupt pin: */
1401         spi_wr8(hcd, MAX3421_REG_PINCTL,
1402                 (BIT(MAX3421_PINCTL_FDUPSPI_BIT) |      /* full-duplex */
1403                  BIT(MAX3421_PINCTL_INTLEVEL_BIT)));    /* low-active irq */
1404
1405         while (!kthread_should_stop()) {
1406                 max3421_hcd->rev = spi_rd8(hcd, MAX3421_REG_REVISION);
1407                 if (max3421_hcd->rev == 0x12 || max3421_hcd->rev == 0x13)
1408                         break;
1409                 dev_err(&spi->dev, "bad rev 0x%02x", max3421_hcd->rev);
1410                 msleep(10000);
1411         }
1412         dev_info(&spi->dev, "rev 0x%x, SPI clk %dHz, bpw %u, irq %d\n",
1413                  max3421_hcd->rev, spi->max_speed_hz, spi->bits_per_word,
1414                  spi->irq);
1415
1416         while (!kthread_should_stop()) {
1417                 if (!i_worked) {
1418                         /*
1419                          * We'll be waiting for wakeups from the hard
1420                          * interrupt handler, so now is a good time to
1421                          * sync our hien with the chip:
1422                          */
1423                         spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien);
1424
1425                         set_current_state(TASK_INTERRUPTIBLE);
1426                         if (max3421_hcd->do_enable_irq) {
1427                                 max3421_hcd->do_enable_irq = 0;
1428                                 enable_irq(spi->irq);
1429                         }
1430                         schedule();
1431                         __set_current_state(TASK_RUNNING);
1432                 }
1433
1434                 i_worked = 0;
1435
1436                 if (max3421_hcd->urb_done)
1437                         i_worked |= max3421_urb_done(hcd);
1438                 else if (max3421_handle_irqs(hcd))
1439                         i_worked = 1;
1440                 else if (!max3421_hcd->curr_urb)
1441                         i_worked |= max3421_select_and_start_urb(hcd);
1442
1443                 if (max3421_hcd->do_reset_hcd) {
1444                         /* reset the HCD: */
1445                         max3421_hcd->do_reset_hcd = 0;
1446                         i_worked |= max3421_reset_hcd(hcd);
1447                 }
1448                 if (max3421_hcd->do_reset_port) {
1449                         /* perform a USB bus reset: */
1450                         max3421_hcd->do_reset_port = 0;
1451                         spi_wr8(hcd, MAX3421_REG_HCTL,
1452                                 BIT(MAX3421_HCTL_BUSRST_BIT));
1453                         i_worked = 1;
1454                 }
1455                 if (max3421_hcd->do_check_unlink) {
1456                         max3421_hcd->do_check_unlink = 0;
1457                         i_worked |= max3421_check_unlink(hcd);
1458                 }
1459                 if (max3421_hcd->do_iopin_update) {
1460                         /*
1461                          * IOPINS1/IOPINS2 do not auto-increment, so we can't
1462                          * use spi_wr_buf().
1463                          */
1464                         for (i = 0; i < ARRAY_SIZE(max3421_hcd->iopins); ++i) {
1465                                 u8 val = spi_rd8(hcd, MAX3421_REG_IOPINS1);
1466
1467                                 val = ((val & 0xf0) |
1468                                        (max3421_hcd->iopins[i] & 0x0f));
1469                                 spi_wr8(hcd, MAX3421_REG_IOPINS1 + i, val);
1470                                 max3421_hcd->iopins[i] = val;
1471                         }
1472                         max3421_hcd->do_iopin_update = 0;
1473                         i_worked = 1;
1474                 }
1475         }
1476         set_current_state(TASK_RUNNING);
1477         dev_info(&spi->dev, "SPI thread exiting");
1478         return 0;
1479 }
1480
1481 static int
1482 max3421_reset_port(struct usb_hcd *hcd)
1483 {
1484         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1485
1486         max3421_hcd->port_status &= ~(USB_PORT_STAT_ENABLE |
1487                                       USB_PORT_STAT_LOW_SPEED);
1488         max3421_hcd->do_reset_port = 1;
1489         wake_up_process(max3421_hcd->spi_thread);
1490         return 0;
1491 }
1492
1493 static int
1494 max3421_reset(struct usb_hcd *hcd)
1495 {
1496         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1497
1498         hcd->self.sg_tablesize = 0;
1499         hcd->speed = HCD_USB2;
1500         hcd->self.root_hub->speed = USB_SPEED_FULL;
1501         max3421_hcd->do_reset_hcd = 1;
1502         wake_up_process(max3421_hcd->spi_thread);
1503         return 0;
1504 }
1505
1506 static int
1507 max3421_start(struct usb_hcd *hcd)
1508 {
1509         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1510
1511         spin_lock_init(&max3421_hcd->lock);
1512         max3421_hcd->rh_state = MAX3421_RH_RUNNING;
1513
1514         INIT_LIST_HEAD(&max3421_hcd->ep_list);
1515
1516         hcd->power_budget = POWER_BUDGET;
1517         hcd->state = HC_STATE_RUNNING;
1518         hcd->uses_new_polling = 1;
1519         return 0;
1520 }
1521
1522 static void
1523 max3421_stop(struct usb_hcd *hcd)
1524 {
1525 }
1526
1527 static int
1528 max3421_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
1529 {
1530         struct spi_device *spi = to_spi_device(hcd->self.controller);
1531         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1532         struct max3421_ep *max3421_ep;
1533         unsigned long flags;
1534         int retval;
1535
1536         switch (usb_pipetype(urb->pipe)) {
1537         case PIPE_INTERRUPT:
1538         case PIPE_ISOCHRONOUS:
1539                 if (urb->interval < 0) {
1540                         dev_err(&spi->dev,
1541                           "%s: interval=%d for intr-/iso-pipe; expected > 0\n",
1542                                 __func__, urb->interval);
1543                         return -EINVAL;
1544                 }
1545         default:
1546                 break;
1547         }
1548
1549         spin_lock_irqsave(&max3421_hcd->lock, flags);
1550
1551         max3421_ep = urb->ep->hcpriv;
1552         if (!max3421_ep) {
1553                 /* gets freed in max3421_endpoint_disable: */
1554                 max3421_ep = kzalloc(sizeof(struct max3421_ep), mem_flags);
1555                 if (!max3421_ep) {
1556                         retval = -ENOMEM;
1557                         goto out;
1558                 }
1559                 max3421_ep->ep = urb->ep;
1560                 max3421_ep->last_active = max3421_hcd->frame_number;
1561                 urb->ep->hcpriv = max3421_ep;
1562
1563                 list_add_tail(&max3421_ep->ep_list, &max3421_hcd->ep_list);
1564         }
1565
1566         retval = usb_hcd_link_urb_to_ep(hcd, urb);
1567         if (retval == 0) {
1568                 /* Since we added to the queue, restart scheduling: */
1569                 max3421_hcd->sched_pass = SCHED_PASS_PERIODIC;
1570                 wake_up_process(max3421_hcd->spi_thread);
1571         }
1572
1573 out:
1574         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1575         return retval;
1576 }
1577
1578 static int
1579 max3421_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1580 {
1581         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1582         unsigned long flags;
1583         int retval;
1584
1585         spin_lock_irqsave(&max3421_hcd->lock, flags);
1586
1587         /*
1588          * This will set urb->unlinked which in turn causes the entry
1589          * to be dropped at the next opportunity.
1590          */
1591         retval = usb_hcd_check_unlink_urb(hcd, urb, status);
1592         if (retval == 0) {
1593                 max3421_hcd->do_check_unlink = 1;
1594                 wake_up_process(max3421_hcd->spi_thread);
1595         }
1596         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1597         return retval;
1598 }
1599
1600 static void
1601 max3421_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
1602 {
1603         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1604         unsigned long flags;
1605
1606         spin_lock_irqsave(&max3421_hcd->lock, flags);
1607
1608         if (ep->hcpriv) {
1609                 struct max3421_ep *max3421_ep = ep->hcpriv;
1610
1611                 /* remove myself from the ep_list: */
1612                 if (!list_empty(&max3421_ep->ep_list))
1613                         list_del(&max3421_ep->ep_list);
1614                 kfree(max3421_ep);
1615                 ep->hcpriv = NULL;
1616         }
1617
1618         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1619 }
1620
1621 static int
1622 max3421_get_frame_number(struct usb_hcd *hcd)
1623 {
1624         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1625         return max3421_hcd->frame_number;
1626 }
1627
1628 /*
1629  * Should return a non-zero value when any port is undergoing a resume
1630  * transition while the root hub is suspended.
1631  */
1632 static int
1633 max3421_hub_status_data(struct usb_hcd *hcd, char *buf)
1634 {
1635         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1636         unsigned long flags;
1637         int retval = 0;
1638
1639         spin_lock_irqsave(&max3421_hcd->lock, flags);
1640         if (!HCD_HW_ACCESSIBLE(hcd))
1641                 goto done;
1642
1643         *buf = 0;
1644         if ((max3421_hcd->port_status & PORT_C_MASK) != 0) {
1645                 *buf = (1 << 1); /* a hub over-current condition exists */
1646                 dev_dbg(hcd->self.controller,
1647                         "port status 0x%08x has changes\n",
1648                         max3421_hcd->port_status);
1649                 retval = 1;
1650                 if (max3421_hcd->rh_state == MAX3421_RH_SUSPENDED)
1651                         usb_hcd_resume_root_hub(hcd);
1652         }
1653 done:
1654         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1655         return retval;
1656 }
1657
1658 static inline void
1659 hub_descriptor(struct usb_hub_descriptor *desc)
1660 {
1661         memset(desc, 0, sizeof(*desc));
1662         /*
1663          * See Table 11-13: Hub Descriptor in USB 2.0 spec.
1664          */
1665         desc->bDescriptorType = 0x29;   /* hub descriptor */
1666         desc->bDescLength = 9;
1667         desc->wHubCharacteristics = cpu_to_le16(0x0001);
1668         desc->bNbrPorts = 1;
1669 }
1670
1671 /*
1672  * Set the MAX3421E general-purpose output with number PIN_NUMBER to
1673  * VALUE (0 or 1).  PIN_NUMBER may be in the range from 1-8.  For
1674  * any other value, this function acts as a no-op.
1675  */
1676 static void
1677 max3421_gpout_set_value(struct usb_hcd *hcd, u8 pin_number, u8 value)
1678 {
1679         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1680         u8 mask, idx;
1681
1682         --pin_number;
1683         if (pin_number > 7)
1684                 return;
1685
1686         mask = 1u << pin_number;
1687         idx = pin_number / 4;
1688
1689         if (value)
1690                 max3421_hcd->iopins[idx] |=  mask;
1691         else
1692                 max3421_hcd->iopins[idx] &= ~mask;
1693         max3421_hcd->do_iopin_update = 1;
1694         wake_up_process(max3421_hcd->spi_thread);
1695 }
1696
1697 static int
1698 max3421_hub_control(struct usb_hcd *hcd, u16 type_req, u16 value, u16 index,
1699                     char *buf, u16 length)
1700 {
1701         struct spi_device *spi = to_spi_device(hcd->self.controller);
1702         struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1703         struct max3421_hcd_platform_data *pdata;
1704         unsigned long flags;
1705         int retval = 0;
1706
1707         spin_lock_irqsave(&max3421_hcd->lock, flags);
1708
1709         pdata = spi->dev.platform_data;
1710
1711         switch (type_req) {
1712         case ClearHubFeature:
1713                 break;
1714         case ClearPortFeature:
1715                 switch (value) {
1716                 case USB_PORT_FEAT_SUSPEND:
1717                         break;
1718                 case USB_PORT_FEAT_POWER:
1719                         dev_dbg(hcd->self.controller, "power-off\n");
1720                         max3421_gpout_set_value(hcd, pdata->vbus_gpout,
1721                                                 !pdata->vbus_active_level);
1722                         /* FALLS THROUGH */
1723                 default:
1724                         max3421_hcd->port_status &= ~(1 << value);
1725                 }
1726                 break;
1727         case GetHubDescriptor:
1728                 hub_descriptor((struct usb_hub_descriptor *) buf);
1729                 break;
1730
1731         case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
1732         case GetPortErrorCount:
1733         case SetHubDepth:
1734                 /* USB3 only */
1735                 goto error;
1736
1737         case GetHubStatus:
1738                 *(__le32 *) buf = cpu_to_le32(0);
1739                 break;
1740
1741         case GetPortStatus:
1742                 if (index != 1) {
1743                         retval = -EPIPE;
1744                         goto error;
1745                 }
1746                 ((__le16 *) buf)[0] = cpu_to_le16(max3421_hcd->port_status);
1747                 ((__le16 *) buf)[1] =
1748                         cpu_to_le16(max3421_hcd->port_status >> 16);
1749                 break;
1750
1751         case SetHubFeature:
1752                 retval = -EPIPE;
1753                 break;
1754
1755         case SetPortFeature:
1756                 switch (value) {
1757                 case USB_PORT_FEAT_LINK_STATE:
1758                 case USB_PORT_FEAT_U1_TIMEOUT:
1759                 case USB_PORT_FEAT_U2_TIMEOUT:
1760                 case USB_PORT_FEAT_BH_PORT_RESET:
1761                         goto error;
1762                 case USB_PORT_FEAT_SUSPEND:
1763                         if (max3421_hcd->active)
1764                                 max3421_hcd->port_status |=
1765                                         USB_PORT_STAT_SUSPEND;
1766                         break;
1767                 case USB_PORT_FEAT_POWER:
1768                         dev_dbg(hcd->self.controller, "power-on\n");
1769                         max3421_hcd->port_status |= USB_PORT_STAT_POWER;
1770                         max3421_gpout_set_value(hcd, pdata->vbus_gpout,
1771                                                 pdata->vbus_active_level);
1772                         break;
1773                 case USB_PORT_FEAT_RESET:
1774                         max3421_reset_port(hcd);
1775                         /* FALLS THROUGH */
1776                 default:
1777                         if ((max3421_hcd->port_status & USB_PORT_STAT_POWER)
1778                             != 0)
1779                                 max3421_hcd->port_status |= (1 << value);
1780                 }
1781                 break;
1782
1783         default:
1784                 dev_dbg(hcd->self.controller,
1785                         "hub control req%04x v%04x i%04x l%d\n",
1786                         type_req, value, index, length);
1787 error:          /* "protocol stall" on error */
1788                 retval = -EPIPE;
1789         }
1790
1791         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1792         return retval;
1793 }
1794
1795 static int
1796 max3421_bus_suspend(struct usb_hcd *hcd)
1797 {
1798         return -1;
1799 }
1800
1801 static int
1802 max3421_bus_resume(struct usb_hcd *hcd)
1803 {
1804         return -1;
1805 }
1806
1807 /*
1808  * The SPI driver already takes care of DMA-mapping/unmapping, so no
1809  * reason to do it twice.
1810  */
1811 static int
1812 max3421_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
1813 {
1814         return 0;
1815 }
1816
1817 static void
1818 max3421_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1819 {
1820 }
1821
1822 static struct hc_driver max3421_hcd_desc = {
1823         .description =          "max3421",
1824         .product_desc =         DRIVER_DESC,
1825         .hcd_priv_size =        sizeof(struct max3421_hcd),
1826         .flags =                HCD_USB11,
1827         .reset =                max3421_reset,
1828         .start =                max3421_start,
1829         .stop =                 max3421_stop,
1830         .get_frame_number =     max3421_get_frame_number,
1831         .urb_enqueue =          max3421_urb_enqueue,
1832         .urb_dequeue =          max3421_urb_dequeue,
1833         .map_urb_for_dma =      max3421_map_urb_for_dma,
1834         .unmap_urb_for_dma =    max3421_unmap_urb_for_dma,
1835         .endpoint_disable =     max3421_endpoint_disable,
1836         .hub_status_data =      max3421_hub_status_data,
1837         .hub_control =          max3421_hub_control,
1838         .bus_suspend =          max3421_bus_suspend,
1839         .bus_resume =           max3421_bus_resume,
1840 };
1841
1842 static int
1843 max3421_probe(struct spi_device *spi)
1844 {
1845         struct max3421_hcd *max3421_hcd;
1846         struct usb_hcd *hcd = NULL;
1847         int retval = -ENOMEM;
1848
1849         if (spi_setup(spi) < 0) {
1850                 dev_err(&spi->dev, "Unable to setup SPI bus");
1851                 return -EFAULT;
1852         }
1853
1854         hcd = usb_create_hcd(&max3421_hcd_desc, &spi->dev,
1855                              dev_name(&spi->dev));
1856         if (!hcd) {
1857                 dev_err(&spi->dev, "failed to create HCD structure\n");
1858                 goto error;
1859         }
1860         set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
1861         max3421_hcd = hcd_to_max3421(hcd);
1862         max3421_hcd->next = max3421_hcd_list;
1863         max3421_hcd_list = max3421_hcd;
1864         INIT_LIST_HEAD(&max3421_hcd->ep_list);
1865
1866         max3421_hcd->tx = kmalloc(sizeof(*max3421_hcd->tx), GFP_KERNEL);
1867         if (!max3421_hcd->tx) {
1868                 dev_err(&spi->dev, "failed to kmalloc tx buffer\n");
1869                 goto error;
1870         }
1871         max3421_hcd->rx = kmalloc(sizeof(*max3421_hcd->rx), GFP_KERNEL);
1872         if (!max3421_hcd->rx) {
1873                 dev_err(&spi->dev, "failed to kmalloc rx buffer\n");
1874                 goto error;
1875         }
1876
1877         max3421_hcd->spi_thread = kthread_run(max3421_spi_thread, hcd,
1878                                               "max3421_spi_thread");
1879         if (max3421_hcd->spi_thread == ERR_PTR(-ENOMEM)) {
1880                 dev_err(&spi->dev,
1881                         "failed to create SPI thread (out of memory)\n");
1882                 goto error;
1883         }
1884
1885         retval = usb_add_hcd(hcd, 0, 0);
1886         if (retval) {
1887                 dev_err(&spi->dev, "failed to add HCD\n");
1888                 goto error;
1889         }
1890
1891         retval = request_irq(spi->irq, max3421_irq_handler,
1892                              IRQF_TRIGGER_LOW, "max3421", hcd);
1893         if (retval < 0) {
1894                 dev_err(&spi->dev, "failed to request irq %d\n", spi->irq);
1895                 goto error;
1896         }
1897         return 0;
1898
1899 error:
1900         if (hcd) {
1901                 kfree(max3421_hcd->tx);
1902                 kfree(max3421_hcd->rx);
1903                 if (max3421_hcd->spi_thread)
1904                         kthread_stop(max3421_hcd->spi_thread);
1905                 usb_put_hcd(hcd);
1906         }
1907         return retval;
1908 }
1909
1910 static int
1911 max3421_remove(struct spi_device *spi)
1912 {
1913         struct max3421_hcd *max3421_hcd = NULL, **prev;
1914         struct usb_hcd *hcd = NULL;
1915         unsigned long flags;
1916
1917         for (prev = &max3421_hcd_list; *prev; prev = &(*prev)->next) {
1918                 max3421_hcd = *prev;
1919                 hcd = max3421_to_hcd(max3421_hcd);
1920                 if (hcd->self.controller == &spi->dev)
1921                         break;
1922         }
1923         if (!max3421_hcd) {
1924                 dev_err(&spi->dev, "no MAX3421 HCD found for SPI device %p\n",
1925                         spi);
1926                 return -ENODEV;
1927         }
1928
1929         usb_remove_hcd(hcd);
1930
1931         spin_lock_irqsave(&max3421_hcd->lock, flags);
1932
1933         kthread_stop(max3421_hcd->spi_thread);
1934         *prev = max3421_hcd->next;
1935
1936         spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1937
1938         free_irq(spi->irq, hcd);
1939
1940         usb_put_hcd(hcd);
1941         return 0;
1942 }
1943
1944 static struct spi_driver max3421_driver = {
1945         .probe          = max3421_probe,
1946         .remove         = max3421_remove,
1947         .driver         = {
1948                 .name   = "max3421-hcd",
1949                 .owner  = THIS_MODULE,
1950         },
1951 };
1952
1953 module_spi_driver(max3421_driver);
1954
1955 MODULE_DESCRIPTION(DRIVER_DESC);
1956 MODULE_AUTHOR("David Mosberger <davidm@egauge.net>");
1957 MODULE_LICENSE("GPL");