1// SPDX-License-Identifier: GPL-2.0 2/* 3 * FOTG210 UDC Driver supports Bulk transfer so far 4 * 5 * Copyright (C) 2013 Faraday Technology Corporation 6 * 7 * Author : Yuan-Hsin Chen <yhchen@faraday-tech.com> 8 */ 9 10#include <linux/delay.h> 11#include <linux/dma-mapping.h> 12#include <linux/err.h> 13#include <linux/interrupt.h> 14#include <linux/io.h> 15#include <linux/module.h> 16#include <linux/platform_device.h> 17#include <linux/usb/ch9.h> 18#include <linux/usb/gadget.h> 19#include <linux/usb/otg.h> 20#include <linux/usb/phy.h> 21 22#include "fotg210.h" 23#include "fotg210-udc.h" 24 25#define DRIVER_DESC "FOTG210 USB Device Controller Driver" 26#define DRIVER_VERSION "30-April-2013" 27 28static const char udc_name[] = "fotg210_udc"; 29static const char * const fotg210_ep_name[] = { 30 "ep0", "ep1", "ep2", "ep3", "ep4"}; 31 32static void fotg210_ack_int(struct fotg210_udc *fotg210, u32 offset, u32 mask) 33{ 34 u32 value = ioread32(fotg210->reg + offset); 35 36 value &= ~mask; 37 iowrite32(value, fotg210->reg + offset); 38} 39 40static void fotg210_disable_fifo_int(struct fotg210_ep *ep) 41{ 42 u32 value = ioread32(ep->fotg210->reg + FOTG210_DMISGR1); 43 44 if (ep->dir_in) 45 value |= DMISGR1_MF_IN_INT(ep->epnum - 1); 46 else 47 value |= DMISGR1_MF_OUTSPK_INT(ep->epnum - 1); 48 iowrite32(value, ep->fotg210->reg + FOTG210_DMISGR1); 49} 50 51static void fotg210_enable_fifo_int(struct fotg210_ep *ep) 52{ 53 u32 value = ioread32(ep->fotg210->reg + FOTG210_DMISGR1); 54 55 if (ep->dir_in) 56 value &= ~DMISGR1_MF_IN_INT(ep->epnum - 1); 57 else 58 value &= ~DMISGR1_MF_OUTSPK_INT(ep->epnum - 1); 59 iowrite32(value, ep->fotg210->reg + FOTG210_DMISGR1); 60} 61 62static void fotg210_set_cxdone(struct fotg210_udc *fotg210) 63{ 64 u32 value = ioread32(fotg210->reg + FOTG210_DCFESR); 65 66 value |= DCFESR_CX_DONE; 67 iowrite32(value, fotg210->reg + FOTG210_DCFESR); 68} 69 70static void fotg210_done(struct fotg210_ep *ep, struct fotg210_request *req, 71 int status) 72{ 73 list_del_init(&req->queue); 74 75 /* don't modify queue heads during completion callback */ 76 if (ep->fotg210->gadget.speed == USB_SPEED_UNKNOWN) 77 req->req.status = -ESHUTDOWN; 78 else 79 req->req.status = status; 80 81 spin_unlock(&ep->fotg210->lock); 82 usb_gadget_giveback_request(&ep->ep, &req->req); 83 spin_lock(&ep->fotg210->lock); 84 85 if (ep->epnum) { 86 if (list_empty(&ep->queue)) 87 fotg210_disable_fifo_int(ep); 88 } else { 89 fotg210_set_cxdone(ep->fotg210); 90 } 91} 92 93static void fotg210_fifo_ep_mapping(struct fotg210_ep *ep, u32 epnum, 94 u32 dir_in) 95{ 96 struct fotg210_udc *fotg210 = ep->fotg210; 97 u32 val; 98 99 /* Driver should map an ep to a fifo and then map the fifo 100 * to the ep. What a brain-damaged design! 101 */ 102 103 /* map a fifo to an ep */ 104 val = ioread32(fotg210->reg + FOTG210_EPMAP); 105 val &= ~EPMAP_FIFONOMSK(epnum, dir_in); 106 val |= EPMAP_FIFONO(epnum, dir_in); 107 iowrite32(val, fotg210->reg + FOTG210_EPMAP); 108 109 /* map the ep to the fifo */ 110 val = ioread32(fotg210->reg + FOTG210_FIFOMAP); 111 val &= ~FIFOMAP_EPNOMSK(epnum); 112 val |= FIFOMAP_EPNO(epnum); 113 iowrite32(val, fotg210->reg + FOTG210_FIFOMAP); 114 115 /* enable fifo */ 116 val = ioread32(fotg210->reg + FOTG210_FIFOCF); 117 val |= FIFOCF_FIFO_EN(epnum - 1); 118 iowrite32(val, fotg210->reg + FOTG210_FIFOCF); 119} 120 121static void fotg210_set_fifo_dir(struct fotg210_ep *ep, u32 epnum, u32 dir_in) 122{ 123 struct fotg210_udc *fotg210 = ep->fotg210; 124 u32 val; 125 126 val = ioread32(fotg210->reg + FOTG210_FIFOMAP); 127 val |= (dir_in ? FIFOMAP_DIRIN(epnum - 1) : FIFOMAP_DIROUT(epnum - 1)); 128 iowrite32(val, fotg210->reg + FOTG210_FIFOMAP); 129} 130 131static void fotg210_set_tfrtype(struct fotg210_ep *ep, u32 epnum, u32 type) 132{ 133 struct fotg210_udc *fotg210 = ep->fotg210; 134 u32 val; 135 136 val = ioread32(fotg210->reg + FOTG210_FIFOCF); 137 val |= FIFOCF_TYPE(type, epnum - 1); 138 iowrite32(val, fotg210->reg + FOTG210_FIFOCF); 139} 140 141static void fotg210_set_mps(struct fotg210_ep *ep, u32 epnum, u32 mps, 142 u32 dir_in) 143{ 144 struct fotg210_udc *fotg210 = ep->fotg210; 145 u32 val; 146 u32 offset = dir_in ? FOTG210_INEPMPSR(epnum) : 147 FOTG210_OUTEPMPSR(epnum); 148 149 val = ioread32(fotg210->reg + offset); 150 val |= INOUTEPMPSR_MPS(mps); 151 iowrite32(val, fotg210->reg + offset); 152} 153 154static int fotg210_config_ep(struct fotg210_ep *ep, 155 const struct usb_endpoint_descriptor *desc) 156{ 157 struct fotg210_udc *fotg210 = ep->fotg210; 158 159 fotg210_set_fifo_dir(ep, ep->epnum, ep->dir_in); 160 fotg210_set_tfrtype(ep, ep->epnum, ep->type); 161 fotg210_set_mps(ep, ep->epnum, ep->ep.maxpacket, ep->dir_in); 162 fotg210_fifo_ep_mapping(ep, ep->epnum, ep->dir_in); 163 164 fotg210->ep[ep->epnum] = ep; 165 166 return 0; 167} 168 169static int fotg210_ep_enable(struct usb_ep *_ep, 170 const struct usb_endpoint_descriptor *desc) 171{ 172 struct fotg210_ep *ep; 173 174 ep = container_of(_ep, struct fotg210_ep, ep); 175 176 ep->desc = desc; 177 ep->epnum = usb_endpoint_num(desc); 178 ep->type = usb_endpoint_type(desc); 179 ep->dir_in = usb_endpoint_dir_in(desc); 180 ep->ep.maxpacket = usb_endpoint_maxp(desc); 181 182 return fotg210_config_ep(ep, desc); 183} 184 185static void fotg210_reset_tseq(struct fotg210_udc *fotg210, u8 epnum) 186{ 187 struct fotg210_ep *ep = fotg210->ep[epnum]; 188 u32 value; 189 void __iomem *reg; 190 191 reg = (ep->dir_in) ? 192 fotg210->reg + FOTG210_INEPMPSR(epnum) : 193 fotg210->reg + FOTG210_OUTEPMPSR(epnum); 194 195 /* Note: Driver needs to set and clear INOUTEPMPSR_RESET_TSEQ 196 * bit. Controller wouldn't clear this bit. WTF!!! 197 */ 198 199 value = ioread32(reg); 200 value |= INOUTEPMPSR_RESET_TSEQ; 201 iowrite32(value, reg); 202 203 value = ioread32(reg); 204 value &= ~INOUTEPMPSR_RESET_TSEQ; 205 iowrite32(value, reg); 206} 207 208static int fotg210_ep_release(struct fotg210_ep *ep) 209{ 210 if (!ep->epnum) 211 return 0; 212 ep->epnum = 0; 213 ep->stall = 0; 214 ep->wedged = 0; 215 216 fotg210_reset_tseq(ep->fotg210, ep->epnum); 217 218 return 0; 219} 220 221static int fotg210_ep_disable(struct usb_ep *_ep) 222{ 223 struct fotg210_ep *ep; 224 struct fotg210_request *req; 225 unsigned long flags; 226 227 BUG_ON(!_ep); 228 229 ep = container_of(_ep, struct fotg210_ep, ep); 230 231 while (!list_empty(&ep->queue)) { 232 req = list_entry(ep->queue.next, 233 struct fotg210_request, queue); 234 spin_lock_irqsave(&ep->fotg210->lock, flags); 235 fotg210_done(ep, req, -ECONNRESET); 236 spin_unlock_irqrestore(&ep->fotg210->lock, flags); 237 } 238 239 return fotg210_ep_release(ep); 240} 241 242static struct usb_request *fotg210_ep_alloc_request(struct usb_ep *_ep, 243 gfp_t gfp_flags) 244{ 245 struct fotg210_request *req; 246 247 req = kzalloc(sizeof(struct fotg210_request), gfp_flags); 248 if (!req) 249 return NULL; 250 251 INIT_LIST_HEAD(&req->queue); 252 253 return &req->req; 254} 255 256static void fotg210_ep_free_request(struct usb_ep *_ep, 257 struct usb_request *_req) 258{ 259 struct fotg210_request *req; 260 261 req = container_of(_req, struct fotg210_request, req); 262 kfree(req); 263} 264 265static void fotg210_enable_dma(struct fotg210_ep *ep, 266 dma_addr_t d, u32 len) 267{ 268 u32 value; 269 struct fotg210_udc *fotg210 = ep->fotg210; 270 271 /* set transfer length and direction */ 272 value = ioread32(fotg210->reg + FOTG210_DMACPSR1); 273 value &= ~(DMACPSR1_DMA_LEN(0xFFFF) | DMACPSR1_DMA_TYPE(1)); 274 value |= DMACPSR1_DMA_LEN(len) | DMACPSR1_DMA_TYPE(ep->dir_in); 275 iowrite32(value, fotg210->reg + FOTG210_DMACPSR1); 276 277 /* set device DMA target FIFO number */ 278 value = ioread32(fotg210->reg + FOTG210_DMATFNR); 279 if (ep->epnum) 280 value |= DMATFNR_ACC_FN(ep->epnum - 1); 281 else 282 value |= DMATFNR_ACC_CXF; 283 iowrite32(value, fotg210->reg + FOTG210_DMATFNR); 284 285 /* set DMA memory address */ 286 iowrite32(d, fotg210->reg + FOTG210_DMACPSR2); 287 288 /* enable MDMA_EROR and MDMA_CMPLT interrupt */ 289 value = ioread32(fotg210->reg + FOTG210_DMISGR2); 290 value &= ~(DMISGR2_MDMA_CMPLT | DMISGR2_MDMA_ERROR); 291 iowrite32(value, fotg210->reg + FOTG210_DMISGR2); 292 293 /* start DMA */ 294 value = ioread32(fotg210->reg + FOTG210_DMACPSR1); 295 value |= DMACPSR1_DMA_START; 296 iowrite32(value, fotg210->reg + FOTG210_DMACPSR1); 297} 298 299static void fotg210_disable_dma(struct fotg210_ep *ep) 300{ 301 iowrite32(DMATFNR_DISDMA, ep->fotg210->reg + FOTG210_DMATFNR); 302} 303 304static void fotg210_wait_dma_done(struct fotg210_ep *ep) 305{ 306 u32 value; 307 308 do { 309 value = ioread32(ep->fotg210->reg + FOTG210_DISGR2); 310 if ((value & DISGR2_USBRST_INT) || 311 (value & DISGR2_DMA_ERROR)) 312 goto dma_reset; 313 } while (!(value & DISGR2_DMA_CMPLT)); 314 315 fotg210_ack_int(ep->fotg210, FOTG210_DISGR2, DISGR2_DMA_CMPLT); 316 return; 317 318dma_reset: 319 value = ioread32(ep->fotg210->reg + FOTG210_DMACPSR1); 320 value |= DMACPSR1_DMA_ABORT; 321 iowrite32(value, ep->fotg210->reg + FOTG210_DMACPSR1); 322 323 /* reset fifo */ 324 if (ep->epnum) { 325 value = ioread32(ep->fotg210->reg + 326 FOTG210_FIBCR(ep->epnum - 1)); 327 value |= FIBCR_FFRST; 328 iowrite32(value, ep->fotg210->reg + 329 FOTG210_FIBCR(ep->epnum - 1)); 330 } else { 331 value = ioread32(ep->fotg210->reg + FOTG210_DCFESR); 332 value |= DCFESR_CX_CLR; 333 iowrite32(value, ep->fotg210->reg + FOTG210_DCFESR); 334 } 335} 336 337static void fotg210_start_dma(struct fotg210_ep *ep, 338 struct fotg210_request *req) 339{ 340 struct device *dev = &ep->fotg210->gadget.dev; 341 dma_addr_t d; 342 u8 *buffer; 343 u32 length; 344 345 if (ep->epnum) { 346 if (ep->dir_in) { 347 buffer = req->req.buf; 348 length = req->req.length; 349 } else { 350 buffer = req->req.buf + req->req.actual; 351 length = ioread32(ep->fotg210->reg + 352 FOTG210_FIBCR(ep->epnum - 1)) & FIBCR_BCFX; 353 if (length > req->req.length - req->req.actual) 354 length = req->req.length - req->req.actual; 355 } 356 } else { 357 buffer = req->req.buf + req->req.actual; 358 if (req->req.length - req->req.actual > ep->ep.maxpacket) 359 length = ep->ep.maxpacket; 360 else 361 length = req->req.length - req->req.actual; 362 } 363 364 d = dma_map_single(dev, buffer, length, 365 ep->dir_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE); 366 367 if (dma_mapping_error(dev, d)) { 368 pr_err("dma_mapping_error\n"); 369 return; 370 } 371 372 fotg210_enable_dma(ep, d, length); 373 374 /* check if dma is done */ 375 fotg210_wait_dma_done(ep); 376 377 fotg210_disable_dma(ep); 378 379 /* update actual transfer length */ 380 req->req.actual += length; 381 382 dma_unmap_single(dev, d, length, DMA_TO_DEVICE); 383} 384 385static void fotg210_ep0_queue(struct fotg210_ep *ep, 386 struct fotg210_request *req) 387{ 388 if (!req->req.length) { 389 fotg210_done(ep, req, 0); 390 return; 391 } 392 if (ep->dir_in) { /* if IN */ 393 fotg210_start_dma(ep, req); 394 if (req->req.length == req->req.actual) 395 fotg210_done(ep, req, 0); 396 } else { /* OUT */ 397 u32 value = ioread32(ep->fotg210->reg + FOTG210_DMISGR0); 398 399 value &= ~DMISGR0_MCX_OUT_INT; 400 iowrite32(value, ep->fotg210->reg + FOTG210_DMISGR0); 401 } 402} 403 404static int fotg210_ep_queue(struct usb_ep *_ep, struct usb_request *_req, 405 gfp_t gfp_flags) 406{ 407 struct fotg210_ep *ep; 408 struct fotg210_request *req; 409 unsigned long flags; 410 int request = 0; 411 412 ep = container_of(_ep, struct fotg210_ep, ep); 413 req = container_of(_req, struct fotg210_request, req); 414 415 if (ep->fotg210->gadget.speed == USB_SPEED_UNKNOWN) 416 return -ESHUTDOWN; 417 418 spin_lock_irqsave(&ep->fotg210->lock, flags); 419 420 if (list_empty(&ep->queue)) 421 request = 1; 422 423 list_add_tail(&req->queue, &ep->queue); 424 425 req->req.actual = 0; 426 req->req.status = -EINPROGRESS; 427 428 if (!ep->epnum) /* ep0 */ 429 fotg210_ep0_queue(ep, req); 430 else if (request && !ep->stall) 431 fotg210_enable_fifo_int(ep); 432 433 spin_unlock_irqrestore(&ep->fotg210->lock, flags); 434 435 return 0; 436} 437 438static int fotg210_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req) 439{ 440 struct fotg210_ep *ep; 441 struct fotg210_request *req; 442 unsigned long flags; 443 444 ep = container_of(_ep, struct fotg210_ep, ep); 445 req = container_of(_req, struct fotg210_request, req); 446 447 spin_lock_irqsave(&ep->fotg210->lock, flags); 448 if (!list_empty(&ep->queue)) 449 fotg210_done(ep, req, -ECONNRESET); 450 spin_unlock_irqrestore(&ep->fotg210->lock, flags); 451 452 return 0; 453} 454 455static void fotg210_set_epnstall(struct fotg210_ep *ep) 456{ 457 struct fotg210_udc *fotg210 = ep->fotg210; 458 u32 value; 459 void __iomem *reg; 460 461 /* check if IN FIFO is empty before stall */ 462 if (ep->dir_in) { 463 do { 464 value = ioread32(fotg210->reg + FOTG210_DCFESR); 465 } while (!(value & DCFESR_FIFO_EMPTY(ep->epnum - 1))); 466 } 467 468 reg = (ep->dir_in) ? 469 fotg210->reg + FOTG210_INEPMPSR(ep->epnum) : 470 fotg210->reg + FOTG210_OUTEPMPSR(ep->epnum); 471 value = ioread32(reg); 472 value |= INOUTEPMPSR_STL_EP; 473 iowrite32(value, reg); 474} 475 476static void fotg210_clear_epnstall(struct fotg210_ep *ep) 477{ 478 struct fotg210_udc *fotg210 = ep->fotg210; 479 u32 value; 480 void __iomem *reg; 481 482 reg = (ep->dir_in) ? 483 fotg210->reg + FOTG210_INEPMPSR(ep->epnum) : 484 fotg210->reg + FOTG210_OUTEPMPSR(ep->epnum); 485 value = ioread32(reg); 486 value &= ~INOUTEPMPSR_STL_EP; 487 iowrite32(value, reg); 488} 489 490static int fotg210_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedge) 491{ 492 struct fotg210_ep *ep; 493 struct fotg210_udc *fotg210; 494 unsigned long flags; 495 496 ep = container_of(_ep, struct fotg210_ep, ep); 497 498 fotg210 = ep->fotg210; 499 500 spin_lock_irqsave(&ep->fotg210->lock, flags); 501 502 if (value) { 503 fotg210_set_epnstall(ep); 504 ep->stall = 1; 505 if (wedge) 506 ep->wedged = 1; 507 } else { 508 fotg210_reset_tseq(fotg210, ep->epnum); 509 fotg210_clear_epnstall(ep); 510 ep->stall = 0; 511 ep->wedged = 0; 512 if (!list_empty(&ep->queue)) 513 fotg210_enable_fifo_int(ep); 514 } 515 516 spin_unlock_irqrestore(&ep->fotg210->lock, flags); 517 return 0; 518} 519 520static int fotg210_ep_set_halt(struct usb_ep *_ep, int value) 521{ 522 return fotg210_set_halt_and_wedge(_ep, value, 0); 523} 524 525static int fotg210_ep_set_wedge(struct usb_ep *_ep) 526{ 527 return fotg210_set_halt_and_wedge(_ep, 1, 1); 528} 529 530static void fotg210_ep_fifo_flush(struct usb_ep *_ep) 531{ 532} 533 534static const struct usb_ep_ops fotg210_ep_ops = { 535 .enable = fotg210_ep_enable, 536 .disable = fotg210_ep_disable, 537 538 .alloc_request = fotg210_ep_alloc_request, 539 .free_request = fotg210_ep_free_request, 540 541 .queue = fotg210_ep_queue, 542 .dequeue = fotg210_ep_dequeue, 543 544 .set_halt = fotg210_ep_set_halt, 545 .fifo_flush = fotg210_ep_fifo_flush, 546 .set_wedge = fotg210_ep_set_wedge, 547}; 548 549static void fotg210_clear_tx0byte(struct fotg210_udc *fotg210) 550{ 551 u32 value = ioread32(fotg210->reg + FOTG210_TX0BYTE); 552 553 value &= ~(TX0BYTE_EP1 | TX0BYTE_EP2 | TX0BYTE_EP3 554 | TX0BYTE_EP4); 555 iowrite32(value, fotg210->reg + FOTG210_TX0BYTE); 556} 557 558static void fotg210_clear_rx0byte(struct fotg210_udc *fotg210) 559{ 560 u32 value = ioread32(fotg210->reg + FOTG210_RX0BYTE); 561 562 value &= ~(RX0BYTE_EP1 | RX0BYTE_EP2 | RX0BYTE_EP3 563 | RX0BYTE_EP4); 564 iowrite32(value, fotg210->reg + FOTG210_RX0BYTE); 565} 566 567/* read 8-byte setup packet only */ 568static void fotg210_rdsetupp(struct fotg210_udc *fotg210, 569 u8 *buffer) 570{ 571 int i = 0; 572 u8 *tmp = buffer; 573 u32 data; 574 u32 length = 8; 575 576 iowrite32(DMATFNR_ACC_CXF, fotg210->reg + FOTG210_DMATFNR); 577 578 for (i = (length >> 2); i > 0; i--) { 579 data = ioread32(fotg210->reg + FOTG210_CXPORT); 580 *tmp = data & 0xFF; 581 *(tmp + 1) = (data >> 8) & 0xFF; 582 *(tmp + 2) = (data >> 16) & 0xFF; 583 *(tmp + 3) = (data >> 24) & 0xFF; 584 tmp = tmp + 4; 585 } 586 587 switch (length % 4) { 588 case 1: 589 data = ioread32(fotg210->reg + FOTG210_CXPORT); 590 *tmp = data & 0xFF; 591 break; 592 case 2: 593 data = ioread32(fotg210->reg + FOTG210_CXPORT); 594 *tmp = data & 0xFF; 595 *(tmp + 1) = (data >> 8) & 0xFF; 596 break; 597 case 3: 598 data = ioread32(fotg210->reg + FOTG210_CXPORT); 599 *tmp = data & 0xFF; 600 *(tmp + 1) = (data >> 8) & 0xFF; 601 *(tmp + 2) = (data >> 16) & 0xFF; 602 break; 603 default: 604 break; 605 } 606 607 iowrite32(DMATFNR_DISDMA, fotg210->reg + FOTG210_DMATFNR); 608} 609 610static void fotg210_set_configuration(struct fotg210_udc *fotg210) 611{ 612 u32 value = ioread32(fotg210->reg + FOTG210_DAR); 613 614 value |= DAR_AFT_CONF; 615 iowrite32(value, fotg210->reg + FOTG210_DAR); 616} 617 618static void fotg210_set_dev_addr(struct fotg210_udc *fotg210, u32 addr) 619{ 620 u32 value = ioread32(fotg210->reg + FOTG210_DAR); 621 622 value |= (addr & 0x7F); 623 iowrite32(value, fotg210->reg + FOTG210_DAR); 624} 625 626static void fotg210_set_cxstall(struct fotg210_udc *fotg210) 627{ 628 u32 value = ioread32(fotg210->reg + FOTG210_DCFESR); 629 630 value |= DCFESR_CX_STL; 631 iowrite32(value, fotg210->reg + FOTG210_DCFESR); 632} 633 634static void fotg210_request_error(struct fotg210_udc *fotg210) 635{ 636 fotg210_set_cxstall(fotg210); 637 pr_err("request error!!\n"); 638} 639 640static void fotg210_set_address(struct fotg210_udc *fotg210, 641 struct usb_ctrlrequest *ctrl) 642{ 643 if (le16_to_cpu(ctrl->wValue) >= 0x0100) { 644 fotg210_request_error(fotg210); 645 } else { 646 fotg210_set_dev_addr(fotg210, le16_to_cpu(ctrl->wValue)); 647 fotg210_set_cxdone(fotg210); 648 } 649} 650 651static void fotg210_set_feature(struct fotg210_udc *fotg210, 652 struct usb_ctrlrequest *ctrl) 653{ 654 switch (ctrl->bRequestType & USB_RECIP_MASK) { 655 case USB_RECIP_DEVICE: 656 fotg210_set_cxdone(fotg210); 657 break; 658 case USB_RECIP_INTERFACE: 659 fotg210_set_cxdone(fotg210); 660 break; 661 case USB_RECIP_ENDPOINT: { 662 u8 epnum; 663 epnum = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK; 664 if (epnum) 665 fotg210_set_epnstall(fotg210->ep[epnum]); 666 else 667 fotg210_set_cxstall(fotg210); 668 fotg210_set_cxdone(fotg210); 669 } 670 break; 671 default: 672 fotg210_request_error(fotg210); 673 break; 674 } 675} 676 677static void fotg210_clear_feature(struct fotg210_udc *fotg210, 678 struct usb_ctrlrequest *ctrl) 679{ 680 struct fotg210_ep *ep = 681 fotg210->ep[ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK]; 682 683 switch (ctrl->bRequestType & USB_RECIP_MASK) { 684 case USB_RECIP_DEVICE: 685 fotg210_set_cxdone(fotg210); 686 break; 687 case USB_RECIP_INTERFACE: 688 fotg210_set_cxdone(fotg210); 689 break; 690 case USB_RECIP_ENDPOINT: 691 if (ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK) { 692 if (ep->wedged) { 693 fotg210_set_cxdone(fotg210); 694 break; 695 } 696 if (ep->stall) 697 fotg210_set_halt_and_wedge(&ep->ep, 0, 0); 698 } 699 fotg210_set_cxdone(fotg210); 700 break; 701 default: 702 fotg210_request_error(fotg210); 703 break; 704 } 705} 706 707static int fotg210_is_epnstall(struct fotg210_ep *ep) 708{ 709 struct fotg210_udc *fotg210 = ep->fotg210; 710 u32 value; 711 void __iomem *reg; 712 713 reg = (ep->dir_in) ? 714 fotg210->reg + FOTG210_INEPMPSR(ep->epnum) : 715 fotg210->reg + FOTG210_OUTEPMPSR(ep->epnum); 716 value = ioread32(reg); 717 return value & INOUTEPMPSR_STL_EP ? 1 : 0; 718} 719 720/* For EP0 requests triggered by this driver (currently GET_STATUS response) */ 721static void fotg210_ep0_complete(struct usb_ep *_ep, struct usb_request *req) 722{ 723 struct fotg210_ep *ep; 724 struct fotg210_udc *fotg210; 725 726 ep = container_of(_ep, struct fotg210_ep, ep); 727 fotg210 = ep->fotg210; 728 729 if (req->status || req->actual != req->length) { 730 dev_warn(&fotg210->gadget.dev, "EP0 request failed: %d\n", req->status); 731 } 732} 733 734static void fotg210_get_status(struct fotg210_udc *fotg210, 735 struct usb_ctrlrequest *ctrl) 736{ 737 u8 epnum; 738 739 switch (ctrl->bRequestType & USB_RECIP_MASK) { 740 case USB_RECIP_DEVICE: 741 fotg210->ep0_data = cpu_to_le16(1 << USB_DEVICE_SELF_POWERED); 742 break; 743 case USB_RECIP_INTERFACE: 744 fotg210->ep0_data = cpu_to_le16(0); 745 break; 746 case USB_RECIP_ENDPOINT: 747 epnum = ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK; 748 if (epnum) 749 fotg210->ep0_data = 750 cpu_to_le16(fotg210_is_epnstall(fotg210->ep[epnum]) 751 << USB_ENDPOINT_HALT); 752 else 753 fotg210_request_error(fotg210); 754 break; 755 756 default: 757 fotg210_request_error(fotg210); 758 return; /* exit */ 759 } 760 761 fotg210->ep0_req->buf = &fotg210->ep0_data; 762 fotg210->ep0_req->length = 2; 763 764 spin_unlock(&fotg210->lock); 765 fotg210_ep_queue(fotg210->gadget.ep0, fotg210->ep0_req, GFP_ATOMIC); 766 spin_lock(&fotg210->lock); 767} 768 769static int fotg210_setup_packet(struct fotg210_udc *fotg210, 770 struct usb_ctrlrequest *ctrl) 771{ 772 u8 *p = (u8 *)ctrl; 773 u8 ret = 0; 774 775 fotg210_rdsetupp(fotg210, p); 776 777 fotg210->ep[0]->dir_in = ctrl->bRequestType & USB_DIR_IN; 778 779 if (fotg210->gadget.speed == USB_SPEED_UNKNOWN) { 780 u32 value = ioread32(fotg210->reg + FOTG210_DMCR); 781 fotg210->gadget.speed = value & DMCR_HS_EN ? 782 USB_SPEED_HIGH : USB_SPEED_FULL; 783 } 784 785 /* check request */ 786 if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) { 787 switch (ctrl->bRequest) { 788 case USB_REQ_GET_STATUS: 789 fotg210_get_status(fotg210, ctrl); 790 break; 791 case USB_REQ_CLEAR_FEATURE: 792 fotg210_clear_feature(fotg210, ctrl); 793 break; 794 case USB_REQ_SET_FEATURE: 795 fotg210_set_feature(fotg210, ctrl); 796 break; 797 case USB_REQ_SET_ADDRESS: 798 fotg210_set_address(fotg210, ctrl); 799 break; 800 case USB_REQ_SET_CONFIGURATION: 801 fotg210_set_configuration(fotg210); 802 ret = 1; 803 break; 804 default: 805 ret = 1; 806 break; 807 } 808 } else { 809 ret = 1; 810 } 811 812 return ret; 813} 814 815static void fotg210_ep0out(struct fotg210_udc *fotg210) 816{ 817 struct fotg210_ep *ep = fotg210->ep[0]; 818 819 if (!list_empty(&ep->queue) && !ep->dir_in) { 820 struct fotg210_request *req; 821 822 req = list_first_entry(&ep->queue, 823 struct fotg210_request, queue); 824 825 if (req->req.length) 826 fotg210_start_dma(ep, req); 827 828 if ((req->req.length - req->req.actual) < ep->ep.maxpacket) 829 fotg210_done(ep, req, 0); 830 } else { 831 pr_err("%s : empty queue\n", __func__); 832 } 833} 834 835static void fotg210_ep0in(struct fotg210_udc *fotg210) 836{ 837 struct fotg210_ep *ep = fotg210->ep[0]; 838 839 if ((!list_empty(&ep->queue)) && (ep->dir_in)) { 840 struct fotg210_request *req; 841 842 req = list_entry(ep->queue.next, 843 struct fotg210_request, queue); 844 845 if (req->req.length) 846 fotg210_start_dma(ep, req); 847 848 if (req->req.actual == req->req.length) 849 fotg210_done(ep, req, 0); 850 } else { 851 fotg210_set_cxdone(fotg210); 852 } 853} 854 855static void fotg210_in_fifo_handler(struct fotg210_ep *ep) 856{ 857 struct fotg210_request *req = list_entry(ep->queue.next, 858 struct fotg210_request, queue); 859 860 if (req->req.length) 861 fotg210_start_dma(ep, req); 862 fotg210_done(ep, req, 0); 863} 864 865static void fotg210_out_fifo_handler(struct fotg210_ep *ep) 866{ 867 struct fotg210_request *req = list_entry(ep->queue.next, 868 struct fotg210_request, queue); 869 int disgr1 = ioread32(ep->fotg210->reg + FOTG210_DISGR1); 870 871 fotg210_start_dma(ep, req); 872 873 /* Complete the request when it's full or a short packet arrived. 874 * Like other drivers, short_not_ok isn't handled. 875 */ 876 877 if (req->req.length == req->req.actual || 878 (disgr1 & DISGR1_SPK_INT(ep->epnum - 1))) 879 fotg210_done(ep, req, 0); 880} 881 882static irqreturn_t fotg210_irq(int irq, void *_fotg210) 883{ 884 struct fotg210_udc *fotg210 = _fotg210; 885 u32 int_grp = ioread32(fotg210->reg + FOTG210_DIGR); 886 u32 int_msk = ioread32(fotg210->reg + FOTG210_DMIGR); 887 888 int_grp &= ~int_msk; 889 890 spin_lock(&fotg210->lock); 891 892 if (int_grp & DIGR_INT_G2) { 893 void __iomem *reg = fotg210->reg + FOTG210_DISGR2; 894 u32 int_grp2 = ioread32(reg); 895 u32 int_msk2 = ioread32(fotg210->reg + FOTG210_DMISGR2); 896 897 int_grp2 &= ~int_msk2; 898 899 if (int_grp2 & DISGR2_USBRST_INT) { 900 usb_gadget_udc_reset(&fotg210->gadget, 901 fotg210->driver); 902 fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_USBRST_INT); 903 pr_info("fotg210 udc reset\n"); 904 } 905 if (int_grp2 & DISGR2_SUSP_INT) { 906 fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_SUSP_INT); 907 pr_info("fotg210 udc suspend\n"); 908 } 909 if (int_grp2 & DISGR2_RESM_INT) { 910 fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_RESM_INT); 911 pr_info("fotg210 udc resume\n"); 912 } 913 if (int_grp2 & DISGR2_ISO_SEQ_ERR_INT) { 914 fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_ISO_SEQ_ERR_INT); 915 pr_info("fotg210 iso sequence error\n"); 916 } 917 if (int_grp2 & DISGR2_ISO_SEQ_ABORT_INT) { 918 fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_ISO_SEQ_ABORT_INT); 919 pr_info("fotg210 iso sequence abort\n"); 920 } 921 if (int_grp2 & DISGR2_TX0BYTE_INT) { 922 fotg210_clear_tx0byte(fotg210); 923 fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_TX0BYTE_INT); 924 pr_info("fotg210 transferred 0 byte\n"); 925 } 926 if (int_grp2 & DISGR2_RX0BYTE_INT) { 927 fotg210_clear_rx0byte(fotg210); 928 fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_RX0BYTE_INT); 929 pr_info("fotg210 received 0 byte\n"); 930 } 931 if (int_grp2 & DISGR2_DMA_ERROR) { 932 fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_DMA_ERROR); 933 } 934 } 935 936 if (int_grp & DIGR_INT_G0) { 937 void __iomem *reg = fotg210->reg + FOTG210_DISGR0; 938 u32 int_grp0 = ioread32(reg); 939 u32 int_msk0 = ioread32(fotg210->reg + FOTG210_DMISGR0); 940 struct usb_ctrlrequest ctrl; 941 942 int_grp0 &= ~int_msk0; 943 944 /* the highest priority in this source register */ 945 if (int_grp0 & DISGR0_CX_COMABT_INT) { 946 fotg210_ack_int(fotg210, FOTG210_DISGR0, DISGR0_CX_COMABT_INT); 947 pr_info("fotg210 CX command abort\n"); 948 } 949 950 if (int_grp0 & DISGR0_CX_SETUP_INT) { 951 if (fotg210_setup_packet(fotg210, &ctrl)) { 952 spin_unlock(&fotg210->lock); 953 if (fotg210->driver->setup(&fotg210->gadget, 954 &ctrl) < 0) 955 fotg210_set_cxstall(fotg210); 956 spin_lock(&fotg210->lock); 957 } 958 } 959 if (int_grp0 & DISGR0_CX_COMEND_INT) 960 pr_info("fotg210 cmd end\n"); 961 962 if (int_grp0 & DISGR0_CX_IN_INT) 963 fotg210_ep0in(fotg210); 964 965 if (int_grp0 & DISGR0_CX_OUT_INT) 966 fotg210_ep0out(fotg210); 967 968 if (int_grp0 & DISGR0_CX_COMFAIL_INT) { 969 fotg210_set_cxstall(fotg210); 970 pr_info("fotg210 ep0 fail\n"); 971 } 972 } 973 974 if (int_grp & DIGR_INT_G1) { 975 void __iomem *reg = fotg210->reg + FOTG210_DISGR1; 976 u32 int_grp1 = ioread32(reg); 977 u32 int_msk1 = ioread32(fotg210->reg + FOTG210_DMISGR1); 978 int fifo; 979 980 int_grp1 &= ~int_msk1; 981 982 for (fifo = 0; fifo < FOTG210_MAX_FIFO_NUM; fifo++) { 983 if (int_grp1 & DISGR1_IN_INT(fifo)) 984 fotg210_in_fifo_handler(fotg210->ep[fifo + 1]); 985 986 if ((int_grp1 & DISGR1_OUT_INT(fifo)) || 987 (int_grp1 & DISGR1_SPK_INT(fifo))) 988 fotg210_out_fifo_handler(fotg210->ep[fifo + 1]); 989 } 990 } 991 992 spin_unlock(&fotg210->lock); 993 994 return IRQ_HANDLED; 995} 996 997static void fotg210_disable_unplug(struct fotg210_udc *fotg210) 998{ 999 u32 reg = ioread32(fotg210->reg + FOTG210_PHYTMSR); 1000 1001 reg &= ~PHYTMSR_UNPLUG; 1002 iowrite32(reg, fotg210->reg + FOTG210_PHYTMSR); 1003} 1004 1005static int fotg210_udc_start(struct usb_gadget *g, 1006 struct usb_gadget_driver *driver) 1007{ 1008 struct fotg210_udc *fotg210 = gadget_to_fotg210(g); 1009 u32 value; 1010 int ret; 1011 1012 /* hook up the driver */ 1013 fotg210->driver = driver; 1014 fotg210->gadget.dev.of_node = fotg210->dev->of_node; 1015 fotg210->gadget.speed = USB_SPEED_UNKNOWN; 1016 1017 dev_info(fotg210->dev, "bound driver %s\n", driver->driver.name); 1018 1019 if (!IS_ERR_OR_NULL(fotg210->phy)) { 1020 ret = otg_set_peripheral(fotg210->phy->otg, 1021 &fotg210->gadget); 1022 if (ret) 1023 dev_err(fotg210->dev, "can't bind to phy\n"); 1024 } 1025 1026 /* chip enable */ 1027 value = ioread32(fotg210->reg + FOTG210_DMCR); 1028 value |= DMCR_CHIP_EN; 1029 iowrite32(value, fotg210->reg + FOTG210_DMCR); 1030 1031 /* enable device global interrupt */ 1032 value = ioread32(fotg210->reg + FOTG210_DMCR); 1033 value |= DMCR_GLINT_EN; 1034 iowrite32(value, fotg210->reg + FOTG210_DMCR); 1035 1036 return 0; 1037} 1038 1039static void fotg210_init(struct fotg210_udc *fotg210) 1040{ 1041 u32 value; 1042 1043 /* disable global interrupt and set int polarity to active high */ 1044 iowrite32(GMIR_MHC_INT | GMIR_MOTG_INT | GMIR_INT_POLARITY, 1045 fotg210->reg + FOTG210_GMIR); 1046 1047 /* mask interrupts for groups other than 0-2 */ 1048 iowrite32(~(DMIGR_MINT_G0 | DMIGR_MINT_G1 | DMIGR_MINT_G2), 1049 fotg210->reg + FOTG210_DMIGR); 1050 1051 /* udc software reset */ 1052 iowrite32(DMCR_SFRST, fotg210->reg + FOTG210_DMCR); 1053 /* Better wait a bit, but without a datasheet, no idea how long. */ 1054 usleep_range(100, 200); 1055 1056 /* disable device global interrupt */ 1057 value = ioread32(fotg210->reg + FOTG210_DMCR); 1058 value &= ~DMCR_GLINT_EN; 1059 iowrite32(value, fotg210->reg + FOTG210_DMCR); 1060 1061 /* enable only grp2 irqs we handle */ 1062 iowrite32(~(DISGR2_DMA_ERROR | DISGR2_RX0BYTE_INT | DISGR2_TX0BYTE_INT 1063 | DISGR2_ISO_SEQ_ABORT_INT | DISGR2_ISO_SEQ_ERR_INT 1064 | DISGR2_RESM_INT | DISGR2_SUSP_INT | DISGR2_USBRST_INT), 1065 fotg210->reg + FOTG210_DMISGR2); 1066 1067 /* disable all fifo interrupt */ 1068 iowrite32(~(u32)0, fotg210->reg + FOTG210_DMISGR1); 1069 1070 /* disable cmd end */ 1071 value = ioread32(fotg210->reg + FOTG210_DMISGR0); 1072 value |= DMISGR0_MCX_COMEND; 1073 iowrite32(value, fotg210->reg + FOTG210_DMISGR0); 1074} 1075 1076static int fotg210_udc_stop(struct usb_gadget *g) 1077{ 1078 struct fotg210_udc *fotg210 = gadget_to_fotg210(g); 1079 unsigned long flags; 1080 1081 if (!IS_ERR_OR_NULL(fotg210->phy)) 1082 return otg_set_peripheral(fotg210->phy->otg, NULL); 1083 1084 spin_lock_irqsave(&fotg210->lock, flags); 1085 1086 fotg210_init(fotg210); 1087 fotg210->driver = NULL; 1088 fotg210->gadget.speed = USB_SPEED_UNKNOWN; 1089 1090 spin_unlock_irqrestore(&fotg210->lock, flags); 1091 1092 return 0; 1093} 1094 1095/** 1096 * fotg210_vbus_session - Called by external transceiver to enable/disable udc 1097 * @g: usb gadget 1098 * @is_active: 0 if should disable UDC VBUS, 1 if should enable 1099 * 1100 * Returns: %0 1101 */ 1102static int fotg210_vbus_session(struct usb_gadget *g, int is_active) 1103{ 1104 struct fotg210_udc *fotg210 = gadget_to_fotg210(g); 1105 1106 /* Call down to core integration layer to drive or disable VBUS */ 1107 fotg210_vbus(fotg210->fotg, is_active); 1108 return 0; 1109} 1110 1111static const struct usb_gadget_ops fotg210_gadget_ops = { 1112 .udc_start = fotg210_udc_start, 1113 .udc_stop = fotg210_udc_stop, 1114 .vbus_session = fotg210_vbus_session, 1115}; 1116 1117/** 1118 * fotg210_phy_event - Called by phy upon VBus event 1119 * @nb: notifier block 1120 * @action: phy action, is vbus connect or disconnect 1121 * @data: the usb_gadget structure in fotg210 1122 * 1123 * Called by the USB Phy when a cable connect or disconnect is sensed. 1124 * 1125 * Returns: NOTIFY_OK or NOTIFY_DONE 1126 */ 1127static int fotg210_phy_event(struct notifier_block *nb, unsigned long action, 1128 void *data) 1129{ 1130 struct usb_gadget *gadget = data; 1131 1132 if (!gadget) 1133 return NOTIFY_DONE; 1134 1135 switch (action) { 1136 case USB_EVENT_VBUS: 1137 usb_gadget_vbus_connect(gadget); 1138 return NOTIFY_OK; 1139 case USB_EVENT_NONE: 1140 usb_gadget_vbus_disconnect(gadget); 1141 return NOTIFY_OK; 1142 default: 1143 return NOTIFY_DONE; 1144 } 1145} 1146 1147static struct notifier_block fotg210_phy_notifier = { 1148 .notifier_call = fotg210_phy_event, 1149}; 1150 1151int fotg210_udc_remove(struct platform_device *pdev) 1152{ 1153 struct fotg210_udc *fotg210 = platform_get_drvdata(pdev); 1154 int i; 1155 1156 usb_del_gadget_udc(&fotg210->gadget); 1157 if (!IS_ERR_OR_NULL(fotg210->phy)) { 1158 usb_unregister_notifier(fotg210->phy, &fotg210_phy_notifier); 1159 usb_put_phy(fotg210->phy); 1160 } 1161 iounmap(fotg210->reg); 1162 free_irq(platform_get_irq(pdev, 0), fotg210); 1163 1164 fotg210_ep_free_request(&fotg210->ep[0]->ep, fotg210->ep0_req); 1165 for (i = 0; i < FOTG210_MAX_NUM_EP; i++) 1166 kfree(fotg210->ep[i]); 1167 1168 kfree(fotg210); 1169 1170 return 0; 1171} 1172 1173int fotg210_udc_probe(struct platform_device *pdev, struct fotg210 *fotg) 1174{ 1175 struct fotg210_udc *fotg210 = NULL; 1176 struct device *dev = &pdev->dev; 1177 int irq; 1178 int ret = 0; 1179 int i; 1180 1181 irq = platform_get_irq(pdev, 0); 1182 if (irq < 0) 1183 return irq; 1184 1185 /* initialize udc */ 1186 fotg210 = kzalloc(sizeof(struct fotg210_udc), GFP_KERNEL); 1187 if (fotg210 == NULL) 1188 return -ENOMEM; 1189 1190 fotg210->dev = dev; 1191 fotg210->fotg = fotg; 1192 1193 fotg210->phy = devm_usb_get_phy_by_phandle(dev, "usb-phy", 0); 1194 if (IS_ERR(fotg210->phy)) { 1195 ret = PTR_ERR(fotg210->phy); 1196 if (ret == -EPROBE_DEFER) 1197 goto err_free; 1198 dev_info(dev, "no PHY found\n"); 1199 fotg210->phy = NULL; 1200 } else { 1201 ret = usb_phy_init(fotg210->phy); 1202 if (ret) 1203 goto err_free; 1204 dev_info(dev, "found and initialized PHY\n"); 1205 } 1206 1207 ret = -ENOMEM; 1208 1209 for (i = 0; i < FOTG210_MAX_NUM_EP; i++) { 1210 fotg210->ep[i] = kzalloc(sizeof(struct fotg210_ep), GFP_KERNEL); 1211 if (!fotg210->ep[i]) 1212 goto err_alloc; 1213 } 1214 1215 fotg210->reg = fotg->base; 1216 1217 spin_lock_init(&fotg210->lock); 1218 1219 platform_set_drvdata(pdev, fotg210); 1220 1221 fotg210->gadget.ops = &fotg210_gadget_ops; 1222 1223 fotg210->gadget.max_speed = USB_SPEED_HIGH; 1224 fotg210->gadget.dev.parent = dev; 1225 fotg210->gadget.dev.dma_mask = dev->dma_mask; 1226 fotg210->gadget.name = udc_name; 1227 1228 INIT_LIST_HEAD(&fotg210->gadget.ep_list); 1229 1230 for (i = 0; i < FOTG210_MAX_NUM_EP; i++) { 1231 struct fotg210_ep *ep = fotg210->ep[i]; 1232 1233 if (i) { 1234 INIT_LIST_HEAD(&fotg210->ep[i]->ep.ep_list); 1235 list_add_tail(&fotg210->ep[i]->ep.ep_list, 1236 &fotg210->gadget.ep_list); 1237 } 1238 ep->fotg210 = fotg210; 1239 INIT_LIST_HEAD(&ep->queue); 1240 ep->ep.name = fotg210_ep_name[i]; 1241 ep->ep.ops = &fotg210_ep_ops; 1242 usb_ep_set_maxpacket_limit(&ep->ep, (unsigned short) ~0); 1243 1244 if (i == 0) { 1245 ep->ep.caps.type_control = true; 1246 } else { 1247 ep->ep.caps.type_iso = true; 1248 ep->ep.caps.type_bulk = true; 1249 ep->ep.caps.type_int = true; 1250 } 1251 1252 ep->ep.caps.dir_in = true; 1253 ep->ep.caps.dir_out = true; 1254 } 1255 usb_ep_set_maxpacket_limit(&fotg210->ep[0]->ep, 0x40); 1256 fotg210->gadget.ep0 = &fotg210->ep[0]->ep; 1257 INIT_LIST_HEAD(&fotg210->gadget.ep0->ep_list); 1258 1259 fotg210->ep0_req = fotg210_ep_alloc_request(&fotg210->ep[0]->ep, 1260 GFP_KERNEL); 1261 if (fotg210->ep0_req == NULL) 1262 goto err_map; 1263 1264 fotg210->ep0_req->complete = fotg210_ep0_complete; 1265 1266 fotg210_init(fotg210); 1267 1268 fotg210_disable_unplug(fotg210); 1269 1270 ret = request_irq(irq, fotg210_irq, IRQF_SHARED, 1271 udc_name, fotg210); 1272 if (ret < 0) { 1273 dev_err_probe(dev, ret, "request_irq error\n"); 1274 goto err_req; 1275 } 1276 1277 if (!IS_ERR_OR_NULL(fotg210->phy)) 1278 usb_register_notifier(fotg210->phy, &fotg210_phy_notifier); 1279 1280 ret = usb_add_gadget_udc(dev, &fotg210->gadget); 1281 if (ret) 1282 goto err_add_udc; 1283 1284 dev_info(dev, "version %s\n", DRIVER_VERSION); 1285 1286 return 0; 1287 1288err_add_udc: 1289 if (!IS_ERR_OR_NULL(fotg210->phy)) 1290 usb_unregister_notifier(fotg210->phy, &fotg210_phy_notifier); 1291 free_irq(irq, fotg210); 1292 1293err_req: 1294 fotg210_ep_free_request(&fotg210->ep[0]->ep, fotg210->ep0_req); 1295 1296err_map: 1297 iounmap(fotg210->reg); 1298 1299err_alloc: 1300 for (i = 0; i < FOTG210_MAX_NUM_EP; i++) 1301 kfree(fotg210->ep[i]); 1302 1303err_free: 1304 kfree(fotg210); 1305 return ret; 1306} 1307