/* * MAX3421 Host Controller driver for USB. * * Author: David Mosberger-Tang * * (C) Copyright 2014 David Mosberger-Tang * * MAX3421 is a chip implementing a USB 2.0 Full-/Low-Speed host * controller on a SPI bus. * * Based on: * o MAX3421E datasheet * http://datasheets.maximintegrated.com/en/ds/MAX3421E.pdf * o MAX3421E Programming Guide * http://www.hdl.co.jp/ftpdata/utl-001/AN3785.pdf * o gadget/dummy_hcd.c * For USB HCD implementation. * o Arduino MAX3421 driver * https://github.com/felis/USB_Host_Shield_2.0/blob/master/Usb.cpp * * This file is licenced under the GPL v2. * * Important note on worst-case (full-speed) packet size constraints * (See USB 2.0 Section 5.6.3 and following): * * - control: 64 bytes * - isochronous: 1023 bytes * - interrupt: 64 bytes * - bulk: 64 bytes * * Since the MAX3421 FIFO size is 64 bytes, we do not have to work about * multi-FIFO writes/reads for a single USB packet *except* for isochronous * transfers. We don't support isochronous transfers at this time, so we * just assume that a USB packet always fits into a single FIFO buffer. * * NOTE: The June 2006 version of "MAX3421E Programming Guide" * (AN3785) has conflicting info for the RCVDAVIRQ bit: * * The description of RCVDAVIRQ says "The CPU *must* clear * this IRQ bit (by writing a 1 to it) before reading the * RCVFIFO data. * * However, the earlier section on "Programming BULK-IN * Transfers" says * that: * * After the CPU retrieves the data, it clears the * RCVDAVIRQ bit. * * The December 2006 version has been corrected and it consistently * states the second behavior is the correct one. * * Synchronous SPI transactions sleep so we can't perform any such * transactions while holding a spin-lock (and/or while interrupts are * masked). To achieve this, all SPI transactions are issued from a * single thread (max3421_spi_thread). */ #include #include #include #include #include #include #define DRIVER_DESC "MAX3421 USB Host-Controller Driver" #define DRIVER_VERSION "1.0" /* 11-bit counter that wraps around (USB 2.0 Section 8.3.3): */ #define USB_MAX_FRAME_NUMBER 0x7ff #define USB_MAX_RETRIES 3 /* # of retries before error is reported */ /* * Max. # of times we're willing to retransmit a request immediately in * resposne to a NAK. Afterwards, we fall back on trying once a frame. */ #define NAK_MAX_FAST_RETRANSMITS 2 #define POWER_BUDGET 500 /* in mA; use 8 for low-power port testing */ /* Port-change mask: */ #define PORT_C_MASK ((USB_PORT_STAT_C_CONNECTION | \ USB_PORT_STAT_C_ENABLE | \ USB_PORT_STAT_C_SUSPEND | \ USB_PORT_STAT_C_OVERCURRENT | \ USB_PORT_STAT_C_RESET) << 16) enum max3421_rh_state { MAX3421_RH_RESET, MAX3421_RH_SUSPENDED, MAX3421_RH_RUNNING }; enum pkt_state { PKT_STATE_SETUP, /* waiting to send setup packet to ctrl pipe */ PKT_STATE_TRANSFER, /* waiting to xfer transfer_buffer */ PKT_STATE_TERMINATE /* waiting to terminate control transfer */ }; enum scheduling_pass { SCHED_PASS_PERIODIC, SCHED_PASS_NON_PERIODIC, SCHED_PASS_DONE }; /* Bit numbers for max3421_hcd->todo: */ enum { ENABLE_IRQ = 0, RESET_HCD, RESET_PORT, CHECK_UNLINK, IOPIN_UPDATE }; struct max3421_dma_buf { u8 data[2]; }; struct max3421_hcd { spinlock_t lock; struct task_struct *spi_thread; struct max3421_hcd *next; enum max3421_rh_state rh_state; /* lower 16 bits contain port status, upper 16 bits the change mask: */ u32 port_status; unsigned active:1; struct list_head ep_list; /* list of EP's with work */ /* * The following are owned by spi_thread (may be accessed by * SPI-thread without acquiring the HCD lock: */ u8 rev; /* chip revision */ u16 frame_number; /* * kmalloc'd buffers guaranteed to be in separate (DMA) * cache-lines: */ struct max3421_dma_buf *tx; struct max3421_dma_buf *rx; /* * URB we're currently processing. Must not be reset to NULL * unless MAX3421E chip is idle: */ struct urb *curr_urb; enum scheduling_pass sched_pass; struct usb_device *loaded_dev; /* dev that's loaded into the chip */ int loaded_epnum; /* epnum whose toggles are loaded */ int urb_done; /* > 0 -> no errors, < 0: errno */ size_t curr_len; u8 hien; u8 mode; u8 iopins[2]; unsigned long todo; #ifdef DEBUG unsigned long err_stat[16]; #endif }; struct max3421_ep { struct usb_host_endpoint *ep; struct list_head ep_list; u32 naks; u16 last_active; /* frame # this ep was last active */ enum pkt_state pkt_state; u8 retries; u8 retransmit; /* packet needs retransmission */ }; static struct max3421_hcd *max3421_hcd_list; #define MAX3421_FIFO_SIZE 64 #define MAX3421_SPI_DIR_RD 0 /* read register from MAX3421 */ #define MAX3421_SPI_DIR_WR 1 /* write register to MAX3421 */ /* SPI commands: */ #define MAX3421_SPI_DIR_SHIFT 1 #define MAX3421_SPI_REG_SHIFT 3 #define MAX3421_REG_RCVFIFO 1 #define MAX3421_REG_SNDFIFO 2 #define MAX3421_REG_SUDFIFO 4 #define MAX3421_REG_RCVBC 6 #define MAX3421_REG_SNDBC 7 #define MAX3421_REG_USBIRQ 13 #define MAX3421_REG_USBIEN 14 #define MAX3421_REG_USBCTL 15 #define MAX3421_REG_CPUCTL 16 #define MAX3421_REG_PINCTL 17 #define MAX3421_REG_REVISION 18 #define MAX3421_REG_IOPINS1 20 #define MAX3421_REG_IOPINS2 21 #define MAX3421_REG_GPINIRQ 22 #define MAX3421_REG_GPINIEN 23 #define MAX3421_REG_GPINPOL 24 #define MAX3421_REG_HIRQ 25 #define MAX3421_REG_HIEN 26 #define MAX3421_REG_MODE 27 #define MAX3421_REG_PERADDR 28 #define MAX3421_REG_HCTL 29 #define MAX3421_REG_HXFR 30 #define MAX3421_REG_HRSL 31 enum { MAX3421_USBIRQ_OSCOKIRQ_BIT = 0, MAX3421_USBIRQ_NOVBUSIRQ_BIT = 5, MAX3421_USBIRQ_VBUSIRQ_BIT }; enum { MAX3421_CPUCTL_IE_BIT = 0, MAX3421_CPUCTL_PULSEWID0_BIT = 6, MAX3421_CPUCTL_PULSEWID1_BIT }; enum { MAX3421_USBCTL_PWRDOWN_BIT = 4, MAX3421_USBCTL_CHIPRES_BIT }; enum { MAX3421_PINCTL_GPXA_BIT = 0, MAX3421_PINCTL_GPXB_BIT, MAX3421_PINCTL_POSINT_BIT, MAX3421_PINCTL_INTLEVEL_BIT, MAX3421_PINCTL_FDUPSPI_BIT, MAX3421_PINCTL_EP0INAK_BIT, MAX3421_PINCTL_EP2INAK_BIT, MAX3421_PINCTL_EP3INAK_BIT, }; enum { MAX3421_HI_BUSEVENT_BIT = 0, /* bus-reset/-resume */ MAX3421_HI_RWU_BIT, /* remote wakeup */ MAX3421_HI_RCVDAV_BIT, /* receive FIFO data available */ MAX3421_HI_SNDBAV_BIT, /* send buffer available */ MAX3421_HI_SUSDN_BIT, /* suspend operation done */ MAX3421_HI_CONDET_BIT, /* peripheral connect/disconnect */ MAX3421_HI_FRAME_BIT, /* frame generator */ MAX3421_HI_HXFRDN_BIT, /* host transfer done */ }; enum { MAX3421_HCTL_BUSRST_BIT = 0, MAX3421_HCTL_FRMRST_BIT, MAX3421_HCTL_SAMPLEBUS_BIT, MAX3421_HCTL_SIGRSM_BIT, MAX3421_HCTL_RCVTOG0_BIT, MAX3421_HCTL_RCVTOG1_BIT, MAX3421_HCTL_SNDTOG0_BIT, MAX3421_HCTL_SNDTOG1_BIT }; enum { MAX3421_MODE_HOST_BIT = 0, MAX3421_MODE_LOWSPEED_BIT, MAX3421_MODE_HUBPRE_BIT, MAX3421_MODE_SOFKAENAB_BIT, MAX3421_MODE_SEPIRQ_BIT, MAX3421_MODE_DELAYISO_BIT, MAX3421_MODE_DMPULLDN_BIT, MAX3421_MODE_DPPULLDN_BIT }; enum { MAX3421_HRSL_OK = 0, MAX3421_HRSL_BUSY, MAX3421_HRSL_BADREQ, MAX3421_HRSL_UNDEF, MAX3421_HRSL_NAK, MAX3421_HRSL_STALL, MAX3421_HRSL_TOGERR, MAX3421_HRSL_WRONGPID, MAX3421_HRSL_BADBC, MAX3421_HRSL_PIDERR, MAX3421_HRSL_PKTERR, MAX3421_HRSL_CRCERR, MAX3421_HRSL_KERR, MAX3421_HRSL_JERR, MAX3421_HRSL_TIMEOUT, MAX3421_HRSL_BABBLE, MAX3421_HRSL_RESULT_MASK = 0xf, MAX3421_HRSL_RCVTOGRD_BIT = 4, MAX3421_HRSL_SNDTOGRD_BIT, MAX3421_HRSL_KSTATUS_BIT, MAX3421_HRSL_JSTATUS_BIT }; /* Return same error-codes as ohci.h:cc_to_error: */ static const int hrsl_to_error[] = { [MAX3421_HRSL_OK] = 0, [MAX3421_HRSL_BUSY] = -EINVAL, [MAX3421_HRSL_BADREQ] = -EINVAL, [MAX3421_HRSL_UNDEF] = -EINVAL, [MAX3421_HRSL_NAK] = -EAGAIN, [MAX3421_HRSL_STALL] = -EPIPE, [MAX3421_HRSL_TOGERR] = -EILSEQ, [MAX3421_HRSL_WRONGPID] = -EPROTO, [MAX3421_HRSL_BADBC] = -EREMOTEIO, [MAX3421_HRSL_PIDERR] = -EPROTO, [MAX3421_HRSL_PKTERR] = -EPROTO, [MAX3421_HRSL_CRCERR] = -EILSEQ, [MAX3421_HRSL_KERR] = -EIO, [MAX3421_HRSL_JERR] = -EIO, [MAX3421_HRSL_TIMEOUT] = -ETIME, [MAX3421_HRSL_BABBLE] = -EOVERFLOW }; /* * See http://www.beyondlogic.org/usbnutshell/usb4.shtml#Control for a * reasonable overview of how control transfers use the the IN/OUT * tokens. */ #define MAX3421_HXFR_BULK_IN(ep) (0x00 | (ep)) /* bulk or interrupt */ #define MAX3421_HXFR_SETUP 0x10 #define MAX3421_HXFR_BULK_OUT(ep) (0x20 | (ep)) /* bulk or interrupt */ #define MAX3421_HXFR_ISO_IN(ep) (0x40 | (ep)) #define MAX3421_HXFR_ISO_OUT(ep) (0x60 | (ep)) #define MAX3421_HXFR_HS_IN 0x80 /* handshake in */ #define MAX3421_HXFR_HS_OUT 0xa0 /* handshake out */ #define field(val, bit) ((val) << (bit)) static inline s16 frame_diff(u16 left, u16 right) { return ((unsigned) (left - right)) % (USB_MAX_FRAME_NUMBER + 1); } static inline struct max3421_hcd * hcd_to_max3421(struct usb_hcd *hcd) { return (struct max3421_hcd *) hcd->hcd_priv; } static inline struct usb_hcd * max3421_to_hcd(struct max3421_hcd *max3421_hcd) { return container_of((void *) max3421_hcd, struct usb_hcd, hcd_priv); } static u8 spi_rd8(struct usb_hcd *hcd, unsigned int reg) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct spi_device *spi = to_spi_device(hcd->self.controller); struct spi_transfer transfer; struct spi_message msg; memset(&transfer, 0, sizeof(transfer)); spi_message_init(&msg); max3421_hcd->tx->data[0] = (field(reg, MAX3421_SPI_REG_SHIFT) | field(MAX3421_SPI_DIR_RD, MAX3421_SPI_DIR_SHIFT)); transfer.tx_buf = max3421_hcd->tx->data; transfer.rx_buf = max3421_hcd->rx->data; transfer.len = 2; spi_message_add_tail(&transfer, &msg); spi_sync(spi, &msg); return max3421_hcd->rx->data[1]; } static void spi_wr8(struct usb_hcd *hcd, unsigned int reg, u8 val) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct spi_transfer transfer; struct spi_message msg; memset(&transfer, 0, sizeof(transfer)); spi_message_init(&msg); max3421_hcd->tx->data[0] = (field(reg, MAX3421_SPI_REG_SHIFT) | field(MAX3421_SPI_DIR_WR, MAX3421_SPI_DIR_SHIFT)); max3421_hcd->tx->data[1] = val; transfer.tx_buf = max3421_hcd->tx->data; transfer.len = 2; spi_message_add_tail(&transfer, &msg); spi_sync(spi, &msg); } static void spi_rd_buf(struct usb_hcd *hcd, unsigned int reg, void *buf, size_t len) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct spi_transfer transfer[2]; struct spi_message msg; memset(transfer, 0, sizeof(transfer)); spi_message_init(&msg); max3421_hcd->tx->data[0] = (field(reg, MAX3421_SPI_REG_SHIFT) | field(MAX3421_SPI_DIR_RD, MAX3421_SPI_DIR_SHIFT)); transfer[0].tx_buf = max3421_hcd->tx->data; transfer[0].len = 1; transfer[1].rx_buf = buf; transfer[1].len = len; spi_message_add_tail(&transfer[0], &msg); spi_message_add_tail(&transfer[1], &msg); spi_sync(spi, &msg); } static void spi_wr_buf(struct usb_hcd *hcd, unsigned int reg, void *buf, size_t len) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct spi_transfer transfer[2]; struct spi_message msg; memset(transfer, 0, sizeof(transfer)); spi_message_init(&msg); max3421_hcd->tx->data[0] = (field(reg, MAX3421_SPI_REG_SHIFT) | field(MAX3421_SPI_DIR_WR, MAX3421_SPI_DIR_SHIFT)); transfer[0].tx_buf = max3421_hcd->tx->data; transfer[0].len = 1; transfer[1].tx_buf = buf; transfer[1].len = len; spi_message_add_tail(&transfer[0], &msg); spi_message_add_tail(&transfer[1], &msg); spi_sync(spi, &msg); } /* * Figure out the correct setting for the LOWSPEED and HUBPRE mode * bits. The HUBPRE bit needs to be set when MAX3421E operates at * full speed, but it's talking to a low-speed device (i.e., through a * hub). Setting that bit ensures that every low-speed packet is * preceded by a full-speed PRE PID. Possible configurations: * * Hub speed: Device speed: => LOWSPEED bit: HUBPRE bit: * FULL FULL => 0 0 * FULL LOW => 1 1 * LOW LOW => 1 0 * LOW FULL => 1 0 */ static void max3421_set_speed(struct usb_hcd *hcd, struct usb_device *dev) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); u8 mode_lowspeed, mode_hubpre, mode = max3421_hcd->mode; mode_lowspeed = BIT(MAX3421_MODE_LOWSPEED_BIT); mode_hubpre = BIT(MAX3421_MODE_HUBPRE_BIT); if (max3421_hcd->port_status & USB_PORT_STAT_LOW_SPEED) { mode |= mode_lowspeed; mode &= ~mode_hubpre; } else if (dev->speed == USB_SPEED_LOW) { mode |= mode_lowspeed | mode_hubpre; } else { mode &= ~(mode_lowspeed | mode_hubpre); } if (mode != max3421_hcd->mode) { max3421_hcd->mode = mode; spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode); } } /* * Caller must NOT hold HCD spinlock. */ static void max3421_set_address(struct usb_hcd *hcd, struct usb_device *dev, int epnum, int force_toggles) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); int old_epnum, same_ep, rcvtog, sndtog; struct usb_device *old_dev; u8 hctl; old_dev = max3421_hcd->loaded_dev; old_epnum = max3421_hcd->loaded_epnum; same_ep = (dev == old_dev && epnum == old_epnum); if (same_ep && !force_toggles) return; if (old_dev && !same_ep) { /* save the old end-points toggles: */ u8 hrsl = spi_rd8(hcd, MAX3421_REG_HRSL); rcvtog = (hrsl >> MAX3421_HRSL_RCVTOGRD_BIT) & 1; sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1; /* no locking: HCD (i.e., we) own toggles, don't we? */ usb_settoggle(old_dev, old_epnum, 0, rcvtog); usb_settoggle(old_dev, old_epnum, 1, sndtog); } /* setup new endpoint's toggle bits: */ rcvtog = usb_gettoggle(dev, epnum, 0); sndtog = usb_gettoggle(dev, epnum, 1); hctl = (BIT(rcvtog + MAX3421_HCTL_RCVTOG0_BIT) | BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT)); max3421_hcd->loaded_epnum = epnum; spi_wr8(hcd, MAX3421_REG_HCTL, hctl); /* * Note: devnum for one and the same device can change during * address-assignment so it's best to just always load the * address whenever the end-point changed/was forced. */ max3421_hcd->loaded_dev = dev; spi_wr8(hcd, MAX3421_REG_PERADDR, dev->devnum); } static int max3421_ctrl_setup(struct usb_hcd *hcd, struct urb *urb) { spi_wr_buf(hcd, MAX3421_REG_SUDFIFO, urb->setup_packet, 8); return MAX3421_HXFR_SETUP; } static int max3421_transfer_in(struct usb_hcd *hcd, struct urb *urb) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); int epnum = usb_pipeendpoint(urb->pipe); max3421_hcd->curr_len = 0; max3421_hcd->hien |= BIT(MAX3421_HI_RCVDAV_BIT); return MAX3421_HXFR_BULK_IN(epnum); } static int max3421_transfer_out(struct usb_hcd *hcd, struct urb *urb, int fast_retransmit) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); int epnum = usb_pipeendpoint(urb->pipe); u32 max_packet; void *src; src = urb->transfer_buffer + urb->actual_length; if (fast_retransmit) { if (max3421_hcd->rev == 0x12) { /* work around rev 0x12 bug: */ spi_wr8(hcd, MAX3421_REG_SNDBC, 0); spi_wr8(hcd, MAX3421_REG_SNDFIFO, ((u8 *) src)[0]); spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len); } return MAX3421_HXFR_BULK_OUT(epnum); } max_packet = usb_maxpacket(urb->dev, urb->pipe, 1); if (max_packet > MAX3421_FIFO_SIZE) { /* * We do not support isochronous transfers at this * time. */ dev_err(&spi->dev, "%s: packet-size of %u too big (limit is %u bytes)", __func__, max_packet, MAX3421_FIFO_SIZE); max3421_hcd->urb_done = -EMSGSIZE; return -EMSGSIZE; } max3421_hcd->curr_len = min((urb->transfer_buffer_length - urb->actual_length), max_packet); spi_wr_buf(hcd, MAX3421_REG_SNDFIFO, src, max3421_hcd->curr_len); spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len); return MAX3421_HXFR_BULK_OUT(epnum); } /* * Issue the next host-transfer command. * Caller must NOT hold HCD spinlock. */ static void max3421_next_transfer(struct usb_hcd *hcd, int fast_retransmit) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct urb *urb = max3421_hcd->curr_urb; struct max3421_ep *max3421_ep; int cmd = -EINVAL; if (!urb) return; /* nothing to do */ max3421_ep = urb->ep->hcpriv; switch (max3421_ep->pkt_state) { case PKT_STATE_SETUP: cmd = max3421_ctrl_setup(hcd, urb); break; case PKT_STATE_TRANSFER: if (usb_urb_dir_in(urb)) cmd = max3421_transfer_in(hcd, urb); else cmd = max3421_transfer_out(hcd, urb, fast_retransmit); break; case PKT_STATE_TERMINATE: /* * IN transfers are terminated with HS_OUT token, * OUT transfers with HS_IN: */ if (usb_urb_dir_in(urb)) cmd = MAX3421_HXFR_HS_OUT; else cmd = MAX3421_HXFR_HS_IN; break; } if (cmd < 0) return; /* issue the command and wait for host-xfer-done interrupt: */ spi_wr8(hcd, MAX3421_REG_HXFR, cmd); max3421_hcd->hien |= BIT(MAX3421_HI_HXFRDN_BIT); } /* * Find the next URB to process and start its execution. * * At this time, we do not anticipate ever connecting a USB hub to the * MAX3421 chip, so at most USB device can be connected and we can use * a simplistic scheduler: at the start of a frame, schedule all * periodic transfers. Once that is done, use the remainder of the * frame to process non-periodic (bulk & control) transfers. * * Preconditions: * o Caller must NOT hold HCD spinlock. * o max3421_hcd->curr_urb MUST BE NULL. * o MAX3421E chip must be idle. */ static int max3421_select_and_start_urb(struct usb_hcd *hcd) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct urb *urb, *curr_urb = NULL; struct max3421_ep *max3421_ep; int epnum, force_toggles = 0; struct usb_host_endpoint *ep; struct list_head *pos; unsigned long flags; spin_lock_irqsave(&max3421_hcd->lock, flags); for (; max3421_hcd->sched_pass < SCHED_PASS_DONE; ++max3421_hcd->sched_pass) list_for_each(pos, &max3421_hcd->ep_list) { urb = NULL; max3421_ep = container_of(pos, struct max3421_ep, ep_list); ep = max3421_ep->ep; switch (usb_endpoint_type(&ep->desc)) { case USB_ENDPOINT_XFER_ISOC: case USB_ENDPOINT_XFER_INT: if (max3421_hcd->sched_pass != SCHED_PASS_PERIODIC) continue; break; case USB_ENDPOINT_XFER_CONTROL: case USB_ENDPOINT_XFER_BULK: if (max3421_hcd->sched_pass != SCHED_PASS_NON_PERIODIC) continue; break; } if (list_empty(&ep->urb_list)) continue; /* nothing to do */ urb = list_first_entry(&ep->urb_list, struct urb, urb_list); if (urb->unlinked) { dev_dbg(&spi->dev, "%s: URB %p unlinked=%d", __func__, urb, urb->unlinked); max3421_hcd->curr_urb = urb; max3421_hcd->urb_done = 1; spin_unlock_irqrestore(&max3421_hcd->lock, flags); return 1; } switch (usb_endpoint_type(&ep->desc)) { case USB_ENDPOINT_XFER_CONTROL: /* * Allow one control transaction per * frame per endpoint: */ if (frame_diff(max3421_ep->last_active, max3421_hcd->frame_number) == 0) continue; break; case USB_ENDPOINT_XFER_BULK: if (max3421_ep->retransmit && (frame_diff(max3421_ep->last_active, max3421_hcd->frame_number) == 0)) /* * We already tried this EP * during this frame and got a * NAK or error; wait for next frame */ continue; break; case USB_ENDPOINT_XFER_ISOC: case USB_ENDPOINT_XFER_INT: if (frame_diff(max3421_hcd->frame_number, max3421_ep->last_active) < urb->interval) /* * We already processed this * end-point in the current * frame */ continue; break; } /* move current ep to tail: */ list_move_tail(pos, &max3421_hcd->ep_list); curr_urb = urb; goto done; } done: if (!curr_urb) { spin_unlock_irqrestore(&max3421_hcd->lock, flags); return 0; } urb = max3421_hcd->curr_urb = curr_urb; epnum = usb_endpoint_num(&urb->ep->desc); if (max3421_ep->retransmit) /* restart (part of) a USB transaction: */ max3421_ep->retransmit = 0; else { /* start USB transaction: */ if (usb_endpoint_xfer_control(&ep->desc)) { /* * See USB 2.0 spec section 8.6.1 * Initialization via SETUP Token: */ usb_settoggle(urb->dev, epnum, 0, 1); usb_settoggle(urb->dev, epnum, 1, 1); max3421_ep->pkt_state = PKT_STATE_SETUP; force_toggles = 1; } else max3421_ep->pkt_state = PKT_STATE_TRANSFER; } spin_unlock_irqrestore(&max3421_hcd->lock, flags); max3421_ep->last_active = max3421_hcd->frame_number; max3421_set_address(hcd, urb->dev, epnum, force_toggles); max3421_set_speed(hcd, urb->dev); max3421_next_transfer(hcd, 0); return 1; } /* * Check all endpoints for URBs that got unlinked. * * Caller must NOT hold HCD spinlock. */ static int max3421_check_unlink(struct usb_hcd *hcd) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct list_head *pos, *upos, *next_upos; struct max3421_ep *max3421_ep; struct usb_host_endpoint *ep; struct urb *urb; unsigned long flags; int retval = 0; spin_lock_irqsave(&max3421_hcd->lock, flags); list_for_each(pos, &max3421_hcd->ep_list) { max3421_ep = container_of(pos, struct max3421_ep, ep_list); ep = max3421_ep->ep; list_for_each_safe(upos, next_upos, &ep->urb_list) { urb = container_of(upos, struct urb, urb_list); if (urb->unlinked) { retval = 1; dev_dbg(&spi->dev, "%s: URB %p unlinked=%d", __func__, urb, urb->unlinked); usb_hcd_unlink_urb_from_ep(hcd, urb); spin_unlock_irqrestore(&max3421_hcd->lock, flags); usb_hcd_giveback_urb(hcd, urb, 0); spin_lock_irqsave(&max3421_hcd->lock, flags); } } } spin_unlock_irqrestore(&max3421_hcd->lock, flags); return retval; } /* * Caller must NOT hold HCD spinlock. */ static void max3421_slow_retransmit(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct urb *urb = max3421_hcd->curr_urb; struct max3421_ep *max3421_ep; max3421_ep = urb->ep->hcpriv; max3421_ep->retransmit = 1; max3421_hcd->curr_urb = NULL; } /* * Caller must NOT hold HCD spinlock. */ static void max3421_recv_data_available(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct urb *urb = max3421_hcd->curr_urb; size_t remaining, transfer_size; u8 rcvbc; rcvbc = spi_rd8(hcd, MAX3421_REG_RCVBC); if (rcvbc > MAX3421_FIFO_SIZE) rcvbc = MAX3421_FIFO_SIZE; if (urb->actual_length >= urb->transfer_buffer_length) remaining = 0; else remaining = urb->transfer_buffer_length - urb->actual_length; transfer_size = rcvbc; if (transfer_size > remaining) transfer_size = remaining; if (transfer_size > 0) { void *dst = urb->transfer_buffer + urb->actual_length; spi_rd_buf(hcd, MAX3421_REG_RCVFIFO, dst, transfer_size); urb->actual_length += transfer_size; max3421_hcd->curr_len = transfer_size; } /* ack the RCVDAV irq now that the FIFO has been read: */ spi_wr8(hcd, MAX3421_REG_HIRQ, BIT(MAX3421_HI_RCVDAV_BIT)); } static void max3421_handle_error(struct usb_hcd *hcd, u8 hrsl) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); u8 result_code = hrsl & MAX3421_HRSL_RESULT_MASK; struct urb *urb = max3421_hcd->curr_urb; struct max3421_ep *max3421_ep = urb->ep->hcpriv; int switch_sndfifo; /* * If an OUT command results in any response other than OK * (i.e., error or NAK), we have to perform a dummy-write to * SNDBC so the FIFO gets switched back to us. Otherwise, we * get out of sync with the SNDFIFO double buffer. */ switch_sndfifo = (max3421_ep->pkt_state == PKT_STATE_TRANSFER && usb_urb_dir_out(urb)); switch (result_code) { case MAX3421_HRSL_OK: return; /* this shouldn't happen */ case MAX3421_HRSL_WRONGPID: /* received wrong PID */ case MAX3421_HRSL_BUSY: /* SIE busy */ case MAX3421_HRSL_BADREQ: /* bad val in HXFR */ case MAX3421_HRSL_UNDEF: /* reserved */ case MAX3421_HRSL_KERR: /* K-state instead of response */ case MAX3421_HRSL_JERR: /* J-state instead of response */ /* * packet experienced an error that we cannot recover * from; report error */ max3421_hcd->urb_done = hrsl_to_error[result_code]; dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x", __func__, hrsl); break; case MAX3421_HRSL_TOGERR: if (usb_urb_dir_in(urb)) ; /* don't do anything (device will switch toggle) */ else { /* flip the send toggle bit: */ int sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1; sndtog ^= 1; spi_wr8(hcd, MAX3421_REG_HCTL, BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT)); } /* FALL THROUGH */ case MAX3421_HRSL_BADBC: /* bad byte count */ case MAX3421_HRSL_PIDERR: /* received PID is corrupted */ case MAX3421_HRSL_PKTERR: /* packet error (stuff, EOP) */ case MAX3421_HRSL_CRCERR: /* CRC error */ case MAX3421_HRSL_BABBLE: /* device talked too long */ case MAX3421_HRSL_TIMEOUT: if (max3421_ep->retries++ < USB_MAX_RETRIES) /* retry the packet again in the next frame */ max3421_slow_retransmit(hcd); else { /* Based on ohci.h cc_to_err[]: */ max3421_hcd->urb_done = hrsl_to_error[result_code]; dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x", __func__, hrsl); } break; case MAX3421_HRSL_STALL: dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x", __func__, hrsl); max3421_hcd->urb_done = hrsl_to_error[result_code]; break; case MAX3421_HRSL_NAK: /* * Device wasn't ready for data or has no data * available: retry the packet again. */ if (max3421_ep->naks++ < NAK_MAX_FAST_RETRANSMITS) { max3421_next_transfer(hcd, 1); switch_sndfifo = 0; } else max3421_slow_retransmit(hcd); break; } if (switch_sndfifo) spi_wr8(hcd, MAX3421_REG_SNDBC, 0); } /* * Caller must NOT hold HCD spinlock. */ static int max3421_transfer_in_done(struct usb_hcd *hcd, struct urb *urb) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); u32 max_packet; if (urb->actual_length >= urb->transfer_buffer_length) return 1; /* read is complete, so we're done */ /* * USB 2.0 Section 5.3.2 Pipes: packets must be full size * except for last one. */ max_packet = usb_maxpacket(urb->dev, urb->pipe, 0); if (max_packet > MAX3421_FIFO_SIZE) { /* * We do not support isochronous transfers at this * time... */ dev_err(&spi->dev, "%s: packet-size of %u too big (limit is %u bytes)", __func__, max_packet, MAX3421_FIFO_SIZE); return -EINVAL; } if (max3421_hcd->curr_len < max_packet) { if (urb->transfer_flags & URB_SHORT_NOT_OK) { /* * remaining > 0 and received an * unexpected partial packet -> * error */ return -EREMOTEIO; } else /* short read, but it's OK */ return 1; } return 0; /* not done */ } /* * Caller must NOT hold HCD spinlock. */ static int max3421_transfer_out_done(struct usb_hcd *hcd, struct urb *urb) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); urb->actual_length += max3421_hcd->curr_len; if (urb->actual_length < urb->transfer_buffer_length) return 0; if (urb->transfer_flags & URB_ZERO_PACKET) { /* * Some hardware needs a zero-size packet at the end * of a bulk-out transfer if the last transfer was a * full-sized packet (i.e., such hardware use < * max_packet as an indicator that the end of the * packet has been reached). */ u32 max_packet = usb_maxpacket(urb->dev, urb->pipe, 1); if (max3421_hcd->curr_len == max_packet) return 0; } return 1; } /* * Caller must NOT hold HCD spinlock. */ static void max3421_host_transfer_done(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct urb *urb = max3421_hcd->curr_urb; struct max3421_ep *max3421_ep; u8 result_code, hrsl; int urb_done = 0; max3421_hcd->hien &= ~(BIT(MAX3421_HI_HXFRDN_BIT) | BIT(MAX3421_HI_RCVDAV_BIT)); hrsl = spi_rd8(hcd, MAX3421_REG_HRSL); result_code = hrsl & MAX3421_HRSL_RESULT_MASK; #ifdef DEBUG ++max3421_hcd->err_stat[result_code]; #endif max3421_ep = urb->ep->hcpriv; if (unlikely(result_code != MAX3421_HRSL_OK)) { max3421_handle_error(hcd, hrsl); return; } max3421_ep->naks = 0; max3421_ep->retries = 0; switch (max3421_ep->pkt_state) { case PKT_STATE_SETUP: if (urb->transfer_buffer_length > 0) max3421_ep->pkt_state = PKT_STATE_TRANSFER; else max3421_ep->pkt_state = PKT_STATE_TERMINATE; break; case PKT_STATE_TRANSFER: if (usb_urb_dir_in(urb)) urb_done = max3421_transfer_in_done(hcd, urb); else urb_done = max3421_transfer_out_done(hcd, urb); if (urb_done > 0 && usb_pipetype(urb->pipe) == PIPE_CONTROL) { /* * We aren't really done - we still need to * terminate the control transfer: */ max3421_hcd->urb_done = urb_done = 0; max3421_ep->pkt_state = PKT_STATE_TERMINATE; } break; case PKT_STATE_TERMINATE: urb_done = 1; break; } if (urb_done) max3421_hcd->urb_done = urb_done; else max3421_next_transfer(hcd, 0); } /* * Caller must NOT hold HCD spinlock. */ static void max3421_detect_conn(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); unsigned int jk, have_conn = 0; u32 old_port_status, chg; unsigned long flags; u8 hrsl, mode; hrsl = spi_rd8(hcd, MAX3421_REG_HRSL); jk = ((((hrsl >> MAX3421_HRSL_JSTATUS_BIT) & 1) << 0) | (((hrsl >> MAX3421_HRSL_KSTATUS_BIT) & 1) << 1)); mode = max3421_hcd->mode; switch (jk) { case 0x0: /* SE0: disconnect */ /* * Turn off SOFKAENAB bit to avoid getting interrupt * every milli-second: */ mode &= ~BIT(MAX3421_MODE_SOFKAENAB_BIT); break; case 0x1: /* J=0,K=1: low-speed (in full-speed or vice versa) */ case 0x2: /* J=1,K=0: full-speed (in full-speed or vice versa) */ if (jk == 0x2) /* need to switch to the other speed: */ mode ^= BIT(MAX3421_MODE_LOWSPEED_BIT); /* turn on SOFKAENAB bit: */ mode |= BIT(MAX3421_MODE_SOFKAENAB_BIT); have_conn = 1; break; case 0x3: /* illegal */ break; } max3421_hcd->mode = mode; spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode); spin_lock_irqsave(&max3421_hcd->lock, flags); old_port_status = max3421_hcd->port_status; if (have_conn) max3421_hcd->port_status |= USB_PORT_STAT_CONNECTION; else max3421_hcd->port_status &= ~USB_PORT_STAT_CONNECTION; if (mode & BIT(MAX3421_MODE_LOWSPEED_BIT)) max3421_hcd->port_status |= USB_PORT_STAT_LOW_SPEED; else max3421_hcd->port_status &= ~USB_PORT_STAT_LOW_SPEED; chg = (old_port_status ^ max3421_hcd->port_status); max3421_hcd->port_status |= chg << 16; spin_unlock_irqrestore(&max3421_hcd->lock, flags); } static irqreturn_t max3421_irq_handler(int irq, void *dev_id) { struct usb_hcd *hcd = dev_id; struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); if (max3421_hcd->spi_thread && max3421_hcd->spi_thread->state != TASK_RUNNING) wake_up_process(max3421_hcd->spi_thread); if (!test_and_set_bit(ENABLE_IRQ, &max3421_hcd->todo)) disable_irq_nosync(spi->irq); return IRQ_HANDLED; } #ifdef DEBUG static void dump_eps(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct max3421_ep *max3421_ep; struct usb_host_endpoint *ep; struct list_head *pos, *upos; char ubuf[512], *dp, *end; unsigned long flags; struct urb *urb; int epnum, ret; spin_lock_irqsave(&max3421_hcd->lock, flags); list_for_each(pos, &max3421_hcd->ep_list) { max3421_ep = container_of(pos, struct max3421_ep, ep_list); ep = max3421_ep->ep; dp = ubuf; end = dp + sizeof(ubuf); *dp = '\0'; list_for_each(upos, &ep->urb_list) { urb = container_of(upos, struct urb, urb_list); ret = snprintf(dp, end - dp, " %p(%d.%s %d/%d)", urb, usb_pipetype(urb->pipe), usb_urb_dir_in(urb) ? "IN" : "OUT", urb->actual_length, urb->transfer_buffer_length); if (ret < 0 || ret >= end - dp) break; /* error or buffer full */ dp += ret; } epnum = usb_endpoint_num(&ep->desc); pr_info("EP%0u %u lst %04u rtr %u nak %6u rxmt %u: %s\n", epnum, max3421_ep->pkt_state, max3421_ep->last_active, max3421_ep->retries, max3421_ep->naks, max3421_ep->retransmit, ubuf); } spin_unlock_irqrestore(&max3421_hcd->lock, flags); } #endif /* DEBUG */ /* Return zero if no work was performed, 1 otherwise. */ static int max3421_handle_irqs(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); u32 chg, old_port_status; unsigned long flags; u8 hirq; /* * Read and ack pending interrupts (CPU must never * clear SNDBAV directly and RCVDAV must be cleared by * max3421_recv_data_available()!): */ hirq = spi_rd8(hcd, MAX3421_REG_HIRQ); hirq &= max3421_hcd->hien; if (!hirq) return 0; spi_wr8(hcd, MAX3421_REG_HIRQ, hirq & ~(BIT(MAX3421_HI_SNDBAV_BIT) | BIT(MAX3421_HI_RCVDAV_BIT))); if (hirq & BIT(MAX3421_HI_FRAME_BIT)) { max3421_hcd->frame_number = ((max3421_hcd->frame_number + 1) & USB_MAX_FRAME_NUMBER); max3421_hcd->sched_pass = SCHED_PASS_PERIODIC; } if (hirq & BIT(MAX3421_HI_RCVDAV_BIT)) max3421_recv_data_available(hcd); if (hirq & BIT(MAX3421_HI_HXFRDN_BIT)) max3421_host_transfer_done(hcd); if (hirq & BIT(MAX3421_HI_CONDET_BIT)) max3421_detect_conn(hcd); /* * Now process interrupts that may affect HCD state * other than the end-points: */ spin_lock_irqsave(&max3421_hcd->lock, flags); old_port_status = max3421_hcd->port_status; if (hirq & BIT(MAX3421_HI_BUSEVENT_BIT)) { if (max3421_hcd->port_status & USB_PORT_STAT_RESET) { /* BUSEVENT due to completion of Bus Reset */ max3421_hcd->port_status &= ~USB_PORT_STAT_RESET; max3421_hcd->port_status |= USB_PORT_STAT_ENABLE; } else { /* BUSEVENT due to completion of Bus Resume */ pr_info("%s: BUSEVENT Bus Resume Done\n", __func__); } } if (hirq & BIT(MAX3421_HI_RWU_BIT)) pr_info("%s: RWU\n", __func__); if (hirq & BIT(MAX3421_HI_SUSDN_BIT)) pr_info("%s: SUSDN\n", __func__); chg = (old_port_status ^ max3421_hcd->port_status); max3421_hcd->port_status |= chg << 16; spin_unlock_irqrestore(&max3421_hcd->lock, flags); #ifdef DEBUG { static unsigned long last_time; char sbuf[16 * 16], *dp, *end; int i; if (time_after(jiffies, last_time + 5*HZ)) { dp = sbuf; end = sbuf + sizeof(sbuf); *dp = '\0'; for (i = 0; i < 16; ++i) { int ret = snprintf(dp, end - dp, " %lu", max3421_hcd->err_stat[i]); if (ret < 0 || ret >= end - dp) break; /* error or buffer full */ dp += ret; } pr_info("%s: hrsl_stats %s\n", __func__, sbuf); memset(max3421_hcd->err_stat, 0, sizeof(max3421_hcd->err_stat)); last_time = jiffies; dump_eps(hcd); } } #endif return 1; } static int max3421_reset_hcd(struct usb_hcd *hcd) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); int timeout; /* perform a chip reset and wait for OSCIRQ signal to appear: */ spi_wr8(hcd, MAX3421_REG_USBCTL, BIT(MAX3421_USBCTL_CHIPRES_BIT)); /* clear reset: */ spi_wr8(hcd, MAX3421_REG_USBCTL, 0); timeout = 1000; while (1) { if (spi_rd8(hcd, MAX3421_REG_USBIRQ) & BIT(MAX3421_USBIRQ_OSCOKIRQ_BIT)) break; if (--timeout < 0) { dev_err(&spi->dev, "timed out waiting for oscillator OK signal"); return 1; } cond_resched(); } /* * Turn on host mode, automatic generation of SOF packets, and * enable pull-down registers on DM/DP: */ max3421_hcd->mode = (BIT(MAX3421_MODE_HOST_BIT) | BIT(MAX3421_MODE_SOFKAENAB_BIT) | BIT(MAX3421_MODE_DMPULLDN_BIT) | BIT(MAX3421_MODE_DPPULLDN_BIT)); spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode); /* reset frame-number: */ max3421_hcd->frame_number = USB_MAX_FRAME_NUMBER; spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_FRMRST_BIT)); /* sample the state of the D+ and D- lines */ spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_SAMPLEBUS_BIT)); max3421_detect_conn(hcd); /* enable frame, connection-detected, and bus-event interrupts: */ max3421_hcd->hien = (BIT(MAX3421_HI_FRAME_BIT) | BIT(MAX3421_HI_CONDET_BIT) | BIT(MAX3421_HI_BUSEVENT_BIT)); spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien); /* enable interrupts: */ spi_wr8(hcd, MAX3421_REG_CPUCTL, BIT(MAX3421_CPUCTL_IE_BIT)); return 1; } static int max3421_urb_done(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); unsigned long flags; struct urb *urb; int status; status = max3421_hcd->urb_done; max3421_hcd->urb_done = 0; if (status > 0) status = 0; urb = max3421_hcd->curr_urb; if (urb) { max3421_hcd->curr_urb = NULL; spin_lock_irqsave(&max3421_hcd->lock, flags); usb_hcd_unlink_urb_from_ep(hcd, urb); spin_unlock_irqrestore(&max3421_hcd->lock, flags); /* must be called without the HCD spinlock: */ usb_hcd_giveback_urb(hcd, urb, status); } return 1; } static int max3421_spi_thread(void *dev_id) { struct usb_hcd *hcd = dev_id; struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); int i, i_worked = 1; /* set full-duplex SPI mode, low-active interrupt pin: */ spi_wr8(hcd, MAX3421_REG_PINCTL, (BIT(MAX3421_PINCTL_FDUPSPI_BIT) | /* full-duplex */ BIT(MAX3421_PINCTL_INTLEVEL_BIT))); /* low-active irq */ while (!kthread_should_stop()) { max3421_hcd->rev = spi_rd8(hcd, MAX3421_REG_REVISION); if (max3421_hcd->rev == 0x12 || max3421_hcd->rev == 0x13) break; dev_err(&spi->dev, "bad rev 0x%02x", max3421_hcd->rev); msleep(10000); } dev_info(&spi->dev, "rev 0x%x, SPI clk %dHz, bpw %u, irq %d\n", max3421_hcd->rev, spi->max_speed_hz, spi->bits_per_word, spi->irq); while (!kthread_should_stop()) { if (!i_worked) { /* * We'll be waiting for wakeups from the hard * interrupt handler, so now is a good time to * sync our hien with the chip: */ spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien); set_current_state(TASK_INTERRUPTIBLE); if (test_and_clear_bit(ENABLE_IRQ, &max3421_hcd->todo)) enable_irq(spi->irq); schedule(); __set_current_state(TASK_RUNNING); } i_worked = 0; if (max3421_hcd->urb_done) i_worked |= max3421_urb_done(hcd); else if (max3421_handle_irqs(hcd)) i_worked = 1; else if (!max3421_hcd->curr_urb) i_worked |= max3421_select_and_start_urb(hcd); if (test_and_clear_bit(RESET_HCD, &max3421_hcd->todo)) /* reset the HCD: */ i_worked |= max3421_reset_hcd(hcd); if (test_and_clear_bit(RESET_PORT, &max3421_hcd->todo)) { /* perform a USB bus reset: */ spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_BUSRST_BIT)); i_worked = 1; } if (test_and_clear_bit(CHECK_UNLINK, &max3421_hcd->todo)) i_worked |= max3421_check_unlink(hcd); if (test_and_clear_bit(IOPIN_UPDATE, &max3421_hcd->todo)) { /* * IOPINS1/IOPINS2 do not auto-increment, so we can't * use spi_wr_buf(). */ for (i = 0; i < ARRAY_SIZE(max3421_hcd->iopins); ++i) { u8 val = spi_rd8(hcd, MAX3421_REG_IOPINS1); val = ((val & 0xf0) | (max3421_hcd->iopins[i] & 0x0f)); spi_wr8(hcd, MAX3421_REG_IOPINS1 + i, val); max3421_hcd->iopins[i] = val; } i_worked = 1; } } set_current_state(TASK_RUNNING); dev_info(&spi->dev, "SPI thread exiting"); return 0; } static int max3421_reset_port(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); max3421_hcd->port_status &= ~(USB_PORT_STAT_ENABLE | USB_PORT_STAT_LOW_SPEED); max3421_hcd->port_status |= USB_PORT_STAT_RESET; set_bit(RESET_PORT, &max3421_hcd->todo); wake_up_process(max3421_hcd->spi_thread); return 0; } static int max3421_reset(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); hcd->self.sg_tablesize = 0; hcd->speed = HCD_USB2; hcd->self.root_hub->speed = USB_SPEED_FULL; set_bit(RESET_HCD, &max3421_hcd->todo); wake_up_process(max3421_hcd->spi_thread); return 0; } static int max3421_start(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); spin_lock_init(&max3421_hcd->lock); max3421_hcd->rh_state = MAX3421_RH_RUNNING; INIT_LIST_HEAD(&max3421_hcd->ep_list); hcd->power_budget = POWER_BUDGET; hcd->state = HC_STATE_RUNNING; hcd->uses_new_polling = 1; return 0; } static void max3421_stop(struct usb_hcd *hcd) { } static int max3421_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct max3421_ep *max3421_ep; unsigned long flags; int retval; switch (usb_pipetype(urb->pipe)) { case PIPE_INTERRUPT: case PIPE_ISOCHRONOUS: if (urb->interval < 0) { dev_err(&spi->dev, "%s: interval=%d for intr-/iso-pipe; expected > 0\n", __func__, urb->interval); return -EINVAL; } default: break; } spin_lock_irqsave(&max3421_hcd->lock, flags); max3421_ep = urb->ep->hcpriv; if (!max3421_ep) { /* gets freed in max3421_endpoint_disable: */ max3421_ep = kzalloc(sizeof(struct max3421_ep), GFP_ATOMIC); if (!max3421_ep) { retval = -ENOMEM; goto out; } max3421_ep->ep = urb->ep; max3421_ep->last_active = max3421_hcd->frame_number; urb->ep->hcpriv = max3421_ep; list_add_tail(&max3421_ep->ep_list, &max3421_hcd->ep_list); } retval = usb_hcd_link_urb_to_ep(hcd, urb); if (retval == 0) { /* Since we added to the queue, restart scheduling: */ max3421_hcd->sched_pass = SCHED_PASS_PERIODIC; wake_up_process(max3421_hcd->spi_thread); } out: spin_unlock_irqrestore(&max3421_hcd->lock, flags); return retval; } static int max3421_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); unsigned long flags; int retval; spin_lock_irqsave(&max3421_hcd->lock, flags); /* * This will set urb->unlinked which in turn causes the entry * to be dropped at the next opportunity. */ retval = usb_hcd_check_unlink_urb(hcd, urb, status); if (retval == 0) { set_bit(CHECK_UNLINK, &max3421_hcd->todo); wake_up_process(max3421_hcd->spi_thread); } spin_unlock_irqrestore(&max3421_hcd->lock, flags); return retval; } static void max3421_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); unsigned long flags; spin_lock_irqsave(&max3421_hcd->lock, flags); if (ep->hcpriv) { struct max3421_ep *max3421_ep = ep->hcpriv; /* remove myself from the ep_list: */ if (!list_empty(&max3421_ep->ep_list)) list_del(&max3421_ep->ep_list); kfree(max3421_ep); ep->hcpriv = NULL; } spin_unlock_irqrestore(&max3421_hcd->lock, flags); } static int max3421_get_frame_number(struct usb_hcd *hcd) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); return max3421_hcd->frame_number; } /* * Should return a non-zero value when any port is undergoing a resume * transition while the root hub is suspended. */ static int max3421_hub_status_data(struct usb_hcd *hcd, char *buf) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); unsigned long flags; int retval = 0; spin_lock_irqsave(&max3421_hcd->lock, flags); if (!HCD_HW_ACCESSIBLE(hcd)) goto done; *buf = 0; if ((max3421_hcd->port_status & PORT_C_MASK) != 0) { *buf = (1 << 1); /* a hub over-current condition exists */ dev_dbg(hcd->self.controller, "port status 0x%08x has changes\n", max3421_hcd->port_status); retval = 1; if (max3421_hcd->rh_state == MAX3421_RH_SUSPENDED) usb_hcd_resume_root_hub(hcd); } done: spin_unlock_irqrestore(&max3421_hcd->lock, flags); return retval; } static inline void hub_descriptor(struct usb_hub_descriptor *desc) { memset(desc, 0, sizeof(*desc)); /* * See Table 11-13: Hub Descriptor in USB 2.0 spec. */ desc->bDescriptorType = 0x29; /* hub descriptor */ desc->bDescLength = 9; desc->wHubCharacteristics = cpu_to_le16(0x0001); desc->bNbrPorts = 1; } /* * Set the MAX3421E general-purpose output with number PIN_NUMBER to * VALUE (0 or 1). PIN_NUMBER may be in the range from 1-8. For * any other value, this function acts as a no-op. */ static void max3421_gpout_set_value(struct usb_hcd *hcd, u8 pin_number, u8 value) { struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); u8 mask, idx; --pin_number; if (pin_number > 7) return; mask = 1u << pin_number; idx = pin_number / 4; if (value) max3421_hcd->iopins[idx] |= mask; else max3421_hcd->iopins[idx] &= ~mask; set_bit(IOPIN_UPDATE, &max3421_hcd->todo); wake_up_process(max3421_hcd->spi_thread); } static int max3421_hub_control(struct usb_hcd *hcd, u16 type_req, u16 value, u16 index, char *buf, u16 length) { struct spi_device *spi = to_spi_device(hcd->self.controller); struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); struct max3421_hcd_platform_data *pdata; unsigned long flags; int retval = 0; spin_lock_irqsave(&max3421_hcd->lock, flags); pdata = spi->dev.platform_data; switch (type_req) { case ClearHubFeature: break; case ClearPortFeature: switch (value) { case USB_PORT_FEAT_SUSPEND: break; case USB_PORT_FEAT_POWER: dev_dbg(hcd->self.controller, "power-off\n"); max3421_gpout_set_value(hcd, pdata->vbus_gpout, !pdata->vbus_active_level); /* FALLS THROUGH */ default: max3421_hcd->port_status &= ~(1 << value); } break; case GetHubDescriptor: hub_descriptor((struct usb_hub_descriptor *) buf); break; case DeviceRequest | USB_REQ_GET_DESCRIPTOR: case GetPortErrorCount: case SetHubDepth: /* USB3 only */ goto error; case GetHubStatus: *(__le32 *) buf = cpu_to_le32(0); break; case GetPortStatus: if (index != 1) { retval = -EPIPE; goto error; } ((__le16 *) buf)[0] = cpu_to_le16(max3421_hcd->port_status); ((__le16 *) buf)[1] = cpu_to_le16(max3421_hcd->port_status >> 16); break; case SetHubFeature: retval = -EPIPE; break; case SetPortFeature: switch (value) { case USB_PORT_FEAT_LINK_STATE: case USB_PORT_FEAT_U1_TIMEOUT: case USB_PORT_FEAT_U2_TIMEOUT: case USB_PORT_FEAT_BH_PORT_RESET: goto error; case USB_PORT_FEAT_SUSPEND: if (max3421_hcd->active) max3421_hcd->port_status |= USB_PORT_STAT_SUSPEND; break; case USB_PORT_FEAT_POWER: dev_dbg(hcd->self.controller, "power-on\n"); max3421_hcd->port_status |= USB_PORT_STAT_POWER; max3421_gpout_set_value(hcd, pdata->vbus_gpout, pdata->vbus_active_level); break; case USB_PORT_FEAT_RESET: max3421_reset_port(hcd); /* FALLS THROUGH */ default: if ((max3421_hcd->port_status & USB_PORT_STAT_POWER) != 0) max3421_hcd->port_status |= (1 << value); } break; default: dev_dbg(hcd->self.controller, "hub control req%04x v%04x i%04x l%d\n", type_req, value, index, length); error: /* "protocol stall" on error */ retval = -EPIPE; } spin_unlock_irqrestore(&max3421_hcd->lock, flags); return retval; } static int max3421_bus_suspend(struct usb_hcd *hcd) { return -1; } static int max3421_bus_resume(struct usb_hcd *hcd) { return -1; } /* * The SPI driver already takes care of DMA-mapping/unmapping, so no * reason to do it twice. */ static int max3421_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags) { return 0; } static void max3421_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb) { } static struct hc_driver max3421_hcd_desc = { .description = "max3421", .product_desc = DRIVER_DESC, .hcd_priv_size = sizeof(struct max3421_hcd), .flags = HCD_USB11, .reset = max3421_reset, .start = max3421_start, .stop = max3421_stop, .get_frame_number = max3421_get_frame_number, .urb_enqueue = max3421_urb_enqueue, .urb_dequeue = max3421_urb_dequeue, .map_urb_for_dma = max3421_map_urb_for_dma, .unmap_urb_for_dma = max3421_unmap_urb_for_dma, .endpoint_disable = max3421_endpoint_disable, .hub_status_data = max3421_hub_status_data, .hub_control = max3421_hub_control, .bus_suspend = max3421_bus_suspend, .bus_resume = max3421_bus_resume, }; static int max3421_probe(struct spi_device *spi) { struct max3421_hcd *max3421_hcd; struct usb_hcd *hcd = NULL; int retval = -ENOMEM; if (spi_setup(spi) < 0) { dev_err(&spi->dev, "Unable to setup SPI bus"); return -EFAULT; } hcd = usb_create_hcd(&max3421_hcd_desc, &spi->dev, dev_name(&spi->dev)); if (!hcd) { dev_err(&spi->dev, "failed to create HCD structure\n"); goto error; } set_bit(HCD_FLAG_POLL_RH, &hcd->flags); max3421_hcd = hcd_to_max3421(hcd); max3421_hcd->next = max3421_hcd_list; max3421_hcd_list = max3421_hcd; INIT_LIST_HEAD(&max3421_hcd->ep_list); max3421_hcd->tx = kmalloc(sizeof(*max3421_hcd->tx), GFP_KERNEL); if (!max3421_hcd->tx) { dev_err(&spi->dev, "failed to kmalloc tx buffer\n"); goto error; } max3421_hcd->rx = kmalloc(sizeof(*max3421_hcd->rx), GFP_KERNEL); if (!max3421_hcd->rx) { dev_err(&spi->dev, "failed to kmalloc rx buffer\n"); goto error; } max3421_hcd->spi_thread = kthread_run(max3421_spi_thread, hcd, "max3421_spi_thread"); if (max3421_hcd->spi_thread == ERR_PTR(-ENOMEM)) { dev_err(&spi->dev, "failed to create SPI thread (out of memory)\n"); goto error; } retval = usb_add_hcd(hcd, 0, 0); if (retval) { dev_err(&spi->dev, "failed to add HCD\n"); goto error; } retval = request_irq(spi->irq, max3421_irq_handler, IRQF_TRIGGER_LOW, "max3421", hcd); if (retval < 0) { dev_err(&spi->dev, "failed to request irq %d\n", spi->irq); goto error; } return 0; error: if (hcd) { kfree(max3421_hcd->tx); kfree(max3421_hcd->rx); if (max3421_hcd->spi_thread) kthread_stop(max3421_hcd->spi_thread); usb_put_hcd(hcd); } return retval; } static int max3421_remove(struct spi_device *spi) { struct max3421_hcd *max3421_hcd = NULL, **prev; struct usb_hcd *hcd = NULL; unsigned long flags; for (prev = &max3421_hcd_list; *prev; prev = &(*prev)->next) { max3421_hcd = *prev; hcd = max3421_to_hcd(max3421_hcd); if (hcd->self.controller == &spi->dev) break; } if (!max3421_hcd) { dev_err(&spi->dev, "no MAX3421 HCD found for SPI device %p\n", spi); return -ENODEV; } usb_remove_hcd(hcd); spin_lock_irqsave(&max3421_hcd->lock, flags); kthread_stop(max3421_hcd->spi_thread); *prev = max3421_hcd->next; spin_unlock_irqrestore(&max3421_hcd->lock, flags); free_irq(spi->irq, hcd); usb_put_hcd(hcd); return 0; } static struct spi_driver max3421_driver = { .probe = max3421_probe, .remove = max3421_remove, .driver = { .name = "max3421-hcd", .owner = THIS_MODULE, }, }; module_spi_driver(max3421_driver); MODULE_DESCRIPTION(DRIVER_DESC); MODULE_AUTHOR("David Mosberger "); MODULE_LICENSE("GPL");