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