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