1 /* 2 * Faraday USB 2.0 OTG Controller 3 * 4 * (C) Copyright 2010 Faraday Technology 5 * Dante Su <dantesu@faraday-tech.com> 6 * 7 * SPDX-License-Identifier: GPL-2.0+ 8 */ 9 10 #include <common.h> 11 #include <command.h> 12 #include <config.h> 13 #include <net.h> 14 #include <malloc.h> 15 #include <asm/io.h> 16 #include <asm/errno.h> 17 #include <linux/types.h> 18 #include <linux/usb/ch9.h> 19 #include <linux/usb/gadget.h> 20 21 #include <usb/fotg210.h> 22 23 #define CFG_NUM_ENDPOINTS 4 24 #define CFG_EP0_MAX_PACKET_SIZE 64 25 #define CFG_EPX_MAX_PACKET_SIZE 512 26 27 #define CFG_CMD_TIMEOUT (CONFIG_SYS_HZ >> 2) /* 250 ms */ 28 29 struct fotg210_chip; 30 31 struct fotg210_ep { 32 struct usb_ep ep; 33 34 uint maxpacket; 35 uint id; 36 uint stopped; 37 38 struct list_head queue; 39 struct fotg210_chip *chip; 40 const struct usb_endpoint_descriptor *desc; 41 }; 42 43 struct fotg210_request { 44 struct usb_request req; 45 struct list_head queue; 46 struct fotg210_ep *ep; 47 }; 48 49 struct fotg210_chip { 50 struct usb_gadget gadget; 51 struct usb_gadget_driver *driver; 52 struct fotg210_regs *regs; 53 uint8_t irq; 54 uint16_t addr; 55 int pullup; 56 enum usb_device_state state; 57 struct fotg210_ep ep[1 + CFG_NUM_ENDPOINTS]; 58 }; 59 60 static struct usb_endpoint_descriptor ep0_desc = { 61 .bLength = sizeof(struct usb_endpoint_descriptor), 62 .bDescriptorType = USB_DT_ENDPOINT, 63 .bEndpointAddress = USB_DIR_IN, 64 .bmAttributes = USB_ENDPOINT_XFER_CONTROL, 65 }; 66 67 static inline int fifo_to_ep(struct fotg210_chip *chip, int id, int in) 68 { 69 return (id < 0) ? 0 : ((id & 0x03) + 1); 70 } 71 72 static inline int ep_to_fifo(struct fotg210_chip *chip, int id) 73 { 74 return (id <= 0) ? -1 : ((id - 1) & 0x03); 75 } 76 77 static inline int ep_reset(struct fotg210_chip *chip, uint8_t ep_addr) 78 { 79 int ep = ep_addr & USB_ENDPOINT_NUMBER_MASK; 80 struct fotg210_regs *regs = chip->regs; 81 82 if (ep_addr & USB_DIR_IN) { 83 /* reset endpoint */ 84 setbits_le32(®s->iep[ep - 1], IEP_RESET); 85 mdelay(1); 86 clrbits_le32(®s->iep[ep - 1], IEP_RESET); 87 /* clear endpoint stall */ 88 clrbits_le32(®s->iep[ep - 1], IEP_STALL); 89 } else { 90 /* reset endpoint */ 91 setbits_le32(®s->oep[ep - 1], OEP_RESET); 92 mdelay(1); 93 clrbits_le32(®s->oep[ep - 1], OEP_RESET); 94 /* clear endpoint stall */ 95 clrbits_le32(®s->oep[ep - 1], OEP_STALL); 96 } 97 98 return 0; 99 } 100 101 static int fotg210_reset(struct fotg210_chip *chip) 102 { 103 struct fotg210_regs *regs = chip->regs; 104 uint32_t i; 105 106 chip->state = USB_STATE_POWERED; 107 108 /* chip enable */ 109 writel(DEVCTRL_EN, ®s->dev_ctrl); 110 111 /* device address reset */ 112 chip->addr = 0; 113 writel(0, ®s->dev_addr); 114 115 /* set idle counter to 7ms */ 116 writel(7, ®s->idle); 117 118 /* disable all interrupts */ 119 writel(IMR_MASK, ®s->imr); 120 writel(GIMR_MASK, ®s->gimr); 121 writel(GIMR0_MASK, ®s->gimr0); 122 writel(GIMR1_MASK, ®s->gimr1); 123 writel(GIMR2_MASK, ®s->gimr2); 124 125 /* clear interrupts */ 126 writel(ISR_MASK, ®s->isr); 127 writel(0, ®s->gisr); 128 writel(0, ®s->gisr0); 129 writel(0, ®s->gisr1); 130 writel(0, ®s->gisr2); 131 132 /* chip reset */ 133 setbits_le32(®s->dev_ctrl, DEVCTRL_RESET); 134 mdelay(10); 135 if (readl(®s->dev_ctrl) & DEVCTRL_RESET) { 136 printf("fotg210: chip reset failed\n"); 137 return -1; 138 } 139 140 /* CX FIFO reset */ 141 setbits_le32(®s->cxfifo, CXFIFO_CXFIFOCLR); 142 mdelay(10); 143 if (readl(®s->cxfifo) & CXFIFO_CXFIFOCLR) { 144 printf("fotg210: ep0 fifo reset failed\n"); 145 return -1; 146 } 147 148 /* create static ep-fifo map (EP1 <-> FIFO0, EP2 <-> FIFO1 ...) */ 149 writel(EPMAP14_DEFAULT, ®s->epmap14); 150 writel(EPMAP58_DEFAULT, ®s->epmap58); 151 writel(FIFOMAP_DEFAULT, ®s->fifomap); 152 writel(0, ®s->fifocfg); 153 for (i = 0; i < 8; ++i) { 154 writel(CFG_EPX_MAX_PACKET_SIZE, ®s->iep[i]); 155 writel(CFG_EPX_MAX_PACKET_SIZE, ®s->oep[i]); 156 } 157 158 /* FIFO reset */ 159 for (i = 0; i < 4; ++i) { 160 writel(FIFOCSR_RESET, ®s->fifocsr[i]); 161 mdelay(10); 162 if (readl(®s->fifocsr[i]) & FIFOCSR_RESET) { 163 printf("fotg210: fifo%d reset failed\n", i); 164 return -1; 165 } 166 } 167 168 /* enable only device interrupt and triggered at level-high */ 169 writel(IMR_IRQLH | IMR_HOST | IMR_OTG, ®s->imr); 170 writel(ISR_MASK, ®s->isr); 171 /* disable EP0 IN/OUT interrupt */ 172 writel(GIMR0_CXOUT | GIMR0_CXIN, ®s->gimr0); 173 /* disable EPX IN+SPK+OUT interrupts */ 174 writel(GIMR1_MASK, ®s->gimr1); 175 /* disable wakeup+idle+dma+zlp interrupts */ 176 writel(GIMR2_WAKEUP | GIMR2_IDLE | GIMR2_DMAERR | GIMR2_DMAFIN 177 | GIMR2_ZLPRX | GIMR2_ZLPTX, ®s->gimr2); 178 /* enable all group interrupt */ 179 writel(0, ®s->gimr); 180 181 /* suspend delay = 3 ms */ 182 writel(3, ®s->idle); 183 184 /* turn-on device interrupts */ 185 setbits_le32(®s->dev_ctrl, DEVCTRL_GIRQ_EN); 186 187 return 0; 188 } 189 190 static inline int fotg210_cxwait(struct fotg210_chip *chip, uint32_t mask) 191 { 192 struct fotg210_regs *regs = chip->regs; 193 int ret = -1; 194 ulong ts; 195 196 for (ts = get_timer(0); get_timer(ts) < CFG_CMD_TIMEOUT; ) { 197 if ((readl(®s->cxfifo) & mask) != mask) 198 continue; 199 ret = 0; 200 break; 201 } 202 203 if (ret) 204 printf("fotg210: cx/ep0 timeout\n"); 205 206 return ret; 207 } 208 209 static int fotg210_dma(struct fotg210_ep *ep, struct fotg210_request *req) 210 { 211 struct fotg210_chip *chip = ep->chip; 212 struct fotg210_regs *regs = chip->regs; 213 uint32_t tmp, ts; 214 uint8_t *buf = req->req.buf + req->req.actual; 215 uint32_t len = req->req.length - req->req.actual; 216 int fifo = ep_to_fifo(chip, ep->id); 217 int ret = -EBUSY; 218 219 /* 1. init dma buffer */ 220 if (len > ep->maxpacket) 221 len = ep->maxpacket; 222 223 /* 2. wait for dma ready (hardware) */ 224 for (ts = get_timer(0); get_timer(ts) < CFG_CMD_TIMEOUT; ) { 225 if (!(readl(®s->dma_ctrl) & DMACTRL_START)) { 226 ret = 0; 227 break; 228 } 229 } 230 if (ret) { 231 printf("fotg210: dma busy\n"); 232 req->req.status = ret; 233 return ret; 234 } 235 236 /* 3. DMA target setup */ 237 if (ep->desc->bEndpointAddress & USB_DIR_IN) 238 flush_dcache_range((ulong)buf, (ulong)buf + len); 239 else 240 invalidate_dcache_range((ulong)buf, (ulong)buf + len); 241 242 writel(virt_to_phys(buf), ®s->dma_addr); 243 244 if (ep->desc->bEndpointAddress & USB_DIR_IN) { 245 if (ep->id == 0) { 246 /* Wait until cx/ep0 fifo empty */ 247 fotg210_cxwait(chip, CXFIFO_CXFIFOE); 248 writel(DMAFIFO_CX, ®s->dma_fifo); 249 } else { 250 /* Wait until epx fifo empty */ 251 fotg210_cxwait(chip, CXFIFO_FIFOE(fifo)); 252 writel(DMAFIFO_FIFO(fifo), ®s->dma_fifo); 253 } 254 writel(DMACTRL_LEN(len) | DMACTRL_MEM2FIFO, ®s->dma_ctrl); 255 } else { 256 uint32_t blen; 257 258 if (ep->id == 0) { 259 writel(DMAFIFO_CX, ®s->dma_fifo); 260 do { 261 blen = CXFIFO_BYTES(readl(®s->cxfifo)); 262 } while (blen < len); 263 } else { 264 writel(DMAFIFO_FIFO(fifo), ®s->dma_fifo); 265 blen = FIFOCSR_BYTES(readl(®s->fifocsr[fifo])); 266 } 267 len = (len < blen) ? len : blen; 268 writel(DMACTRL_LEN(len) | DMACTRL_FIFO2MEM, ®s->dma_ctrl); 269 } 270 271 /* 4. DMA start */ 272 setbits_le32(®s->dma_ctrl, DMACTRL_START); 273 274 /* 5. DMA wait */ 275 ret = -EBUSY; 276 for (ts = get_timer(0); get_timer(ts) < CFG_CMD_TIMEOUT; ) { 277 tmp = readl(®s->gisr2); 278 /* DMA complete */ 279 if (tmp & GISR2_DMAFIN) { 280 ret = 0; 281 break; 282 } 283 /* DMA error */ 284 if (tmp & GISR2_DMAERR) { 285 printf("fotg210: dma error\n"); 286 break; 287 } 288 /* resume, suspend, reset */ 289 if (tmp & (GISR2_RESUME | GISR2_SUSPEND | GISR2_RESET)) { 290 printf("fotg210: dma reset by host\n"); 291 break; 292 } 293 } 294 295 /* 7. DMA target reset */ 296 if (ret) 297 writel(DMACTRL_ABORT | DMACTRL_CLRFF, ®s->dma_ctrl); 298 299 writel(0, ®s->gisr2); 300 writel(0, ®s->dma_fifo); 301 302 req->req.status = ret; 303 if (!ret) 304 req->req.actual += len; 305 else 306 printf("fotg210: ep%d dma error(code=%d)\n", ep->id, ret); 307 308 return len; 309 } 310 311 /* 312 * result of setup packet 313 */ 314 #define CX_IDLE 0 315 #define CX_FINISH 1 316 #define CX_STALL 2 317 318 static void fotg210_setup(struct fotg210_chip *chip) 319 { 320 int id, ret = CX_IDLE; 321 uint32_t tmp[2]; 322 struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)tmp; 323 struct fotg210_regs *regs = chip->regs; 324 325 /* 326 * If this is the first Cx 8 byte command, 327 * we can now query USB mode (high/full speed; USB 2.0/USB 1.0) 328 */ 329 if (chip->state == USB_STATE_POWERED) { 330 chip->state = USB_STATE_DEFAULT; 331 if (readl(®s->otgcsr) & OTGCSR_DEV_B) { 332 /* Mini-B */ 333 if (readl(®s->dev_ctrl) & DEVCTRL_HS) { 334 puts("fotg210: HS\n"); 335 chip->gadget.speed = USB_SPEED_HIGH; 336 /* SOF mask timer = 1100 ticks */ 337 writel(SOFMTR_TMR(1100), ®s->sof_mtr); 338 } else { 339 puts("fotg210: FS\n"); 340 chip->gadget.speed = USB_SPEED_FULL; 341 /* SOF mask timer = 10000 ticks */ 342 writel(SOFMTR_TMR(10000), ®s->sof_mtr); 343 } 344 } else { 345 printf("fotg210: mini-A?\n"); 346 } 347 } 348 349 /* switch data port to ep0 */ 350 writel(DMAFIFO_CX, ®s->dma_fifo); 351 /* fetch 8 bytes setup packet */ 352 tmp[0] = readl(®s->ep0_data); 353 tmp[1] = readl(®s->ep0_data); 354 /* release data port */ 355 writel(0, ®s->dma_fifo); 356 357 if (req->bRequestType & USB_DIR_IN) 358 ep0_desc.bEndpointAddress = USB_DIR_IN; 359 else 360 ep0_desc.bEndpointAddress = USB_DIR_OUT; 361 362 ret = CX_IDLE; 363 364 if ((req->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) { 365 switch (req->bRequest) { 366 case USB_REQ_SET_CONFIGURATION: 367 debug("fotg210: set_cfg(%d)\n", req->wValue & 0x00FF); 368 if (!(req->wValue & 0x00FF)) { 369 chip->state = USB_STATE_ADDRESS; 370 writel(chip->addr, ®s->dev_addr); 371 } else { 372 chip->state = USB_STATE_CONFIGURED; 373 writel(chip->addr | DEVADDR_CONF, 374 ®s->dev_addr); 375 } 376 ret = CX_IDLE; 377 break; 378 379 case USB_REQ_SET_ADDRESS: 380 debug("fotg210: set_addr(0x%04X)\n", req->wValue); 381 chip->state = USB_STATE_ADDRESS; 382 chip->addr = req->wValue & DEVADDR_ADDR_MASK; 383 ret = CX_FINISH; 384 writel(chip->addr, ®s->dev_addr); 385 break; 386 387 case USB_REQ_CLEAR_FEATURE: 388 debug("fotg210: clr_feature(%d, %d)\n", 389 req->bRequestType & 0x03, req->wValue); 390 switch (req->wValue) { 391 case 0: /* [Endpoint] halt */ 392 ep_reset(chip, req->wIndex); 393 ret = CX_FINISH; 394 break; 395 case 1: /* [Device] remote wake-up */ 396 case 2: /* [Device] test mode */ 397 default: 398 ret = CX_STALL; 399 break; 400 } 401 break; 402 403 case USB_REQ_SET_FEATURE: 404 debug("fotg210: set_feature(%d, %d)\n", 405 req->wValue, req->wIndex & 0xf); 406 switch (req->wValue) { 407 case 0: /* Endpoint Halt */ 408 id = req->wIndex & 0xf; 409 setbits_le32(®s->iep[id - 1], IEP_STALL); 410 setbits_le32(®s->oep[id - 1], OEP_STALL); 411 ret = CX_FINISH; 412 break; 413 case 1: /* Remote Wakeup */ 414 case 2: /* Test Mode */ 415 default: 416 ret = CX_STALL; 417 break; 418 } 419 break; 420 421 case USB_REQ_GET_STATUS: 422 debug("fotg210: get_status\n"); 423 ret = CX_STALL; 424 break; 425 426 case USB_REQ_SET_DESCRIPTOR: 427 debug("fotg210: set_descriptor\n"); 428 ret = CX_STALL; 429 break; 430 431 case USB_REQ_SYNCH_FRAME: 432 debug("fotg210: sync frame\n"); 433 ret = CX_STALL; 434 break; 435 } 436 } /* if ((req->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) */ 437 438 if (ret == CX_IDLE && chip->driver->setup) { 439 if (chip->driver->setup(&chip->gadget, req) < 0) 440 ret = CX_STALL; 441 else 442 ret = CX_FINISH; 443 } 444 445 switch (ret) { 446 case CX_FINISH: 447 setbits_le32(®s->cxfifo, CXFIFO_CXFIN); 448 break; 449 450 case CX_STALL: 451 setbits_le32(®s->cxfifo, CXFIFO_CXSTALL | CXFIFO_CXFIN); 452 printf("fotg210: cx_stall!\n"); 453 break; 454 455 case CX_IDLE: 456 debug("fotg210: cx_idle?\n"); 457 default: 458 break; 459 } 460 } 461 462 /* 463 * fifo - FIFO id 464 * zlp - zero length packet 465 */ 466 static void fotg210_recv(struct fotg210_chip *chip, int ep_id) 467 { 468 struct fotg210_regs *regs = chip->regs; 469 struct fotg210_ep *ep = chip->ep + ep_id; 470 struct fotg210_request *req; 471 int len; 472 473 if (ep->stopped || (ep->desc->bEndpointAddress & USB_DIR_IN)) { 474 printf("fotg210: ep%d recv, invalid!\n", ep->id); 475 return; 476 } 477 478 if (list_empty(&ep->queue)) { 479 printf("fotg210: ep%d recv, drop!\n", ep->id); 480 return; 481 } 482 483 req = list_first_entry(&ep->queue, struct fotg210_request, queue); 484 len = fotg210_dma(ep, req); 485 if (len < ep->ep.maxpacket || req->req.length <= req->req.actual) { 486 list_del_init(&req->queue); 487 if (req->req.complete) 488 req->req.complete(&ep->ep, &req->req); 489 } 490 491 if (ep->id > 0 && list_empty(&ep->queue)) { 492 setbits_le32(®s->gimr1, 493 GIMR1_FIFO_RX(ep_to_fifo(chip, ep->id))); 494 } 495 } 496 497 /* 498 * USB Gadget Layer 499 */ 500 static int fotg210_ep_enable( 501 struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) 502 { 503 struct fotg210_ep *ep = container_of(_ep, struct fotg210_ep, ep); 504 struct fotg210_chip *chip = ep->chip; 505 struct fotg210_regs *regs = chip->regs; 506 int id = ep_to_fifo(chip, ep->id); 507 int in = (desc->bEndpointAddress & USB_DIR_IN) ? 1 : 0; 508 509 if (!_ep || !desc 510 || desc->bDescriptorType != USB_DT_ENDPOINT 511 || le16_to_cpu(desc->wMaxPacketSize) == 0) { 512 printf("fotg210: bad ep or descriptor\n"); 513 return -EINVAL; 514 } 515 516 ep->desc = desc; 517 ep->stopped = 0; 518 519 if (in) 520 setbits_le32(®s->fifomap, FIFOMAP(id, FIFOMAP_IN)); 521 522 switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { 523 case USB_ENDPOINT_XFER_CONTROL: 524 return -EINVAL; 525 526 case USB_ENDPOINT_XFER_ISOC: 527 setbits_le32(®s->fifocfg, 528 FIFOCFG(id, FIFOCFG_EN | FIFOCFG_ISOC)); 529 break; 530 531 case USB_ENDPOINT_XFER_BULK: 532 setbits_le32(®s->fifocfg, 533 FIFOCFG(id, FIFOCFG_EN | FIFOCFG_BULK)); 534 break; 535 536 case USB_ENDPOINT_XFER_INT: 537 setbits_le32(®s->fifocfg, 538 FIFOCFG(id, FIFOCFG_EN | FIFOCFG_INTR)); 539 break; 540 } 541 542 return 0; 543 } 544 545 static int fotg210_ep_disable(struct usb_ep *_ep) 546 { 547 struct fotg210_ep *ep = container_of(_ep, struct fotg210_ep, ep); 548 struct fotg210_chip *chip = ep->chip; 549 struct fotg210_regs *regs = chip->regs; 550 int id = ep_to_fifo(chip, ep->id); 551 552 ep->desc = NULL; 553 ep->stopped = 1; 554 555 clrbits_le32(®s->fifocfg, FIFOCFG(id, FIFOCFG_CFG_MASK)); 556 clrbits_le32(®s->fifomap, FIFOMAP(id, FIFOMAP_DIR_MASK)); 557 558 return 0; 559 } 560 561 static struct usb_request *fotg210_ep_alloc_request( 562 struct usb_ep *_ep, gfp_t gfp_flags) 563 { 564 struct fotg210_request *req = malloc(sizeof(*req)); 565 566 if (req) { 567 memset(req, 0, sizeof(*req)); 568 INIT_LIST_HEAD(&req->queue); 569 } 570 return &req->req; 571 } 572 573 static void fotg210_ep_free_request( 574 struct usb_ep *_ep, struct usb_request *_req) 575 { 576 struct fotg210_request *req; 577 578 req = container_of(_req, struct fotg210_request, req); 579 free(req); 580 } 581 582 static int fotg210_ep_queue( 583 struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags) 584 { 585 struct fotg210_ep *ep = container_of(_ep, struct fotg210_ep, ep); 586 struct fotg210_chip *chip = ep->chip; 587 struct fotg210_regs *regs = chip->regs; 588 struct fotg210_request *req; 589 590 req = container_of(_req, struct fotg210_request, req); 591 if (!_req || !_req->complete || !_req->buf 592 || !list_empty(&req->queue)) { 593 printf("fotg210: invalid request to ep%d\n", ep->id); 594 return -EINVAL; 595 } 596 597 if (!chip || chip->state == USB_STATE_SUSPENDED) { 598 printf("fotg210: request while chip suspended\n"); 599 return -EINVAL; 600 } 601 602 req->req.actual = 0; 603 req->req.status = -EINPROGRESS; 604 605 if (req->req.length == 0) { 606 req->req.status = 0; 607 if (req->req.complete) 608 req->req.complete(&ep->ep, &req->req); 609 return 0; 610 } 611 612 if (ep->id == 0) { 613 do { 614 int len = fotg210_dma(ep, req); 615 if (len < ep->ep.maxpacket) 616 break; 617 if (ep->desc->bEndpointAddress & USB_DIR_IN) 618 udelay(100); 619 } while (req->req.length > req->req.actual); 620 } else { 621 if (ep->desc->bEndpointAddress & USB_DIR_IN) { 622 do { 623 int len = fotg210_dma(ep, req); 624 if (len < ep->ep.maxpacket) 625 break; 626 } while (req->req.length > req->req.actual); 627 } else { 628 list_add_tail(&req->queue, &ep->queue); 629 clrbits_le32(®s->gimr1, 630 GIMR1_FIFO_RX(ep_to_fifo(chip, ep->id))); 631 } 632 } 633 634 if (ep->id == 0 || (ep->desc->bEndpointAddress & USB_DIR_IN)) { 635 if (req->req.complete) 636 req->req.complete(&ep->ep, &req->req); 637 } 638 639 return 0; 640 } 641 642 static int fotg210_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req) 643 { 644 struct fotg210_ep *ep = container_of(_ep, struct fotg210_ep, ep); 645 struct fotg210_request *req; 646 647 /* make sure it's actually queued on this endpoint */ 648 list_for_each_entry(req, &ep->queue, queue) { 649 if (&req->req == _req) 650 break; 651 } 652 if (&req->req != _req) 653 return -EINVAL; 654 655 /* remove the request */ 656 list_del_init(&req->queue); 657 658 /* update status & invoke complete callback */ 659 if (req->req.status == -EINPROGRESS) { 660 req->req.status = -ECONNRESET; 661 if (req->req.complete) 662 req->req.complete(_ep, &req->req); 663 } 664 665 return 0; 666 } 667 668 static int fotg210_ep_halt(struct usb_ep *_ep, int halt) 669 { 670 struct fotg210_ep *ep = container_of(_ep, struct fotg210_ep, ep); 671 struct fotg210_chip *chip = ep->chip; 672 struct fotg210_regs *regs = chip->regs; 673 int ret = -1; 674 675 debug("fotg210: ep%d halt=%d\n", ep->id, halt); 676 677 /* Endpoint STALL */ 678 if (ep->id > 0 && ep->id <= CFG_NUM_ENDPOINTS) { 679 if (halt) { 680 /* wait until all ep fifo empty */ 681 fotg210_cxwait(chip, 0xf00); 682 /* stall */ 683 if (ep->desc->bEndpointAddress & USB_DIR_IN) { 684 setbits_le32(®s->iep[ep->id - 1], 685 IEP_STALL); 686 } else { 687 setbits_le32(®s->oep[ep->id - 1], 688 OEP_STALL); 689 } 690 } else { 691 if (ep->desc->bEndpointAddress & USB_DIR_IN) { 692 clrbits_le32(®s->iep[ep->id - 1], 693 IEP_STALL); 694 } else { 695 clrbits_le32(®s->oep[ep->id - 1], 696 OEP_STALL); 697 } 698 } 699 ret = 0; 700 } 701 702 return ret; 703 } 704 705 /* 706 * activate/deactivate link with host. 707 */ 708 static void pullup(struct fotg210_chip *chip, int is_on) 709 { 710 struct fotg210_regs *regs = chip->regs; 711 712 if (is_on) { 713 if (!chip->pullup) { 714 chip->state = USB_STATE_POWERED; 715 chip->pullup = 1; 716 /* enable the chip */ 717 setbits_le32(®s->dev_ctrl, DEVCTRL_EN); 718 /* clear unplug bit (BIT0) */ 719 clrbits_le32(®s->phy_tmsr, PHYTMSR_UNPLUG); 720 } 721 } else { 722 chip->state = USB_STATE_NOTATTACHED; 723 chip->pullup = 0; 724 chip->addr = 0; 725 writel(chip->addr, ®s->dev_addr); 726 /* set unplug bit (BIT0) */ 727 setbits_le32(®s->phy_tmsr, PHYTMSR_UNPLUG); 728 /* disable the chip */ 729 clrbits_le32(®s->dev_ctrl, DEVCTRL_EN); 730 } 731 } 732 733 static int fotg210_pullup(struct usb_gadget *_gadget, int is_on) 734 { 735 struct fotg210_chip *chip; 736 737 chip = container_of(_gadget, struct fotg210_chip, gadget); 738 739 debug("fotg210: pullup=%d\n", is_on); 740 741 pullup(chip, is_on); 742 743 return 0; 744 } 745 746 static int fotg210_get_frame(struct usb_gadget *_gadget) 747 { 748 struct fotg210_chip *chip; 749 struct fotg210_regs *regs; 750 751 chip = container_of(_gadget, struct fotg210_chip, gadget); 752 regs = chip->regs; 753 754 return SOFFNR_FNR(readl(®s->sof_fnr)); 755 } 756 757 static struct usb_gadget_ops fotg210_gadget_ops = { 758 .get_frame = fotg210_get_frame, 759 .pullup = fotg210_pullup, 760 }; 761 762 static struct usb_ep_ops fotg210_ep_ops = { 763 .enable = fotg210_ep_enable, 764 .disable = fotg210_ep_disable, 765 .queue = fotg210_ep_queue, 766 .dequeue = fotg210_ep_dequeue, 767 .set_halt = fotg210_ep_halt, 768 .alloc_request = fotg210_ep_alloc_request, 769 .free_request = fotg210_ep_free_request, 770 }; 771 772 static struct fotg210_chip controller = { 773 .regs = (void __iomem *)CONFIG_FOTG210_BASE, 774 .gadget = { 775 .name = "fotg210_udc", 776 .ops = &fotg210_gadget_ops, 777 .ep0 = &controller.ep[0].ep, 778 .speed = USB_SPEED_UNKNOWN, 779 .is_dualspeed = 1, 780 .is_otg = 0, 781 .is_a_peripheral = 0, 782 .b_hnp_enable = 0, 783 .a_hnp_support = 0, 784 .a_alt_hnp_support = 0, 785 }, 786 .ep[0] = { 787 .id = 0, 788 .ep = { 789 .name = "ep0", 790 .ops = &fotg210_ep_ops, 791 }, 792 .desc = &ep0_desc, 793 .chip = &controller, 794 .maxpacket = CFG_EP0_MAX_PACKET_SIZE, 795 }, 796 .ep[1] = { 797 .id = 1, 798 .ep = { 799 .name = "ep1", 800 .ops = &fotg210_ep_ops, 801 }, 802 .chip = &controller, 803 .maxpacket = CFG_EPX_MAX_PACKET_SIZE, 804 }, 805 .ep[2] = { 806 .id = 2, 807 .ep = { 808 .name = "ep2", 809 .ops = &fotg210_ep_ops, 810 }, 811 .chip = &controller, 812 .maxpacket = CFG_EPX_MAX_PACKET_SIZE, 813 }, 814 .ep[3] = { 815 .id = 3, 816 .ep = { 817 .name = "ep3", 818 .ops = &fotg210_ep_ops, 819 }, 820 .chip = &controller, 821 .maxpacket = CFG_EPX_MAX_PACKET_SIZE, 822 }, 823 .ep[4] = { 824 .id = 4, 825 .ep = { 826 .name = "ep4", 827 .ops = &fotg210_ep_ops, 828 }, 829 .chip = &controller, 830 .maxpacket = CFG_EPX_MAX_PACKET_SIZE, 831 }, 832 }; 833 834 int usb_gadget_handle_interrupts(void) 835 { 836 struct fotg210_chip *chip = &controller; 837 struct fotg210_regs *regs = chip->regs; 838 uint32_t id, st, isr, gisr; 839 840 isr = readl(®s->isr) & (~readl(®s->imr)); 841 gisr = readl(®s->gisr) & (~readl(®s->gimr)); 842 if (!(isr & ISR_DEV) || !gisr) 843 return 0; 844 845 writel(ISR_DEV, ®s->isr); 846 847 /* CX interrupts */ 848 if (gisr & GISR_GRP0) { 849 st = readl(®s->gisr0); 850 writel(0, ®s->gisr0); 851 852 if (st & GISR0_CXERR) 853 printf("fotg210: cmd error\n"); 854 855 if (st & GISR0_CXABORT) 856 printf("fotg210: cmd abort\n"); 857 858 if (st & GISR0_CXSETUP) /* setup */ 859 fotg210_setup(chip); 860 else if (st & GISR0_CXEND) /* command finish */ 861 setbits_le32(®s->cxfifo, CXFIFO_CXFIN); 862 } 863 864 /* FIFO interrupts */ 865 if (gisr & GISR_GRP1) { 866 st = readl(®s->gisr1); 867 for (id = 0; id < 4; ++id) { 868 if (st & GISR1_RX_FIFO(id)) 869 fotg210_recv(chip, fifo_to_ep(chip, id, 0)); 870 } 871 } 872 873 /* Device Status Interrupts */ 874 if (gisr & GISR_GRP2) { 875 st = readl(®s->gisr2); 876 writel(0, ®s->gisr2); 877 878 if (st & GISR2_RESET) 879 printf("fotg210: reset by host\n"); 880 else if (st & GISR2_SUSPEND) 881 printf("fotg210: suspend/removed\n"); 882 else if (st & GISR2_RESUME) 883 printf("fotg210: resume\n"); 884 885 /* Errors */ 886 if (st & GISR2_ISOCERR) 887 printf("fotg210: iso error\n"); 888 if (st & GISR2_ISOCABT) 889 printf("fotg210: iso abort\n"); 890 if (st & GISR2_DMAERR) 891 printf("fotg210: dma error\n"); 892 } 893 894 return 0; 895 } 896 897 int usb_gadget_register_driver(struct usb_gadget_driver *driver) 898 { 899 int i, ret = 0; 900 struct fotg210_chip *chip = &controller; 901 902 if (!driver || !driver->bind || !driver->setup) { 903 puts("fotg210: bad parameter.\n"); 904 return -EINVAL; 905 } 906 907 INIT_LIST_HEAD(&chip->gadget.ep_list); 908 for (i = 0; i < CFG_NUM_ENDPOINTS + 1; ++i) { 909 struct fotg210_ep *ep = chip->ep + i; 910 911 ep->ep.maxpacket = ep->maxpacket; 912 INIT_LIST_HEAD(&ep->queue); 913 914 if (ep->id == 0) { 915 ep->stopped = 0; 916 } else { 917 ep->stopped = 1; 918 list_add_tail(&ep->ep.ep_list, &chip->gadget.ep_list); 919 } 920 } 921 922 if (fotg210_reset(chip)) { 923 puts("fotg210: reset failed.\n"); 924 return -EINVAL; 925 } 926 927 ret = driver->bind(&chip->gadget); 928 if (ret) { 929 debug("fotg210: driver->bind() returned %d\n", ret); 930 return ret; 931 } 932 chip->driver = driver; 933 934 return ret; 935 } 936 937 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) 938 { 939 struct fotg210_chip *chip = &controller; 940 941 driver->unbind(&chip->gadget); 942 chip->driver = NULL; 943 944 pullup(chip, 0); 945 946 return 0; 947 } 948