1/* 2 * driver/usb/gadget/imx_udc.c 3 * 4 * Copyright (C) 2005 Mike Lee <eemike@gmail.com> 5 * Copyright (C) 2008 Darius Augulis <augulis.darius@gmail.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 */ 17 18#include <linux/init.h> 19#include <linux/kernel.h> 20#include <linux/platform_device.h> 21#include <linux/module.h> 22#include <linux/errno.h> 23#include <linux/list.h> 24#include <linux/interrupt.h> 25#include <linux/io.h> 26#include <linux/irq.h> 27#include <linux/device.h> 28#include <linux/dma-mapping.h> 29#include <linux/clk.h> 30#include <linux/delay.h> 31#include <linux/timer.h> 32#include <linux/slab.h> 33 34#include <linux/usb/ch9.h> 35#include <linux/usb/gadget.h> 36 37#include <mach/usb.h> 38#include <mach/hardware.h> 39 40#include "imx_udc.h" 41 42static const char driver_name[] = "imx_udc"; 43static const char ep0name[] = "ep0"; 44 45void ep0_chg_stat(const char *label, struct imx_udc_struct *imx_usb, 46 enum ep0_state stat); 47 48/******************************************************************************* 49 * IMX UDC hardware related functions 50 ******************************************************************************* 51 */ 52 53void imx_udc_enable(struct imx_udc_struct *imx_usb) 54{ 55 int temp = __raw_readl(imx_usb->base + USB_CTRL); 56 __raw_writel(temp | CTRL_FE_ENA | CTRL_AFE_ENA, 57 imx_usb->base + USB_CTRL); 58 imx_usb->gadget.speed = USB_SPEED_FULL; 59} 60 61void imx_udc_disable(struct imx_udc_struct *imx_usb) 62{ 63 int temp = __raw_readl(imx_usb->base + USB_CTRL); 64 65 __raw_writel(temp & ~(CTRL_FE_ENA | CTRL_AFE_ENA), 66 imx_usb->base + USB_CTRL); 67 68 ep0_chg_stat(__func__, imx_usb, EP0_IDLE); 69 imx_usb->gadget.speed = USB_SPEED_UNKNOWN; 70} 71 72void imx_udc_reset(struct imx_udc_struct *imx_usb) 73{ 74 int temp = __raw_readl(imx_usb->base + USB_ENAB); 75 76 /* set RST bit */ 77 __raw_writel(temp | ENAB_RST, imx_usb->base + USB_ENAB); 78 79 /* wait RST bit to clear */ 80 do {} while (__raw_readl(imx_usb->base + USB_ENAB) & ENAB_RST); 81 82 /* wait CFG bit to assert */ 83 do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG)); 84 85 /* udc module is now ready */ 86} 87 88void imx_udc_config(struct imx_udc_struct *imx_usb) 89{ 90 u8 ep_conf[5]; 91 u8 i, j, cfg; 92 struct imx_ep_struct *imx_ep; 93 94 /* wait CFG bit to assert */ 95 do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG)); 96 97 /* Download the endpoint buffer for endpoint 0. */ 98 for (j = 0; j < 5; j++) { 99 i = (j == 2 ? imx_usb->imx_ep[0].fifosize : 0x00); 100 __raw_writeb(i, imx_usb->base + USB_DDAT); 101 do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_BSY); 102 } 103 104 /* Download the endpoint buffers for endpoints 1-5. 105 * We specify two configurations, one interface 106 */ 107 for (cfg = 1; cfg < 3; cfg++) { 108 for (i = 1; i < IMX_USB_NB_EP; i++) { 109 imx_ep = &imx_usb->imx_ep[i]; 110 /* EP no | Config no */ 111 ep_conf[0] = (i << 4) | (cfg << 2); 112 /* Type | Direction */ 113 ep_conf[1] = (imx_ep->bmAttributes << 3) | 114 (EP_DIR(imx_ep) << 2); 115 /* Max packet size */ 116 ep_conf[2] = imx_ep->fifosize; 117 /* TRXTYP */ 118 ep_conf[3] = 0xC0; 119 /* FIFO no */ 120 ep_conf[4] = i; 121 122 D_INI(imx_usb->dev, 123 "<%s> ep%d_conf[%d]:" 124 "[%02x-%02x-%02x-%02x-%02x]\n", 125 __func__, i, cfg, 126 ep_conf[0], ep_conf[1], ep_conf[2], 127 ep_conf[3], ep_conf[4]); 128 129 for (j = 0; j < 5; j++) { 130 __raw_writeb(ep_conf[j], 131 imx_usb->base + USB_DDAT); 132 do {} while (__raw_readl(imx_usb->base 133 + USB_DADR) 134 & DADR_BSY); 135 } 136 } 137 } 138 139 /* wait CFG bit to clear */ 140 do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG); 141} 142 143void imx_udc_init_irq(struct imx_udc_struct *imx_usb) 144{ 145 int i; 146 147 /* Mask and clear all irqs */ 148 __raw_writel(0xFFFFFFFF, imx_usb->base + USB_MASK); 149 __raw_writel(0xFFFFFFFF, imx_usb->base + USB_INTR); 150 for (i = 0; i < IMX_USB_NB_EP; i++) { 151 __raw_writel(0x1FF, imx_usb->base + USB_EP_MASK(i)); 152 __raw_writel(0x1FF, imx_usb->base + USB_EP_INTR(i)); 153 } 154 155 /* Enable USB irqs */ 156 __raw_writel(INTR_MSOF | INTR_FRAME_MATCH, imx_usb->base + USB_MASK); 157 158 /* Enable EP0 irqs */ 159 __raw_writel(0x1FF & ~(EPINTR_DEVREQ | EPINTR_MDEVREQ | EPINTR_EOT 160 | EPINTR_EOF | EPINTR_FIFO_EMPTY | EPINTR_FIFO_FULL), 161 imx_usb->base + USB_EP_MASK(0)); 162} 163 164void imx_udc_init_ep(struct imx_udc_struct *imx_usb) 165{ 166 int i, max, temp; 167 struct imx_ep_struct *imx_ep; 168 for (i = 0; i < IMX_USB_NB_EP; i++) { 169 imx_ep = &imx_usb->imx_ep[i]; 170 switch (imx_ep->fifosize) { 171 case 8: 172 max = 0; 173 break; 174 case 16: 175 max = 1; 176 break; 177 case 32: 178 max = 2; 179 break; 180 case 64: 181 max = 3; 182 break; 183 default: 184 max = 1; 185 break; 186 } 187 temp = (EP_DIR(imx_ep) << 7) | (max << 5) 188 | (imx_ep->bmAttributes << 3); 189 __raw_writel(temp, imx_usb->base + USB_EP_STAT(i)); 190 __raw_writel(temp | EPSTAT_FLUSH, 191 imx_usb->base + USB_EP_STAT(i)); 192 D_INI(imx_usb->dev, "<%s> ep%d_stat %08x\n", __func__, i, 193 __raw_readl(imx_usb->base + USB_EP_STAT(i))); 194 } 195} 196 197void imx_udc_init_fifo(struct imx_udc_struct *imx_usb) 198{ 199 int i, temp; 200 struct imx_ep_struct *imx_ep; 201 for (i = 0; i < IMX_USB_NB_EP; i++) { 202 imx_ep = &imx_usb->imx_ep[i]; 203 204 /* Fifo control */ 205 temp = EP_DIR(imx_ep) ? 0x0B000000 : 0x0F000000; 206 __raw_writel(temp, imx_usb->base + USB_EP_FCTRL(i)); 207 D_INI(imx_usb->dev, "<%s> ep%d_fctrl %08x\n", __func__, i, 208 __raw_readl(imx_usb->base + USB_EP_FCTRL(i))); 209 210 /* Fifo alarm */ 211 temp = (i ? imx_ep->fifosize / 2 : 0); 212 __raw_writel(temp, imx_usb->base + USB_EP_FALRM(i)); 213 D_INI(imx_usb->dev, "<%s> ep%d_falrm %08x\n", __func__, i, 214 __raw_readl(imx_usb->base + USB_EP_FALRM(i))); 215 } 216} 217 218static void imx_udc_init(struct imx_udc_struct *imx_usb) 219{ 220 /* Reset UDC */ 221 imx_udc_reset(imx_usb); 222 223 /* Download config to enpoint buffer */ 224 imx_udc_config(imx_usb); 225 226 /* Setup interrups */ 227 imx_udc_init_irq(imx_usb); 228 229 /* Setup endpoints */ 230 imx_udc_init_ep(imx_usb); 231 232 /* Setup fifos */ 233 imx_udc_init_fifo(imx_usb); 234} 235 236void imx_ep_irq_enable(struct imx_ep_struct *imx_ep) 237{ 238 239 int i = EP_NO(imx_ep); 240 241 __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i)); 242 __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i)); 243 __raw_writel(0x1FF & ~(EPINTR_EOT | EPINTR_EOF), 244 imx_ep->imx_usb->base + USB_EP_MASK(i)); 245} 246 247void imx_ep_irq_disable(struct imx_ep_struct *imx_ep) 248{ 249 250 int i = EP_NO(imx_ep); 251 252 __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i)); 253 __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i)); 254} 255 256int imx_ep_empty(struct imx_ep_struct *imx_ep) 257{ 258 struct imx_udc_struct *imx_usb = imx_ep->imx_usb; 259 260 return __raw_readl(imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep))) 261 & FSTAT_EMPTY; 262} 263 264unsigned imx_fifo_bcount(struct imx_ep_struct *imx_ep) 265{ 266 struct imx_udc_struct *imx_usb = imx_ep->imx_usb; 267 268 return (__raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep))) 269 & EPSTAT_BCOUNT) >> 16; 270} 271 272void imx_flush(struct imx_ep_struct *imx_ep) 273{ 274 struct imx_udc_struct *imx_usb = imx_ep->imx_usb; 275 276 int temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep))); 277 __raw_writel(temp | EPSTAT_FLUSH, 278 imx_usb->base + USB_EP_STAT(EP_NO(imx_ep))); 279} 280 281void imx_ep_stall(struct imx_ep_struct *imx_ep) 282{ 283 struct imx_udc_struct *imx_usb = imx_ep->imx_usb; 284 int temp, i; 285 286 D_ERR(imx_usb->dev, 287 "<%s> Forced stall on %s\n", __func__, imx_ep->ep.name); 288 289 imx_flush(imx_ep); 290 291 /* Special care for ep0 */ 292 if (!EP_NO(imx_ep)) { 293 temp = __raw_readl(imx_usb->base + USB_CTRL); 294 __raw_writel(temp | CTRL_CMDOVER | CTRL_CMDERROR, 295 imx_usb->base + USB_CTRL); 296 do { } while (__raw_readl(imx_usb->base + USB_CTRL) 297 & CTRL_CMDOVER); 298 temp = __raw_readl(imx_usb->base + USB_CTRL); 299 __raw_writel(temp & ~CTRL_CMDERROR, imx_usb->base + USB_CTRL); 300 } 301 else { 302 temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep))); 303 __raw_writel(temp | EPSTAT_STALL, 304 imx_usb->base + USB_EP_STAT(EP_NO(imx_ep))); 305 306 for (i = 0; i < 100; i ++) { 307 temp = __raw_readl(imx_usb->base 308 + USB_EP_STAT(EP_NO(imx_ep))); 309 if (!(temp & EPSTAT_STALL)) 310 break; 311 udelay(20); 312 } 313 if (i == 100) 314 D_ERR(imx_usb->dev, "<%s> Non finished stall on %s\n", 315 __func__, imx_ep->ep.name); 316 } 317} 318 319static int imx_udc_get_frame(struct usb_gadget *_gadget) 320{ 321 struct imx_udc_struct *imx_usb = container_of(_gadget, 322 struct imx_udc_struct, gadget); 323 324 return __raw_readl(imx_usb->base + USB_FRAME) & 0x7FF; 325} 326 327static int imx_udc_wakeup(struct usb_gadget *_gadget) 328{ 329 return 0; 330} 331 332/******************************************************************************* 333 * USB request control functions 334 ******************************************************************************* 335 */ 336 337static void ep_add_request(struct imx_ep_struct *imx_ep, 338 struct imx_request *req) 339{ 340 if (unlikely(!req)) 341 return; 342 343 req->in_use = 1; 344 list_add_tail(&req->queue, &imx_ep->queue); 345} 346 347static void ep_del_request(struct imx_ep_struct *imx_ep, 348 struct imx_request *req) 349{ 350 if (unlikely(!req)) 351 return; 352 353 list_del_init(&req->queue); 354 req->in_use = 0; 355} 356 357static void done(struct imx_ep_struct *imx_ep, 358 struct imx_request *req, int status) 359{ 360 ep_del_request(imx_ep, req); 361 362 if (likely(req->req.status == -EINPROGRESS)) 363 req->req.status = status; 364 else 365 status = req->req.status; 366 367 if (status && status != -ESHUTDOWN) 368 D_ERR(imx_ep->imx_usb->dev, 369 "<%s> complete %s req %p stat %d len %u/%u\n", __func__, 370 imx_ep->ep.name, &req->req, status, 371 req->req.actual, req->req.length); 372 373 req->req.complete(&imx_ep->ep, &req->req); 374} 375 376static void nuke(struct imx_ep_struct *imx_ep, int status) 377{ 378 struct imx_request *req; 379 380 while (!list_empty(&imx_ep->queue)) { 381 req = list_entry(imx_ep->queue.next, struct imx_request, queue); 382 done(imx_ep, req, status); 383 } 384} 385 386/******************************************************************************* 387 * Data tansfer over USB functions 388 ******************************************************************************* 389 */ 390static int read_packet(struct imx_ep_struct *imx_ep, struct imx_request *req) 391{ 392 u8 *buf; 393 int bytes_ep, bufferspace, count, i; 394 395 bytes_ep = imx_fifo_bcount(imx_ep); 396 bufferspace = req->req.length - req->req.actual; 397 398 buf = req->req.buf + req->req.actual; 399 prefetchw(buf); 400 401 if (unlikely(imx_ep_empty(imx_ep))) 402 count = 0; /* zlp */ 403 else 404 count = min(bytes_ep, bufferspace); 405 406 for (i = count; i > 0; i--) 407 *buf++ = __raw_readb(imx_ep->imx_usb->base 408 + USB_EP_FDAT0(EP_NO(imx_ep))); 409 req->req.actual += count; 410 411 return count; 412} 413 414static int write_packet(struct imx_ep_struct *imx_ep, struct imx_request *req) 415{ 416 u8 *buf; 417 int length, count, temp; 418 419 if (unlikely(__raw_readl(imx_ep->imx_usb->base + 420 USB_EP_STAT(EP_NO(imx_ep))) & EPSTAT_ZLPS)) { 421 D_TRX(imx_ep->imx_usb->dev, "<%s> zlp still queued in EP %s\n", 422 __func__, imx_ep->ep.name); 423 return -1; 424 } 425 426 buf = req->req.buf + req->req.actual; 427 prefetch(buf); 428 429 length = min(req->req.length - req->req.actual, (u32)imx_ep->fifosize); 430 431 if (imx_fifo_bcount(imx_ep) + length > imx_ep->fifosize) { 432 D_TRX(imx_ep->imx_usb->dev, "<%s> packet overfill %s fifo\n", 433 __func__, imx_ep->ep.name); 434 return -1; 435 } 436 437 req->req.actual += length; 438 count = length; 439 440 if (!count && req->req.zero) { /* zlp */ 441 temp = __raw_readl(imx_ep->imx_usb->base 442 + USB_EP_STAT(EP_NO(imx_ep))); 443 __raw_writel(temp | EPSTAT_ZLPS, imx_ep->imx_usb->base 444 + USB_EP_STAT(EP_NO(imx_ep))); 445 D_TRX(imx_ep->imx_usb->dev, "<%s> zero packet\n", __func__); 446 return 0; 447 } 448 449 while (count--) { 450 if (count == 0) { /* last byte */ 451 temp = __raw_readl(imx_ep->imx_usb->base 452 + USB_EP_FCTRL(EP_NO(imx_ep))); 453 __raw_writel(temp | FCTRL_WFR, imx_ep->imx_usb->base 454 + USB_EP_FCTRL(EP_NO(imx_ep))); 455 } 456 __raw_writeb(*buf++, 457 imx_ep->imx_usb->base + USB_EP_FDAT0(EP_NO(imx_ep))); 458 } 459 460 return length; 461} 462 463static int read_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req) 464{ 465 int bytes = 0, 466 count, 467 completed = 0; 468 469 while (__raw_readl(imx_ep->imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep))) 470 & FSTAT_FR) { 471 count = read_packet(imx_ep, req); 472 bytes += count; 473 474 completed = (count != imx_ep->fifosize); 475 if (completed || req->req.actual == req->req.length) { 476 completed = 1; 477 break; 478 } 479 } 480 481 if (completed || !req->req.length) { 482 done(imx_ep, req, 0); 483 D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n", 484 __func__, imx_ep->ep.name, req, 485 completed ? "completed" : "not completed"); 486 if (!EP_NO(imx_ep)) 487 ep0_chg_stat(__func__, imx_ep->imx_usb, EP0_IDLE); 488 } 489 490 D_TRX(imx_ep->imx_usb->dev, "<%s> bytes read: %d\n", __func__, bytes); 491 492 return completed; 493} 494 495static int write_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req) 496{ 497 int bytes = 0, 498 count, 499 completed = 0; 500 501 while (!completed) { 502 count = write_packet(imx_ep, req); 503 if (count < 0) 504 break; /* busy */ 505 bytes += count; 506 507 /* last packet "must be" short (or a zlp) */ 508 completed = (count != imx_ep->fifosize); 509 510 if (unlikely(completed)) { 511 done(imx_ep, req, 0); 512 D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n", 513 __func__, imx_ep->ep.name, req, 514 completed ? "completed" : "not completed"); 515 if (!EP_NO(imx_ep)) 516 ep0_chg_stat(__func__, 517 imx_ep->imx_usb, EP0_IDLE); 518 } 519 } 520 521 D_TRX(imx_ep->imx_usb->dev, "<%s> bytes sent: %d\n", __func__, bytes); 522 523 return completed; 524} 525 526/******************************************************************************* 527 * Endpoint handlers 528 ******************************************************************************* 529 */ 530static int handle_ep(struct imx_ep_struct *imx_ep) 531{ 532 struct imx_request *req; 533 int completed = 0; 534 535 do { 536 if (!list_empty(&imx_ep->queue)) 537 req = list_entry(imx_ep->queue.next, 538 struct imx_request, queue); 539 else { 540 D_REQ(imx_ep->imx_usb->dev, "<%s> no request on %s\n", 541 __func__, imx_ep->ep.name); 542 return 0; 543 } 544 545 if (EP_DIR(imx_ep)) /* to host */ 546 completed = write_fifo(imx_ep, req); 547 else /* to device */ 548 completed = read_fifo(imx_ep, req); 549 550 dump_ep_stat(__func__, imx_ep); 551 552 } while (completed); 553 554 return 0; 555} 556 557static int handle_ep0(struct imx_ep_struct *imx_ep) 558{ 559 struct imx_request *req = NULL; 560 int ret = 0; 561 562 if (!list_empty(&imx_ep->queue)) { 563 req = list_entry(imx_ep->queue.next, struct imx_request, queue); 564 565 switch (imx_ep->imx_usb->ep0state) { 566 567 case EP0_IN_DATA_PHASE: /* GET_DESCRIPTOR */ 568 write_fifo(imx_ep, req); 569 break; 570 case EP0_OUT_DATA_PHASE: /* SET_DESCRIPTOR */ 571 read_fifo(imx_ep, req); 572 break; 573 default: 574 D_EP0(imx_ep->imx_usb->dev, 575 "<%s> ep0 i/o, odd state %d\n", 576 __func__, imx_ep->imx_usb->ep0state); 577 ep_del_request(imx_ep, req); 578 ret = -EL2HLT; 579 break; 580 } 581 } 582 583 else 584 D_ERR(imx_ep->imx_usb->dev, "<%s> no request on %s\n", 585 __func__, imx_ep->ep.name); 586 587 return ret; 588} 589 590static void handle_ep0_devreq(struct imx_udc_struct *imx_usb) 591{ 592 struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0]; 593 union { 594 struct usb_ctrlrequest r; 595 u8 raw[8]; 596 u32 word[2]; 597 } u; 598 int temp, i; 599 600 nuke(imx_ep, -EPROTO); 601 602 /* read SETUP packet */ 603 for (i = 0; i < 2; i++) { 604 if (imx_ep_empty(imx_ep)) { 605 D_ERR(imx_usb->dev, 606 "<%s> no setup packet received\n", __func__); 607 goto stall; 608 } 609 u.word[i] = __raw_readl(imx_usb->base 610 + USB_EP_FDAT(EP_NO(imx_ep))); 611 } 612 613 temp = imx_ep_empty(imx_ep); 614 while (!imx_ep_empty(imx_ep)) { 615 i = __raw_readl(imx_usb->base + USB_EP_FDAT(EP_NO(imx_ep))); 616 D_ERR(imx_usb->dev, 617 "<%s> wrong to have extra bytes for setup : 0x%08x\n", 618 __func__, i); 619 } 620 if (!temp) 621 goto stall; 622 623 le16_to_cpus(&u.r.wValue); 624 le16_to_cpus(&u.r.wIndex); 625 le16_to_cpus(&u.r.wLength); 626 627 D_REQ(imx_usb->dev, "<%s> SETUP %02x.%02x v%04x i%04x l%04x\n", 628 __func__, u.r.bRequestType, u.r.bRequest, 629 u.r.wValue, u.r.wIndex, u.r.wLength); 630 631 if (imx_usb->set_config) { 632 /* NACK the host by using CMDOVER */ 633 temp = __raw_readl(imx_usb->base + USB_CTRL); 634 __raw_writel(temp | CTRL_CMDOVER, imx_usb->base + USB_CTRL); 635 636 D_ERR(imx_usb->dev, 637 "<%s> set config req is pending, NACK the host\n", 638 __func__); 639 return; 640 } 641 642 if (u.r.bRequestType & USB_DIR_IN) 643 ep0_chg_stat(__func__, imx_usb, EP0_IN_DATA_PHASE); 644 else 645 ep0_chg_stat(__func__, imx_usb, EP0_OUT_DATA_PHASE); 646 647 i = imx_usb->driver->setup(&imx_usb->gadget, &u.r); 648 if (i < 0) { 649 D_ERR(imx_usb->dev, "<%s> device setup error %d\n", 650 __func__, i); 651 goto stall; 652 } 653 654 return; 655stall: 656 D_ERR(imx_usb->dev, "<%s> protocol STALL\n", __func__); 657 imx_ep_stall(imx_ep); 658 ep0_chg_stat(__func__, imx_usb, EP0_STALL); 659 return; 660} 661 662/******************************************************************************* 663 * USB gadget callback functions 664 ******************************************************************************* 665 */ 666 667static int imx_ep_enable(struct usb_ep *usb_ep, 668 const struct usb_endpoint_descriptor *desc) 669{ 670 struct imx_ep_struct *imx_ep = container_of(usb_ep, 671 struct imx_ep_struct, ep); 672 struct imx_udc_struct *imx_usb = imx_ep->imx_usb; 673 unsigned long flags; 674 675 if (!usb_ep 676 || !desc 677 || !EP_NO(imx_ep) 678 || desc->bDescriptorType != USB_DT_ENDPOINT 679 || imx_ep->bEndpointAddress != desc->bEndpointAddress) { 680 D_ERR(imx_usb->dev, 681 "<%s> bad ep or descriptor\n", __func__); 682 return -EINVAL; 683 } 684 685 if (imx_ep->bmAttributes != desc->bmAttributes) { 686 D_ERR(imx_usb->dev, 687 "<%s> %s type mismatch\n", __func__, usb_ep->name); 688 return -EINVAL; 689 } 690 691 if (imx_ep->fifosize < le16_to_cpu(desc->wMaxPacketSize)) { 692 D_ERR(imx_usb->dev, 693 "<%s> bad %s maxpacket\n", __func__, usb_ep->name); 694 return -ERANGE; 695 } 696 697 if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) { 698 D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__); 699 return -ESHUTDOWN; 700 } 701 702 local_irq_save(flags); 703 704 imx_ep->stopped = 0; 705 imx_flush(imx_ep); 706 imx_ep_irq_enable(imx_ep); 707 708 local_irq_restore(flags); 709 710 D_EPX(imx_usb->dev, "<%s> ENABLED %s\n", __func__, usb_ep->name); 711 return 0; 712} 713 714static int imx_ep_disable(struct usb_ep *usb_ep) 715{ 716 struct imx_ep_struct *imx_ep = container_of(usb_ep, 717 struct imx_ep_struct, ep); 718 unsigned long flags; 719 720 if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) { 721 D_ERR(imx_ep->imx_usb->dev, "<%s> %s can not be disabled\n", 722 __func__, usb_ep ? imx_ep->ep.name : NULL); 723 return -EINVAL; 724 } 725 726 local_irq_save(flags); 727 728 imx_ep->stopped = 1; 729 nuke(imx_ep, -ESHUTDOWN); 730 imx_flush(imx_ep); 731 imx_ep_irq_disable(imx_ep); 732 733 local_irq_restore(flags); 734 735 D_EPX(imx_ep->imx_usb->dev, 736 "<%s> DISABLED %s\n", __func__, usb_ep->name); 737 return 0; 738} 739 740static struct usb_request *imx_ep_alloc_request 741 (struct usb_ep *usb_ep, gfp_t gfp_flags) 742{ 743 struct imx_request *req; 744 745 if (!usb_ep) 746 return NULL; 747 748 req = kzalloc(sizeof *req, gfp_flags); 749 if (!req) 750 return NULL; 751 752 INIT_LIST_HEAD(&req->queue); 753 req->in_use = 0; 754 755 return &req->req; 756} 757 758static void imx_ep_free_request 759 (struct usb_ep *usb_ep, struct usb_request *usb_req) 760{ 761 struct imx_request *req; 762 763 req = container_of(usb_req, struct imx_request, req); 764 WARN_ON(!list_empty(&req->queue)); 765 kfree(req); 766} 767 768static int imx_ep_queue 769 (struct usb_ep *usb_ep, struct usb_request *usb_req, gfp_t gfp_flags) 770{ 771 struct imx_ep_struct *imx_ep; 772 struct imx_udc_struct *imx_usb; 773 struct imx_request *req; 774 unsigned long flags; 775 int ret = 0; 776 777 imx_ep = container_of(usb_ep, struct imx_ep_struct, ep); 778 imx_usb = imx_ep->imx_usb; 779 req = container_of(usb_req, struct imx_request, req); 780 781 /* 782 Special care on IMX udc. 783 Ignore enqueue when after set configuration from the 784 host. This assume all gadget drivers reply set 785 configuration with the next ep0 req enqueue. 786 */ 787 if (imx_usb->set_config && !EP_NO(imx_ep)) { 788 imx_usb->set_config = 0; 789 D_ERR(imx_usb->dev, 790 "<%s> gadget reply set config\n", __func__); 791 return 0; 792 } 793 794 if (unlikely(!usb_req || !req || !usb_req->complete || !usb_req->buf)) { 795 D_ERR(imx_usb->dev, "<%s> bad params\n", __func__); 796 return -EINVAL; 797 } 798 799 if (unlikely(!usb_ep || !imx_ep)) { 800 D_ERR(imx_usb->dev, "<%s> bad ep\n", __func__); 801 return -EINVAL; 802 } 803 804 if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) { 805 D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__); 806 return -ESHUTDOWN; 807 } 808 809 /* Debug */ 810 D_REQ(imx_usb->dev, "<%s> ep%d %s request for [%d] bytes\n", 811 __func__, EP_NO(imx_ep), 812 ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state 813 == EP0_IN_DATA_PHASE) 814 || (EP_NO(imx_ep) && EP_DIR(imx_ep))) 815 ? "IN" : "OUT", usb_req->length); 816 dump_req(__func__, imx_ep, usb_req); 817 818 if (imx_ep->stopped) { 819 usb_req->status = -ESHUTDOWN; 820 return -ESHUTDOWN; 821 } 822 823 if (req->in_use) { 824 D_ERR(imx_usb->dev, 825 "<%s> refusing to queue req %p (already queued)\n", 826 __func__, req); 827 return 0; 828 } 829 830 local_irq_save(flags); 831 832 usb_req->status = -EINPROGRESS; 833 usb_req->actual = 0; 834 835 ep_add_request(imx_ep, req); 836 837 if (!EP_NO(imx_ep)) 838 ret = handle_ep0(imx_ep); 839 else 840 ret = handle_ep(imx_ep); 841 842 local_irq_restore(flags); 843 return ret; 844} 845 846static int imx_ep_dequeue(struct usb_ep *usb_ep, struct usb_request *usb_req) 847{ 848 849 struct imx_ep_struct *imx_ep = container_of 850 (usb_ep, struct imx_ep_struct, ep); 851 struct imx_request *req; 852 unsigned long flags; 853 854 if (unlikely(!usb_ep || !EP_NO(imx_ep))) { 855 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__); 856 return -EINVAL; 857 } 858 859 local_irq_save(flags); 860 861 /* make sure it's actually queued on this endpoint */ 862 list_for_each_entry(req, &imx_ep->queue, queue) { 863 if (&req->req == usb_req) 864 break; 865 } 866 if (&req->req != usb_req) { 867 local_irq_restore(flags); 868 return -EINVAL; 869 } 870 871 done(imx_ep, req, -ECONNRESET); 872 873 local_irq_restore(flags); 874 return 0; 875} 876 877static int imx_ep_set_halt(struct usb_ep *usb_ep, int value) 878{ 879 struct imx_ep_struct *imx_ep = container_of 880 (usb_ep, struct imx_ep_struct, ep); 881 unsigned long flags; 882 883 if (unlikely(!usb_ep || !EP_NO(imx_ep))) { 884 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__); 885 return -EINVAL; 886 } 887 888 local_irq_save(flags); 889 890 if ((imx_ep->bEndpointAddress & USB_DIR_IN) 891 && !list_empty(&imx_ep->queue)) { 892 local_irq_restore(flags); 893 return -EAGAIN; 894 } 895 896 imx_ep_stall(imx_ep); 897 898 local_irq_restore(flags); 899 900 D_EPX(imx_ep->imx_usb->dev, "<%s> %s halt\n", __func__, usb_ep->name); 901 return 0; 902} 903 904static int imx_ep_fifo_status(struct usb_ep *usb_ep) 905{ 906 struct imx_ep_struct *imx_ep = container_of 907 (usb_ep, struct imx_ep_struct, ep); 908 909 if (!usb_ep) { 910 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__); 911 return -ENODEV; 912 } 913 914 if (imx_ep->imx_usb->gadget.speed == USB_SPEED_UNKNOWN) 915 return 0; 916 else 917 return imx_fifo_bcount(imx_ep); 918} 919 920static void imx_ep_fifo_flush(struct usb_ep *usb_ep) 921{ 922 struct imx_ep_struct *imx_ep = container_of 923 (usb_ep, struct imx_ep_struct, ep); 924 unsigned long flags; 925 926 local_irq_save(flags); 927 928 if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) { 929 D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__); 930 local_irq_restore(flags); 931 return; 932 } 933 934 /* toggle and halt bits stay unchanged */ 935 imx_flush(imx_ep); 936 937 local_irq_restore(flags); 938} 939 940static struct usb_ep_ops imx_ep_ops = { 941 .enable = imx_ep_enable, 942 .disable = imx_ep_disable, 943 944 .alloc_request = imx_ep_alloc_request, 945 .free_request = imx_ep_free_request, 946 947 .queue = imx_ep_queue, 948 .dequeue = imx_ep_dequeue, 949 950 .set_halt = imx_ep_set_halt, 951 .fifo_status = imx_ep_fifo_status, 952 .fifo_flush = imx_ep_fifo_flush, 953}; 954 955/******************************************************************************* 956 * USB endpoint control functions 957 ******************************************************************************* 958 */ 959 960void ep0_chg_stat(const char *label, 961 struct imx_udc_struct *imx_usb, enum ep0_state stat) 962{ 963 D_EP0(imx_usb->dev, "<%s> from %15s to %15s\n", 964 label, state_name[imx_usb->ep0state], state_name[stat]); 965 966 if (imx_usb->ep0state == stat) 967 return; 968 969 imx_usb->ep0state = stat; 970} 971 972static void usb_init_data(struct imx_udc_struct *imx_usb) 973{ 974 struct imx_ep_struct *imx_ep; 975 u8 i; 976 977 /* device/ep0 records init */ 978 INIT_LIST_HEAD(&imx_usb->gadget.ep_list); 979 INIT_LIST_HEAD(&imx_usb->gadget.ep0->ep_list); 980 ep0_chg_stat(__func__, imx_usb, EP0_IDLE); 981 982 /* basic endpoint records init */ 983 for (i = 0; i < IMX_USB_NB_EP; i++) { 984 imx_ep = &imx_usb->imx_ep[i]; 985 986 if (i) { 987 list_add_tail(&imx_ep->ep.ep_list, 988 &imx_usb->gadget.ep_list); 989 imx_ep->stopped = 1; 990 } else 991 imx_ep->stopped = 0; 992 993 INIT_LIST_HEAD(&imx_ep->queue); 994 } 995} 996 997static void udc_stop_activity(struct imx_udc_struct *imx_usb, 998 struct usb_gadget_driver *driver) 999{ 1000 struct imx_ep_struct *imx_ep; 1001 int i; 1002 1003 if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN) 1004 driver = NULL; 1005 1006 /* prevent new request submissions, kill any outstanding requests */ 1007 for (i = 1; i < IMX_USB_NB_EP; i++) { 1008 imx_ep = &imx_usb->imx_ep[i]; 1009 imx_flush(imx_ep); 1010 imx_ep->stopped = 1; 1011 imx_ep_irq_disable(imx_ep); 1012 nuke(imx_ep, -ESHUTDOWN); 1013 } 1014 1015 imx_usb->cfg = 0; 1016 imx_usb->intf = 0; 1017 imx_usb->alt = 0; 1018 1019 if (driver) 1020 driver->disconnect(&imx_usb->gadget); 1021} 1022 1023/******************************************************************************* 1024 * Interrupt handlers 1025 ******************************************************************************* 1026 */ 1027 1028/* 1029 * Called when timer expires. 1030 * Timer is started when CFG_CHG is received. 1031 */ 1032static void handle_config(unsigned long data) 1033{ 1034 struct imx_udc_struct *imx_usb = (void *)data; 1035 struct usb_ctrlrequest u; 1036 int temp, cfg, intf, alt; 1037 1038 local_irq_disable(); 1039 1040 temp = __raw_readl(imx_usb->base + USB_STAT); 1041 cfg = (temp & STAT_CFG) >> 5; 1042 intf = (temp & STAT_INTF) >> 3; 1043 alt = temp & STAT_ALTSET; 1044 1045 D_REQ(imx_usb->dev, 1046 "<%s> orig config C=%d, I=%d, A=%d / " 1047 "req config C=%d, I=%d, A=%d\n", 1048 __func__, imx_usb->cfg, imx_usb->intf, imx_usb->alt, 1049 cfg, intf, alt); 1050 1051 if (cfg == 1 || cfg == 2) { 1052 1053 if (imx_usb->cfg != cfg) { 1054 u.bRequest = USB_REQ_SET_CONFIGURATION; 1055 u.bRequestType = USB_DIR_OUT | 1056 USB_TYPE_STANDARD | 1057 USB_RECIP_DEVICE; 1058 u.wValue = cfg; 1059 u.wIndex = 0; 1060 u.wLength = 0; 1061 imx_usb->cfg = cfg; 1062 imx_usb->driver->setup(&imx_usb->gadget, &u); 1063 1064 } 1065 if (imx_usb->intf != intf || imx_usb->alt != alt) { 1066 u.bRequest = USB_REQ_SET_INTERFACE; 1067 u.bRequestType = USB_DIR_OUT | 1068 USB_TYPE_STANDARD | 1069 USB_RECIP_INTERFACE; 1070 u.wValue = alt; 1071 u.wIndex = intf; 1072 u.wLength = 0; 1073 imx_usb->intf = intf; 1074 imx_usb->alt = alt; 1075 imx_usb->driver->setup(&imx_usb->gadget, &u); 1076 } 1077 } 1078 1079 imx_usb->set_config = 0; 1080 1081 local_irq_enable(); 1082} 1083 1084static irqreturn_t imx_udc_irq(int irq, void *dev) 1085{ 1086 struct imx_udc_struct *imx_usb = dev; 1087 int intr = __raw_readl(imx_usb->base + USB_INTR); 1088 int temp; 1089 1090 if (intr & (INTR_WAKEUP | INTR_SUSPEND | INTR_RESUME | INTR_RESET_START 1091 | INTR_RESET_STOP | INTR_CFG_CHG)) { 1092 dump_intr(__func__, intr, imx_usb->dev); 1093 dump_usb_stat(__func__, imx_usb); 1094 } 1095 1096 if (!imx_usb->driver) 1097 goto end_irq; 1098 1099 if (intr & INTR_SOF) { 1100 /* Copy from Freescale BSP. 1101 We must enable SOF intr and set CMDOVER. 1102 Datasheet don't specifiy this action, but it 1103 is done in Freescale BSP, so just copy it. 1104 */ 1105 if (imx_usb->ep0state == EP0_IDLE) { 1106 temp = __raw_readl(imx_usb->base + USB_CTRL); 1107 __raw_writel(temp | CTRL_CMDOVER, 1108 imx_usb->base + USB_CTRL); 1109 } 1110 } 1111 1112 if (intr & INTR_CFG_CHG) { 1113 __raw_writel(INTR_CFG_CHG, imx_usb->base + USB_INTR); 1114 imx_usb->set_config = 1; 1115 mod_timer(&imx_usb->timer, jiffies + 5); 1116 goto end_irq; 1117 } 1118 1119 if (intr & INTR_WAKEUP) { 1120 if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN 1121 && imx_usb->driver && imx_usb->driver->resume) 1122 imx_usb->driver->resume(&imx_usb->gadget); 1123 imx_usb->set_config = 0; 1124 del_timer(&imx_usb->timer); 1125 imx_usb->gadget.speed = USB_SPEED_FULL; 1126 } 1127 1128 if (intr & INTR_SUSPEND) { 1129 if (imx_usb->gadget.speed != USB_SPEED_UNKNOWN 1130 && imx_usb->driver && imx_usb->driver->suspend) 1131 imx_usb->driver->suspend(&imx_usb->gadget); 1132 imx_usb->set_config = 0; 1133 del_timer(&imx_usb->timer); 1134 imx_usb->gadget.speed = USB_SPEED_UNKNOWN; 1135 } 1136 1137 if (intr & INTR_RESET_START) { 1138 __raw_writel(intr, imx_usb->base + USB_INTR); 1139 udc_stop_activity(imx_usb, imx_usb->driver); 1140 imx_usb->set_config = 0; 1141 del_timer(&imx_usb->timer); 1142 imx_usb->gadget.speed = USB_SPEED_UNKNOWN; 1143 } 1144 1145 if (intr & INTR_RESET_STOP) 1146 imx_usb->gadget.speed = USB_SPEED_FULL; 1147 1148end_irq: 1149 __raw_writel(intr, imx_usb->base + USB_INTR); 1150 return IRQ_HANDLED; 1151} 1152 1153static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev) 1154{ 1155 struct imx_udc_struct *imx_usb = dev; 1156 struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0]; 1157 int intr = __raw_readl(imx_usb->base + USB_EP_INTR(0)); 1158 1159 dump_ep_intr(__func__, 0, intr, imx_usb->dev); 1160 1161 if (!imx_usb->driver) { 1162 __raw_writel(intr, imx_usb->base + USB_EP_INTR(0)); 1163 return IRQ_HANDLED; 1164 } 1165 1166 /* DEVREQ has highest priority */ 1167 if (intr & (EPINTR_DEVREQ | EPINTR_MDEVREQ)) 1168 handle_ep0_devreq(imx_usb); 1169 /* Seem i.MX is missing EOF interrupt sometimes. 1170 * Therefore we don't monitor EOF. 1171 * We call handle_ep0() only if a request is queued for ep0. 1172 */ 1173 else if (!list_empty(&imx_ep->queue)) 1174 handle_ep0(imx_ep); 1175 1176 __raw_writel(intr, imx_usb->base + USB_EP_INTR(0)); 1177 1178 return IRQ_HANDLED; 1179} 1180 1181static irqreturn_t imx_udc_bulk_irq(int irq, void *dev) 1182{ 1183 struct imx_udc_struct *imx_usb = dev; 1184 struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - USBD_INT0]; 1185 int intr = __raw_readl(imx_usb->base + USB_EP_INTR(EP_NO(imx_ep))); 1186 1187 dump_ep_intr(__func__, irq - USBD_INT0, intr, imx_usb->dev); 1188 1189 if (!imx_usb->driver) { 1190 __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep))); 1191 return IRQ_HANDLED; 1192 } 1193 1194 handle_ep(imx_ep); 1195 1196 __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep))); 1197 1198 return IRQ_HANDLED; 1199} 1200 1201irq_handler_t intr_handler(int i) 1202{ 1203 switch (i) { 1204 case 0: 1205 return imx_udc_ctrl_irq; 1206 case 1: 1207 case 2: 1208 case 3: 1209 case 4: 1210 case 5: 1211 return imx_udc_bulk_irq; 1212 default: 1213 return imx_udc_irq; 1214 } 1215} 1216 1217/******************************************************************************* 1218 * Static defined IMX UDC structure 1219 ******************************************************************************* 1220 */ 1221 1222static const struct usb_gadget_ops imx_udc_ops = { 1223 .get_frame = imx_udc_get_frame, 1224 .wakeup = imx_udc_wakeup, 1225}; 1226 1227static struct imx_udc_struct controller = { 1228 .gadget = { 1229 .ops = &imx_udc_ops, 1230 .ep0 = &controller.imx_ep[0].ep, 1231 .name = driver_name, 1232 .dev = { 1233 .init_name = "gadget", 1234 }, 1235 }, 1236 1237 .imx_ep[0] = { 1238 .ep = { 1239 .name = ep0name, 1240 .ops = &imx_ep_ops, 1241 .maxpacket = 32, 1242 }, 1243 .imx_usb = &controller, 1244 .fifosize = 32, 1245 .bEndpointAddress = 0, 1246 .bmAttributes = USB_ENDPOINT_XFER_CONTROL, 1247 }, 1248 .imx_ep[1] = { 1249 .ep = { 1250 .name = "ep1in-bulk", 1251 .ops = &imx_ep_ops, 1252 .maxpacket = 64, 1253 }, 1254 .imx_usb = &controller, 1255 .fifosize = 64, 1256 .bEndpointAddress = USB_DIR_IN | 1, 1257 .bmAttributes = USB_ENDPOINT_XFER_BULK, 1258 }, 1259 .imx_ep[2] = { 1260 .ep = { 1261 .name = "ep2out-bulk", 1262 .ops = &imx_ep_ops, 1263 .maxpacket = 64, 1264 }, 1265 .imx_usb = &controller, 1266 .fifosize = 64, 1267 .bEndpointAddress = USB_DIR_OUT | 2, 1268 .bmAttributes = USB_ENDPOINT_XFER_BULK, 1269 }, 1270 .imx_ep[3] = { 1271 .ep = { 1272 .name = "ep3out-bulk", 1273 .ops = &imx_ep_ops, 1274 .maxpacket = 32, 1275 }, 1276 .imx_usb = &controller, 1277 .fifosize = 32, 1278 .bEndpointAddress = USB_DIR_OUT | 3, 1279 .bmAttributes = USB_ENDPOINT_XFER_BULK, 1280 }, 1281 .imx_ep[4] = { 1282 .ep = { 1283 .name = "ep4in-int", 1284 .ops = &imx_ep_ops, 1285 .maxpacket = 32, 1286 }, 1287 .imx_usb = &controller, 1288 .fifosize = 32, 1289 .bEndpointAddress = USB_DIR_IN | 4, 1290 .bmAttributes = USB_ENDPOINT_XFER_INT, 1291 }, 1292 .imx_ep[5] = { 1293 .ep = { 1294 .name = "ep5out-int", 1295 .ops = &imx_ep_ops, 1296 .maxpacket = 32, 1297 }, 1298 .imx_usb = &controller, 1299 .fifosize = 32, 1300 .bEndpointAddress = USB_DIR_OUT | 5, 1301 .bmAttributes = USB_ENDPOINT_XFER_INT, 1302 }, 1303}; 1304 1305/******************************************************************************* 1306 * USB gadged driver functions 1307 ******************************************************************************* 1308 */ 1309int usb_gadget_register_driver(struct usb_gadget_driver *driver) 1310{ 1311 struct imx_udc_struct *imx_usb = &controller; 1312 int retval; 1313 1314 if (!driver 1315 || driver->speed < USB_SPEED_FULL 1316 || !driver->bind 1317 || !driver->disconnect 1318 || !driver->setup) 1319 return -EINVAL; 1320 if (!imx_usb) 1321 return -ENODEV; 1322 if (imx_usb->driver) 1323 return -EBUSY; 1324 1325 /* first hook up the driver ... */ 1326 imx_usb->driver = driver; 1327 imx_usb->gadget.dev.driver = &driver->driver; 1328 1329 retval = device_add(&imx_usb->gadget.dev); 1330 if (retval) 1331 goto fail; 1332 retval = driver->bind(&imx_usb->gadget); 1333 if (retval) { 1334 D_ERR(imx_usb->dev, "<%s> bind to driver %s --> error %d\n", 1335 __func__, driver->driver.name, retval); 1336 device_del(&imx_usb->gadget.dev); 1337 1338 goto fail; 1339 } 1340 1341 D_INI(imx_usb->dev, "<%s> registered gadget driver '%s'\n", 1342 __func__, driver->driver.name); 1343 1344 imx_udc_enable(imx_usb); 1345 1346 return 0; 1347fail: 1348 imx_usb->driver = NULL; 1349 imx_usb->gadget.dev.driver = NULL; 1350 return retval; 1351} 1352EXPORT_SYMBOL(usb_gadget_register_driver); 1353 1354int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) 1355{ 1356 struct imx_udc_struct *imx_usb = &controller; 1357 1358 if (!imx_usb) 1359 return -ENODEV; 1360 if (!driver || driver != imx_usb->driver || !driver->unbind) 1361 return -EINVAL; 1362 1363 udc_stop_activity(imx_usb, driver); 1364 imx_udc_disable(imx_usb); 1365 del_timer(&imx_usb->timer); 1366 1367 driver->unbind(&imx_usb->gadget); 1368 imx_usb->gadget.dev.driver = NULL; 1369 imx_usb->driver = NULL; 1370 1371 device_del(&imx_usb->gadget.dev); 1372 1373 D_INI(imx_usb->dev, "<%s> unregistered gadget driver '%s'\n", 1374 __func__, driver->driver.name); 1375 1376 return 0; 1377} 1378EXPORT_SYMBOL(usb_gadget_unregister_driver); 1379 1380/******************************************************************************* 1381 * Module functions 1382 ******************************************************************************* 1383 */ 1384 1385static int __init imx_udc_probe(struct platform_device *pdev) 1386{ 1387 struct imx_udc_struct *imx_usb = &controller; 1388 struct resource *res; 1389 struct imxusb_platform_data *pdata; 1390 struct clk *clk; 1391 void __iomem *base; 1392 int ret = 0; 1393 int i; 1394 resource_size_t res_size; 1395 1396 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1397 if (!res) { 1398 dev_err(&pdev->dev, "can't get device resources\n"); 1399 return -ENODEV; 1400 } 1401 1402 pdata = pdev->dev.platform_data; 1403 if (!pdata) { 1404 dev_err(&pdev->dev, "driver needs platform data\n"); 1405 return -ENODEV; 1406 } 1407 1408 res_size = resource_size(res); 1409 if (!request_mem_region(res->start, res_size, res->name)) { 1410 dev_err(&pdev->dev, "can't allocate %d bytes at %d address\n", 1411 res_size, res->start); 1412 return -ENOMEM; 1413 } 1414 1415 if (pdata->init) { 1416 ret = pdata->init(&pdev->dev); 1417 if (ret) 1418 goto fail0; 1419 } 1420 1421 base = ioremap(res->start, res_size); 1422 if (!base) { 1423 dev_err(&pdev->dev, "ioremap failed\n"); 1424 ret = -EIO; 1425 goto fail1; 1426 } 1427 1428 clk = clk_get(NULL, "usbd_clk"); 1429 if (IS_ERR(clk)) { 1430 ret = PTR_ERR(clk); 1431 dev_err(&pdev->dev, "can't get USB clock\n"); 1432 goto fail2; 1433 } 1434 clk_enable(clk); 1435 1436 if (clk_get_rate(clk) != 48000000) { 1437 D_INI(&pdev->dev, 1438 "Bad USB clock (%d Hz), changing to 48000000 Hz\n", 1439 (int)clk_get_rate(clk)); 1440 if (clk_set_rate(clk, 48000000)) { 1441 dev_err(&pdev->dev, 1442 "Unable to set correct USB clock (48MHz)\n"); 1443 ret = -EIO; 1444 goto fail3; 1445 } 1446 } 1447 1448 for (i = 0; i < IMX_USB_NB_EP + 1; i++) { 1449 imx_usb->usbd_int[i] = platform_get_irq(pdev, i); 1450 if (imx_usb->usbd_int[i] < 0) { 1451 dev_err(&pdev->dev, "can't get irq number\n"); 1452 ret = -ENODEV; 1453 goto fail3; 1454 } 1455 } 1456 1457 for (i = 0; i < IMX_USB_NB_EP + 1; i++) { 1458 ret = request_irq(imx_usb->usbd_int[i], intr_handler(i), 1459 IRQF_DISABLED, driver_name, imx_usb); 1460 if (ret) { 1461 dev_err(&pdev->dev, "can't get irq %i, err %d\n", 1462 imx_usb->usbd_int[i], ret); 1463 for (--i; i >= 0; i--) 1464 free_irq(imx_usb->usbd_int[i], imx_usb); 1465 goto fail3; 1466 } 1467 } 1468 1469 imx_usb->res = res; 1470 imx_usb->base = base; 1471 imx_usb->clk = clk; 1472 imx_usb->dev = &pdev->dev; 1473 1474 device_initialize(&imx_usb->gadget.dev); 1475 1476 imx_usb->gadget.dev.parent = &pdev->dev; 1477 imx_usb->gadget.dev.dma_mask = pdev->dev.dma_mask; 1478 1479 platform_set_drvdata(pdev, imx_usb); 1480 1481 usb_init_data(imx_usb); 1482 imx_udc_init(imx_usb); 1483 1484 init_timer(&imx_usb->timer); 1485 imx_usb->timer.function = handle_config; 1486 imx_usb->timer.data = (unsigned long)imx_usb; 1487 1488 return 0; 1489 1490fail3: 1491 clk_put(clk); 1492 clk_disable(clk); 1493fail2: 1494 iounmap(base); 1495fail1: 1496 if (pdata->exit) 1497 pdata->exit(&pdev->dev); 1498fail0: 1499 release_mem_region(res->start, res_size); 1500 return ret; 1501} 1502 1503static int __exit imx_udc_remove(struct platform_device *pdev) 1504{ 1505 struct imx_udc_struct *imx_usb = platform_get_drvdata(pdev); 1506 struct imxusb_platform_data *pdata = pdev->dev.platform_data; 1507 int i; 1508 1509 imx_udc_disable(imx_usb); 1510 del_timer(&imx_usb->timer); 1511 1512 for (i = 0; i < IMX_USB_NB_EP + 1; i++) 1513 free_irq(imx_usb->usbd_int[i], imx_usb); 1514 1515 clk_put(imx_usb->clk); 1516 clk_disable(imx_usb->clk); 1517 iounmap(imx_usb->base); 1518 1519 release_mem_region(imx_usb->res->start, resource_size(imx_usb->res)); 1520 1521 if (pdata->exit) 1522 pdata->exit(&pdev->dev); 1523 1524 platform_set_drvdata(pdev, NULL); 1525 1526 return 0; 1527} 1528 1529/*----------------------------------------------------------------------------*/ 1530 1531#ifdef CONFIG_PM 1532#define imx_udc_suspend NULL 1533#define imx_udc_resume NULL 1534#else 1535#define imx_udc_suspend NULL 1536#define imx_udc_resume NULL 1537#endif 1538 1539/*----------------------------------------------------------------------------*/ 1540 1541static struct platform_driver udc_driver = { 1542 .driver = { 1543 .name = driver_name, 1544 .owner = THIS_MODULE, 1545 }, 1546 .remove = __exit_p(imx_udc_remove), 1547 .suspend = imx_udc_suspend, 1548 .resume = imx_udc_resume, 1549}; 1550 1551static int __init udc_init(void) 1552{ 1553 return platform_driver_probe(&udc_driver, imx_udc_probe); 1554} 1555module_init(udc_init); 1556 1557static void __exit udc_exit(void) 1558{ 1559 platform_driver_unregister(&udc_driver); 1560} 1561module_exit(udc_exit); 1562 1563MODULE_DESCRIPTION("IMX USB Device Controller driver"); 1564MODULE_AUTHOR("Darius Augulis <augulis.darius@gmail.com>"); 1565MODULE_LICENSE("GPL"); 1566MODULE_ALIAS("platform:imx_udc"); 1567