1/* 2 * Toshiba TC86C001 ("Goku-S") USB Device Controller driver 3 * 4 * Copyright (C) 2000-2002 Lineo 5 * by Stuart Lynne, Tom Rushworth, and Bruce Balden 6 * Copyright (C) 2002 Toshiba Corporation 7 * Copyright (C) 2003 MontaVista Software (source@mvista.com) 8 * 9 * This file is licensed under the terms of the GNU General Public 10 * License version 2. This program is licensed "as is" without any 11 * warranty of any kind, whether express or implied. 12 */ 13 14/* 15 * This device has ep0 and three semi-configurable bulk/interrupt endpoints. 16 * 17 * - Endpoint numbering is fixed: ep{1,2,3}-bulk 18 * - Gadget drivers can choose ep maxpacket (8/16/32/64) 19 * - Gadget drivers can choose direction (IN, OUT) 20 * - DMA works with ep1 (OUT transfers) and ep2 (IN transfers). 21 */ 22 23// #define VERBOSE /* extra debug messages (success too) */ 24// #define USB_TRACE /* packet-level success messages */ 25 26#include <linux/kernel.h> 27#include <linux/module.h> 28#include <linux/pci.h> 29#include <linux/delay.h> 30#include <linux/ioport.h> 31#include <linux/slab.h> 32#include <linux/errno.h> 33#include <linux/init.h> 34#include <linux/timer.h> 35#include <linux/list.h> 36#include <linux/interrupt.h> 37#include <linux/proc_fs.h> 38#include <linux/device.h> 39#include <linux/usb/ch9.h> 40#include <linux/usb/gadget.h> 41 42#include <asm/byteorder.h> 43#include <asm/io.h> 44#include <asm/irq.h> 45#include <asm/system.h> 46#include <asm/unaligned.h> 47 48 49#include "goku_udc.h" 50 51#define DRIVER_DESC "TC86C001 USB Device Controller" 52#define DRIVER_VERSION "30-Oct 2003" 53 54#define DMA_ADDR_INVALID (~(dma_addr_t)0) 55 56static const char driver_name [] = "goku_udc"; 57static const char driver_desc [] = DRIVER_DESC; 58 59MODULE_AUTHOR("source@mvista.com"); 60MODULE_DESCRIPTION(DRIVER_DESC); 61MODULE_LICENSE("GPL"); 62 63 64/* 65 * IN dma behaves ok under testing, though the IN-dma abort paths don't 66 * seem to behave quite as expected. Used by default. 67 * 68 * OUT dma documents design problems handling the common "short packet" 69 * transfer termination policy; it couldn't be enabled by default, even 70 * if the OUT-dma abort problems had a resolution. 71 */ 72static unsigned use_dma = 1; 73 74 75/*-------------------------------------------------------------------------*/ 76 77static void nuke(struct goku_ep *, int status); 78 79static inline void 80command(struct goku_udc_regs __iomem *regs, int command, unsigned epnum) 81{ 82 writel(COMMAND_EP(epnum) | command, ®s->Command); 83 udelay(300); 84} 85 86static int 87goku_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) 88{ 89 struct goku_udc *dev; 90 struct goku_ep *ep; 91 u32 mode; 92 u16 max; 93 unsigned long flags; 94 95 ep = container_of(_ep, struct goku_ep, ep); 96 if (!_ep || !desc || ep->desc 97 || desc->bDescriptorType != USB_DT_ENDPOINT) 98 return -EINVAL; 99 dev = ep->dev; 100 if (ep == &dev->ep[0]) 101 return -EINVAL; 102 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) 103 return -ESHUTDOWN; 104 if (ep->num != usb_endpoint_num(desc)) 105 return -EINVAL; 106 107 switch (usb_endpoint_type(desc)) { 108 case USB_ENDPOINT_XFER_BULK: 109 case USB_ENDPOINT_XFER_INT: 110 break; 111 default: 112 return -EINVAL; 113 } 114 115 if ((readl(ep->reg_status) & EPxSTATUS_EP_MASK) 116 != EPxSTATUS_EP_INVALID) 117 return -EBUSY; 118 119 /* enabling the no-toggle interrupt mode would need an api hook */ 120 mode = 0; 121 max = get_unaligned_le16(&desc->wMaxPacketSize); 122 switch (max) { 123 case 64: mode++; 124 case 32: mode++; 125 case 16: mode++; 126 case 8: mode <<= 3; 127 break; 128 default: 129 return -EINVAL; 130 } 131 mode |= 2 << 1; /* bulk, or intr-with-toggle */ 132 133 /* ep1/ep2 dma direction is chosen early; it works in the other 134 * direction, with pio. be cautious with out-dma. 135 */ 136 ep->is_in = usb_endpoint_dir_in(desc); 137 if (ep->is_in) { 138 mode |= 1; 139 ep->dma = (use_dma != 0) && (ep->num == UDC_MSTRD_ENDPOINT); 140 } else { 141 ep->dma = (use_dma == 2) && (ep->num == UDC_MSTWR_ENDPOINT); 142 if (ep->dma) 143 DBG(dev, "%s out-dma hides short packets\n", 144 ep->ep.name); 145 } 146 147 spin_lock_irqsave(&ep->dev->lock, flags); 148 149 /* ep1 and ep2 can do double buffering and/or dma */ 150 if (ep->num < 3) { 151 struct goku_udc_regs __iomem *regs = ep->dev->regs; 152 u32 tmp; 153 154 /* double buffer except (for now) with pio in */ 155 tmp = ((ep->dma || !ep->is_in) 156 ? 0x10 /* double buffered */ 157 : 0x11 /* single buffer */ 158 ) << ep->num; 159 tmp |= readl(®s->EPxSingle); 160 writel(tmp, ®s->EPxSingle); 161 162 tmp = (ep->dma ? 0x10/*dma*/ : 0x11/*pio*/) << ep->num; 163 tmp |= readl(®s->EPxBCS); 164 writel(tmp, ®s->EPxBCS); 165 } 166 writel(mode, ep->reg_mode); 167 command(ep->dev->regs, COMMAND_RESET, ep->num); 168 ep->ep.maxpacket = max; 169 ep->stopped = 0; 170 ep->desc = desc; 171 spin_unlock_irqrestore(&ep->dev->lock, flags); 172 173 DBG(dev, "enable %s %s %s maxpacket %u\n", ep->ep.name, 174 ep->is_in ? "IN" : "OUT", 175 ep->dma ? "dma" : "pio", 176 max); 177 178 return 0; 179} 180 181static void ep_reset(struct goku_udc_regs __iomem *regs, struct goku_ep *ep) 182{ 183 struct goku_udc *dev = ep->dev; 184 185 if (regs) { 186 command(regs, COMMAND_INVALID, ep->num); 187 if (ep->num) { 188 if (ep->num == UDC_MSTWR_ENDPOINT) 189 dev->int_enable &= ~(INT_MSTWREND 190 |INT_MSTWRTMOUT); 191 else if (ep->num == UDC_MSTRD_ENDPOINT) 192 dev->int_enable &= ~INT_MSTRDEND; 193 dev->int_enable &= ~INT_EPxDATASET (ep->num); 194 } else 195 dev->int_enable &= ~INT_EP0; 196 writel(dev->int_enable, ®s->int_enable); 197 readl(®s->int_enable); 198 if (ep->num < 3) { 199 struct goku_udc_regs __iomem *r = ep->dev->regs; 200 u32 tmp; 201 202 tmp = readl(&r->EPxSingle); 203 tmp &= ~(0x11 << ep->num); 204 writel(tmp, &r->EPxSingle); 205 206 tmp = readl(&r->EPxBCS); 207 tmp &= ~(0x11 << ep->num); 208 writel(tmp, &r->EPxBCS); 209 } 210 /* reset dma in case we're still using it */ 211 if (ep->dma) { 212 u32 master; 213 214 master = readl(®s->dma_master) & MST_RW_BITS; 215 if (ep->num == UDC_MSTWR_ENDPOINT) { 216 master &= ~MST_W_BITS; 217 master |= MST_WR_RESET; 218 } else { 219 master &= ~MST_R_BITS; 220 master |= MST_RD_RESET; 221 } 222 writel(master, ®s->dma_master); 223 } 224 } 225 226 ep->ep.maxpacket = MAX_FIFO_SIZE; 227 ep->desc = NULL; 228 ep->stopped = 1; 229 ep->irqs = 0; 230 ep->dma = 0; 231} 232 233static int goku_ep_disable(struct usb_ep *_ep) 234{ 235 struct goku_ep *ep; 236 struct goku_udc *dev; 237 unsigned long flags; 238 239 ep = container_of(_ep, struct goku_ep, ep); 240 if (!_ep || !ep->desc) 241 return -ENODEV; 242 dev = ep->dev; 243 if (dev->ep0state == EP0_SUSPEND) 244 return -EBUSY; 245 246 VDBG(dev, "disable %s\n", _ep->name); 247 248 spin_lock_irqsave(&dev->lock, flags); 249 nuke(ep, -ESHUTDOWN); 250 ep_reset(dev->regs, ep); 251 spin_unlock_irqrestore(&dev->lock, flags); 252 253 return 0; 254} 255 256/*-------------------------------------------------------------------------*/ 257 258static struct usb_request * 259goku_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags) 260{ 261 struct goku_request *req; 262 263 if (!_ep) 264 return NULL; 265 req = kzalloc(sizeof *req, gfp_flags); 266 if (!req) 267 return NULL; 268 269 req->req.dma = DMA_ADDR_INVALID; 270 INIT_LIST_HEAD(&req->queue); 271 return &req->req; 272} 273 274static void 275goku_free_request(struct usb_ep *_ep, struct usb_request *_req) 276{ 277 struct goku_request *req; 278 279 if (!_ep || !_req) 280 return; 281 282 req = container_of(_req, struct goku_request, req); 283 WARN_ON(!list_empty(&req->queue)); 284 kfree(req); 285} 286 287/*-------------------------------------------------------------------------*/ 288 289static void 290done(struct goku_ep *ep, struct goku_request *req, int status) 291{ 292 struct goku_udc *dev; 293 unsigned stopped = ep->stopped; 294 295 list_del_init(&req->queue); 296 297 if (likely(req->req.status == -EINPROGRESS)) 298 req->req.status = status; 299 else 300 status = req->req.status; 301 302 dev = ep->dev; 303 if (req->mapped) { 304 pci_unmap_single(dev->pdev, req->req.dma, req->req.length, 305 ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE); 306 req->req.dma = DMA_ADDR_INVALID; 307 req->mapped = 0; 308 } 309 310#ifndef USB_TRACE 311 if (status && status != -ESHUTDOWN) 312#endif 313 VDBG(dev, "complete %s req %p stat %d len %u/%u\n", 314 ep->ep.name, &req->req, status, 315 req->req.actual, req->req.length); 316 317 /* don't modify queue heads during completion callback */ 318 ep->stopped = 1; 319 spin_unlock(&dev->lock); 320 req->req.complete(&ep->ep, &req->req); 321 spin_lock(&dev->lock); 322 ep->stopped = stopped; 323} 324 325/*-------------------------------------------------------------------------*/ 326 327static inline int 328write_packet(u32 __iomem *fifo, u8 *buf, struct goku_request *req, unsigned max) 329{ 330 unsigned length, count; 331 332 length = min(req->req.length - req->req.actual, max); 333 req->req.actual += length; 334 335 count = length; 336 while (likely(count--)) 337 writel(*buf++, fifo); 338 return length; 339} 340 341// return: 0 = still running, 1 = completed, negative = errno 342static int write_fifo(struct goku_ep *ep, struct goku_request *req) 343{ 344 struct goku_udc *dev = ep->dev; 345 u32 tmp; 346 u8 *buf; 347 unsigned count; 348 int is_last; 349 350 tmp = readl(&dev->regs->DataSet); 351 buf = req->req.buf + req->req.actual; 352 prefetch(buf); 353 354 dev = ep->dev; 355 if (unlikely(ep->num == 0 && dev->ep0state != EP0_IN)) 356 return -EL2HLT; 357 358 /* NOTE: just single-buffered PIO-IN for now. */ 359 if (unlikely((tmp & DATASET_A(ep->num)) != 0)) 360 return 0; 361 362 /* clear our "packet available" irq */ 363 if (ep->num != 0) 364 writel(~INT_EPxDATASET(ep->num), &dev->regs->int_status); 365 366 count = write_packet(ep->reg_fifo, buf, req, ep->ep.maxpacket); 367 368 /* last packet often short (sometimes a zlp, especially on ep0) */ 369 if (unlikely(count != ep->ep.maxpacket)) { 370 writel(~(1<<ep->num), &dev->regs->EOP); 371 if (ep->num == 0) { 372 dev->ep[0].stopped = 1; 373 dev->ep0state = EP0_STATUS; 374 } 375 is_last = 1; 376 } else { 377 if (likely(req->req.length != req->req.actual) 378 || req->req.zero) 379 is_last = 0; 380 else 381 is_last = 1; 382 } 383 384 /* requests complete when all IN data is in the FIFO, 385 * or sometimes later, if a zlp was needed. 386 */ 387 if (is_last) { 388 done(ep, req, 0); 389 return 1; 390 } 391 392 return 0; 393} 394 395static int read_fifo(struct goku_ep *ep, struct goku_request *req) 396{ 397 struct goku_udc_regs __iomem *regs; 398 u32 size, set; 399 u8 *buf; 400 unsigned bufferspace, is_short, dbuff; 401 402 regs = ep->dev->regs; 403top: 404 buf = req->req.buf + req->req.actual; 405 prefetchw(buf); 406 407 if (unlikely(ep->num == 0 && ep->dev->ep0state != EP0_OUT)) 408 return -EL2HLT; 409 410 dbuff = (ep->num == 1 || ep->num == 2); 411 do { 412 /* ack dataset irq matching the status we'll handle */ 413 if (ep->num != 0) 414 writel(~INT_EPxDATASET(ep->num), ®s->int_status); 415 416 set = readl(®s->DataSet) & DATASET_AB(ep->num); 417 size = readl(®s->EPxSizeLA[ep->num]); 418 bufferspace = req->req.length - req->req.actual; 419 420 /* usually do nothing without an OUT packet */ 421 if (likely(ep->num != 0 || bufferspace != 0)) { 422 if (unlikely(set == 0)) 423 break; 424 /* use ep1/ep2 double-buffering for OUT */ 425 if (!(size & PACKET_ACTIVE)) 426 size = readl(®s->EPxSizeLB[ep->num]); 427 if (!(size & PACKET_ACTIVE)) /* "can't happen" */ 428 break; 429 size &= DATASIZE; /* EPxSizeH == 0 */ 430 431 /* ep0out no-out-data case for set_config, etc */ 432 } else 433 size = 0; 434 435 /* read all bytes from this packet */ 436 req->req.actual += size; 437 is_short = (size < ep->ep.maxpacket); 438#ifdef USB_TRACE 439 VDBG(ep->dev, "read %s %u bytes%s OUT req %p %u/%u\n", 440 ep->ep.name, size, is_short ? "/S" : "", 441 req, req->req.actual, req->req.length); 442#endif 443 while (likely(size-- != 0)) { 444 u8 byte = (u8) readl(ep->reg_fifo); 445 446 if (unlikely(bufferspace == 0)) { 447 /* this happens when the driver's buffer 448 * is smaller than what the host sent. 449 * discard the extra data in this packet. 450 */ 451 if (req->req.status != -EOVERFLOW) 452 DBG(ep->dev, "%s overflow %u\n", 453 ep->ep.name, size); 454 req->req.status = -EOVERFLOW; 455 } else { 456 *buf++ = byte; 457 bufferspace--; 458 } 459 } 460 461 /* completion */ 462 if (unlikely(is_short || req->req.actual == req->req.length)) { 463 if (unlikely(ep->num == 0)) { 464 /* non-control endpoints now usable? */ 465 if (ep->dev->req_config) 466 writel(ep->dev->configured 467 ? USBSTATE_CONFIGURED 468 : 0, 469 ®s->UsbState); 470 /* ep0out status stage */ 471 writel(~(1<<0), ®s->EOP); 472 ep->stopped = 1; 473 ep->dev->ep0state = EP0_STATUS; 474 } 475 done(ep, req, 0); 476 477 /* empty the second buffer asap */ 478 if (dbuff && !list_empty(&ep->queue)) { 479 req = list_entry(ep->queue.next, 480 struct goku_request, queue); 481 goto top; 482 } 483 return 1; 484 } 485 } while (dbuff); 486 return 0; 487} 488 489static inline void 490pio_irq_enable(struct goku_udc *dev, 491 struct goku_udc_regs __iomem *regs, int epnum) 492{ 493 dev->int_enable |= INT_EPxDATASET (epnum); 494 writel(dev->int_enable, ®s->int_enable); 495 /* write may still be posted */ 496} 497 498static inline void 499pio_irq_disable(struct goku_udc *dev, 500 struct goku_udc_regs __iomem *regs, int epnum) 501{ 502 dev->int_enable &= ~INT_EPxDATASET (epnum); 503 writel(dev->int_enable, ®s->int_enable); 504 /* write may still be posted */ 505} 506 507static inline void 508pio_advance(struct goku_ep *ep) 509{ 510 struct goku_request *req; 511 512 if (unlikely(list_empty (&ep->queue))) 513 return; 514 req = list_entry(ep->queue.next, struct goku_request, queue); 515 (ep->is_in ? write_fifo : read_fifo)(ep, req); 516} 517 518 519/*-------------------------------------------------------------------------*/ 520 521// return: 0 = q running, 1 = q stopped, negative = errno 522static int start_dma(struct goku_ep *ep, struct goku_request *req) 523{ 524 struct goku_udc_regs __iomem *regs = ep->dev->regs; 525 u32 master; 526 u32 start = req->req.dma; 527 u32 end = start + req->req.length - 1; 528 529 master = readl(®s->dma_master) & MST_RW_BITS; 530 531 /* re-init the bits affecting IN dma; careful with zlps */ 532 if (likely(ep->is_in)) { 533 if (unlikely(master & MST_RD_ENA)) { 534 DBG (ep->dev, "start, IN active dma %03x!!\n", 535 master); 536// return -EL2HLT; 537 } 538 writel(end, ®s->in_dma_end); 539 writel(start, ®s->in_dma_start); 540 541 master &= ~MST_R_BITS; 542 if (unlikely(req->req.length == 0)) 543 master = MST_RD_ENA | MST_RD_EOPB; 544 else if ((req->req.length % ep->ep.maxpacket) != 0 545 || req->req.zero) 546 master = MST_RD_ENA | MST_EOPB_ENA; 547 else 548 master = MST_RD_ENA | MST_EOPB_DIS; 549 550 ep->dev->int_enable |= INT_MSTRDEND; 551 552 /* Goku DMA-OUT merges short packets, which plays poorly with 553 * protocols where short packets mark the transfer boundaries. 554 * The chip supports a nonstandard policy with INT_MSTWRTMOUT, 555 * ending transfers after 3 SOFs; we don't turn it on. 556 */ 557 } else { 558 if (unlikely(master & MST_WR_ENA)) { 559 DBG (ep->dev, "start, OUT active dma %03x!!\n", 560 master); 561// return -EL2HLT; 562 } 563 writel(end, ®s->out_dma_end); 564 writel(start, ®s->out_dma_start); 565 566 master &= ~MST_W_BITS; 567 master |= MST_WR_ENA | MST_TIMEOUT_DIS; 568 569 ep->dev->int_enable |= INT_MSTWREND|INT_MSTWRTMOUT; 570 } 571 572 writel(master, ®s->dma_master); 573 writel(ep->dev->int_enable, ®s->int_enable); 574 return 0; 575} 576 577static void dma_advance(struct goku_udc *dev, struct goku_ep *ep) 578{ 579 struct goku_request *req; 580 struct goku_udc_regs __iomem *regs = ep->dev->regs; 581 u32 master; 582 583 master = readl(®s->dma_master); 584 585 if (unlikely(list_empty(&ep->queue))) { 586stop: 587 if (ep->is_in) 588 dev->int_enable &= ~INT_MSTRDEND; 589 else 590 dev->int_enable &= ~(INT_MSTWREND|INT_MSTWRTMOUT); 591 writel(dev->int_enable, ®s->int_enable); 592 return; 593 } 594 req = list_entry(ep->queue.next, struct goku_request, queue); 595 596 /* normal hw dma completion (not abort) */ 597 if (likely(ep->is_in)) { 598 if (unlikely(master & MST_RD_ENA)) 599 return; 600 req->req.actual = readl(®s->in_dma_current); 601 } else { 602 if (unlikely(master & MST_WR_ENA)) 603 return; 604 605 /* hardware merges short packets, and also hides packet 606 * overruns. a partial packet MAY be in the fifo here. 607 */ 608 req->req.actual = readl(®s->out_dma_current); 609 } 610 req->req.actual -= req->req.dma; 611 req->req.actual++; 612 613#ifdef USB_TRACE 614 VDBG(dev, "done %s %s dma, %u/%u bytes, req %p\n", 615 ep->ep.name, ep->is_in ? "IN" : "OUT", 616 req->req.actual, req->req.length, req); 617#endif 618 done(ep, req, 0); 619 if (list_empty(&ep->queue)) 620 goto stop; 621 req = list_entry(ep->queue.next, struct goku_request, queue); 622 (void) start_dma(ep, req); 623} 624 625static void abort_dma(struct goku_ep *ep, int status) 626{ 627 struct goku_udc_regs __iomem *regs = ep->dev->regs; 628 struct goku_request *req; 629 u32 curr, master; 630 631 /* NAK future host requests, hoping the implicit delay lets the 632 * dma engine finish reading (or writing) its latest packet and 633 * empty the dma buffer (up to 16 bytes). 634 * 635 * This avoids needing to clean up a partial packet in the fifo; 636 * we can't do that for IN without side effects to HALT and TOGGLE. 637 */ 638 command(regs, COMMAND_FIFO_DISABLE, ep->num); 639 req = list_entry(ep->queue.next, struct goku_request, queue); 640 master = readl(®s->dma_master) & MST_RW_BITS; 641 642 if (ep->is_in) { 643 if (unlikely((readl(®s->dma_master) & MST_RD_ENA) == 0)) 644 goto finished; 645 curr = readl(®s->in_dma_current); 646 647 writel(curr, ®s->in_dma_end); 648 writel(curr, ®s->in_dma_start); 649 650 master &= ~MST_R_BITS; 651 master |= MST_RD_RESET; 652 writel(master, ®s->dma_master); 653 654 if (readl(®s->dma_master) & MST_RD_ENA) 655 DBG(ep->dev, "IN dma active after reset!\n"); 656 657 } else { 658 if (unlikely((readl(®s->dma_master) & MST_WR_ENA) == 0)) 659 goto finished; 660 curr = readl(®s->out_dma_current); 661 662 writel(curr, ®s->out_dma_end); 663 writel(curr, ®s->out_dma_start); 664 665 master &= ~MST_W_BITS; 666 master |= MST_WR_RESET; 667 writel(master, ®s->dma_master); 668 669 if (readl(®s->dma_master) & MST_WR_ENA) 670 DBG(ep->dev, "OUT dma active after reset!\n"); 671 } 672 req->req.actual = (curr - req->req.dma) + 1; 673 req->req.status = status; 674 675 VDBG(ep->dev, "%s %s %s %d/%d\n", __func__, ep->ep.name, 676 ep->is_in ? "IN" : "OUT", 677 req->req.actual, req->req.length); 678 679 command(regs, COMMAND_FIFO_ENABLE, ep->num); 680 681 return; 682 683finished: 684 /* dma already completed; no abort needed */ 685 command(regs, COMMAND_FIFO_ENABLE, ep->num); 686 req->req.actual = req->req.length; 687 req->req.status = 0; 688} 689 690/*-------------------------------------------------------------------------*/ 691 692static int 693goku_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags) 694{ 695 struct goku_request *req; 696 struct goku_ep *ep; 697 struct goku_udc *dev; 698 unsigned long flags; 699 int status; 700 701 /* always require a cpu-view buffer so pio works */ 702 req = container_of(_req, struct goku_request, req); 703 if (unlikely(!_req || !_req->complete 704 || !_req->buf || !list_empty(&req->queue))) 705 return -EINVAL; 706 ep = container_of(_ep, struct goku_ep, ep); 707 if (unlikely(!_ep || (!ep->desc && ep->num != 0))) 708 return -EINVAL; 709 dev = ep->dev; 710 if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) 711 return -ESHUTDOWN; 712 713 /* can't touch registers when suspended */ 714 if (dev->ep0state == EP0_SUSPEND) 715 return -EBUSY; 716 717 /* set up dma mapping in case the caller didn't */ 718 if (ep->dma && _req->dma == DMA_ADDR_INVALID) { 719 _req->dma = pci_map_single(dev->pdev, _req->buf, _req->length, 720 ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE); 721 req->mapped = 1; 722 } 723 724#ifdef USB_TRACE 725 VDBG(dev, "%s queue req %p, len %u buf %p\n", 726 _ep->name, _req, _req->length, _req->buf); 727#endif 728 729 spin_lock_irqsave(&dev->lock, flags); 730 731 _req->status = -EINPROGRESS; 732 _req->actual = 0; 733 734 /* for ep0 IN without premature status, zlp is required and 735 * writing EOP starts the status stage (OUT). 736 */ 737 if (unlikely(ep->num == 0 && ep->is_in)) 738 _req->zero = 1; 739 740 /* kickstart this i/o queue? */ 741 status = 0; 742 if (list_empty(&ep->queue) && likely(!ep->stopped)) { 743 /* dma: done after dma completion IRQ (or error) 744 * pio: done after last fifo operation 745 */ 746 if (ep->dma) 747 status = start_dma(ep, req); 748 else 749 status = (ep->is_in ? write_fifo : read_fifo)(ep, req); 750 751 if (unlikely(status != 0)) { 752 if (status > 0) 753 status = 0; 754 req = NULL; 755 } 756 757 } /* else pio or dma irq handler advances the queue. */ 758 759 if (likely(req != 0)) 760 list_add_tail(&req->queue, &ep->queue); 761 762 if (likely(!list_empty(&ep->queue)) 763 && likely(ep->num != 0) 764 && !ep->dma 765 && !(dev->int_enable & INT_EPxDATASET (ep->num))) 766 pio_irq_enable(dev, dev->regs, ep->num); 767 768 spin_unlock_irqrestore(&dev->lock, flags); 769 770 /* pci writes may still be posted */ 771 return status; 772} 773 774/* dequeue ALL requests */ 775static void nuke(struct goku_ep *ep, int status) 776{ 777 struct goku_request *req; 778 779 ep->stopped = 1; 780 if (list_empty(&ep->queue)) 781 return; 782 if (ep->dma) 783 abort_dma(ep, status); 784 while (!list_empty(&ep->queue)) { 785 req = list_entry(ep->queue.next, struct goku_request, queue); 786 done(ep, req, status); 787 } 788} 789 790/* dequeue JUST ONE request */ 791static int goku_dequeue(struct usb_ep *_ep, struct usb_request *_req) 792{ 793 struct goku_request *req; 794 struct goku_ep *ep; 795 struct goku_udc *dev; 796 unsigned long flags; 797 798 ep = container_of(_ep, struct goku_ep, ep); 799 if (!_ep || !_req || (!ep->desc && ep->num != 0)) 800 return -EINVAL; 801 dev = ep->dev; 802 if (!dev->driver) 803 return -ESHUTDOWN; 804 805 /* we can't touch (dma) registers when suspended */ 806 if (dev->ep0state == EP0_SUSPEND) 807 return -EBUSY; 808 809 VDBG(dev, "%s %s %s %s %p\n", __func__, _ep->name, 810 ep->is_in ? "IN" : "OUT", 811 ep->dma ? "dma" : "pio", 812 _req); 813 814 spin_lock_irqsave(&dev->lock, flags); 815 816 /* make sure it's actually queued on this endpoint */ 817 list_for_each_entry (req, &ep->queue, queue) { 818 if (&req->req == _req) 819 break; 820 } 821 if (&req->req != _req) { 822 spin_unlock_irqrestore (&dev->lock, flags); 823 return -EINVAL; 824 } 825 826 if (ep->dma && ep->queue.next == &req->queue && !ep->stopped) { 827 abort_dma(ep, -ECONNRESET); 828 done(ep, req, -ECONNRESET); 829 dma_advance(dev, ep); 830 } else if (!list_empty(&req->queue)) 831 done(ep, req, -ECONNRESET); 832 else 833 req = NULL; 834 spin_unlock_irqrestore(&dev->lock, flags); 835 836 return req ? 0 : -EOPNOTSUPP; 837} 838 839/*-------------------------------------------------------------------------*/ 840 841static void goku_clear_halt(struct goku_ep *ep) 842{ 843 // assert (ep->num !=0) 844 VDBG(ep->dev, "%s clear halt\n", ep->ep.name); 845 command(ep->dev->regs, COMMAND_SETDATA0, ep->num); 846 command(ep->dev->regs, COMMAND_STALL_CLEAR, ep->num); 847 if (ep->stopped) { 848 ep->stopped = 0; 849 if (ep->dma) { 850 struct goku_request *req; 851 852 if (list_empty(&ep->queue)) 853 return; 854 req = list_entry(ep->queue.next, struct goku_request, 855 queue); 856 (void) start_dma(ep, req); 857 } else 858 pio_advance(ep); 859 } 860} 861 862static int goku_set_halt(struct usb_ep *_ep, int value) 863{ 864 struct goku_ep *ep; 865 unsigned long flags; 866 int retval = 0; 867 868 if (!_ep) 869 return -ENODEV; 870 ep = container_of (_ep, struct goku_ep, ep); 871 872 if (ep->num == 0) { 873 if (value) { 874 ep->dev->ep0state = EP0_STALL; 875 ep->dev->ep[0].stopped = 1; 876 } else 877 return -EINVAL; 878 879 /* don't change EPxSTATUS_EP_INVALID to READY */ 880 } else if (!ep->desc) { 881 DBG(ep->dev, "%s %s inactive?\n", __func__, ep->ep.name); 882 return -EINVAL; 883 } 884 885 spin_lock_irqsave(&ep->dev->lock, flags); 886 if (!list_empty(&ep->queue)) 887 retval = -EAGAIN; 888 else if (ep->is_in && value 889 /* data in (either) packet buffer? */ 890 && (readl(&ep->dev->regs->DataSet) 891 & DATASET_AB(ep->num))) 892 retval = -EAGAIN; 893 else if (!value) 894 goku_clear_halt(ep); 895 else { 896 ep->stopped = 1; 897 VDBG(ep->dev, "%s set halt\n", ep->ep.name); 898 command(ep->dev->regs, COMMAND_STALL, ep->num); 899 readl(ep->reg_status); 900 } 901 spin_unlock_irqrestore(&ep->dev->lock, flags); 902 return retval; 903} 904 905static int goku_fifo_status(struct usb_ep *_ep) 906{ 907 struct goku_ep *ep; 908 struct goku_udc_regs __iomem *regs; 909 u32 size; 910 911 if (!_ep) 912 return -ENODEV; 913 ep = container_of(_ep, struct goku_ep, ep); 914 915 /* size is only reported sanely for OUT */ 916 if (ep->is_in) 917 return -EOPNOTSUPP; 918 919 /* ignores 16-byte dma buffer; SizeH == 0 */ 920 regs = ep->dev->regs; 921 size = readl(®s->EPxSizeLA[ep->num]) & DATASIZE; 922 size += readl(®s->EPxSizeLB[ep->num]) & DATASIZE; 923 VDBG(ep->dev, "%s %s %u\n", __func__, ep->ep.name, size); 924 return size; 925} 926 927static void goku_fifo_flush(struct usb_ep *_ep) 928{ 929 struct goku_ep *ep; 930 struct goku_udc_regs __iomem *regs; 931 u32 size; 932 933 if (!_ep) 934 return; 935 ep = container_of(_ep, struct goku_ep, ep); 936 VDBG(ep->dev, "%s %s\n", __func__, ep->ep.name); 937 938 /* don't change EPxSTATUS_EP_INVALID to READY */ 939 if (!ep->desc && ep->num != 0) { 940 DBG(ep->dev, "%s %s inactive?\n", __func__, ep->ep.name); 941 return; 942 } 943 944 regs = ep->dev->regs; 945 size = readl(®s->EPxSizeLA[ep->num]); 946 size &= DATASIZE; 947 948 /* Non-desirable behavior: FIFO_CLEAR also clears the 949 * endpoint halt feature. For OUT, we _could_ just read 950 * the bytes out (PIO, if !ep->dma); for in, no choice. 951 */ 952 if (size) 953 command(regs, COMMAND_FIFO_CLEAR, ep->num); 954} 955 956static struct usb_ep_ops goku_ep_ops = { 957 .enable = goku_ep_enable, 958 .disable = goku_ep_disable, 959 960 .alloc_request = goku_alloc_request, 961 .free_request = goku_free_request, 962 963 .queue = goku_queue, 964 .dequeue = goku_dequeue, 965 966 .set_halt = goku_set_halt, 967 .fifo_status = goku_fifo_status, 968 .fifo_flush = goku_fifo_flush, 969}; 970 971/*-------------------------------------------------------------------------*/ 972 973static int goku_get_frame(struct usb_gadget *_gadget) 974{ 975 return -EOPNOTSUPP; 976} 977 978static const struct usb_gadget_ops goku_ops = { 979 .get_frame = goku_get_frame, 980 // no remote wakeup 981 // not selfpowered 982}; 983 984/*-------------------------------------------------------------------------*/ 985 986static inline char *dmastr(void) 987{ 988 if (use_dma == 0) 989 return "(dma disabled)"; 990 else if (use_dma == 2) 991 return "(dma IN and OUT)"; 992 else 993 return "(dma IN)"; 994} 995 996#ifdef CONFIG_USB_GADGET_DEBUG_FILES 997 998static const char proc_node_name [] = "driver/udc"; 999 1000#define FOURBITS "%s%s%s%s" 1001#define EIGHTBITS FOURBITS FOURBITS 1002 1003static void 1004dump_intmask(const char *label, u32 mask, char **next, unsigned *size) 1005{ 1006 int t; 1007 1008 /* int_status is the same format ... */ 1009 t = scnprintf(*next, *size, 1010 "%s %05X =" FOURBITS EIGHTBITS EIGHTBITS "\n", 1011 label, mask, 1012 (mask & INT_PWRDETECT) ? " power" : "", 1013 (mask & INT_SYSERROR) ? " sys" : "", 1014 (mask & INT_MSTRDEND) ? " in-dma" : "", 1015 (mask & INT_MSTWRTMOUT) ? " wrtmo" : "", 1016 1017 (mask & INT_MSTWREND) ? " out-dma" : "", 1018 (mask & INT_MSTWRSET) ? " wrset" : "", 1019 (mask & INT_ERR) ? " err" : "", 1020 (mask & INT_SOF) ? " sof" : "", 1021 1022 (mask & INT_EP3NAK) ? " ep3nak" : "", 1023 (mask & INT_EP2NAK) ? " ep2nak" : "", 1024 (mask & INT_EP1NAK) ? " ep1nak" : "", 1025 (mask & INT_EP3DATASET) ? " ep3" : "", 1026 1027 (mask & INT_EP2DATASET) ? " ep2" : "", 1028 (mask & INT_EP1DATASET) ? " ep1" : "", 1029 (mask & INT_STATUSNAK) ? " ep0snak" : "", 1030 (mask & INT_STATUS) ? " ep0status" : "", 1031 1032 (mask & INT_SETUP) ? " setup" : "", 1033 (mask & INT_ENDPOINT0) ? " ep0" : "", 1034 (mask & INT_USBRESET) ? " reset" : "", 1035 (mask & INT_SUSPEND) ? " suspend" : ""); 1036 *size -= t; 1037 *next += t; 1038} 1039 1040 1041static int 1042udc_proc_read(char *buffer, char **start, off_t off, int count, 1043 int *eof, void *_dev) 1044{ 1045 char *buf = buffer; 1046 struct goku_udc *dev = _dev; 1047 struct goku_udc_regs __iomem *regs = dev->regs; 1048 char *next = buf; 1049 unsigned size = count; 1050 unsigned long flags; 1051 int i, t, is_usb_connected; 1052 u32 tmp; 1053 1054 if (off != 0) 1055 return 0; 1056 1057 local_irq_save(flags); 1058 1059 /* basic device status */ 1060 tmp = readl(®s->power_detect); 1061 is_usb_connected = tmp & PW_DETECT; 1062 t = scnprintf(next, size, 1063 "%s - %s\n" 1064 "%s version: %s %s\n" 1065 "Gadget driver: %s\n" 1066 "Host %s, %s\n" 1067 "\n", 1068 pci_name(dev->pdev), driver_desc, 1069 driver_name, DRIVER_VERSION, dmastr(), 1070 dev->driver ? dev->driver->driver.name : "(none)", 1071 is_usb_connected 1072 ? ((tmp & PW_PULLUP) ? "full speed" : "powered") 1073 : "disconnected", 1074 ({char *state; 1075 switch(dev->ep0state){ 1076 case EP0_DISCONNECT: state = "ep0_disconnect"; break; 1077 case EP0_IDLE: state = "ep0_idle"; break; 1078 case EP0_IN: state = "ep0_in"; break; 1079 case EP0_OUT: state = "ep0_out"; break; 1080 case EP0_STATUS: state = "ep0_status"; break; 1081 case EP0_STALL: state = "ep0_stall"; break; 1082 case EP0_SUSPEND: state = "ep0_suspend"; break; 1083 default: state = "ep0_?"; break; 1084 } state; }) 1085 ); 1086 size -= t; 1087 next += t; 1088 1089 dump_intmask("int_status", readl(®s->int_status), &next, &size); 1090 dump_intmask("int_enable", readl(®s->int_enable), &next, &size); 1091 1092 if (!is_usb_connected || !dev->driver || (tmp & PW_PULLUP) == 0) 1093 goto done; 1094 1095 /* registers for (active) device and ep0 */ 1096 t = scnprintf(next, size, "\nirqs %lu\ndataset %02x " 1097 "single.bcs %02x.%02x state %x addr %u\n", 1098 dev->irqs, readl(®s->DataSet), 1099 readl(®s->EPxSingle), readl(®s->EPxBCS), 1100 readl(®s->UsbState), 1101 readl(®s->address)); 1102 size -= t; 1103 next += t; 1104 1105 tmp = readl(®s->dma_master); 1106 t = scnprintf(next, size, 1107 "dma %03X =" EIGHTBITS "%s %s\n", tmp, 1108 (tmp & MST_EOPB_DIS) ? " eopb-" : "", 1109 (tmp & MST_EOPB_ENA) ? " eopb+" : "", 1110 (tmp & MST_TIMEOUT_DIS) ? " tmo-" : "", 1111 (tmp & MST_TIMEOUT_ENA) ? " tmo+" : "", 1112 1113 (tmp & MST_RD_EOPB) ? " eopb" : "", 1114 (tmp & MST_RD_RESET) ? " in_reset" : "", 1115 (tmp & MST_WR_RESET) ? " out_reset" : "", 1116 (tmp & MST_RD_ENA) ? " IN" : "", 1117 1118 (tmp & MST_WR_ENA) ? " OUT" : "", 1119 (tmp & MST_CONNECTION) 1120 ? "ep1in/ep2out" 1121 : "ep1out/ep2in"); 1122 size -= t; 1123 next += t; 1124 1125 /* dump endpoint queues */ 1126 for (i = 0; i < 4; i++) { 1127 struct goku_ep *ep = &dev->ep [i]; 1128 struct goku_request *req; 1129 1130 if (i && !ep->desc) 1131 continue; 1132 1133 tmp = readl(ep->reg_status); 1134 t = scnprintf(next, size, 1135 "%s %s max %u %s, irqs %lu, " 1136 "status %02x (%s) " FOURBITS "\n", 1137 ep->ep.name, 1138 ep->is_in ? "in" : "out", 1139 ep->ep.maxpacket, 1140 ep->dma ? "dma" : "pio", 1141 ep->irqs, 1142 tmp, ({ char *s; 1143 switch (tmp & EPxSTATUS_EP_MASK) { 1144 case EPxSTATUS_EP_READY: 1145 s = "ready"; break; 1146 case EPxSTATUS_EP_DATAIN: 1147 s = "packet"; break; 1148 case EPxSTATUS_EP_FULL: 1149 s = "full"; break; 1150 case EPxSTATUS_EP_TX_ERR: // host will retry 1151 s = "tx_err"; break; 1152 case EPxSTATUS_EP_RX_ERR: 1153 s = "rx_err"; break; 1154 case EPxSTATUS_EP_BUSY: /* ep0 only */ 1155 s = "busy"; break; 1156 case EPxSTATUS_EP_STALL: 1157 s = "stall"; break; 1158 case EPxSTATUS_EP_INVALID: // these "can't happen" 1159 s = "invalid"; break; 1160 default: 1161 s = "?"; break; 1162 }; s; }), 1163 (tmp & EPxSTATUS_TOGGLE) ? "data1" : "data0", 1164 (tmp & EPxSTATUS_SUSPEND) ? " suspend" : "", 1165 (tmp & EPxSTATUS_FIFO_DISABLE) ? " disable" : "", 1166 (tmp & EPxSTATUS_STAGE_ERROR) ? " ep0stat" : "" 1167 ); 1168 if (t <= 0 || t > size) 1169 goto done; 1170 size -= t; 1171 next += t; 1172 1173 if (list_empty(&ep->queue)) { 1174 t = scnprintf(next, size, "\t(nothing queued)\n"); 1175 if (t <= 0 || t > size) 1176 goto done; 1177 size -= t; 1178 next += t; 1179 continue; 1180 } 1181 list_for_each_entry(req, &ep->queue, queue) { 1182 if (ep->dma && req->queue.prev == &ep->queue) { 1183 if (i == UDC_MSTRD_ENDPOINT) 1184 tmp = readl(®s->in_dma_current); 1185 else 1186 tmp = readl(®s->out_dma_current); 1187 tmp -= req->req.dma; 1188 tmp++; 1189 } else 1190 tmp = req->req.actual; 1191 1192 t = scnprintf(next, size, 1193 "\treq %p len %u/%u buf %p\n", 1194 &req->req, tmp, req->req.length, 1195 req->req.buf); 1196 if (t <= 0 || t > size) 1197 goto done; 1198 size -= t; 1199 next += t; 1200 } 1201 } 1202 1203done: 1204 local_irq_restore(flags); 1205 *eof = 1; 1206 return count - size; 1207} 1208 1209#endif /* CONFIG_USB_GADGET_DEBUG_FILES */ 1210 1211/*-------------------------------------------------------------------------*/ 1212 1213static void udc_reinit (struct goku_udc *dev) 1214{ 1215 static char *names [] = { "ep0", "ep1-bulk", "ep2-bulk", "ep3-bulk" }; 1216 1217 unsigned i; 1218 1219 INIT_LIST_HEAD (&dev->gadget.ep_list); 1220 dev->gadget.ep0 = &dev->ep [0].ep; 1221 dev->gadget.speed = USB_SPEED_UNKNOWN; 1222 dev->ep0state = EP0_DISCONNECT; 1223 dev->irqs = 0; 1224 1225 for (i = 0; i < 4; i++) { 1226 struct goku_ep *ep = &dev->ep[i]; 1227 1228 ep->num = i; 1229 ep->ep.name = names[i]; 1230 ep->reg_fifo = &dev->regs->ep_fifo [i]; 1231 ep->reg_status = &dev->regs->ep_status [i]; 1232 ep->reg_mode = &dev->regs->ep_mode[i]; 1233 1234 ep->ep.ops = &goku_ep_ops; 1235 list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list); 1236 ep->dev = dev; 1237 INIT_LIST_HEAD (&ep->queue); 1238 1239 ep_reset(NULL, ep); 1240 } 1241 1242 dev->ep[0].reg_mode = NULL; 1243 dev->ep[0].ep.maxpacket = MAX_EP0_SIZE; 1244 list_del_init (&dev->ep[0].ep.ep_list); 1245} 1246 1247static void udc_reset(struct goku_udc *dev) 1248{ 1249 struct goku_udc_regs __iomem *regs = dev->regs; 1250 1251 writel(0, ®s->power_detect); 1252 writel(0, ®s->int_enable); 1253 readl(®s->int_enable); 1254 dev->int_enable = 0; 1255 1256 /* deassert reset, leave USB D+ at hi-Z (no pullup) 1257 * don't let INT_PWRDETECT sequence begin 1258 */ 1259 udelay(250); 1260 writel(PW_RESETB, ®s->power_detect); 1261 readl(®s->int_enable); 1262} 1263 1264static void ep0_start(struct goku_udc *dev) 1265{ 1266 struct goku_udc_regs __iomem *regs = dev->regs; 1267 unsigned i; 1268 1269 VDBG(dev, "%s\n", __func__); 1270 1271 udc_reset(dev); 1272 udc_reinit (dev); 1273 //writel(MST_EOPB_ENA | MST_TIMEOUT_ENA, ®s->dma_master); 1274 1275 /* hw handles set_address, set_feature, get_status; maybe more */ 1276 writel( G_REQMODE_SET_INTF | G_REQMODE_GET_INTF 1277 | G_REQMODE_SET_CONF | G_REQMODE_GET_CONF 1278 | G_REQMODE_GET_DESC 1279 | G_REQMODE_CLEAR_FEAT 1280 , ®s->reqmode); 1281 1282 for (i = 0; i < 4; i++) 1283 dev->ep[i].irqs = 0; 1284 1285 /* can't modify descriptors after writing UsbReady */ 1286 for (i = 0; i < DESC_LEN; i++) 1287 writel(0, ®s->descriptors[i]); 1288 writel(0, ®s->UsbReady); 1289 1290 /* expect ep0 requests when the host drops reset */ 1291 writel(PW_RESETB | PW_PULLUP, ®s->power_detect); 1292 dev->int_enable = INT_DEVWIDE | INT_EP0; 1293 writel(dev->int_enable, &dev->regs->int_enable); 1294 readl(®s->int_enable); 1295 dev->gadget.speed = USB_SPEED_FULL; 1296 dev->ep0state = EP0_IDLE; 1297} 1298 1299static void udc_enable(struct goku_udc *dev) 1300{ 1301 /* start enumeration now, or after power detect irq */ 1302 if (readl(&dev->regs->power_detect) & PW_DETECT) 1303 ep0_start(dev); 1304 else { 1305 DBG(dev, "%s\n", __func__); 1306 dev->int_enable = INT_PWRDETECT; 1307 writel(dev->int_enable, &dev->regs->int_enable); 1308 } 1309} 1310 1311/*-------------------------------------------------------------------------*/ 1312 1313/* keeping it simple: 1314 * - one bus driver, initted first; 1315 * - one function driver, initted second 1316 */ 1317 1318static struct goku_udc *the_controller; 1319 1320/* when a driver is successfully registered, it will receive 1321 * control requests including set_configuration(), which enables 1322 * non-control requests. then usb traffic follows until a 1323 * disconnect is reported. then a host may connect again, or 1324 * the driver might get unbound. 1325 */ 1326int usb_gadget_register_driver(struct usb_gadget_driver *driver) 1327{ 1328 struct goku_udc *dev = the_controller; 1329 int retval; 1330 1331 if (!driver 1332 || driver->speed < USB_SPEED_FULL 1333 || !driver->bind 1334 || !driver->disconnect 1335 || !driver->setup) 1336 return -EINVAL; 1337 if (!dev) 1338 return -ENODEV; 1339 if (dev->driver) 1340 return -EBUSY; 1341 1342 /* hook up the driver */ 1343 driver->driver.bus = NULL; 1344 dev->driver = driver; 1345 dev->gadget.dev.driver = &driver->driver; 1346 retval = driver->bind(&dev->gadget); 1347 if (retval) { 1348 DBG(dev, "bind to driver %s --> error %d\n", 1349 driver->driver.name, retval); 1350 dev->driver = NULL; 1351 dev->gadget.dev.driver = NULL; 1352 return retval; 1353 } 1354 1355 /* then enable host detection and ep0; and we're ready 1356 * for set_configuration as well as eventual disconnect. 1357 */ 1358 udc_enable(dev); 1359 1360 DBG(dev, "registered gadget driver '%s'\n", driver->driver.name); 1361 return 0; 1362} 1363EXPORT_SYMBOL(usb_gadget_register_driver); 1364 1365static void 1366stop_activity(struct goku_udc *dev, struct usb_gadget_driver *driver) 1367{ 1368 unsigned i; 1369 1370 DBG (dev, "%s\n", __func__); 1371 1372 if (dev->gadget.speed == USB_SPEED_UNKNOWN) 1373 driver = NULL; 1374 1375 /* disconnect gadget driver after quiesceing hw and the driver */ 1376 udc_reset (dev); 1377 for (i = 0; i < 4; i++) 1378 nuke(&dev->ep [i], -ESHUTDOWN); 1379 if (driver) { 1380 spin_unlock(&dev->lock); 1381 driver->disconnect(&dev->gadget); 1382 spin_lock(&dev->lock); 1383 } 1384 1385 if (dev->driver) 1386 udc_enable(dev); 1387} 1388 1389int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) 1390{ 1391 struct goku_udc *dev = the_controller; 1392 unsigned long flags; 1393 1394 if (!dev) 1395 return -ENODEV; 1396 if (!driver || driver != dev->driver || !driver->unbind) 1397 return -EINVAL; 1398 1399 spin_lock_irqsave(&dev->lock, flags); 1400 dev->driver = NULL; 1401 stop_activity(dev, driver); 1402 spin_unlock_irqrestore(&dev->lock, flags); 1403 1404 driver->unbind(&dev->gadget); 1405 dev->gadget.dev.driver = NULL; 1406 1407 DBG(dev, "unregistered driver '%s'\n", driver->driver.name); 1408 return 0; 1409} 1410EXPORT_SYMBOL(usb_gadget_unregister_driver); 1411 1412 1413/*-------------------------------------------------------------------------*/ 1414 1415static void ep0_setup(struct goku_udc *dev) 1416{ 1417 struct goku_udc_regs __iomem *regs = dev->regs; 1418 struct usb_ctrlrequest ctrl; 1419 int tmp; 1420 1421 /* read SETUP packet and enter DATA stage */ 1422 ctrl.bRequestType = readl(®s->bRequestType); 1423 ctrl.bRequest = readl(®s->bRequest); 1424 ctrl.wValue = cpu_to_le16((readl(®s->wValueH) << 8) 1425 | readl(®s->wValueL)); 1426 ctrl.wIndex = cpu_to_le16((readl(®s->wIndexH) << 8) 1427 | readl(®s->wIndexL)); 1428 ctrl.wLength = cpu_to_le16((readl(®s->wLengthH) << 8) 1429 | readl(®s->wLengthL)); 1430 writel(0, ®s->SetupRecv); 1431 1432 nuke(&dev->ep[0], 0); 1433 dev->ep[0].stopped = 0; 1434 if (likely(ctrl.bRequestType & USB_DIR_IN)) { 1435 dev->ep[0].is_in = 1; 1436 dev->ep0state = EP0_IN; 1437 /* detect early status stages */ 1438 writel(ICONTROL_STATUSNAK, &dev->regs->IntControl); 1439 } else { 1440 dev->ep[0].is_in = 0; 1441 dev->ep0state = EP0_OUT; 1442 1443 /* NOTE: CLEAR_FEATURE is done in software so that we can 1444 * synchronize transfer restarts after bulk IN stalls. data 1445 * won't even enter the fifo until the halt is cleared. 1446 */ 1447 switch (ctrl.bRequest) { 1448 case USB_REQ_CLEAR_FEATURE: 1449 switch (ctrl.bRequestType) { 1450 case USB_RECIP_ENDPOINT: 1451 tmp = le16_to_cpu(ctrl.wIndex) & 0x0f; 1452 /* active endpoint */ 1453 if (tmp > 3 || (!dev->ep[tmp].desc && tmp != 0)) 1454 goto stall; 1455 if (ctrl.wIndex & cpu_to_le16( 1456 USB_DIR_IN)) { 1457 if (!dev->ep[tmp].is_in) 1458 goto stall; 1459 } else { 1460 if (dev->ep[tmp].is_in) 1461 goto stall; 1462 } 1463 if (ctrl.wValue != cpu_to_le16( 1464 USB_ENDPOINT_HALT)) 1465 goto stall; 1466 if (tmp) 1467 goku_clear_halt(&dev->ep[tmp]); 1468succeed: 1469 /* start ep0out status stage */ 1470 writel(~(1<<0), ®s->EOP); 1471 dev->ep[0].stopped = 1; 1472 dev->ep0state = EP0_STATUS; 1473 return; 1474 case USB_RECIP_DEVICE: 1475 /* device remote wakeup: always clear */ 1476 if (ctrl.wValue != cpu_to_le16(1)) 1477 goto stall; 1478 VDBG(dev, "clear dev remote wakeup\n"); 1479 goto succeed; 1480 case USB_RECIP_INTERFACE: 1481 goto stall; 1482 default: /* pass to gadget driver */ 1483 break; 1484 } 1485 break; 1486 default: 1487 break; 1488 } 1489 } 1490 1491#ifdef USB_TRACE 1492 VDBG(dev, "SETUP %02x.%02x v%04x i%04x l%04x\n", 1493 ctrl.bRequestType, ctrl.bRequest, 1494 le16_to_cpu(ctrl.wValue), le16_to_cpu(ctrl.wIndex), 1495 le16_to_cpu(ctrl.wLength)); 1496#endif 1497 1498 /* hw wants to know when we're configured (or not) */ 1499 dev->req_config = (ctrl.bRequest == USB_REQ_SET_CONFIGURATION 1500 && ctrl.bRequestType == USB_RECIP_DEVICE); 1501 if (unlikely(dev->req_config)) 1502 dev->configured = (ctrl.wValue != cpu_to_le16(0)); 1503 1504 /* delegate everything to the gadget driver. 1505 * it may respond after this irq handler returns. 1506 */ 1507 spin_unlock (&dev->lock); 1508 tmp = dev->driver->setup(&dev->gadget, &ctrl); 1509 spin_lock (&dev->lock); 1510 if (unlikely(tmp < 0)) { 1511stall: 1512#ifdef USB_TRACE 1513 VDBG(dev, "req %02x.%02x protocol STALL; err %d\n", 1514 ctrl.bRequestType, ctrl.bRequest, tmp); 1515#endif 1516 command(regs, COMMAND_STALL, 0); 1517 dev->ep[0].stopped = 1; 1518 dev->ep0state = EP0_STALL; 1519 } 1520 1521 /* expect at least one data or status stage irq */ 1522} 1523 1524#define ACK(irqbit) { \ 1525 stat &= ~irqbit; \ 1526 writel(~irqbit, ®s->int_status); \ 1527 handled = 1; \ 1528 } 1529 1530static irqreturn_t goku_irq(int irq, void *_dev) 1531{ 1532 struct goku_udc *dev = _dev; 1533 struct goku_udc_regs __iomem *regs = dev->regs; 1534 struct goku_ep *ep; 1535 u32 stat, handled = 0; 1536 unsigned i, rescans = 5; 1537 1538 spin_lock(&dev->lock); 1539 1540rescan: 1541 stat = readl(®s->int_status) & dev->int_enable; 1542 if (!stat) 1543 goto done; 1544 dev->irqs++; 1545 1546 /* device-wide irqs */ 1547 if (unlikely(stat & INT_DEVWIDE)) { 1548 if (stat & INT_SYSERROR) { 1549 ERROR(dev, "system error\n"); 1550 stop_activity(dev, dev->driver); 1551 stat = 0; 1552 handled = 1; 1553 dev->driver = NULL; 1554 goto done; 1555 } 1556 if (stat & INT_PWRDETECT) { 1557 writel(~stat, ®s->int_status); 1558 if (readl(&dev->regs->power_detect) & PW_DETECT) { 1559 VDBG(dev, "connect\n"); 1560 ep0_start(dev); 1561 } else { 1562 DBG(dev, "disconnect\n"); 1563 if (dev->gadget.speed == USB_SPEED_FULL) 1564 stop_activity(dev, dev->driver); 1565 dev->ep0state = EP0_DISCONNECT; 1566 dev->int_enable = INT_DEVWIDE; 1567 writel(dev->int_enable, &dev->regs->int_enable); 1568 } 1569 stat = 0; 1570 handled = 1; 1571 goto done; 1572 } 1573 if (stat & INT_SUSPEND) { 1574 ACK(INT_SUSPEND); 1575 if (readl(®s->ep_status[0]) & EPxSTATUS_SUSPEND) { 1576 switch (dev->ep0state) { 1577 case EP0_DISCONNECT: 1578 case EP0_SUSPEND: 1579 goto pm_next; 1580 default: 1581 break; 1582 } 1583 DBG(dev, "USB suspend\n"); 1584 dev->ep0state = EP0_SUSPEND; 1585 if (dev->gadget.speed != USB_SPEED_UNKNOWN 1586 && dev->driver 1587 && dev->driver->suspend) { 1588 spin_unlock(&dev->lock); 1589 dev->driver->suspend(&dev->gadget); 1590 spin_lock(&dev->lock); 1591 } 1592 } else { 1593 if (dev->ep0state != EP0_SUSPEND) { 1594 DBG(dev, "bogus USB resume %d\n", 1595 dev->ep0state); 1596 goto pm_next; 1597 } 1598 DBG(dev, "USB resume\n"); 1599 dev->ep0state = EP0_IDLE; 1600 if (dev->gadget.speed != USB_SPEED_UNKNOWN 1601 && dev->driver 1602 && dev->driver->resume) { 1603 spin_unlock(&dev->lock); 1604 dev->driver->resume(&dev->gadget); 1605 spin_lock(&dev->lock); 1606 } 1607 } 1608 } 1609pm_next: 1610 if (stat & INT_USBRESET) { /* hub reset done */ 1611 ACK(INT_USBRESET); 1612 INFO(dev, "USB reset done, gadget %s\n", 1613 dev->driver->driver.name); 1614 } 1615 // and INT_ERR on some endpoint's crc/bitstuff/... problem 1616 } 1617 1618 /* progress ep0 setup, data, or status stages. 1619 * no transition {EP0_STATUS, EP0_STALL} --> EP0_IDLE; saves irqs 1620 */ 1621 if (stat & INT_SETUP) { 1622 ACK(INT_SETUP); 1623 dev->ep[0].irqs++; 1624 ep0_setup(dev); 1625 } 1626 if (stat & INT_STATUSNAK) { 1627 ACK(INT_STATUSNAK|INT_ENDPOINT0); 1628 if (dev->ep0state == EP0_IN) { 1629 ep = &dev->ep[0]; 1630 ep->irqs++; 1631 nuke(ep, 0); 1632 writel(~(1<<0), ®s->EOP); 1633 dev->ep0state = EP0_STATUS; 1634 } 1635 } 1636 if (stat & INT_ENDPOINT0) { 1637 ACK(INT_ENDPOINT0); 1638 ep = &dev->ep[0]; 1639 ep->irqs++; 1640 pio_advance(ep); 1641 } 1642 1643 /* dma completion */ 1644 if (stat & INT_MSTRDEND) { /* IN */ 1645 ACK(INT_MSTRDEND); 1646 ep = &dev->ep[UDC_MSTRD_ENDPOINT]; 1647 ep->irqs++; 1648 dma_advance(dev, ep); 1649 } 1650 if (stat & INT_MSTWREND) { /* OUT */ 1651 ACK(INT_MSTWREND); 1652 ep = &dev->ep[UDC_MSTWR_ENDPOINT]; 1653 ep->irqs++; 1654 dma_advance(dev, ep); 1655 } 1656 if (stat & INT_MSTWRTMOUT) { /* OUT */ 1657 ACK(INT_MSTWRTMOUT); 1658 ep = &dev->ep[UDC_MSTWR_ENDPOINT]; 1659 ep->irqs++; 1660 ERROR(dev, "%s write timeout ?\n", ep->ep.name); 1661 // reset dma? then dma_advance() 1662 } 1663 1664 /* pio */ 1665 for (i = 1; i < 4; i++) { 1666 u32 tmp = INT_EPxDATASET(i); 1667 1668 if (!(stat & tmp)) 1669 continue; 1670 ep = &dev->ep[i]; 1671 pio_advance(ep); 1672 if (list_empty (&ep->queue)) 1673 pio_irq_disable(dev, regs, i); 1674 stat &= ~tmp; 1675 handled = 1; 1676 ep->irqs++; 1677 } 1678 1679 if (rescans--) 1680 goto rescan; 1681 1682done: 1683 (void)readl(®s->int_enable); 1684 spin_unlock(&dev->lock); 1685 if (stat) 1686 DBG(dev, "unhandled irq status: %05x (%05x, %05x)\n", stat, 1687 readl(®s->int_status), dev->int_enable); 1688 return IRQ_RETVAL(handled); 1689} 1690 1691#undef ACK 1692 1693/*-------------------------------------------------------------------------*/ 1694 1695static void gadget_release(struct device *_dev) 1696{ 1697 struct goku_udc *dev = dev_get_drvdata(_dev); 1698 1699 kfree(dev); 1700} 1701 1702/* tear down the binding between this driver and the pci device */ 1703 1704static void goku_remove(struct pci_dev *pdev) 1705{ 1706 struct goku_udc *dev = pci_get_drvdata(pdev); 1707 1708 DBG(dev, "%s\n", __func__); 1709 1710 BUG_ON(dev->driver); 1711 1712#ifdef CONFIG_USB_GADGET_DEBUG_FILES 1713 remove_proc_entry(proc_node_name, NULL); 1714#endif 1715 if (dev->regs) 1716 udc_reset(dev); 1717 if (dev->got_irq) 1718 free_irq(pdev->irq, dev); 1719 if (dev->regs) 1720 iounmap(dev->regs); 1721 if (dev->got_region) 1722 release_mem_region(pci_resource_start (pdev, 0), 1723 pci_resource_len (pdev, 0)); 1724 if (dev->enabled) 1725 pci_disable_device(pdev); 1726 device_unregister(&dev->gadget.dev); 1727 1728 pci_set_drvdata(pdev, NULL); 1729 dev->regs = NULL; 1730 the_controller = NULL; 1731 1732 INFO(dev, "unbind\n"); 1733} 1734 1735/* wrap this driver around the specified pci device, but 1736 * don't respond over USB until a gadget driver binds to us. 1737 */ 1738 1739static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id) 1740{ 1741 struct goku_udc *dev = NULL; 1742 unsigned long resource, len; 1743 void __iomem *base = NULL; 1744 int retval; 1745 1746 /* if you want to support more than one controller in a system, 1747 * usb_gadget_driver_{register,unregister}() must change. 1748 */ 1749 if (the_controller) { 1750 pr_warning("ignoring %s\n", pci_name(pdev)); 1751 return -EBUSY; 1752 } 1753 if (!pdev->irq) { 1754 printk(KERN_ERR "Check PCI %s IRQ setup!\n", pci_name(pdev)); 1755 retval = -ENODEV; 1756 goto done; 1757 } 1758 1759 /* alloc, and start init */ 1760 dev = kzalloc (sizeof *dev, GFP_KERNEL); 1761 if (dev == NULL){ 1762 pr_debug("enomem %s\n", pci_name(pdev)); 1763 retval = -ENOMEM; 1764 goto done; 1765 } 1766 1767 spin_lock_init(&dev->lock); 1768 dev->pdev = pdev; 1769 dev->gadget.ops = &goku_ops; 1770 1771 /* the "gadget" abstracts/virtualizes the controller */ 1772 dev_set_name(&dev->gadget.dev, "gadget"); 1773 dev->gadget.dev.parent = &pdev->dev; 1774 dev->gadget.dev.dma_mask = pdev->dev.dma_mask; 1775 dev->gadget.dev.release = gadget_release; 1776 dev->gadget.name = driver_name; 1777 1778 /* now all the pci goodies ... */ 1779 retval = pci_enable_device(pdev); 1780 if (retval < 0) { 1781 DBG(dev, "can't enable, %d\n", retval); 1782 goto done; 1783 } 1784 dev->enabled = 1; 1785 1786 resource = pci_resource_start(pdev, 0); 1787 len = pci_resource_len(pdev, 0); 1788 if (!request_mem_region(resource, len, driver_name)) { 1789 DBG(dev, "controller already in use\n"); 1790 retval = -EBUSY; 1791 goto done; 1792 } 1793 dev->got_region = 1; 1794 1795 base = ioremap_nocache(resource, len); 1796 if (base == NULL) { 1797 DBG(dev, "can't map memory\n"); 1798 retval = -EFAULT; 1799 goto done; 1800 } 1801 dev->regs = (struct goku_udc_regs __iomem *) base; 1802 1803 pci_set_drvdata(pdev, dev); 1804 INFO(dev, "%s\n", driver_desc); 1805 INFO(dev, "version: " DRIVER_VERSION " %s\n", dmastr()); 1806 INFO(dev, "irq %d, pci mem %p\n", pdev->irq, base); 1807 1808 /* init to known state, then setup irqs */ 1809 udc_reset(dev); 1810 udc_reinit (dev); 1811 if (request_irq(pdev->irq, goku_irq, IRQF_SHARED/*|IRQF_SAMPLE_RANDOM*/, 1812 driver_name, dev) != 0) { 1813 DBG(dev, "request interrupt %d failed\n", pdev->irq); 1814 retval = -EBUSY; 1815 goto done; 1816 } 1817 dev->got_irq = 1; 1818 if (use_dma) 1819 pci_set_master(pdev); 1820 1821 1822#ifdef CONFIG_USB_GADGET_DEBUG_FILES 1823 create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev); 1824#endif 1825 1826 /* done */ 1827 the_controller = dev; 1828 retval = device_register(&dev->gadget.dev); 1829 if (retval == 0) 1830 return 0; 1831 1832done: 1833 if (dev) 1834 goku_remove (pdev); 1835 return retval; 1836} 1837 1838 1839/*-------------------------------------------------------------------------*/ 1840 1841static const struct pci_device_id pci_ids[] = { { 1842 .class = ((PCI_CLASS_SERIAL_USB << 8) | 0xfe), 1843 .class_mask = ~0, 1844 .vendor = 0x102f, /* Toshiba */ 1845 .device = 0x0107, /* this UDC */ 1846 .subvendor = PCI_ANY_ID, 1847 .subdevice = PCI_ANY_ID, 1848 1849}, { /* end: all zeroes */ } 1850}; 1851MODULE_DEVICE_TABLE (pci, pci_ids); 1852 1853static struct pci_driver goku_pci_driver = { 1854 .name = (char *) driver_name, 1855 .id_table = pci_ids, 1856 1857 .probe = goku_probe, 1858 .remove = goku_remove, 1859 1860}; 1861 1862static int __init init (void) 1863{ 1864 return pci_register_driver (&goku_pci_driver); 1865} 1866module_init (init); 1867 1868static void __exit cleanup (void) 1869{ 1870 pci_unregister_driver (&goku_pci_driver); 1871} 1872module_exit (cleanup); 1873