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 * http://datasheets.maximintegrated.com/en/ds/MAX3421E.pdf 15 * o MAX3421E Programming Guide 16 * http://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 http://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 /* FALL THROUGH */ 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 max3421_hcd->spi_thread->state != TASK_RUNNING) 1174 wake_up_process(max3421_hcd->spi_thread); 1175 if (!test_and_set_bit(ENABLE_IRQ, &max3421_hcd->todo)) 1176 disable_irq_nosync(spi->irq); 1177 return IRQ_HANDLED; 1178 } 1179 1180 #ifdef DEBUG 1181 1182 static void 1183 dump_eps(struct usb_hcd *hcd) 1184 { 1185 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); 1186 struct max3421_ep *max3421_ep; 1187 struct usb_host_endpoint *ep; 1188 char ubuf[512], *dp, *end; 1189 unsigned long flags; 1190 struct urb *urb; 1191 int epnum, ret; 1192 1193 spin_lock_irqsave(&max3421_hcd->lock, flags); 1194 list_for_each_entry(max3421_ep, &max3421_hcd->ep_list, ep_list) { 1195 ep = max3421_ep->ep; 1196 1197 dp = ubuf; 1198 end = dp + sizeof(ubuf); 1199 *dp = '\0'; 1200 list_for_each_entry(urb, &ep->urb_list, urb_list) { 1201 ret = snprintf(dp, end - dp, " %p(%d.%s %d/%d)", urb, 1202 usb_pipetype(urb->pipe), 1203 usb_urb_dir_in(urb) ? "IN" : "OUT", 1204 urb->actual_length, 1205 urb->transfer_buffer_length); 1206 if (ret < 0 || ret >= end - dp) 1207 break; /* error or buffer full */ 1208 dp += ret; 1209 } 1210 1211 epnum = usb_endpoint_num(&ep->desc); 1212 pr_info("EP%0u %u lst %04u rtr %u nak %6u rxmt %u: %s\n", 1213 epnum, max3421_ep->pkt_state, max3421_ep->last_active, 1214 max3421_ep->retries, max3421_ep->naks, 1215 max3421_ep->retransmit, ubuf); 1216 } 1217 spin_unlock_irqrestore(&max3421_hcd->lock, flags); 1218 } 1219 1220 #endif /* DEBUG */ 1221 1222 /* Return zero if no work was performed, 1 otherwise. */ 1223 static int 1224 max3421_handle_irqs(struct usb_hcd *hcd) 1225 { 1226 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); 1227 u32 chg, old_port_status; 1228 unsigned long flags; 1229 u8 hirq; 1230 1231 /* 1232 * Read and ack pending interrupts (CPU must never 1233 * clear SNDBAV directly and RCVDAV must be cleared by 1234 * max3421_recv_data_available()!): 1235 */ 1236 hirq = spi_rd8(hcd, MAX3421_REG_HIRQ); 1237 hirq &= max3421_hcd->hien; 1238 if (!hirq) 1239 return 0; 1240 1241 spi_wr8(hcd, MAX3421_REG_HIRQ, 1242 hirq & ~(BIT(MAX3421_HI_SNDBAV_BIT) | 1243 BIT(MAX3421_HI_RCVDAV_BIT))); 1244 1245 if (hirq & BIT(MAX3421_HI_FRAME_BIT)) { 1246 max3421_hcd->frame_number = ((max3421_hcd->frame_number + 1) 1247 & USB_MAX_FRAME_NUMBER); 1248 max3421_hcd->sched_pass = SCHED_PASS_PERIODIC; 1249 } 1250 1251 if (hirq & BIT(MAX3421_HI_RCVDAV_BIT)) 1252 max3421_recv_data_available(hcd); 1253 1254 if (hirq & BIT(MAX3421_HI_HXFRDN_BIT)) 1255 max3421_host_transfer_done(hcd); 1256 1257 if (hirq & BIT(MAX3421_HI_CONDET_BIT)) 1258 max3421_detect_conn(hcd); 1259 1260 /* 1261 * Now process interrupts that may affect HCD state 1262 * other than the end-points: 1263 */ 1264 spin_lock_irqsave(&max3421_hcd->lock, flags); 1265 1266 old_port_status = max3421_hcd->port_status; 1267 if (hirq & BIT(MAX3421_HI_BUSEVENT_BIT)) { 1268 if (max3421_hcd->port_status & USB_PORT_STAT_RESET) { 1269 /* BUSEVENT due to completion of Bus Reset */ 1270 max3421_hcd->port_status &= ~USB_PORT_STAT_RESET; 1271 max3421_hcd->port_status |= USB_PORT_STAT_ENABLE; 1272 } else { 1273 /* BUSEVENT due to completion of Bus Resume */ 1274 pr_info("%s: BUSEVENT Bus Resume Done\n", __func__); 1275 } 1276 } 1277 if (hirq & BIT(MAX3421_HI_RWU_BIT)) 1278 pr_info("%s: RWU\n", __func__); 1279 if (hirq & BIT(MAX3421_HI_SUSDN_BIT)) 1280 pr_info("%s: SUSDN\n", __func__); 1281 1282 chg = (old_port_status ^ max3421_hcd->port_status); 1283 max3421_hcd->port_status |= chg << 16; 1284 1285 spin_unlock_irqrestore(&max3421_hcd->lock, flags); 1286 1287 #ifdef DEBUG 1288 { 1289 static unsigned long last_time; 1290 char sbuf[16 * 16], *dp, *end; 1291 int i; 1292 1293 if (time_after(jiffies, last_time + 5*HZ)) { 1294 dp = sbuf; 1295 end = sbuf + sizeof(sbuf); 1296 *dp = '\0'; 1297 for (i = 0; i < 16; ++i) { 1298 int ret = snprintf(dp, end - dp, " %lu", 1299 max3421_hcd->err_stat[i]); 1300 if (ret < 0 || ret >= end - dp) 1301 break; /* error or buffer full */ 1302 dp += ret; 1303 } 1304 pr_info("%s: hrsl_stats %s\n", __func__, sbuf); 1305 memset(max3421_hcd->err_stat, 0, 1306 sizeof(max3421_hcd->err_stat)); 1307 last_time = jiffies; 1308 1309 dump_eps(hcd); 1310 } 1311 } 1312 #endif 1313 return 1; 1314 } 1315 1316 static int 1317 max3421_reset_hcd(struct usb_hcd *hcd) 1318 { 1319 struct spi_device *spi = to_spi_device(hcd->self.controller); 1320 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); 1321 int timeout; 1322 1323 /* perform a chip reset and wait for OSCIRQ signal to appear: */ 1324 spi_wr8(hcd, MAX3421_REG_USBCTL, BIT(MAX3421_USBCTL_CHIPRES_BIT)); 1325 /* clear reset: */ 1326 spi_wr8(hcd, MAX3421_REG_USBCTL, 0); 1327 timeout = 1000; 1328 while (1) { 1329 if (spi_rd8(hcd, MAX3421_REG_USBIRQ) 1330 & BIT(MAX3421_USBIRQ_OSCOKIRQ_BIT)) 1331 break; 1332 if (--timeout < 0) { 1333 dev_err(&spi->dev, 1334 "timed out waiting for oscillator OK signal"); 1335 return 1; 1336 } 1337 cond_resched(); 1338 } 1339 1340 /* 1341 * Turn on host mode, automatic generation of SOF packets, and 1342 * enable pull-down registers on DM/DP: 1343 */ 1344 max3421_hcd->mode = (BIT(MAX3421_MODE_HOST_BIT) | 1345 BIT(MAX3421_MODE_SOFKAENAB_BIT) | 1346 BIT(MAX3421_MODE_DMPULLDN_BIT) | 1347 BIT(MAX3421_MODE_DPPULLDN_BIT)); 1348 spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode); 1349 1350 /* reset frame-number: */ 1351 max3421_hcd->frame_number = USB_MAX_FRAME_NUMBER; 1352 spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_FRMRST_BIT)); 1353 1354 /* sample the state of the D+ and D- lines */ 1355 spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_SAMPLEBUS_BIT)); 1356 max3421_detect_conn(hcd); 1357 1358 /* enable frame, connection-detected, and bus-event interrupts: */ 1359 max3421_hcd->hien = (BIT(MAX3421_HI_FRAME_BIT) | 1360 BIT(MAX3421_HI_CONDET_BIT) | 1361 BIT(MAX3421_HI_BUSEVENT_BIT)); 1362 spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien); 1363 1364 /* enable interrupts: */ 1365 spi_wr8(hcd, MAX3421_REG_CPUCTL, BIT(MAX3421_CPUCTL_IE_BIT)); 1366 return 1; 1367 } 1368 1369 static int 1370 max3421_urb_done(struct usb_hcd *hcd) 1371 { 1372 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); 1373 unsigned long flags; 1374 struct urb *urb; 1375 int status; 1376 1377 status = max3421_hcd->urb_done; 1378 max3421_hcd->urb_done = 0; 1379 if (status > 0) 1380 status = 0; 1381 urb = max3421_hcd->curr_urb; 1382 if (urb) { 1383 max3421_hcd->curr_urb = NULL; 1384 spin_lock_irqsave(&max3421_hcd->lock, flags); 1385 usb_hcd_unlink_urb_from_ep(hcd, urb); 1386 spin_unlock_irqrestore(&max3421_hcd->lock, flags); 1387 1388 /* must be called without the HCD spinlock: */ 1389 usb_hcd_giveback_urb(hcd, urb, status); 1390 } 1391 return 1; 1392 } 1393 1394 static int 1395 max3421_spi_thread(void *dev_id) 1396 { 1397 struct usb_hcd *hcd = dev_id; 1398 struct spi_device *spi = to_spi_device(hcd->self.controller); 1399 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); 1400 int i, i_worked = 1; 1401 1402 /* set full-duplex SPI mode, low-active interrupt pin: */ 1403 spi_wr8(hcd, MAX3421_REG_PINCTL, 1404 (BIT(MAX3421_PINCTL_FDUPSPI_BIT) | /* full-duplex */ 1405 BIT(MAX3421_PINCTL_INTLEVEL_BIT))); /* low-active irq */ 1406 1407 while (!kthread_should_stop()) { 1408 max3421_hcd->rev = spi_rd8(hcd, MAX3421_REG_REVISION); 1409 if (max3421_hcd->rev == 0x12 || max3421_hcd->rev == 0x13) 1410 break; 1411 dev_err(&spi->dev, "bad rev 0x%02x", max3421_hcd->rev); 1412 msleep(10000); 1413 } 1414 dev_info(&spi->dev, "rev 0x%x, SPI clk %dHz, bpw %u, irq %d\n", 1415 max3421_hcd->rev, spi->max_speed_hz, spi->bits_per_word, 1416 spi->irq); 1417 1418 while (!kthread_should_stop()) { 1419 if (!i_worked) { 1420 /* 1421 * We'll be waiting for wakeups from the hard 1422 * interrupt handler, so now is a good time to 1423 * sync our hien with the chip: 1424 */ 1425 spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien); 1426 1427 set_current_state(TASK_INTERRUPTIBLE); 1428 if (test_and_clear_bit(ENABLE_IRQ, &max3421_hcd->todo)) 1429 enable_irq(spi->irq); 1430 schedule(); 1431 __set_current_state(TASK_RUNNING); 1432 } 1433 1434 i_worked = 0; 1435 1436 if (max3421_hcd->urb_done) 1437 i_worked |= max3421_urb_done(hcd); 1438 else if (max3421_handle_irqs(hcd)) 1439 i_worked = 1; 1440 else if (!max3421_hcd->curr_urb) 1441 i_worked |= max3421_select_and_start_urb(hcd); 1442 1443 if (test_and_clear_bit(RESET_HCD, &max3421_hcd->todo)) 1444 /* reset the HCD: */ 1445 i_worked |= max3421_reset_hcd(hcd); 1446 if (test_and_clear_bit(RESET_PORT, &max3421_hcd->todo)) { 1447 /* perform a USB bus reset: */ 1448 spi_wr8(hcd, MAX3421_REG_HCTL, 1449 BIT(MAX3421_HCTL_BUSRST_BIT)); 1450 i_worked = 1; 1451 } 1452 if (test_and_clear_bit(CHECK_UNLINK, &max3421_hcd->todo)) 1453 i_worked |= max3421_check_unlink(hcd); 1454 if (test_and_clear_bit(IOPIN_UPDATE, &max3421_hcd->todo)) { 1455 /* 1456 * IOPINS1/IOPINS2 do not auto-increment, so we can't 1457 * use spi_wr_buf(). 1458 */ 1459 for (i = 0; i < ARRAY_SIZE(max3421_hcd->iopins); ++i) { 1460 u8 val = spi_rd8(hcd, MAX3421_REG_IOPINS1); 1461 1462 val = ((val & 0xf0) | 1463 (max3421_hcd->iopins[i] & 0x0f)); 1464 spi_wr8(hcd, MAX3421_REG_IOPINS1 + i, val); 1465 max3421_hcd->iopins[i] = val; 1466 } 1467 i_worked = 1; 1468 } 1469 } 1470 set_current_state(TASK_RUNNING); 1471 dev_info(&spi->dev, "SPI thread exiting"); 1472 return 0; 1473 } 1474 1475 static int 1476 max3421_reset_port(struct usb_hcd *hcd) 1477 { 1478 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); 1479 1480 max3421_hcd->port_status &= ~(USB_PORT_STAT_ENABLE | 1481 USB_PORT_STAT_LOW_SPEED); 1482 max3421_hcd->port_status |= USB_PORT_STAT_RESET; 1483 set_bit(RESET_PORT, &max3421_hcd->todo); 1484 wake_up_process(max3421_hcd->spi_thread); 1485 return 0; 1486 } 1487 1488 static int 1489 max3421_reset(struct usb_hcd *hcd) 1490 { 1491 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); 1492 1493 hcd->self.sg_tablesize = 0; 1494 hcd->speed = HCD_USB2; 1495 hcd->self.root_hub->speed = USB_SPEED_FULL; 1496 set_bit(RESET_HCD, &max3421_hcd->todo); 1497 wake_up_process(max3421_hcd->spi_thread); 1498 return 0; 1499 } 1500 1501 static int 1502 max3421_start(struct usb_hcd *hcd) 1503 { 1504 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); 1505 1506 spin_lock_init(&max3421_hcd->lock); 1507 max3421_hcd->rh_state = MAX3421_RH_RUNNING; 1508 1509 INIT_LIST_HEAD(&max3421_hcd->ep_list); 1510 1511 hcd->power_budget = POWER_BUDGET; 1512 hcd->state = HC_STATE_RUNNING; 1513 hcd->uses_new_polling = 1; 1514 return 0; 1515 } 1516 1517 static void 1518 max3421_stop(struct usb_hcd *hcd) 1519 { 1520 } 1521 1522 static int 1523 max3421_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags) 1524 { 1525 struct spi_device *spi = to_spi_device(hcd->self.controller); 1526 struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd); 1527 struct max3421_ep *max3421_ep; 1528 unsigned long flags; 1529 int retval; 1530 1531 switch (usb_pipetype(urb->pipe)) { 1532 case PIPE_INTERRUPT: 1533 case PIPE_ISOCHRONOUS: 1534 if (urb->interval < 0) { 1535 dev_err(&spi->dev, 1536 "%s: interval=%d for intr-/iso-pipe; expected > 0\n", 1537 __func__, urb->interval); 1538 return -EINVAL; 1539 } 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 /* FALLS THROUGH */ 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 /* FALLS THROUGH */ 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 /* 1804 * The SPI driver already takes care of DMA-mapping/unmapping, so no 1805 * reason to do it twice. 1806 */ 1807 static int 1808 max3421_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags) 1809 { 1810 return 0; 1811 } 1812 1813 static void 1814 max3421_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb) 1815 { 1816 } 1817 1818 static const struct hc_driver max3421_hcd_desc = { 1819 .description = "max3421", 1820 .product_desc = DRIVER_DESC, 1821 .hcd_priv_size = sizeof(struct max3421_hcd), 1822 .flags = HCD_USB11, 1823 .reset = max3421_reset, 1824 .start = max3421_start, 1825 .stop = max3421_stop, 1826 .get_frame_number = max3421_get_frame_number, 1827 .urb_enqueue = max3421_urb_enqueue, 1828 .urb_dequeue = max3421_urb_dequeue, 1829 .map_urb_for_dma = max3421_map_urb_for_dma, 1830 .unmap_urb_for_dma = max3421_unmap_urb_for_dma, 1831 .endpoint_disable = max3421_endpoint_disable, 1832 .hub_status_data = max3421_hub_status_data, 1833 .hub_control = max3421_hub_control, 1834 .bus_suspend = max3421_bus_suspend, 1835 .bus_resume = max3421_bus_resume, 1836 }; 1837 1838 static int 1839 max3421_of_vbus_en_pin(struct device *dev, struct max3421_hcd_platform_data *pdata) 1840 { 1841 int retval; 1842 uint32_t value[2]; 1843 1844 if (!pdata) 1845 return -EINVAL; 1846 1847 retval = of_property_read_u32_array(dev->of_node, "maxim,vbus-en-pin", value, 2); 1848 if (retval) { 1849 dev_err(dev, "device tree node property 'maxim,vbus-en-pin' is missing\n"); 1850 return retval; 1851 } 1852 dev_info(dev, "property 'maxim,vbus-en-pin' value is <%d %d>\n", value[0], value[1]); 1853 1854 pdata->vbus_gpout = value[0]; 1855 pdata->vbus_active_level = value[1]; 1856 1857 return 0; 1858 } 1859 1860 static int 1861 max3421_probe(struct spi_device *spi) 1862 { 1863 struct device *dev = &spi->dev; 1864 struct max3421_hcd *max3421_hcd; 1865 struct usb_hcd *hcd = NULL; 1866 struct max3421_hcd_platform_data *pdata = NULL; 1867 int retval = -ENOMEM; 1868 1869 if (spi_setup(spi) < 0) { 1870 dev_err(&spi->dev, "Unable to setup SPI bus"); 1871 return -EFAULT; 1872 } 1873 1874 if (!spi->irq) { 1875 dev_err(dev, "Failed to get SPI IRQ"); 1876 return -EFAULT; 1877 } 1878 1879 if (IS_ENABLED(CONFIG_OF) && dev->of_node) { 1880 pdata = devm_kzalloc(&spi->dev, sizeof(*pdata), GFP_KERNEL); 1881 if (!pdata) { 1882 retval = -ENOMEM; 1883 goto error; 1884 } 1885 retval = max3421_of_vbus_en_pin(dev, pdata); 1886 if (retval) 1887 goto error; 1888 1889 spi->dev.platform_data = pdata; 1890 } 1891 1892 pdata = spi->dev.platform_data; 1893 if (!pdata) { 1894 dev_err(&spi->dev, "driver configuration data is not provided\n"); 1895 retval = -EFAULT; 1896 goto error; 1897 } 1898 if (pdata->vbus_active_level > 1) { 1899 dev_err(&spi->dev, "vbus active level value %d is out of range (0/1)\n", pdata->vbus_active_level); 1900 retval = -EINVAL; 1901 goto error; 1902 } 1903 if (pdata->vbus_gpout < 1 || pdata->vbus_gpout > MAX3421_GPOUT_COUNT) { 1904 dev_err(&spi->dev, "vbus gpout value %d is out of range (1..8)\n", pdata->vbus_gpout); 1905 retval = -EINVAL; 1906 goto error; 1907 } 1908 1909 hcd = usb_create_hcd(&max3421_hcd_desc, &spi->dev, 1910 dev_name(&spi->dev)); 1911 if (!hcd) { 1912 dev_err(&spi->dev, "failed to create HCD structure\n"); 1913 goto error; 1914 } 1915 set_bit(HCD_FLAG_POLL_RH, &hcd->flags); 1916 max3421_hcd = hcd_to_max3421(hcd); 1917 max3421_hcd->next = max3421_hcd_list; 1918 max3421_hcd_list = max3421_hcd; 1919 INIT_LIST_HEAD(&max3421_hcd->ep_list); 1920 1921 max3421_hcd->tx = kmalloc(sizeof(*max3421_hcd->tx), GFP_KERNEL); 1922 if (!max3421_hcd->tx) 1923 goto error; 1924 max3421_hcd->rx = kmalloc(sizeof(*max3421_hcd->rx), GFP_KERNEL); 1925 if (!max3421_hcd->rx) 1926 goto error; 1927 1928 max3421_hcd->spi_thread = kthread_run(max3421_spi_thread, hcd, 1929 "max3421_spi_thread"); 1930 if (max3421_hcd->spi_thread == ERR_PTR(-ENOMEM)) { 1931 dev_err(&spi->dev, 1932 "failed to create SPI thread (out of memory)\n"); 1933 goto error; 1934 } 1935 1936 retval = usb_add_hcd(hcd, 0, 0); 1937 if (retval) { 1938 dev_err(&spi->dev, "failed to add HCD\n"); 1939 goto error; 1940 } 1941 1942 retval = request_irq(spi->irq, max3421_irq_handler, 1943 IRQF_TRIGGER_LOW, "max3421", hcd); 1944 if (retval < 0) { 1945 dev_err(&spi->dev, "failed to request irq %d\n", spi->irq); 1946 goto error; 1947 } 1948 return 0; 1949 1950 error: 1951 if (IS_ENABLED(CONFIG_OF) && dev->of_node && pdata) { 1952 devm_kfree(&spi->dev, pdata); 1953 spi->dev.platform_data = NULL; 1954 } 1955 1956 if (hcd) { 1957 kfree(max3421_hcd->tx); 1958 kfree(max3421_hcd->rx); 1959 if (max3421_hcd->spi_thread) 1960 kthread_stop(max3421_hcd->spi_thread); 1961 usb_put_hcd(hcd); 1962 } 1963 return retval; 1964 } 1965 1966 static int 1967 max3421_remove(struct spi_device *spi) 1968 { 1969 struct max3421_hcd *max3421_hcd = NULL, **prev; 1970 struct usb_hcd *hcd = NULL; 1971 unsigned long flags; 1972 1973 for (prev = &max3421_hcd_list; *prev; prev = &(*prev)->next) { 1974 max3421_hcd = *prev; 1975 hcd = max3421_to_hcd(max3421_hcd); 1976 if (hcd->self.controller == &spi->dev) 1977 break; 1978 } 1979 if (!max3421_hcd) { 1980 dev_err(&spi->dev, "no MAX3421 HCD found for SPI device %p\n", 1981 spi); 1982 return -ENODEV; 1983 } 1984 1985 usb_remove_hcd(hcd); 1986 1987 spin_lock_irqsave(&max3421_hcd->lock, flags); 1988 1989 kthread_stop(max3421_hcd->spi_thread); 1990 *prev = max3421_hcd->next; 1991 1992 spin_unlock_irqrestore(&max3421_hcd->lock, flags); 1993 1994 free_irq(spi->irq, hcd); 1995 1996 usb_put_hcd(hcd); 1997 return 0; 1998 } 1999 2000 static const struct of_device_id max3421_of_match_table[] = { 2001 { .compatible = "maxim,max3421", }, 2002 {}, 2003 }; 2004 MODULE_DEVICE_TABLE(of, max3421_of_match_table); 2005 2006 static struct spi_driver max3421_driver = { 2007 .probe = max3421_probe, 2008 .remove = max3421_remove, 2009 .driver = { 2010 .name = "max3421-hcd", 2011 .of_match_table = of_match_ptr(max3421_of_match_table), 2012 }, 2013 }; 2014 2015 module_spi_driver(max3421_driver); 2016 2017 MODULE_DESCRIPTION(DRIVER_DESC); 2018 MODULE_AUTHOR("David Mosberger <davidm@egauge.net>"); 2019 MODULE_LICENSE("GPL"); 2020