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