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 86 enum max3421_rh_state { 87 MAX3421_RH_RESET, 88 MAX3421_RH_SUSPENDED, 89 MAX3421_RH_RUNNING 90 }; 91 92 enum 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 98 enum scheduling_pass { 99 SCHED_PASS_PERIODIC, 100 SCHED_PASS_NON_PERIODIC, 101 SCHED_PASS_DONE 102 }; 103 104 /* Bit numbers for max3421_hcd->todo: */ 105 enum { 106 ENABLE_IRQ = 0, 107 RESET_HCD, 108 RESET_PORT, 109 CHECK_UNLINK, 110 IOPIN_UPDATE 111 }; 112 113 struct max3421_dma_buf { 114 u8 data[2]; 115 }; 116 117 struct 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 159 struct 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 202 enum { 203 MAX3421_USBIRQ_OSCOKIRQ_BIT = 0, 204 MAX3421_USBIRQ_NOVBUSIRQ_BIT = 5, 205 MAX3421_USBIRQ_VBUSIRQ_BIT 206 }; 207 208 enum { 209 MAX3421_CPUCTL_IE_BIT = 0, 210 MAX3421_CPUCTL_PULSEWID0_BIT = 6, 211 MAX3421_CPUCTL_PULSEWID1_BIT 212 }; 213 214 enum { 215 MAX3421_USBCTL_PWRDOWN_BIT = 4, 216 MAX3421_USBCTL_CHIPRES_BIT 217 }; 218 219 enum { 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 230 enum { 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 241 enum { 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 252 enum { 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 263 enum { 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: */ 288 static 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 322 static inline s16 323 frame_diff(u16 left, u16 right) 324 { 325 return ((unsigned) (left - right)) % (USB_MAX_FRAME_NUMBER + 1); 326 } 327 328 static inline struct max3421_hcd * 329 hcd_to_max3421(struct usb_hcd *hcd) 330 { 331 return (struct max3421_hcd *) hcd->hcd_priv; 332 } 333 334 static inline struct usb_hcd * 335 max3421_to_hcd(struct max3421_hcd *max3421_hcd) 336 { 337 return container_of((void *) max3421_hcd, struct usb_hcd, hcd_priv); 338 } 339 340 static u8 341 spi_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 366 static void 367 spi_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 390 static void 391 spi_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 416 static void 417 spi_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 */ 456 static void 457 max3421_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 */ 482 static void 483 max3421_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 504 static int 505 max3421_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 511 static int 512 max3421_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 522 static int 523 max3421_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 */ 568 static void 569 max3421_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 */ 628 static int 629 max3421_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 } 724 done: 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 */ 763 static int 764 max3421_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 */ 797 static void 798 max3421_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 */ 812 static void 813 max3421_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 843 static void 844 max3421_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 */ 932 static int 933 max3421_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 */ 976 static int 977 max3421_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 */ 1003 static void 1004 max3421_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 */ 1069 static void 1070 max3421_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 1126 static irqreturn_t 1127 max3421_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 1142 static void 1143 dump_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 = snprintf(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 < 0 || ret >= end - dp) 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. */ 1183 static int 1184 max3421_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 = snprintf(dp, end - dp, " %lu", 1259 max3421_hcd->err_stat[i]); 1260 if (ret < 0 || ret >= end - dp) 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 1276 static int 1277 max3421_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 1329 static int 1330 max3421_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 1364 static int 1365 max3421_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 1445 static int 1446 max3421_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 1458 static int 1459 max3421_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 1471 static int 1472 max3421_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 1487 static void 1488 max3421_stop(struct usb_hcd *hcd) 1489 { 1490 } 1491 1492 static int 1493 max3421_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 1539 out: 1540 spin_unlock_irqrestore(&max3421_hcd->lock, flags); 1541 return retval; 1542 } 1543 1544 static int 1545 max3421_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 1566 static void 1567 max3421_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 1587 static int 1588 max3421_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 */ 1598 static int 1599 max3421_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 } 1619 done: 1620 spin_unlock_irqrestore(&max3421_hcd->lock, flags); 1621 return retval; 1622 } 1623 1624 static inline void 1625 hub_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 */ 1643 static void 1644 max3421_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 1664 static int 1665 max3421_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); 1754 error: /* "protocol stall" on error */ 1755 retval = -EPIPE; 1756 } 1757 1758 spin_unlock_irqrestore(&max3421_hcd->lock, flags); 1759 return retval; 1760 } 1761 1762 static int 1763 max3421_bus_suspend(struct usb_hcd *hcd) 1764 { 1765 return -1; 1766 } 1767 1768 static int 1769 max3421_bus_resume(struct usb_hcd *hcd) 1770 { 1771 return -1; 1772 } 1773 1774 static 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 1792 static int 1793 max3421_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 1814 static int 1815 max3421_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 1904 error: 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 1920 static void 1921 max3421_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 1943 static const struct of_device_id max3421_of_match_table[] = { 1944 { .compatible = "maxim,max3421", }, 1945 {}, 1946 }; 1947 MODULE_DEVICE_TABLE(of, max3421_of_match_table); 1948 1949 static struct spi_driver max3421_driver = { 1950 .probe = max3421_probe, 1951 .remove = max3421_remove, 1952 .driver = { 1953 .name = "max3421-hcd", 1954 .of_match_table = of_match_ptr(max3421_of_match_table), 1955 }, 1956 }; 1957 1958 module_spi_driver(max3421_driver); 1959 1960 MODULE_DESCRIPTION(DRIVER_DESC); 1961 MODULE_AUTHOR("David Mosberger <davidm@egauge.net>"); 1962 MODULE_LICENSE("GPL"); 1963