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