1 /* 2 * Renesas USB driver 3 * 4 * Copyright (C) 2011 Renesas Solutions Corp. 5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software 14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 15 * 16 */ 17 #include <linux/delay.h> 18 #include <linux/dma-mapping.h> 19 #include <linux/io.h> 20 #include <linux/module.h> 21 #include <linux/platform_device.h> 22 #include <linux/usb/ch9.h> 23 #include <linux/usb/gadget.h> 24 #include <linux/usb/otg.h> 25 #include "common.h" 26 27 /* 28 * struct 29 */ 30 struct usbhsg_request { 31 struct usb_request req; 32 struct usbhs_pkt pkt; 33 }; 34 35 #define EP_NAME_SIZE 8 36 struct usbhsg_gpriv; 37 struct usbhsg_uep { 38 struct usb_ep ep; 39 struct usbhs_pipe *pipe; 40 41 char ep_name[EP_NAME_SIZE]; 42 43 struct usbhsg_gpriv *gpriv; 44 }; 45 46 struct usbhsg_gpriv { 47 struct usb_gadget gadget; 48 struct usbhs_mod mod; 49 50 struct usbhsg_uep *uep; 51 int uep_size; 52 53 struct usb_gadget_driver *driver; 54 struct usb_phy *transceiver; 55 bool vbus_active; 56 57 u32 status; 58 #define USBHSG_STATUS_STARTED (1 << 0) 59 #define USBHSG_STATUS_REGISTERD (1 << 1) 60 #define USBHSG_STATUS_WEDGE (1 << 2) 61 #define USBHSG_STATUS_SELF_POWERED (1 << 3) 62 #define USBHSG_STATUS_SOFT_CONNECT (1 << 4) 63 }; 64 65 struct usbhsg_recip_handle { 66 char *name; 67 int (*device)(struct usbhs_priv *priv, struct usbhsg_uep *uep, 68 struct usb_ctrlrequest *ctrl); 69 int (*interface)(struct usbhs_priv *priv, struct usbhsg_uep *uep, 70 struct usb_ctrlrequest *ctrl); 71 int (*endpoint)(struct usbhs_priv *priv, struct usbhsg_uep *uep, 72 struct usb_ctrlrequest *ctrl); 73 }; 74 75 /* 76 * macro 77 */ 78 #define usbhsg_priv_to_gpriv(priv) \ 79 container_of( \ 80 usbhs_mod_get(priv, USBHS_GADGET), \ 81 struct usbhsg_gpriv, mod) 82 83 #define __usbhsg_for_each_uep(start, pos, g, i) \ 84 for ((i) = start; \ 85 ((i) < (g)->uep_size) && ((pos) = (g)->uep + (i)); \ 86 (i)++) 87 88 #define usbhsg_for_each_uep(pos, gpriv, i) \ 89 __usbhsg_for_each_uep(1, pos, gpriv, i) 90 91 #define usbhsg_for_each_uep_with_dcp(pos, gpriv, i) \ 92 __usbhsg_for_each_uep(0, pos, gpriv, i) 93 94 #define usbhsg_gadget_to_gpriv(g)\ 95 container_of(g, struct usbhsg_gpriv, gadget) 96 97 #define usbhsg_req_to_ureq(r)\ 98 container_of(r, struct usbhsg_request, req) 99 100 #define usbhsg_ep_to_uep(e) container_of(e, struct usbhsg_uep, ep) 101 #define usbhsg_gpriv_to_dev(gp) usbhs_priv_to_dev((gp)->mod.priv) 102 #define usbhsg_gpriv_to_priv(gp) ((gp)->mod.priv) 103 #define usbhsg_gpriv_to_dcp(gp) ((gp)->uep) 104 #define usbhsg_gpriv_to_nth_uep(gp, i) ((gp)->uep + i) 105 #define usbhsg_uep_to_gpriv(u) ((u)->gpriv) 106 #define usbhsg_uep_to_pipe(u) ((u)->pipe) 107 #define usbhsg_pipe_to_uep(p) ((p)->mod_private) 108 #define usbhsg_is_dcp(u) ((u) == usbhsg_gpriv_to_dcp((u)->gpriv)) 109 110 #define usbhsg_ureq_to_pkt(u) (&(u)->pkt) 111 #define usbhsg_pkt_to_ureq(i) \ 112 container_of(i, struct usbhsg_request, pkt) 113 114 #define usbhsg_is_not_connected(gp) ((gp)->gadget.speed == USB_SPEED_UNKNOWN) 115 116 /* status */ 117 #define usbhsg_status_init(gp) do {(gp)->status = 0; } while (0) 118 #define usbhsg_status_set(gp, b) (gp->status |= b) 119 #define usbhsg_status_clr(gp, b) (gp->status &= ~b) 120 #define usbhsg_status_has(gp, b) (gp->status & b) 121 122 /* 123 * queue push/pop 124 */ 125 static void __usbhsg_queue_pop(struct usbhsg_uep *uep, 126 struct usbhsg_request *ureq, 127 int status) 128 { 129 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep); 130 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep); 131 struct device *dev = usbhsg_gpriv_to_dev(gpriv); 132 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv); 133 134 if (pipe) 135 dev_dbg(dev, "pipe %d : queue pop\n", usbhs_pipe_number(pipe)); 136 137 ureq->req.status = status; 138 spin_unlock(usbhs_priv_to_lock(priv)); 139 usb_gadget_giveback_request(&uep->ep, &ureq->req); 140 spin_lock(usbhs_priv_to_lock(priv)); 141 } 142 143 static void usbhsg_queue_pop(struct usbhsg_uep *uep, 144 struct usbhsg_request *ureq, 145 int status) 146 { 147 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep); 148 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv); 149 unsigned long flags; 150 151 usbhs_lock(priv, flags); 152 __usbhsg_queue_pop(uep, ureq, status); 153 usbhs_unlock(priv, flags); 154 } 155 156 static void usbhsg_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt) 157 { 158 struct usbhs_pipe *pipe = pkt->pipe; 159 struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe); 160 struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt); 161 unsigned long flags; 162 163 ureq->req.actual = pkt->actual; 164 165 usbhs_lock(priv, flags); 166 if (uep) 167 __usbhsg_queue_pop(uep, ureq, 0); 168 usbhs_unlock(priv, flags); 169 } 170 171 static void usbhsg_queue_push(struct usbhsg_uep *uep, 172 struct usbhsg_request *ureq) 173 { 174 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep); 175 struct device *dev = usbhsg_gpriv_to_dev(gpriv); 176 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep); 177 struct usbhs_pkt *pkt = usbhsg_ureq_to_pkt(ureq); 178 struct usb_request *req = &ureq->req; 179 180 req->actual = 0; 181 req->status = -EINPROGRESS; 182 usbhs_pkt_push(pipe, pkt, usbhsg_queue_done, 183 req->buf, req->length, req->zero, -1); 184 usbhs_pkt_start(pipe); 185 186 dev_dbg(dev, "pipe %d : queue push (%d)\n", 187 usbhs_pipe_number(pipe), 188 req->length); 189 } 190 191 /* 192 * dma map/unmap 193 */ 194 static int usbhsg_dma_map_ctrl(struct device *dma_dev, struct usbhs_pkt *pkt, 195 int map) 196 { 197 struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt); 198 struct usb_request *req = &ureq->req; 199 struct usbhs_pipe *pipe = pkt->pipe; 200 enum dma_data_direction dir; 201 int ret = 0; 202 203 dir = usbhs_pipe_is_dir_host(pipe); 204 205 if (map) { 206 /* it can not use scatter/gather */ 207 WARN_ON(req->num_sgs); 208 209 ret = usb_gadget_map_request_by_dev(dma_dev, req, dir); 210 if (ret < 0) 211 return ret; 212 213 pkt->dma = req->dma; 214 } else { 215 usb_gadget_unmap_request_by_dev(dma_dev, req, dir); 216 } 217 218 return ret; 219 } 220 221 /* 222 * USB_TYPE_STANDARD / clear feature functions 223 */ 224 static int usbhsg_recip_handler_std_control_done(struct usbhs_priv *priv, 225 struct usbhsg_uep *uep, 226 struct usb_ctrlrequest *ctrl) 227 { 228 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv); 229 struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv); 230 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp); 231 232 usbhs_dcp_control_transfer_done(pipe); 233 234 return 0; 235 } 236 237 static int usbhsg_recip_handler_std_clear_endpoint(struct usbhs_priv *priv, 238 struct usbhsg_uep *uep, 239 struct usb_ctrlrequest *ctrl) 240 { 241 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep); 242 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep); 243 244 if (!usbhsg_status_has(gpriv, USBHSG_STATUS_WEDGE)) { 245 usbhs_pipe_disable(pipe); 246 usbhs_pipe_sequence_data0(pipe); 247 usbhs_pipe_enable(pipe); 248 } 249 250 usbhsg_recip_handler_std_control_done(priv, uep, ctrl); 251 252 usbhs_pkt_start(pipe); 253 254 return 0; 255 } 256 257 static struct usbhsg_recip_handle req_clear_feature = { 258 .name = "clear feature", 259 .device = usbhsg_recip_handler_std_control_done, 260 .interface = usbhsg_recip_handler_std_control_done, 261 .endpoint = usbhsg_recip_handler_std_clear_endpoint, 262 }; 263 264 /* 265 * USB_TYPE_STANDARD / set feature functions 266 */ 267 static int usbhsg_recip_handler_std_set_device(struct usbhs_priv *priv, 268 struct usbhsg_uep *uep, 269 struct usb_ctrlrequest *ctrl) 270 { 271 switch (le16_to_cpu(ctrl->wValue)) { 272 case USB_DEVICE_TEST_MODE: 273 usbhsg_recip_handler_std_control_done(priv, uep, ctrl); 274 udelay(100); 275 usbhs_sys_set_test_mode(priv, le16_to_cpu(ctrl->wIndex >> 8)); 276 break; 277 default: 278 usbhsg_recip_handler_std_control_done(priv, uep, ctrl); 279 break; 280 } 281 282 return 0; 283 } 284 285 static int usbhsg_recip_handler_std_set_endpoint(struct usbhs_priv *priv, 286 struct usbhsg_uep *uep, 287 struct usb_ctrlrequest *ctrl) 288 { 289 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep); 290 291 usbhs_pipe_stall(pipe); 292 293 usbhsg_recip_handler_std_control_done(priv, uep, ctrl); 294 295 return 0; 296 } 297 298 static struct usbhsg_recip_handle req_set_feature = { 299 .name = "set feature", 300 .device = usbhsg_recip_handler_std_set_device, 301 .interface = usbhsg_recip_handler_std_control_done, 302 .endpoint = usbhsg_recip_handler_std_set_endpoint, 303 }; 304 305 /* 306 * USB_TYPE_STANDARD / get status functions 307 */ 308 static void __usbhsg_recip_send_complete(struct usb_ep *ep, 309 struct usb_request *req) 310 { 311 struct usbhsg_request *ureq = usbhsg_req_to_ureq(req); 312 313 /* free allocated recip-buffer/usb_request */ 314 kfree(ureq->pkt.buf); 315 usb_ep_free_request(ep, req); 316 } 317 318 static void __usbhsg_recip_send_status(struct usbhsg_gpriv *gpriv, 319 unsigned short status) 320 { 321 struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv); 322 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp); 323 struct device *dev = usbhsg_gpriv_to_dev(gpriv); 324 struct usb_request *req; 325 unsigned short *buf; 326 327 /* alloc new usb_request for recip */ 328 req = usb_ep_alloc_request(&dcp->ep, GFP_ATOMIC); 329 if (!req) { 330 dev_err(dev, "recip request allocation fail\n"); 331 return; 332 } 333 334 /* alloc recip data buffer */ 335 buf = kmalloc(sizeof(*buf), GFP_ATOMIC); 336 if (!buf) { 337 usb_ep_free_request(&dcp->ep, req); 338 return; 339 } 340 341 /* recip data is status */ 342 *buf = cpu_to_le16(status); 343 344 /* allocated usb_request/buffer will be freed */ 345 req->complete = __usbhsg_recip_send_complete; 346 req->buf = buf; 347 req->length = sizeof(*buf); 348 req->zero = 0; 349 350 /* push packet */ 351 pipe->handler = &usbhs_fifo_pio_push_handler; 352 usbhsg_queue_push(dcp, usbhsg_req_to_ureq(req)); 353 } 354 355 static int usbhsg_recip_handler_std_get_device(struct usbhs_priv *priv, 356 struct usbhsg_uep *uep, 357 struct usb_ctrlrequest *ctrl) 358 { 359 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep); 360 unsigned short status = 0; 361 362 if (usbhsg_status_has(gpriv, USBHSG_STATUS_SELF_POWERED)) 363 status = 1 << USB_DEVICE_SELF_POWERED; 364 365 __usbhsg_recip_send_status(gpriv, status); 366 367 return 0; 368 } 369 370 static int usbhsg_recip_handler_std_get_interface(struct usbhs_priv *priv, 371 struct usbhsg_uep *uep, 372 struct usb_ctrlrequest *ctrl) 373 { 374 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep); 375 unsigned short status = 0; 376 377 __usbhsg_recip_send_status(gpriv, status); 378 379 return 0; 380 } 381 382 static int usbhsg_recip_handler_std_get_endpoint(struct usbhs_priv *priv, 383 struct usbhsg_uep *uep, 384 struct usb_ctrlrequest *ctrl) 385 { 386 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep); 387 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep); 388 unsigned short status = 0; 389 390 if (usbhs_pipe_is_stall(pipe)) 391 status = 1 << USB_ENDPOINT_HALT; 392 393 __usbhsg_recip_send_status(gpriv, status); 394 395 return 0; 396 } 397 398 static struct usbhsg_recip_handle req_get_status = { 399 .name = "get status", 400 .device = usbhsg_recip_handler_std_get_device, 401 .interface = usbhsg_recip_handler_std_get_interface, 402 .endpoint = usbhsg_recip_handler_std_get_endpoint, 403 }; 404 405 /* 406 * USB_TYPE handler 407 */ 408 static int usbhsg_recip_run_handle(struct usbhs_priv *priv, 409 struct usbhsg_recip_handle *handler, 410 struct usb_ctrlrequest *ctrl) 411 { 412 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv); 413 struct device *dev = usbhsg_gpriv_to_dev(gpriv); 414 struct usbhsg_uep *uep; 415 struct usbhs_pipe *pipe; 416 int recip = ctrl->bRequestType & USB_RECIP_MASK; 417 int nth = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK; 418 int ret = 0; 419 int (*func)(struct usbhs_priv *priv, struct usbhsg_uep *uep, 420 struct usb_ctrlrequest *ctrl); 421 char *msg; 422 423 uep = usbhsg_gpriv_to_nth_uep(gpriv, nth); 424 pipe = usbhsg_uep_to_pipe(uep); 425 if (!pipe) { 426 dev_err(dev, "wrong recip request\n"); 427 return -EINVAL; 428 } 429 430 switch (recip) { 431 case USB_RECIP_DEVICE: 432 msg = "DEVICE"; 433 func = handler->device; 434 break; 435 case USB_RECIP_INTERFACE: 436 msg = "INTERFACE"; 437 func = handler->interface; 438 break; 439 case USB_RECIP_ENDPOINT: 440 msg = "ENDPOINT"; 441 func = handler->endpoint; 442 break; 443 default: 444 dev_warn(dev, "unsupported RECIP(%d)\n", recip); 445 func = NULL; 446 ret = -EINVAL; 447 } 448 449 if (func) { 450 dev_dbg(dev, "%s (pipe %d :%s)\n", handler->name, nth, msg); 451 ret = func(priv, uep, ctrl); 452 } 453 454 return ret; 455 } 456 457 /* 458 * irq functions 459 * 460 * it will be called from usbhs_interrupt 461 */ 462 static int usbhsg_irq_dev_state(struct usbhs_priv *priv, 463 struct usbhs_irq_state *irq_state) 464 { 465 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv); 466 struct device *dev = usbhsg_gpriv_to_dev(gpriv); 467 468 gpriv->gadget.speed = usbhs_bus_get_speed(priv); 469 470 dev_dbg(dev, "state = %x : speed : %d\n", 471 usbhs_status_get_device_state(irq_state), 472 gpriv->gadget.speed); 473 474 return 0; 475 } 476 477 static int usbhsg_irq_ctrl_stage(struct usbhs_priv *priv, 478 struct usbhs_irq_state *irq_state) 479 { 480 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv); 481 struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv); 482 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(dcp); 483 struct device *dev = usbhsg_gpriv_to_dev(gpriv); 484 struct usb_ctrlrequest ctrl; 485 struct usbhsg_recip_handle *recip_handler = NULL; 486 int stage = usbhs_status_get_ctrl_stage(irq_state); 487 int ret = 0; 488 489 dev_dbg(dev, "stage = %d\n", stage); 490 491 /* 492 * see Manual 493 * 494 * "Operation" 495 * - "Interrupt Function" 496 * - "Control Transfer Stage Transition Interrupt" 497 * - Fig. "Control Transfer Stage Transitions" 498 */ 499 500 switch (stage) { 501 case READ_DATA_STAGE: 502 pipe->handler = &usbhs_fifo_pio_push_handler; 503 break; 504 case WRITE_DATA_STAGE: 505 pipe->handler = &usbhs_fifo_pio_pop_handler; 506 break; 507 case NODATA_STATUS_STAGE: 508 pipe->handler = &usbhs_ctrl_stage_end_handler; 509 break; 510 case READ_STATUS_STAGE: 511 case WRITE_STATUS_STAGE: 512 usbhs_dcp_control_transfer_done(pipe); 513 default: 514 return ret; 515 } 516 517 /* 518 * get usb request 519 */ 520 usbhs_usbreq_get_val(priv, &ctrl); 521 522 switch (ctrl.bRequestType & USB_TYPE_MASK) { 523 case USB_TYPE_STANDARD: 524 switch (ctrl.bRequest) { 525 case USB_REQ_CLEAR_FEATURE: 526 recip_handler = &req_clear_feature; 527 break; 528 case USB_REQ_SET_FEATURE: 529 recip_handler = &req_set_feature; 530 break; 531 case USB_REQ_GET_STATUS: 532 recip_handler = &req_get_status; 533 break; 534 } 535 } 536 537 /* 538 * setup stage / run recip 539 */ 540 if (recip_handler) 541 ret = usbhsg_recip_run_handle(priv, recip_handler, &ctrl); 542 else 543 ret = gpriv->driver->setup(&gpriv->gadget, &ctrl); 544 545 if (ret < 0) 546 usbhs_pipe_stall(pipe); 547 548 return ret; 549 } 550 551 /* 552 * 553 * usb_dcp_ops 554 * 555 */ 556 static int usbhsg_pipe_disable(struct usbhsg_uep *uep) 557 { 558 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep); 559 struct usbhs_pkt *pkt; 560 561 while (1) { 562 pkt = usbhs_pkt_pop(pipe, NULL); 563 if (!pkt) 564 break; 565 566 usbhsg_queue_pop(uep, usbhsg_pkt_to_ureq(pkt), -ESHUTDOWN); 567 } 568 569 usbhs_pipe_disable(pipe); 570 571 return 0; 572 } 573 574 /* 575 * 576 * usb_ep_ops 577 * 578 */ 579 static int usbhsg_ep_enable(struct usb_ep *ep, 580 const struct usb_endpoint_descriptor *desc) 581 { 582 struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep); 583 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep); 584 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv); 585 struct usbhs_pipe *pipe; 586 int ret = -EIO; 587 unsigned long flags; 588 589 usbhs_lock(priv, flags); 590 591 /* 592 * if it already have pipe, 593 * nothing to do 594 */ 595 if (uep->pipe) { 596 usbhs_pipe_clear(uep->pipe); 597 usbhs_pipe_sequence_data0(uep->pipe); 598 ret = 0; 599 goto usbhsg_ep_enable_end; 600 } 601 602 pipe = usbhs_pipe_malloc(priv, 603 usb_endpoint_type(desc), 604 usb_endpoint_dir_in(desc)); 605 if (pipe) { 606 uep->pipe = pipe; 607 pipe->mod_private = uep; 608 609 /* set epnum / maxp */ 610 usbhs_pipe_config_update(pipe, 0, 611 usb_endpoint_num(desc), 612 usb_endpoint_maxp(desc)); 613 614 /* 615 * usbhs_fifo_dma_push/pop_handler try to 616 * use dmaengine if possible. 617 * It will use pio handler if impossible. 618 */ 619 if (usb_endpoint_dir_in(desc)) { 620 pipe->handler = &usbhs_fifo_dma_push_handler; 621 } else { 622 pipe->handler = &usbhs_fifo_dma_pop_handler; 623 usbhs_xxxsts_clear(priv, BRDYSTS, 624 usbhs_pipe_number(pipe)); 625 } 626 627 ret = 0; 628 } 629 630 usbhsg_ep_enable_end: 631 usbhs_unlock(priv, flags); 632 633 return ret; 634 } 635 636 static int usbhsg_ep_disable(struct usb_ep *ep) 637 { 638 struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep); 639 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep); 640 641 if (!pipe) 642 return -EINVAL; 643 644 usbhsg_pipe_disable(uep); 645 usbhs_pipe_free(pipe); 646 647 uep->pipe->mod_private = NULL; 648 uep->pipe = NULL; 649 650 return 0; 651 } 652 653 static struct usb_request *usbhsg_ep_alloc_request(struct usb_ep *ep, 654 gfp_t gfp_flags) 655 { 656 struct usbhsg_request *ureq; 657 658 ureq = kzalloc(sizeof *ureq, gfp_flags); 659 if (!ureq) 660 return NULL; 661 662 usbhs_pkt_init(usbhsg_ureq_to_pkt(ureq)); 663 664 return &ureq->req; 665 } 666 667 static void usbhsg_ep_free_request(struct usb_ep *ep, 668 struct usb_request *req) 669 { 670 struct usbhsg_request *ureq = usbhsg_req_to_ureq(req); 671 672 WARN_ON(!list_empty(&ureq->pkt.node)); 673 kfree(ureq); 674 } 675 676 static int usbhsg_ep_queue(struct usb_ep *ep, struct usb_request *req, 677 gfp_t gfp_flags) 678 { 679 struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep); 680 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep); 681 struct usbhsg_request *ureq = usbhsg_req_to_ureq(req); 682 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep); 683 684 /* param check */ 685 if (usbhsg_is_not_connected(gpriv) || 686 unlikely(!gpriv->driver) || 687 unlikely(!pipe)) 688 return -ESHUTDOWN; 689 690 usbhsg_queue_push(uep, ureq); 691 692 return 0; 693 } 694 695 static int usbhsg_ep_dequeue(struct usb_ep *ep, struct usb_request *req) 696 { 697 struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep); 698 struct usbhsg_request *ureq = usbhsg_req_to_ureq(req); 699 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep); 700 701 if (pipe) 702 usbhs_pkt_pop(pipe, usbhsg_ureq_to_pkt(ureq)); 703 704 /* 705 * To dequeue a request, this driver should call the usbhsg_queue_pop() 706 * even if the pipe is NULL. 707 */ 708 usbhsg_queue_pop(uep, ureq, -ECONNRESET); 709 710 return 0; 711 } 712 713 static int __usbhsg_ep_set_halt_wedge(struct usb_ep *ep, int halt, int wedge) 714 { 715 struct usbhsg_uep *uep = usbhsg_ep_to_uep(ep); 716 struct usbhs_pipe *pipe = usbhsg_uep_to_pipe(uep); 717 struct usbhsg_gpriv *gpriv = usbhsg_uep_to_gpriv(uep); 718 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv); 719 struct device *dev = usbhsg_gpriv_to_dev(gpriv); 720 unsigned long flags; 721 722 usbhsg_pipe_disable(uep); 723 724 dev_dbg(dev, "set halt %d (pipe %d)\n", 725 halt, usbhs_pipe_number(pipe)); 726 727 /******************** spin lock ********************/ 728 usbhs_lock(priv, flags); 729 730 if (halt) 731 usbhs_pipe_stall(pipe); 732 else 733 usbhs_pipe_disable(pipe); 734 735 if (halt && wedge) 736 usbhsg_status_set(gpriv, USBHSG_STATUS_WEDGE); 737 else 738 usbhsg_status_clr(gpriv, USBHSG_STATUS_WEDGE); 739 740 usbhs_unlock(priv, flags); 741 /******************** spin unlock ******************/ 742 743 return 0; 744 } 745 746 static int usbhsg_ep_set_halt(struct usb_ep *ep, int value) 747 { 748 return __usbhsg_ep_set_halt_wedge(ep, value, 0); 749 } 750 751 static int usbhsg_ep_set_wedge(struct usb_ep *ep) 752 { 753 return __usbhsg_ep_set_halt_wedge(ep, 1, 1); 754 } 755 756 static struct usb_ep_ops usbhsg_ep_ops = { 757 .enable = usbhsg_ep_enable, 758 .disable = usbhsg_ep_disable, 759 760 .alloc_request = usbhsg_ep_alloc_request, 761 .free_request = usbhsg_ep_free_request, 762 763 .queue = usbhsg_ep_queue, 764 .dequeue = usbhsg_ep_dequeue, 765 766 .set_halt = usbhsg_ep_set_halt, 767 .set_wedge = usbhsg_ep_set_wedge, 768 }; 769 770 /* 771 * pullup control 772 */ 773 static int usbhsg_can_pullup(struct usbhs_priv *priv) 774 { 775 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv); 776 777 return gpriv->driver && 778 usbhsg_status_has(gpriv, USBHSG_STATUS_SOFT_CONNECT); 779 } 780 781 static void usbhsg_update_pullup(struct usbhs_priv *priv) 782 { 783 if (usbhsg_can_pullup(priv)) 784 usbhs_sys_function_pullup(priv, 1); 785 else 786 usbhs_sys_function_pullup(priv, 0); 787 } 788 789 /* 790 * usb module start/end 791 */ 792 static int usbhsg_try_start(struct usbhs_priv *priv, u32 status) 793 { 794 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv); 795 struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv); 796 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 797 struct device *dev = usbhs_priv_to_dev(priv); 798 unsigned long flags; 799 int ret = 0; 800 801 /******************** spin lock ********************/ 802 usbhs_lock(priv, flags); 803 804 usbhsg_status_set(gpriv, status); 805 if (!(usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) && 806 usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD))) 807 ret = -1; /* not ready */ 808 809 usbhs_unlock(priv, flags); 810 /******************** spin unlock ********************/ 811 812 if (ret < 0) 813 return 0; /* not ready is not error */ 814 815 /* 816 * enable interrupt and systems if ready 817 */ 818 dev_dbg(dev, "start gadget\n"); 819 820 /* 821 * pipe initialize and enable DCP 822 */ 823 usbhs_fifo_init(priv); 824 usbhs_pipe_init(priv, 825 usbhsg_dma_map_ctrl); 826 827 /* dcp init instead of usbhsg_ep_enable() */ 828 dcp->pipe = usbhs_dcp_malloc(priv); 829 dcp->pipe->mod_private = dcp; 830 usbhs_pipe_config_update(dcp->pipe, 0, 0, 64); 831 832 /* 833 * system config enble 834 * - HI speed 835 * - function 836 * - usb module 837 */ 838 usbhs_sys_function_ctrl(priv, 1); 839 usbhsg_update_pullup(priv); 840 841 /* 842 * enable irq callback 843 */ 844 mod->irq_dev_state = usbhsg_irq_dev_state; 845 mod->irq_ctrl_stage = usbhsg_irq_ctrl_stage; 846 usbhs_irq_callback_update(priv, mod); 847 848 return 0; 849 } 850 851 static int usbhsg_try_stop(struct usbhs_priv *priv, u32 status) 852 { 853 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv); 854 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 855 struct usbhsg_uep *dcp = usbhsg_gpriv_to_dcp(gpriv); 856 struct device *dev = usbhs_priv_to_dev(priv); 857 unsigned long flags; 858 int ret = 0; 859 860 /******************** spin lock ********************/ 861 usbhs_lock(priv, flags); 862 863 usbhsg_status_clr(gpriv, status); 864 if (!usbhsg_status_has(gpriv, USBHSG_STATUS_STARTED) && 865 !usbhsg_status_has(gpriv, USBHSG_STATUS_REGISTERD)) 866 ret = -1; /* already done */ 867 868 usbhs_unlock(priv, flags); 869 /******************** spin unlock ********************/ 870 871 if (ret < 0) 872 return 0; /* already done is not error */ 873 874 /* 875 * disable interrupt and systems if 1st try 876 */ 877 usbhs_fifo_quit(priv); 878 879 /* disable all irq */ 880 mod->irq_dev_state = NULL; 881 mod->irq_ctrl_stage = NULL; 882 usbhs_irq_callback_update(priv, mod); 883 884 gpriv->gadget.speed = USB_SPEED_UNKNOWN; 885 886 /* disable sys */ 887 usbhs_sys_set_test_mode(priv, 0); 888 usbhs_sys_function_ctrl(priv, 0); 889 890 usbhsg_ep_disable(&dcp->ep); 891 892 dev_dbg(dev, "stop gadget\n"); 893 894 return 0; 895 } 896 897 /* 898 * VBUS provided by the PHY 899 */ 900 static int usbhsm_phy_get_vbus(struct platform_device *pdev) 901 { 902 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 903 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv); 904 905 return gpriv->vbus_active; 906 } 907 908 static void usbhs_mod_phy_mode(struct usbhs_priv *priv) 909 { 910 struct usbhs_mod_info *info = &priv->mod_info; 911 912 info->irq_vbus = NULL; 913 priv->pfunc.get_vbus = usbhsm_phy_get_vbus; 914 915 usbhs_irq_callback_update(priv, NULL); 916 } 917 918 /* 919 * 920 * linux usb function 921 * 922 */ 923 static int usbhsg_gadget_start(struct usb_gadget *gadget, 924 struct usb_gadget_driver *driver) 925 { 926 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget); 927 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv); 928 struct device *dev = usbhs_priv_to_dev(priv); 929 int ret; 930 931 if (!driver || 932 !driver->setup || 933 driver->max_speed < USB_SPEED_FULL) 934 return -EINVAL; 935 936 /* connect to bus through transceiver */ 937 if (!IS_ERR_OR_NULL(gpriv->transceiver)) { 938 ret = otg_set_peripheral(gpriv->transceiver->otg, 939 &gpriv->gadget); 940 if (ret) { 941 dev_err(dev, "%s: can't bind to transceiver\n", 942 gpriv->gadget.name); 943 return ret; 944 } 945 946 /* get vbus using phy versions */ 947 usbhs_mod_phy_mode(priv); 948 } 949 950 /* first hook up the driver ... */ 951 gpriv->driver = driver; 952 953 return usbhsg_try_start(priv, USBHSG_STATUS_REGISTERD); 954 } 955 956 static int usbhsg_gadget_stop(struct usb_gadget *gadget) 957 { 958 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget); 959 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv); 960 961 usbhsg_try_stop(priv, USBHSG_STATUS_REGISTERD); 962 963 if (!IS_ERR_OR_NULL(gpriv->transceiver)) 964 otg_set_peripheral(gpriv->transceiver->otg, NULL); 965 966 gpriv->driver = NULL; 967 968 return 0; 969 } 970 971 /* 972 * usb gadget ops 973 */ 974 static int usbhsg_get_frame(struct usb_gadget *gadget) 975 { 976 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget); 977 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv); 978 979 return usbhs_frame_get_num(priv); 980 } 981 982 static int usbhsg_pullup(struct usb_gadget *gadget, int is_on) 983 { 984 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget); 985 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv); 986 unsigned long flags; 987 988 usbhs_lock(priv, flags); 989 if (is_on) 990 usbhsg_status_set(gpriv, USBHSG_STATUS_SOFT_CONNECT); 991 else 992 usbhsg_status_clr(gpriv, USBHSG_STATUS_SOFT_CONNECT); 993 usbhsg_update_pullup(priv); 994 usbhs_unlock(priv, flags); 995 996 return 0; 997 } 998 999 static int usbhsg_set_selfpowered(struct usb_gadget *gadget, int is_self) 1000 { 1001 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget); 1002 1003 if (is_self) 1004 usbhsg_status_set(gpriv, USBHSG_STATUS_SELF_POWERED); 1005 else 1006 usbhsg_status_clr(gpriv, USBHSG_STATUS_SELF_POWERED); 1007 1008 gadget->is_selfpowered = (is_self != 0); 1009 1010 return 0; 1011 } 1012 1013 static int usbhsg_vbus_session(struct usb_gadget *gadget, int is_active) 1014 { 1015 struct usbhsg_gpriv *gpriv = usbhsg_gadget_to_gpriv(gadget); 1016 struct usbhs_priv *priv = usbhsg_gpriv_to_priv(gpriv); 1017 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 1018 1019 gpriv->vbus_active = !!is_active; 1020 1021 renesas_usbhs_call_notify_hotplug(pdev); 1022 1023 return 0; 1024 } 1025 1026 static const struct usb_gadget_ops usbhsg_gadget_ops = { 1027 .get_frame = usbhsg_get_frame, 1028 .set_selfpowered = usbhsg_set_selfpowered, 1029 .udc_start = usbhsg_gadget_start, 1030 .udc_stop = usbhsg_gadget_stop, 1031 .pullup = usbhsg_pullup, 1032 .vbus_session = usbhsg_vbus_session, 1033 }; 1034 1035 static int usbhsg_start(struct usbhs_priv *priv) 1036 { 1037 return usbhsg_try_start(priv, USBHSG_STATUS_STARTED); 1038 } 1039 1040 static int usbhsg_stop(struct usbhs_priv *priv) 1041 { 1042 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv); 1043 1044 /* cable disconnect */ 1045 if (gpriv->driver && 1046 gpriv->driver->disconnect) 1047 gpriv->driver->disconnect(&gpriv->gadget); 1048 1049 return usbhsg_try_stop(priv, USBHSG_STATUS_STARTED); 1050 } 1051 1052 int usbhs_mod_gadget_probe(struct usbhs_priv *priv) 1053 { 1054 struct usbhsg_gpriv *gpriv; 1055 struct usbhsg_uep *uep; 1056 struct device *dev = usbhs_priv_to_dev(priv); 1057 struct renesas_usbhs_driver_pipe_config *pipe_configs = 1058 usbhs_get_dparam(priv, pipe_configs); 1059 int pipe_size = usbhs_get_dparam(priv, pipe_size); 1060 int i; 1061 int ret; 1062 1063 gpriv = kzalloc(sizeof(struct usbhsg_gpriv), GFP_KERNEL); 1064 if (!gpriv) 1065 return -ENOMEM; 1066 1067 uep = kzalloc(sizeof(struct usbhsg_uep) * pipe_size, GFP_KERNEL); 1068 if (!uep) { 1069 ret = -ENOMEM; 1070 goto usbhs_mod_gadget_probe_err_gpriv; 1071 } 1072 1073 gpriv->transceiver = usb_get_phy(USB_PHY_TYPE_UNDEFINED); 1074 dev_info(dev, "%stransceiver found\n", 1075 !IS_ERR(gpriv->transceiver) ? "" : "no "); 1076 1077 /* 1078 * CAUTION 1079 * 1080 * There is no guarantee that it is possible to access usb module here. 1081 * Don't accesses to it. 1082 * The accesse will be enable after "usbhsg_start" 1083 */ 1084 1085 /* 1086 * register itself 1087 */ 1088 usbhs_mod_register(priv, &gpriv->mod, USBHS_GADGET); 1089 1090 /* init gpriv */ 1091 gpriv->mod.name = "gadget"; 1092 gpriv->mod.start = usbhsg_start; 1093 gpriv->mod.stop = usbhsg_stop; 1094 gpriv->uep = uep; 1095 gpriv->uep_size = pipe_size; 1096 usbhsg_status_init(gpriv); 1097 1098 /* 1099 * init gadget 1100 */ 1101 gpriv->gadget.dev.parent = dev; 1102 gpriv->gadget.name = "renesas_usbhs_udc"; 1103 gpriv->gadget.ops = &usbhsg_gadget_ops; 1104 gpriv->gadget.max_speed = USB_SPEED_HIGH; 1105 gpriv->gadget.quirk_avoids_skb_reserve = usbhs_get_dparam(priv, 1106 has_usb_dmac); 1107 1108 INIT_LIST_HEAD(&gpriv->gadget.ep_list); 1109 1110 /* 1111 * init usb_ep 1112 */ 1113 usbhsg_for_each_uep_with_dcp(uep, gpriv, i) { 1114 uep->gpriv = gpriv; 1115 uep->pipe = NULL; 1116 snprintf(uep->ep_name, EP_NAME_SIZE, "ep%d", i); 1117 1118 uep->ep.name = uep->ep_name; 1119 uep->ep.ops = &usbhsg_ep_ops; 1120 INIT_LIST_HEAD(&uep->ep.ep_list); 1121 1122 /* init DCP */ 1123 if (usbhsg_is_dcp(uep)) { 1124 gpriv->gadget.ep0 = &uep->ep; 1125 usb_ep_set_maxpacket_limit(&uep->ep, 64); 1126 uep->ep.caps.type_control = true; 1127 } else { 1128 /* init normal pipe */ 1129 if (pipe_configs[i].type == USB_ENDPOINT_XFER_ISOC) 1130 uep->ep.caps.type_iso = true; 1131 if (pipe_configs[i].type == USB_ENDPOINT_XFER_BULK) 1132 uep->ep.caps.type_bulk = true; 1133 if (pipe_configs[i].type == USB_ENDPOINT_XFER_INT) 1134 uep->ep.caps.type_int = true; 1135 usb_ep_set_maxpacket_limit(&uep->ep, 1136 pipe_configs[i].bufsize); 1137 list_add_tail(&uep->ep.ep_list, &gpriv->gadget.ep_list); 1138 } 1139 uep->ep.caps.dir_in = true; 1140 uep->ep.caps.dir_out = true; 1141 } 1142 1143 ret = usb_add_gadget_udc(dev, &gpriv->gadget); 1144 if (ret) 1145 goto err_add_udc; 1146 1147 1148 dev_info(dev, "gadget probed\n"); 1149 1150 return 0; 1151 1152 err_add_udc: 1153 kfree(gpriv->uep); 1154 1155 usbhs_mod_gadget_probe_err_gpriv: 1156 kfree(gpriv); 1157 1158 return ret; 1159 } 1160 1161 void usbhs_mod_gadget_remove(struct usbhs_priv *priv) 1162 { 1163 struct usbhsg_gpriv *gpriv = usbhsg_priv_to_gpriv(priv); 1164 1165 usb_del_gadget_udc(&gpriv->gadget); 1166 1167 kfree(gpriv->uep); 1168 kfree(gpriv); 1169 } 1170