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