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");