1 // SPDX-License-Identifier: GPL-2.0
3 * MAX3421 Host Controller driver for USB.
5 * Author: David Mosberger-Tang <davidm@egauge.net>
7 * (C) Copyright 2014 David Mosberger-Tang <davidm@egauge.net>
9 * MAX3421 is a chip implementing a USB 2.0 Full-/Low-Speed host
10 * controller on a SPI bus.
13 * o MAX3421E datasheet
14 * http://datasheets.maximintegrated.com/en/ds/MAX3421E.pdf
15 * o MAX3421E Programming Guide
16 * http://www.hdl.co.jp/ftpdata/utl-001/AN3785.pdf
17 * o gadget/dummy_hcd.c
18 * For USB HCD implementation.
19 * o Arduino MAX3421 driver
20 * https://github.com/felis/USB_Host_Shield_2.0/blob/master/Usb.cpp
22 * This file is licenced under the GPL v2.
24 * Important note on worst-case (full-speed) packet size constraints
25 * (See USB 2.0 Section 5.6.3 and following):
28 * - isochronous: 1023 bytes
29 * - interrupt: 64 bytes
32 * Since the MAX3421 FIFO size is 64 bytes, we do not have to work about
33 * multi-FIFO writes/reads for a single USB packet *except* for isochronous
34 * transfers. We don't support isochronous transfers at this time, so we
35 * just assume that a USB packet always fits into a single FIFO buffer.
37 * NOTE: The June 2006 version of "MAX3421E Programming Guide"
38 * (AN3785) has conflicting info for the RCVDAVIRQ bit:
40 * The description of RCVDAVIRQ says "The CPU *must* clear
41 * this IRQ bit (by writing a 1 to it) before reading the
44 * However, the earlier section on "Programming BULK-IN
45 * Transfers" says * that:
47 * After the CPU retrieves the data, it clears the
50 * The December 2006 version has been corrected and it consistently
51 * states the second behavior is the correct one.
53 * Synchronous SPI transactions sleep so we can't perform any such
54 * transactions while holding a spin-lock (and/or while interrupts are
55 * masked). To achieve this, all SPI transactions are issued from a
56 * single thread (max3421_spi_thread).
59 #include <linux/jiffies.h>
60 #include <linux/module.h>
61 #include <linux/spi/spi.h>
62 #include <linux/usb.h>
63 #include <linux/usb/hcd.h>
66 #include <linux/platform_data/max3421-hcd.h>
68 #define DRIVER_DESC "MAX3421 USB Host-Controller Driver"
69 #define DRIVER_VERSION "1.0"
71 /* 11-bit counter that wraps around (USB 2.0 Section 8.3.3): */
72 #define USB_MAX_FRAME_NUMBER 0x7ff
73 #define USB_MAX_RETRIES 3 /* # of retries before error is reported */
76 * Max. # of times we're willing to retransmit a request immediately in
77 * resposne to a NAK. Afterwards, we fall back on trying once a frame.
79 #define NAK_MAX_FAST_RETRANSMITS 2
81 #define POWER_BUDGET 500 /* in mA; use 8 for low-power port testing */
83 /* Port-change mask: */
84 #define PORT_C_MASK ((USB_PORT_STAT_C_CONNECTION | \
85 USB_PORT_STAT_C_ENABLE | \
86 USB_PORT_STAT_C_SUSPEND | \
87 USB_PORT_STAT_C_OVERCURRENT | \
88 USB_PORT_STAT_C_RESET) << 16)
90 #define MAX3421_GPOUT_COUNT 8
92 enum max3421_rh_state {
99 PKT_STATE_SETUP, /* waiting to send setup packet to ctrl pipe */
100 PKT_STATE_TRANSFER, /* waiting to xfer transfer_buffer */
101 PKT_STATE_TERMINATE /* waiting to terminate control transfer */
104 enum scheduling_pass {
106 SCHED_PASS_NON_PERIODIC,
110 /* Bit numbers for max3421_hcd->todo: */
119 struct max3421_dma_buf {
126 struct task_struct *spi_thread;
128 struct max3421_hcd *next;
130 enum max3421_rh_state rh_state;
131 /* lower 16 bits contain port status, upper 16 bits the change mask: */
136 struct list_head ep_list; /* list of EP's with work */
139 * The following are owned by spi_thread (may be accessed by
140 * SPI-thread without acquiring the HCD lock:
142 u8 rev; /* chip revision */
145 * kmalloc'd buffers guaranteed to be in separate (DMA)
148 struct max3421_dma_buf *tx;
149 struct max3421_dma_buf *rx;
151 * URB we're currently processing. Must not be reset to NULL
152 * unless MAX3421E chip is idle:
154 struct urb *curr_urb;
155 enum scheduling_pass sched_pass;
156 int urb_done; /* > 0 -> no errors, < 0: errno */
163 unsigned long err_stat[16];
168 struct usb_host_endpoint *ep;
169 struct list_head ep_list;
171 u16 last_active; /* frame # this ep was last active */
172 enum pkt_state pkt_state;
174 u8 retransmit; /* packet needs retransmission */
177 static struct max3421_hcd *max3421_hcd_list;
179 #define MAX3421_FIFO_SIZE 64
181 #define MAX3421_SPI_DIR_RD 0 /* read register from MAX3421 */
182 #define MAX3421_SPI_DIR_WR 1 /* write register to MAX3421 */
185 #define MAX3421_SPI_DIR_SHIFT 1
186 #define MAX3421_SPI_REG_SHIFT 3
188 #define MAX3421_REG_RCVFIFO 1
189 #define MAX3421_REG_SNDFIFO 2
190 #define MAX3421_REG_SUDFIFO 4
191 #define MAX3421_REG_RCVBC 6
192 #define MAX3421_REG_SNDBC 7
193 #define MAX3421_REG_USBIRQ 13
194 #define MAX3421_REG_USBIEN 14
195 #define MAX3421_REG_USBCTL 15
196 #define MAX3421_REG_CPUCTL 16
197 #define MAX3421_REG_PINCTL 17
198 #define MAX3421_REG_REVISION 18
199 #define MAX3421_REG_IOPINS1 20
200 #define MAX3421_REG_IOPINS2 21
201 #define MAX3421_REG_GPINIRQ 22
202 #define MAX3421_REG_GPINIEN 23
203 #define MAX3421_REG_GPINPOL 24
204 #define MAX3421_REG_HIRQ 25
205 #define MAX3421_REG_HIEN 26
206 #define MAX3421_REG_MODE 27
207 #define MAX3421_REG_PERADDR 28
208 #define MAX3421_REG_HCTL 29
209 #define MAX3421_REG_HXFR 30
210 #define MAX3421_REG_HRSL 31
213 MAX3421_USBIRQ_OSCOKIRQ_BIT = 0,
214 MAX3421_USBIRQ_NOVBUSIRQ_BIT = 5,
215 MAX3421_USBIRQ_VBUSIRQ_BIT
219 MAX3421_CPUCTL_IE_BIT = 0,
220 MAX3421_CPUCTL_PULSEWID0_BIT = 6,
221 MAX3421_CPUCTL_PULSEWID1_BIT
225 MAX3421_USBCTL_PWRDOWN_BIT = 4,
226 MAX3421_USBCTL_CHIPRES_BIT
230 MAX3421_PINCTL_GPXA_BIT = 0,
231 MAX3421_PINCTL_GPXB_BIT,
232 MAX3421_PINCTL_POSINT_BIT,
233 MAX3421_PINCTL_INTLEVEL_BIT,
234 MAX3421_PINCTL_FDUPSPI_BIT,
235 MAX3421_PINCTL_EP0INAK_BIT,
236 MAX3421_PINCTL_EP2INAK_BIT,
237 MAX3421_PINCTL_EP3INAK_BIT,
241 MAX3421_HI_BUSEVENT_BIT = 0, /* bus-reset/-resume */
242 MAX3421_HI_RWU_BIT, /* remote wakeup */
243 MAX3421_HI_RCVDAV_BIT, /* receive FIFO data available */
244 MAX3421_HI_SNDBAV_BIT, /* send buffer available */
245 MAX3421_HI_SUSDN_BIT, /* suspend operation done */
246 MAX3421_HI_CONDET_BIT, /* peripheral connect/disconnect */
247 MAX3421_HI_FRAME_BIT, /* frame generator */
248 MAX3421_HI_HXFRDN_BIT, /* host transfer done */
252 MAX3421_HCTL_BUSRST_BIT = 0,
253 MAX3421_HCTL_FRMRST_BIT,
254 MAX3421_HCTL_SAMPLEBUS_BIT,
255 MAX3421_HCTL_SIGRSM_BIT,
256 MAX3421_HCTL_RCVTOG0_BIT,
257 MAX3421_HCTL_RCVTOG1_BIT,
258 MAX3421_HCTL_SNDTOG0_BIT,
259 MAX3421_HCTL_SNDTOG1_BIT
263 MAX3421_MODE_HOST_BIT = 0,
264 MAX3421_MODE_LOWSPEED_BIT,
265 MAX3421_MODE_HUBPRE_BIT,
266 MAX3421_MODE_SOFKAENAB_BIT,
267 MAX3421_MODE_SEPIRQ_BIT,
268 MAX3421_MODE_DELAYISO_BIT,
269 MAX3421_MODE_DMPULLDN_BIT,
270 MAX3421_MODE_DPPULLDN_BIT
281 MAX3421_HRSL_WRONGPID,
288 MAX3421_HRSL_TIMEOUT,
290 MAX3421_HRSL_RESULT_MASK = 0xf,
291 MAX3421_HRSL_RCVTOGRD_BIT = 4,
292 MAX3421_HRSL_SNDTOGRD_BIT,
293 MAX3421_HRSL_KSTATUS_BIT,
294 MAX3421_HRSL_JSTATUS_BIT
297 /* Return same error-codes as ohci.h:cc_to_error: */
298 static const int hrsl_to_error[] = {
299 [MAX3421_HRSL_OK] = 0,
300 [MAX3421_HRSL_BUSY] = -EINVAL,
301 [MAX3421_HRSL_BADREQ] = -EINVAL,
302 [MAX3421_HRSL_UNDEF] = -EINVAL,
303 [MAX3421_HRSL_NAK] = -EAGAIN,
304 [MAX3421_HRSL_STALL] = -EPIPE,
305 [MAX3421_HRSL_TOGERR] = -EILSEQ,
306 [MAX3421_HRSL_WRONGPID] = -EPROTO,
307 [MAX3421_HRSL_BADBC] = -EREMOTEIO,
308 [MAX3421_HRSL_PIDERR] = -EPROTO,
309 [MAX3421_HRSL_PKTERR] = -EPROTO,
310 [MAX3421_HRSL_CRCERR] = -EILSEQ,
311 [MAX3421_HRSL_KERR] = -EIO,
312 [MAX3421_HRSL_JERR] = -EIO,
313 [MAX3421_HRSL_TIMEOUT] = -ETIME,
314 [MAX3421_HRSL_BABBLE] = -EOVERFLOW
318 * See http://www.beyondlogic.org/usbnutshell/usb4.shtml#Control for a
319 * reasonable overview of how control transfers use the the IN/OUT
322 #define MAX3421_HXFR_BULK_IN(ep) (0x00 | (ep)) /* bulk or interrupt */
323 #define MAX3421_HXFR_SETUP 0x10
324 #define MAX3421_HXFR_BULK_OUT(ep) (0x20 | (ep)) /* bulk or interrupt */
325 #define MAX3421_HXFR_ISO_IN(ep) (0x40 | (ep))
326 #define MAX3421_HXFR_ISO_OUT(ep) (0x60 | (ep))
327 #define MAX3421_HXFR_HS_IN 0x80 /* handshake in */
328 #define MAX3421_HXFR_HS_OUT 0xa0 /* handshake out */
330 #define field(val, bit) ((val) << (bit))
333 frame_diff(u16 left, u16 right)
335 return ((unsigned) (left - right)) % (USB_MAX_FRAME_NUMBER + 1);
338 static inline struct max3421_hcd *
339 hcd_to_max3421(struct usb_hcd *hcd)
341 return (struct max3421_hcd *) hcd->hcd_priv;
344 static inline struct usb_hcd *
345 max3421_to_hcd(struct max3421_hcd *max3421_hcd)
347 return container_of((void *) max3421_hcd, struct usb_hcd, hcd_priv);
351 spi_rd8(struct usb_hcd *hcd, unsigned int reg)
353 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
354 struct spi_device *spi = to_spi_device(hcd->self.controller);
355 struct spi_transfer transfer;
356 struct spi_message msg;
358 memset(&transfer, 0, sizeof(transfer));
360 spi_message_init(&msg);
362 max3421_hcd->tx->data[0] =
363 (field(reg, MAX3421_SPI_REG_SHIFT) |
364 field(MAX3421_SPI_DIR_RD, MAX3421_SPI_DIR_SHIFT));
366 transfer.tx_buf = max3421_hcd->tx->data;
367 transfer.rx_buf = max3421_hcd->rx->data;
370 spi_message_add_tail(&transfer, &msg);
373 return max3421_hcd->rx->data[1];
377 spi_wr8(struct usb_hcd *hcd, unsigned int reg, u8 val)
379 struct spi_device *spi = to_spi_device(hcd->self.controller);
380 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
381 struct spi_transfer transfer;
382 struct spi_message msg;
384 memset(&transfer, 0, sizeof(transfer));
386 spi_message_init(&msg);
388 max3421_hcd->tx->data[0] =
389 (field(reg, MAX3421_SPI_REG_SHIFT) |
390 field(MAX3421_SPI_DIR_WR, MAX3421_SPI_DIR_SHIFT));
391 max3421_hcd->tx->data[1] = val;
393 transfer.tx_buf = max3421_hcd->tx->data;
396 spi_message_add_tail(&transfer, &msg);
401 spi_rd_buf(struct usb_hcd *hcd, unsigned int reg, void *buf, size_t len)
403 struct spi_device *spi = to_spi_device(hcd->self.controller);
404 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
405 struct spi_transfer transfer[2];
406 struct spi_message msg;
408 memset(transfer, 0, sizeof(transfer));
410 spi_message_init(&msg);
412 max3421_hcd->tx->data[0] =
413 (field(reg, MAX3421_SPI_REG_SHIFT) |
414 field(MAX3421_SPI_DIR_RD, MAX3421_SPI_DIR_SHIFT));
415 transfer[0].tx_buf = max3421_hcd->tx->data;
418 transfer[1].rx_buf = buf;
419 transfer[1].len = len;
421 spi_message_add_tail(&transfer[0], &msg);
422 spi_message_add_tail(&transfer[1], &msg);
427 spi_wr_buf(struct usb_hcd *hcd, unsigned int reg, void *buf, size_t len)
429 struct spi_device *spi = to_spi_device(hcd->self.controller);
430 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
431 struct spi_transfer transfer[2];
432 struct spi_message msg;
434 memset(transfer, 0, sizeof(transfer));
436 spi_message_init(&msg);
438 max3421_hcd->tx->data[0] =
439 (field(reg, MAX3421_SPI_REG_SHIFT) |
440 field(MAX3421_SPI_DIR_WR, MAX3421_SPI_DIR_SHIFT));
442 transfer[0].tx_buf = max3421_hcd->tx->data;
445 transfer[1].tx_buf = buf;
446 transfer[1].len = len;
448 spi_message_add_tail(&transfer[0], &msg);
449 spi_message_add_tail(&transfer[1], &msg);
454 * Figure out the correct setting for the LOWSPEED and HUBPRE mode
455 * bits. The HUBPRE bit needs to be set when MAX3421E operates at
456 * full speed, but it's talking to a low-speed device (i.e., through a
457 * hub). Setting that bit ensures that every low-speed packet is
458 * preceded by a full-speed PRE PID. Possible configurations:
460 * Hub speed: Device speed: => LOWSPEED bit: HUBPRE bit:
467 max3421_set_speed(struct usb_hcd *hcd, struct usb_device *dev)
469 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
470 u8 mode_lowspeed, mode_hubpre, mode = max3421_hcd->mode;
472 mode_lowspeed = BIT(MAX3421_MODE_LOWSPEED_BIT);
473 mode_hubpre = BIT(MAX3421_MODE_HUBPRE_BIT);
474 if (max3421_hcd->port_status & USB_PORT_STAT_LOW_SPEED) {
475 mode |= mode_lowspeed;
476 mode &= ~mode_hubpre;
477 } else if (dev->speed == USB_SPEED_LOW) {
478 mode |= mode_lowspeed | mode_hubpre;
480 mode &= ~(mode_lowspeed | mode_hubpre);
482 if (mode != max3421_hcd->mode) {
483 max3421_hcd->mode = mode;
484 spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
490 * Caller must NOT hold HCD spinlock.
493 max3421_set_address(struct usb_hcd *hcd, struct usb_device *dev, int epnum)
498 /* setup new endpoint's toggle bits: */
499 rcvtog = usb_gettoggle(dev, epnum, 0);
500 sndtog = usb_gettoggle(dev, epnum, 1);
501 hctl = (BIT(rcvtog + MAX3421_HCTL_RCVTOG0_BIT) |
502 BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT));
504 spi_wr8(hcd, MAX3421_REG_HCTL, hctl);
507 * Note: devnum for one and the same device can change during
508 * address-assignment so it's best to just always load the
509 * address whenever the end-point changed/was forced.
511 spi_wr8(hcd, MAX3421_REG_PERADDR, dev->devnum);
515 max3421_ctrl_setup(struct usb_hcd *hcd, struct urb *urb)
517 spi_wr_buf(hcd, MAX3421_REG_SUDFIFO, urb->setup_packet, 8);
518 return MAX3421_HXFR_SETUP;
522 max3421_transfer_in(struct usb_hcd *hcd, struct urb *urb)
524 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
525 int epnum = usb_pipeendpoint(urb->pipe);
527 max3421_hcd->curr_len = 0;
528 max3421_hcd->hien |= BIT(MAX3421_HI_RCVDAV_BIT);
529 return MAX3421_HXFR_BULK_IN(epnum);
533 max3421_transfer_out(struct usb_hcd *hcd, struct urb *urb, int fast_retransmit)
535 struct spi_device *spi = to_spi_device(hcd->self.controller);
536 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
537 int epnum = usb_pipeendpoint(urb->pipe);
541 src = urb->transfer_buffer + urb->actual_length;
543 if (fast_retransmit) {
544 if (max3421_hcd->rev == 0x12) {
545 /* work around rev 0x12 bug: */
546 spi_wr8(hcd, MAX3421_REG_SNDBC, 0);
547 spi_wr8(hcd, MAX3421_REG_SNDFIFO, ((u8 *) src)[0]);
548 spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len);
550 return MAX3421_HXFR_BULK_OUT(epnum);
553 max_packet = usb_maxpacket(urb->dev, urb->pipe, 1);
555 if (max_packet > MAX3421_FIFO_SIZE) {
557 * We do not support isochronous transfers at this
561 "%s: packet-size of %u too big (limit is %u bytes)",
562 __func__, max_packet, MAX3421_FIFO_SIZE);
563 max3421_hcd->urb_done = -EMSGSIZE;
566 max3421_hcd->curr_len = min((urb->transfer_buffer_length -
567 urb->actual_length), max_packet);
569 spi_wr_buf(hcd, MAX3421_REG_SNDFIFO, src, max3421_hcd->curr_len);
570 spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len);
571 return MAX3421_HXFR_BULK_OUT(epnum);
575 * Issue the next host-transfer command.
576 * Caller must NOT hold HCD spinlock.
579 max3421_next_transfer(struct usb_hcd *hcd, int fast_retransmit)
581 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
582 struct urb *urb = max3421_hcd->curr_urb;
583 struct max3421_ep *max3421_ep;
587 return; /* nothing to do */
589 max3421_ep = urb->ep->hcpriv;
591 switch (max3421_ep->pkt_state) {
592 case PKT_STATE_SETUP:
593 cmd = max3421_ctrl_setup(hcd, urb);
596 case PKT_STATE_TRANSFER:
597 if (usb_urb_dir_in(urb))
598 cmd = max3421_transfer_in(hcd, urb);
600 cmd = max3421_transfer_out(hcd, urb, fast_retransmit);
603 case PKT_STATE_TERMINATE:
605 * IN transfers are terminated with HS_OUT token,
606 * OUT transfers with HS_IN:
608 if (usb_urb_dir_in(urb))
609 cmd = MAX3421_HXFR_HS_OUT;
611 cmd = MAX3421_HXFR_HS_IN;
618 /* issue the command and wait for host-xfer-done interrupt: */
620 spi_wr8(hcd, MAX3421_REG_HXFR, cmd);
621 max3421_hcd->hien |= BIT(MAX3421_HI_HXFRDN_BIT);
625 * Find the next URB to process and start its execution.
627 * At this time, we do not anticipate ever connecting a USB hub to the
628 * MAX3421 chip, so at most USB device can be connected and we can use
629 * a simplistic scheduler: at the start of a frame, schedule all
630 * periodic transfers. Once that is done, use the remainder of the
631 * frame to process non-periodic (bulk & control) transfers.
634 * o Caller must NOT hold HCD spinlock.
635 * o max3421_hcd->curr_urb MUST BE NULL.
636 * o MAX3421E chip must be idle.
639 max3421_select_and_start_urb(struct usb_hcd *hcd)
641 struct spi_device *spi = to_spi_device(hcd->self.controller);
642 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
643 struct urb *urb, *curr_urb = NULL;
644 struct max3421_ep *max3421_ep;
646 struct usb_host_endpoint *ep;
647 struct list_head *pos;
650 spin_lock_irqsave(&max3421_hcd->lock, flags);
653 max3421_hcd->sched_pass < SCHED_PASS_DONE;
654 ++max3421_hcd->sched_pass)
655 list_for_each(pos, &max3421_hcd->ep_list) {
657 max3421_ep = container_of(pos, struct max3421_ep,
661 switch (usb_endpoint_type(&ep->desc)) {
662 case USB_ENDPOINT_XFER_ISOC:
663 case USB_ENDPOINT_XFER_INT:
664 if (max3421_hcd->sched_pass !=
669 case USB_ENDPOINT_XFER_CONTROL:
670 case USB_ENDPOINT_XFER_BULK:
671 if (max3421_hcd->sched_pass !=
672 SCHED_PASS_NON_PERIODIC)
677 if (list_empty(&ep->urb_list))
678 continue; /* nothing to do */
679 urb = list_first_entry(&ep->urb_list, struct urb,
682 dev_dbg(&spi->dev, "%s: URB %p unlinked=%d",
683 __func__, urb, urb->unlinked);
684 max3421_hcd->curr_urb = urb;
685 max3421_hcd->urb_done = 1;
686 spin_unlock_irqrestore(&max3421_hcd->lock,
691 switch (usb_endpoint_type(&ep->desc)) {
692 case USB_ENDPOINT_XFER_CONTROL:
694 * Allow one control transaction per
695 * frame per endpoint:
697 if (frame_diff(max3421_ep->last_active,
698 max3421_hcd->frame_number) == 0)
702 case USB_ENDPOINT_XFER_BULK:
703 if (max3421_ep->retransmit
704 && (frame_diff(max3421_ep->last_active,
705 max3421_hcd->frame_number)
708 * We already tried this EP
709 * during this frame and got a
710 * NAK or error; wait for next frame
715 case USB_ENDPOINT_XFER_ISOC:
716 case USB_ENDPOINT_XFER_INT:
717 if (frame_diff(max3421_hcd->frame_number,
718 max3421_ep->last_active)
721 * We already processed this
722 * end-point in the current
729 /* move current ep to tail: */
730 list_move_tail(pos, &max3421_hcd->ep_list);
736 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
740 urb = max3421_hcd->curr_urb = curr_urb;
741 epnum = usb_endpoint_num(&urb->ep->desc);
742 if (max3421_ep->retransmit)
743 /* restart (part of) a USB transaction: */
744 max3421_ep->retransmit = 0;
746 /* start USB transaction: */
747 if (usb_endpoint_xfer_control(&ep->desc)) {
749 * See USB 2.0 spec section 8.6.1
750 * Initialization via SETUP Token:
752 usb_settoggle(urb->dev, epnum, 0, 1);
753 usb_settoggle(urb->dev, epnum, 1, 1);
754 max3421_ep->pkt_state = PKT_STATE_SETUP;
756 max3421_ep->pkt_state = PKT_STATE_TRANSFER;
759 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
761 max3421_ep->last_active = max3421_hcd->frame_number;
762 max3421_set_address(hcd, urb->dev, epnum);
763 max3421_set_speed(hcd, urb->dev);
764 max3421_next_transfer(hcd, 0);
769 * Check all endpoints for URBs that got unlinked.
771 * Caller must NOT hold HCD spinlock.
774 max3421_check_unlink(struct usb_hcd *hcd)
776 struct spi_device *spi = to_spi_device(hcd->self.controller);
777 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
778 struct max3421_ep *max3421_ep;
779 struct usb_host_endpoint *ep;
780 struct urb *urb, *next;
784 spin_lock_irqsave(&max3421_hcd->lock, flags);
785 list_for_each_entry(max3421_ep, &max3421_hcd->ep_list, ep_list) {
787 list_for_each_entry_safe(urb, next, &ep->urb_list, urb_list) {
790 dev_dbg(&spi->dev, "%s: URB %p unlinked=%d",
791 __func__, urb, urb->unlinked);
792 usb_hcd_unlink_urb_from_ep(hcd, urb);
793 spin_unlock_irqrestore(&max3421_hcd->lock,
795 usb_hcd_giveback_urb(hcd, urb, 0);
796 spin_lock_irqsave(&max3421_hcd->lock, flags);
800 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
805 * Caller must NOT hold HCD spinlock.
808 max3421_slow_retransmit(struct usb_hcd *hcd)
810 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
811 struct urb *urb = max3421_hcd->curr_urb;
812 struct max3421_ep *max3421_ep;
814 max3421_ep = urb->ep->hcpriv;
815 max3421_ep->retransmit = 1;
816 max3421_hcd->curr_urb = NULL;
820 * Caller must NOT hold HCD spinlock.
823 max3421_recv_data_available(struct usb_hcd *hcd)
825 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
826 struct urb *urb = max3421_hcd->curr_urb;
827 size_t remaining, transfer_size;
830 rcvbc = spi_rd8(hcd, MAX3421_REG_RCVBC);
832 if (rcvbc > MAX3421_FIFO_SIZE)
833 rcvbc = MAX3421_FIFO_SIZE;
834 if (urb->actual_length >= urb->transfer_buffer_length)
837 remaining = urb->transfer_buffer_length - urb->actual_length;
838 transfer_size = rcvbc;
839 if (transfer_size > remaining)
840 transfer_size = remaining;
841 if (transfer_size > 0) {
842 void *dst = urb->transfer_buffer + urb->actual_length;
844 spi_rd_buf(hcd, MAX3421_REG_RCVFIFO, dst, transfer_size);
845 urb->actual_length += transfer_size;
846 max3421_hcd->curr_len = transfer_size;
849 /* ack the RCVDAV irq now that the FIFO has been read: */
850 spi_wr8(hcd, MAX3421_REG_HIRQ, BIT(MAX3421_HI_RCVDAV_BIT));
854 max3421_handle_error(struct usb_hcd *hcd, u8 hrsl)
856 struct spi_device *spi = to_spi_device(hcd->self.controller);
857 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
858 u8 result_code = hrsl & MAX3421_HRSL_RESULT_MASK;
859 struct urb *urb = max3421_hcd->curr_urb;
860 struct max3421_ep *max3421_ep = urb->ep->hcpriv;
864 * If an OUT command results in any response other than OK
865 * (i.e., error or NAK), we have to perform a dummy-write to
866 * SNDBC so the FIFO gets switched back to us. Otherwise, we
867 * get out of sync with the SNDFIFO double buffer.
869 switch_sndfifo = (max3421_ep->pkt_state == PKT_STATE_TRANSFER &&
870 usb_urb_dir_out(urb));
872 switch (result_code) {
873 case MAX3421_HRSL_OK:
874 return; /* this shouldn't happen */
876 case MAX3421_HRSL_WRONGPID: /* received wrong PID */
877 case MAX3421_HRSL_BUSY: /* SIE busy */
878 case MAX3421_HRSL_BADREQ: /* bad val in HXFR */
879 case MAX3421_HRSL_UNDEF: /* reserved */
880 case MAX3421_HRSL_KERR: /* K-state instead of response */
881 case MAX3421_HRSL_JERR: /* J-state instead of response */
883 * packet experienced an error that we cannot recover
886 max3421_hcd->urb_done = hrsl_to_error[result_code];
887 dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
891 case MAX3421_HRSL_TOGERR:
892 if (usb_urb_dir_in(urb))
893 ; /* don't do anything (device will switch toggle) */
895 /* flip the send toggle bit: */
896 int sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1;
899 spi_wr8(hcd, MAX3421_REG_HCTL,
900 BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT));
903 case MAX3421_HRSL_BADBC: /* bad byte count */
904 case MAX3421_HRSL_PIDERR: /* received PID is corrupted */
905 case MAX3421_HRSL_PKTERR: /* packet error (stuff, EOP) */
906 case MAX3421_HRSL_CRCERR: /* CRC error */
907 case MAX3421_HRSL_BABBLE: /* device talked too long */
908 case MAX3421_HRSL_TIMEOUT:
909 if (max3421_ep->retries++ < USB_MAX_RETRIES)
910 /* retry the packet again in the next frame */
911 max3421_slow_retransmit(hcd);
913 /* Based on ohci.h cc_to_err[]: */
914 max3421_hcd->urb_done = hrsl_to_error[result_code];
915 dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
920 case MAX3421_HRSL_STALL:
921 dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
923 max3421_hcd->urb_done = hrsl_to_error[result_code];
926 case MAX3421_HRSL_NAK:
928 * Device wasn't ready for data or has no data
929 * available: retry the packet again.
931 if (max3421_ep->naks++ < NAK_MAX_FAST_RETRANSMITS) {
932 max3421_next_transfer(hcd, 1);
935 max3421_slow_retransmit(hcd);
939 spi_wr8(hcd, MAX3421_REG_SNDBC, 0);
943 * Caller must NOT hold HCD spinlock.
946 max3421_transfer_in_done(struct usb_hcd *hcd, struct urb *urb)
948 struct spi_device *spi = to_spi_device(hcd->self.controller);
949 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
952 if (urb->actual_length >= urb->transfer_buffer_length)
953 return 1; /* read is complete, so we're done */
956 * USB 2.0 Section 5.3.2 Pipes: packets must be full size
957 * except for last one.
959 max_packet = usb_maxpacket(urb->dev, urb->pipe, 0);
960 if (max_packet > MAX3421_FIFO_SIZE) {
962 * We do not support isochronous transfers at this
966 "%s: packet-size of %u too big (limit is %u bytes)",
967 __func__, max_packet, MAX3421_FIFO_SIZE);
971 if (max3421_hcd->curr_len < max_packet) {
972 if (urb->transfer_flags & URB_SHORT_NOT_OK) {
974 * remaining > 0 and received an
975 * unexpected partial packet ->
980 /* short read, but it's OK */
983 return 0; /* not done */
987 * Caller must NOT hold HCD spinlock.
990 max3421_transfer_out_done(struct usb_hcd *hcd, struct urb *urb)
992 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
994 urb->actual_length += max3421_hcd->curr_len;
995 if (urb->actual_length < urb->transfer_buffer_length)
997 if (urb->transfer_flags & URB_ZERO_PACKET) {
999 * Some hardware needs a zero-size packet at the end
1000 * of a bulk-out transfer if the last transfer was a
1001 * full-sized packet (i.e., such hardware use <
1002 * max_packet as an indicator that the end of the
1003 * packet has been reached).
1005 u32 max_packet = usb_maxpacket(urb->dev, urb->pipe, 1);
1007 if (max3421_hcd->curr_len == max_packet)
1014 * Caller must NOT hold HCD spinlock.
1017 max3421_host_transfer_done(struct usb_hcd *hcd)
1019 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1020 struct urb *urb = max3421_hcd->curr_urb;
1021 struct max3421_ep *max3421_ep;
1022 u8 result_code, hrsl;
1025 max3421_hcd->hien &= ~(BIT(MAX3421_HI_HXFRDN_BIT) |
1026 BIT(MAX3421_HI_RCVDAV_BIT));
1028 hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
1029 result_code = hrsl & MAX3421_HRSL_RESULT_MASK;
1032 ++max3421_hcd->err_stat[result_code];
1035 max3421_ep = urb->ep->hcpriv;
1037 if (unlikely(result_code != MAX3421_HRSL_OK)) {
1038 max3421_handle_error(hcd, hrsl);
1042 max3421_ep->naks = 0;
1043 max3421_ep->retries = 0;
1044 switch (max3421_ep->pkt_state) {
1046 case PKT_STATE_SETUP:
1047 if (urb->transfer_buffer_length > 0)
1048 max3421_ep->pkt_state = PKT_STATE_TRANSFER;
1050 max3421_ep->pkt_state = PKT_STATE_TERMINATE;
1053 case PKT_STATE_TRANSFER:
1054 if (usb_urb_dir_in(urb))
1055 urb_done = max3421_transfer_in_done(hcd, urb);
1057 urb_done = max3421_transfer_out_done(hcd, urb);
1058 if (urb_done > 0 && usb_pipetype(urb->pipe) == PIPE_CONTROL) {
1060 * We aren't really done - we still need to
1061 * terminate the control transfer:
1063 max3421_hcd->urb_done = urb_done = 0;
1064 max3421_ep->pkt_state = PKT_STATE_TERMINATE;
1068 case PKT_STATE_TERMINATE:
1074 max3421_hcd->urb_done = urb_done;
1076 max3421_next_transfer(hcd, 0);
1080 * Caller must NOT hold HCD spinlock.
1083 max3421_detect_conn(struct usb_hcd *hcd)
1085 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1086 unsigned int jk, have_conn = 0;
1087 u32 old_port_status, chg;
1088 unsigned long flags;
1091 hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
1093 jk = ((((hrsl >> MAX3421_HRSL_JSTATUS_BIT) & 1) << 0) |
1094 (((hrsl >> MAX3421_HRSL_KSTATUS_BIT) & 1) << 1));
1096 mode = max3421_hcd->mode;
1099 case 0x0: /* SE0: disconnect */
1101 * Turn off SOFKAENAB bit to avoid getting interrupt
1102 * every milli-second:
1104 mode &= ~BIT(MAX3421_MODE_SOFKAENAB_BIT);
1107 case 0x1: /* J=0,K=1: low-speed (in full-speed or vice versa) */
1108 case 0x2: /* J=1,K=0: full-speed (in full-speed or vice versa) */
1110 /* need to switch to the other speed: */
1111 mode ^= BIT(MAX3421_MODE_LOWSPEED_BIT);
1112 /* turn on SOFKAENAB bit: */
1113 mode |= BIT(MAX3421_MODE_SOFKAENAB_BIT);
1117 case 0x3: /* illegal */
1121 max3421_hcd->mode = mode;
1122 spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
1124 spin_lock_irqsave(&max3421_hcd->lock, flags);
1125 old_port_status = max3421_hcd->port_status;
1127 max3421_hcd->port_status |= USB_PORT_STAT_CONNECTION;
1129 max3421_hcd->port_status &= ~USB_PORT_STAT_CONNECTION;
1130 if (mode & BIT(MAX3421_MODE_LOWSPEED_BIT))
1131 max3421_hcd->port_status |= USB_PORT_STAT_LOW_SPEED;
1133 max3421_hcd->port_status &= ~USB_PORT_STAT_LOW_SPEED;
1134 chg = (old_port_status ^ max3421_hcd->port_status);
1135 max3421_hcd->port_status |= chg << 16;
1136 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1140 max3421_irq_handler(int irq, void *dev_id)
1142 struct usb_hcd *hcd = dev_id;
1143 struct spi_device *spi = to_spi_device(hcd->self.controller);
1144 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1146 if (max3421_hcd->spi_thread &&
1147 max3421_hcd->spi_thread->state != TASK_RUNNING)
1148 wake_up_process(max3421_hcd->spi_thread);
1149 if (!test_and_set_bit(ENABLE_IRQ, &max3421_hcd->todo))
1150 disable_irq_nosync(spi->irq);
1157 dump_eps(struct usb_hcd *hcd)
1159 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1160 struct max3421_ep *max3421_ep;
1161 struct usb_host_endpoint *ep;
1162 char ubuf[512], *dp, *end;
1163 unsigned long flags;
1167 spin_lock_irqsave(&max3421_hcd->lock, flags);
1168 list_for_each_entry(max3421_ep, &max3421_hcd->ep_list, ep_list) {
1169 ep = max3421_ep->ep;
1172 end = dp + sizeof(ubuf);
1174 list_for_each_entry(urb, &ep->urb_list, urb_list) {
1175 ret = snprintf(dp, end - dp, " %p(%d.%s %d/%d)", urb,
1176 usb_pipetype(urb->pipe),
1177 usb_urb_dir_in(urb) ? "IN" : "OUT",
1179 urb->transfer_buffer_length);
1180 if (ret < 0 || ret >= end - dp)
1181 break; /* error or buffer full */
1185 epnum = usb_endpoint_num(&ep->desc);
1186 pr_info("EP%0u %u lst %04u rtr %u nak %6u rxmt %u: %s\n",
1187 epnum, max3421_ep->pkt_state, max3421_ep->last_active,
1188 max3421_ep->retries, max3421_ep->naks,
1189 max3421_ep->retransmit, ubuf);
1191 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1196 /* Return zero if no work was performed, 1 otherwise. */
1198 max3421_handle_irqs(struct usb_hcd *hcd)
1200 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1201 u32 chg, old_port_status;
1202 unsigned long flags;
1206 * Read and ack pending interrupts (CPU must never
1207 * clear SNDBAV directly and RCVDAV must be cleared by
1208 * max3421_recv_data_available()!):
1210 hirq = spi_rd8(hcd, MAX3421_REG_HIRQ);
1211 hirq &= max3421_hcd->hien;
1215 spi_wr8(hcd, MAX3421_REG_HIRQ,
1216 hirq & ~(BIT(MAX3421_HI_SNDBAV_BIT) |
1217 BIT(MAX3421_HI_RCVDAV_BIT)));
1219 if (hirq & BIT(MAX3421_HI_FRAME_BIT)) {
1220 max3421_hcd->frame_number = ((max3421_hcd->frame_number + 1)
1221 & USB_MAX_FRAME_NUMBER);
1222 max3421_hcd->sched_pass = SCHED_PASS_PERIODIC;
1225 if (hirq & BIT(MAX3421_HI_RCVDAV_BIT))
1226 max3421_recv_data_available(hcd);
1228 if (hirq & BIT(MAX3421_HI_HXFRDN_BIT))
1229 max3421_host_transfer_done(hcd);
1231 if (hirq & BIT(MAX3421_HI_CONDET_BIT))
1232 max3421_detect_conn(hcd);
1235 * Now process interrupts that may affect HCD state
1236 * other than the end-points:
1238 spin_lock_irqsave(&max3421_hcd->lock, flags);
1240 old_port_status = max3421_hcd->port_status;
1241 if (hirq & BIT(MAX3421_HI_BUSEVENT_BIT)) {
1242 if (max3421_hcd->port_status & USB_PORT_STAT_RESET) {
1243 /* BUSEVENT due to completion of Bus Reset */
1244 max3421_hcd->port_status &= ~USB_PORT_STAT_RESET;
1245 max3421_hcd->port_status |= USB_PORT_STAT_ENABLE;
1247 /* BUSEVENT due to completion of Bus Resume */
1248 pr_info("%s: BUSEVENT Bus Resume Done\n", __func__);
1251 if (hirq & BIT(MAX3421_HI_RWU_BIT))
1252 pr_info("%s: RWU\n", __func__);
1253 if (hirq & BIT(MAX3421_HI_SUSDN_BIT))
1254 pr_info("%s: SUSDN\n", __func__);
1256 chg = (old_port_status ^ max3421_hcd->port_status);
1257 max3421_hcd->port_status |= chg << 16;
1259 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1263 static unsigned long last_time;
1264 char sbuf[16 * 16], *dp, *end;
1267 if (time_after(jiffies, last_time + 5*HZ)) {
1269 end = sbuf + sizeof(sbuf);
1271 for (i = 0; i < 16; ++i) {
1272 int ret = snprintf(dp, end - dp, " %lu",
1273 max3421_hcd->err_stat[i]);
1274 if (ret < 0 || ret >= end - dp)
1275 break; /* error or buffer full */
1278 pr_info("%s: hrsl_stats %s\n", __func__, sbuf);
1279 memset(max3421_hcd->err_stat, 0,
1280 sizeof(max3421_hcd->err_stat));
1281 last_time = jiffies;
1291 max3421_reset_hcd(struct usb_hcd *hcd)
1293 struct spi_device *spi = to_spi_device(hcd->self.controller);
1294 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1297 /* perform a chip reset and wait for OSCIRQ signal to appear: */
1298 spi_wr8(hcd, MAX3421_REG_USBCTL, BIT(MAX3421_USBCTL_CHIPRES_BIT));
1300 spi_wr8(hcd, MAX3421_REG_USBCTL, 0);
1303 if (spi_rd8(hcd, MAX3421_REG_USBIRQ)
1304 & BIT(MAX3421_USBIRQ_OSCOKIRQ_BIT))
1306 if (--timeout < 0) {
1308 "timed out waiting for oscillator OK signal");
1315 * Turn on host mode, automatic generation of SOF packets, and
1316 * enable pull-down registers on DM/DP:
1318 max3421_hcd->mode = (BIT(MAX3421_MODE_HOST_BIT) |
1319 BIT(MAX3421_MODE_SOFKAENAB_BIT) |
1320 BIT(MAX3421_MODE_DMPULLDN_BIT) |
1321 BIT(MAX3421_MODE_DPPULLDN_BIT));
1322 spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
1324 /* reset frame-number: */
1325 max3421_hcd->frame_number = USB_MAX_FRAME_NUMBER;
1326 spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_FRMRST_BIT));
1328 /* sample the state of the D+ and D- lines */
1329 spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_SAMPLEBUS_BIT));
1330 max3421_detect_conn(hcd);
1332 /* enable frame, connection-detected, and bus-event interrupts: */
1333 max3421_hcd->hien = (BIT(MAX3421_HI_FRAME_BIT) |
1334 BIT(MAX3421_HI_CONDET_BIT) |
1335 BIT(MAX3421_HI_BUSEVENT_BIT));
1336 spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien);
1338 /* enable interrupts: */
1339 spi_wr8(hcd, MAX3421_REG_CPUCTL, BIT(MAX3421_CPUCTL_IE_BIT));
1344 max3421_urb_done(struct usb_hcd *hcd)
1346 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1347 unsigned long flags;
1351 status = max3421_hcd->urb_done;
1352 max3421_hcd->urb_done = 0;
1355 urb = max3421_hcd->curr_urb;
1357 /* save the old end-points toggles: */
1358 u8 hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
1359 int rcvtog = (hrsl >> MAX3421_HRSL_RCVTOGRD_BIT) & 1;
1360 int sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1;
1361 int epnum = usb_endpoint_num(&urb->ep->desc);
1363 /* no locking: HCD (i.e., we) own toggles, don't we? */
1364 usb_settoggle(urb->dev, epnum, 0, rcvtog);
1365 usb_settoggle(urb->dev, epnum, 1, sndtog);
1367 max3421_hcd->curr_urb = NULL;
1368 spin_lock_irqsave(&max3421_hcd->lock, flags);
1369 usb_hcd_unlink_urb_from_ep(hcd, urb);
1370 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1372 /* must be called without the HCD spinlock: */
1373 usb_hcd_giveback_urb(hcd, urb, status);
1379 max3421_spi_thread(void *dev_id)
1381 struct usb_hcd *hcd = dev_id;
1382 struct spi_device *spi = to_spi_device(hcd->self.controller);
1383 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1384 int i, i_worked = 1;
1386 /* set full-duplex SPI mode, low-active interrupt pin: */
1387 spi_wr8(hcd, MAX3421_REG_PINCTL,
1388 (BIT(MAX3421_PINCTL_FDUPSPI_BIT) | /* full-duplex */
1389 BIT(MAX3421_PINCTL_INTLEVEL_BIT))); /* low-active irq */
1391 while (!kthread_should_stop()) {
1392 max3421_hcd->rev = spi_rd8(hcd, MAX3421_REG_REVISION);
1393 if (max3421_hcd->rev == 0x12 || max3421_hcd->rev == 0x13)
1395 dev_err(&spi->dev, "bad rev 0x%02x", max3421_hcd->rev);
1398 dev_info(&spi->dev, "rev 0x%x, SPI clk %dHz, bpw %u, irq %d\n",
1399 max3421_hcd->rev, spi->max_speed_hz, spi->bits_per_word,
1402 while (!kthread_should_stop()) {
1405 * We'll be waiting for wakeups from the hard
1406 * interrupt handler, so now is a good time to
1407 * sync our hien with the chip:
1409 spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien);
1411 set_current_state(TASK_INTERRUPTIBLE);
1412 if (test_and_clear_bit(ENABLE_IRQ, &max3421_hcd->todo))
1413 enable_irq(spi->irq);
1415 __set_current_state(TASK_RUNNING);
1420 if (max3421_hcd->urb_done)
1421 i_worked |= max3421_urb_done(hcd);
1422 else if (max3421_handle_irqs(hcd))
1424 else if (!max3421_hcd->curr_urb)
1425 i_worked |= max3421_select_and_start_urb(hcd);
1427 if (test_and_clear_bit(RESET_HCD, &max3421_hcd->todo))
1428 /* reset the HCD: */
1429 i_worked |= max3421_reset_hcd(hcd);
1430 if (test_and_clear_bit(RESET_PORT, &max3421_hcd->todo)) {
1431 /* perform a USB bus reset: */
1432 spi_wr8(hcd, MAX3421_REG_HCTL,
1433 BIT(MAX3421_HCTL_BUSRST_BIT));
1436 if (test_and_clear_bit(CHECK_UNLINK, &max3421_hcd->todo))
1437 i_worked |= max3421_check_unlink(hcd);
1438 if (test_and_clear_bit(IOPIN_UPDATE, &max3421_hcd->todo)) {
1440 * IOPINS1/IOPINS2 do not auto-increment, so we can't
1443 for (i = 0; i < ARRAY_SIZE(max3421_hcd->iopins); ++i) {
1444 u8 val = spi_rd8(hcd, MAX3421_REG_IOPINS1);
1446 val = ((val & 0xf0) |
1447 (max3421_hcd->iopins[i] & 0x0f));
1448 spi_wr8(hcd, MAX3421_REG_IOPINS1 + i, val);
1449 max3421_hcd->iopins[i] = val;
1454 set_current_state(TASK_RUNNING);
1455 dev_info(&spi->dev, "SPI thread exiting");
1460 max3421_reset_port(struct usb_hcd *hcd)
1462 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1464 max3421_hcd->port_status &= ~(USB_PORT_STAT_ENABLE |
1465 USB_PORT_STAT_LOW_SPEED);
1466 max3421_hcd->port_status |= USB_PORT_STAT_RESET;
1467 set_bit(RESET_PORT, &max3421_hcd->todo);
1468 wake_up_process(max3421_hcd->spi_thread);
1473 max3421_reset(struct usb_hcd *hcd)
1475 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1477 hcd->self.sg_tablesize = 0;
1478 hcd->speed = HCD_USB2;
1479 hcd->self.root_hub->speed = USB_SPEED_FULL;
1480 set_bit(RESET_HCD, &max3421_hcd->todo);
1481 wake_up_process(max3421_hcd->spi_thread);
1486 max3421_start(struct usb_hcd *hcd)
1488 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1490 spin_lock_init(&max3421_hcd->lock);
1491 max3421_hcd->rh_state = MAX3421_RH_RUNNING;
1493 INIT_LIST_HEAD(&max3421_hcd->ep_list);
1495 hcd->power_budget = POWER_BUDGET;
1496 hcd->state = HC_STATE_RUNNING;
1497 hcd->uses_new_polling = 1;
1502 max3421_stop(struct usb_hcd *hcd)
1507 max3421_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
1509 struct spi_device *spi = to_spi_device(hcd->self.controller);
1510 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1511 struct max3421_ep *max3421_ep;
1512 unsigned long flags;
1515 switch (usb_pipetype(urb->pipe)) {
1516 case PIPE_INTERRUPT:
1517 case PIPE_ISOCHRONOUS:
1518 if (urb->interval < 0) {
1520 "%s: interval=%d for intr-/iso-pipe; expected > 0\n",
1521 __func__, urb->interval);
1528 spin_lock_irqsave(&max3421_hcd->lock, flags);
1530 max3421_ep = urb->ep->hcpriv;
1532 /* gets freed in max3421_endpoint_disable: */
1533 max3421_ep = kzalloc(sizeof(struct max3421_ep), GFP_ATOMIC);
1538 max3421_ep->ep = urb->ep;
1539 max3421_ep->last_active = max3421_hcd->frame_number;
1540 urb->ep->hcpriv = max3421_ep;
1542 list_add_tail(&max3421_ep->ep_list, &max3421_hcd->ep_list);
1545 retval = usb_hcd_link_urb_to_ep(hcd, urb);
1547 /* Since we added to the queue, restart scheduling: */
1548 max3421_hcd->sched_pass = SCHED_PASS_PERIODIC;
1549 wake_up_process(max3421_hcd->spi_thread);
1553 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1558 max3421_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
1560 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1561 unsigned long flags;
1564 spin_lock_irqsave(&max3421_hcd->lock, flags);
1567 * This will set urb->unlinked which in turn causes the entry
1568 * to be dropped at the next opportunity.
1570 retval = usb_hcd_check_unlink_urb(hcd, urb, status);
1572 set_bit(CHECK_UNLINK, &max3421_hcd->todo);
1573 wake_up_process(max3421_hcd->spi_thread);
1575 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1580 max3421_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
1582 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1583 unsigned long flags;
1585 spin_lock_irqsave(&max3421_hcd->lock, flags);
1588 struct max3421_ep *max3421_ep = ep->hcpriv;
1590 /* remove myself from the ep_list: */
1591 if (!list_empty(&max3421_ep->ep_list))
1592 list_del(&max3421_ep->ep_list);
1597 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1601 max3421_get_frame_number(struct usb_hcd *hcd)
1603 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1604 return max3421_hcd->frame_number;
1608 * Should return a non-zero value when any port is undergoing a resume
1609 * transition while the root hub is suspended.
1612 max3421_hub_status_data(struct usb_hcd *hcd, char *buf)
1614 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1615 unsigned long flags;
1618 spin_lock_irqsave(&max3421_hcd->lock, flags);
1619 if (!HCD_HW_ACCESSIBLE(hcd))
1623 if ((max3421_hcd->port_status & PORT_C_MASK) != 0) {
1624 *buf = (1 << 1); /* a hub over-current condition exists */
1625 dev_dbg(hcd->self.controller,
1626 "port status 0x%08x has changes\n",
1627 max3421_hcd->port_status);
1629 if (max3421_hcd->rh_state == MAX3421_RH_SUSPENDED)
1630 usb_hcd_resume_root_hub(hcd);
1633 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1638 hub_descriptor(struct usb_hub_descriptor *desc)
1640 memset(desc, 0, sizeof(*desc));
1642 * See Table 11-13: Hub Descriptor in USB 2.0 spec.
1644 desc->bDescriptorType = USB_DT_HUB; /* hub descriptor */
1645 desc->bDescLength = 9;
1646 desc->wHubCharacteristics = cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM |
1647 HUB_CHAR_COMMON_OCPM);
1648 desc->bNbrPorts = 1;
1652 * Set the MAX3421E general-purpose output with number PIN_NUMBER to
1653 * VALUE (0 or 1). PIN_NUMBER may be in the range from 1-8. For
1654 * any other value, this function acts as a no-op.
1657 max3421_gpout_set_value(struct usb_hcd *hcd, u8 pin_number, u8 value)
1659 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1663 if (pin_number >= MAX3421_GPOUT_COUNT)
1666 mask = 1u << (pin_number % 4);
1667 idx = pin_number / 4;
1670 max3421_hcd->iopins[idx] |= mask;
1672 max3421_hcd->iopins[idx] &= ~mask;
1673 set_bit(IOPIN_UPDATE, &max3421_hcd->todo);
1674 wake_up_process(max3421_hcd->spi_thread);
1678 max3421_hub_control(struct usb_hcd *hcd, u16 type_req, u16 value, u16 index,
1679 char *buf, u16 length)
1681 struct spi_device *spi = to_spi_device(hcd->self.controller);
1682 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
1683 struct max3421_hcd_platform_data *pdata;
1684 unsigned long flags;
1687 pdata = spi->dev.platform_data;
1689 spin_lock_irqsave(&max3421_hcd->lock, flags);
1692 case ClearHubFeature:
1694 case ClearPortFeature:
1696 case USB_PORT_FEAT_SUSPEND:
1698 case USB_PORT_FEAT_POWER:
1699 dev_dbg(hcd->self.controller, "power-off\n");
1700 max3421_gpout_set_value(hcd, pdata->vbus_gpout,
1701 !pdata->vbus_active_level);
1704 max3421_hcd->port_status &= ~(1 << value);
1707 case GetHubDescriptor:
1708 hub_descriptor((struct usb_hub_descriptor *) buf);
1711 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
1712 case GetPortErrorCount:
1718 *(__le32 *) buf = cpu_to_le32(0);
1726 ((__le16 *) buf)[0] = cpu_to_le16(max3421_hcd->port_status);
1727 ((__le16 *) buf)[1] =
1728 cpu_to_le16(max3421_hcd->port_status >> 16);
1735 case SetPortFeature:
1737 case USB_PORT_FEAT_LINK_STATE:
1738 case USB_PORT_FEAT_U1_TIMEOUT:
1739 case USB_PORT_FEAT_U2_TIMEOUT:
1740 case USB_PORT_FEAT_BH_PORT_RESET:
1742 case USB_PORT_FEAT_SUSPEND:
1743 if (max3421_hcd->active)
1744 max3421_hcd->port_status |=
1745 USB_PORT_STAT_SUSPEND;
1747 case USB_PORT_FEAT_POWER:
1748 dev_dbg(hcd->self.controller, "power-on\n");
1749 max3421_hcd->port_status |= USB_PORT_STAT_POWER;
1750 max3421_gpout_set_value(hcd, pdata->vbus_gpout,
1751 pdata->vbus_active_level);
1753 case USB_PORT_FEAT_RESET:
1754 max3421_reset_port(hcd);
1757 if ((max3421_hcd->port_status & USB_PORT_STAT_POWER)
1759 max3421_hcd->port_status |= (1 << value);
1764 dev_dbg(hcd->self.controller,
1765 "hub control req%04x v%04x i%04x l%d\n",
1766 type_req, value, index, length);
1767 error: /* "protocol stall" on error */
1771 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1776 max3421_bus_suspend(struct usb_hcd *hcd)
1782 max3421_bus_resume(struct usb_hcd *hcd)
1788 * The SPI driver already takes care of DMA-mapping/unmapping, so no
1789 * reason to do it twice.
1792 max3421_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
1798 max3421_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1802 static const struct hc_driver max3421_hcd_desc = {
1803 .description = "max3421",
1804 .product_desc = DRIVER_DESC,
1805 .hcd_priv_size = sizeof(struct max3421_hcd),
1807 .reset = max3421_reset,
1808 .start = max3421_start,
1809 .stop = max3421_stop,
1810 .get_frame_number = max3421_get_frame_number,
1811 .urb_enqueue = max3421_urb_enqueue,
1812 .urb_dequeue = max3421_urb_dequeue,
1813 .map_urb_for_dma = max3421_map_urb_for_dma,
1814 .unmap_urb_for_dma = max3421_unmap_urb_for_dma,
1815 .endpoint_disable = max3421_endpoint_disable,
1816 .hub_status_data = max3421_hub_status_data,
1817 .hub_control = max3421_hub_control,
1818 .bus_suspend = max3421_bus_suspend,
1819 .bus_resume = max3421_bus_resume,
1823 max3421_of_vbus_en_pin(struct device *dev, struct max3421_hcd_platform_data *pdata)
1831 retval = of_property_read_u32_array(dev->of_node, "maxim,vbus-en-pin", value, 2);
1833 dev_err(dev, "device tree node property 'maxim,vbus-en-pin' is missing\n");
1836 dev_info(dev, "property 'maxim,vbus-en-pin' value is <%d %d>\n", value[0], value[1]);
1838 pdata->vbus_gpout = value[0];
1839 pdata->vbus_active_level = value[1];
1845 max3421_probe(struct spi_device *spi)
1847 struct device *dev = &spi->dev;
1848 struct max3421_hcd *max3421_hcd;
1849 struct usb_hcd *hcd = NULL;
1850 struct max3421_hcd_platform_data *pdata = NULL;
1853 if (spi_setup(spi) < 0) {
1854 dev_err(&spi->dev, "Unable to setup SPI bus");
1859 dev_err(dev, "Failed to get SPI IRQ");
1863 if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
1864 pdata = devm_kzalloc(&spi->dev, sizeof(*pdata), GFP_KERNEL);
1869 retval = max3421_of_vbus_en_pin(dev, pdata);
1873 spi->dev.platform_data = pdata;
1876 pdata = spi->dev.platform_data;
1878 dev_err(&spi->dev, "driver configuration data is not provided\n");
1882 if (pdata->vbus_active_level > 1) {
1883 dev_err(&spi->dev, "vbus active level value %d is out of range (0/1)\n", pdata->vbus_active_level);
1887 if (pdata->vbus_gpout < 1 || pdata->vbus_gpout > MAX3421_GPOUT_COUNT) {
1888 dev_err(&spi->dev, "vbus gpout value %d is out of range (1..8)\n", pdata->vbus_gpout);
1894 hcd = usb_create_hcd(&max3421_hcd_desc, &spi->dev,
1895 dev_name(&spi->dev));
1897 dev_err(&spi->dev, "failed to create HCD structure\n");
1900 set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
1901 max3421_hcd = hcd_to_max3421(hcd);
1902 max3421_hcd->next = max3421_hcd_list;
1903 max3421_hcd_list = max3421_hcd;
1904 INIT_LIST_HEAD(&max3421_hcd->ep_list);
1906 max3421_hcd->tx = kmalloc(sizeof(*max3421_hcd->tx), GFP_KERNEL);
1907 if (!max3421_hcd->tx)
1909 max3421_hcd->rx = kmalloc(sizeof(*max3421_hcd->rx), GFP_KERNEL);
1910 if (!max3421_hcd->rx)
1913 max3421_hcd->spi_thread = kthread_run(max3421_spi_thread, hcd,
1914 "max3421_spi_thread");
1915 if (max3421_hcd->spi_thread == ERR_PTR(-ENOMEM)) {
1917 "failed to create SPI thread (out of memory)\n");
1921 retval = usb_add_hcd(hcd, 0, 0);
1923 dev_err(&spi->dev, "failed to add HCD\n");
1927 retval = request_irq(spi->irq, max3421_irq_handler,
1928 IRQF_TRIGGER_LOW, "max3421", hcd);
1930 dev_err(&spi->dev, "failed to request irq %d\n", spi->irq);
1936 if (IS_ENABLED(CONFIG_OF) && dev->of_node && pdata) {
1937 devm_kfree(&spi->dev, pdata);
1938 spi->dev.platform_data = NULL;
1942 kfree(max3421_hcd->tx);
1943 kfree(max3421_hcd->rx);
1944 if (max3421_hcd->spi_thread)
1945 kthread_stop(max3421_hcd->spi_thread);
1952 max3421_remove(struct spi_device *spi)
1954 struct max3421_hcd *max3421_hcd = NULL, **prev;
1955 struct usb_hcd *hcd = NULL;
1956 unsigned long flags;
1958 for (prev = &max3421_hcd_list; *prev; prev = &(*prev)->next) {
1959 max3421_hcd = *prev;
1960 hcd = max3421_to_hcd(max3421_hcd);
1961 if (hcd->self.controller == &spi->dev)
1965 dev_err(&spi->dev, "no MAX3421 HCD found for SPI device %p\n",
1970 usb_remove_hcd(hcd);
1972 spin_lock_irqsave(&max3421_hcd->lock, flags);
1974 kthread_stop(max3421_hcd->spi_thread);
1975 *prev = max3421_hcd->next;
1977 spin_unlock_irqrestore(&max3421_hcd->lock, flags);
1979 free_irq(spi->irq, hcd);
1985 static const struct of_device_id max3421_of_match_table[] = {
1986 { .compatible = "maxim,max3421", },
1989 MODULE_DEVICE_TABLE(of, max3421_of_match_table);
1991 static struct spi_driver max3421_driver = {
1992 .probe = max3421_probe,
1993 .remove = max3421_remove,
1995 .name = "max3421-hcd",
1996 .of_match_table = of_match_ptr(max3421_of_match_table),
2000 module_spi_driver(max3421_driver);
2002 MODULE_DESCRIPTION(DRIVER_DESC);
2003 MODULE_AUTHOR("David Mosberger <davidm@egauge.net>");
2004 MODULE_LICENSE("GPL");