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 = NULL; 1048 struct max3420_req *req = to_max3420_req(_req); 1049 struct max3420_req *iter; 1050 struct max3420_ep *ep = to_max3420_ep(_ep); 1051 unsigned long flags; 1052 1053 spin_lock_irqsave(&ep->lock, flags); 1054 1055 /* Pluck the descriptor from queue */ 1056 list_for_each_entry(iter, &ep->queue, queue) { 1057 if (iter != req) 1058 continue; 1059 list_del_init(&req->queue); 1060 t = iter; 1061 break; 1062 } 1063 1064 spin_unlock_irqrestore(&ep->lock, flags); 1065 1066 if (t) 1067 max3420_req_done(req, -ECONNRESET); 1068 1069 return 0; 1070 } 1071 1072 static const struct usb_ep_ops max3420_ep_ops = { 1073 .enable = max3420_ep_enable, 1074 .disable = max3420_ep_disable, 1075 .alloc_request = max3420_alloc_request, 1076 .free_request = max3420_free_request, 1077 .queue = max3420_ep_queue, 1078 .dequeue = max3420_ep_dequeue, 1079 .set_halt = max3420_ep_set_halt, 1080 }; 1081 1082 static int max3420_wakeup(struct usb_gadget *gadget) 1083 { 1084 struct max3420_udc *udc = to_udc(gadget); 1085 unsigned long flags; 1086 int ret = -EINVAL; 1087 1088 spin_lock_irqsave(&udc->lock, flags); 1089 1090 /* Only if wakeup allowed by host */ 1091 if (udc->remote_wkp) { 1092 udc->todo |= REMOTE_WAKEUP; 1093 ret = 0; 1094 } 1095 1096 spin_unlock_irqrestore(&udc->lock, flags); 1097 1098 if (udc->thread_task) 1099 wake_up_process(udc->thread_task); 1100 return ret; 1101 } 1102 1103 static int max3420_udc_start(struct usb_gadget *gadget, 1104 struct usb_gadget_driver *driver) 1105 { 1106 struct max3420_udc *udc = to_udc(gadget); 1107 unsigned long flags; 1108 1109 spin_lock_irqsave(&udc->lock, flags); 1110 /* hook up the driver */ 1111 driver->driver.bus = NULL; 1112 udc->driver = driver; 1113 udc->gadget.speed = USB_SPEED_FULL; 1114 1115 udc->gadget.is_selfpowered = udc->is_selfpowered; 1116 udc->remote_wkp = 0; 1117 udc->softconnect = true; 1118 udc->todo |= UDC_START; 1119 spin_unlock_irqrestore(&udc->lock, flags); 1120 1121 if (udc->thread_task) 1122 wake_up_process(udc->thread_task); 1123 1124 return 0; 1125 } 1126 1127 static int max3420_udc_stop(struct usb_gadget *gadget) 1128 { 1129 struct max3420_udc *udc = to_udc(gadget); 1130 unsigned long flags; 1131 1132 spin_lock_irqsave(&udc->lock, flags); 1133 udc->is_selfpowered = udc->gadget.is_selfpowered; 1134 udc->gadget.speed = USB_SPEED_UNKNOWN; 1135 udc->driver = NULL; 1136 udc->softconnect = false; 1137 udc->todo |= UDC_START; 1138 spin_unlock_irqrestore(&udc->lock, flags); 1139 1140 if (udc->thread_task) 1141 wake_up_process(udc->thread_task); 1142 1143 return 0; 1144 } 1145 1146 static const struct usb_gadget_ops max3420_udc_ops = { 1147 .udc_start = max3420_udc_start, 1148 .udc_stop = max3420_udc_stop, 1149 .wakeup = max3420_wakeup, 1150 }; 1151 1152 static void max3420_eps_init(struct max3420_udc *udc) 1153 { 1154 int idx; 1155 1156 INIT_LIST_HEAD(&udc->gadget.ep_list); 1157 1158 for (idx = 0; idx < MAX3420_MAX_EPS; idx++) { 1159 struct max3420_ep *ep = &udc->ep[idx]; 1160 1161 spin_lock_init(&ep->lock); 1162 INIT_LIST_HEAD(&ep->queue); 1163 1164 ep->udc = udc; 1165 ep->id = idx; 1166 ep->halted = 0; 1167 ep->maxpacket = 0; 1168 ep->ep_usb.name = ep->name; 1169 ep->ep_usb.ops = &max3420_ep_ops; 1170 usb_ep_set_maxpacket_limit(&ep->ep_usb, MAX3420_EP_MAX_PACKET); 1171 1172 if (idx == 0) { /* For EP0 */ 1173 ep->ep_usb.desc = &ep0_desc; 1174 ep->ep_usb.maxpacket = usb_endpoint_maxp(&ep0_desc); 1175 ep->ep_usb.caps.type_control = true; 1176 ep->ep_usb.caps.dir_in = true; 1177 ep->ep_usb.caps.dir_out = true; 1178 snprintf(ep->name, MAX3420_EPNAME_SIZE, "ep0"); 1179 continue; 1180 } 1181 1182 if (idx == 1) { /* EP1 is OUT */ 1183 ep->ep_usb.caps.dir_in = false; 1184 ep->ep_usb.caps.dir_out = true; 1185 snprintf(ep->name, MAX3420_EPNAME_SIZE, "ep1-bulk-out"); 1186 } else { /* EP2 & EP3 are IN */ 1187 ep->ep_usb.caps.dir_in = true; 1188 ep->ep_usb.caps.dir_out = false; 1189 snprintf(ep->name, MAX3420_EPNAME_SIZE, 1190 "ep%d-bulk-in", idx); 1191 } 1192 ep->ep_usb.caps.type_iso = false; 1193 ep->ep_usb.caps.type_int = false; 1194 ep->ep_usb.caps.type_bulk = true; 1195 1196 list_add_tail(&ep->ep_usb.ep_list, 1197 &udc->gadget.ep_list); 1198 } 1199 } 1200 1201 static int max3420_probe(struct spi_device *spi) 1202 { 1203 struct max3420_udc *udc; 1204 int err, irq; 1205 u8 reg[8]; 1206 1207 if (spi->master->flags & SPI_MASTER_HALF_DUPLEX) { 1208 dev_err(&spi->dev, "UDC needs full duplex to work\n"); 1209 return -EINVAL; 1210 } 1211 1212 spi->mode = SPI_MODE_3; 1213 spi->bits_per_word = 8; 1214 1215 err = spi_setup(spi); 1216 if (err) { 1217 dev_err(&spi->dev, "Unable to setup SPI bus\n"); 1218 return -EFAULT; 1219 } 1220 1221 udc = devm_kzalloc(&spi->dev, sizeof(*udc), GFP_KERNEL); 1222 if (!udc) 1223 return -ENOMEM; 1224 1225 udc->spi = spi; 1226 1227 udc->remote_wkp = 0; 1228 1229 /* Setup gadget structure */ 1230 udc->gadget.ops = &max3420_udc_ops; 1231 udc->gadget.max_speed = USB_SPEED_FULL; 1232 udc->gadget.speed = USB_SPEED_UNKNOWN; 1233 udc->gadget.ep0 = &udc->ep[0].ep_usb; 1234 udc->gadget.name = driver_name; 1235 1236 spin_lock_init(&udc->lock); 1237 mutex_init(&udc->spi_bus_mutex); 1238 1239 udc->ep0req.ep = &udc->ep[0]; 1240 udc->ep0req.usb_req.buf = udc->ep0buf; 1241 INIT_LIST_HEAD(&udc->ep0req.queue); 1242 1243 /* setup Endpoints */ 1244 max3420_eps_init(udc); 1245 1246 /* configure SPI */ 1247 spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8); 1248 spi_wr8(udc, MAX3420_REG_PINCTL, FDUPSPI); 1249 1250 err = usb_add_gadget_udc(&spi->dev, &udc->gadget); 1251 if (err) 1252 return err; 1253 1254 udc->dev = &udc->gadget.dev; 1255 1256 spi_set_drvdata(spi, udc); 1257 1258 irq = of_irq_get_byname(spi->dev.of_node, "udc"); 1259 err = devm_request_irq(&spi->dev, irq, max3420_irq_handler, 0, 1260 "max3420", udc); 1261 if (err < 0) 1262 goto del_gadget; 1263 1264 udc->thread_task = kthread_create(max3420_thread, udc, 1265 "max3420-thread"); 1266 if (IS_ERR(udc->thread_task)) { 1267 err = PTR_ERR(udc->thread_task); 1268 goto del_gadget; 1269 } 1270 1271 irq = of_irq_get_byname(spi->dev.of_node, "vbus"); 1272 if (irq <= 0) { /* no vbus irq implies self-powered design */ 1273 udc->is_selfpowered = 1; 1274 udc->vbus_active = true; 1275 udc->todo |= UDC_START; 1276 usb_udc_vbus_handler(&udc->gadget, udc->vbus_active); 1277 usb_gadget_set_state(&udc->gadget, USB_STATE_POWERED); 1278 max3420_start(udc); 1279 } else { 1280 udc->is_selfpowered = 0; 1281 /* Detect current vbus status */ 1282 spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8); 1283 if (reg[7] != 0xff) 1284 udc->vbus_active = true; 1285 1286 err = devm_request_irq(&spi->dev, irq, 1287 max3420_vbus_handler, 0, "vbus", udc); 1288 if (err < 0) 1289 goto del_gadget; 1290 } 1291 1292 return 0; 1293 1294 del_gadget: 1295 usb_del_gadget_udc(&udc->gadget); 1296 return err; 1297 } 1298 1299 static void max3420_remove(struct spi_device *spi) 1300 { 1301 struct max3420_udc *udc = spi_get_drvdata(spi); 1302 unsigned long flags; 1303 1304 usb_del_gadget_udc(&udc->gadget); 1305 1306 spin_lock_irqsave(&udc->lock, flags); 1307 1308 kthread_stop(udc->thread_task); 1309 1310 spin_unlock_irqrestore(&udc->lock, flags); 1311 } 1312 1313 static const struct of_device_id max3420_udc_of_match[] = { 1314 { .compatible = "maxim,max3420-udc"}, 1315 { .compatible = "maxim,max3421-udc"}, 1316 {}, 1317 }; 1318 MODULE_DEVICE_TABLE(of, max3420_udc_of_match); 1319 1320 static struct spi_driver max3420_driver = { 1321 .driver = { 1322 .name = "max3420-udc", 1323 .of_match_table = of_match_ptr(max3420_udc_of_match), 1324 }, 1325 .probe = max3420_probe, 1326 .remove = max3420_remove, 1327 }; 1328 1329 module_spi_driver(max3420_driver); 1330 1331 MODULE_DESCRIPTION(DRIVER_DESC); 1332 MODULE_AUTHOR("Jassi Brar <jaswinder.singh@linaro.org>"); 1333 MODULE_LICENSE("GPL"); 1334