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/slab.h> 19 #include "common.h" 20 #include "pipe.h" 21 22 /* 23 * macros 24 */ 25 #define usbhsp_addr_offset(p) ((usbhs_pipe_number(p) - 1) * 2) 26 27 #define usbhsp_flags_set(p, f) ((p)->flags |= USBHS_PIPE_FLAGS_##f) 28 #define usbhsp_flags_clr(p, f) ((p)->flags &= ~USBHS_PIPE_FLAGS_##f) 29 #define usbhsp_flags_has(p, f) ((p)->flags & USBHS_PIPE_FLAGS_##f) 30 #define usbhsp_flags_init(p) do {(p)->flags = 0; } while (0) 31 32 /* 33 * for debug 34 */ 35 static char *usbhsp_pipe_name[] = { 36 [USB_ENDPOINT_XFER_CONTROL] = "DCP", 37 [USB_ENDPOINT_XFER_BULK] = "BULK", 38 [USB_ENDPOINT_XFER_INT] = "INT", 39 [USB_ENDPOINT_XFER_ISOC] = "ISO", 40 }; 41 42 char *usbhs_pipe_name(struct usbhs_pipe *pipe) 43 { 44 return usbhsp_pipe_name[usbhs_pipe_type(pipe)]; 45 } 46 47 static struct renesas_usbhs_driver_pipe_config 48 *usbhsp_get_pipe_config(struct usbhs_priv *priv, int pipe_num) 49 { 50 struct renesas_usbhs_driver_pipe_config *pipe_configs = 51 usbhs_get_dparam(priv, pipe_configs); 52 53 return &pipe_configs[pipe_num]; 54 } 55 56 /* 57 * DCPCTR/PIPEnCTR functions 58 */ 59 static void usbhsp_pipectrl_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 60 { 61 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 62 int offset = usbhsp_addr_offset(pipe); 63 64 if (usbhs_pipe_is_dcp(pipe)) 65 usbhs_bset(priv, DCPCTR, mask, val); 66 else 67 usbhs_bset(priv, PIPEnCTR + offset, mask, val); 68 } 69 70 static u16 usbhsp_pipectrl_get(struct usbhs_pipe *pipe) 71 { 72 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 73 int offset = usbhsp_addr_offset(pipe); 74 75 if (usbhs_pipe_is_dcp(pipe)) 76 return usbhs_read(priv, DCPCTR); 77 else 78 return usbhs_read(priv, PIPEnCTR + offset); 79 } 80 81 /* 82 * DCP/PIPE functions 83 */ 84 static void __usbhsp_pipe_xxx_set(struct usbhs_pipe *pipe, 85 u16 dcp_reg, u16 pipe_reg, 86 u16 mask, u16 val) 87 { 88 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 89 90 if (usbhs_pipe_is_dcp(pipe)) 91 usbhs_bset(priv, dcp_reg, mask, val); 92 else 93 usbhs_bset(priv, pipe_reg, mask, val); 94 } 95 96 static u16 __usbhsp_pipe_xxx_get(struct usbhs_pipe *pipe, 97 u16 dcp_reg, u16 pipe_reg) 98 { 99 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 100 101 if (usbhs_pipe_is_dcp(pipe)) 102 return usbhs_read(priv, dcp_reg); 103 else 104 return usbhs_read(priv, pipe_reg); 105 } 106 107 /* 108 * DCPCFG/PIPECFG functions 109 */ 110 static void usbhsp_pipe_cfg_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 111 { 112 __usbhsp_pipe_xxx_set(pipe, DCPCFG, PIPECFG, mask, val); 113 } 114 115 static u16 usbhsp_pipe_cfg_get(struct usbhs_pipe *pipe) 116 { 117 return __usbhsp_pipe_xxx_get(pipe, DCPCFG, PIPECFG); 118 } 119 120 /* 121 * PIPEnTRN/PIPEnTRE functions 122 */ 123 static void usbhsp_pipe_trn_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 124 { 125 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 126 struct device *dev = usbhs_priv_to_dev(priv); 127 int num = usbhs_pipe_number(pipe); 128 u16 reg; 129 130 /* 131 * It is impossible to calculate address, 132 * since PIPEnTRN addresses were mapped randomly. 133 */ 134 #define CASE_PIPExTRN(a) \ 135 case 0x ## a: \ 136 reg = PIPE ## a ## TRN; \ 137 break; 138 139 switch (num) { 140 CASE_PIPExTRN(1); 141 CASE_PIPExTRN(2); 142 CASE_PIPExTRN(3); 143 CASE_PIPExTRN(4); 144 CASE_PIPExTRN(5); 145 CASE_PIPExTRN(B); 146 CASE_PIPExTRN(C); 147 CASE_PIPExTRN(D); 148 CASE_PIPExTRN(E); 149 CASE_PIPExTRN(F); 150 CASE_PIPExTRN(9); 151 CASE_PIPExTRN(A); 152 default: 153 dev_err(dev, "unknown pipe (%d)\n", num); 154 return; 155 } 156 __usbhsp_pipe_xxx_set(pipe, 0, reg, mask, val); 157 } 158 159 static void usbhsp_pipe_tre_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 160 { 161 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 162 struct device *dev = usbhs_priv_to_dev(priv); 163 int num = usbhs_pipe_number(pipe); 164 u16 reg; 165 166 /* 167 * It is impossible to calculate address, 168 * since PIPEnTRE addresses were mapped randomly. 169 */ 170 #define CASE_PIPExTRE(a) \ 171 case 0x ## a: \ 172 reg = PIPE ## a ## TRE; \ 173 break; 174 175 switch (num) { 176 CASE_PIPExTRE(1); 177 CASE_PIPExTRE(2); 178 CASE_PIPExTRE(3); 179 CASE_PIPExTRE(4); 180 CASE_PIPExTRE(5); 181 CASE_PIPExTRE(B); 182 CASE_PIPExTRE(C); 183 CASE_PIPExTRE(D); 184 CASE_PIPExTRE(E); 185 CASE_PIPExTRE(F); 186 CASE_PIPExTRE(9); 187 CASE_PIPExTRE(A); 188 default: 189 dev_err(dev, "unknown pipe (%d)\n", num); 190 return; 191 } 192 193 __usbhsp_pipe_xxx_set(pipe, 0, reg, mask, val); 194 } 195 196 /* 197 * PIPEBUF 198 */ 199 static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 200 { 201 if (usbhs_pipe_is_dcp(pipe)) 202 return; 203 204 __usbhsp_pipe_xxx_set(pipe, 0, PIPEBUF, mask, val); 205 } 206 207 /* 208 * DCPMAXP/PIPEMAXP 209 */ 210 static void usbhsp_pipe_maxp_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 211 { 212 __usbhsp_pipe_xxx_set(pipe, DCPMAXP, PIPEMAXP, mask, val); 213 } 214 215 /* 216 * pipe control functions 217 */ 218 static void usbhsp_pipe_select(struct usbhs_pipe *pipe) 219 { 220 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 221 222 /* 223 * On pipe, this is necessary before 224 * accesses to below registers. 225 * 226 * PIPESEL : usbhsp_pipe_select 227 * PIPECFG : usbhsp_pipe_cfg_xxx 228 * PIPEBUF : usbhsp_pipe_buf_xxx 229 * PIPEMAXP : usbhsp_pipe_maxp_xxx 230 * PIPEPERI 231 */ 232 233 /* 234 * if pipe is dcp, no pipe is selected. 235 * it is no problem, because dcp have its register 236 */ 237 usbhs_write(priv, PIPESEL, 0xF & usbhs_pipe_number(pipe)); 238 } 239 240 static int usbhsp_pipe_barrier(struct usbhs_pipe *pipe) 241 { 242 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 243 int timeout = 1024; 244 u16 val; 245 246 /* 247 * make sure.... 248 * 249 * Modify these bits when CSSTS = 0, PID = NAK, and no pipe number is 250 * specified by the CURPIPE bits. 251 * When changing the setting of this bit after changing 252 * the PID bits for the selected pipe from BUF to NAK, 253 * check that CSSTS = 0 and PBUSY = 0. 254 */ 255 256 /* 257 * CURPIPE bit = 0 258 * 259 * see also 260 * "Operation" 261 * - "Pipe Control" 262 * - "Pipe Control Registers Switching Procedure" 263 */ 264 usbhs_write(priv, CFIFOSEL, 0); 265 usbhs_pipe_disable(pipe); 266 267 do { 268 val = usbhsp_pipectrl_get(pipe); 269 val &= CSSTS | PID_MASK; 270 if (!val) 271 return 0; 272 273 udelay(10); 274 275 } while (timeout--); 276 277 return -EBUSY; 278 } 279 280 int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe) 281 { 282 u16 val; 283 284 val = usbhsp_pipectrl_get(pipe); 285 if (val & BSTS) 286 return 0; 287 288 return -EBUSY; 289 } 290 291 /* 292 * PID ctrl 293 */ 294 static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe) 295 { 296 u16 pid = usbhsp_pipectrl_get(pipe); 297 298 pid &= PID_MASK; 299 300 /* 301 * see 302 * "Pipe n Control Register" - "PID" 303 */ 304 switch (pid) { 305 case PID_STALL11: 306 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10); 307 /* fall-through */ 308 case PID_STALL10: 309 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK); 310 } 311 } 312 313 void usbhs_pipe_disable(struct usbhs_pipe *pipe) 314 { 315 int timeout = 1024; 316 u16 val; 317 318 /* see "Pipe n Control Register" - "PID" */ 319 __usbhsp_pid_try_nak_if_stall(pipe); 320 321 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK); 322 323 do { 324 val = usbhsp_pipectrl_get(pipe); 325 val &= PBUSY; 326 if (!val) 327 break; 328 329 udelay(10); 330 } while (timeout--); 331 } 332 333 void usbhs_pipe_enable(struct usbhs_pipe *pipe) 334 { 335 /* see "Pipe n Control Register" - "PID" */ 336 __usbhsp_pid_try_nak_if_stall(pipe); 337 338 usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF); 339 } 340 341 void usbhs_pipe_stall(struct usbhs_pipe *pipe) 342 { 343 u16 pid = usbhsp_pipectrl_get(pipe); 344 345 pid &= PID_MASK; 346 347 /* 348 * see 349 * "Pipe n Control Register" - "PID" 350 */ 351 switch (pid) { 352 case PID_NAK: 353 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10); 354 break; 355 case PID_BUF: 356 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11); 357 break; 358 } 359 } 360 361 int usbhs_pipe_is_stall(struct usbhs_pipe *pipe) 362 { 363 u16 pid = usbhsp_pipectrl_get(pipe) & PID_MASK; 364 365 return (int)(pid == PID_STALL10 || pid == PID_STALL11); 366 } 367 368 void usbhs_pipe_set_trans_count_if_bulk(struct usbhs_pipe *pipe, int len) 369 { 370 if (!usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 371 return; 372 373 /* 374 * clear and disable transfer counter for IN/OUT pipe 375 */ 376 usbhsp_pipe_tre_set(pipe, TRCLR | TRENB, TRCLR); 377 378 /* 379 * Only IN direction bulk pipe can use transfer count. 380 * Without using this function, 381 * received data will break if it was large data size. 382 * see PIPEnTRN/PIPEnTRE for detail 383 */ 384 if (usbhs_pipe_is_dir_in(pipe)) { 385 int maxp = usbhs_pipe_get_maxpacket(pipe); 386 387 usbhsp_pipe_trn_set(pipe, 0xffff, DIV_ROUND_UP(len, maxp)); 388 usbhsp_pipe_tre_set(pipe, TRENB, TRENB); /* enable */ 389 } 390 } 391 392 393 /* 394 * pipe setup 395 */ 396 static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe, 397 int is_host, 398 int dir_in) 399 { 400 u16 type = 0; 401 u16 bfre = 0; 402 u16 dblb = 0; 403 u16 cntmd = 0; 404 u16 dir = 0; 405 u16 epnum = 0; 406 u16 shtnak = 0; 407 u16 type_array[] = { 408 [USB_ENDPOINT_XFER_BULK] = TYPE_BULK, 409 [USB_ENDPOINT_XFER_INT] = TYPE_INT, 410 [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO, 411 }; 412 413 if (usbhs_pipe_is_dcp(pipe)) 414 return -EINVAL; 415 416 /* 417 * PIPECFG 418 * 419 * see 420 * - "Register Descriptions" - "PIPECFG" register 421 * - "Features" - "Pipe configuration" 422 * - "Operation" - "Pipe Control" 423 */ 424 425 /* TYPE */ 426 type = type_array[usbhs_pipe_type(pipe)]; 427 428 /* BFRE */ 429 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) || 430 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 431 bfre = 0; /* FIXME */ 432 433 /* DBLB: see usbhs_pipe_config_update() */ 434 435 /* CNTMD */ 436 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 437 cntmd = 0; /* FIXME */ 438 439 /* DIR */ 440 if (dir_in) 441 usbhsp_flags_set(pipe, IS_DIR_HOST); 442 443 if (!!is_host ^ !!dir_in) 444 dir |= DIR_OUT; 445 446 if (!dir) 447 usbhsp_flags_set(pipe, IS_DIR_IN); 448 449 /* SHTNAK */ 450 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) && 451 !dir) 452 shtnak = SHTNAK; 453 454 /* EPNUM */ 455 epnum = 0; /* see usbhs_pipe_config_update() */ 456 457 return type | 458 bfre | 459 dblb | 460 cntmd | 461 dir | 462 shtnak | 463 epnum; 464 } 465 466 static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe) 467 { 468 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 469 struct device *dev = usbhs_priv_to_dev(priv); 470 int pipe_num = usbhs_pipe_number(pipe); 471 u16 buff_size; 472 u16 bufnmb; 473 u16 bufnmb_cnt; 474 struct renesas_usbhs_driver_pipe_config *pipe_config = 475 usbhsp_get_pipe_config(priv, pipe_num); 476 477 /* 478 * PIPEBUF 479 * 480 * see 481 * - "Register Descriptions" - "PIPEBUF" register 482 * - "Features" - "Pipe configuration" 483 * - "Operation" - "FIFO Buffer Memory" 484 * - "Operation" - "Pipe Control" 485 */ 486 buff_size = pipe_config->bufsize; 487 bufnmb = pipe_config->bufnum; 488 489 /* change buff_size to register value */ 490 bufnmb_cnt = (buff_size / 64) - 1; 491 492 dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n", 493 pipe_num, buff_size, bufnmb); 494 495 return (0x1f & bufnmb_cnt) << 10 | 496 (0xff & bufnmb) << 0; 497 } 498 499 void usbhs_pipe_config_update(struct usbhs_pipe *pipe, u16 devsel, 500 u16 epnum, u16 maxp) 501 { 502 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 503 int pipe_num = usbhs_pipe_number(pipe); 504 struct renesas_usbhs_driver_pipe_config *pipe_config = 505 usbhsp_get_pipe_config(priv, pipe_num); 506 u16 dblb = pipe_config->double_buf ? DBLB : 0; 507 508 if (devsel > 0xA) { 509 struct device *dev = usbhs_priv_to_dev(priv); 510 511 dev_err(dev, "devsel error %d\n", devsel); 512 513 devsel = 0; 514 } 515 516 usbhsp_pipe_barrier(pipe); 517 518 pipe->maxp = maxp; 519 520 usbhsp_pipe_select(pipe); 521 usbhsp_pipe_maxp_set(pipe, 0xFFFF, 522 (devsel << 12) | 523 maxp); 524 525 if (!usbhs_pipe_is_dcp(pipe)) 526 usbhsp_pipe_cfg_set(pipe, 0x000F | DBLB, epnum | dblb); 527 } 528 529 /* 530 * pipe control 531 */ 532 int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe) 533 { 534 /* 535 * see 536 * usbhs_pipe_config_update() 537 * usbhs_dcp_malloc() 538 */ 539 return pipe->maxp; 540 } 541 542 int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe) 543 { 544 return usbhsp_flags_has(pipe, IS_DIR_IN); 545 } 546 547 int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe) 548 { 549 return usbhsp_flags_has(pipe, IS_DIR_HOST); 550 } 551 552 int usbhs_pipe_is_running(struct usbhs_pipe *pipe) 553 { 554 return usbhsp_flags_has(pipe, IS_RUNNING); 555 } 556 557 void usbhs_pipe_running(struct usbhs_pipe *pipe, int running) 558 { 559 if (running) 560 usbhsp_flags_set(pipe, IS_RUNNING); 561 else 562 usbhsp_flags_clr(pipe, IS_RUNNING); 563 } 564 565 void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence) 566 { 567 u16 mask = (SQCLR | SQSET); 568 u16 val; 569 570 /* 571 * sequence 572 * 0 : data0 573 * 1 : data1 574 * -1 : no change 575 */ 576 switch (sequence) { 577 case 0: 578 val = SQCLR; 579 break; 580 case 1: 581 val = SQSET; 582 break; 583 default: 584 return; 585 } 586 587 usbhsp_pipectrl_set(pipe, mask, val); 588 } 589 590 static int usbhs_pipe_get_data_sequence(struct usbhs_pipe *pipe) 591 { 592 return !!(usbhsp_pipectrl_get(pipe) & SQMON); 593 } 594 595 void usbhs_pipe_clear(struct usbhs_pipe *pipe) 596 { 597 if (usbhs_pipe_is_dcp(pipe)) { 598 usbhs_fifo_clear_dcp(pipe); 599 } else { 600 usbhsp_pipectrl_set(pipe, ACLRM, ACLRM); 601 usbhsp_pipectrl_set(pipe, ACLRM, 0); 602 } 603 } 604 605 void usbhs_pipe_config_change_bfre(struct usbhs_pipe *pipe, int enable) 606 { 607 int sequence; 608 609 if (usbhs_pipe_is_dcp(pipe)) 610 return; 611 612 usbhsp_pipe_select(pipe); 613 /* check if the driver needs to change the BFRE value */ 614 if (!(enable ^ !!(usbhsp_pipe_cfg_get(pipe) & BFRE))) 615 return; 616 617 sequence = usbhs_pipe_get_data_sequence(pipe); 618 usbhsp_pipe_cfg_set(pipe, BFRE, enable ? BFRE : 0); 619 usbhs_pipe_clear(pipe); 620 usbhs_pipe_data_sequence(pipe, sequence); 621 } 622 623 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type) 624 { 625 struct usbhs_pipe *pos, *pipe; 626 int i; 627 628 /* 629 * find target pipe 630 */ 631 pipe = NULL; 632 usbhs_for_each_pipe_with_dcp(pos, priv, i) { 633 if (!usbhs_pipe_type_is(pos, type)) 634 continue; 635 if (usbhsp_flags_has(pos, IS_USED)) 636 continue; 637 638 pipe = pos; 639 break; 640 } 641 642 if (!pipe) 643 return NULL; 644 645 /* 646 * initialize pipe flags 647 */ 648 usbhsp_flags_init(pipe); 649 usbhsp_flags_set(pipe, IS_USED); 650 651 return pipe; 652 } 653 654 static void usbhsp_put_pipe(struct usbhs_pipe *pipe) 655 { 656 usbhsp_flags_init(pipe); 657 } 658 659 void usbhs_pipe_init(struct usbhs_priv *priv, 660 int (*dma_map_ctrl)(struct usbhs_pkt *pkt, int map)) 661 { 662 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 663 struct usbhs_pipe *pipe; 664 int i; 665 666 usbhs_for_each_pipe_with_dcp(pipe, priv, i) { 667 usbhsp_flags_init(pipe); 668 pipe->fifo = NULL; 669 pipe->mod_private = NULL; 670 INIT_LIST_HEAD(&pipe->list); 671 672 /* pipe force init */ 673 usbhs_pipe_clear(pipe); 674 } 675 676 info->dma_map_ctrl = dma_map_ctrl; 677 } 678 679 struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv, 680 int endpoint_type, 681 int dir_in) 682 { 683 struct device *dev = usbhs_priv_to_dev(priv); 684 struct usbhs_pipe *pipe; 685 int is_host = usbhs_mod_is_host(priv); 686 int ret; 687 u16 pipecfg, pipebuf; 688 689 pipe = usbhsp_get_pipe(priv, endpoint_type); 690 if (!pipe) { 691 dev_err(dev, "can't get pipe (%s)\n", 692 usbhsp_pipe_name[endpoint_type]); 693 return NULL; 694 } 695 696 INIT_LIST_HEAD(&pipe->list); 697 698 usbhs_pipe_disable(pipe); 699 700 /* make sure pipe is not busy */ 701 ret = usbhsp_pipe_barrier(pipe); 702 if (ret < 0) { 703 dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe)); 704 return NULL; 705 } 706 707 pipecfg = usbhsp_setup_pipecfg(pipe, is_host, dir_in); 708 pipebuf = usbhsp_setup_pipebuff(pipe); 709 710 usbhsp_pipe_select(pipe); 711 usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg); 712 usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf); 713 usbhs_pipe_clear(pipe); 714 715 usbhs_pipe_sequence_data0(pipe); 716 717 dev_dbg(dev, "enable pipe %d : %s (%s)\n", 718 usbhs_pipe_number(pipe), 719 usbhs_pipe_name(pipe), 720 usbhs_pipe_is_dir_in(pipe) ? "in" : "out"); 721 722 /* 723 * epnum / maxp are still not set to this pipe. 724 * call usbhs_pipe_config_update() after this function !! 725 */ 726 727 return pipe; 728 } 729 730 void usbhs_pipe_free(struct usbhs_pipe *pipe) 731 { 732 usbhsp_put_pipe(pipe); 733 } 734 735 void usbhs_pipe_select_fifo(struct usbhs_pipe *pipe, struct usbhs_fifo *fifo) 736 { 737 if (pipe->fifo) 738 pipe->fifo->pipe = NULL; 739 740 pipe->fifo = fifo; 741 742 if (fifo) 743 fifo->pipe = pipe; 744 } 745 746 747 /* 748 * dcp control 749 */ 750 struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv) 751 { 752 struct usbhs_pipe *pipe; 753 754 pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL); 755 if (!pipe) 756 return NULL; 757 758 INIT_LIST_HEAD(&pipe->list); 759 760 /* 761 * call usbhs_pipe_config_update() after this function !! 762 */ 763 764 return pipe; 765 } 766 767 void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe) 768 { 769 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 770 771 WARN_ON(!usbhs_pipe_is_dcp(pipe)); 772 773 usbhs_pipe_enable(pipe); 774 775 if (!usbhs_mod_is_host(priv)) /* funconly */ 776 usbhsp_pipectrl_set(pipe, CCPL, CCPL); 777 } 778 779 void usbhs_dcp_dir_for_host(struct usbhs_pipe *pipe, int dir_out) 780 { 781 usbhsp_pipe_cfg_set(pipe, DIR_OUT, 782 dir_out ? DIR_OUT : 0); 783 } 784 785 /* 786 * pipe module function 787 */ 788 int usbhs_pipe_probe(struct usbhs_priv *priv) 789 { 790 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 791 struct usbhs_pipe *pipe; 792 struct device *dev = usbhs_priv_to_dev(priv); 793 struct renesas_usbhs_driver_pipe_config *pipe_configs = 794 usbhs_get_dparam(priv, pipe_configs); 795 int pipe_size = usbhs_get_dparam(priv, pipe_size); 796 int i; 797 798 /* This driver expects 1st pipe is DCP */ 799 if (pipe_configs[0].type != USB_ENDPOINT_XFER_CONTROL) { 800 dev_err(dev, "1st PIPE is not DCP\n"); 801 return -EINVAL; 802 } 803 804 info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL); 805 if (!info->pipe) { 806 dev_err(dev, "Could not allocate pipe\n"); 807 return -ENOMEM; 808 } 809 810 info->size = pipe_size; 811 812 /* 813 * init pipe 814 */ 815 usbhs_for_each_pipe_with_dcp(pipe, priv, i) { 816 pipe->priv = priv; 817 818 usbhs_pipe_type(pipe) = 819 pipe_configs[i].type & USB_ENDPOINT_XFERTYPE_MASK; 820 821 dev_dbg(dev, "pipe %x\t: %s\n", 822 i, usbhsp_pipe_name[pipe_configs[i].type]); 823 } 824 825 return 0; 826 } 827 828 void usbhs_pipe_remove(struct usbhs_priv *priv) 829 { 830 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 831 832 kfree(info->pipe); 833 } 834