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