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