1/* 2 * linux/drivers/usb/gadget/lh7a40x_udc.c 3 * Sharp LH7A40x on-chip full speed USB device controllers 4 * 5 * Copyright (C) 2004 Mikko Lahteenmaki, Nordic ID 6 * Copyright (C) 2004 Bo Henriksen, Nordic ID 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23 24#include <linux/platform_device.h> 25 26#include "lh7a40x_udc.h" 27 28//#define DEBUG printk 29//#define DEBUG_EP0 printk 30//#define DEBUG_SETUP printk 31 32#ifndef DEBUG_EP0 33# define DEBUG_EP0(fmt,args...) 34#endif 35#ifndef DEBUG_SETUP 36# define DEBUG_SETUP(fmt,args...) 37#endif 38#ifndef DEBUG 39# define NO_STATES 40# define DEBUG(fmt,args...) 41#endif 42 43#define DRIVER_DESC "LH7A40x USB Device Controller" 44#define DRIVER_VERSION __DATE__ 45 46#ifndef _BIT 47#define _BIT(x) (1<<(x)) 48#endif 49 50struct lh7a40x_udc *the_controller; 51 52static const char driver_name[] = "lh7a40x_udc"; 53static const char driver_desc[] = DRIVER_DESC; 54static const char ep0name[] = "ep0-control"; 55 56/* 57 Local definintions. 58*/ 59 60#ifndef NO_STATES 61static char *state_names[] = { 62 "WAIT_FOR_SETUP", 63 "DATA_STATE_XMIT", 64 "DATA_STATE_NEED_ZLP", 65 "WAIT_FOR_OUT_STATUS", 66 "DATA_STATE_RECV" 67}; 68#endif 69 70/* 71 Local declarations. 72*/ 73static int lh7a40x_ep_enable(struct usb_ep *ep, 74 const struct usb_endpoint_descriptor *); 75static int lh7a40x_ep_disable(struct usb_ep *ep); 76static struct usb_request *lh7a40x_alloc_request(struct usb_ep *ep, gfp_t); 77static void lh7a40x_free_request(struct usb_ep *ep, struct usb_request *); 78static void *lh7a40x_alloc_buffer(struct usb_ep *ep, unsigned, dma_addr_t *, 79 gfp_t); 80static void lh7a40x_free_buffer(struct usb_ep *ep, void *, dma_addr_t, 81 unsigned); 82static int lh7a40x_queue(struct usb_ep *ep, struct usb_request *, gfp_t); 83static int lh7a40x_dequeue(struct usb_ep *ep, struct usb_request *); 84static int lh7a40x_set_halt(struct usb_ep *ep, int); 85static int lh7a40x_fifo_status(struct usb_ep *ep); 86static void lh7a40x_fifo_flush(struct usb_ep *ep); 87static void lh7a40x_ep0_kick(struct lh7a40x_udc *dev, struct lh7a40x_ep *ep); 88static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr); 89 90static void done(struct lh7a40x_ep *ep, struct lh7a40x_request *req, 91 int status); 92static void pio_irq_enable(int bEndpointAddress); 93static void pio_irq_disable(int bEndpointAddress); 94static void stop_activity(struct lh7a40x_udc *dev, 95 struct usb_gadget_driver *driver); 96static void flush(struct lh7a40x_ep *ep); 97static void udc_enable(struct lh7a40x_udc *dev); 98static void udc_set_address(struct lh7a40x_udc *dev, unsigned char address); 99 100static struct usb_ep_ops lh7a40x_ep_ops = { 101 .enable = lh7a40x_ep_enable, 102 .disable = lh7a40x_ep_disable, 103 104 .alloc_request = lh7a40x_alloc_request, 105 .free_request = lh7a40x_free_request, 106 107 .alloc_buffer = lh7a40x_alloc_buffer, 108 .free_buffer = lh7a40x_free_buffer, 109 110 .queue = lh7a40x_queue, 111 .dequeue = lh7a40x_dequeue, 112 113 .set_halt = lh7a40x_set_halt, 114 .fifo_status = lh7a40x_fifo_status, 115 .fifo_flush = lh7a40x_fifo_flush, 116}; 117 118/* Inline code */ 119 120static __inline__ int write_packet(struct lh7a40x_ep *ep, 121 struct lh7a40x_request *req, int max) 122{ 123 u8 *buf; 124 int length, count; 125 volatile u32 *fifo = (volatile u32 *)ep->fifo; 126 127 buf = req->req.buf + req->req.actual; 128 prefetch(buf); 129 130 length = req->req.length - req->req.actual; 131 length = min(length, max); 132 req->req.actual += length; 133 134 DEBUG("Write %d (max %d), fifo %p\n", length, max, fifo); 135 136 count = length; 137 while (count--) { 138 *fifo = *buf++; 139 } 140 141 return length; 142} 143 144static __inline__ void usb_set_index(u32 ep) 145{ 146 *(volatile u32 *)io_p2v(USB_INDEX) = ep; 147} 148 149static __inline__ u32 usb_read(u32 port) 150{ 151 return *(volatile u32 *)io_p2v(port); 152} 153 154static __inline__ void usb_write(u32 val, u32 port) 155{ 156 *(volatile u32 *)io_p2v(port) = val; 157} 158 159static __inline__ void usb_set(u32 val, u32 port) 160{ 161 volatile u32 *ioport = (volatile u32 *)io_p2v(port); 162 u32 after = (*ioport) | val; 163 *ioport = after; 164} 165 166static __inline__ void usb_clear(u32 val, u32 port) 167{ 168 volatile u32 *ioport = (volatile u32 *)io_p2v(port); 169 u32 after = (*ioport) & ~val; 170 *ioport = after; 171} 172 173/*-------------------------------------------------------------------------*/ 174 175#define GPIO_PORTC_DR (0x80000E08) 176#define GPIO_PORTC_DDR (0x80000E18) 177#define GPIO_PORTC_PDR (0x80000E70) 178 179/* get port C pin data register */ 180#define get_portc_pdr(bit) ((usb_read(GPIO_PORTC_PDR) & _BIT(bit)) != 0) 181/* get port C data direction register */ 182#define get_portc_ddr(bit) ((usb_read(GPIO_PORTC_DDR) & _BIT(bit)) != 0) 183/* set port C data register */ 184#define set_portc_dr(bit, val) (val ? usb_set(_BIT(bit), GPIO_PORTC_DR) : usb_clear(_BIT(bit), GPIO_PORTC_DR)) 185/* set port C data direction register */ 186#define set_portc_ddr(bit, val) (val ? usb_set(_BIT(bit), GPIO_PORTC_DDR) : usb_clear(_BIT(bit), GPIO_PORTC_DDR)) 187 188/* 189 * LPD7A404 GPIO's: 190 * Port C bit 1 = USB Port 1 Power Enable 191 * Port C bit 2 = USB Port 1 Data Carrier Detect 192 */ 193#define is_usb_connected() get_portc_pdr(2) 194 195#ifdef CONFIG_USB_GADGET_DEBUG_FILES 196 197static const char proc_node_name[] = "driver/udc"; 198 199static int 200udc_proc_read(char *page, char **start, off_t off, int count, 201 int *eof, void *_dev) 202{ 203 char *buf = page; 204 struct lh7a40x_udc *dev = _dev; 205 char *next = buf; 206 unsigned size = count; 207 unsigned long flags; 208 int t; 209 210 if (off != 0) 211 return 0; 212 213 local_irq_save(flags); 214 215 /* basic device status */ 216 t = scnprintf(next, size, 217 DRIVER_DESC "\n" 218 "%s version: %s\n" 219 "Gadget driver: %s\n" 220 "Host: %s\n\n", 221 driver_name, DRIVER_VERSION, 222 dev->driver ? dev->driver->driver.name : "(none)", 223 is_usb_connected()? "full speed" : "disconnected"); 224 size -= t; 225 next += t; 226 227 t = scnprintf(next, size, 228 "GPIO:\n" 229 " Port C bit 1: %d, dir %d\n" 230 " Port C bit 2: %d, dir %d\n\n", 231 get_portc_pdr(1), get_portc_ddr(1), 232 get_portc_pdr(2), get_portc_ddr(2) 233 ); 234 size -= t; 235 next += t; 236 237 t = scnprintf(next, size, 238 "DCP pullup: %d\n\n", 239 (usb_read(USB_PM) & PM_USB_DCP) != 0); 240 size -= t; 241 next += t; 242 243 local_irq_restore(flags); 244 *eof = 1; 245 return count - size; 246} 247 248#define create_proc_files() create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev) 249#define remove_proc_files() remove_proc_entry(proc_node_name, NULL) 250 251#else /* !CONFIG_USB_GADGET_DEBUG_FILES */ 252 253#define create_proc_files() do {} while (0) 254#define remove_proc_files() do {} while (0) 255 256#endif /* CONFIG_USB_GADGET_DEBUG_FILES */ 257 258/* 259 * udc_disable - disable USB device controller 260 */ 261static void udc_disable(struct lh7a40x_udc *dev) 262{ 263 DEBUG("%s, %p\n", __FUNCTION__, dev); 264 265 udc_set_address(dev, 0); 266 267 /* Disable interrupts */ 268 usb_write(0, USB_IN_INT_EN); 269 usb_write(0, USB_OUT_INT_EN); 270 usb_write(0, USB_INT_EN); 271 272 /* Disable the USB */ 273 usb_write(0, USB_PM); 274 275#ifdef CONFIG_ARCH_LH7A404 276 /* Disable USB power */ 277 set_portc_dr(1, 0); 278#endif 279 280 /* if hardware supports it, disconnect from usb */ 281 /* make_usb_disappear(); */ 282 283 dev->ep0state = WAIT_FOR_SETUP; 284 dev->gadget.speed = USB_SPEED_UNKNOWN; 285 dev->usb_address = 0; 286} 287 288/* 289 * udc_reinit - initialize software state 290 */ 291static void udc_reinit(struct lh7a40x_udc *dev) 292{ 293 u32 i; 294 295 DEBUG("%s, %p\n", __FUNCTION__, dev); 296 297 /* device/ep0 records init */ 298 INIT_LIST_HEAD(&dev->gadget.ep_list); 299 INIT_LIST_HEAD(&dev->gadget.ep0->ep_list); 300 dev->ep0state = WAIT_FOR_SETUP; 301 302 /* basic endpoint records init */ 303 for (i = 0; i < UDC_MAX_ENDPOINTS; i++) { 304 struct lh7a40x_ep *ep = &dev->ep[i]; 305 306 if (i != 0) 307 list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list); 308 309 ep->desc = 0; 310 ep->stopped = 0; 311 INIT_LIST_HEAD(&ep->queue); 312 ep->pio_irqs = 0; 313 } 314 315 /* the rest was statically initialized, and is read-only */ 316} 317 318#define BYTES2MAXP(x) (x / 8) 319#define MAXP2BYTES(x) (x * 8) 320 321/* until it's enabled, this UDC should be completely invisible 322 * to any USB host. 323 */ 324static void udc_enable(struct lh7a40x_udc *dev) 325{ 326 int ep; 327 328 DEBUG("%s, %p\n", __FUNCTION__, dev); 329 330 dev->gadget.speed = USB_SPEED_UNKNOWN; 331 332#ifdef CONFIG_ARCH_LH7A404 333 /* Set Port C bit 1 & 2 as output */ 334 set_portc_ddr(1, 1); 335 set_portc_ddr(2, 1); 336 337 /* Enable USB power */ 338 set_portc_dr(1, 0); 339#endif 340 341 /* 342 * C.f Chapter 18.1.3.1 Initializing the USB 343 */ 344 345 /* Disable the USB */ 346 usb_clear(PM_USB_ENABLE, USB_PM); 347 348 /* Reset APB & I/O sides of the USB */ 349 usb_set(USB_RESET_APB | USB_RESET_IO, USB_RESET); 350 mdelay(5); 351 usb_clear(USB_RESET_APB | USB_RESET_IO, USB_RESET); 352 353 /* Set MAXP values for each */ 354 for (ep = 0; ep < UDC_MAX_ENDPOINTS; ep++) { 355 struct lh7a40x_ep *ep_reg = &dev->ep[ep]; 356 u32 csr; 357 358 usb_set_index(ep); 359 360 switch (ep_reg->ep_type) { 361 case ep_bulk_in: 362 case ep_interrupt: 363 usb_clear(USB_IN_CSR2_USB_DMA_EN | USB_IN_CSR2_AUTO_SET, 364 ep_reg->csr2); 365 /* Fall through */ 366 case ep_control: 367 usb_write(BYTES2MAXP(ep_maxpacket(ep_reg)), 368 USB_IN_MAXP); 369 break; 370 case ep_bulk_out: 371 usb_clear(USB_OUT_CSR2_USB_DMA_EN | 372 USB_OUT_CSR2_AUTO_CLR, ep_reg->csr2); 373 usb_write(BYTES2MAXP(ep_maxpacket(ep_reg)), 374 USB_OUT_MAXP); 375 break; 376 } 377 378 /* Read & Write CSR1, just in case */ 379 csr = usb_read(ep_reg->csr1); 380 usb_write(csr, ep_reg->csr1); 381 382 flush(ep_reg); 383 } 384 385 /* Disable interrupts */ 386 usb_write(0, USB_IN_INT_EN); 387 usb_write(0, USB_OUT_INT_EN); 388 usb_write(0, USB_INT_EN); 389 390 /* Enable interrupts */ 391 usb_set(USB_IN_INT_EP0, USB_IN_INT_EN); 392 usb_set(USB_INT_RESET_INT | USB_INT_RESUME_INT, USB_INT_EN); 393 /* Dont enable rest of the interrupts */ 394 /* usb_set(USB_IN_INT_EP3 | USB_IN_INT_EP1 | USB_IN_INT_EP0, USB_IN_INT_EN); 395 usb_set(USB_OUT_INT_EP2, USB_OUT_INT_EN); */ 396 397 /* Enable SUSPEND */ 398 usb_set(PM_ENABLE_SUSPEND, USB_PM); 399 400 /* Enable the USB */ 401 usb_set(PM_USB_ENABLE, USB_PM); 402 403#ifdef CONFIG_ARCH_LH7A404 404 /* NOTE: DOES NOT WORK! */ 405 /* Let host detect UDC: 406 * Software must write a 0 to the PMR:DCP_CTRL bit to turn this 407 * transistor on and pull the USBDP pin HIGH. 408 */ 409 /* usb_clear(PM_USB_DCP, USB_PM); 410 usb_set(PM_USB_DCP, USB_PM); */ 411#endif 412} 413 414/* 415 Register entry point for the peripheral controller driver. 416*/ 417int usb_gadget_register_driver(struct usb_gadget_driver *driver) 418{ 419 struct lh7a40x_udc *dev = the_controller; 420 int retval; 421 422 DEBUG("%s: %s\n", __FUNCTION__, driver->driver.name); 423 424 if (!driver 425 || driver->speed != USB_SPEED_FULL 426 || !driver->bind 427 || !driver->disconnect 428 || !driver->setup) 429 return -EINVAL; 430 if (!dev) 431 return -ENODEV; 432 if (dev->driver) 433 return -EBUSY; 434 435 /* first hook up the driver ... */ 436 dev->driver = driver; 437 dev->gadget.dev.driver = &driver->driver; 438 439 device_add(&dev->gadget.dev); 440 retval = driver->bind(&dev->gadget); 441 if (retval) { 442 printk("%s: bind to driver %s --> error %d\n", dev->gadget.name, 443 driver->driver.name, retval); 444 device_del(&dev->gadget.dev); 445 446 dev->driver = 0; 447 dev->gadget.dev.driver = 0; 448 return retval; 449 } 450 451 /* ... then enable host detection and ep0; and we're ready 452 * for set_configuration as well as eventual disconnect. 453 * NOTE: this shouldn't power up until later. 454 */ 455 printk("%s: registered gadget driver '%s'\n", dev->gadget.name, 456 driver->driver.name); 457 458 udc_enable(dev); 459 460 return 0; 461} 462 463EXPORT_SYMBOL(usb_gadget_register_driver); 464 465/* 466 Unregister entry point for the peripheral controller driver. 467*/ 468int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) 469{ 470 struct lh7a40x_udc *dev = the_controller; 471 unsigned long flags; 472 473 if (!dev) 474 return -ENODEV; 475 if (!driver || driver != dev->driver || !driver->unbind) 476 return -EINVAL; 477 478 spin_lock_irqsave(&dev->lock, flags); 479 dev->driver = 0; 480 stop_activity(dev, driver); 481 spin_unlock_irqrestore(&dev->lock, flags); 482 483 driver->unbind(&dev->gadget); 484 device_del(&dev->gadget.dev); 485 486 udc_disable(dev); 487 488 DEBUG("unregistered gadget driver '%s'\n", driver->driver.name); 489 return 0; 490} 491 492EXPORT_SYMBOL(usb_gadget_unregister_driver); 493 494/*-------------------------------------------------------------------------*/ 495 496/** Write request to FIFO (max write == maxp size) 497 * Return: 0 = still running, 1 = completed, negative = errno 498 * NOTE: INDEX register must be set for EP 499 */ 500static int write_fifo(struct lh7a40x_ep *ep, struct lh7a40x_request *req) 501{ 502 u32 max; 503 u32 csr; 504 505 max = le16_to_cpu(ep->desc->wMaxPacketSize); 506 507 csr = usb_read(ep->csr1); 508 DEBUG("CSR: %x %d\n", csr, csr & USB_IN_CSR1_FIFO_NOT_EMPTY); 509 510 if (!(csr & USB_IN_CSR1_FIFO_NOT_EMPTY)) { 511 unsigned count; 512 int is_last, is_short; 513 514 count = write_packet(ep, req, max); 515 usb_set(USB_IN_CSR1_IN_PKT_RDY, ep->csr1); 516 517 /* last packet is usually short (or a zlp) */ 518 if (unlikely(count != max)) 519 is_last = is_short = 1; 520 else { 521 if (likely(req->req.length != req->req.actual) 522 || req->req.zero) 523 is_last = 0; 524 else 525 is_last = 1; 526 /* interrupt/iso maxpacket may not fill the fifo */ 527 is_short = unlikely(max < ep_maxpacket(ep)); 528 } 529 530 DEBUG("%s: wrote %s %d bytes%s%s %d left %p\n", __FUNCTION__, 531 ep->ep.name, count, 532 is_last ? "/L" : "", is_short ? "/S" : "", 533 req->req.length - req->req.actual, req); 534 535 /* requests complete when all IN data is in the FIFO */ 536 if (is_last) { 537 done(ep, req, 0); 538 if (list_empty(&ep->queue)) { 539 pio_irq_disable(ep_index(ep)); 540 } 541 return 1; 542 } 543 } else { 544 DEBUG("Hmm.. %d ep FIFO is not empty!\n", ep_index(ep)); 545 } 546 547 return 0; 548} 549 550/** Read to request from FIFO (max read == bytes in fifo) 551 * Return: 0 = still running, 1 = completed, negative = errno 552 * NOTE: INDEX register must be set for EP 553 */ 554static int read_fifo(struct lh7a40x_ep *ep, struct lh7a40x_request *req) 555{ 556 u32 csr; 557 u8 *buf; 558 unsigned bufferspace, count, is_short; 559 volatile u32 *fifo = (volatile u32 *)ep->fifo; 560 561 /* make sure there's a packet in the FIFO. */ 562 csr = usb_read(ep->csr1); 563 if (!(csr & USB_OUT_CSR1_OUT_PKT_RDY)) { 564 DEBUG("%s: Packet NOT ready!\n", __FUNCTION__); 565 return -EINVAL; 566 } 567 568 buf = req->req.buf + req->req.actual; 569 prefetchw(buf); 570 bufferspace = req->req.length - req->req.actual; 571 572 /* read all bytes from this packet */ 573 count = usb_read(USB_OUT_FIFO_WC1); 574 req->req.actual += min(count, bufferspace); 575 576 is_short = (count < ep->ep.maxpacket); 577 DEBUG("read %s %02x, %d bytes%s req %p %d/%d\n", 578 ep->ep.name, csr, count, 579 is_short ? "/S" : "", req, req->req.actual, req->req.length); 580 581 while (likely(count-- != 0)) { 582 u8 byte = (u8) (*fifo & 0xff); 583 584 if (unlikely(bufferspace == 0)) { 585 /* this happens when the driver's buffer 586 * is smaller than what the host sent. 587 * discard the extra data. 588 */ 589 if (req->req.status != -EOVERFLOW) 590 printk("%s overflow %d\n", ep->ep.name, count); 591 req->req.status = -EOVERFLOW; 592 } else { 593 *buf++ = byte; 594 bufferspace--; 595 } 596 } 597 598 usb_clear(USB_OUT_CSR1_OUT_PKT_RDY, ep->csr1); 599 600 /* completion */ 601 if (is_short || req->req.actual == req->req.length) { 602 done(ep, req, 0); 603 usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1); 604 605 if (list_empty(&ep->queue)) 606 pio_irq_disable(ep_index(ep)); 607 return 1; 608 } 609 610 /* finished that packet. the next one may be waiting... */ 611 return 0; 612} 613 614/* 615 * done - retire a request; caller blocked irqs 616 * INDEX register is preserved to keep same 617 */ 618static void done(struct lh7a40x_ep *ep, struct lh7a40x_request *req, int status) 619{ 620 unsigned int stopped = ep->stopped; 621 u32 index; 622 623 DEBUG("%s, %p\n", __FUNCTION__, ep); 624 list_del_init(&req->queue); 625 626 if (likely(req->req.status == -EINPROGRESS)) 627 req->req.status = status; 628 else 629 status = req->req.status; 630 631 if (status && status != -ESHUTDOWN) 632 DEBUG("complete %s req %p stat %d len %u/%u\n", 633 ep->ep.name, &req->req, status, 634 req->req.actual, req->req.length); 635 636 /* don't modify queue heads during completion callback */ 637 ep->stopped = 1; 638 /* Read current index (completion may modify it) */ 639 index = usb_read(USB_INDEX); 640 641 spin_unlock(&ep->dev->lock); 642 req->req.complete(&ep->ep, &req->req); 643 spin_lock(&ep->dev->lock); 644 645 /* Restore index */ 646 usb_set_index(index); 647 ep->stopped = stopped; 648} 649 650/** Enable EP interrupt */ 651static void pio_irq_enable(int ep) 652{ 653 DEBUG("%s: %d\n", __FUNCTION__, ep); 654 655 switch (ep) { 656 case 1: 657 usb_set(USB_IN_INT_EP1, USB_IN_INT_EN); 658 break; 659 case 2: 660 usb_set(USB_OUT_INT_EP2, USB_OUT_INT_EN); 661 break; 662 case 3: 663 usb_set(USB_IN_INT_EP3, USB_IN_INT_EN); 664 break; 665 default: 666 DEBUG("Unknown endpoint: %d\n", ep); 667 break; 668 } 669} 670 671/** Disable EP interrupt */ 672static void pio_irq_disable(int ep) 673{ 674 DEBUG("%s: %d\n", __FUNCTION__, ep); 675 676 switch (ep) { 677 case 1: 678 usb_clear(USB_IN_INT_EP1, USB_IN_INT_EN); 679 break; 680 case 2: 681 usb_clear(USB_OUT_INT_EP2, USB_OUT_INT_EN); 682 break; 683 case 3: 684 usb_clear(USB_IN_INT_EP3, USB_IN_INT_EN); 685 break; 686 default: 687 DEBUG("Unknown endpoint: %d\n", ep); 688 break; 689 } 690} 691 692/* 693 * nuke - dequeue ALL requests 694 */ 695void nuke(struct lh7a40x_ep *ep, int status) 696{ 697 struct lh7a40x_request *req; 698 699 DEBUG("%s, %p\n", __FUNCTION__, ep); 700 701 /* Flush FIFO */ 702 flush(ep); 703 704 /* called with irqs blocked */ 705 while (!list_empty(&ep->queue)) { 706 req = list_entry(ep->queue.next, struct lh7a40x_request, queue); 707 done(ep, req, status); 708 } 709 710 /* Disable IRQ if EP is enabled (has descriptor) */ 711 if (ep->desc) 712 pio_irq_disable(ep_index(ep)); 713} 714 715/* 716void nuke_all(struct lh7a40x_udc *dev) 717{ 718 int n; 719 for(n=0; n<UDC_MAX_ENDPOINTS; n++) { 720 struct lh7a40x_ep *ep = &dev->ep[n]; 721 usb_set_index(n); 722 nuke(ep, 0); 723 } 724}*/ 725 726/* 727static void flush_all(struct lh7a40x_udc *dev) 728{ 729 int n; 730 for (n = 0; n < UDC_MAX_ENDPOINTS; n++) 731 { 732 struct lh7a40x_ep *ep = &dev->ep[n]; 733 flush(ep); 734 } 735} 736*/ 737 738/** Flush EP 739 * NOTE: INDEX register must be set before this call 740 */ 741static void flush(struct lh7a40x_ep *ep) 742{ 743 DEBUG("%s, %p\n", __FUNCTION__, ep); 744 745 switch (ep->ep_type) { 746 case ep_control: 747 /* check, by implication c.f. 15.1.2.11 */ 748 break; 749 750 case ep_bulk_in: 751 case ep_interrupt: 752 /* if(csr & USB_IN_CSR1_IN_PKT_RDY) */ 753 usb_set(USB_IN_CSR1_FIFO_FLUSH, ep->csr1); 754 break; 755 756 case ep_bulk_out: 757 /* if(csr & USB_OUT_CSR1_OUT_PKT_RDY) */ 758 usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1); 759 break; 760 } 761} 762 763/** 764 * lh7a40x_in_epn - handle IN interrupt 765 */ 766static void lh7a40x_in_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr) 767{ 768 u32 csr; 769 struct lh7a40x_ep *ep = &dev->ep[ep_idx]; 770 struct lh7a40x_request *req; 771 772 usb_set_index(ep_idx); 773 774 csr = usb_read(ep->csr1); 775 DEBUG("%s: %d, csr %x\n", __FUNCTION__, ep_idx, csr); 776 777 if (csr & USB_IN_CSR1_SENT_STALL) { 778 DEBUG("USB_IN_CSR1_SENT_STALL\n"); 779 usb_set(USB_IN_CSR1_SENT_STALL /*|USB_IN_CSR1_SEND_STALL */ , 780 ep->csr1); 781 return; 782 } 783 784 if (!ep->desc) { 785 DEBUG("%s: NO EP DESC\n", __FUNCTION__); 786 return; 787 } 788 789 if (list_empty(&ep->queue)) 790 req = 0; 791 else 792 req = list_entry(ep->queue.next, struct lh7a40x_request, queue); 793 794 DEBUG("req: %p\n", req); 795 796 if (!req) 797 return; 798 799 write_fifo(ep, req); 800} 801 802/* ********************************************************************************************* */ 803/* Bulk OUT (recv) 804 */ 805 806static void lh7a40x_out_epn(struct lh7a40x_udc *dev, u32 ep_idx, u32 intr) 807{ 808 struct lh7a40x_ep *ep = &dev->ep[ep_idx]; 809 struct lh7a40x_request *req; 810 811 DEBUG("%s: %d\n", __FUNCTION__, ep_idx); 812 813 usb_set_index(ep_idx); 814 815 if (ep->desc) { 816 u32 csr; 817 csr = usb_read(ep->csr1); 818 819 while ((csr = 820 usb_read(ep-> 821 csr1)) & (USB_OUT_CSR1_OUT_PKT_RDY | 822 USB_OUT_CSR1_SENT_STALL)) { 823 DEBUG("%s: %x\n", __FUNCTION__, csr); 824 825 if (csr & USB_OUT_CSR1_SENT_STALL) { 826 DEBUG("%s: stall sent, flush fifo\n", 827 __FUNCTION__); 828 /* usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1); */ 829 flush(ep); 830 } else if (csr & USB_OUT_CSR1_OUT_PKT_RDY) { 831 if (list_empty(&ep->queue)) 832 req = 0; 833 else 834 req = 835 list_entry(ep->queue.next, 836 struct lh7a40x_request, 837 queue); 838 839 if (!req) { 840 printk("%s: NULL REQ %d\n", 841 __FUNCTION__, ep_idx); 842 flush(ep); 843 break; 844 } else { 845 read_fifo(ep, req); 846 } 847 } 848 849 } 850 851 } else { 852 /* Throw packet away.. */ 853 printk("%s: No descriptor?!?\n", __FUNCTION__); 854 flush(ep); 855 } 856} 857 858static void stop_activity(struct lh7a40x_udc *dev, 859 struct usb_gadget_driver *driver) 860{ 861 int i; 862 863 /* don't disconnect drivers more than once */ 864 if (dev->gadget.speed == USB_SPEED_UNKNOWN) 865 driver = 0; 866 dev->gadget.speed = USB_SPEED_UNKNOWN; 867 868 /* prevent new request submissions, kill any outstanding requests */ 869 for (i = 0; i < UDC_MAX_ENDPOINTS; i++) { 870 struct lh7a40x_ep *ep = &dev->ep[i]; 871 ep->stopped = 1; 872 873 usb_set_index(i); 874 nuke(ep, -ESHUTDOWN); 875 } 876 877 /* report disconnect; the driver is already quiesced */ 878 if (driver) { 879 spin_unlock(&dev->lock); 880 driver->disconnect(&dev->gadget); 881 spin_lock(&dev->lock); 882 } 883 884 /* re-init driver-visible data structures */ 885 udc_reinit(dev); 886} 887 888/** Handle USB RESET interrupt 889 */ 890static void lh7a40x_reset_intr(struct lh7a40x_udc *dev) 891{ 892 dev->gadget.speed = USB_SPEED_FULL; 893} 894 895/* 896 * lh7a40x usb client interrupt handler. 897 */ 898static irqreturn_t lh7a40x_udc_irq(int irq, void *_dev) 899{ 900 struct lh7a40x_udc *dev = _dev; 901 902 DEBUG("\n\n"); 903 904 spin_lock(&dev->lock); 905 906 for (;;) { 907 u32 intr_in = usb_read(USB_IN_INT); 908 u32 intr_out = usb_read(USB_OUT_INT); 909 u32 intr_int = usb_read(USB_INT); 910 911 /* Test also against enable bits.. (lh7a40x errata).. Sigh.. */ 912 u32 in_en = usb_read(USB_IN_INT_EN); 913 u32 out_en = usb_read(USB_OUT_INT_EN); 914 915 if (!intr_out && !intr_in && !intr_int) 916 break; 917 918 DEBUG("%s (on state %s)\n", __FUNCTION__, 919 state_names[dev->ep0state]); 920 DEBUG("intr_out = %x\n", intr_out); 921 DEBUG("intr_in = %x\n", intr_in); 922 DEBUG("intr_int = %x\n", intr_int); 923 924 if (intr_in) { 925 usb_write(intr_in, USB_IN_INT); 926 927 if ((intr_in & USB_IN_INT_EP1) 928 && (in_en & USB_IN_INT_EP1)) { 929 DEBUG("USB_IN_INT_EP1\n"); 930 lh7a40x_in_epn(dev, 1, intr_in); 931 } 932 if ((intr_in & USB_IN_INT_EP3) 933 && (in_en & USB_IN_INT_EP3)) { 934 DEBUG("USB_IN_INT_EP3\n"); 935 lh7a40x_in_epn(dev, 3, intr_in); 936 } 937 if (intr_in & USB_IN_INT_EP0) { 938 DEBUG("USB_IN_INT_EP0 (control)\n"); 939 lh7a40x_handle_ep0(dev, intr_in); 940 } 941 } 942 943 if (intr_out) { 944 usb_write(intr_out, USB_OUT_INT); 945 946 if ((intr_out & USB_OUT_INT_EP2) 947 && (out_en & USB_OUT_INT_EP2)) { 948 DEBUG("USB_OUT_INT_EP2\n"); 949 lh7a40x_out_epn(dev, 2, intr_out); 950 } 951 } 952 953 if (intr_int) { 954 usb_write(intr_int, USB_INT); 955 956 if (intr_int & USB_INT_RESET_INT) { 957 lh7a40x_reset_intr(dev); 958 } 959 960 if (intr_int & USB_INT_RESUME_INT) { 961 DEBUG("USB resume\n"); 962 963 if (dev->gadget.speed != USB_SPEED_UNKNOWN 964 && dev->driver 965 && dev->driver->resume 966 && is_usb_connected()) { 967 dev->driver->resume(&dev->gadget); 968 } 969 } 970 971 if (intr_int & USB_INT_SUSPEND_INT) { 972 DEBUG("USB suspend%s\n", 973 is_usb_connected()? "" : "+disconnect"); 974 if (!is_usb_connected()) { 975 stop_activity(dev, dev->driver); 976 } else if (dev->gadget.speed != 977 USB_SPEED_UNKNOWN && dev->driver 978 && dev->driver->suspend) { 979 dev->driver->suspend(&dev->gadget); 980 } 981 } 982 983 } 984 } 985 986 spin_unlock(&dev->lock); 987 988 return IRQ_HANDLED; 989} 990 991static int lh7a40x_ep_enable(struct usb_ep *_ep, 992 const struct usb_endpoint_descriptor *desc) 993{ 994 struct lh7a40x_ep *ep; 995 struct lh7a40x_udc *dev; 996 unsigned long flags; 997 998 DEBUG("%s, %p\n", __FUNCTION__, _ep); 999 1000 ep = container_of(_ep, struct lh7a40x_ep, ep); 1001 if (!_ep || !desc || ep->desc || _ep->name == ep0name 1002 || desc->bDescriptorType != USB_DT_ENDPOINT 1003 || ep->bEndpointAddress != desc->bEndpointAddress 1004 || ep_maxpacket(ep) < le16_to_cpu(desc->wMaxPacketSize)) { 1005 DEBUG("%s, bad ep or descriptor\n", __FUNCTION__); 1006 return -EINVAL; 1007 } 1008 1009 /* xfer types must match, except that interrupt ~= bulk */ 1010 if (ep->bmAttributes != desc->bmAttributes 1011 && ep->bmAttributes != USB_ENDPOINT_XFER_BULK 1012 && desc->bmAttributes != USB_ENDPOINT_XFER_INT) { 1013 DEBUG("%s, %s type mismatch\n", __FUNCTION__, _ep->name); 1014 return -EINVAL; 1015 } 1016 1017 /* hardware _could_ do smaller, but driver doesn't */ 1018 if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK 1019 && le16_to_cpu(desc->wMaxPacketSize) != ep_maxpacket(ep)) 1020 || !desc->wMaxPacketSize) { 1021 DEBUG("%s, bad %s maxpacket\n", __FUNCTION__, _ep->name); 1022 return -ERANGE; 1023 } 1024 1025 dev = ep->dev; 1026 if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) { 1027 DEBUG("%s, bogus device state\n", __FUNCTION__); 1028 return -ESHUTDOWN; 1029 } 1030 1031 spin_lock_irqsave(&ep->dev->lock, flags); 1032 1033 ep->stopped = 0; 1034 ep->desc = desc; 1035 ep->pio_irqs = 0; 1036 ep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize); 1037 1038 spin_unlock_irqrestore(&ep->dev->lock, flags); 1039 1040 /* Reset halt state (does flush) */ 1041 lh7a40x_set_halt(_ep, 0); 1042 1043 DEBUG("%s: enabled %s\n", __FUNCTION__, _ep->name); 1044 return 0; 1045} 1046 1047/** Disable EP 1048 * NOTE: Sets INDEX register 1049 */ 1050static int lh7a40x_ep_disable(struct usb_ep *_ep) 1051{ 1052 struct lh7a40x_ep *ep; 1053 unsigned long flags; 1054 1055 DEBUG("%s, %p\n", __FUNCTION__, _ep); 1056 1057 ep = container_of(_ep, struct lh7a40x_ep, ep); 1058 if (!_ep || !ep->desc) { 1059 DEBUG("%s, %s not enabled\n", __FUNCTION__, 1060 _ep ? ep->ep.name : NULL); 1061 return -EINVAL; 1062 } 1063 1064 spin_lock_irqsave(&ep->dev->lock, flags); 1065 1066 usb_set_index(ep_index(ep)); 1067 1068 /* Nuke all pending requests (does flush) */ 1069 nuke(ep, -ESHUTDOWN); 1070 1071 /* Disable ep IRQ */ 1072 pio_irq_disable(ep_index(ep)); 1073 1074 ep->desc = 0; 1075 ep->stopped = 1; 1076 1077 spin_unlock_irqrestore(&ep->dev->lock, flags); 1078 1079 DEBUG("%s: disabled %s\n", __FUNCTION__, _ep->name); 1080 return 0; 1081} 1082 1083static struct usb_request *lh7a40x_alloc_request(struct usb_ep *ep, 1084 gfp_t gfp_flags) 1085{ 1086 struct lh7a40x_request *req; 1087 1088 DEBUG("%s, %p\n", __FUNCTION__, ep); 1089 1090 req = kzalloc(sizeof(*req), gfp_flags); 1091 if (!req) 1092 return 0; 1093 1094 INIT_LIST_HEAD(&req->queue); 1095 1096 return &req->req; 1097} 1098 1099static void lh7a40x_free_request(struct usb_ep *ep, struct usb_request *_req) 1100{ 1101 struct lh7a40x_request *req; 1102 1103 DEBUG("%s, %p\n", __FUNCTION__, ep); 1104 1105 req = container_of(_req, struct lh7a40x_request, req); 1106 WARN_ON(!list_empty(&req->queue)); 1107 kfree(req); 1108} 1109 1110static void *lh7a40x_alloc_buffer(struct usb_ep *ep, unsigned bytes, 1111 dma_addr_t * dma, gfp_t gfp_flags) 1112{ 1113 char *retval; 1114 1115 DEBUG("%s (%p, %d, %d)\n", __FUNCTION__, ep, bytes, gfp_flags); 1116 1117 retval = kmalloc(bytes, gfp_flags & ~(__GFP_DMA | __GFP_HIGHMEM)); 1118 if (retval) 1119 *dma = virt_to_bus(retval); 1120 return retval; 1121} 1122 1123static void lh7a40x_free_buffer(struct usb_ep *ep, void *buf, dma_addr_t dma, 1124 unsigned bytes) 1125{ 1126 DEBUG("%s, %p\n", __FUNCTION__, ep); 1127 kfree(buf); 1128} 1129 1130/** Queue one request 1131 * Kickstart transfer if needed 1132 * NOTE: Sets INDEX register 1133 */ 1134static int lh7a40x_queue(struct usb_ep *_ep, struct usb_request *_req, 1135 gfp_t gfp_flags) 1136{ 1137 struct lh7a40x_request *req; 1138 struct lh7a40x_ep *ep; 1139 struct lh7a40x_udc *dev; 1140 unsigned long flags; 1141 1142 DEBUG("\n\n\n%s, %p\n", __FUNCTION__, _ep); 1143 1144 req = container_of(_req, struct lh7a40x_request, req); 1145 if (unlikely 1146 (!_req || !_req->complete || !_req->buf 1147 || !list_empty(&req->queue))) { 1148 DEBUG("%s, bad params\n", __FUNCTION__); 1149 return -EINVAL; 1150 } 1151 1152 ep = container_of(_ep, struct lh7a40x_ep, ep); 1153 if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) { 1154 DEBUG("%s, bad ep\n", __FUNCTION__); 1155 return -EINVAL; 1156 } 1157 1158 dev = ep->dev; 1159 if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) { 1160 DEBUG("%s, bogus device state %p\n", __FUNCTION__, dev->driver); 1161 return -ESHUTDOWN; 1162 } 1163 1164 DEBUG("%s queue req %p, len %d buf %p\n", _ep->name, _req, _req->length, 1165 _req->buf); 1166 1167 spin_lock_irqsave(&dev->lock, flags); 1168 1169 _req->status = -EINPROGRESS; 1170 _req->actual = 0; 1171 1172 /* kickstart this i/o queue? */ 1173 DEBUG("Add to %d Q %d %d\n", ep_index(ep), list_empty(&ep->queue), 1174 ep->stopped); 1175 if (list_empty(&ep->queue) && likely(!ep->stopped)) { 1176 u32 csr; 1177 1178 if (unlikely(ep_index(ep) == 0)) { 1179 /* EP0 */ 1180 list_add_tail(&req->queue, &ep->queue); 1181 lh7a40x_ep0_kick(dev, ep); 1182 req = 0; 1183 } else if (ep_is_in(ep)) { 1184 /* EP1 & EP3 */ 1185 usb_set_index(ep_index(ep)); 1186 csr = usb_read(ep->csr1); 1187 pio_irq_enable(ep_index(ep)); 1188 if ((csr & USB_IN_CSR1_FIFO_NOT_EMPTY) == 0) { 1189 if (write_fifo(ep, req) == 1) 1190 req = 0; 1191 } 1192 } else { 1193 /* EP2 */ 1194 usb_set_index(ep_index(ep)); 1195 csr = usb_read(ep->csr1); 1196 pio_irq_enable(ep_index(ep)); 1197 if (!(csr & USB_OUT_CSR1_FIFO_FULL)) { 1198 if (read_fifo(ep, req) == 1) 1199 req = 0; 1200 } 1201 } 1202 } 1203 1204 /* pio or dma irq handler advances the queue. */ 1205 if (likely(req != 0)) 1206 list_add_tail(&req->queue, &ep->queue); 1207 1208 spin_unlock_irqrestore(&dev->lock, flags); 1209 1210 return 0; 1211} 1212 1213/* dequeue JUST ONE request */ 1214static int lh7a40x_dequeue(struct usb_ep *_ep, struct usb_request *_req) 1215{ 1216 struct lh7a40x_ep *ep; 1217 struct lh7a40x_request *req; 1218 unsigned long flags; 1219 1220 DEBUG("%s, %p\n", __FUNCTION__, _ep); 1221 1222 ep = container_of(_ep, struct lh7a40x_ep, ep); 1223 if (!_ep || ep->ep.name == ep0name) 1224 return -EINVAL; 1225 1226 spin_lock_irqsave(&ep->dev->lock, flags); 1227 1228 /* make sure it's actually queued on this endpoint */ 1229 list_for_each_entry(req, &ep->queue, queue) { 1230 if (&req->req == _req) 1231 break; 1232 } 1233 if (&req->req != _req) { 1234 spin_unlock_irqrestore(&ep->dev->lock, flags); 1235 return -EINVAL; 1236 } 1237 1238 done(ep, req, -ECONNRESET); 1239 1240 spin_unlock_irqrestore(&ep->dev->lock, flags); 1241 return 0; 1242} 1243 1244/** Halt specific EP 1245 * Return 0 if success 1246 * NOTE: Sets INDEX register to EP ! 1247 */ 1248static int lh7a40x_set_halt(struct usb_ep *_ep, int value) 1249{ 1250 struct lh7a40x_ep *ep; 1251 unsigned long flags; 1252 1253 ep = container_of(_ep, struct lh7a40x_ep, ep); 1254 if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) { 1255 DEBUG("%s, bad ep\n", __FUNCTION__); 1256 return -EINVAL; 1257 } 1258 1259 usb_set_index(ep_index(ep)); 1260 1261 DEBUG("%s, ep %d, val %d\n", __FUNCTION__, ep_index(ep), value); 1262 1263 spin_lock_irqsave(&ep->dev->lock, flags); 1264 1265 if (ep_index(ep) == 0) { 1266 /* EP0 */ 1267 usb_set(EP0_SEND_STALL, ep->csr1); 1268 } else if (ep_is_in(ep)) { 1269 u32 csr = usb_read(ep->csr1); 1270 if (value && ((csr & USB_IN_CSR1_FIFO_NOT_EMPTY) 1271 || !list_empty(&ep->queue))) { 1272 /* 1273 * Attempts to halt IN endpoints will fail (returning -EAGAIN) 1274 * if any transfer requests are still queued, or if the controller 1275 * FIFO still holds bytes that the host hasn�t collected. 1276 */ 1277 spin_unlock_irqrestore(&ep->dev->lock, flags); 1278 DEBUG 1279 ("Attempt to halt IN endpoint failed (returning -EAGAIN) %d %d\n", 1280 (csr & USB_IN_CSR1_FIFO_NOT_EMPTY), 1281 !list_empty(&ep->queue)); 1282 return -EAGAIN; 1283 } 1284 flush(ep); 1285 if (value) 1286 usb_set(USB_IN_CSR1_SEND_STALL, ep->csr1); 1287 else { 1288 usb_clear(USB_IN_CSR1_SEND_STALL, ep->csr1); 1289 usb_set(USB_IN_CSR1_CLR_DATA_TOGGLE, ep->csr1); 1290 } 1291 1292 } else { 1293 1294 flush(ep); 1295 if (value) 1296 usb_set(USB_OUT_CSR1_SEND_STALL, ep->csr1); 1297 else { 1298 usb_clear(USB_OUT_CSR1_SEND_STALL, ep->csr1); 1299 usb_set(USB_OUT_CSR1_CLR_DATA_REG, ep->csr1); 1300 } 1301 } 1302 1303 if (value) { 1304 ep->stopped = 1; 1305 } else { 1306 ep->stopped = 0; 1307 } 1308 1309 spin_unlock_irqrestore(&ep->dev->lock, flags); 1310 1311 DEBUG("%s %s halted\n", _ep->name, value == 0 ? "NOT" : "IS"); 1312 1313 return 0; 1314} 1315 1316/** Return bytes in EP FIFO 1317 * NOTE: Sets INDEX register to EP 1318 */ 1319static int lh7a40x_fifo_status(struct usb_ep *_ep) 1320{ 1321 u32 csr; 1322 int count = 0; 1323 struct lh7a40x_ep *ep; 1324 1325 ep = container_of(_ep, struct lh7a40x_ep, ep); 1326 if (!_ep) { 1327 DEBUG("%s, bad ep\n", __FUNCTION__); 1328 return -ENODEV; 1329 } 1330 1331 DEBUG("%s, %d\n", __FUNCTION__, ep_index(ep)); 1332 1333 /* LPD can't report unclaimed bytes from IN fifos */ 1334 if (ep_is_in(ep)) 1335 return -EOPNOTSUPP; 1336 1337 usb_set_index(ep_index(ep)); 1338 1339 csr = usb_read(ep->csr1); 1340 if (ep->dev->gadget.speed != USB_SPEED_UNKNOWN || 1341 csr & USB_OUT_CSR1_OUT_PKT_RDY) { 1342 count = usb_read(USB_OUT_FIFO_WC1); 1343 } 1344 1345 return count; 1346} 1347 1348/** Flush EP FIFO 1349 * NOTE: Sets INDEX register to EP 1350 */ 1351static void lh7a40x_fifo_flush(struct usb_ep *_ep) 1352{ 1353 struct lh7a40x_ep *ep; 1354 1355 ep = container_of(_ep, struct lh7a40x_ep, ep); 1356 if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) { 1357 DEBUG("%s, bad ep\n", __FUNCTION__); 1358 return; 1359 } 1360 1361 usb_set_index(ep_index(ep)); 1362 flush(ep); 1363} 1364 1365/****************************************************************/ 1366/* End Point 0 related functions */ 1367/****************************************************************/ 1368 1369/* return: 0 = still running, 1 = completed, negative = errno */ 1370static int write_fifo_ep0(struct lh7a40x_ep *ep, struct lh7a40x_request *req) 1371{ 1372 u32 max; 1373 unsigned count; 1374 int is_last; 1375 1376 max = ep_maxpacket(ep); 1377 1378 DEBUG_EP0("%s\n", __FUNCTION__); 1379 1380 count = write_packet(ep, req, max); 1381 1382 /* last packet is usually short (or a zlp) */ 1383 if (unlikely(count != max)) 1384 is_last = 1; 1385 else { 1386 if (likely(req->req.length != req->req.actual) || req->req.zero) 1387 is_last = 0; 1388 else 1389 is_last = 1; 1390 } 1391 1392 DEBUG_EP0("%s: wrote %s %d bytes%s %d left %p\n", __FUNCTION__, 1393 ep->ep.name, count, 1394 is_last ? "/L" : "", req->req.length - req->req.actual, req); 1395 1396 /* requests complete when all IN data is in the FIFO */ 1397 if (is_last) { 1398 done(ep, req, 0); 1399 return 1; 1400 } 1401 1402 return 0; 1403} 1404 1405static __inline__ int lh7a40x_fifo_read(struct lh7a40x_ep *ep, 1406 unsigned char *cp, int max) 1407{ 1408 int bytes; 1409 int count = usb_read(USB_OUT_FIFO_WC1); 1410 volatile u32 *fifo = (volatile u32 *)ep->fifo; 1411 1412 if (count > max) 1413 count = max; 1414 bytes = count; 1415 while (count--) 1416 *cp++ = *fifo & 0xFF; 1417 return bytes; 1418} 1419 1420static __inline__ void lh7a40x_fifo_write(struct lh7a40x_ep *ep, 1421 unsigned char *cp, int count) 1422{ 1423 volatile u32 *fifo = (volatile u32 *)ep->fifo; 1424 DEBUG_EP0("fifo_write: %d %d\n", ep_index(ep), count); 1425 while (count--) 1426 *fifo = *cp++; 1427} 1428 1429static int read_fifo_ep0(struct lh7a40x_ep *ep, struct lh7a40x_request *req) 1430{ 1431 u32 csr; 1432 u8 *buf; 1433 unsigned bufferspace, count, is_short; 1434 volatile u32 *fifo = (volatile u32 *)ep->fifo; 1435 1436 DEBUG_EP0("%s\n", __FUNCTION__); 1437 1438 csr = usb_read(USB_EP0_CSR); 1439 if (!(csr & USB_OUT_CSR1_OUT_PKT_RDY)) 1440 return 0; 1441 1442 buf = req->req.buf + req->req.actual; 1443 prefetchw(buf); 1444 bufferspace = req->req.length - req->req.actual; 1445 1446 /* read all bytes from this packet */ 1447 if (likely(csr & EP0_OUT_PKT_RDY)) { 1448 count = usb_read(USB_OUT_FIFO_WC1); 1449 req->req.actual += min(count, bufferspace); 1450 } else /* zlp */ 1451 count = 0; 1452 1453 is_short = (count < ep->ep.maxpacket); 1454 DEBUG_EP0("read %s %02x, %d bytes%s req %p %d/%d\n", 1455 ep->ep.name, csr, count, 1456 is_short ? "/S" : "", req, req->req.actual, req->req.length); 1457 1458 while (likely(count-- != 0)) { 1459 u8 byte = (u8) (*fifo & 0xff); 1460 1461 if (unlikely(bufferspace == 0)) { 1462 /* this happens when the driver's buffer 1463 * is smaller than what the host sent. 1464 * discard the extra data. 1465 */ 1466 if (req->req.status != -EOVERFLOW) 1467 DEBUG_EP0("%s overflow %d\n", ep->ep.name, 1468 count); 1469 req->req.status = -EOVERFLOW; 1470 } else { 1471 *buf++ = byte; 1472 bufferspace--; 1473 } 1474 } 1475 1476 /* completion */ 1477 if (is_short || req->req.actual == req->req.length) { 1478 done(ep, req, 0); 1479 return 1; 1480 } 1481 1482 /* finished that packet. the next one may be waiting... */ 1483 return 0; 1484} 1485 1486/** 1487 * udc_set_address - set the USB address for this device 1488 * @address: 1489 * 1490 * Called from control endpoint function after it decodes a set address setup packet. 1491 */ 1492static void udc_set_address(struct lh7a40x_udc *dev, unsigned char address) 1493{ 1494 DEBUG_EP0("%s: %d\n", __FUNCTION__, address); 1495 /* c.f. 15.1.2.2 Table 15-4 address will be used after DATA_END is set */ 1496 dev->usb_address = address; 1497 usb_set((address & USB_FA_FUNCTION_ADDR), USB_FA); 1498 usb_set(USB_FA_ADDR_UPDATE | (address & USB_FA_FUNCTION_ADDR), USB_FA); 1499 /* usb_read(USB_FA); */ 1500} 1501 1502/* 1503 * DATA_STATE_RECV (OUT_PKT_RDY) 1504 * - if error 1505 * set EP0_CLR_OUT | EP0_DATA_END | EP0_SEND_STALL bits 1506 * - else 1507 * set EP0_CLR_OUT bit 1508 if last set EP0_DATA_END bit 1509 */ 1510static void lh7a40x_ep0_out(struct lh7a40x_udc *dev, u32 csr) 1511{ 1512 struct lh7a40x_request *req; 1513 struct lh7a40x_ep *ep = &dev->ep[0]; 1514 int ret; 1515 1516 DEBUG_EP0("%s: %x\n", __FUNCTION__, csr); 1517 1518 if (list_empty(&ep->queue)) 1519 req = 0; 1520 else 1521 req = list_entry(ep->queue.next, struct lh7a40x_request, queue); 1522 1523 if (req) { 1524 1525 if (req->req.length == 0) { 1526 DEBUG_EP0("ZERO LENGTH OUT!\n"); 1527 usb_set((EP0_CLR_OUT | EP0_DATA_END), USB_EP0_CSR); 1528 dev->ep0state = WAIT_FOR_SETUP; 1529 return; 1530 } 1531 ret = read_fifo_ep0(ep, req); 1532 if (ret) { 1533 /* Done! */ 1534 DEBUG_EP0("%s: finished, waiting for status\n", 1535 __FUNCTION__); 1536 1537 usb_set((EP0_CLR_OUT | EP0_DATA_END), USB_EP0_CSR); 1538 dev->ep0state = WAIT_FOR_SETUP; 1539 } else { 1540 /* Not done yet.. */ 1541 DEBUG_EP0("%s: not finished\n", __FUNCTION__); 1542 usb_set(EP0_CLR_OUT, USB_EP0_CSR); 1543 } 1544 } else { 1545 DEBUG_EP0("NO REQ??!\n"); 1546 } 1547} 1548 1549/* 1550 * DATA_STATE_XMIT 1551 */ 1552static int lh7a40x_ep0_in(struct lh7a40x_udc *dev, u32 csr) 1553{ 1554 struct lh7a40x_request *req; 1555 struct lh7a40x_ep *ep = &dev->ep[0]; 1556 int ret, need_zlp = 0; 1557 1558 DEBUG_EP0("%s: %x\n", __FUNCTION__, csr); 1559 1560 if (list_empty(&ep->queue)) 1561 req = 0; 1562 else 1563 req = list_entry(ep->queue.next, struct lh7a40x_request, queue); 1564 1565 if (!req) { 1566 DEBUG_EP0("%s: NULL REQ\n", __FUNCTION__); 1567 return 0; 1568 } 1569 1570 if (req->req.length == 0) { 1571 1572 usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR); 1573 dev->ep0state = WAIT_FOR_SETUP; 1574 return 1; 1575 } 1576 1577 if (req->req.length - req->req.actual == EP0_PACKETSIZE) { 1578 /* Next write will end with the packet size, */ 1579 /* so we need Zero-length-packet */ 1580 need_zlp = 1; 1581 } 1582 1583 ret = write_fifo_ep0(ep, req); 1584 1585 if (ret == 1 && !need_zlp) { 1586 /* Last packet */ 1587 DEBUG_EP0("%s: finished, waiting for status\n", __FUNCTION__); 1588 1589 usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR); 1590 dev->ep0state = WAIT_FOR_SETUP; 1591 } else { 1592 DEBUG_EP0("%s: not finished\n", __FUNCTION__); 1593 usb_set(EP0_IN_PKT_RDY, USB_EP0_CSR); 1594 } 1595 1596 if (need_zlp) { 1597 DEBUG_EP0("%s: Need ZLP!\n", __FUNCTION__); 1598 usb_set(EP0_IN_PKT_RDY, USB_EP0_CSR); 1599 dev->ep0state = DATA_STATE_NEED_ZLP; 1600 } 1601 1602 return 1; 1603} 1604 1605static int lh7a40x_handle_get_status(struct lh7a40x_udc *dev, 1606 struct usb_ctrlrequest *ctrl) 1607{ 1608 struct lh7a40x_ep *ep0 = &dev->ep[0]; 1609 struct lh7a40x_ep *qep; 1610 int reqtype = (ctrl->bRequestType & USB_RECIP_MASK); 1611 u16 val = 0; 1612 1613 if (reqtype == USB_RECIP_INTERFACE) { 1614 /* This is not supported. 1615 * And according to the USB spec, this one does nothing.. 1616 * Just return 0 1617 */ 1618 DEBUG_SETUP("GET_STATUS: USB_RECIP_INTERFACE\n"); 1619 } else if (reqtype == USB_RECIP_DEVICE) { 1620 DEBUG_SETUP("GET_STATUS: USB_RECIP_DEVICE\n"); 1621 val |= (1 << 0); /* Self powered */ 1622 /*val |= (1<<1); *//* Remote wakeup */ 1623 } else if (reqtype == USB_RECIP_ENDPOINT) { 1624 int ep_num = (ctrl->wIndex & ~USB_DIR_IN); 1625 1626 DEBUG_SETUP 1627 ("GET_STATUS: USB_RECIP_ENDPOINT (%d), ctrl->wLength = %d\n", 1628 ep_num, ctrl->wLength); 1629 1630 if (ctrl->wLength > 2 || ep_num > 3) 1631 return -EOPNOTSUPP; 1632 1633 qep = &dev->ep[ep_num]; 1634 if (ep_is_in(qep) != ((ctrl->wIndex & USB_DIR_IN) ? 1 : 0) 1635 && ep_index(qep) != 0) { 1636 return -EOPNOTSUPP; 1637 } 1638 1639 usb_set_index(ep_index(qep)); 1640 1641 /* Return status on next IN token */ 1642 switch (qep->ep_type) { 1643 case ep_control: 1644 val = 1645 (usb_read(qep->csr1) & EP0_SEND_STALL) == 1646 EP0_SEND_STALL; 1647 break; 1648 case ep_bulk_in: 1649 case ep_interrupt: 1650 val = 1651 (usb_read(qep->csr1) & USB_IN_CSR1_SEND_STALL) == 1652 USB_IN_CSR1_SEND_STALL; 1653 break; 1654 case ep_bulk_out: 1655 val = 1656 (usb_read(qep->csr1) & USB_OUT_CSR1_SEND_STALL) == 1657 USB_OUT_CSR1_SEND_STALL; 1658 break; 1659 } 1660 1661 /* Back to EP0 index */ 1662 usb_set_index(0); 1663 1664 DEBUG_SETUP("GET_STATUS, ep: %d (%x), val = %d\n", ep_num, 1665 ctrl->wIndex, val); 1666 } else { 1667 DEBUG_SETUP("Unknown REQ TYPE: %d\n", reqtype); 1668 return -EOPNOTSUPP; 1669 } 1670 1671 /* Clear "out packet ready" */ 1672 usb_set((EP0_CLR_OUT), USB_EP0_CSR); 1673 /* Put status to FIFO */ 1674 lh7a40x_fifo_write(ep0, (u8 *) & val, sizeof(val)); 1675 /* Issue "In packet ready" */ 1676 usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR); 1677 1678 return 0; 1679} 1680 1681/* 1682 * WAIT_FOR_SETUP (OUT_PKT_RDY) 1683 * - read data packet from EP0 FIFO 1684 * - decode command 1685 * - if error 1686 * set EP0_CLR_OUT | EP0_DATA_END | EP0_SEND_STALL bits 1687 * - else 1688 * set EP0_CLR_OUT | EP0_DATA_END bits 1689 */ 1690static void lh7a40x_ep0_setup(struct lh7a40x_udc *dev, u32 csr) 1691{ 1692 struct lh7a40x_ep *ep = &dev->ep[0]; 1693 struct usb_ctrlrequest ctrl; 1694 int i, bytes, is_in; 1695 1696 DEBUG_SETUP("%s: %x\n", __FUNCTION__, csr); 1697 1698 /* Nuke all previous transfers */ 1699 nuke(ep, -EPROTO); 1700 1701 /* read control req from fifo (8 bytes) */ 1702 bytes = lh7a40x_fifo_read(ep, (unsigned char *)&ctrl, 8); 1703 1704 DEBUG_SETUP("Read CTRL REQ %d bytes\n", bytes); 1705 DEBUG_SETUP("CTRL.bRequestType = %d (is_in %d)\n", ctrl.bRequestType, 1706 ctrl.bRequestType == USB_DIR_IN); 1707 DEBUG_SETUP("CTRL.bRequest = %d\n", ctrl.bRequest); 1708 DEBUG_SETUP("CTRL.wLength = %d\n", ctrl.wLength); 1709 DEBUG_SETUP("CTRL.wValue = %d (%d)\n", ctrl.wValue, ctrl.wValue >> 8); 1710 DEBUG_SETUP("CTRL.wIndex = %d\n", ctrl.wIndex); 1711 1712 /* Set direction of EP0 */ 1713 if (likely(ctrl.bRequestType & USB_DIR_IN)) { 1714 ep->bEndpointAddress |= USB_DIR_IN; 1715 is_in = 1; 1716 } else { 1717 ep->bEndpointAddress &= ~USB_DIR_IN; 1718 is_in = 0; 1719 } 1720 1721 dev->req_pending = 1; 1722 1723 /* Handle some SETUP packets ourselves */ 1724 switch (ctrl.bRequest) { 1725 case USB_REQ_SET_ADDRESS: 1726 if (ctrl.bRequestType != (USB_TYPE_STANDARD | USB_RECIP_DEVICE)) 1727 break; 1728 1729 DEBUG_SETUP("USB_REQ_SET_ADDRESS (%d)\n", ctrl.wValue); 1730 udc_set_address(dev, ctrl.wValue); 1731 usb_set((EP0_CLR_OUT | EP0_DATA_END), USB_EP0_CSR); 1732 return; 1733 1734 case USB_REQ_GET_STATUS:{ 1735 if (lh7a40x_handle_get_status(dev, &ctrl) == 0) 1736 return; 1737 1738 case USB_REQ_CLEAR_FEATURE: 1739 case USB_REQ_SET_FEATURE: 1740 if (ctrl.bRequestType == USB_RECIP_ENDPOINT) { 1741 struct lh7a40x_ep *qep; 1742 int ep_num = (ctrl.wIndex & 0x0f); 1743 1744 /* Support only HALT feature */ 1745 if (ctrl.wValue != 0 || ctrl.wLength != 0 1746 || ep_num > 3 || ep_num < 1) 1747 break; 1748 1749 qep = &dev->ep[ep_num]; 1750 spin_unlock(&dev->lock); 1751 if (ctrl.bRequest == USB_REQ_SET_FEATURE) { 1752 DEBUG_SETUP("SET_FEATURE (%d)\n", 1753 ep_num); 1754 lh7a40x_set_halt(&qep->ep, 1); 1755 } else { 1756 DEBUG_SETUP("CLR_FEATURE (%d)\n", 1757 ep_num); 1758 lh7a40x_set_halt(&qep->ep, 0); 1759 } 1760 spin_lock(&dev->lock); 1761 usb_set_index(0); 1762 1763 /* Reply with a ZLP on next IN token */ 1764 usb_set((EP0_CLR_OUT | EP0_DATA_END), 1765 USB_EP0_CSR); 1766 return; 1767 } 1768 break; 1769 } 1770 1771 default: 1772 break; 1773 } 1774 1775 if (likely(dev->driver)) { 1776 /* device-2-host (IN) or no data setup command, process immediately */ 1777 spin_unlock(&dev->lock); 1778 i = dev->driver->setup(&dev->gadget, &ctrl); 1779 spin_lock(&dev->lock); 1780 1781 if (i < 0) { 1782 /* setup processing failed, force stall */ 1783 DEBUG_SETUP 1784 (" --> ERROR: gadget setup FAILED (stalling), setup returned %d\n", 1785 i); 1786 usb_set_index(0); 1787 usb_set((EP0_CLR_OUT | EP0_DATA_END | EP0_SEND_STALL), 1788 USB_EP0_CSR); 1789 1790 /* ep->stopped = 1; */ 1791 dev->ep0state = WAIT_FOR_SETUP; 1792 } 1793 } 1794} 1795 1796/* 1797 * DATA_STATE_NEED_ZLP 1798 */ 1799static void lh7a40x_ep0_in_zlp(struct lh7a40x_udc *dev, u32 csr) 1800{ 1801 DEBUG_EP0("%s: %x\n", __FUNCTION__, csr); 1802 1803 /* c.f. Table 15-14 */ 1804 usb_set((EP0_IN_PKT_RDY | EP0_DATA_END), USB_EP0_CSR); 1805 dev->ep0state = WAIT_FOR_SETUP; 1806} 1807 1808/* 1809 * handle ep0 interrupt 1810 */ 1811static void lh7a40x_handle_ep0(struct lh7a40x_udc *dev, u32 intr) 1812{ 1813 struct lh7a40x_ep *ep = &dev->ep[0]; 1814 u32 csr; 1815 1816 /* Set index 0 */ 1817 usb_set_index(0); 1818 csr = usb_read(USB_EP0_CSR); 1819 1820 DEBUG_EP0("%s: csr = %x\n", __FUNCTION__, csr); 1821 1822 /* 1823 * For overview of what we should be doing see c.f. Chapter 18.1.2.4 1824 * We will follow that outline here modified by our own global state 1825 * indication which provides hints as to what we think should be 1826 * happening.. 1827 */ 1828 1829 /* 1830 * if SENT_STALL is set 1831 * - clear the SENT_STALL bit 1832 */ 1833 if (csr & EP0_SENT_STALL) { 1834 DEBUG_EP0("%s: EP0_SENT_STALL is set: %x\n", __FUNCTION__, csr); 1835 usb_clear((EP0_SENT_STALL | EP0_SEND_STALL), USB_EP0_CSR); 1836 nuke(ep, -ECONNABORTED); 1837 dev->ep0state = WAIT_FOR_SETUP; 1838 return; 1839 } 1840 1841 /* 1842 * if a transfer is in progress && IN_PKT_RDY and OUT_PKT_RDY are clear 1843 * - fill EP0 FIFO 1844 * - if last packet 1845 * - set IN_PKT_RDY | DATA_END 1846 * - else 1847 * set IN_PKT_RDY 1848 */ 1849 if (!(csr & (EP0_IN_PKT_RDY | EP0_OUT_PKT_RDY))) { 1850 DEBUG_EP0("%s: IN_PKT_RDY and OUT_PKT_RDY are clear\n", 1851 __FUNCTION__); 1852 1853 switch (dev->ep0state) { 1854 case DATA_STATE_XMIT: 1855 DEBUG_EP0("continue with DATA_STATE_XMIT\n"); 1856 lh7a40x_ep0_in(dev, csr); 1857 return; 1858 case DATA_STATE_NEED_ZLP: 1859 DEBUG_EP0("continue with DATA_STATE_NEED_ZLP\n"); 1860 lh7a40x_ep0_in_zlp(dev, csr); 1861 return; 1862 default: 1863 /* Stall? */ 1864 DEBUG_EP0("Odd state!! state = %s\n", 1865 state_names[dev->ep0state]); 1866 dev->ep0state = WAIT_FOR_SETUP; 1867 /* nuke(ep, 0); */ 1868 /* usb_set(EP0_SEND_STALL, ep->csr1); */ 1869 break; 1870 } 1871 } 1872 1873 /* 1874 * if SETUP_END is set 1875 * - abort the last transfer 1876 * - set SERVICED_SETUP_END_BIT 1877 */ 1878 if (csr & EP0_SETUP_END) { 1879 DEBUG_EP0("%s: EP0_SETUP_END is set: %x\n", __FUNCTION__, csr); 1880 1881 usb_set(EP0_CLR_SETUP_END, USB_EP0_CSR); 1882 1883 nuke(ep, 0); 1884 dev->ep0state = WAIT_FOR_SETUP; 1885 } 1886 1887 /* 1888 * if EP0_OUT_PKT_RDY is set 1889 * - read data packet from EP0 FIFO 1890 * - decode command 1891 * - if error 1892 * set SERVICED_OUT_PKT_RDY | DATA_END bits | SEND_STALL 1893 * - else 1894 * set SERVICED_OUT_PKT_RDY | DATA_END bits 1895 */ 1896 if (csr & EP0_OUT_PKT_RDY) { 1897 1898 DEBUG_EP0("%s: EP0_OUT_PKT_RDY is set: %x\n", __FUNCTION__, 1899 csr); 1900 1901 switch (dev->ep0state) { 1902 case WAIT_FOR_SETUP: 1903 DEBUG_EP0("WAIT_FOR_SETUP\n"); 1904 lh7a40x_ep0_setup(dev, csr); 1905 break; 1906 1907 case DATA_STATE_RECV: 1908 DEBUG_EP0("DATA_STATE_RECV\n"); 1909 lh7a40x_ep0_out(dev, csr); 1910 break; 1911 1912 default: 1913 /* send stall? */ 1914 DEBUG_EP0("strange state!! 2. send stall? state = %d\n", 1915 dev->ep0state); 1916 break; 1917 } 1918 } 1919} 1920 1921static void lh7a40x_ep0_kick(struct lh7a40x_udc *dev, struct lh7a40x_ep *ep) 1922{ 1923 u32 csr; 1924 1925 usb_set_index(0); 1926 csr = usb_read(USB_EP0_CSR); 1927 1928 DEBUG_EP0("%s: %x\n", __FUNCTION__, csr); 1929 1930 /* Clear "out packet ready" */ 1931 usb_set(EP0_CLR_OUT, USB_EP0_CSR); 1932 1933 if (ep_is_in(ep)) { 1934 dev->ep0state = DATA_STATE_XMIT; 1935 lh7a40x_ep0_in(dev, csr); 1936 } else { 1937 dev->ep0state = DATA_STATE_RECV; 1938 lh7a40x_ep0_out(dev, csr); 1939 } 1940} 1941 1942/* --------------------------------------------------------------------------- 1943 * device-scoped parts of the api to the usb controller hardware 1944 * --------------------------------------------------------------------------- 1945 */ 1946 1947static int lh7a40x_udc_get_frame(struct usb_gadget *_gadget) 1948{ 1949 u32 frame1 = usb_read(USB_FRM_NUM1); /* Least significant 8 bits */ 1950 u32 frame2 = usb_read(USB_FRM_NUM2); /* Most significant 3 bits */ 1951 DEBUG("%s, %p\n", __FUNCTION__, _gadget); 1952 return ((frame2 & 0x07) << 8) | (frame1 & 0xff); 1953} 1954 1955static int lh7a40x_udc_wakeup(struct usb_gadget *_gadget) 1956{ 1957 /* host may not have enabled remote wakeup */ 1958 /*if ((UDCCS0 & UDCCS0_DRWF) == 0) 1959 return -EHOSTUNREACH; 1960 udc_set_mask_UDCCR(UDCCR_RSM); */ 1961 return -ENOTSUPP; 1962} 1963 1964static const struct usb_gadget_ops lh7a40x_udc_ops = { 1965 .get_frame = lh7a40x_udc_get_frame, 1966 .wakeup = lh7a40x_udc_wakeup, 1967 /* current versions must always be self-powered */ 1968}; 1969 1970static void nop_release(struct device *dev) 1971{ 1972 DEBUG("%s %s\n", __FUNCTION__, dev->bus_id); 1973} 1974 1975static struct lh7a40x_udc memory = { 1976 .usb_address = 0, 1977 1978 .gadget = { 1979 .ops = &lh7a40x_udc_ops, 1980 .ep0 = &memory.ep[0].ep, 1981 .name = driver_name, 1982 .dev = { 1983 .bus_id = "gadget", 1984 .release = nop_release, 1985 }, 1986 }, 1987 1988 /* control endpoint */ 1989 .ep[0] = { 1990 .ep = { 1991 .name = ep0name, 1992 .ops = &lh7a40x_ep_ops, 1993 .maxpacket = EP0_PACKETSIZE, 1994 }, 1995 .dev = &memory, 1996 1997 .bEndpointAddress = 0, 1998 .bmAttributes = 0, 1999 2000 .ep_type = ep_control, 2001 .fifo = io_p2v(USB_EP0_FIFO), 2002 .csr1 = USB_EP0_CSR, 2003 .csr2 = USB_EP0_CSR, 2004 }, 2005 2006 /* first group of endpoints */ 2007 .ep[1] = { 2008 .ep = { 2009 .name = "ep1in-bulk", 2010 .ops = &lh7a40x_ep_ops, 2011 .maxpacket = 64, 2012 }, 2013 .dev = &memory, 2014 2015 .bEndpointAddress = USB_DIR_IN | 1, 2016 .bmAttributes = USB_ENDPOINT_XFER_BULK, 2017 2018 .ep_type = ep_bulk_in, 2019 .fifo = io_p2v(USB_EP1_FIFO), 2020 .csr1 = USB_IN_CSR1, 2021 .csr2 = USB_IN_CSR2, 2022 }, 2023 2024 .ep[2] = { 2025 .ep = { 2026 .name = "ep2out-bulk", 2027 .ops = &lh7a40x_ep_ops, 2028 .maxpacket = 64, 2029 }, 2030 .dev = &memory, 2031 2032 .bEndpointAddress = 2, 2033 .bmAttributes = USB_ENDPOINT_XFER_BULK, 2034 2035 .ep_type = ep_bulk_out, 2036 .fifo = io_p2v(USB_EP2_FIFO), 2037 .csr1 = USB_OUT_CSR1, 2038 .csr2 = USB_OUT_CSR2, 2039 }, 2040 2041 .ep[3] = { 2042 .ep = { 2043 .name = "ep3in-int", 2044 .ops = &lh7a40x_ep_ops, 2045 .maxpacket = 64, 2046 }, 2047 .dev = &memory, 2048 2049 .bEndpointAddress = USB_DIR_IN | 3, 2050 .bmAttributes = USB_ENDPOINT_XFER_INT, 2051 2052 .ep_type = ep_interrupt, 2053 .fifo = io_p2v(USB_EP3_FIFO), 2054 .csr1 = USB_IN_CSR1, 2055 .csr2 = USB_IN_CSR2, 2056 }, 2057}; 2058 2059/* 2060 * probe - binds to the platform device 2061 */ 2062static int lh7a40x_udc_probe(struct platform_device *pdev) 2063{ 2064 struct lh7a40x_udc *dev = &memory; 2065 int retval; 2066 2067 DEBUG("%s: %p\n", __FUNCTION__, pdev); 2068 2069 spin_lock_init(&dev->lock); 2070 dev->dev = &pdev->dev; 2071 2072 device_initialize(&dev->gadget.dev); 2073 dev->gadget.dev.parent = &pdev->dev; 2074 2075 the_controller = dev; 2076 platform_set_drvdata(pdev, dev); 2077 2078 udc_disable(dev); 2079 udc_reinit(dev); 2080 2081 /* irq setup after old hardware state is cleaned up */ 2082 retval = 2083 request_irq(IRQ_USBINTR, lh7a40x_udc_irq, IRQF_DISABLED, driver_name, 2084 dev); 2085 if (retval != 0) { 2086 DEBUG(KERN_ERR "%s: can't get irq %i, err %d\n", driver_name, 2087 IRQ_USBINTR, retval); 2088 return -EBUSY; 2089 } 2090 2091 create_proc_files(); 2092 2093 return retval; 2094} 2095 2096static int lh7a40x_udc_remove(struct platform_device *pdev) 2097{ 2098 struct lh7a40x_udc *dev = platform_get_drvdata(pdev); 2099 2100 DEBUG("%s: %p\n", __FUNCTION__, pdev); 2101 2102 if (dev->driver) 2103 return -EBUSY; 2104 2105 udc_disable(dev); 2106 remove_proc_files(); 2107 2108 free_irq(IRQ_USBINTR, dev); 2109 2110 platform_set_drvdata(pdev, 0); 2111 2112 the_controller = 0; 2113 2114 return 0; 2115} 2116 2117/*-------------------------------------------------------------------------*/ 2118 2119static struct platform_driver udc_driver = { 2120 .probe = lh7a40x_udc_probe, 2121 .remove = lh7a40x_udc_remove, 2122 /* .suspend = ... disable UDC */ 2123 /* .resume = ... re-enable UDC */ 2124 .driver = { 2125 .name = (char *)driver_name, 2126 .owner = THIS_MODULE, 2127 }, 2128}; 2129 2130static int __init udc_init(void) 2131{ 2132 DEBUG("%s: %s version %s\n", __FUNCTION__, driver_name, DRIVER_VERSION); 2133 return platform_driver_register(&udc_driver); 2134} 2135 2136static void __exit udc_exit(void) 2137{ 2138 platform_driver_unregister(&udc_driver); 2139} 2140 2141module_init(udc_init); 2142module_exit(udc_exit); 2143 2144MODULE_DESCRIPTION(DRIVER_DESC); 2145MODULE_AUTHOR("Mikko Lahteenmaki, Bo Henriksen"); 2146MODULE_LICENSE("GPL"); 2147