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