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