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 mask = usbhs_mod_is_host(priv) ? (CSSTS | PID_MASK) : PID_MASK; 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 if (!(usbhsp_pipectrl_get(pipe) & mask)) 269 return 0; 270 271 udelay(10); 272 273 } while (timeout--); 274 275 return -EBUSY; 276 } 277 278 int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe) 279 { 280 u16 val; 281 282 val = usbhsp_pipectrl_get(pipe); 283 if (val & BSTS) 284 return 0; 285 286 return -EBUSY; 287 } 288 289 /* 290 * PID ctrl 291 */ 292 static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe) 293 { 294 u16 pid = usbhsp_pipectrl_get(pipe); 295 296 pid &= PID_MASK; 297 298 /* 299 * see 300 * "Pipe n Control Register" - "PID" 301 */ 302 switch (pid) { 303 case PID_STALL11: 304 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10); 305 /* fall-through */ 306 case PID_STALL10: 307 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK); 308 } 309 } 310 311 void usbhs_pipe_disable(struct usbhs_pipe *pipe) 312 { 313 int timeout = 1024; 314 u16 val; 315 316 /* see "Pipe n Control Register" - "PID" */ 317 __usbhsp_pid_try_nak_if_stall(pipe); 318 319 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK); 320 321 do { 322 val = usbhsp_pipectrl_get(pipe); 323 val &= PBUSY; 324 if (!val) 325 break; 326 327 udelay(10); 328 } while (timeout--); 329 } 330 331 void usbhs_pipe_enable(struct usbhs_pipe *pipe) 332 { 333 /* see "Pipe n Control Register" - "PID" */ 334 __usbhsp_pid_try_nak_if_stall(pipe); 335 336 usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF); 337 } 338 339 void usbhs_pipe_stall(struct usbhs_pipe *pipe) 340 { 341 u16 pid = usbhsp_pipectrl_get(pipe); 342 343 pid &= PID_MASK; 344 345 /* 346 * see 347 * "Pipe n Control Register" - "PID" 348 */ 349 switch (pid) { 350 case PID_NAK: 351 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10); 352 break; 353 case PID_BUF: 354 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11); 355 break; 356 } 357 } 358 359 int usbhs_pipe_is_stall(struct usbhs_pipe *pipe) 360 { 361 u16 pid = usbhsp_pipectrl_get(pipe) & PID_MASK; 362 363 return (int)(pid == PID_STALL10 || pid == PID_STALL11); 364 } 365 366 void usbhs_pipe_set_trans_count_if_bulk(struct usbhs_pipe *pipe, int len) 367 { 368 if (!usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 369 return; 370 371 /* 372 * clear and disable transfer counter for IN/OUT pipe 373 */ 374 usbhsp_pipe_tre_set(pipe, TRCLR | TRENB, TRCLR); 375 376 /* 377 * Only IN direction bulk pipe can use transfer count. 378 * Without using this function, 379 * received data will break if it was large data size. 380 * see PIPEnTRN/PIPEnTRE for detail 381 */ 382 if (usbhs_pipe_is_dir_in(pipe)) { 383 int maxp = usbhs_pipe_get_maxpacket(pipe); 384 385 usbhsp_pipe_trn_set(pipe, 0xffff, DIV_ROUND_UP(len, maxp)); 386 usbhsp_pipe_tre_set(pipe, TRENB, TRENB); /* enable */ 387 } 388 } 389 390 391 /* 392 * pipe setup 393 */ 394 static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe, 395 int is_host, 396 int dir_in) 397 { 398 u16 type = 0; 399 u16 bfre = 0; 400 u16 dblb = 0; 401 u16 cntmd = 0; 402 u16 dir = 0; 403 u16 epnum = 0; 404 u16 shtnak = 0; 405 u16 type_array[] = { 406 [USB_ENDPOINT_XFER_BULK] = TYPE_BULK, 407 [USB_ENDPOINT_XFER_INT] = TYPE_INT, 408 [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO, 409 }; 410 411 if (usbhs_pipe_is_dcp(pipe)) 412 return -EINVAL; 413 414 /* 415 * PIPECFG 416 * 417 * see 418 * - "Register Descriptions" - "PIPECFG" register 419 * - "Features" - "Pipe configuration" 420 * - "Operation" - "Pipe Control" 421 */ 422 423 /* TYPE */ 424 type = type_array[usbhs_pipe_type(pipe)]; 425 426 /* BFRE */ 427 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) || 428 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 429 bfre = 0; /* FIXME */ 430 431 /* DBLB: see usbhs_pipe_config_update() */ 432 433 /* CNTMD */ 434 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 435 cntmd = 0; /* FIXME */ 436 437 /* DIR */ 438 if (dir_in) 439 usbhsp_flags_set(pipe, IS_DIR_HOST); 440 441 if (!!is_host ^ !!dir_in) 442 dir |= DIR_OUT; 443 444 if (!dir) 445 usbhsp_flags_set(pipe, IS_DIR_IN); 446 447 /* SHTNAK */ 448 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) && 449 !dir) 450 shtnak = SHTNAK; 451 452 /* EPNUM */ 453 epnum = 0; /* see usbhs_pipe_config_update() */ 454 455 return type | 456 bfre | 457 dblb | 458 cntmd | 459 dir | 460 shtnak | 461 epnum; 462 } 463 464 static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe) 465 { 466 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 467 struct device *dev = usbhs_priv_to_dev(priv); 468 int pipe_num = usbhs_pipe_number(pipe); 469 u16 buff_size; 470 u16 bufnmb; 471 u16 bufnmb_cnt; 472 struct renesas_usbhs_driver_pipe_config *pipe_config = 473 usbhsp_get_pipe_config(priv, pipe_num); 474 475 /* 476 * PIPEBUF 477 * 478 * see 479 * - "Register Descriptions" - "PIPEBUF" register 480 * - "Features" - "Pipe configuration" 481 * - "Operation" - "FIFO Buffer Memory" 482 * - "Operation" - "Pipe Control" 483 */ 484 buff_size = pipe_config->bufsize; 485 bufnmb = pipe_config->bufnum; 486 487 /* change buff_size to register value */ 488 bufnmb_cnt = (buff_size / 64) - 1; 489 490 dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n", 491 pipe_num, buff_size, bufnmb); 492 493 return (0x1f & bufnmb_cnt) << 10 | 494 (0xff & bufnmb) << 0; 495 } 496 497 void usbhs_pipe_config_update(struct usbhs_pipe *pipe, u16 devsel, 498 u16 epnum, u16 maxp) 499 { 500 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 501 int pipe_num = usbhs_pipe_number(pipe); 502 struct renesas_usbhs_driver_pipe_config *pipe_config = 503 usbhsp_get_pipe_config(priv, pipe_num); 504 u16 dblb = pipe_config->double_buf ? DBLB : 0; 505 506 if (devsel > 0xA) { 507 struct device *dev = usbhs_priv_to_dev(priv); 508 509 dev_err(dev, "devsel error %d\n", devsel); 510 511 devsel = 0; 512 } 513 514 usbhsp_pipe_barrier(pipe); 515 516 pipe->maxp = maxp; 517 518 usbhsp_pipe_select(pipe); 519 usbhsp_pipe_maxp_set(pipe, 0xFFFF, 520 (devsel << 12) | 521 maxp); 522 523 if (!usbhs_pipe_is_dcp(pipe)) 524 usbhsp_pipe_cfg_set(pipe, 0x000F | DBLB, epnum | dblb); 525 } 526 527 /* 528 * pipe control 529 */ 530 int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe) 531 { 532 /* 533 * see 534 * usbhs_pipe_config_update() 535 * usbhs_dcp_malloc() 536 */ 537 return pipe->maxp; 538 } 539 540 int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe) 541 { 542 return usbhsp_flags_has(pipe, IS_DIR_IN); 543 } 544 545 int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe) 546 { 547 return usbhsp_flags_has(pipe, IS_DIR_HOST); 548 } 549 550 int usbhs_pipe_is_running(struct usbhs_pipe *pipe) 551 { 552 return usbhsp_flags_has(pipe, IS_RUNNING); 553 } 554 555 void usbhs_pipe_running(struct usbhs_pipe *pipe, int running) 556 { 557 if (running) 558 usbhsp_flags_set(pipe, IS_RUNNING); 559 else 560 usbhsp_flags_clr(pipe, IS_RUNNING); 561 } 562 563 void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence) 564 { 565 u16 mask = (SQCLR | SQSET); 566 u16 val; 567 568 /* 569 * sequence 570 * 0 : data0 571 * 1 : data1 572 * -1 : no change 573 */ 574 switch (sequence) { 575 case 0: 576 val = SQCLR; 577 break; 578 case 1: 579 val = SQSET; 580 break; 581 default: 582 return; 583 } 584 585 usbhsp_pipectrl_set(pipe, mask, val); 586 } 587 588 static int usbhs_pipe_get_data_sequence(struct usbhs_pipe *pipe) 589 { 590 return !!(usbhsp_pipectrl_get(pipe) & SQMON); 591 } 592 593 void usbhs_pipe_clear(struct usbhs_pipe *pipe) 594 { 595 if (usbhs_pipe_is_dcp(pipe)) { 596 usbhs_fifo_clear_dcp(pipe); 597 } else { 598 usbhsp_pipectrl_set(pipe, ACLRM, ACLRM); 599 usbhsp_pipectrl_set(pipe, ACLRM, 0); 600 } 601 } 602 603 void usbhs_pipe_config_change_bfre(struct usbhs_pipe *pipe, int enable) 604 { 605 int sequence; 606 607 if (usbhs_pipe_is_dcp(pipe)) 608 return; 609 610 usbhsp_pipe_select(pipe); 611 /* check if the driver needs to change the BFRE value */ 612 if (!(enable ^ !!(usbhsp_pipe_cfg_get(pipe) & BFRE))) 613 return; 614 615 sequence = usbhs_pipe_get_data_sequence(pipe); 616 usbhsp_pipe_cfg_set(pipe, BFRE, enable ? BFRE : 0); 617 usbhs_pipe_clear(pipe); 618 usbhs_pipe_data_sequence(pipe, sequence); 619 } 620 621 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type) 622 { 623 struct usbhs_pipe *pos, *pipe; 624 int i; 625 626 /* 627 * find target pipe 628 */ 629 pipe = NULL; 630 usbhs_for_each_pipe_with_dcp(pos, priv, i) { 631 if (!usbhs_pipe_type_is(pos, type)) 632 continue; 633 if (usbhsp_flags_has(pos, IS_USED)) 634 continue; 635 636 pipe = pos; 637 break; 638 } 639 640 if (!pipe) 641 return NULL; 642 643 /* 644 * initialize pipe flags 645 */ 646 usbhsp_flags_init(pipe); 647 usbhsp_flags_set(pipe, IS_USED); 648 649 return pipe; 650 } 651 652 static void usbhsp_put_pipe(struct usbhs_pipe *pipe) 653 { 654 usbhsp_flags_init(pipe); 655 } 656 657 void usbhs_pipe_init(struct usbhs_priv *priv, 658 int (*dma_map_ctrl)(struct usbhs_pkt *pkt, int map)) 659 { 660 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 661 struct usbhs_pipe *pipe; 662 int i; 663 664 usbhs_for_each_pipe_with_dcp(pipe, priv, i) { 665 usbhsp_flags_init(pipe); 666 pipe->fifo = NULL; 667 pipe->mod_private = NULL; 668 INIT_LIST_HEAD(&pipe->list); 669 670 /* pipe force init */ 671 usbhs_pipe_clear(pipe); 672 } 673 674 info->dma_map_ctrl = dma_map_ctrl; 675 } 676 677 struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv, 678 int endpoint_type, 679 int dir_in) 680 { 681 struct device *dev = usbhs_priv_to_dev(priv); 682 struct usbhs_pipe *pipe; 683 int is_host = usbhs_mod_is_host(priv); 684 int ret; 685 u16 pipecfg, pipebuf; 686 687 pipe = usbhsp_get_pipe(priv, endpoint_type); 688 if (!pipe) { 689 dev_err(dev, "can't get pipe (%s)\n", 690 usbhsp_pipe_name[endpoint_type]); 691 return NULL; 692 } 693 694 INIT_LIST_HEAD(&pipe->list); 695 696 usbhs_pipe_disable(pipe); 697 698 /* make sure pipe is not busy */ 699 ret = usbhsp_pipe_barrier(pipe); 700 if (ret < 0) { 701 dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe)); 702 return NULL; 703 } 704 705 pipecfg = usbhsp_setup_pipecfg(pipe, is_host, dir_in); 706 pipebuf = usbhsp_setup_pipebuff(pipe); 707 708 usbhsp_pipe_select(pipe); 709 usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg); 710 usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf); 711 usbhs_pipe_clear(pipe); 712 713 usbhs_pipe_sequence_data0(pipe); 714 715 dev_dbg(dev, "enable pipe %d : %s (%s)\n", 716 usbhs_pipe_number(pipe), 717 usbhs_pipe_name(pipe), 718 usbhs_pipe_is_dir_in(pipe) ? "in" : "out"); 719 720 /* 721 * epnum / maxp are still not set to this pipe. 722 * call usbhs_pipe_config_update() after this function !! 723 */ 724 725 return pipe; 726 } 727 728 void usbhs_pipe_free(struct usbhs_pipe *pipe) 729 { 730 usbhsp_put_pipe(pipe); 731 } 732 733 void usbhs_pipe_select_fifo(struct usbhs_pipe *pipe, struct usbhs_fifo *fifo) 734 { 735 if (pipe->fifo) 736 pipe->fifo->pipe = NULL; 737 738 pipe->fifo = fifo; 739 740 if (fifo) 741 fifo->pipe = pipe; 742 } 743 744 745 /* 746 * dcp control 747 */ 748 struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv) 749 { 750 struct usbhs_pipe *pipe; 751 752 pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL); 753 if (!pipe) 754 return NULL; 755 756 INIT_LIST_HEAD(&pipe->list); 757 758 /* 759 * call usbhs_pipe_config_update() after this function !! 760 */ 761 762 return pipe; 763 } 764 765 void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe) 766 { 767 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 768 769 WARN_ON(!usbhs_pipe_is_dcp(pipe)); 770 771 usbhs_pipe_enable(pipe); 772 773 if (!usbhs_mod_is_host(priv)) /* funconly */ 774 usbhsp_pipectrl_set(pipe, CCPL, CCPL); 775 } 776 777 void usbhs_dcp_dir_for_host(struct usbhs_pipe *pipe, int dir_out) 778 { 779 usbhsp_pipe_cfg_set(pipe, DIR_OUT, 780 dir_out ? DIR_OUT : 0); 781 } 782 783 /* 784 * pipe module function 785 */ 786 int usbhs_pipe_probe(struct usbhs_priv *priv) 787 { 788 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 789 struct usbhs_pipe *pipe; 790 struct device *dev = usbhs_priv_to_dev(priv); 791 struct renesas_usbhs_driver_pipe_config *pipe_configs = 792 usbhs_get_dparam(priv, pipe_configs); 793 int pipe_size = usbhs_get_dparam(priv, pipe_size); 794 int i; 795 796 /* This driver expects 1st pipe is DCP */ 797 if (pipe_configs[0].type != USB_ENDPOINT_XFER_CONTROL) { 798 dev_err(dev, "1st PIPE is not DCP\n"); 799 return -EINVAL; 800 } 801 802 info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL); 803 if (!info->pipe) { 804 dev_err(dev, "Could not allocate pipe\n"); 805 return -ENOMEM; 806 } 807 808 info->size = pipe_size; 809 810 /* 811 * init pipe 812 */ 813 usbhs_for_each_pipe_with_dcp(pipe, priv, i) { 814 pipe->priv = priv; 815 816 usbhs_pipe_type(pipe) = 817 pipe_configs[i].type & USB_ENDPOINT_XFERTYPE_MASK; 818 819 dev_dbg(dev, "pipe %x\t: %s\n", 820 i, usbhsp_pipe_name[pipe_configs[i].type]); 821 } 822 823 return 0; 824 } 825 826 void usbhs_pipe_remove(struct usbhs_priv *priv) 827 { 828 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 829 830 kfree(info->pipe); 831 } 832