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