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