1 /* 2 * Driver for the Atmel USBA high speed USB device controller 3 * 4 * Copyright (C) 2005-2007 Atmel Corporation 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 #include <linux/clk.h> 11 #include <linux/module.h> 12 #include <linux/init.h> 13 #include <linux/interrupt.h> 14 #include <linux/io.h> 15 #include <linux/slab.h> 16 #include <linux/device.h> 17 #include <linux/dma-mapping.h> 18 #include <linux/list.h> 19 #include <linux/platform_device.h> 20 #include <linux/usb/ch9.h> 21 #include <linux/usb/gadget.h> 22 #include <linux/usb/atmel_usba_udc.h> 23 #include <linux/delay.h> 24 #include <linux/platform_data/atmel.h> 25 #include <linux/of.h> 26 #include <linux/of_gpio.h> 27 28 #include <asm/gpio.h> 29 30 #include "atmel_usba_udc.h" 31 32 #ifdef CONFIG_USB_GADGET_DEBUG_FS 33 #include <linux/debugfs.h> 34 #include <linux/uaccess.h> 35 36 static int queue_dbg_open(struct inode *inode, struct file *file) 37 { 38 struct usba_ep *ep = inode->i_private; 39 struct usba_request *req, *req_copy; 40 struct list_head *queue_data; 41 42 queue_data = kmalloc(sizeof(*queue_data), GFP_KERNEL); 43 if (!queue_data) 44 return -ENOMEM; 45 INIT_LIST_HEAD(queue_data); 46 47 spin_lock_irq(&ep->udc->lock); 48 list_for_each_entry(req, &ep->queue, queue) { 49 req_copy = kmemdup(req, sizeof(*req_copy), GFP_ATOMIC); 50 if (!req_copy) 51 goto fail; 52 list_add_tail(&req_copy->queue, queue_data); 53 } 54 spin_unlock_irq(&ep->udc->lock); 55 56 file->private_data = queue_data; 57 return 0; 58 59 fail: 60 spin_unlock_irq(&ep->udc->lock); 61 list_for_each_entry_safe(req, req_copy, queue_data, queue) { 62 list_del(&req->queue); 63 kfree(req); 64 } 65 kfree(queue_data); 66 return -ENOMEM; 67 } 68 69 /* 70 * bbbbbbbb llllllll IZS sssss nnnn FDL\n\0 71 * 72 * b: buffer address 73 * l: buffer length 74 * I/i: interrupt/no interrupt 75 * Z/z: zero/no zero 76 * S/s: short ok/short not ok 77 * s: status 78 * n: nr_packets 79 * F/f: submitted/not submitted to FIFO 80 * D/d: using/not using DMA 81 * L/l: last transaction/not last transaction 82 */ 83 static ssize_t queue_dbg_read(struct file *file, char __user *buf, 84 size_t nbytes, loff_t *ppos) 85 { 86 struct list_head *queue = file->private_data; 87 struct usba_request *req, *tmp_req; 88 size_t len, remaining, actual = 0; 89 char tmpbuf[38]; 90 91 if (!access_ok(VERIFY_WRITE, buf, nbytes)) 92 return -EFAULT; 93 94 mutex_lock(&file_inode(file)->i_mutex); 95 list_for_each_entry_safe(req, tmp_req, queue, queue) { 96 len = snprintf(tmpbuf, sizeof(tmpbuf), 97 "%8p %08x %c%c%c %5d %c%c%c\n", 98 req->req.buf, req->req.length, 99 req->req.no_interrupt ? 'i' : 'I', 100 req->req.zero ? 'Z' : 'z', 101 req->req.short_not_ok ? 's' : 'S', 102 req->req.status, 103 req->submitted ? 'F' : 'f', 104 req->using_dma ? 'D' : 'd', 105 req->last_transaction ? 'L' : 'l'); 106 len = min(len, sizeof(tmpbuf)); 107 if (len > nbytes) 108 break; 109 110 list_del(&req->queue); 111 kfree(req); 112 113 remaining = __copy_to_user(buf, tmpbuf, len); 114 actual += len - remaining; 115 if (remaining) 116 break; 117 118 nbytes -= len; 119 buf += len; 120 } 121 mutex_unlock(&file_inode(file)->i_mutex); 122 123 return actual; 124 } 125 126 static int queue_dbg_release(struct inode *inode, struct file *file) 127 { 128 struct list_head *queue_data = file->private_data; 129 struct usba_request *req, *tmp_req; 130 131 list_for_each_entry_safe(req, tmp_req, queue_data, queue) { 132 list_del(&req->queue); 133 kfree(req); 134 } 135 kfree(queue_data); 136 return 0; 137 } 138 139 static int regs_dbg_open(struct inode *inode, struct file *file) 140 { 141 struct usba_udc *udc; 142 unsigned int i; 143 u32 *data; 144 int ret = -ENOMEM; 145 146 mutex_lock(&inode->i_mutex); 147 udc = inode->i_private; 148 data = kmalloc(inode->i_size, GFP_KERNEL); 149 if (!data) 150 goto out; 151 152 spin_lock_irq(&udc->lock); 153 for (i = 0; i < inode->i_size / 4; i++) 154 data[i] = __raw_readl(udc->regs + i * 4); 155 spin_unlock_irq(&udc->lock); 156 157 file->private_data = data; 158 ret = 0; 159 160 out: 161 mutex_unlock(&inode->i_mutex); 162 163 return ret; 164 } 165 166 static ssize_t regs_dbg_read(struct file *file, char __user *buf, 167 size_t nbytes, loff_t *ppos) 168 { 169 struct inode *inode = file_inode(file); 170 int ret; 171 172 mutex_lock(&inode->i_mutex); 173 ret = simple_read_from_buffer(buf, nbytes, ppos, 174 file->private_data, 175 file_inode(file)->i_size); 176 mutex_unlock(&inode->i_mutex); 177 178 return ret; 179 } 180 181 static int regs_dbg_release(struct inode *inode, struct file *file) 182 { 183 kfree(file->private_data); 184 return 0; 185 } 186 187 const struct file_operations queue_dbg_fops = { 188 .owner = THIS_MODULE, 189 .open = queue_dbg_open, 190 .llseek = no_llseek, 191 .read = queue_dbg_read, 192 .release = queue_dbg_release, 193 }; 194 195 const struct file_operations regs_dbg_fops = { 196 .owner = THIS_MODULE, 197 .open = regs_dbg_open, 198 .llseek = generic_file_llseek, 199 .read = regs_dbg_read, 200 .release = regs_dbg_release, 201 }; 202 203 static void usba_ep_init_debugfs(struct usba_udc *udc, 204 struct usba_ep *ep) 205 { 206 struct dentry *ep_root; 207 208 ep_root = debugfs_create_dir(ep->ep.name, udc->debugfs_root); 209 if (!ep_root) 210 goto err_root; 211 ep->debugfs_dir = ep_root; 212 213 ep->debugfs_queue = debugfs_create_file("queue", 0400, ep_root, 214 ep, &queue_dbg_fops); 215 if (!ep->debugfs_queue) 216 goto err_queue; 217 218 if (ep->can_dma) { 219 ep->debugfs_dma_status 220 = debugfs_create_u32("dma_status", 0400, ep_root, 221 &ep->last_dma_status); 222 if (!ep->debugfs_dma_status) 223 goto err_dma_status; 224 } 225 if (ep_is_control(ep)) { 226 ep->debugfs_state 227 = debugfs_create_u32("state", 0400, ep_root, 228 &ep->state); 229 if (!ep->debugfs_state) 230 goto err_state; 231 } 232 233 return; 234 235 err_state: 236 if (ep->can_dma) 237 debugfs_remove(ep->debugfs_dma_status); 238 err_dma_status: 239 debugfs_remove(ep->debugfs_queue); 240 err_queue: 241 debugfs_remove(ep_root); 242 err_root: 243 dev_err(&ep->udc->pdev->dev, 244 "failed to create debugfs directory for %s\n", ep->ep.name); 245 } 246 247 static void usba_ep_cleanup_debugfs(struct usba_ep *ep) 248 { 249 debugfs_remove(ep->debugfs_queue); 250 debugfs_remove(ep->debugfs_dma_status); 251 debugfs_remove(ep->debugfs_state); 252 debugfs_remove(ep->debugfs_dir); 253 ep->debugfs_dma_status = NULL; 254 ep->debugfs_dir = NULL; 255 } 256 257 static void usba_init_debugfs(struct usba_udc *udc) 258 { 259 struct dentry *root, *regs; 260 struct resource *regs_resource; 261 262 root = debugfs_create_dir(udc->gadget.name, NULL); 263 if (IS_ERR(root) || !root) 264 goto err_root; 265 udc->debugfs_root = root; 266 267 regs = debugfs_create_file("regs", 0400, root, udc, ®s_dbg_fops); 268 if (!regs) 269 goto err_regs; 270 271 regs_resource = platform_get_resource(udc->pdev, IORESOURCE_MEM, 272 CTRL_IOMEM_ID); 273 regs->d_inode->i_size = resource_size(regs_resource); 274 udc->debugfs_regs = regs; 275 276 usba_ep_init_debugfs(udc, to_usba_ep(udc->gadget.ep0)); 277 278 return; 279 280 err_regs: 281 debugfs_remove(root); 282 err_root: 283 udc->debugfs_root = NULL; 284 dev_err(&udc->pdev->dev, "debugfs is not available\n"); 285 } 286 287 static void usba_cleanup_debugfs(struct usba_udc *udc) 288 { 289 usba_ep_cleanup_debugfs(to_usba_ep(udc->gadget.ep0)); 290 debugfs_remove(udc->debugfs_regs); 291 debugfs_remove(udc->debugfs_root); 292 udc->debugfs_regs = NULL; 293 udc->debugfs_root = NULL; 294 } 295 #else 296 static inline void usba_ep_init_debugfs(struct usba_udc *udc, 297 struct usba_ep *ep) 298 { 299 300 } 301 302 static inline void usba_ep_cleanup_debugfs(struct usba_ep *ep) 303 { 304 305 } 306 307 static inline void usba_init_debugfs(struct usba_udc *udc) 308 { 309 310 } 311 312 static inline void usba_cleanup_debugfs(struct usba_udc *udc) 313 { 314 315 } 316 #endif 317 318 static int vbus_is_present(struct usba_udc *udc) 319 { 320 if (gpio_is_valid(udc->vbus_pin)) 321 return gpio_get_value(udc->vbus_pin) ^ udc->vbus_pin_inverted; 322 323 /* No Vbus detection: Assume always present */ 324 return 1; 325 } 326 327 #if defined(CONFIG_ARCH_AT91SAM9RL) 328 329 #include <linux/clk/at91_pmc.h> 330 331 static void toggle_bias(int is_on) 332 { 333 unsigned int uckr = at91_pmc_read(AT91_CKGR_UCKR); 334 335 if (is_on) 336 at91_pmc_write(AT91_CKGR_UCKR, uckr | AT91_PMC_BIASEN); 337 else 338 at91_pmc_write(AT91_CKGR_UCKR, uckr & ~(AT91_PMC_BIASEN)); 339 } 340 341 #else 342 343 static void toggle_bias(int is_on) 344 { 345 } 346 347 #endif /* CONFIG_ARCH_AT91SAM9RL */ 348 349 static void next_fifo_transaction(struct usba_ep *ep, struct usba_request *req) 350 { 351 unsigned int transaction_len; 352 353 transaction_len = req->req.length - req->req.actual; 354 req->last_transaction = 1; 355 if (transaction_len > ep->ep.maxpacket) { 356 transaction_len = ep->ep.maxpacket; 357 req->last_transaction = 0; 358 } else if (transaction_len == ep->ep.maxpacket && req->req.zero) 359 req->last_transaction = 0; 360 361 DBG(DBG_QUEUE, "%s: submit_transaction, req %p (length %d)%s\n", 362 ep->ep.name, req, transaction_len, 363 req->last_transaction ? ", done" : ""); 364 365 memcpy_toio(ep->fifo, req->req.buf + req->req.actual, transaction_len); 366 usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY); 367 req->req.actual += transaction_len; 368 } 369 370 static void submit_request(struct usba_ep *ep, struct usba_request *req) 371 { 372 DBG(DBG_QUEUE, "%s: submit_request: req %p (length %d)\n", 373 ep->ep.name, req, req->req.length); 374 375 req->req.actual = 0; 376 req->submitted = 1; 377 378 if (req->using_dma) { 379 if (req->req.length == 0) { 380 usba_ep_writel(ep, CTL_ENB, USBA_TX_PK_RDY); 381 return; 382 } 383 384 if (req->req.zero) 385 usba_ep_writel(ep, CTL_ENB, USBA_SHORT_PACKET); 386 else 387 usba_ep_writel(ep, CTL_DIS, USBA_SHORT_PACKET); 388 389 usba_dma_writel(ep, ADDRESS, req->req.dma); 390 usba_dma_writel(ep, CONTROL, req->ctrl); 391 } else { 392 next_fifo_transaction(ep, req); 393 if (req->last_transaction) { 394 usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY); 395 usba_ep_writel(ep, CTL_ENB, USBA_TX_COMPLETE); 396 } else { 397 usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE); 398 usba_ep_writel(ep, CTL_ENB, USBA_TX_PK_RDY); 399 } 400 } 401 } 402 403 static void submit_next_request(struct usba_ep *ep) 404 { 405 struct usba_request *req; 406 407 if (list_empty(&ep->queue)) { 408 usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY | USBA_RX_BK_RDY); 409 return; 410 } 411 412 req = list_entry(ep->queue.next, struct usba_request, queue); 413 if (!req->submitted) 414 submit_request(ep, req); 415 } 416 417 static void send_status(struct usba_udc *udc, struct usba_ep *ep) 418 { 419 ep->state = STATUS_STAGE_IN; 420 usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY); 421 usba_ep_writel(ep, CTL_ENB, USBA_TX_COMPLETE); 422 } 423 424 static void receive_data(struct usba_ep *ep) 425 { 426 struct usba_udc *udc = ep->udc; 427 struct usba_request *req; 428 unsigned long status; 429 unsigned int bytecount, nr_busy; 430 int is_complete = 0; 431 432 status = usba_ep_readl(ep, STA); 433 nr_busy = USBA_BFEXT(BUSY_BANKS, status); 434 435 DBG(DBG_QUEUE, "receive data: nr_busy=%u\n", nr_busy); 436 437 while (nr_busy > 0) { 438 if (list_empty(&ep->queue)) { 439 usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY); 440 break; 441 } 442 req = list_entry(ep->queue.next, 443 struct usba_request, queue); 444 445 bytecount = USBA_BFEXT(BYTE_COUNT, status); 446 447 if (status & (1 << 31)) 448 is_complete = 1; 449 if (req->req.actual + bytecount >= req->req.length) { 450 is_complete = 1; 451 bytecount = req->req.length - req->req.actual; 452 } 453 454 memcpy_fromio(req->req.buf + req->req.actual, 455 ep->fifo, bytecount); 456 req->req.actual += bytecount; 457 458 usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY); 459 460 if (is_complete) { 461 DBG(DBG_QUEUE, "%s: request done\n", ep->ep.name); 462 req->req.status = 0; 463 list_del_init(&req->queue); 464 usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY); 465 spin_unlock(&udc->lock); 466 usb_gadget_giveback_request(&ep->ep, &req->req); 467 spin_lock(&udc->lock); 468 } 469 470 status = usba_ep_readl(ep, STA); 471 nr_busy = USBA_BFEXT(BUSY_BANKS, status); 472 473 if (is_complete && ep_is_control(ep)) { 474 send_status(udc, ep); 475 break; 476 } 477 } 478 } 479 480 static void 481 request_complete(struct usba_ep *ep, struct usba_request *req, int status) 482 { 483 struct usba_udc *udc = ep->udc; 484 485 WARN_ON(!list_empty(&req->queue)); 486 487 if (req->req.status == -EINPROGRESS) 488 req->req.status = status; 489 490 if (req->using_dma) 491 usb_gadget_unmap_request(&udc->gadget, &req->req, ep->is_in); 492 493 DBG(DBG_GADGET | DBG_REQ, 494 "%s: req %p complete: status %d, actual %u\n", 495 ep->ep.name, req, req->req.status, req->req.actual); 496 497 spin_unlock(&udc->lock); 498 usb_gadget_giveback_request(&ep->ep, &req->req); 499 spin_lock(&udc->lock); 500 } 501 502 static void 503 request_complete_list(struct usba_ep *ep, struct list_head *list, int status) 504 { 505 struct usba_request *req, *tmp_req; 506 507 list_for_each_entry_safe(req, tmp_req, list, queue) { 508 list_del_init(&req->queue); 509 request_complete(ep, req, status); 510 } 511 } 512 513 static int 514 usba_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) 515 { 516 struct usba_ep *ep = to_usba_ep(_ep); 517 struct usba_udc *udc = ep->udc; 518 unsigned long flags, ept_cfg, maxpacket; 519 unsigned int nr_trans; 520 521 DBG(DBG_GADGET, "%s: ep_enable: desc=%p\n", ep->ep.name, desc); 522 523 maxpacket = usb_endpoint_maxp(desc) & 0x7ff; 524 525 if (((desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK) != ep->index) 526 || ep->index == 0 527 || desc->bDescriptorType != USB_DT_ENDPOINT 528 || maxpacket == 0 529 || maxpacket > ep->fifo_size) { 530 DBG(DBG_ERR, "ep_enable: Invalid argument"); 531 return -EINVAL; 532 } 533 534 ep->is_isoc = 0; 535 ep->is_in = 0; 536 537 if (maxpacket <= 8) 538 ept_cfg = USBA_BF(EPT_SIZE, USBA_EPT_SIZE_8); 539 else 540 /* LSB is bit 1, not 0 */ 541 ept_cfg = USBA_BF(EPT_SIZE, fls(maxpacket - 1) - 3); 542 543 DBG(DBG_HW, "%s: EPT_SIZE = %lu (maxpacket = %lu)\n", 544 ep->ep.name, ept_cfg, maxpacket); 545 546 if (usb_endpoint_dir_in(desc)) { 547 ep->is_in = 1; 548 ept_cfg |= USBA_EPT_DIR_IN; 549 } 550 551 switch (usb_endpoint_type(desc)) { 552 case USB_ENDPOINT_XFER_CONTROL: 553 ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_CONTROL); 554 ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_ONE); 555 break; 556 case USB_ENDPOINT_XFER_ISOC: 557 if (!ep->can_isoc) { 558 DBG(DBG_ERR, "ep_enable: %s is not isoc capable\n", 559 ep->ep.name); 560 return -EINVAL; 561 } 562 563 /* 564 * Bits 11:12 specify number of _additional_ 565 * transactions per microframe. 566 */ 567 nr_trans = ((usb_endpoint_maxp(desc) >> 11) & 3) + 1; 568 if (nr_trans > 3) 569 return -EINVAL; 570 571 ep->is_isoc = 1; 572 ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_ISO); 573 574 /* 575 * Do triple-buffering on high-bandwidth iso endpoints. 576 */ 577 if (nr_trans > 1 && ep->nr_banks == 3) 578 ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_TRIPLE); 579 else 580 ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_DOUBLE); 581 ept_cfg |= USBA_BF(NB_TRANS, nr_trans); 582 break; 583 case USB_ENDPOINT_XFER_BULK: 584 ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_BULK); 585 ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_DOUBLE); 586 break; 587 case USB_ENDPOINT_XFER_INT: 588 ept_cfg |= USBA_BF(EPT_TYPE, USBA_EPT_TYPE_INT); 589 ept_cfg |= USBA_BF(BK_NUMBER, USBA_BK_NUMBER_DOUBLE); 590 break; 591 } 592 593 spin_lock_irqsave(&ep->udc->lock, flags); 594 595 ep->ep.desc = desc; 596 ep->ep.maxpacket = maxpacket; 597 598 usba_ep_writel(ep, CFG, ept_cfg); 599 usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE); 600 601 if (ep->can_dma) { 602 u32 ctrl; 603 604 usba_writel(udc, INT_ENB, 605 (usba_readl(udc, INT_ENB) 606 | USBA_BF(EPT_INT, 1 << ep->index) 607 | USBA_BF(DMA_INT, 1 << ep->index))); 608 ctrl = USBA_AUTO_VALID | USBA_INTDIS_DMA; 609 usba_ep_writel(ep, CTL_ENB, ctrl); 610 } else { 611 usba_writel(udc, INT_ENB, 612 (usba_readl(udc, INT_ENB) 613 | USBA_BF(EPT_INT, 1 << ep->index))); 614 } 615 616 spin_unlock_irqrestore(&udc->lock, flags); 617 618 DBG(DBG_HW, "EPT_CFG%d after init: %#08lx\n", ep->index, 619 (unsigned long)usba_ep_readl(ep, CFG)); 620 DBG(DBG_HW, "INT_ENB after init: %#08lx\n", 621 (unsigned long)usba_readl(udc, INT_ENB)); 622 623 return 0; 624 } 625 626 static int usba_ep_disable(struct usb_ep *_ep) 627 { 628 struct usba_ep *ep = to_usba_ep(_ep); 629 struct usba_udc *udc = ep->udc; 630 LIST_HEAD(req_list); 631 unsigned long flags; 632 633 DBG(DBG_GADGET, "ep_disable: %s\n", ep->ep.name); 634 635 spin_lock_irqsave(&udc->lock, flags); 636 637 if (!ep->ep.desc) { 638 spin_unlock_irqrestore(&udc->lock, flags); 639 /* REVISIT because this driver disables endpoints in 640 * reset_all_endpoints() before calling disconnect(), 641 * most gadget drivers would trigger this non-error ... 642 */ 643 if (udc->gadget.speed != USB_SPEED_UNKNOWN) 644 DBG(DBG_ERR, "ep_disable: %s not enabled\n", 645 ep->ep.name); 646 return -EINVAL; 647 } 648 ep->ep.desc = NULL; 649 650 list_splice_init(&ep->queue, &req_list); 651 if (ep->can_dma) { 652 usba_dma_writel(ep, CONTROL, 0); 653 usba_dma_writel(ep, ADDRESS, 0); 654 usba_dma_readl(ep, STATUS); 655 } 656 usba_ep_writel(ep, CTL_DIS, USBA_EPT_ENABLE); 657 usba_writel(udc, INT_ENB, 658 usba_readl(udc, INT_ENB) 659 & ~USBA_BF(EPT_INT, 1 << ep->index)); 660 661 request_complete_list(ep, &req_list, -ESHUTDOWN); 662 663 spin_unlock_irqrestore(&udc->lock, flags); 664 665 return 0; 666 } 667 668 static struct usb_request * 669 usba_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags) 670 { 671 struct usba_request *req; 672 673 DBG(DBG_GADGET, "ep_alloc_request: %p, 0x%x\n", _ep, gfp_flags); 674 675 req = kzalloc(sizeof(*req), gfp_flags); 676 if (!req) 677 return NULL; 678 679 INIT_LIST_HEAD(&req->queue); 680 681 return &req->req; 682 } 683 684 static void 685 usba_ep_free_request(struct usb_ep *_ep, struct usb_request *_req) 686 { 687 struct usba_request *req = to_usba_req(_req); 688 689 DBG(DBG_GADGET, "ep_free_request: %p, %p\n", _ep, _req); 690 691 kfree(req); 692 } 693 694 static int queue_dma(struct usba_udc *udc, struct usba_ep *ep, 695 struct usba_request *req, gfp_t gfp_flags) 696 { 697 unsigned long flags; 698 int ret; 699 700 DBG(DBG_DMA, "%s: req l/%u d/%08x %c%c%c\n", 701 ep->ep.name, req->req.length, req->req.dma, 702 req->req.zero ? 'Z' : 'z', 703 req->req.short_not_ok ? 'S' : 's', 704 req->req.no_interrupt ? 'I' : 'i'); 705 706 if (req->req.length > 0x10000) { 707 /* Lengths from 0 to 65536 (inclusive) are supported */ 708 DBG(DBG_ERR, "invalid request length %u\n", req->req.length); 709 return -EINVAL; 710 } 711 712 ret = usb_gadget_map_request(&udc->gadget, &req->req, ep->is_in); 713 if (ret) 714 return ret; 715 716 req->using_dma = 1; 717 req->ctrl = USBA_BF(DMA_BUF_LEN, req->req.length) 718 | USBA_DMA_CH_EN | USBA_DMA_END_BUF_IE 719 | USBA_DMA_END_TR_EN | USBA_DMA_END_TR_IE; 720 721 if (ep->is_in) 722 req->ctrl |= USBA_DMA_END_BUF_EN; 723 724 /* 725 * Add this request to the queue and submit for DMA if 726 * possible. Check if we're still alive first -- we may have 727 * received a reset since last time we checked. 728 */ 729 ret = -ESHUTDOWN; 730 spin_lock_irqsave(&udc->lock, flags); 731 if (ep->ep.desc) { 732 if (list_empty(&ep->queue)) 733 submit_request(ep, req); 734 735 list_add_tail(&req->queue, &ep->queue); 736 ret = 0; 737 } 738 spin_unlock_irqrestore(&udc->lock, flags); 739 740 return ret; 741 } 742 743 static int 744 usba_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags) 745 { 746 struct usba_request *req = to_usba_req(_req); 747 struct usba_ep *ep = to_usba_ep(_ep); 748 struct usba_udc *udc = ep->udc; 749 unsigned long flags; 750 int ret; 751 752 DBG(DBG_GADGET | DBG_QUEUE | DBG_REQ, "%s: queue req %p, len %u\n", 753 ep->ep.name, req, _req->length); 754 755 if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN || 756 !ep->ep.desc) 757 return -ESHUTDOWN; 758 759 req->submitted = 0; 760 req->using_dma = 0; 761 req->last_transaction = 0; 762 763 _req->status = -EINPROGRESS; 764 _req->actual = 0; 765 766 if (ep->can_dma) 767 return queue_dma(udc, ep, req, gfp_flags); 768 769 /* May have received a reset since last time we checked */ 770 ret = -ESHUTDOWN; 771 spin_lock_irqsave(&udc->lock, flags); 772 if (ep->ep.desc) { 773 list_add_tail(&req->queue, &ep->queue); 774 775 if ((!ep_is_control(ep) && ep->is_in) || 776 (ep_is_control(ep) 777 && (ep->state == DATA_STAGE_IN 778 || ep->state == STATUS_STAGE_IN))) 779 usba_ep_writel(ep, CTL_ENB, USBA_TX_PK_RDY); 780 else 781 usba_ep_writel(ep, CTL_ENB, USBA_RX_BK_RDY); 782 ret = 0; 783 } 784 spin_unlock_irqrestore(&udc->lock, flags); 785 786 return ret; 787 } 788 789 static void 790 usba_update_req(struct usba_ep *ep, struct usba_request *req, u32 status) 791 { 792 req->req.actual = req->req.length - USBA_BFEXT(DMA_BUF_LEN, status); 793 } 794 795 static int stop_dma(struct usba_ep *ep, u32 *pstatus) 796 { 797 unsigned int timeout; 798 u32 status; 799 800 /* 801 * Stop the DMA controller. When writing both CH_EN 802 * and LINK to 0, the other bits are not affected. 803 */ 804 usba_dma_writel(ep, CONTROL, 0); 805 806 /* Wait for the FIFO to empty */ 807 for (timeout = 40; timeout; --timeout) { 808 status = usba_dma_readl(ep, STATUS); 809 if (!(status & USBA_DMA_CH_EN)) 810 break; 811 udelay(1); 812 } 813 814 if (pstatus) 815 *pstatus = status; 816 817 if (timeout == 0) { 818 dev_err(&ep->udc->pdev->dev, 819 "%s: timed out waiting for DMA FIFO to empty\n", 820 ep->ep.name); 821 return -ETIMEDOUT; 822 } 823 824 return 0; 825 } 826 827 static int usba_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req) 828 { 829 struct usba_ep *ep = to_usba_ep(_ep); 830 struct usba_udc *udc = ep->udc; 831 struct usba_request *req = to_usba_req(_req); 832 unsigned long flags; 833 u32 status; 834 835 DBG(DBG_GADGET | DBG_QUEUE, "ep_dequeue: %s, req %p\n", 836 ep->ep.name, req); 837 838 spin_lock_irqsave(&udc->lock, flags); 839 840 if (req->using_dma) { 841 /* 842 * If this request is currently being transferred, 843 * stop the DMA controller and reset the FIFO. 844 */ 845 if (ep->queue.next == &req->queue) { 846 status = usba_dma_readl(ep, STATUS); 847 if (status & USBA_DMA_CH_EN) 848 stop_dma(ep, &status); 849 850 #ifdef CONFIG_USB_GADGET_DEBUG_FS 851 ep->last_dma_status = status; 852 #endif 853 854 usba_writel(udc, EPT_RST, 1 << ep->index); 855 856 usba_update_req(ep, req, status); 857 } 858 } 859 860 /* 861 * Errors should stop the queue from advancing until the 862 * completion function returns. 863 */ 864 list_del_init(&req->queue); 865 866 request_complete(ep, req, -ECONNRESET); 867 868 /* Process the next request if any */ 869 submit_next_request(ep); 870 spin_unlock_irqrestore(&udc->lock, flags); 871 872 return 0; 873 } 874 875 static int usba_ep_set_halt(struct usb_ep *_ep, int value) 876 { 877 struct usba_ep *ep = to_usba_ep(_ep); 878 struct usba_udc *udc = ep->udc; 879 unsigned long flags; 880 int ret = 0; 881 882 DBG(DBG_GADGET, "endpoint %s: %s HALT\n", ep->ep.name, 883 value ? "set" : "clear"); 884 885 if (!ep->ep.desc) { 886 DBG(DBG_ERR, "Attempted to halt uninitialized ep %s\n", 887 ep->ep.name); 888 return -ENODEV; 889 } 890 if (ep->is_isoc) { 891 DBG(DBG_ERR, "Attempted to halt isochronous ep %s\n", 892 ep->ep.name); 893 return -ENOTTY; 894 } 895 896 spin_lock_irqsave(&udc->lock, flags); 897 898 /* 899 * We can't halt IN endpoints while there are still data to be 900 * transferred 901 */ 902 if (!list_empty(&ep->queue) 903 || ((value && ep->is_in && (usba_ep_readl(ep, STA) 904 & USBA_BF(BUSY_BANKS, -1L))))) { 905 ret = -EAGAIN; 906 } else { 907 if (value) 908 usba_ep_writel(ep, SET_STA, USBA_FORCE_STALL); 909 else 910 usba_ep_writel(ep, CLR_STA, 911 USBA_FORCE_STALL | USBA_TOGGLE_CLR); 912 usba_ep_readl(ep, STA); 913 } 914 915 spin_unlock_irqrestore(&udc->lock, flags); 916 917 return ret; 918 } 919 920 static int usba_ep_fifo_status(struct usb_ep *_ep) 921 { 922 struct usba_ep *ep = to_usba_ep(_ep); 923 924 return USBA_BFEXT(BYTE_COUNT, usba_ep_readl(ep, STA)); 925 } 926 927 static void usba_ep_fifo_flush(struct usb_ep *_ep) 928 { 929 struct usba_ep *ep = to_usba_ep(_ep); 930 struct usba_udc *udc = ep->udc; 931 932 usba_writel(udc, EPT_RST, 1 << ep->index); 933 } 934 935 static const struct usb_ep_ops usba_ep_ops = { 936 .enable = usba_ep_enable, 937 .disable = usba_ep_disable, 938 .alloc_request = usba_ep_alloc_request, 939 .free_request = usba_ep_free_request, 940 .queue = usba_ep_queue, 941 .dequeue = usba_ep_dequeue, 942 .set_halt = usba_ep_set_halt, 943 .fifo_status = usba_ep_fifo_status, 944 .fifo_flush = usba_ep_fifo_flush, 945 }; 946 947 static int usba_udc_get_frame(struct usb_gadget *gadget) 948 { 949 struct usba_udc *udc = to_usba_udc(gadget); 950 951 return USBA_BFEXT(FRAME_NUMBER, usba_readl(udc, FNUM)); 952 } 953 954 static int usba_udc_wakeup(struct usb_gadget *gadget) 955 { 956 struct usba_udc *udc = to_usba_udc(gadget); 957 unsigned long flags; 958 u32 ctrl; 959 int ret = -EINVAL; 960 961 spin_lock_irqsave(&udc->lock, flags); 962 if (udc->devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) { 963 ctrl = usba_readl(udc, CTRL); 964 usba_writel(udc, CTRL, ctrl | USBA_REMOTE_WAKE_UP); 965 ret = 0; 966 } 967 spin_unlock_irqrestore(&udc->lock, flags); 968 969 return ret; 970 } 971 972 static int 973 usba_udc_set_selfpowered(struct usb_gadget *gadget, int is_selfpowered) 974 { 975 struct usba_udc *udc = to_usba_udc(gadget); 976 unsigned long flags; 977 978 spin_lock_irqsave(&udc->lock, flags); 979 if (is_selfpowered) 980 udc->devstatus |= 1 << USB_DEVICE_SELF_POWERED; 981 else 982 udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED); 983 spin_unlock_irqrestore(&udc->lock, flags); 984 985 return 0; 986 } 987 988 static int atmel_usba_start(struct usb_gadget *gadget, 989 struct usb_gadget_driver *driver); 990 static int atmel_usba_stop(struct usb_gadget *gadget); 991 992 static const struct usb_gadget_ops usba_udc_ops = { 993 .get_frame = usba_udc_get_frame, 994 .wakeup = usba_udc_wakeup, 995 .set_selfpowered = usba_udc_set_selfpowered, 996 .udc_start = atmel_usba_start, 997 .udc_stop = atmel_usba_stop, 998 }; 999 1000 static struct usb_endpoint_descriptor usba_ep0_desc = { 1001 .bLength = USB_DT_ENDPOINT_SIZE, 1002 .bDescriptorType = USB_DT_ENDPOINT, 1003 .bEndpointAddress = 0, 1004 .bmAttributes = USB_ENDPOINT_XFER_CONTROL, 1005 .wMaxPacketSize = cpu_to_le16(64), 1006 /* FIXME: I have no idea what to put here */ 1007 .bInterval = 1, 1008 }; 1009 1010 static struct usb_gadget usba_gadget_template = { 1011 .ops = &usba_udc_ops, 1012 .max_speed = USB_SPEED_HIGH, 1013 .name = "atmel_usba_udc", 1014 }; 1015 1016 /* 1017 * Called with interrupts disabled and udc->lock held. 1018 */ 1019 static void reset_all_endpoints(struct usba_udc *udc) 1020 { 1021 struct usba_ep *ep; 1022 struct usba_request *req, *tmp_req; 1023 1024 usba_writel(udc, EPT_RST, ~0UL); 1025 1026 ep = to_usba_ep(udc->gadget.ep0); 1027 list_for_each_entry_safe(req, tmp_req, &ep->queue, queue) { 1028 list_del_init(&req->queue); 1029 request_complete(ep, req, -ECONNRESET); 1030 } 1031 1032 /* NOTE: normally, the next call to the gadget driver is in 1033 * charge of disabling endpoints... usually disconnect(). 1034 * The exception would be entering a high speed test mode. 1035 * 1036 * FIXME remove this code ... and retest thoroughly. 1037 */ 1038 list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) { 1039 if (ep->ep.desc) { 1040 spin_unlock(&udc->lock); 1041 usba_ep_disable(&ep->ep); 1042 spin_lock(&udc->lock); 1043 } 1044 } 1045 } 1046 1047 static struct usba_ep *get_ep_by_addr(struct usba_udc *udc, u16 wIndex) 1048 { 1049 struct usba_ep *ep; 1050 1051 if ((wIndex & USB_ENDPOINT_NUMBER_MASK) == 0) 1052 return to_usba_ep(udc->gadget.ep0); 1053 1054 list_for_each_entry (ep, &udc->gadget.ep_list, ep.ep_list) { 1055 u8 bEndpointAddress; 1056 1057 if (!ep->ep.desc) 1058 continue; 1059 bEndpointAddress = ep->ep.desc->bEndpointAddress; 1060 if ((wIndex ^ bEndpointAddress) & USB_DIR_IN) 1061 continue; 1062 if ((bEndpointAddress & USB_ENDPOINT_NUMBER_MASK) 1063 == (wIndex & USB_ENDPOINT_NUMBER_MASK)) 1064 return ep; 1065 } 1066 1067 return NULL; 1068 } 1069 1070 /* Called with interrupts disabled and udc->lock held */ 1071 static inline void set_protocol_stall(struct usba_udc *udc, struct usba_ep *ep) 1072 { 1073 usba_ep_writel(ep, SET_STA, USBA_FORCE_STALL); 1074 ep->state = WAIT_FOR_SETUP; 1075 } 1076 1077 static inline int is_stalled(struct usba_udc *udc, struct usba_ep *ep) 1078 { 1079 if (usba_ep_readl(ep, STA) & USBA_FORCE_STALL) 1080 return 1; 1081 return 0; 1082 } 1083 1084 static inline void set_address(struct usba_udc *udc, unsigned int addr) 1085 { 1086 u32 regval; 1087 1088 DBG(DBG_BUS, "setting address %u...\n", addr); 1089 regval = usba_readl(udc, CTRL); 1090 regval = USBA_BFINS(DEV_ADDR, addr, regval); 1091 usba_writel(udc, CTRL, regval); 1092 } 1093 1094 static int do_test_mode(struct usba_udc *udc) 1095 { 1096 static const char test_packet_buffer[] = { 1097 /* JKJKJKJK * 9 */ 1098 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1099 /* JJKKJJKK * 8 */ 1100 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 1101 /* JJKKJJKK * 8 */ 1102 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 1103 /* JJJJJJJKKKKKKK * 8 */ 1104 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 1105 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 1106 /* JJJJJJJK * 8 */ 1107 0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 1108 /* {JKKKKKKK * 10}, JK */ 1109 0xFC, 0x7E, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0x7E 1110 }; 1111 struct usba_ep *ep; 1112 struct device *dev = &udc->pdev->dev; 1113 int test_mode; 1114 1115 test_mode = udc->test_mode; 1116 1117 /* Start from a clean slate */ 1118 reset_all_endpoints(udc); 1119 1120 switch (test_mode) { 1121 case 0x0100: 1122 /* Test_J */ 1123 usba_writel(udc, TST, USBA_TST_J_MODE); 1124 dev_info(dev, "Entering Test_J mode...\n"); 1125 break; 1126 case 0x0200: 1127 /* Test_K */ 1128 usba_writel(udc, TST, USBA_TST_K_MODE); 1129 dev_info(dev, "Entering Test_K mode...\n"); 1130 break; 1131 case 0x0300: 1132 /* 1133 * Test_SE0_NAK: Force high-speed mode and set up ep0 1134 * for Bulk IN transfers 1135 */ 1136 ep = &udc->usba_ep[0]; 1137 usba_writel(udc, TST, 1138 USBA_BF(SPEED_CFG, USBA_SPEED_CFG_FORCE_HIGH)); 1139 usba_ep_writel(ep, CFG, 1140 USBA_BF(EPT_SIZE, USBA_EPT_SIZE_64) 1141 | USBA_EPT_DIR_IN 1142 | USBA_BF(EPT_TYPE, USBA_EPT_TYPE_BULK) 1143 | USBA_BF(BK_NUMBER, 1)); 1144 if (!(usba_ep_readl(ep, CFG) & USBA_EPT_MAPPED)) { 1145 set_protocol_stall(udc, ep); 1146 dev_err(dev, "Test_SE0_NAK: ep0 not mapped\n"); 1147 } else { 1148 usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE); 1149 dev_info(dev, "Entering Test_SE0_NAK mode...\n"); 1150 } 1151 break; 1152 case 0x0400: 1153 /* Test_Packet */ 1154 ep = &udc->usba_ep[0]; 1155 usba_ep_writel(ep, CFG, 1156 USBA_BF(EPT_SIZE, USBA_EPT_SIZE_64) 1157 | USBA_EPT_DIR_IN 1158 | USBA_BF(EPT_TYPE, USBA_EPT_TYPE_BULK) 1159 | USBA_BF(BK_NUMBER, 1)); 1160 if (!(usba_ep_readl(ep, CFG) & USBA_EPT_MAPPED)) { 1161 set_protocol_stall(udc, ep); 1162 dev_err(dev, "Test_Packet: ep0 not mapped\n"); 1163 } else { 1164 usba_ep_writel(ep, CTL_ENB, USBA_EPT_ENABLE); 1165 usba_writel(udc, TST, USBA_TST_PKT_MODE); 1166 memcpy_toio(ep->fifo, test_packet_buffer, 1167 sizeof(test_packet_buffer)); 1168 usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY); 1169 dev_info(dev, "Entering Test_Packet mode...\n"); 1170 } 1171 break; 1172 default: 1173 dev_err(dev, "Invalid test mode: 0x%04x\n", test_mode); 1174 return -EINVAL; 1175 } 1176 1177 return 0; 1178 } 1179 1180 /* Avoid overly long expressions */ 1181 static inline bool feature_is_dev_remote_wakeup(struct usb_ctrlrequest *crq) 1182 { 1183 if (crq->wValue == cpu_to_le16(USB_DEVICE_REMOTE_WAKEUP)) 1184 return true; 1185 return false; 1186 } 1187 1188 static inline bool feature_is_dev_test_mode(struct usb_ctrlrequest *crq) 1189 { 1190 if (crq->wValue == cpu_to_le16(USB_DEVICE_TEST_MODE)) 1191 return true; 1192 return false; 1193 } 1194 1195 static inline bool feature_is_ep_halt(struct usb_ctrlrequest *crq) 1196 { 1197 if (crq->wValue == cpu_to_le16(USB_ENDPOINT_HALT)) 1198 return true; 1199 return false; 1200 } 1201 1202 static int handle_ep0_setup(struct usba_udc *udc, struct usba_ep *ep, 1203 struct usb_ctrlrequest *crq) 1204 { 1205 int retval = 0; 1206 1207 switch (crq->bRequest) { 1208 case USB_REQ_GET_STATUS: { 1209 u16 status; 1210 1211 if (crq->bRequestType == (USB_DIR_IN | USB_RECIP_DEVICE)) { 1212 status = cpu_to_le16(udc->devstatus); 1213 } else if (crq->bRequestType 1214 == (USB_DIR_IN | USB_RECIP_INTERFACE)) { 1215 status = cpu_to_le16(0); 1216 } else if (crq->bRequestType 1217 == (USB_DIR_IN | USB_RECIP_ENDPOINT)) { 1218 struct usba_ep *target; 1219 1220 target = get_ep_by_addr(udc, le16_to_cpu(crq->wIndex)); 1221 if (!target) 1222 goto stall; 1223 1224 status = 0; 1225 if (is_stalled(udc, target)) 1226 status |= cpu_to_le16(1); 1227 } else 1228 goto delegate; 1229 1230 /* Write directly to the FIFO. No queueing is done. */ 1231 if (crq->wLength != cpu_to_le16(sizeof(status))) 1232 goto stall; 1233 ep->state = DATA_STAGE_IN; 1234 __raw_writew(status, ep->fifo); 1235 usba_ep_writel(ep, SET_STA, USBA_TX_PK_RDY); 1236 break; 1237 } 1238 1239 case USB_REQ_CLEAR_FEATURE: { 1240 if (crq->bRequestType == USB_RECIP_DEVICE) { 1241 if (feature_is_dev_remote_wakeup(crq)) 1242 udc->devstatus 1243 &= ~(1 << USB_DEVICE_REMOTE_WAKEUP); 1244 else 1245 /* Can't CLEAR_FEATURE TEST_MODE */ 1246 goto stall; 1247 } else if (crq->bRequestType == USB_RECIP_ENDPOINT) { 1248 struct usba_ep *target; 1249 1250 if (crq->wLength != cpu_to_le16(0) 1251 || !feature_is_ep_halt(crq)) 1252 goto stall; 1253 target = get_ep_by_addr(udc, le16_to_cpu(crq->wIndex)); 1254 if (!target) 1255 goto stall; 1256 1257 usba_ep_writel(target, CLR_STA, USBA_FORCE_STALL); 1258 if (target->index != 0) 1259 usba_ep_writel(target, CLR_STA, 1260 USBA_TOGGLE_CLR); 1261 } else { 1262 goto delegate; 1263 } 1264 1265 send_status(udc, ep); 1266 break; 1267 } 1268 1269 case USB_REQ_SET_FEATURE: { 1270 if (crq->bRequestType == USB_RECIP_DEVICE) { 1271 if (feature_is_dev_test_mode(crq)) { 1272 send_status(udc, ep); 1273 ep->state = STATUS_STAGE_TEST; 1274 udc->test_mode = le16_to_cpu(crq->wIndex); 1275 return 0; 1276 } else if (feature_is_dev_remote_wakeup(crq)) { 1277 udc->devstatus |= 1 << USB_DEVICE_REMOTE_WAKEUP; 1278 } else { 1279 goto stall; 1280 } 1281 } else if (crq->bRequestType == USB_RECIP_ENDPOINT) { 1282 struct usba_ep *target; 1283 1284 if (crq->wLength != cpu_to_le16(0) 1285 || !feature_is_ep_halt(crq)) 1286 goto stall; 1287 1288 target = get_ep_by_addr(udc, le16_to_cpu(crq->wIndex)); 1289 if (!target) 1290 goto stall; 1291 1292 usba_ep_writel(target, SET_STA, USBA_FORCE_STALL); 1293 } else 1294 goto delegate; 1295 1296 send_status(udc, ep); 1297 break; 1298 } 1299 1300 case USB_REQ_SET_ADDRESS: 1301 if (crq->bRequestType != (USB_DIR_OUT | USB_RECIP_DEVICE)) 1302 goto delegate; 1303 1304 set_address(udc, le16_to_cpu(crq->wValue)); 1305 send_status(udc, ep); 1306 ep->state = STATUS_STAGE_ADDR; 1307 break; 1308 1309 default: 1310 delegate: 1311 spin_unlock(&udc->lock); 1312 retval = udc->driver->setup(&udc->gadget, crq); 1313 spin_lock(&udc->lock); 1314 } 1315 1316 return retval; 1317 1318 stall: 1319 pr_err("udc: %s: Invalid setup request: %02x.%02x v%04x i%04x l%d, " 1320 "halting endpoint...\n", 1321 ep->ep.name, crq->bRequestType, crq->bRequest, 1322 le16_to_cpu(crq->wValue), le16_to_cpu(crq->wIndex), 1323 le16_to_cpu(crq->wLength)); 1324 set_protocol_stall(udc, ep); 1325 return -1; 1326 } 1327 1328 static void usba_control_irq(struct usba_udc *udc, struct usba_ep *ep) 1329 { 1330 struct usba_request *req; 1331 u32 epstatus; 1332 u32 epctrl; 1333 1334 restart: 1335 epstatus = usba_ep_readl(ep, STA); 1336 epctrl = usba_ep_readl(ep, CTL); 1337 1338 DBG(DBG_INT, "%s [%d]: s/%08x c/%08x\n", 1339 ep->ep.name, ep->state, epstatus, epctrl); 1340 1341 req = NULL; 1342 if (!list_empty(&ep->queue)) 1343 req = list_entry(ep->queue.next, 1344 struct usba_request, queue); 1345 1346 if ((epctrl & USBA_TX_PK_RDY) && !(epstatus & USBA_TX_PK_RDY)) { 1347 if (req->submitted) 1348 next_fifo_transaction(ep, req); 1349 else 1350 submit_request(ep, req); 1351 1352 if (req->last_transaction) { 1353 usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY); 1354 usba_ep_writel(ep, CTL_ENB, USBA_TX_COMPLETE); 1355 } 1356 goto restart; 1357 } 1358 if ((epstatus & epctrl) & USBA_TX_COMPLETE) { 1359 usba_ep_writel(ep, CLR_STA, USBA_TX_COMPLETE); 1360 1361 switch (ep->state) { 1362 case DATA_STAGE_IN: 1363 usba_ep_writel(ep, CTL_ENB, USBA_RX_BK_RDY); 1364 usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE); 1365 ep->state = STATUS_STAGE_OUT; 1366 break; 1367 case STATUS_STAGE_ADDR: 1368 /* Activate our new address */ 1369 usba_writel(udc, CTRL, (usba_readl(udc, CTRL) 1370 | USBA_FADDR_EN)); 1371 usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE); 1372 ep->state = WAIT_FOR_SETUP; 1373 break; 1374 case STATUS_STAGE_IN: 1375 if (req) { 1376 list_del_init(&req->queue); 1377 request_complete(ep, req, 0); 1378 submit_next_request(ep); 1379 } 1380 usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE); 1381 ep->state = WAIT_FOR_SETUP; 1382 break; 1383 case STATUS_STAGE_TEST: 1384 usba_ep_writel(ep, CTL_DIS, USBA_TX_COMPLETE); 1385 ep->state = WAIT_FOR_SETUP; 1386 if (do_test_mode(udc)) 1387 set_protocol_stall(udc, ep); 1388 break; 1389 default: 1390 pr_err("udc: %s: TXCOMP: Invalid endpoint state %d, " 1391 "halting endpoint...\n", 1392 ep->ep.name, ep->state); 1393 set_protocol_stall(udc, ep); 1394 break; 1395 } 1396 1397 goto restart; 1398 } 1399 if ((epstatus & epctrl) & USBA_RX_BK_RDY) { 1400 switch (ep->state) { 1401 case STATUS_STAGE_OUT: 1402 usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY); 1403 usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY); 1404 1405 if (req) { 1406 list_del_init(&req->queue); 1407 request_complete(ep, req, 0); 1408 } 1409 ep->state = WAIT_FOR_SETUP; 1410 break; 1411 1412 case DATA_STAGE_OUT: 1413 receive_data(ep); 1414 break; 1415 1416 default: 1417 usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY); 1418 usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY); 1419 pr_err("udc: %s: RXRDY: Invalid endpoint state %d, " 1420 "halting endpoint...\n", 1421 ep->ep.name, ep->state); 1422 set_protocol_stall(udc, ep); 1423 break; 1424 } 1425 1426 goto restart; 1427 } 1428 if (epstatus & USBA_RX_SETUP) { 1429 union { 1430 struct usb_ctrlrequest crq; 1431 unsigned long data[2]; 1432 } crq; 1433 unsigned int pkt_len; 1434 int ret; 1435 1436 if (ep->state != WAIT_FOR_SETUP) { 1437 /* 1438 * Didn't expect a SETUP packet at this 1439 * point. Clean up any pending requests (which 1440 * may be successful). 1441 */ 1442 int status = -EPROTO; 1443 1444 /* 1445 * RXRDY and TXCOMP are dropped when SETUP 1446 * packets arrive. Just pretend we received 1447 * the status packet. 1448 */ 1449 if (ep->state == STATUS_STAGE_OUT 1450 || ep->state == STATUS_STAGE_IN) { 1451 usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY); 1452 status = 0; 1453 } 1454 1455 if (req) { 1456 list_del_init(&req->queue); 1457 request_complete(ep, req, status); 1458 } 1459 } 1460 1461 pkt_len = USBA_BFEXT(BYTE_COUNT, usba_ep_readl(ep, STA)); 1462 DBG(DBG_HW, "Packet length: %u\n", pkt_len); 1463 if (pkt_len != sizeof(crq)) { 1464 pr_warning("udc: Invalid packet length %u " 1465 "(expected %zu)\n", pkt_len, sizeof(crq)); 1466 set_protocol_stall(udc, ep); 1467 return; 1468 } 1469 1470 DBG(DBG_FIFO, "Copying ctrl request from 0x%p:\n", ep->fifo); 1471 memcpy_fromio(crq.data, ep->fifo, sizeof(crq)); 1472 1473 /* Free up one bank in the FIFO so that we can 1474 * generate or receive a reply right away. */ 1475 usba_ep_writel(ep, CLR_STA, USBA_RX_SETUP); 1476 1477 /* printk(KERN_DEBUG "setup: %d: %02x.%02x\n", 1478 ep->state, crq.crq.bRequestType, 1479 crq.crq.bRequest); */ 1480 1481 if (crq.crq.bRequestType & USB_DIR_IN) { 1482 /* 1483 * The USB 2.0 spec states that "if wLength is 1484 * zero, there is no data transfer phase." 1485 * However, testusb #14 seems to actually 1486 * expect a data phase even if wLength = 0... 1487 */ 1488 ep->state = DATA_STAGE_IN; 1489 } else { 1490 if (crq.crq.wLength != cpu_to_le16(0)) 1491 ep->state = DATA_STAGE_OUT; 1492 else 1493 ep->state = STATUS_STAGE_IN; 1494 } 1495 1496 ret = -1; 1497 if (ep->index == 0) 1498 ret = handle_ep0_setup(udc, ep, &crq.crq); 1499 else { 1500 spin_unlock(&udc->lock); 1501 ret = udc->driver->setup(&udc->gadget, &crq.crq); 1502 spin_lock(&udc->lock); 1503 } 1504 1505 DBG(DBG_BUS, "req %02x.%02x, length %d, state %d, ret %d\n", 1506 crq.crq.bRequestType, crq.crq.bRequest, 1507 le16_to_cpu(crq.crq.wLength), ep->state, ret); 1508 1509 if (ret < 0) { 1510 /* Let the host know that we failed */ 1511 set_protocol_stall(udc, ep); 1512 } 1513 } 1514 } 1515 1516 static void usba_ep_irq(struct usba_udc *udc, struct usba_ep *ep) 1517 { 1518 struct usba_request *req; 1519 u32 epstatus; 1520 u32 epctrl; 1521 1522 epstatus = usba_ep_readl(ep, STA); 1523 epctrl = usba_ep_readl(ep, CTL); 1524 1525 DBG(DBG_INT, "%s: interrupt, status: 0x%08x\n", ep->ep.name, epstatus); 1526 1527 while ((epctrl & USBA_TX_PK_RDY) && !(epstatus & USBA_TX_PK_RDY)) { 1528 DBG(DBG_BUS, "%s: TX PK ready\n", ep->ep.name); 1529 1530 if (list_empty(&ep->queue)) { 1531 dev_warn(&udc->pdev->dev, "ep_irq: queue empty\n"); 1532 usba_ep_writel(ep, CTL_DIS, USBA_TX_PK_RDY); 1533 return; 1534 } 1535 1536 req = list_entry(ep->queue.next, struct usba_request, queue); 1537 1538 if (req->using_dma) { 1539 /* Send a zero-length packet */ 1540 usba_ep_writel(ep, SET_STA, 1541 USBA_TX_PK_RDY); 1542 usba_ep_writel(ep, CTL_DIS, 1543 USBA_TX_PK_RDY); 1544 list_del_init(&req->queue); 1545 submit_next_request(ep); 1546 request_complete(ep, req, 0); 1547 } else { 1548 if (req->submitted) 1549 next_fifo_transaction(ep, req); 1550 else 1551 submit_request(ep, req); 1552 1553 if (req->last_transaction) { 1554 list_del_init(&req->queue); 1555 submit_next_request(ep); 1556 request_complete(ep, req, 0); 1557 } 1558 } 1559 1560 epstatus = usba_ep_readl(ep, STA); 1561 epctrl = usba_ep_readl(ep, CTL); 1562 } 1563 if ((epstatus & epctrl) & USBA_RX_BK_RDY) { 1564 DBG(DBG_BUS, "%s: RX data ready\n", ep->ep.name); 1565 receive_data(ep); 1566 usba_ep_writel(ep, CLR_STA, USBA_RX_BK_RDY); 1567 } 1568 } 1569 1570 static void usba_dma_irq(struct usba_udc *udc, struct usba_ep *ep) 1571 { 1572 struct usba_request *req; 1573 u32 status, control, pending; 1574 1575 status = usba_dma_readl(ep, STATUS); 1576 control = usba_dma_readl(ep, CONTROL); 1577 #ifdef CONFIG_USB_GADGET_DEBUG_FS 1578 ep->last_dma_status = status; 1579 #endif 1580 pending = status & control; 1581 DBG(DBG_INT | DBG_DMA, "dma irq, s/%#08x, c/%#08x\n", status, control); 1582 1583 if (status & USBA_DMA_CH_EN) { 1584 dev_err(&udc->pdev->dev, 1585 "DMA_CH_EN is set after transfer is finished!\n"); 1586 dev_err(&udc->pdev->dev, 1587 "status=%#08x, pending=%#08x, control=%#08x\n", 1588 status, pending, control); 1589 1590 /* 1591 * try to pretend nothing happened. We might have to 1592 * do something here... 1593 */ 1594 } 1595 1596 if (list_empty(&ep->queue)) 1597 /* Might happen if a reset comes along at the right moment */ 1598 return; 1599 1600 if (pending & (USBA_DMA_END_TR_ST | USBA_DMA_END_BUF_ST)) { 1601 req = list_entry(ep->queue.next, struct usba_request, queue); 1602 usba_update_req(ep, req, status); 1603 1604 list_del_init(&req->queue); 1605 submit_next_request(ep); 1606 request_complete(ep, req, 0); 1607 } 1608 } 1609 1610 static irqreturn_t usba_udc_irq(int irq, void *devid) 1611 { 1612 struct usba_udc *udc = devid; 1613 u32 status; 1614 u32 dma_status; 1615 u32 ep_status; 1616 1617 spin_lock(&udc->lock); 1618 1619 status = usba_readl(udc, INT_STA); 1620 DBG(DBG_INT, "irq, status=%#08x\n", status); 1621 1622 if (status & USBA_DET_SUSPEND) { 1623 toggle_bias(0); 1624 usba_writel(udc, INT_CLR, USBA_DET_SUSPEND); 1625 DBG(DBG_BUS, "Suspend detected\n"); 1626 if (udc->gadget.speed != USB_SPEED_UNKNOWN 1627 && udc->driver && udc->driver->suspend) { 1628 spin_unlock(&udc->lock); 1629 udc->driver->suspend(&udc->gadget); 1630 spin_lock(&udc->lock); 1631 } 1632 } 1633 1634 if (status & USBA_WAKE_UP) { 1635 toggle_bias(1); 1636 usba_writel(udc, INT_CLR, USBA_WAKE_UP); 1637 DBG(DBG_BUS, "Wake Up CPU detected\n"); 1638 } 1639 1640 if (status & USBA_END_OF_RESUME) { 1641 usba_writel(udc, INT_CLR, USBA_END_OF_RESUME); 1642 DBG(DBG_BUS, "Resume detected\n"); 1643 if (udc->gadget.speed != USB_SPEED_UNKNOWN 1644 && udc->driver && udc->driver->resume) { 1645 spin_unlock(&udc->lock); 1646 udc->driver->resume(&udc->gadget); 1647 spin_lock(&udc->lock); 1648 } 1649 } 1650 1651 dma_status = USBA_BFEXT(DMA_INT, status); 1652 if (dma_status) { 1653 int i; 1654 1655 for (i = 1; i <= USBA_NR_DMAS; i++) 1656 if (dma_status & (1 << i)) 1657 usba_dma_irq(udc, &udc->usba_ep[i]); 1658 } 1659 1660 ep_status = USBA_BFEXT(EPT_INT, status); 1661 if (ep_status) { 1662 int i; 1663 1664 for (i = 0; i < udc->num_ep; i++) 1665 if (ep_status & (1 << i)) { 1666 if (ep_is_control(&udc->usba_ep[i])) 1667 usba_control_irq(udc, &udc->usba_ep[i]); 1668 else 1669 usba_ep_irq(udc, &udc->usba_ep[i]); 1670 } 1671 } 1672 1673 if (status & USBA_END_OF_RESET) { 1674 struct usba_ep *ep0; 1675 1676 usba_writel(udc, INT_CLR, USBA_END_OF_RESET); 1677 reset_all_endpoints(udc); 1678 1679 if (udc->gadget.speed != USB_SPEED_UNKNOWN && udc->driver) { 1680 udc->gadget.speed = USB_SPEED_UNKNOWN; 1681 spin_unlock(&udc->lock); 1682 usb_gadget_udc_reset(&udc->gadget, udc->driver); 1683 spin_lock(&udc->lock); 1684 } 1685 1686 if (status & USBA_HIGH_SPEED) 1687 udc->gadget.speed = USB_SPEED_HIGH; 1688 else 1689 udc->gadget.speed = USB_SPEED_FULL; 1690 DBG(DBG_BUS, "%s bus reset detected\n", 1691 usb_speed_string(udc->gadget.speed)); 1692 1693 ep0 = &udc->usba_ep[0]; 1694 ep0->ep.desc = &usba_ep0_desc; 1695 ep0->state = WAIT_FOR_SETUP; 1696 usba_ep_writel(ep0, CFG, 1697 (USBA_BF(EPT_SIZE, EP0_EPT_SIZE) 1698 | USBA_BF(EPT_TYPE, USBA_EPT_TYPE_CONTROL) 1699 | USBA_BF(BK_NUMBER, USBA_BK_NUMBER_ONE))); 1700 usba_ep_writel(ep0, CTL_ENB, 1701 USBA_EPT_ENABLE | USBA_RX_SETUP); 1702 usba_writel(udc, INT_ENB, 1703 (usba_readl(udc, INT_ENB) 1704 | USBA_BF(EPT_INT, 1) 1705 | USBA_DET_SUSPEND 1706 | USBA_END_OF_RESUME)); 1707 1708 /* 1709 * Unclear why we hit this irregularly, e.g. in usbtest, 1710 * but it's clearly harmless... 1711 */ 1712 if (!(usba_ep_readl(ep0, CFG) & USBA_EPT_MAPPED)) 1713 dev_dbg(&udc->pdev->dev, 1714 "ODD: EP0 configuration is invalid!\n"); 1715 } 1716 1717 spin_unlock(&udc->lock); 1718 1719 return IRQ_HANDLED; 1720 } 1721 1722 static irqreturn_t usba_vbus_irq(int irq, void *devid) 1723 { 1724 struct usba_udc *udc = devid; 1725 int vbus; 1726 1727 /* debounce */ 1728 udelay(10); 1729 1730 spin_lock(&udc->lock); 1731 1732 /* May happen if Vbus pin toggles during probe() */ 1733 if (!udc->driver) 1734 goto out; 1735 1736 vbus = vbus_is_present(udc); 1737 if (vbus != udc->vbus_prev) { 1738 if (vbus) { 1739 toggle_bias(1); 1740 usba_writel(udc, CTRL, USBA_ENABLE_MASK); 1741 usba_writel(udc, INT_ENB, USBA_END_OF_RESET); 1742 } else { 1743 udc->gadget.speed = USB_SPEED_UNKNOWN; 1744 reset_all_endpoints(udc); 1745 toggle_bias(0); 1746 usba_writel(udc, CTRL, USBA_DISABLE_MASK); 1747 if (udc->driver->disconnect) { 1748 spin_unlock(&udc->lock); 1749 udc->driver->disconnect(&udc->gadget); 1750 spin_lock(&udc->lock); 1751 } 1752 } 1753 udc->vbus_prev = vbus; 1754 } 1755 1756 out: 1757 spin_unlock(&udc->lock); 1758 1759 return IRQ_HANDLED; 1760 } 1761 1762 static int atmel_usba_start(struct usb_gadget *gadget, 1763 struct usb_gadget_driver *driver) 1764 { 1765 int ret; 1766 struct usba_udc *udc = container_of(gadget, struct usba_udc, gadget); 1767 unsigned long flags; 1768 1769 spin_lock_irqsave(&udc->lock, flags); 1770 1771 udc->devstatus = 1 << USB_DEVICE_SELF_POWERED; 1772 udc->driver = driver; 1773 spin_unlock_irqrestore(&udc->lock, flags); 1774 1775 ret = clk_prepare_enable(udc->pclk); 1776 if (ret) 1777 return ret; 1778 ret = clk_prepare_enable(udc->hclk); 1779 if (ret) { 1780 clk_disable_unprepare(udc->pclk); 1781 return ret; 1782 } 1783 1784 udc->vbus_prev = 0; 1785 if (gpio_is_valid(udc->vbus_pin)) 1786 enable_irq(gpio_to_irq(udc->vbus_pin)); 1787 1788 /* If Vbus is present, enable the controller and wait for reset */ 1789 spin_lock_irqsave(&udc->lock, flags); 1790 if (vbus_is_present(udc) && udc->vbus_prev == 0) { 1791 toggle_bias(1); 1792 usba_writel(udc, CTRL, USBA_ENABLE_MASK); 1793 usba_writel(udc, INT_ENB, USBA_END_OF_RESET); 1794 } 1795 spin_unlock_irqrestore(&udc->lock, flags); 1796 1797 return 0; 1798 } 1799 1800 static int atmel_usba_stop(struct usb_gadget *gadget) 1801 { 1802 struct usba_udc *udc = container_of(gadget, struct usba_udc, gadget); 1803 unsigned long flags; 1804 1805 if (gpio_is_valid(udc->vbus_pin)) 1806 disable_irq(gpio_to_irq(udc->vbus_pin)); 1807 1808 spin_lock_irqsave(&udc->lock, flags); 1809 udc->gadget.speed = USB_SPEED_UNKNOWN; 1810 reset_all_endpoints(udc); 1811 spin_unlock_irqrestore(&udc->lock, flags); 1812 1813 /* This will also disable the DP pullup */ 1814 toggle_bias(0); 1815 usba_writel(udc, CTRL, USBA_DISABLE_MASK); 1816 1817 clk_disable_unprepare(udc->hclk); 1818 clk_disable_unprepare(udc->pclk); 1819 1820 udc->driver = NULL; 1821 1822 return 0; 1823 } 1824 1825 #ifdef CONFIG_OF 1826 static struct usba_ep * atmel_udc_of_init(struct platform_device *pdev, 1827 struct usba_udc *udc) 1828 { 1829 u32 val; 1830 const char *name; 1831 enum of_gpio_flags flags; 1832 struct device_node *np = pdev->dev.of_node; 1833 struct device_node *pp; 1834 int i, ret; 1835 struct usba_ep *eps, *ep; 1836 1837 udc->num_ep = 0; 1838 1839 udc->vbus_pin = of_get_named_gpio_flags(np, "atmel,vbus-gpio", 0, 1840 &flags); 1841 udc->vbus_pin_inverted = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0; 1842 1843 pp = NULL; 1844 while ((pp = of_get_next_child(np, pp))) 1845 udc->num_ep++; 1846 1847 eps = devm_kzalloc(&pdev->dev, sizeof(struct usba_ep) * udc->num_ep, 1848 GFP_KERNEL); 1849 if (!eps) 1850 return ERR_PTR(-ENOMEM); 1851 1852 udc->gadget.ep0 = &eps[0].ep; 1853 1854 INIT_LIST_HEAD(&eps[0].ep.ep_list); 1855 1856 pp = NULL; 1857 i = 0; 1858 while ((pp = of_get_next_child(np, pp))) { 1859 ep = &eps[i]; 1860 1861 ret = of_property_read_u32(pp, "reg", &val); 1862 if (ret) { 1863 dev_err(&pdev->dev, "of_probe: reg error(%d)\n", ret); 1864 goto err; 1865 } 1866 ep->index = val; 1867 1868 ret = of_property_read_u32(pp, "atmel,fifo-size", &val); 1869 if (ret) { 1870 dev_err(&pdev->dev, "of_probe: fifo-size error(%d)\n", ret); 1871 goto err; 1872 } 1873 ep->fifo_size = val; 1874 1875 ret = of_property_read_u32(pp, "atmel,nb-banks", &val); 1876 if (ret) { 1877 dev_err(&pdev->dev, "of_probe: nb-banks error(%d)\n", ret); 1878 goto err; 1879 } 1880 ep->nr_banks = val; 1881 1882 ep->can_dma = of_property_read_bool(pp, "atmel,can-dma"); 1883 ep->can_isoc = of_property_read_bool(pp, "atmel,can-isoc"); 1884 1885 ret = of_property_read_string(pp, "name", &name); 1886 ep->ep.name = name; 1887 1888 ep->ep_regs = udc->regs + USBA_EPT_BASE(i); 1889 ep->dma_regs = udc->regs + USBA_DMA_BASE(i); 1890 ep->fifo = udc->fifo + USBA_FIFO_BASE(i); 1891 ep->ep.ops = &usba_ep_ops; 1892 usb_ep_set_maxpacket_limit(&ep->ep, ep->fifo_size); 1893 ep->udc = udc; 1894 INIT_LIST_HEAD(&ep->queue); 1895 1896 if (i) 1897 list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list); 1898 1899 i++; 1900 } 1901 1902 if (i == 0) { 1903 dev_err(&pdev->dev, "of_probe: no endpoint specified\n"); 1904 ret = -EINVAL; 1905 goto err; 1906 } 1907 1908 return eps; 1909 err: 1910 return ERR_PTR(ret); 1911 } 1912 #else 1913 static struct usba_ep * atmel_udc_of_init(struct platform_device *pdev, 1914 struct usba_udc *udc) 1915 { 1916 return ERR_PTR(-ENOSYS); 1917 } 1918 #endif 1919 1920 static struct usba_ep * usba_udc_pdata(struct platform_device *pdev, 1921 struct usba_udc *udc) 1922 { 1923 struct usba_platform_data *pdata = dev_get_platdata(&pdev->dev); 1924 struct usba_ep *eps; 1925 int i; 1926 1927 if (!pdata) 1928 return ERR_PTR(-ENXIO); 1929 1930 eps = devm_kzalloc(&pdev->dev, sizeof(struct usba_ep) * pdata->num_ep, 1931 GFP_KERNEL); 1932 if (!eps) 1933 return ERR_PTR(-ENOMEM); 1934 1935 udc->gadget.ep0 = &eps[0].ep; 1936 1937 udc->vbus_pin = pdata->vbus_pin; 1938 udc->vbus_pin_inverted = pdata->vbus_pin_inverted; 1939 udc->num_ep = pdata->num_ep; 1940 1941 INIT_LIST_HEAD(&eps[0].ep.ep_list); 1942 1943 for (i = 0; i < pdata->num_ep; i++) { 1944 struct usba_ep *ep = &eps[i]; 1945 1946 ep->ep_regs = udc->regs + USBA_EPT_BASE(i); 1947 ep->dma_regs = udc->regs + USBA_DMA_BASE(i); 1948 ep->fifo = udc->fifo + USBA_FIFO_BASE(i); 1949 ep->ep.ops = &usba_ep_ops; 1950 ep->ep.name = pdata->ep[i].name; 1951 ep->fifo_size = pdata->ep[i].fifo_size; 1952 usb_ep_set_maxpacket_limit(&ep->ep, ep->fifo_size); 1953 ep->udc = udc; 1954 INIT_LIST_HEAD(&ep->queue); 1955 ep->nr_banks = pdata->ep[i].nr_banks; 1956 ep->index = pdata->ep[i].index; 1957 ep->can_dma = pdata->ep[i].can_dma; 1958 ep->can_isoc = pdata->ep[i].can_isoc; 1959 1960 if (i) 1961 list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list); 1962 } 1963 1964 return eps; 1965 } 1966 1967 static int usba_udc_probe(struct platform_device *pdev) 1968 { 1969 struct resource *regs, *fifo; 1970 struct clk *pclk, *hclk; 1971 struct usba_udc *udc; 1972 int irq, ret, i; 1973 1974 udc = devm_kzalloc(&pdev->dev, sizeof(*udc), GFP_KERNEL); 1975 if (!udc) 1976 return -ENOMEM; 1977 1978 udc->gadget = usba_gadget_template; 1979 INIT_LIST_HEAD(&udc->gadget.ep_list); 1980 1981 regs = platform_get_resource(pdev, IORESOURCE_MEM, CTRL_IOMEM_ID); 1982 fifo = platform_get_resource(pdev, IORESOURCE_MEM, FIFO_IOMEM_ID); 1983 if (!regs || !fifo) 1984 return -ENXIO; 1985 1986 irq = platform_get_irq(pdev, 0); 1987 if (irq < 0) 1988 return irq; 1989 1990 pclk = devm_clk_get(&pdev->dev, "pclk"); 1991 if (IS_ERR(pclk)) 1992 return PTR_ERR(pclk); 1993 hclk = devm_clk_get(&pdev->dev, "hclk"); 1994 if (IS_ERR(hclk)) 1995 return PTR_ERR(hclk); 1996 1997 spin_lock_init(&udc->lock); 1998 udc->pdev = pdev; 1999 udc->pclk = pclk; 2000 udc->hclk = hclk; 2001 udc->vbus_pin = -ENODEV; 2002 2003 ret = -ENOMEM; 2004 udc->regs = devm_ioremap(&pdev->dev, regs->start, resource_size(regs)); 2005 if (!udc->regs) { 2006 dev_err(&pdev->dev, "Unable to map I/O memory, aborting.\n"); 2007 return ret; 2008 } 2009 dev_info(&pdev->dev, "MMIO registers at 0x%08lx mapped at %p\n", 2010 (unsigned long)regs->start, udc->regs); 2011 udc->fifo = devm_ioremap(&pdev->dev, fifo->start, resource_size(fifo)); 2012 if (!udc->fifo) { 2013 dev_err(&pdev->dev, "Unable to map FIFO, aborting.\n"); 2014 return ret; 2015 } 2016 dev_info(&pdev->dev, "FIFO at 0x%08lx mapped at %p\n", 2017 (unsigned long)fifo->start, udc->fifo); 2018 2019 platform_set_drvdata(pdev, udc); 2020 2021 /* Make sure we start from a clean slate */ 2022 ret = clk_prepare_enable(pclk); 2023 if (ret) { 2024 dev_err(&pdev->dev, "Unable to enable pclk, aborting.\n"); 2025 return ret; 2026 } 2027 toggle_bias(0); 2028 usba_writel(udc, CTRL, USBA_DISABLE_MASK); 2029 clk_disable_unprepare(pclk); 2030 2031 if (pdev->dev.of_node) 2032 udc->usba_ep = atmel_udc_of_init(pdev, udc); 2033 else 2034 udc->usba_ep = usba_udc_pdata(pdev, udc); 2035 2036 if (IS_ERR(udc->usba_ep)) 2037 return PTR_ERR(udc->usba_ep); 2038 2039 ret = devm_request_irq(&pdev->dev, irq, usba_udc_irq, 0, 2040 "atmel_usba_udc", udc); 2041 if (ret) { 2042 dev_err(&pdev->dev, "Cannot request irq %d (error %d)\n", 2043 irq, ret); 2044 return ret; 2045 } 2046 udc->irq = irq; 2047 2048 if (gpio_is_valid(udc->vbus_pin)) { 2049 if (!devm_gpio_request(&pdev->dev, udc->vbus_pin, "atmel_usba_udc")) { 2050 ret = devm_request_irq(&pdev->dev, 2051 gpio_to_irq(udc->vbus_pin), 2052 usba_vbus_irq, 0, 2053 "atmel_usba_udc", udc); 2054 if (ret) { 2055 udc->vbus_pin = -ENODEV; 2056 dev_warn(&udc->pdev->dev, 2057 "failed to request vbus irq; " 2058 "assuming always on\n"); 2059 } else { 2060 disable_irq(gpio_to_irq(udc->vbus_pin)); 2061 } 2062 } else { 2063 /* gpio_request fail so use -EINVAL for gpio_is_valid */ 2064 udc->vbus_pin = -EINVAL; 2065 } 2066 } 2067 2068 ret = usb_add_gadget_udc(&pdev->dev, &udc->gadget); 2069 if (ret) 2070 return ret; 2071 2072 usba_init_debugfs(udc); 2073 for (i = 1; i < udc->num_ep; i++) 2074 usba_ep_init_debugfs(udc, &udc->usba_ep[i]); 2075 2076 return 0; 2077 } 2078 2079 static int __exit usba_udc_remove(struct platform_device *pdev) 2080 { 2081 struct usba_udc *udc; 2082 int i; 2083 2084 udc = platform_get_drvdata(pdev); 2085 2086 usb_del_gadget_udc(&udc->gadget); 2087 2088 for (i = 1; i < udc->num_ep; i++) 2089 usba_ep_cleanup_debugfs(&udc->usba_ep[i]); 2090 usba_cleanup_debugfs(udc); 2091 2092 return 0; 2093 } 2094 2095 #if defined(CONFIG_OF) 2096 static const struct of_device_id atmel_udc_dt_ids[] = { 2097 { .compatible = "atmel,at91sam9rl-udc" }, 2098 { /* sentinel */ } 2099 }; 2100 2101 MODULE_DEVICE_TABLE(of, atmel_udc_dt_ids); 2102 #endif 2103 2104 static struct platform_driver udc_driver = { 2105 .remove = __exit_p(usba_udc_remove), 2106 .driver = { 2107 .name = "atmel_usba_udc", 2108 .of_match_table = of_match_ptr(atmel_udc_dt_ids), 2109 }, 2110 }; 2111 2112 module_platform_driver_probe(udc_driver, usba_udc_probe); 2113 2114 MODULE_DESCRIPTION("Atmel USBA UDC driver"); 2115 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)"); 2116 MODULE_LICENSE("GPL"); 2117 MODULE_ALIAS("platform:atmel_usba_udc"); 2118