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