1 // SPDX-License-Identifier: GPL-1.0+ 2 /* 3 * Renesas USB driver 4 * 5 * Copyright (C) 2011 Renesas Solutions Corp. 6 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 7 */ 8 #include <linux/io.h> 9 #include <linux/list.h> 10 #include <linux/module.h> 11 #include <linux/platform_device.h> 12 #include <linux/slab.h> 13 #include <linux/usb.h> 14 #include <linux/usb/hcd.h> 15 #include "common.h" 16 17 /* 18 *** HARDWARE LIMITATION *** 19 * 20 * 1) renesas_usbhs has a limited number of controllable devices. 21 * it can control only 9 devices in generally. 22 * see DEVADDn / DCPMAXP / PIPEMAXP. 23 * 24 * 2) renesas_usbhs pipe number is limited. 25 * the pipe will be re-used for each devices. 26 * so, software should control DATA0/1 sequence of each devices. 27 */ 28 29 30 /* 31 * image of mod_host 32 * 33 * +--------+ 34 * | udev 0 | --> it is used when set address 35 * +--------+ 36 * 37 * +--------+ pipes are reused for each uep. 38 * | udev 1 |-+- [uep 0 (dcp) ] --+ pipe will be switched when 39 * +--------+ | | other device requested 40 * +- [uep 1 (bulk)] --|---+ +--------------+ 41 * | +--------------> | pipe0 (dcp) | 42 * +- [uep 2 (bulk)] -@ | +--------------+ 43 * | | pipe1 (isoc) | 44 * +--------+ | +--------------+ 45 * | udev 2 |-+- [uep 0 (dcp) ] -@ +----------> | pipe2 (bulk) | 46 * +--------+ | +--------------+ 47 * +- [uep 1 (int) ] ----+ +------> | pipe3 (bulk) | 48 * | | +--------------+ 49 * +--------+ +-----|------> | pipe4 (int) | 50 * | udev 3 |-+- [uep 0 (dcp) ] -@ | +--------------+ 51 * +--------+ | | | .... | 52 * +- [uep 1 (bulk)] -@ | | .... | 53 * | | 54 * +- [uep 2 (bulk)]-----------+ 55 * 56 * @ : uep requested free pipe, but all have been used. 57 * now it is waiting for free pipe 58 */ 59 60 61 /* 62 * struct 63 */ 64 struct usbhsh_request { 65 struct urb *urb; 66 struct usbhs_pkt pkt; 67 }; 68 69 struct usbhsh_device { 70 struct usb_device *usbv; 71 struct list_head ep_list_head; /* list of usbhsh_ep */ 72 }; 73 74 struct usbhsh_ep { 75 struct usbhs_pipe *pipe; /* attached pipe */ 76 struct usbhsh_device *udev; /* attached udev */ 77 struct usb_host_endpoint *ep; 78 struct list_head ep_list; /* list to usbhsh_device */ 79 unsigned int counter; /* pipe attach counter */ 80 }; 81 82 #define USBHSH_DEVICE_MAX 10 /* see DEVADDn / DCPMAXP / PIPEMAXP */ 83 #define USBHSH_PORT_MAX 7 /* see DEVADDn :: HUBPORT */ 84 struct usbhsh_hpriv { 85 struct usbhs_mod mod; 86 struct usbhs_pipe *dcp; 87 88 struct usbhsh_device udev[USBHSH_DEVICE_MAX]; 89 90 u32 port_stat; /* USB_PORT_STAT_xxx */ 91 92 struct completion setup_ack_done; 93 }; 94 95 96 static const char usbhsh_hcd_name[] = "renesas_usbhs host"; 97 98 /* 99 * macro 100 */ 101 #define usbhsh_priv_to_hpriv(priv) \ 102 container_of(usbhs_mod_get(priv, USBHS_HOST), struct usbhsh_hpriv, mod) 103 104 #define __usbhsh_for_each_udev(start, pos, h, i) \ 105 for ((i) = start; \ 106 ((i) < USBHSH_DEVICE_MAX) && ((pos) = (h)->udev + (i)); \ 107 (i)++) 108 109 #define usbhsh_for_each_udev(pos, hpriv, i) \ 110 __usbhsh_for_each_udev(1, pos, hpriv, i) 111 112 #define usbhsh_for_each_udev_with_dev0(pos, hpriv, i) \ 113 __usbhsh_for_each_udev(0, pos, hpriv, i) 114 115 #define usbhsh_hcd_to_hpriv(h) (struct usbhsh_hpriv *)((h)->hcd_priv) 116 #define usbhsh_hcd_to_dev(h) ((h)->self.controller) 117 118 #define usbhsh_hpriv_to_priv(h) ((h)->mod.priv) 119 #define usbhsh_hpriv_to_dcp(h) ((h)->dcp) 120 #define usbhsh_hpriv_to_hcd(h) \ 121 container_of((void *)h, struct usb_hcd, hcd_priv) 122 123 #define usbhsh_ep_to_uep(u) ((u)->hcpriv) 124 #define usbhsh_uep_to_pipe(u) ((u)->pipe) 125 #define usbhsh_uep_to_udev(u) ((u)->udev) 126 #define usbhsh_uep_to_ep(u) ((u)->ep) 127 128 #define usbhsh_urb_to_ureq(u) ((u)->hcpriv) 129 #define usbhsh_urb_to_usbv(u) ((u)->dev) 130 131 #define usbhsh_usbv_to_udev(d) dev_get_drvdata(&(d)->dev) 132 133 #define usbhsh_udev_to_usbv(h) ((h)->usbv) 134 #define usbhsh_udev_is_used(h) usbhsh_udev_to_usbv(h) 135 136 #define usbhsh_pipe_to_uep(p) ((p)->mod_private) 137 138 #define usbhsh_device_parent(d) (usbhsh_usbv_to_udev((d)->usbv->parent)) 139 #define usbhsh_device_hubport(d) ((d)->usbv->portnum) 140 #define usbhsh_device_number(h, d) ((int)((d) - (h)->udev)) 141 #define usbhsh_device_nth(h, d) ((h)->udev + d) 142 #define usbhsh_device0(h) usbhsh_device_nth(h, 0) 143 144 #define usbhsh_port_stat_init(h) ((h)->port_stat = 0) 145 #define usbhsh_port_stat_set(h, s) ((h)->port_stat |= (s)) 146 #define usbhsh_port_stat_clear(h, s) ((h)->port_stat &= ~(s)) 147 #define usbhsh_port_stat_get(h) ((h)->port_stat) 148 149 #define usbhsh_pkt_to_ureq(p) \ 150 container_of((void *)p, struct usbhsh_request, pkt) 151 152 /* 153 * req alloc/free 154 */ 155 static struct usbhsh_request *usbhsh_ureq_alloc(struct usbhsh_hpriv *hpriv, 156 struct urb *urb, 157 gfp_t mem_flags) 158 { 159 struct usbhsh_request *ureq; 160 161 ureq = kzalloc(sizeof(struct usbhsh_request), mem_flags); 162 if (!ureq) 163 return NULL; 164 165 usbhs_pkt_init(&ureq->pkt); 166 ureq->urb = urb; 167 usbhsh_urb_to_ureq(urb) = ureq; 168 169 return ureq; 170 } 171 172 static void usbhsh_ureq_free(struct usbhsh_hpriv *hpriv, 173 struct usbhsh_request *ureq) 174 { 175 usbhsh_urb_to_ureq(ureq->urb) = NULL; 176 ureq->urb = NULL; 177 178 kfree(ureq); 179 } 180 181 /* 182 * status 183 */ 184 static int usbhsh_is_running(struct usbhsh_hpriv *hpriv) 185 { 186 /* 187 * we can decide some device is attached or not 188 * by checking mod.irq_attch 189 * see 190 * usbhsh_irq_attch() 191 * usbhsh_irq_dtch() 192 */ 193 return (hpriv->mod.irq_attch == NULL); 194 } 195 196 /* 197 * pipe control 198 */ 199 static void usbhsh_endpoint_sequence_save(struct usbhsh_hpriv *hpriv, 200 struct urb *urb, 201 struct usbhs_pkt *pkt) 202 { 203 int len = urb->actual_length; 204 int maxp = usb_endpoint_maxp(&urb->ep->desc); 205 int t = 0; 206 207 /* DCP is out of sequence control */ 208 if (usb_pipecontrol(urb->pipe)) 209 return; 210 211 /* 212 * renesas_usbhs pipe has a limitation in a number. 213 * So, driver should re-use the limited pipe for each device/endpoint. 214 * DATA0/1 sequence should be saved for it. 215 * see [image of mod_host] 216 * [HARDWARE LIMITATION] 217 */ 218 219 /* 220 * next sequence depends on actual_length 221 * 222 * ex) actual_length = 1147, maxp = 512 223 * data0 : 512 224 * data1 : 512 225 * data0 : 123 226 * data1 is the next sequence 227 */ 228 t = len / maxp; 229 if (len % maxp) 230 t++; 231 if (pkt->zero) 232 t++; 233 t %= 2; 234 235 if (t) 236 usb_dotoggle(urb->dev, 237 usb_pipeendpoint(urb->pipe), 238 usb_pipeout(urb->pipe)); 239 } 240 241 static struct usbhsh_device *usbhsh_device_get(struct usbhsh_hpriv *hpriv, 242 struct urb *urb); 243 244 static int usbhsh_pipe_attach(struct usbhsh_hpriv *hpriv, 245 struct urb *urb) 246 { 247 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 248 struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep); 249 struct usbhsh_device *udev = usbhsh_device_get(hpriv, urb); 250 struct usbhs_pipe *pipe; 251 struct usb_endpoint_descriptor *desc = &urb->ep->desc; 252 struct device *dev = usbhs_priv_to_dev(priv); 253 unsigned long flags; 254 int dir_in_req = !!usb_pipein(urb->pipe); 255 int is_dcp = usb_endpoint_xfer_control(desc); 256 int i, dir_in; 257 int ret = -EBUSY; 258 259 /******************** spin lock ********************/ 260 usbhs_lock(priv, flags); 261 262 /* 263 * if uep has been attached to pipe, 264 * reuse it 265 */ 266 if (usbhsh_uep_to_pipe(uep)) { 267 ret = 0; 268 goto usbhsh_pipe_attach_done; 269 } 270 271 usbhs_for_each_pipe_with_dcp(pipe, priv, i) { 272 273 /* check pipe type */ 274 if (!usbhs_pipe_type_is(pipe, usb_endpoint_type(desc))) 275 continue; 276 277 /* check pipe direction if normal pipe */ 278 if (!is_dcp) { 279 dir_in = !!usbhs_pipe_is_dir_in(pipe); 280 if (0 != (dir_in - dir_in_req)) 281 continue; 282 } 283 284 /* check pipe is free */ 285 if (usbhsh_pipe_to_uep(pipe)) 286 continue; 287 288 /* 289 * attach pipe to uep 290 * 291 * usbhs_pipe_config_update() should be called after 292 * usbhs_set_device_config() 293 * see 294 * DCPMAXP/PIPEMAXP 295 */ 296 usbhsh_uep_to_pipe(uep) = pipe; 297 usbhsh_pipe_to_uep(pipe) = uep; 298 299 usbhs_pipe_config_update(pipe, 300 usbhsh_device_number(hpriv, udev), 301 usb_endpoint_num(desc), 302 usb_endpoint_maxp(desc)); 303 304 dev_dbg(dev, "%s [%d-%d(%s:%s)]\n", __func__, 305 usbhsh_device_number(hpriv, udev), 306 usb_endpoint_num(desc), 307 usbhs_pipe_name(pipe), 308 dir_in_req ? "in" : "out"); 309 310 ret = 0; 311 break; 312 } 313 314 usbhsh_pipe_attach_done: 315 if (0 == ret) 316 uep->counter++; 317 318 usbhs_unlock(priv, flags); 319 /******************** spin unlock ******************/ 320 321 return ret; 322 } 323 324 static void usbhsh_pipe_detach(struct usbhsh_hpriv *hpriv, 325 struct usbhsh_ep *uep) 326 { 327 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 328 struct usbhs_pipe *pipe; 329 struct device *dev = usbhs_priv_to_dev(priv); 330 unsigned long flags; 331 332 if (unlikely(!uep)) { 333 dev_err(dev, "no uep\n"); 334 return; 335 } 336 337 /******************** spin lock ********************/ 338 usbhs_lock(priv, flags); 339 340 pipe = usbhsh_uep_to_pipe(uep); 341 342 if (unlikely(!pipe)) { 343 dev_err(dev, "uep doesn't have pipe\n"); 344 } else if (1 == uep->counter--) { /* last user */ 345 struct usb_host_endpoint *ep = usbhsh_uep_to_ep(uep); 346 struct usbhsh_device *udev = usbhsh_uep_to_udev(uep); 347 348 /* detach pipe from uep */ 349 usbhsh_uep_to_pipe(uep) = NULL; 350 usbhsh_pipe_to_uep(pipe) = NULL; 351 352 dev_dbg(dev, "%s [%d-%d(%s)]\n", __func__, 353 usbhsh_device_number(hpriv, udev), 354 usb_endpoint_num(&ep->desc), 355 usbhs_pipe_name(pipe)); 356 } 357 358 usbhs_unlock(priv, flags); 359 /******************** spin unlock ******************/ 360 } 361 362 /* 363 * endpoint control 364 */ 365 static int usbhsh_endpoint_attach(struct usbhsh_hpriv *hpriv, 366 struct urb *urb, 367 gfp_t mem_flags) 368 { 369 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 370 struct usbhsh_device *udev = usbhsh_device_get(hpriv, urb); 371 struct usb_host_endpoint *ep = urb->ep; 372 struct usbhsh_ep *uep; 373 struct device *dev = usbhs_priv_to_dev(priv); 374 struct usb_endpoint_descriptor *desc = &ep->desc; 375 unsigned long flags; 376 377 uep = kzalloc(sizeof(struct usbhsh_ep), mem_flags); 378 if (!uep) 379 return -ENOMEM; 380 381 /******************** spin lock ********************/ 382 usbhs_lock(priv, flags); 383 384 /* 385 * init endpoint 386 */ 387 uep->counter = 0; 388 INIT_LIST_HEAD(&uep->ep_list); 389 list_add_tail(&uep->ep_list, &udev->ep_list_head); 390 391 usbhsh_uep_to_udev(uep) = udev; 392 usbhsh_uep_to_ep(uep) = ep; 393 usbhsh_ep_to_uep(ep) = uep; 394 395 usbhs_unlock(priv, flags); 396 /******************** spin unlock ******************/ 397 398 dev_dbg(dev, "%s [%d-%d]\n", __func__, 399 usbhsh_device_number(hpriv, udev), 400 usb_endpoint_num(desc)); 401 402 return 0; 403 } 404 405 static void usbhsh_endpoint_detach(struct usbhsh_hpriv *hpriv, 406 struct usb_host_endpoint *ep) 407 { 408 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 409 struct device *dev = usbhs_priv_to_dev(priv); 410 struct usbhsh_ep *uep = usbhsh_ep_to_uep(ep); 411 unsigned long flags; 412 413 if (!uep) 414 return; 415 416 dev_dbg(dev, "%s [%d-%d]\n", __func__, 417 usbhsh_device_number(hpriv, usbhsh_uep_to_udev(uep)), 418 usb_endpoint_num(&ep->desc)); 419 420 if (usbhsh_uep_to_pipe(uep)) 421 usbhsh_pipe_detach(hpriv, uep); 422 423 /******************** spin lock ********************/ 424 usbhs_lock(priv, flags); 425 426 /* remove this endpoint from udev */ 427 list_del_init(&uep->ep_list); 428 429 usbhsh_uep_to_udev(uep) = NULL; 430 usbhsh_uep_to_ep(uep) = NULL; 431 usbhsh_ep_to_uep(ep) = NULL; 432 433 usbhs_unlock(priv, flags); 434 /******************** spin unlock ******************/ 435 436 kfree(uep); 437 } 438 439 static void usbhsh_endpoint_detach_all(struct usbhsh_hpriv *hpriv, 440 struct usbhsh_device *udev) 441 { 442 struct usbhsh_ep *uep, *next; 443 444 list_for_each_entry_safe(uep, next, &udev->ep_list_head, ep_list) 445 usbhsh_endpoint_detach(hpriv, usbhsh_uep_to_ep(uep)); 446 } 447 448 /* 449 * device control 450 */ 451 static int usbhsh_connected_to_rhdev(struct usb_hcd *hcd, 452 struct usbhsh_device *udev) 453 { 454 struct usb_device *usbv = usbhsh_udev_to_usbv(udev); 455 456 return hcd->self.root_hub == usbv->parent; 457 } 458 459 static int usbhsh_device_has_endpoint(struct usbhsh_device *udev) 460 { 461 return !list_empty(&udev->ep_list_head); 462 } 463 464 static struct usbhsh_device *usbhsh_device_get(struct usbhsh_hpriv *hpriv, 465 struct urb *urb) 466 { 467 struct usb_device *usbv = usbhsh_urb_to_usbv(urb); 468 struct usbhsh_device *udev = usbhsh_usbv_to_udev(usbv); 469 470 /* usbhsh_device_attach() is still not called */ 471 if (!udev) 472 return NULL; 473 474 /* if it is device0, return it */ 475 if (0 == usb_pipedevice(urb->pipe)) 476 return usbhsh_device0(hpriv); 477 478 /* return attached device */ 479 return udev; 480 } 481 482 static struct usbhsh_device *usbhsh_device_attach(struct usbhsh_hpriv *hpriv, 483 struct urb *urb) 484 { 485 struct usbhsh_device *udev = NULL; 486 struct usbhsh_device *udev0 = usbhsh_device0(hpriv); 487 struct usbhsh_device *pos; 488 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv); 489 struct device *dev = usbhsh_hcd_to_dev(hcd); 490 struct usb_device *usbv = usbhsh_urb_to_usbv(urb); 491 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 492 unsigned long flags; 493 u16 upphub, hubport; 494 int i; 495 496 /* 497 * This function should be called only while urb is pointing to device0. 498 * It will attach unused usbhsh_device to urb (usbv), 499 * and initialize device0. 500 * You can use usbhsh_device_get() to get "current" udev, 501 * and usbhsh_usbv_to_udev() is for "attached" udev. 502 */ 503 if (0 != usb_pipedevice(urb->pipe)) { 504 dev_err(dev, "%s fail: urb isn't pointing device0\n", __func__); 505 return NULL; 506 } 507 508 /******************** spin lock ********************/ 509 usbhs_lock(priv, flags); 510 511 /* 512 * find unused device 513 */ 514 usbhsh_for_each_udev(pos, hpriv, i) { 515 if (usbhsh_udev_is_used(pos)) 516 continue; 517 udev = pos; 518 break; 519 } 520 521 if (udev) { 522 /* 523 * usbhsh_usbv_to_udev() 524 * usbhsh_udev_to_usbv() 525 * will be enable 526 */ 527 dev_set_drvdata(&usbv->dev, udev); 528 udev->usbv = usbv; 529 } 530 531 usbhs_unlock(priv, flags); 532 /******************** spin unlock ******************/ 533 534 if (!udev) { 535 dev_err(dev, "no free usbhsh_device\n"); 536 return NULL; 537 } 538 539 if (usbhsh_device_has_endpoint(udev)) { 540 dev_warn(dev, "udev have old endpoint\n"); 541 usbhsh_endpoint_detach_all(hpriv, udev); 542 } 543 544 if (usbhsh_device_has_endpoint(udev0)) { 545 dev_warn(dev, "udev0 have old endpoint\n"); 546 usbhsh_endpoint_detach_all(hpriv, udev0); 547 } 548 549 /* uep will be attached */ 550 INIT_LIST_HEAD(&udev0->ep_list_head); 551 INIT_LIST_HEAD(&udev->ep_list_head); 552 553 /* 554 * set device0 config 555 */ 556 usbhs_set_device_config(priv, 557 0, 0, 0, usbv->speed); 558 559 /* 560 * set new device config 561 */ 562 upphub = 0; 563 hubport = 0; 564 if (!usbhsh_connected_to_rhdev(hcd, udev)) { 565 /* if udev is not connected to rhdev, it means parent is Hub */ 566 struct usbhsh_device *parent = usbhsh_device_parent(udev); 567 568 upphub = usbhsh_device_number(hpriv, parent); 569 hubport = usbhsh_device_hubport(udev); 570 571 dev_dbg(dev, "%s connected to Hub [%d:%d](%p)\n", __func__, 572 upphub, hubport, parent); 573 } 574 575 usbhs_set_device_config(priv, 576 usbhsh_device_number(hpriv, udev), 577 upphub, hubport, usbv->speed); 578 579 dev_dbg(dev, "%s [%d](%p)\n", __func__, 580 usbhsh_device_number(hpriv, udev), udev); 581 582 return udev; 583 } 584 585 static void usbhsh_device_detach(struct usbhsh_hpriv *hpriv, 586 struct usbhsh_device *udev) 587 { 588 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv); 589 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 590 struct device *dev = usbhsh_hcd_to_dev(hcd); 591 struct usb_device *usbv = usbhsh_udev_to_usbv(udev); 592 unsigned long flags; 593 594 dev_dbg(dev, "%s [%d](%p)\n", __func__, 595 usbhsh_device_number(hpriv, udev), udev); 596 597 if (usbhsh_device_has_endpoint(udev)) { 598 dev_warn(dev, "udev still have endpoint\n"); 599 usbhsh_endpoint_detach_all(hpriv, udev); 600 } 601 602 /* 603 * There is nothing to do if it is device0. 604 * see 605 * usbhsh_device_attach() 606 * usbhsh_device_get() 607 */ 608 if (0 == usbhsh_device_number(hpriv, udev)) 609 return; 610 611 /******************** spin lock ********************/ 612 usbhs_lock(priv, flags); 613 614 /* 615 * usbhsh_usbv_to_udev() 616 * usbhsh_udev_to_usbv() 617 * will be disable 618 */ 619 dev_set_drvdata(&usbv->dev, NULL); 620 udev->usbv = NULL; 621 622 usbhs_unlock(priv, flags); 623 /******************** spin unlock ******************/ 624 } 625 626 /* 627 * queue push/pop 628 */ 629 static void usbhsh_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt) 630 { 631 struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt); 632 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv); 633 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv); 634 struct urb *urb = ureq->urb; 635 struct device *dev = usbhs_priv_to_dev(priv); 636 int status = 0; 637 638 dev_dbg(dev, "%s\n", __func__); 639 640 if (!urb) { 641 dev_warn(dev, "pkt doesn't have urb\n"); 642 return; 643 } 644 645 if (!usbhsh_is_running(hpriv)) 646 status = -ESHUTDOWN; 647 648 urb->actual_length = pkt->actual; 649 650 usbhsh_endpoint_sequence_save(hpriv, urb, pkt); 651 usbhsh_ureq_free(hpriv, ureq); 652 653 usbhsh_pipe_detach(hpriv, usbhsh_ep_to_uep(urb->ep)); 654 655 usb_hcd_unlink_urb_from_ep(hcd, urb); 656 usb_hcd_giveback_urb(hcd, urb, status); 657 } 658 659 static int usbhsh_queue_push(struct usb_hcd *hcd, 660 struct urb *urb, 661 gfp_t mem_flags) 662 { 663 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd); 664 struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep); 665 struct usbhs_pipe *pipe = usbhsh_uep_to_pipe(uep); 666 struct device *dev = usbhsh_hcd_to_dev(hcd); 667 struct usbhsh_request *ureq; 668 void *buf; 669 int len, sequence; 670 671 if (usb_pipeisoc(urb->pipe)) { 672 dev_err(dev, "pipe iso is not supported now\n"); 673 return -EIO; 674 } 675 676 /* this ureq will be freed on usbhsh_queue_done() */ 677 ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags); 678 if (unlikely(!ureq)) { 679 dev_err(dev, "ureq alloc fail\n"); 680 return -ENOMEM; 681 } 682 683 if (usb_pipein(urb->pipe)) 684 pipe->handler = &usbhs_fifo_dma_pop_handler; 685 else 686 pipe->handler = &usbhs_fifo_dma_push_handler; 687 688 buf = (void *)(urb->transfer_buffer + urb->actual_length); 689 len = urb->transfer_buffer_length - urb->actual_length; 690 691 sequence = usb_gettoggle(urb->dev, 692 usb_pipeendpoint(urb->pipe), 693 usb_pipeout(urb->pipe)); 694 695 dev_dbg(dev, "%s\n", __func__); 696 usbhs_pkt_push(pipe, &ureq->pkt, usbhsh_queue_done, 697 buf, len, (urb->transfer_flags & URB_ZERO_PACKET), 698 sequence); 699 700 usbhs_pkt_start(pipe); 701 702 return 0; 703 } 704 705 static void usbhsh_queue_force_pop(struct usbhs_priv *priv, 706 struct usbhs_pipe *pipe) 707 { 708 struct usbhs_pkt *pkt; 709 710 while (1) { 711 pkt = usbhs_pkt_pop(pipe, NULL); 712 if (!pkt) 713 break; 714 715 /* 716 * if all packet are gone, usbhsh_endpoint_disable() 717 * will be called. 718 * then, attached device/endpoint/pipe will be detached 719 */ 720 usbhsh_queue_done(priv, pkt); 721 } 722 } 723 724 static void usbhsh_queue_force_pop_all(struct usbhs_priv *priv) 725 { 726 struct usbhs_pipe *pos; 727 int i; 728 729 usbhs_for_each_pipe_with_dcp(pos, priv, i) 730 usbhsh_queue_force_pop(priv, pos); 731 } 732 733 /* 734 * DCP setup stage 735 */ 736 static int usbhsh_is_request_address(struct urb *urb) 737 { 738 struct usb_ctrlrequest *req; 739 740 req = (struct usb_ctrlrequest *)urb->setup_packet; 741 742 if ((DeviceOutRequest == req->bRequestType << 8) && 743 (USB_REQ_SET_ADDRESS == req->bRequest)) 744 return 1; 745 else 746 return 0; 747 } 748 749 static void usbhsh_setup_stage_packet_push(struct usbhsh_hpriv *hpriv, 750 struct urb *urb, 751 struct usbhs_pipe *pipe) 752 { 753 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 754 struct usb_ctrlrequest req; 755 struct device *dev = usbhs_priv_to_dev(priv); 756 757 /* 758 * wait setup packet ACK 759 * see 760 * usbhsh_irq_setup_ack() 761 * usbhsh_irq_setup_err() 762 */ 763 init_completion(&hpriv->setup_ack_done); 764 765 /* copy original request */ 766 memcpy(&req, urb->setup_packet, sizeof(struct usb_ctrlrequest)); 767 768 /* 769 * renesas_usbhs can not use original usb address. 770 * see HARDWARE LIMITATION. 771 * modify usb address here to use attached device. 772 * see usbhsh_device_attach() 773 */ 774 if (usbhsh_is_request_address(urb)) { 775 struct usb_device *usbv = usbhsh_urb_to_usbv(urb); 776 struct usbhsh_device *udev = usbhsh_usbv_to_udev(usbv); 777 778 /* udev is a attached device */ 779 req.wValue = usbhsh_device_number(hpriv, udev); 780 dev_dbg(dev, "create new address - %d\n", req.wValue); 781 } 782 783 /* set request */ 784 usbhs_usbreq_set_val(priv, &req); 785 786 /* 787 * wait setup packet ACK 788 */ 789 wait_for_completion(&hpriv->setup_ack_done); 790 791 dev_dbg(dev, "%s done\n", __func__); 792 } 793 794 /* 795 * DCP data stage 796 */ 797 static void usbhsh_data_stage_packet_done(struct usbhs_priv *priv, 798 struct usbhs_pkt *pkt) 799 { 800 struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt); 801 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv); 802 803 /* this ureq was connected to urb when usbhsh_urb_enqueue() */ 804 805 usbhsh_ureq_free(hpriv, ureq); 806 } 807 808 static int usbhsh_data_stage_packet_push(struct usbhsh_hpriv *hpriv, 809 struct urb *urb, 810 struct usbhs_pipe *pipe, 811 gfp_t mem_flags) 812 813 { 814 struct usbhsh_request *ureq; 815 816 /* this ureq will be freed on usbhsh_data_stage_packet_done() */ 817 ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags); 818 if (unlikely(!ureq)) 819 return -ENOMEM; 820 821 if (usb_pipein(urb->pipe)) 822 pipe->handler = &usbhs_dcp_data_stage_in_handler; 823 else 824 pipe->handler = &usbhs_dcp_data_stage_out_handler; 825 826 usbhs_pkt_push(pipe, &ureq->pkt, 827 usbhsh_data_stage_packet_done, 828 urb->transfer_buffer, 829 urb->transfer_buffer_length, 830 (urb->transfer_flags & URB_ZERO_PACKET), 831 -1); 832 833 return 0; 834 } 835 836 /* 837 * DCP status stage 838 */ 839 static int usbhsh_status_stage_packet_push(struct usbhsh_hpriv *hpriv, 840 struct urb *urb, 841 struct usbhs_pipe *pipe, 842 gfp_t mem_flags) 843 { 844 struct usbhsh_request *ureq; 845 846 /* This ureq will be freed on usbhsh_queue_done() */ 847 ureq = usbhsh_ureq_alloc(hpriv, urb, mem_flags); 848 if (unlikely(!ureq)) 849 return -ENOMEM; 850 851 if (usb_pipein(urb->pipe)) 852 pipe->handler = &usbhs_dcp_status_stage_in_handler; 853 else 854 pipe->handler = &usbhs_dcp_status_stage_out_handler; 855 856 usbhs_pkt_push(pipe, &ureq->pkt, 857 usbhsh_queue_done, 858 NULL, 859 urb->transfer_buffer_length, 860 0, -1); 861 862 return 0; 863 } 864 865 static int usbhsh_dcp_queue_push(struct usb_hcd *hcd, 866 struct urb *urb, 867 gfp_t mflags) 868 { 869 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd); 870 struct usbhsh_ep *uep = usbhsh_ep_to_uep(urb->ep); 871 struct usbhs_pipe *pipe = usbhsh_uep_to_pipe(uep); 872 struct device *dev = usbhsh_hcd_to_dev(hcd); 873 int ret; 874 875 dev_dbg(dev, "%s\n", __func__); 876 877 /* 878 * setup stage 879 * 880 * usbhsh_send_setup_stage_packet() wait SACK/SIGN 881 */ 882 usbhsh_setup_stage_packet_push(hpriv, urb, pipe); 883 884 /* 885 * data stage 886 * 887 * It is pushed only when urb has buffer. 888 */ 889 if (urb->transfer_buffer_length) { 890 ret = usbhsh_data_stage_packet_push(hpriv, urb, pipe, mflags); 891 if (ret < 0) { 892 dev_err(dev, "data stage failed\n"); 893 return ret; 894 } 895 } 896 897 /* 898 * status stage 899 */ 900 ret = usbhsh_status_stage_packet_push(hpriv, urb, pipe, mflags); 901 if (ret < 0) { 902 dev_err(dev, "status stage failed\n"); 903 return ret; 904 } 905 906 /* 907 * start pushed packets 908 */ 909 usbhs_pkt_start(pipe); 910 911 return 0; 912 } 913 914 /* 915 * dma map functions 916 */ 917 static int usbhsh_dma_map_ctrl(struct device *dma_dev, struct usbhs_pkt *pkt, 918 int map) 919 { 920 if (map) { 921 struct usbhsh_request *ureq = usbhsh_pkt_to_ureq(pkt); 922 struct urb *urb = ureq->urb; 923 924 /* it can not use scatter/gather */ 925 if (urb->num_sgs) 926 return -EINVAL; 927 928 pkt->dma = urb->transfer_dma; 929 if (!pkt->dma) 930 return -EINVAL; 931 } 932 933 return 0; 934 } 935 936 /* 937 * for hc_driver 938 */ 939 static int usbhsh_host_start(struct usb_hcd *hcd) 940 { 941 return 0; 942 } 943 944 static void usbhsh_host_stop(struct usb_hcd *hcd) 945 { 946 } 947 948 static int usbhsh_urb_enqueue(struct usb_hcd *hcd, 949 struct urb *urb, 950 gfp_t mem_flags) 951 { 952 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd); 953 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 954 struct device *dev = usbhs_priv_to_dev(priv); 955 struct usb_host_endpoint *ep = urb->ep; 956 struct usbhsh_device *new_udev = NULL; 957 int is_dir_in = usb_pipein(urb->pipe); 958 int ret; 959 960 dev_dbg(dev, "%s (%s)\n", __func__, is_dir_in ? "in" : "out"); 961 962 if (!usbhsh_is_running(hpriv)) { 963 ret = -EIO; 964 dev_err(dev, "host is not running\n"); 965 goto usbhsh_urb_enqueue_error_not_linked; 966 } 967 968 ret = usb_hcd_link_urb_to_ep(hcd, urb); 969 if (ret) { 970 dev_err(dev, "urb link failed\n"); 971 goto usbhsh_urb_enqueue_error_not_linked; 972 } 973 974 /* 975 * attach udev if needed 976 * see [image of mod_host] 977 */ 978 if (!usbhsh_device_get(hpriv, urb)) { 979 new_udev = usbhsh_device_attach(hpriv, urb); 980 if (!new_udev) { 981 ret = -EIO; 982 dev_err(dev, "device attach failed\n"); 983 goto usbhsh_urb_enqueue_error_not_linked; 984 } 985 } 986 987 /* 988 * attach endpoint if needed 989 * see [image of mod_host] 990 */ 991 if (!usbhsh_ep_to_uep(ep)) { 992 ret = usbhsh_endpoint_attach(hpriv, urb, mem_flags); 993 if (ret < 0) { 994 dev_err(dev, "endpoint attach failed\n"); 995 goto usbhsh_urb_enqueue_error_free_device; 996 } 997 } 998 999 /* 1000 * attach pipe to endpoint 1001 * see [image of mod_host] 1002 */ 1003 ret = usbhsh_pipe_attach(hpriv, urb); 1004 if (ret < 0) { 1005 dev_err(dev, "pipe attach failed\n"); 1006 goto usbhsh_urb_enqueue_error_free_endpoint; 1007 } 1008 1009 /* 1010 * push packet 1011 */ 1012 if (usb_pipecontrol(urb->pipe)) 1013 ret = usbhsh_dcp_queue_push(hcd, urb, mem_flags); 1014 else 1015 ret = usbhsh_queue_push(hcd, urb, mem_flags); 1016 1017 return ret; 1018 1019 usbhsh_urb_enqueue_error_free_endpoint: 1020 usbhsh_endpoint_detach(hpriv, ep); 1021 usbhsh_urb_enqueue_error_free_device: 1022 if (new_udev) 1023 usbhsh_device_detach(hpriv, new_udev); 1024 usbhsh_urb_enqueue_error_not_linked: 1025 1026 dev_dbg(dev, "%s error\n", __func__); 1027 1028 return ret; 1029 } 1030 1031 static int usbhsh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status) 1032 { 1033 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd); 1034 struct usbhsh_request *ureq = usbhsh_urb_to_ureq(urb); 1035 1036 if (ureq) { 1037 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 1038 struct usbhs_pkt *pkt = &ureq->pkt; 1039 1040 usbhs_pkt_pop(pkt->pipe, pkt); 1041 usbhsh_queue_done(priv, pkt); 1042 } 1043 1044 return 0; 1045 } 1046 1047 static void usbhsh_endpoint_disable(struct usb_hcd *hcd, 1048 struct usb_host_endpoint *ep) 1049 { 1050 struct usbhsh_ep *uep = usbhsh_ep_to_uep(ep); 1051 struct usbhsh_device *udev; 1052 struct usbhsh_hpriv *hpriv; 1053 1054 /* 1055 * this function might be called manytimes by same hcd/ep 1056 * in-endpoint == out-endpoint if ep == dcp. 1057 */ 1058 if (!uep) 1059 return; 1060 1061 udev = usbhsh_uep_to_udev(uep); 1062 hpriv = usbhsh_hcd_to_hpriv(hcd); 1063 1064 usbhsh_endpoint_detach(hpriv, ep); 1065 1066 /* 1067 * if there is no endpoint, 1068 * free device 1069 */ 1070 if (!usbhsh_device_has_endpoint(udev)) 1071 usbhsh_device_detach(hpriv, udev); 1072 } 1073 1074 static int usbhsh_hub_status_data(struct usb_hcd *hcd, char *buf) 1075 { 1076 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd); 1077 int roothub_id = 1; /* only 1 root hub */ 1078 1079 /* 1080 * does port stat was changed ? 1081 * check USB_PORT_STAT_C_xxx << 16 1082 */ 1083 if (usbhsh_port_stat_get(hpriv) & 0xFFFF0000) 1084 *buf = (1 << roothub_id); 1085 else 1086 *buf = 0; 1087 1088 return !!(*buf); 1089 } 1090 1091 static int __usbhsh_hub_hub_feature(struct usbhsh_hpriv *hpriv, 1092 u16 typeReq, u16 wValue, 1093 u16 wIndex, char *buf, u16 wLength) 1094 { 1095 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 1096 struct device *dev = usbhs_priv_to_dev(priv); 1097 1098 switch (wValue) { 1099 case C_HUB_OVER_CURRENT: 1100 case C_HUB_LOCAL_POWER: 1101 dev_dbg(dev, "%s :: C_HUB_xx\n", __func__); 1102 return 0; 1103 } 1104 1105 return -EPIPE; 1106 } 1107 1108 static int __usbhsh_hub_port_feature(struct usbhsh_hpriv *hpriv, 1109 u16 typeReq, u16 wValue, 1110 u16 wIndex, char *buf, u16 wLength) 1111 { 1112 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 1113 struct device *dev = usbhs_priv_to_dev(priv); 1114 int enable = (typeReq == SetPortFeature); 1115 int speed, i, timeout = 128; 1116 int roothub_id = 1; /* only 1 root hub */ 1117 1118 /* common error */ 1119 if (wIndex > roothub_id || wLength != 0) 1120 return -EPIPE; 1121 1122 /* check wValue */ 1123 switch (wValue) { 1124 case USB_PORT_FEAT_POWER: 1125 usbhs_vbus_ctrl(priv, enable); 1126 dev_dbg(dev, "%s :: USB_PORT_FEAT_POWER\n", __func__); 1127 break; 1128 1129 case USB_PORT_FEAT_ENABLE: 1130 case USB_PORT_FEAT_SUSPEND: 1131 case USB_PORT_FEAT_C_ENABLE: 1132 case USB_PORT_FEAT_C_SUSPEND: 1133 case USB_PORT_FEAT_C_CONNECTION: 1134 case USB_PORT_FEAT_C_OVER_CURRENT: 1135 case USB_PORT_FEAT_C_RESET: 1136 dev_dbg(dev, "%s :: USB_PORT_FEAT_xxx\n", __func__); 1137 break; 1138 1139 case USB_PORT_FEAT_RESET: 1140 if (!enable) 1141 break; 1142 1143 usbhsh_port_stat_clear(hpriv, 1144 USB_PORT_STAT_HIGH_SPEED | 1145 USB_PORT_STAT_LOW_SPEED); 1146 1147 usbhsh_queue_force_pop_all(priv); 1148 1149 usbhs_bus_send_reset(priv); 1150 msleep(20); 1151 usbhs_bus_send_sof_enable(priv); 1152 1153 for (i = 0; i < timeout ; i++) { 1154 switch (usbhs_bus_get_speed(priv)) { 1155 case USB_SPEED_LOW: 1156 speed = USB_PORT_STAT_LOW_SPEED; 1157 goto got_usb_bus_speed; 1158 case USB_SPEED_HIGH: 1159 speed = USB_PORT_STAT_HIGH_SPEED; 1160 goto got_usb_bus_speed; 1161 case USB_SPEED_FULL: 1162 speed = 0; 1163 goto got_usb_bus_speed; 1164 } 1165 1166 msleep(20); 1167 } 1168 return -EPIPE; 1169 1170 got_usb_bus_speed: 1171 usbhsh_port_stat_set(hpriv, speed); 1172 usbhsh_port_stat_set(hpriv, USB_PORT_STAT_ENABLE); 1173 1174 dev_dbg(dev, "%s :: USB_PORT_FEAT_RESET (speed = %d)\n", 1175 __func__, speed); 1176 1177 /* status change is not needed */ 1178 return 0; 1179 1180 default: 1181 return -EPIPE; 1182 } 1183 1184 /* set/clear status */ 1185 if (enable) 1186 usbhsh_port_stat_set(hpriv, (1 << wValue)); 1187 else 1188 usbhsh_port_stat_clear(hpriv, (1 << wValue)); 1189 1190 return 0; 1191 } 1192 1193 static int __usbhsh_hub_get_status(struct usbhsh_hpriv *hpriv, 1194 u16 typeReq, u16 wValue, 1195 u16 wIndex, char *buf, u16 wLength) 1196 { 1197 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 1198 struct usb_hub_descriptor *desc = (struct usb_hub_descriptor *)buf; 1199 struct device *dev = usbhs_priv_to_dev(priv); 1200 int roothub_id = 1; /* only 1 root hub */ 1201 1202 switch (typeReq) { 1203 case GetHubStatus: 1204 dev_dbg(dev, "%s :: GetHubStatus\n", __func__); 1205 1206 *buf = 0x00; 1207 break; 1208 1209 case GetPortStatus: 1210 if (wIndex != roothub_id) 1211 return -EPIPE; 1212 1213 dev_dbg(dev, "%s :: GetPortStatus\n", __func__); 1214 *(__le32 *)buf = cpu_to_le32(usbhsh_port_stat_get(hpriv)); 1215 break; 1216 1217 case GetHubDescriptor: 1218 desc->bDescriptorType = USB_DT_HUB; 1219 desc->bHubContrCurrent = 0; 1220 desc->bNbrPorts = roothub_id; 1221 desc->bDescLength = 9; 1222 desc->bPwrOn2PwrGood = 0; 1223 desc->wHubCharacteristics = 1224 cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_NO_OCPM); 1225 desc->u.hs.DeviceRemovable[0] = (roothub_id << 1); 1226 desc->u.hs.DeviceRemovable[1] = ~0; 1227 dev_dbg(dev, "%s :: GetHubDescriptor\n", __func__); 1228 break; 1229 } 1230 1231 return 0; 1232 } 1233 1234 static int usbhsh_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 1235 u16 wIndex, char *buf, u16 wLength) 1236 { 1237 struct usbhsh_hpriv *hpriv = usbhsh_hcd_to_hpriv(hcd); 1238 struct usbhs_priv *priv = usbhsh_hpriv_to_priv(hpriv); 1239 struct device *dev = usbhs_priv_to_dev(priv); 1240 int ret = -EPIPE; 1241 1242 switch (typeReq) { 1243 1244 /* Hub Feature */ 1245 case ClearHubFeature: 1246 case SetHubFeature: 1247 ret = __usbhsh_hub_hub_feature(hpriv, typeReq, 1248 wValue, wIndex, buf, wLength); 1249 break; 1250 1251 /* Port Feature */ 1252 case SetPortFeature: 1253 case ClearPortFeature: 1254 ret = __usbhsh_hub_port_feature(hpriv, typeReq, 1255 wValue, wIndex, buf, wLength); 1256 break; 1257 1258 /* Get status */ 1259 case GetHubStatus: 1260 case GetPortStatus: 1261 case GetHubDescriptor: 1262 ret = __usbhsh_hub_get_status(hpriv, typeReq, 1263 wValue, wIndex, buf, wLength); 1264 break; 1265 } 1266 1267 dev_dbg(dev, "typeReq = %x, ret = %d, port_stat = %x\n", 1268 typeReq, ret, usbhsh_port_stat_get(hpriv)); 1269 1270 return ret; 1271 } 1272 1273 static int usbhsh_bus_nop(struct usb_hcd *hcd) 1274 { 1275 /* nothing to do */ 1276 return 0; 1277 } 1278 1279 static const struct hc_driver usbhsh_driver = { 1280 .description = usbhsh_hcd_name, 1281 .hcd_priv_size = sizeof(struct usbhsh_hpriv), 1282 1283 /* 1284 * generic hardware linkage 1285 */ 1286 .flags = HCD_DMA | HCD_USB2, 1287 1288 .start = usbhsh_host_start, 1289 .stop = usbhsh_host_stop, 1290 1291 /* 1292 * managing i/o requests and associated device resources 1293 */ 1294 .urb_enqueue = usbhsh_urb_enqueue, 1295 .urb_dequeue = usbhsh_urb_dequeue, 1296 .endpoint_disable = usbhsh_endpoint_disable, 1297 1298 /* 1299 * root hub 1300 */ 1301 .hub_status_data = usbhsh_hub_status_data, 1302 .hub_control = usbhsh_hub_control, 1303 .bus_suspend = usbhsh_bus_nop, 1304 .bus_resume = usbhsh_bus_nop, 1305 }; 1306 1307 /* 1308 * interrupt functions 1309 */ 1310 static int usbhsh_irq_attch(struct usbhs_priv *priv, 1311 struct usbhs_irq_state *irq_state) 1312 { 1313 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv); 1314 struct device *dev = usbhs_priv_to_dev(priv); 1315 1316 dev_dbg(dev, "device attached\n"); 1317 1318 usbhsh_port_stat_set(hpriv, USB_PORT_STAT_CONNECTION); 1319 usbhsh_port_stat_set(hpriv, USB_PORT_STAT_C_CONNECTION << 16); 1320 1321 /* 1322 * attch interrupt might happen infinitely on some device 1323 * (on self power USB hub ?) 1324 * disable it here. 1325 * 1326 * usbhsh_is_running() becomes effective 1327 * according to this process. 1328 * see 1329 * usbhsh_is_running() 1330 * usbhsh_urb_enqueue() 1331 */ 1332 hpriv->mod.irq_attch = NULL; 1333 usbhs_irq_callback_update(priv, &hpriv->mod); 1334 1335 return 0; 1336 } 1337 1338 static int usbhsh_irq_dtch(struct usbhs_priv *priv, 1339 struct usbhs_irq_state *irq_state) 1340 { 1341 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv); 1342 struct device *dev = usbhs_priv_to_dev(priv); 1343 1344 dev_dbg(dev, "device detached\n"); 1345 1346 usbhsh_port_stat_clear(hpriv, USB_PORT_STAT_CONNECTION); 1347 usbhsh_port_stat_set(hpriv, USB_PORT_STAT_C_CONNECTION << 16); 1348 1349 /* 1350 * enable attch interrupt again 1351 * 1352 * usbhsh_is_running() becomes invalid 1353 * according to this process. 1354 * see 1355 * usbhsh_is_running() 1356 * usbhsh_urb_enqueue() 1357 */ 1358 hpriv->mod.irq_attch = usbhsh_irq_attch; 1359 usbhs_irq_callback_update(priv, &hpriv->mod); 1360 1361 /* 1362 * usbhsh_queue_force_pop_all() should be called 1363 * after usbhsh_is_running() becomes invalid. 1364 */ 1365 usbhsh_queue_force_pop_all(priv); 1366 1367 return 0; 1368 } 1369 1370 static int usbhsh_irq_setup_ack(struct usbhs_priv *priv, 1371 struct usbhs_irq_state *irq_state) 1372 { 1373 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv); 1374 struct device *dev = usbhs_priv_to_dev(priv); 1375 1376 dev_dbg(dev, "setup packet OK\n"); 1377 1378 complete(&hpriv->setup_ack_done); /* see usbhsh_urb_enqueue() */ 1379 1380 return 0; 1381 } 1382 1383 static int usbhsh_irq_setup_err(struct usbhs_priv *priv, 1384 struct usbhs_irq_state *irq_state) 1385 { 1386 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv); 1387 struct device *dev = usbhs_priv_to_dev(priv); 1388 1389 dev_dbg(dev, "setup packet Err\n"); 1390 1391 complete(&hpriv->setup_ack_done); /* see usbhsh_urb_enqueue() */ 1392 1393 return 0; 1394 } 1395 1396 /* 1397 * module start/stop 1398 */ 1399 static void usbhsh_pipe_init_for_host(struct usbhs_priv *priv) 1400 { 1401 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv); 1402 struct usbhs_pipe *pipe; 1403 struct renesas_usbhs_driver_pipe_config *pipe_configs = 1404 usbhs_get_dparam(priv, pipe_configs); 1405 int pipe_size = usbhs_get_dparam(priv, pipe_size); 1406 int old_type, dir_in, i; 1407 1408 /* init all pipe */ 1409 old_type = USB_ENDPOINT_XFER_CONTROL; 1410 for (i = 0; i < pipe_size; i++) { 1411 1412 /* 1413 * data "output" will be finished as soon as possible, 1414 * but there is no guaranty at data "input" case. 1415 * 1416 * "input" needs "standby" pipe. 1417 * So, "input" direction pipe > "output" direction pipe 1418 * is good idea. 1419 * 1420 * 1st USB_ENDPOINT_XFER_xxx will be output direction, 1421 * and the other will be input direction here. 1422 * 1423 * ex) 1424 * ... 1425 * USB_ENDPOINT_XFER_ISOC -> dir out 1426 * USB_ENDPOINT_XFER_ISOC -> dir in 1427 * USB_ENDPOINT_XFER_BULK -> dir out 1428 * USB_ENDPOINT_XFER_BULK -> dir in 1429 * USB_ENDPOINT_XFER_BULK -> dir in 1430 * ... 1431 */ 1432 dir_in = (pipe_configs[i].type == old_type); 1433 old_type = pipe_configs[i].type; 1434 1435 if (USB_ENDPOINT_XFER_CONTROL == pipe_configs[i].type) { 1436 pipe = usbhs_dcp_malloc(priv); 1437 usbhsh_hpriv_to_dcp(hpriv) = pipe; 1438 } else { 1439 pipe = usbhs_pipe_malloc(priv, 1440 pipe_configs[i].type, 1441 dir_in); 1442 } 1443 1444 pipe->mod_private = NULL; 1445 } 1446 } 1447 1448 static int usbhsh_start(struct usbhs_priv *priv) 1449 { 1450 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv); 1451 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv); 1452 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 1453 struct device *dev = usbhs_priv_to_dev(priv); 1454 int ret; 1455 1456 /* add hcd */ 1457 ret = usb_add_hcd(hcd, 0, 0); 1458 if (ret < 0) 1459 return 0; 1460 device_wakeup_enable(hcd->self.controller); 1461 1462 /* 1463 * pipe initialize and enable DCP 1464 */ 1465 usbhs_fifo_init(priv); 1466 usbhs_pipe_init(priv, 1467 usbhsh_dma_map_ctrl); 1468 usbhsh_pipe_init_for_host(priv); 1469 1470 /* 1471 * system config enble 1472 * - HI speed 1473 * - host 1474 * - usb module 1475 */ 1476 usbhs_sys_host_ctrl(priv, 1); 1477 1478 /* 1479 * enable irq callback 1480 */ 1481 mod->irq_attch = usbhsh_irq_attch; 1482 mod->irq_dtch = usbhsh_irq_dtch; 1483 mod->irq_sack = usbhsh_irq_setup_ack; 1484 mod->irq_sign = usbhsh_irq_setup_err; 1485 usbhs_irq_callback_update(priv, mod); 1486 1487 dev_dbg(dev, "start host\n"); 1488 1489 return ret; 1490 } 1491 1492 static int usbhsh_stop(struct usbhs_priv *priv) 1493 { 1494 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv); 1495 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv); 1496 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 1497 struct device *dev = usbhs_priv_to_dev(priv); 1498 1499 /* 1500 * disable irq callback 1501 */ 1502 mod->irq_attch = NULL; 1503 mod->irq_dtch = NULL; 1504 mod->irq_sack = NULL; 1505 mod->irq_sign = NULL; 1506 usbhs_irq_callback_update(priv, mod); 1507 1508 usb_remove_hcd(hcd); 1509 1510 /* disable sys */ 1511 usbhs_sys_host_ctrl(priv, 0); 1512 1513 dev_dbg(dev, "quit host\n"); 1514 1515 return 0; 1516 } 1517 1518 int usbhs_mod_host_probe(struct usbhs_priv *priv) 1519 { 1520 struct usbhsh_hpriv *hpriv; 1521 struct usb_hcd *hcd; 1522 struct usbhsh_device *udev; 1523 struct device *dev = usbhs_priv_to_dev(priv); 1524 int i; 1525 1526 /* initialize hcd */ 1527 hcd = usb_create_hcd(&usbhsh_driver, dev, usbhsh_hcd_name); 1528 if (!hcd) { 1529 dev_err(dev, "Failed to create hcd\n"); 1530 return -ENOMEM; 1531 } 1532 hcd->has_tt = 1; /* for low/full speed */ 1533 1534 /* 1535 * CAUTION 1536 * 1537 * There is no guarantee that it is possible to access usb module here. 1538 * Don't accesses to it. 1539 * The accesse will be enable after "usbhsh_start" 1540 */ 1541 1542 hpriv = usbhsh_hcd_to_hpriv(hcd); 1543 1544 /* 1545 * register itself 1546 */ 1547 usbhs_mod_register(priv, &hpriv->mod, USBHS_HOST); 1548 1549 /* init hpriv */ 1550 hpriv->mod.name = "host"; 1551 hpriv->mod.start = usbhsh_start; 1552 hpriv->mod.stop = usbhsh_stop; 1553 usbhsh_port_stat_init(hpriv); 1554 1555 /* init all device */ 1556 usbhsh_for_each_udev_with_dev0(udev, hpriv, i) { 1557 udev->usbv = NULL; 1558 INIT_LIST_HEAD(&udev->ep_list_head); 1559 } 1560 1561 dev_info(dev, "host probed\n"); 1562 1563 return 0; 1564 } 1565 1566 int usbhs_mod_host_remove(struct usbhs_priv *priv) 1567 { 1568 struct usbhsh_hpriv *hpriv = usbhsh_priv_to_hpriv(priv); 1569 struct usb_hcd *hcd = usbhsh_hpriv_to_hcd(hpriv); 1570 1571 usb_put_hcd(hcd); 1572 1573 return 0; 1574 } 1575