1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * MAX3420 Device Controller driver for USB. 4 * 5 * Author: Jaswinder Singh Brar <jaswinder.singh@linaro.org> 6 * (C) Copyright 2019-2020 Linaro Ltd 7 * 8 * Based on: 9 * o MAX3420E datasheet 10 * https://datasheets.maximintegrated.com/en/ds/MAX3420E.pdf 11 * o MAX342{0,1}E Programming Guides 12 * https://pdfserv.maximintegrated.com/en/an/AN3598.pdf 13 * https://pdfserv.maximintegrated.com/en/an/AN3785.pdf 14 */ 15 16 #include <linux/delay.h> 17 #include <linux/device.h> 18 #include <linux/interrupt.h> 19 #include <linux/io.h> 20 #include <linux/module.h> 21 #include <linux/bitfield.h> 22 #include <linux/of_address.h> 23 #include <linux/of_device.h> 24 #include <linux/of_platform.h> 25 #include <linux/of_irq.h> 26 #include <linux/prefetch.h> 27 #include <linux/usb/ch9.h> 28 #include <linux/usb/gadget.h> 29 #include <linux/spi/spi.h> 30 #include <linux/gpio/consumer.h> 31 32 #define MAX3420_MAX_EPS 4 33 #define MAX3420_EP_MAX_PACKET 64 /* Same for all Endpoints */ 34 #define MAX3420_EPNAME_SIZE 16 /* Buffer size for endpoint name */ 35 36 #define MAX3420_ACKSTAT BIT(0) 37 38 #define MAX3420_SPI_DIR_RD 0 /* read register from MAX3420 */ 39 #define MAX3420_SPI_DIR_WR 1 /* write register to MAX3420 */ 40 41 /* SPI commands: */ 42 #define MAX3420_SPI_DIR_SHIFT 1 43 #define MAX3420_SPI_REG_SHIFT 3 44 45 #define MAX3420_REG_EP0FIFO 0 46 #define MAX3420_REG_EP1FIFO 1 47 #define MAX3420_REG_EP2FIFO 2 48 #define MAX3420_REG_EP3FIFO 3 49 #define MAX3420_REG_SUDFIFO 4 50 #define MAX3420_REG_EP0BC 5 51 #define MAX3420_REG_EP1BC 6 52 #define MAX3420_REG_EP2BC 7 53 #define MAX3420_REG_EP3BC 8 54 55 #define MAX3420_REG_EPSTALLS 9 56 #define ACKSTAT BIT(6) 57 #define STLSTAT BIT(5) 58 #define STLEP3IN BIT(4) 59 #define STLEP2IN BIT(3) 60 #define STLEP1OUT BIT(2) 61 #define STLEP0OUT BIT(1) 62 #define STLEP0IN BIT(0) 63 64 #define MAX3420_REG_CLRTOGS 10 65 #define EP3DISAB BIT(7) 66 #define EP2DISAB BIT(6) 67 #define EP1DISAB BIT(5) 68 #define CTGEP3IN BIT(4) 69 #define CTGEP2IN BIT(3) 70 #define CTGEP1OUT BIT(2) 71 72 #define MAX3420_REG_EPIRQ 11 73 #define MAX3420_REG_EPIEN 12 74 #define SUDAVIRQ BIT(5) 75 #define IN3BAVIRQ BIT(4) 76 #define IN2BAVIRQ BIT(3) 77 #define OUT1DAVIRQ BIT(2) 78 #define OUT0DAVIRQ BIT(1) 79 #define IN0BAVIRQ BIT(0) 80 81 #define MAX3420_REG_USBIRQ 13 82 #define MAX3420_REG_USBIEN 14 83 #define OSCOKIRQ BIT(0) 84 #define RWUDNIRQ BIT(1) 85 #define BUSACTIRQ BIT(2) 86 #define URESIRQ BIT(3) 87 #define SUSPIRQ BIT(4) 88 #define NOVBUSIRQ BIT(5) 89 #define VBUSIRQ BIT(6) 90 #define URESDNIRQ BIT(7) 91 92 #define MAX3420_REG_USBCTL 15 93 #define HOSCSTEN BIT(7) 94 #define VBGATE BIT(6) 95 #define CHIPRES BIT(5) 96 #define PWRDOWN BIT(4) 97 #define CONNECT BIT(3) 98 #define SIGRWU BIT(2) 99 100 #define MAX3420_REG_CPUCTL 16 101 #define IE BIT(0) 102 103 #define MAX3420_REG_PINCTL 17 104 #define EP3INAK BIT(7) 105 #define EP2INAK BIT(6) 106 #define EP0INAK BIT(5) 107 #define FDUPSPI BIT(4) 108 #define INTLEVEL BIT(3) 109 #define POSINT BIT(2) 110 #define GPXB BIT(1) 111 #define GPXA BIT(0) 112 113 #define MAX3420_REG_REVISION 18 114 115 #define MAX3420_REG_FNADDR 19 116 #define FNADDR_MASK 0x7f 117 118 #define MAX3420_REG_IOPINS 20 119 #define MAX3420_REG_IOPINS2 21 120 #define MAX3420_REG_GPINIRQ 22 121 #define MAX3420_REG_GPINIEN 23 122 #define MAX3420_REG_GPINPOL 24 123 #define MAX3420_REG_HIRQ 25 124 #define MAX3420_REG_HIEN 26 125 #define MAX3420_REG_MODE 27 126 #define MAX3420_REG_PERADDR 28 127 #define MAX3420_REG_HCTL 29 128 #define MAX3420_REG_HXFR 30 129 #define MAX3420_REG_HRSL 31 130 131 #define ENABLE_IRQ BIT(0) 132 #define IOPIN_UPDATE BIT(1) 133 #define REMOTE_WAKEUP BIT(2) 134 #define CONNECT_HOST GENMASK(4, 3) 135 #define HCONNECT (1 << 3) 136 #define HDISCONNECT (3 << 3) 137 #define UDC_START GENMASK(6, 5) 138 #define START (1 << 5) 139 #define STOP (3 << 5) 140 #define ENABLE_EP GENMASK(8, 7) 141 #define ENABLE (1 << 7) 142 #define DISABLE (3 << 7) 143 #define STALL_EP GENMASK(10, 9) 144 #define STALL (1 << 9) 145 #define UNSTALL (3 << 9) 146 147 #define MAX3420_CMD(c) FIELD_PREP(GENMASK(7, 3), c) 148 #define MAX3420_SPI_CMD_RD(c) (MAX3420_CMD(c) | (0 << 1)) 149 #define MAX3420_SPI_CMD_WR(c) (MAX3420_CMD(c) | (1 << 1)) 150 151 struct max3420_req { 152 struct usb_request usb_req; 153 struct list_head queue; 154 struct max3420_ep *ep; 155 }; 156 157 struct max3420_ep { 158 struct usb_ep ep_usb; 159 struct max3420_udc *udc; 160 struct list_head queue; 161 char name[MAX3420_EPNAME_SIZE]; 162 unsigned int maxpacket; 163 spinlock_t lock; 164 int halted; 165 u32 todo; 166 int id; 167 }; 168 169 struct max3420_udc { 170 struct usb_gadget gadget; 171 struct max3420_ep ep[MAX3420_MAX_EPS]; 172 struct usb_gadget_driver *driver; 173 struct task_struct *thread_task; 174 int remote_wkp, is_selfpowered; 175 bool vbus_active, softconnect; 176 struct usb_ctrlrequest setup; 177 struct mutex spi_bus_mutex; 178 struct max3420_req ep0req; 179 struct spi_device *spi; 180 struct device *dev; 181 spinlock_t lock; 182 bool suspended; 183 u8 ep0buf[64]; 184 u32 todo; 185 }; 186 187 #define to_max3420_req(r) container_of((r), struct max3420_req, usb_req) 188 #define to_max3420_ep(e) container_of((e), struct max3420_ep, ep_usb) 189 #define to_udc(g) container_of((g), struct max3420_udc, gadget) 190 191 #define DRIVER_DESC "MAX3420 USB Device-Mode Driver" 192 static const char driver_name[] = "max3420-udc"; 193 194 /* Control endpoint configuration.*/ 195 static const struct usb_endpoint_descriptor ep0_desc = { 196 .bEndpointAddress = USB_DIR_OUT, 197 .bmAttributes = USB_ENDPOINT_XFER_CONTROL, 198 .wMaxPacketSize = cpu_to_le16(MAX3420_EP_MAX_PACKET), 199 }; 200 201 static void spi_ack_ctrl(struct max3420_udc *udc) 202 { 203 struct spi_device *spi = udc->spi; 204 struct spi_transfer transfer; 205 struct spi_message msg; 206 u8 txdata[1]; 207 208 memset(&transfer, 0, sizeof(transfer)); 209 210 spi_message_init(&msg); 211 212 txdata[0] = MAX3420_ACKSTAT; 213 transfer.tx_buf = txdata; 214 transfer.len = 1; 215 216 spi_message_add_tail(&transfer, &msg); 217 spi_sync(spi, &msg); 218 } 219 220 static u8 spi_rd8_ack(struct max3420_udc *udc, u8 reg, int actstat) 221 { 222 struct spi_device *spi = udc->spi; 223 struct spi_transfer transfer; 224 struct spi_message msg; 225 u8 txdata[2], rxdata[2]; 226 227 memset(&transfer, 0, sizeof(transfer)); 228 229 spi_message_init(&msg); 230 231 txdata[0] = MAX3420_SPI_CMD_RD(reg) | (actstat ? MAX3420_ACKSTAT : 0); 232 transfer.tx_buf = txdata; 233 transfer.rx_buf = rxdata; 234 transfer.len = 2; 235 236 spi_message_add_tail(&transfer, &msg); 237 spi_sync(spi, &msg); 238 239 return rxdata[1]; 240 } 241 242 static u8 spi_rd8(struct max3420_udc *udc, u8 reg) 243 { 244 return spi_rd8_ack(udc, reg, 0); 245 } 246 247 static void spi_wr8_ack(struct max3420_udc *udc, u8 reg, u8 val, int actstat) 248 { 249 struct spi_device *spi = udc->spi; 250 struct spi_transfer transfer; 251 struct spi_message msg; 252 u8 txdata[2]; 253 254 memset(&transfer, 0, sizeof(transfer)); 255 256 spi_message_init(&msg); 257 258 txdata[0] = MAX3420_SPI_CMD_WR(reg) | (actstat ? MAX3420_ACKSTAT : 0); 259 txdata[1] = val; 260 261 transfer.tx_buf = txdata; 262 transfer.len = 2; 263 264 spi_message_add_tail(&transfer, &msg); 265 spi_sync(spi, &msg); 266 } 267 268 static void spi_wr8(struct max3420_udc *udc, u8 reg, u8 val) 269 { 270 spi_wr8_ack(udc, reg, val, 0); 271 } 272 273 static void spi_rd_buf(struct max3420_udc *udc, u8 reg, void *buf, u8 len) 274 { 275 struct spi_device *spi = udc->spi; 276 struct spi_transfer transfer; 277 struct spi_message msg; 278 u8 local_buf[MAX3420_EP_MAX_PACKET + 1] = {}; 279 280 memset(&transfer, 0, sizeof(transfer)); 281 282 spi_message_init(&msg); 283 284 local_buf[0] = MAX3420_SPI_CMD_RD(reg); 285 transfer.tx_buf = &local_buf[0]; 286 transfer.rx_buf = &local_buf[0]; 287 transfer.len = len + 1; 288 289 spi_message_add_tail(&transfer, &msg); 290 spi_sync(spi, &msg); 291 292 memcpy(buf, &local_buf[1], len); 293 } 294 295 static void spi_wr_buf(struct max3420_udc *udc, u8 reg, void *buf, u8 len) 296 { 297 struct spi_device *spi = udc->spi; 298 struct spi_transfer transfer; 299 struct spi_message msg; 300 u8 local_buf[MAX3420_EP_MAX_PACKET + 1] = {}; 301 302 memset(&transfer, 0, sizeof(transfer)); 303 304 spi_message_init(&msg); 305 306 local_buf[0] = MAX3420_SPI_CMD_WR(reg); 307 memcpy(&local_buf[1], buf, len); 308 309 transfer.tx_buf = local_buf; 310 transfer.len = len + 1; 311 312 spi_message_add_tail(&transfer, &msg); 313 spi_sync(spi, &msg); 314 } 315 316 static int spi_max3420_enable(struct max3420_ep *ep) 317 { 318 struct max3420_udc *udc = ep->udc; 319 unsigned long flags; 320 u8 epdis, epien; 321 int todo; 322 323 spin_lock_irqsave(&ep->lock, flags); 324 todo = ep->todo & ENABLE_EP; 325 ep->todo &= ~ENABLE_EP; 326 spin_unlock_irqrestore(&ep->lock, flags); 327 328 if (!todo || ep->id == 0) 329 return false; 330 331 epien = spi_rd8(udc, MAX3420_REG_EPIEN); 332 epdis = spi_rd8(udc, MAX3420_REG_CLRTOGS); 333 334 if (todo == ENABLE) { 335 epdis &= ~BIT(ep->id + 4); 336 epien |= BIT(ep->id + 1); 337 } else { 338 epdis |= BIT(ep->id + 4); 339 epien &= ~BIT(ep->id + 1); 340 } 341 342 spi_wr8(udc, MAX3420_REG_CLRTOGS, epdis); 343 spi_wr8(udc, MAX3420_REG_EPIEN, epien); 344 345 return true; 346 } 347 348 static int spi_max3420_stall(struct max3420_ep *ep) 349 { 350 struct max3420_udc *udc = ep->udc; 351 unsigned long flags; 352 u8 epstalls; 353 int todo; 354 355 spin_lock_irqsave(&ep->lock, flags); 356 todo = ep->todo & STALL_EP; 357 ep->todo &= ~STALL_EP; 358 spin_unlock_irqrestore(&ep->lock, flags); 359 360 if (!todo || ep->id == 0) 361 return false; 362 363 epstalls = spi_rd8(udc, MAX3420_REG_EPSTALLS); 364 if (todo == STALL) { 365 ep->halted = 1; 366 epstalls |= BIT(ep->id + 1); 367 } else { 368 u8 clrtogs; 369 370 ep->halted = 0; 371 epstalls &= ~BIT(ep->id + 1); 372 clrtogs = spi_rd8(udc, MAX3420_REG_CLRTOGS); 373 clrtogs |= BIT(ep->id + 1); 374 spi_wr8(udc, MAX3420_REG_CLRTOGS, clrtogs); 375 } 376 spi_wr8(udc, MAX3420_REG_EPSTALLS, epstalls | ACKSTAT); 377 378 return true; 379 } 380 381 static int spi_max3420_rwkup(struct max3420_udc *udc) 382 { 383 unsigned long flags; 384 int wake_remote; 385 u8 usbctl; 386 387 spin_lock_irqsave(&udc->lock, flags); 388 wake_remote = udc->todo & REMOTE_WAKEUP; 389 udc->todo &= ~REMOTE_WAKEUP; 390 spin_unlock_irqrestore(&udc->lock, flags); 391 392 if (!wake_remote || !udc->suspended) 393 return false; 394 395 /* Set Remote-WkUp Signal*/ 396 usbctl = spi_rd8(udc, MAX3420_REG_USBCTL); 397 usbctl |= SIGRWU; 398 spi_wr8(udc, MAX3420_REG_USBCTL, usbctl); 399 400 msleep_interruptible(5); 401 402 /* Clear Remote-WkUp Signal*/ 403 usbctl = spi_rd8(udc, MAX3420_REG_USBCTL); 404 usbctl &= ~SIGRWU; 405 spi_wr8(udc, MAX3420_REG_USBCTL, usbctl); 406 407 udc->suspended = false; 408 409 return true; 410 } 411 412 static void max3420_nuke(struct max3420_ep *ep, int status); 413 static void __max3420_stop(struct max3420_udc *udc) 414 { 415 u8 val; 416 int i; 417 418 /* clear all pending requests */ 419 for (i = 1; i < MAX3420_MAX_EPS; i++) 420 max3420_nuke(&udc->ep[i], -ECONNRESET); 421 422 /* Disable IRQ to CPU */ 423 spi_wr8(udc, MAX3420_REG_CPUCTL, 0); 424 425 val = spi_rd8(udc, MAX3420_REG_USBCTL); 426 val |= PWRDOWN; 427 if (udc->is_selfpowered) 428 val &= ~HOSCSTEN; 429 else 430 val |= HOSCSTEN; 431 spi_wr8(udc, MAX3420_REG_USBCTL, val); 432 } 433 434 static void __max3420_start(struct max3420_udc *udc) 435 { 436 u8 val; 437 438 /* Need this delay if bus-powered, 439 * but even for self-powered it helps stability 440 */ 441 msleep_interruptible(250); 442 443 /* configure SPI */ 444 spi_wr8(udc, MAX3420_REG_PINCTL, FDUPSPI); 445 446 /* Chip Reset */ 447 spi_wr8(udc, MAX3420_REG_USBCTL, CHIPRES); 448 msleep_interruptible(5); 449 spi_wr8(udc, MAX3420_REG_USBCTL, 0); 450 451 /* Poll for OSC to stabilize */ 452 while (1) { 453 val = spi_rd8(udc, MAX3420_REG_USBIRQ); 454 if (val & OSCOKIRQ) 455 break; 456 cond_resched(); 457 } 458 459 /* Enable PULL-UP only when Vbus detected */ 460 val = spi_rd8(udc, MAX3420_REG_USBCTL); 461 val |= VBGATE | CONNECT; 462 spi_wr8(udc, MAX3420_REG_USBCTL, val); 463 464 val = URESDNIRQ | URESIRQ; 465 if (udc->is_selfpowered) 466 val |= NOVBUSIRQ; 467 spi_wr8(udc, MAX3420_REG_USBIEN, val); 468 469 /* Enable only EP0 interrupts */ 470 val = IN0BAVIRQ | OUT0DAVIRQ | SUDAVIRQ; 471 spi_wr8(udc, MAX3420_REG_EPIEN, val); 472 473 /* Enable IRQ to CPU */ 474 spi_wr8(udc, MAX3420_REG_CPUCTL, IE); 475 } 476 477 static int max3420_start(struct max3420_udc *udc) 478 { 479 unsigned long flags; 480 int todo; 481 482 spin_lock_irqsave(&udc->lock, flags); 483 todo = udc->todo & UDC_START; 484 udc->todo &= ~UDC_START; 485 spin_unlock_irqrestore(&udc->lock, flags); 486 487 if (!todo) 488 return false; 489 490 if (udc->vbus_active && udc->softconnect) 491 __max3420_start(udc); 492 else 493 __max3420_stop(udc); 494 495 return true; 496 } 497 498 static irqreturn_t max3420_vbus_handler(int irq, void *dev_id) 499 { 500 struct max3420_udc *udc = dev_id; 501 unsigned long flags; 502 503 spin_lock_irqsave(&udc->lock, flags); 504 /* its a vbus change interrupt */ 505 udc->vbus_active = !udc->vbus_active; 506 udc->todo |= UDC_START; 507 usb_udc_vbus_handler(&udc->gadget, udc->vbus_active); 508 usb_gadget_set_state(&udc->gadget, udc->vbus_active 509 ? USB_STATE_POWERED : USB_STATE_NOTATTACHED); 510 spin_unlock_irqrestore(&udc->lock, flags); 511 512 if (udc->thread_task) 513 wake_up_process(udc->thread_task); 514 515 return IRQ_HANDLED; 516 } 517 518 static irqreturn_t max3420_irq_handler(int irq, void *dev_id) 519 { 520 struct max3420_udc *udc = dev_id; 521 struct spi_device *spi = udc->spi; 522 unsigned long flags; 523 524 spin_lock_irqsave(&udc->lock, flags); 525 if ((udc->todo & ENABLE_IRQ) == 0) { 526 disable_irq_nosync(spi->irq); 527 udc->todo |= ENABLE_IRQ; 528 } 529 spin_unlock_irqrestore(&udc->lock, flags); 530 531 if (udc->thread_task) 532 wake_up_process(udc->thread_task); 533 534 return IRQ_HANDLED; 535 } 536 537 static void max3420_getstatus(struct max3420_udc *udc) 538 { 539 struct max3420_ep *ep; 540 u16 status = 0; 541 542 switch (udc->setup.bRequestType & USB_RECIP_MASK) { 543 case USB_RECIP_DEVICE: 544 /* Get device status */ 545 status = udc->gadget.is_selfpowered << USB_DEVICE_SELF_POWERED; 546 status |= (udc->remote_wkp << USB_DEVICE_REMOTE_WAKEUP); 547 break; 548 case USB_RECIP_INTERFACE: 549 if (udc->driver->setup(&udc->gadget, &udc->setup) < 0) 550 goto stall; 551 break; 552 case USB_RECIP_ENDPOINT: 553 ep = &udc->ep[udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK]; 554 if (udc->setup.wIndex & USB_DIR_IN) { 555 if (!ep->ep_usb.caps.dir_in) 556 goto stall; 557 } else { 558 if (!ep->ep_usb.caps.dir_out) 559 goto stall; 560 } 561 if (ep->halted) 562 status = 1 << USB_ENDPOINT_HALT; 563 break; 564 default: 565 goto stall; 566 } 567 568 status = cpu_to_le16(status); 569 spi_wr_buf(udc, MAX3420_REG_EP0FIFO, &status, 2); 570 spi_wr8_ack(udc, MAX3420_REG_EP0BC, 2, 1); 571 return; 572 stall: 573 dev_err(udc->dev, "Can't respond to getstatus request\n"); 574 spi_wr8(udc, MAX3420_REG_EPSTALLS, STLEP0IN | STLEP0OUT | STLSTAT); 575 } 576 577 static void max3420_set_clear_feature(struct max3420_udc *udc) 578 { 579 struct max3420_ep *ep; 580 int set = udc->setup.bRequest == USB_REQ_SET_FEATURE; 581 unsigned long flags; 582 int id; 583 584 switch (udc->setup.bRequestType) { 585 case USB_RECIP_DEVICE: 586 if (udc->setup.wValue != USB_DEVICE_REMOTE_WAKEUP) 587 break; 588 589 if (udc->setup.bRequest == USB_REQ_SET_FEATURE) 590 udc->remote_wkp = 1; 591 else 592 udc->remote_wkp = 0; 593 594 return spi_ack_ctrl(udc); 595 596 case USB_RECIP_ENDPOINT: 597 if (udc->setup.wValue != USB_ENDPOINT_HALT) 598 break; 599 600 id = udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK; 601 ep = &udc->ep[id]; 602 603 spin_lock_irqsave(&ep->lock, flags); 604 ep->todo &= ~STALL_EP; 605 if (set) 606 ep->todo |= STALL; 607 else 608 ep->todo |= UNSTALL; 609 spin_unlock_irqrestore(&ep->lock, flags); 610 611 spi_max3420_stall(ep); 612 return; 613 default: 614 break; 615 } 616 617 dev_err(udc->dev, "Can't respond to SET/CLEAR FEATURE\n"); 618 spi_wr8(udc, MAX3420_REG_EPSTALLS, STLEP0IN | STLEP0OUT | STLSTAT); 619 } 620 621 static void max3420_handle_setup(struct max3420_udc *udc) 622 { 623 struct usb_ctrlrequest setup; 624 625 spi_rd_buf(udc, MAX3420_REG_SUDFIFO, (void *)&setup, 8); 626 627 udc->setup = setup; 628 udc->setup.wValue = cpu_to_le16(setup.wValue); 629 udc->setup.wIndex = cpu_to_le16(setup.wIndex); 630 udc->setup.wLength = cpu_to_le16(setup.wLength); 631 632 switch (udc->setup.bRequest) { 633 case USB_REQ_GET_STATUS: 634 /* Data+Status phase form udc */ 635 if ((udc->setup.bRequestType & 636 (USB_DIR_IN | USB_TYPE_MASK)) != 637 (USB_DIR_IN | USB_TYPE_STANDARD)) { 638 break; 639 } 640 return max3420_getstatus(udc); 641 case USB_REQ_SET_ADDRESS: 642 /* Status phase from udc */ 643 if (udc->setup.bRequestType != (USB_DIR_OUT | 644 USB_TYPE_STANDARD | USB_RECIP_DEVICE)) { 645 break; 646 } 647 spi_rd8_ack(udc, MAX3420_REG_FNADDR, 1); 648 dev_dbg(udc->dev, "Assigned Address=%d\n", udc->setup.wValue); 649 return; 650 case USB_REQ_CLEAR_FEATURE: 651 case USB_REQ_SET_FEATURE: 652 /* Requests with no data phase, status phase from udc */ 653 if ((udc->setup.bRequestType & USB_TYPE_MASK) 654 != USB_TYPE_STANDARD) 655 break; 656 return max3420_set_clear_feature(udc); 657 default: 658 break; 659 } 660 661 if (udc->driver->setup(&udc->gadget, &setup) < 0) { 662 /* Stall EP0 */ 663 spi_wr8(udc, MAX3420_REG_EPSTALLS, 664 STLEP0IN | STLEP0OUT | STLSTAT); 665 } 666 } 667 668 static void max3420_req_done(struct max3420_req *req, int status) 669 { 670 struct max3420_ep *ep = req->ep; 671 struct max3420_udc *udc = ep->udc; 672 673 if (req->usb_req.status == -EINPROGRESS) 674 req->usb_req.status = status; 675 else 676 status = req->usb_req.status; 677 678 if (status && status != -ESHUTDOWN) 679 dev_err(udc->dev, "%s done %p, status %d\n", 680 ep->ep_usb.name, req, status); 681 682 if (req->usb_req.complete) 683 req->usb_req.complete(&ep->ep_usb, &req->usb_req); 684 } 685 686 static int max3420_do_data(struct max3420_udc *udc, int ep_id, int in) 687 { 688 struct max3420_ep *ep = &udc->ep[ep_id]; 689 struct max3420_req *req; 690 int done, length, psz; 691 void *buf; 692 693 if (list_empty(&ep->queue)) 694 return false; 695 696 req = list_first_entry(&ep->queue, struct max3420_req, queue); 697 buf = req->usb_req.buf + req->usb_req.actual; 698 699 psz = ep->ep_usb.maxpacket; 700 length = req->usb_req.length - req->usb_req.actual; 701 length = min(length, psz); 702 703 if (length == 0) { 704 done = 1; 705 goto xfer_done; 706 } 707 708 done = 0; 709 if (in) { 710 prefetch(buf); 711 spi_wr_buf(udc, MAX3420_REG_EP0FIFO + ep_id, buf, length); 712 spi_wr8(udc, MAX3420_REG_EP0BC + ep_id, length); 713 if (length < psz) 714 done = 1; 715 } else { 716 psz = spi_rd8(udc, MAX3420_REG_EP0BC + ep_id); 717 length = min(length, psz); 718 prefetchw(buf); 719 spi_rd_buf(udc, MAX3420_REG_EP0FIFO + ep_id, buf, length); 720 if (length < ep->ep_usb.maxpacket) 721 done = 1; 722 } 723 724 req->usb_req.actual += length; 725 726 if (req->usb_req.actual == req->usb_req.length) 727 done = 1; 728 729 xfer_done: 730 if (done) { 731 unsigned long flags; 732 733 spin_lock_irqsave(&ep->lock, flags); 734 list_del_init(&req->queue); 735 spin_unlock_irqrestore(&ep->lock, flags); 736 737 if (ep_id == 0) 738 spi_ack_ctrl(udc); 739 740 max3420_req_done(req, 0); 741 } 742 743 return true; 744 } 745 746 static int max3420_handle_irqs(struct max3420_udc *udc) 747 { 748 u8 epien, epirq, usbirq, usbien, reg[4]; 749 bool ret = false; 750 751 spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 4); 752 epirq = reg[0]; 753 epien = reg[1]; 754 usbirq = reg[2]; 755 usbien = reg[3]; 756 757 usbirq &= usbien; 758 epirq &= epien; 759 760 if (epirq & SUDAVIRQ) { 761 spi_wr8(udc, MAX3420_REG_EPIRQ, SUDAVIRQ); 762 max3420_handle_setup(udc); 763 return true; 764 } 765 766 if (usbirq & VBUSIRQ) { 767 spi_wr8(udc, MAX3420_REG_USBIRQ, VBUSIRQ); 768 dev_dbg(udc->dev, "Cable plugged in\n"); 769 return true; 770 } 771 772 if (usbirq & NOVBUSIRQ) { 773 spi_wr8(udc, MAX3420_REG_USBIRQ, NOVBUSIRQ); 774 dev_dbg(udc->dev, "Cable pulled out\n"); 775 return true; 776 } 777 778 if (usbirq & URESIRQ) { 779 spi_wr8(udc, MAX3420_REG_USBIRQ, URESIRQ); 780 dev_dbg(udc->dev, "USB Reset - Start\n"); 781 return true; 782 } 783 784 if (usbirq & URESDNIRQ) { 785 spi_wr8(udc, MAX3420_REG_USBIRQ, URESDNIRQ); 786 dev_dbg(udc->dev, "USB Reset - END\n"); 787 spi_wr8(udc, MAX3420_REG_USBIEN, URESDNIRQ | URESIRQ); 788 spi_wr8(udc, MAX3420_REG_EPIEN, SUDAVIRQ | IN0BAVIRQ 789 | OUT0DAVIRQ); 790 return true; 791 } 792 793 if (usbirq & SUSPIRQ) { 794 spi_wr8(udc, MAX3420_REG_USBIRQ, SUSPIRQ); 795 dev_dbg(udc->dev, "USB Suspend - Enter\n"); 796 udc->suspended = true; 797 return true; 798 } 799 800 if (usbirq & BUSACTIRQ) { 801 spi_wr8(udc, MAX3420_REG_USBIRQ, BUSACTIRQ); 802 dev_dbg(udc->dev, "USB Suspend - Exit\n"); 803 udc->suspended = false; 804 return true; 805 } 806 807 if (usbirq & RWUDNIRQ) { 808 spi_wr8(udc, MAX3420_REG_USBIRQ, RWUDNIRQ); 809 dev_dbg(udc->dev, "Asked Host to wakeup\n"); 810 return true; 811 } 812 813 if (usbirq & OSCOKIRQ) { 814 spi_wr8(udc, MAX3420_REG_USBIRQ, OSCOKIRQ); 815 dev_dbg(udc->dev, "Osc stabilized, start work\n"); 816 return true; 817 } 818 819 if (epirq & OUT0DAVIRQ && max3420_do_data(udc, 0, 0)) { 820 spi_wr8_ack(udc, MAX3420_REG_EPIRQ, OUT0DAVIRQ, 1); 821 ret = true; 822 } 823 824 if (epirq & IN0BAVIRQ && max3420_do_data(udc, 0, 1)) 825 ret = true; 826 827 if (epirq & OUT1DAVIRQ && max3420_do_data(udc, 1, 0)) { 828 spi_wr8_ack(udc, MAX3420_REG_EPIRQ, OUT1DAVIRQ, 1); 829 ret = true; 830 } 831 832 if (epirq & IN2BAVIRQ && max3420_do_data(udc, 2, 1)) 833 ret = true; 834 835 if (epirq & IN3BAVIRQ && max3420_do_data(udc, 3, 1)) 836 ret = true; 837 838 return ret; 839 } 840 841 static int max3420_thread(void *dev_id) 842 { 843 struct max3420_udc *udc = dev_id; 844 struct spi_device *spi = udc->spi; 845 int i, loop_again = 1; 846 unsigned long flags; 847 848 while (!kthread_should_stop()) { 849 if (!loop_again) { 850 ktime_t kt = ns_to_ktime(1000 * 1000 * 250); /* 250ms */ 851 852 set_current_state(TASK_INTERRUPTIBLE); 853 854 spin_lock_irqsave(&udc->lock, flags); 855 if (udc->todo & ENABLE_IRQ) { 856 enable_irq(spi->irq); 857 udc->todo &= ~ENABLE_IRQ; 858 } 859 spin_unlock_irqrestore(&udc->lock, flags); 860 861 schedule_hrtimeout(&kt, HRTIMER_MODE_REL); 862 } 863 loop_again = 0; 864 865 mutex_lock(&udc->spi_bus_mutex); 866 867 /* If bus-vbus_active and disconnected */ 868 if (!udc->vbus_active || !udc->softconnect) 869 goto loop; 870 871 if (max3420_start(udc)) { 872 loop_again = 1; 873 goto loop; 874 } 875 876 if (max3420_handle_irqs(udc)) { 877 loop_again = 1; 878 goto loop; 879 } 880 881 if (spi_max3420_rwkup(udc)) { 882 loop_again = 1; 883 goto loop; 884 } 885 886 max3420_do_data(udc, 0, 1); /* get done with the EP0 ZLP */ 887 888 for (i = 1; i < MAX3420_MAX_EPS; i++) { 889 struct max3420_ep *ep = &udc->ep[i]; 890 891 if (spi_max3420_enable(ep)) 892 loop_again = 1; 893 if (spi_max3420_stall(ep)) 894 loop_again = 1; 895 } 896 loop: 897 mutex_unlock(&udc->spi_bus_mutex); 898 } 899 900 set_current_state(TASK_RUNNING); 901 dev_info(udc->dev, "SPI thread exiting\n"); 902 return 0; 903 } 904 905 static int max3420_ep_set_halt(struct usb_ep *_ep, int stall) 906 { 907 struct max3420_ep *ep = to_max3420_ep(_ep); 908 struct max3420_udc *udc = ep->udc; 909 unsigned long flags; 910 911 spin_lock_irqsave(&ep->lock, flags); 912 913 ep->todo &= ~STALL_EP; 914 if (stall) 915 ep->todo |= STALL; 916 else 917 ep->todo |= UNSTALL; 918 919 spin_unlock_irqrestore(&ep->lock, flags); 920 921 wake_up_process(udc->thread_task); 922 923 dev_dbg(udc->dev, "%sStall %s\n", stall ? "" : "Un", ep->name); 924 return 0; 925 } 926 927 static int __max3420_ep_enable(struct max3420_ep *ep, 928 const struct usb_endpoint_descriptor *desc) 929 { 930 unsigned int maxp = usb_endpoint_maxp(desc); 931 unsigned long flags; 932 933 spin_lock_irqsave(&ep->lock, flags); 934 ep->ep_usb.desc = desc; 935 ep->ep_usb.maxpacket = maxp; 936 937 ep->todo &= ~ENABLE_EP; 938 ep->todo |= ENABLE; 939 spin_unlock_irqrestore(&ep->lock, flags); 940 941 return 0; 942 } 943 944 static int max3420_ep_enable(struct usb_ep *_ep, 945 const struct usb_endpoint_descriptor *desc) 946 { 947 struct max3420_ep *ep = to_max3420_ep(_ep); 948 struct max3420_udc *udc = ep->udc; 949 950 __max3420_ep_enable(ep, desc); 951 952 wake_up_process(udc->thread_task); 953 954 return 0; 955 } 956 957 static void max3420_nuke(struct max3420_ep *ep, int status) 958 { 959 struct max3420_req *req, *r; 960 unsigned long flags; 961 962 spin_lock_irqsave(&ep->lock, flags); 963 964 list_for_each_entry_safe(req, r, &ep->queue, queue) { 965 list_del_init(&req->queue); 966 967 spin_unlock_irqrestore(&ep->lock, flags); 968 max3420_req_done(req, status); 969 spin_lock_irqsave(&ep->lock, flags); 970 } 971 972 spin_unlock_irqrestore(&ep->lock, flags); 973 } 974 975 static void __max3420_ep_disable(struct max3420_ep *ep) 976 { 977 struct max3420_udc *udc = ep->udc; 978 unsigned long flags; 979 980 spin_lock_irqsave(&ep->lock, flags); 981 982 ep->ep_usb.desc = NULL; 983 984 ep->todo &= ~ENABLE_EP; 985 ep->todo |= DISABLE; 986 987 spin_unlock_irqrestore(&ep->lock, flags); 988 989 dev_dbg(udc->dev, "Disabled %s\n", ep->name); 990 } 991 992 static int max3420_ep_disable(struct usb_ep *_ep) 993 { 994 struct max3420_ep *ep = to_max3420_ep(_ep); 995 struct max3420_udc *udc = ep->udc; 996 997 max3420_nuke(ep, -ESHUTDOWN); 998 999 __max3420_ep_disable(ep); 1000 1001 wake_up_process(udc->thread_task); 1002 1003 return 0; 1004 } 1005 1006 static struct usb_request *max3420_alloc_request(struct usb_ep *_ep, 1007 gfp_t gfp_flags) 1008 { 1009 struct max3420_ep *ep = to_max3420_ep(_ep); 1010 struct max3420_req *req; 1011 1012 req = kzalloc(sizeof(*req), gfp_flags); 1013 if (!req) 1014 return NULL; 1015 1016 req->ep = ep; 1017 1018 return &req->usb_req; 1019 } 1020 1021 static void max3420_free_request(struct usb_ep *_ep, struct usb_request *_req) 1022 { 1023 kfree(to_max3420_req(_req)); 1024 } 1025 1026 static int max3420_ep_queue(struct usb_ep *_ep, struct usb_request *_req, 1027 gfp_t ignored) 1028 { 1029 struct max3420_req *req = to_max3420_req(_req); 1030 struct max3420_ep *ep = to_max3420_ep(_ep); 1031 struct max3420_udc *udc = ep->udc; 1032 unsigned long flags; 1033 1034 _req->status = -EINPROGRESS; 1035 _req->actual = 0; 1036 1037 spin_lock_irqsave(&ep->lock, flags); 1038 list_add_tail(&req->queue, &ep->queue); 1039 spin_unlock_irqrestore(&ep->lock, flags); 1040 1041 wake_up_process(udc->thread_task); 1042 return 0; 1043 } 1044 1045 static int max3420_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req) 1046 { 1047 struct max3420_req *t, *req = to_max3420_req(_req); 1048 struct max3420_ep *ep = to_max3420_ep(_ep); 1049 unsigned long flags; 1050 1051 spin_lock_irqsave(&ep->lock, flags); 1052 1053 /* Pluck the descriptor from queue */ 1054 list_for_each_entry(t, &ep->queue, queue) 1055 if (t == req) { 1056 list_del_init(&req->queue); 1057 break; 1058 } 1059 1060 spin_unlock_irqrestore(&ep->lock, flags); 1061 1062 if (t == req) 1063 max3420_req_done(req, -ECONNRESET); 1064 1065 return 0; 1066 } 1067 1068 static const struct usb_ep_ops max3420_ep_ops = { 1069 .enable = max3420_ep_enable, 1070 .disable = max3420_ep_disable, 1071 .alloc_request = max3420_alloc_request, 1072 .free_request = max3420_free_request, 1073 .queue = max3420_ep_queue, 1074 .dequeue = max3420_ep_dequeue, 1075 .set_halt = max3420_ep_set_halt, 1076 }; 1077 1078 static int max3420_wakeup(struct usb_gadget *gadget) 1079 { 1080 struct max3420_udc *udc = to_udc(gadget); 1081 unsigned long flags; 1082 int ret = -EINVAL; 1083 1084 spin_lock_irqsave(&udc->lock, flags); 1085 1086 /* Only if wakeup allowed by host */ 1087 if (udc->remote_wkp) { 1088 udc->todo |= REMOTE_WAKEUP; 1089 ret = 0; 1090 } 1091 1092 spin_unlock_irqrestore(&udc->lock, flags); 1093 1094 if (udc->thread_task) 1095 wake_up_process(udc->thread_task); 1096 return ret; 1097 } 1098 1099 static int max3420_udc_start(struct usb_gadget *gadget, 1100 struct usb_gadget_driver *driver) 1101 { 1102 struct max3420_udc *udc = to_udc(gadget); 1103 unsigned long flags; 1104 1105 spin_lock_irqsave(&udc->lock, flags); 1106 /* hook up the driver */ 1107 driver->driver.bus = NULL; 1108 udc->driver = driver; 1109 udc->gadget.speed = USB_SPEED_FULL; 1110 1111 udc->gadget.is_selfpowered = udc->is_selfpowered; 1112 udc->remote_wkp = 0; 1113 udc->softconnect = true; 1114 udc->todo |= UDC_START; 1115 spin_unlock_irqrestore(&udc->lock, flags); 1116 1117 if (udc->thread_task) 1118 wake_up_process(udc->thread_task); 1119 1120 return 0; 1121 } 1122 1123 static int max3420_udc_stop(struct usb_gadget *gadget) 1124 { 1125 struct max3420_udc *udc = to_udc(gadget); 1126 unsigned long flags; 1127 1128 spin_lock_irqsave(&udc->lock, flags); 1129 udc->is_selfpowered = udc->gadget.is_selfpowered; 1130 udc->gadget.speed = USB_SPEED_UNKNOWN; 1131 udc->driver = NULL; 1132 udc->softconnect = false; 1133 udc->todo |= UDC_START; 1134 spin_unlock_irqrestore(&udc->lock, flags); 1135 1136 if (udc->thread_task) 1137 wake_up_process(udc->thread_task); 1138 1139 return 0; 1140 } 1141 1142 static const struct usb_gadget_ops max3420_udc_ops = { 1143 .udc_start = max3420_udc_start, 1144 .udc_stop = max3420_udc_stop, 1145 .wakeup = max3420_wakeup, 1146 }; 1147 1148 static void max3420_eps_init(struct max3420_udc *udc) 1149 { 1150 int idx; 1151 1152 INIT_LIST_HEAD(&udc->gadget.ep_list); 1153 1154 for (idx = 0; idx < MAX3420_MAX_EPS; idx++) { 1155 struct max3420_ep *ep = &udc->ep[idx]; 1156 1157 spin_lock_init(&ep->lock); 1158 INIT_LIST_HEAD(&ep->queue); 1159 1160 ep->udc = udc; 1161 ep->id = idx; 1162 ep->halted = 0; 1163 ep->maxpacket = 0; 1164 ep->ep_usb.name = ep->name; 1165 ep->ep_usb.ops = &max3420_ep_ops; 1166 usb_ep_set_maxpacket_limit(&ep->ep_usb, MAX3420_EP_MAX_PACKET); 1167 1168 if (idx == 0) { /* For EP0 */ 1169 ep->ep_usb.desc = &ep0_desc; 1170 ep->ep_usb.maxpacket = usb_endpoint_maxp(&ep0_desc); 1171 ep->ep_usb.caps.type_control = true; 1172 ep->ep_usb.caps.dir_in = true; 1173 ep->ep_usb.caps.dir_out = true; 1174 snprintf(ep->name, MAX3420_EPNAME_SIZE, "ep0"); 1175 continue; 1176 } 1177 1178 if (idx == 1) { /* EP1 is OUT */ 1179 ep->ep_usb.caps.dir_in = false; 1180 ep->ep_usb.caps.dir_out = true; 1181 snprintf(ep->name, MAX3420_EPNAME_SIZE, "ep1-bulk-out"); 1182 } else { /* EP2 & EP3 are IN */ 1183 ep->ep_usb.caps.dir_in = true; 1184 ep->ep_usb.caps.dir_out = false; 1185 snprintf(ep->name, MAX3420_EPNAME_SIZE, 1186 "ep%d-bulk-in", idx); 1187 } 1188 ep->ep_usb.caps.type_iso = false; 1189 ep->ep_usb.caps.type_int = false; 1190 ep->ep_usb.caps.type_bulk = true; 1191 1192 list_add_tail(&ep->ep_usb.ep_list, 1193 &udc->gadget.ep_list); 1194 } 1195 } 1196 1197 static int max3420_probe(struct spi_device *spi) 1198 { 1199 struct max3420_udc *udc; 1200 int err, irq; 1201 u8 reg[8]; 1202 1203 if (spi->master->flags & SPI_MASTER_HALF_DUPLEX) { 1204 dev_err(&spi->dev, "UDC needs full duplex to work\n"); 1205 return -EINVAL; 1206 } 1207 1208 spi->mode = SPI_MODE_3; 1209 spi->bits_per_word = 8; 1210 1211 err = spi_setup(spi); 1212 if (err) { 1213 dev_err(&spi->dev, "Unable to setup SPI bus\n"); 1214 return -EFAULT; 1215 } 1216 1217 udc = devm_kzalloc(&spi->dev, sizeof(*udc), GFP_KERNEL); 1218 if (!udc) 1219 return -ENOMEM; 1220 1221 udc->spi = spi; 1222 1223 udc->remote_wkp = 0; 1224 1225 /* Setup gadget structure */ 1226 udc->gadget.ops = &max3420_udc_ops; 1227 udc->gadget.max_speed = USB_SPEED_FULL; 1228 udc->gadget.speed = USB_SPEED_UNKNOWN; 1229 udc->gadget.ep0 = &udc->ep[0].ep_usb; 1230 udc->gadget.name = driver_name; 1231 1232 spin_lock_init(&udc->lock); 1233 mutex_init(&udc->spi_bus_mutex); 1234 1235 udc->ep0req.ep = &udc->ep[0]; 1236 udc->ep0req.usb_req.buf = udc->ep0buf; 1237 INIT_LIST_HEAD(&udc->ep0req.queue); 1238 1239 /* setup Endpoints */ 1240 max3420_eps_init(udc); 1241 1242 /* configure SPI */ 1243 spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8); 1244 spi_wr8(udc, MAX3420_REG_PINCTL, FDUPSPI); 1245 1246 err = usb_add_gadget_udc(&spi->dev, &udc->gadget); 1247 if (err) 1248 return err; 1249 1250 udc->dev = &udc->gadget.dev; 1251 1252 spi_set_drvdata(spi, udc); 1253 1254 irq = of_irq_get_byname(spi->dev.of_node, "udc"); 1255 err = devm_request_irq(&spi->dev, irq, max3420_irq_handler, 0, 1256 "max3420", udc); 1257 if (err < 0) 1258 return err; 1259 1260 udc->thread_task = kthread_create(max3420_thread, udc, 1261 "max3420-thread"); 1262 if (IS_ERR(udc->thread_task)) 1263 return PTR_ERR(udc->thread_task); 1264 1265 irq = of_irq_get_byname(spi->dev.of_node, "vbus"); 1266 if (irq <= 0) { /* no vbus irq implies self-powered design */ 1267 udc->is_selfpowered = 1; 1268 udc->vbus_active = true; 1269 udc->todo |= UDC_START; 1270 usb_udc_vbus_handler(&udc->gadget, udc->vbus_active); 1271 usb_gadget_set_state(&udc->gadget, USB_STATE_POWERED); 1272 max3420_start(udc); 1273 } else { 1274 udc->is_selfpowered = 0; 1275 /* Detect current vbus status */ 1276 spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8); 1277 if (reg[7] != 0xff) 1278 udc->vbus_active = true; 1279 1280 err = devm_request_irq(&spi->dev, irq, 1281 max3420_vbus_handler, 0, "vbus", udc); 1282 if (err < 0) 1283 return err; 1284 } 1285 1286 return 0; 1287 } 1288 1289 static int max3420_remove(struct spi_device *spi) 1290 { 1291 struct max3420_udc *udc = spi_get_drvdata(spi); 1292 unsigned long flags; 1293 1294 usb_del_gadget_udc(&udc->gadget); 1295 1296 spin_lock_irqsave(&udc->lock, flags); 1297 1298 kthread_stop(udc->thread_task); 1299 1300 spin_unlock_irqrestore(&udc->lock, flags); 1301 1302 return 0; 1303 } 1304 1305 static const struct of_device_id max3420_udc_of_match[] = { 1306 { .compatible = "maxim,max3420-udc"}, 1307 { .compatible = "maxim,max3421-udc"}, 1308 {}, 1309 }; 1310 MODULE_DEVICE_TABLE(of, max3420_udc_of_match); 1311 1312 static struct spi_driver max3420_driver = { 1313 .driver = { 1314 .name = "max3420-udc", 1315 .of_match_table = of_match_ptr(max3420_udc_of_match), 1316 }, 1317 .probe = max3420_probe, 1318 .remove = max3420_remove, 1319 }; 1320 1321 module_spi_driver(max3420_driver); 1322 1323 MODULE_DESCRIPTION(DRIVER_DESC); 1324 MODULE_AUTHOR("Jassi Brar <jaswinder.singh@linaro.org>"); 1325 MODULE_LICENSE("GPL"); 1326