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