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 int usbhsp_setup_pipecfg(struct usbhs_pipe *pipe, int is_host, 395 int dir_in, u16 *pipecfg) 396 { 397 u16 type = 0; 398 u16 bfre = 0; 399 u16 dblb = 0; 400 u16 cntmd = 0; 401 u16 dir = 0; 402 u16 epnum = 0; 403 u16 shtnak = 0; 404 static const u16 type_array[] = { 405 [USB_ENDPOINT_XFER_BULK] = TYPE_BULK, 406 [USB_ENDPOINT_XFER_INT] = TYPE_INT, 407 [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO, 408 }; 409 410 if (usbhs_pipe_is_dcp(pipe)) 411 return -EINVAL; 412 413 /* 414 * PIPECFG 415 * 416 * see 417 * - "Register Descriptions" - "PIPECFG" register 418 * - "Features" - "Pipe configuration" 419 * - "Operation" - "Pipe Control" 420 */ 421 422 /* TYPE */ 423 type = type_array[usbhs_pipe_type(pipe)]; 424 425 /* BFRE */ 426 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) || 427 usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 428 bfre = 0; /* FIXME */ 429 430 /* DBLB: see usbhs_pipe_config_update() */ 431 432 /* CNTMD */ 433 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 434 cntmd = 0; /* FIXME */ 435 436 /* DIR */ 437 if (dir_in) 438 usbhsp_flags_set(pipe, IS_DIR_HOST); 439 440 if (!!is_host ^ !!dir_in) 441 dir |= DIR_OUT; 442 443 if (!dir) 444 usbhsp_flags_set(pipe, IS_DIR_IN); 445 446 /* SHTNAK */ 447 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) && 448 !dir) 449 shtnak = SHTNAK; 450 451 /* EPNUM */ 452 epnum = 0; /* see usbhs_pipe_config_update() */ 453 *pipecfg = type | 454 bfre | 455 dblb | 456 cntmd | 457 dir | 458 shtnak | 459 epnum; 460 return 0; 461 } 462 463 static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe) 464 { 465 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 466 struct device *dev = usbhs_priv_to_dev(priv); 467 int pipe_num = usbhs_pipe_number(pipe); 468 u16 buff_size; 469 u16 bufnmb; 470 u16 bufnmb_cnt; 471 struct renesas_usbhs_driver_pipe_config *pipe_config = 472 usbhsp_get_pipe_config(priv, pipe_num); 473 474 /* 475 * PIPEBUF 476 * 477 * see 478 * - "Register Descriptions" - "PIPEBUF" register 479 * - "Features" - "Pipe configuration" 480 * - "Operation" - "FIFO Buffer Memory" 481 * - "Operation" - "Pipe Control" 482 */ 483 buff_size = pipe_config->bufsize; 484 bufnmb = pipe_config->bufnum; 485 486 /* change buff_size to register value */ 487 bufnmb_cnt = (buff_size / 64) - 1; 488 489 dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n", 490 pipe_num, buff_size, bufnmb); 491 492 return (0x1f & bufnmb_cnt) << 10 | 493 (0xff & bufnmb) << 0; 494 } 495 496 void usbhs_pipe_config_update(struct usbhs_pipe *pipe, u16 devsel, 497 u16 epnum, u16 maxp) 498 { 499 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 500 int pipe_num = usbhs_pipe_number(pipe); 501 struct renesas_usbhs_driver_pipe_config *pipe_config = 502 usbhsp_get_pipe_config(priv, pipe_num); 503 u16 dblb = pipe_config->double_buf ? DBLB : 0; 504 505 if (devsel > 0xA) { 506 struct device *dev = usbhs_priv_to_dev(priv); 507 508 dev_err(dev, "devsel error %d\n", devsel); 509 510 devsel = 0; 511 } 512 513 usbhsp_pipe_barrier(pipe); 514 515 pipe->maxp = maxp; 516 517 usbhsp_pipe_select(pipe); 518 usbhsp_pipe_maxp_set(pipe, 0xFFFF, 519 (devsel << 12) | 520 maxp); 521 522 if (!usbhs_pipe_is_dcp(pipe)) 523 usbhsp_pipe_cfg_set(pipe, 0x000F | DBLB, epnum | dblb); 524 } 525 526 /* 527 * pipe control 528 */ 529 int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe) 530 { 531 /* 532 * see 533 * usbhs_pipe_config_update() 534 * usbhs_dcp_malloc() 535 */ 536 return pipe->maxp; 537 } 538 539 int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe) 540 { 541 return usbhsp_flags_has(pipe, IS_DIR_IN); 542 } 543 544 int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe) 545 { 546 return usbhsp_flags_has(pipe, IS_DIR_HOST); 547 } 548 549 int usbhs_pipe_is_running(struct usbhs_pipe *pipe) 550 { 551 return usbhsp_flags_has(pipe, IS_RUNNING); 552 } 553 554 void usbhs_pipe_running(struct usbhs_pipe *pipe, int running) 555 { 556 if (running) 557 usbhsp_flags_set(pipe, IS_RUNNING); 558 else 559 usbhsp_flags_clr(pipe, IS_RUNNING); 560 } 561 562 void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence) 563 { 564 u16 mask = (SQCLR | SQSET); 565 u16 val; 566 567 /* 568 * sequence 569 * 0 : data0 570 * 1 : data1 571 * -1 : no change 572 */ 573 switch (sequence) { 574 case 0: 575 val = SQCLR; 576 break; 577 case 1: 578 val = SQSET; 579 break; 580 default: 581 return; 582 } 583 584 usbhsp_pipectrl_set(pipe, mask, val); 585 } 586 587 static int usbhs_pipe_get_data_sequence(struct usbhs_pipe *pipe) 588 { 589 return !!(usbhsp_pipectrl_get(pipe) & SQMON); 590 } 591 592 void usbhs_pipe_clear(struct usbhs_pipe *pipe) 593 { 594 if (usbhs_pipe_is_dcp(pipe)) { 595 usbhs_fifo_clear_dcp(pipe); 596 } else { 597 usbhsp_pipectrl_set(pipe, ACLRM, ACLRM); 598 usbhsp_pipectrl_set(pipe, ACLRM, 0); 599 } 600 } 601 602 void usbhs_pipe_config_change_bfre(struct usbhs_pipe *pipe, int enable) 603 { 604 int sequence; 605 606 if (usbhs_pipe_is_dcp(pipe)) 607 return; 608 609 usbhsp_pipe_select(pipe); 610 /* check if the driver needs to change the BFRE value */ 611 if (!(enable ^ !!(usbhsp_pipe_cfg_get(pipe) & BFRE))) 612 return; 613 614 sequence = usbhs_pipe_get_data_sequence(pipe); 615 usbhsp_pipe_cfg_set(pipe, BFRE, enable ? BFRE : 0); 616 usbhs_pipe_clear(pipe); 617 usbhs_pipe_data_sequence(pipe, sequence); 618 } 619 620 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type) 621 { 622 struct usbhs_pipe *pos, *pipe; 623 int i; 624 625 /* 626 * find target pipe 627 */ 628 pipe = NULL; 629 usbhs_for_each_pipe_with_dcp(pos, priv, i) { 630 if (!usbhs_pipe_type_is(pos, type)) 631 continue; 632 if (usbhsp_flags_has(pos, IS_USED)) 633 continue; 634 635 pipe = pos; 636 break; 637 } 638 639 if (!pipe) 640 return NULL; 641 642 /* 643 * initialize pipe flags 644 */ 645 usbhsp_flags_init(pipe); 646 usbhsp_flags_set(pipe, IS_USED); 647 648 return pipe; 649 } 650 651 static void usbhsp_put_pipe(struct usbhs_pipe *pipe) 652 { 653 usbhsp_flags_init(pipe); 654 } 655 656 void usbhs_pipe_init(struct usbhs_priv *priv, 657 int (*dma_map_ctrl)(struct device *dma_dev, 658 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 if (usbhsp_setup_pipecfg(pipe, is_host, dir_in, &pipecfg)) { 706 dev_err(dev, "can't setup pipe\n"); 707 return NULL; 708 } 709 710 pipebuf = usbhsp_setup_pipebuff(pipe); 711 712 usbhsp_pipe_select(pipe); 713 usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg); 714 usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf); 715 usbhs_pipe_clear(pipe); 716 717 usbhs_pipe_sequence_data0(pipe); 718 719 dev_dbg(dev, "enable pipe %d : %s (%s)\n", 720 usbhs_pipe_number(pipe), 721 usbhs_pipe_name(pipe), 722 usbhs_pipe_is_dir_in(pipe) ? "in" : "out"); 723 724 /* 725 * epnum / maxp are still not set to this pipe. 726 * call usbhs_pipe_config_update() after this function !! 727 */ 728 729 return pipe; 730 } 731 732 void usbhs_pipe_free(struct usbhs_pipe *pipe) 733 { 734 usbhsp_put_pipe(pipe); 735 } 736 737 void usbhs_pipe_select_fifo(struct usbhs_pipe *pipe, struct usbhs_fifo *fifo) 738 { 739 if (pipe->fifo) 740 pipe->fifo->pipe = NULL; 741 742 pipe->fifo = fifo; 743 744 if (fifo) 745 fifo->pipe = pipe; 746 } 747 748 749 /* 750 * dcp control 751 */ 752 struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv) 753 { 754 struct usbhs_pipe *pipe; 755 756 pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL); 757 if (!pipe) 758 return NULL; 759 760 INIT_LIST_HEAD(&pipe->list); 761 762 /* 763 * call usbhs_pipe_config_update() after this function !! 764 */ 765 766 return pipe; 767 } 768 769 void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe) 770 { 771 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 772 773 WARN_ON(!usbhs_pipe_is_dcp(pipe)); 774 775 usbhs_pipe_enable(pipe); 776 777 if (!usbhs_mod_is_host(priv)) /* funconly */ 778 usbhsp_pipectrl_set(pipe, CCPL, CCPL); 779 } 780 781 void usbhs_dcp_dir_for_host(struct usbhs_pipe *pipe, int dir_out) 782 { 783 usbhsp_pipe_cfg_set(pipe, DIR_OUT, 784 dir_out ? DIR_OUT : 0); 785 } 786 787 /* 788 * pipe module function 789 */ 790 int usbhs_pipe_probe(struct usbhs_priv *priv) 791 { 792 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 793 struct usbhs_pipe *pipe; 794 struct device *dev = usbhs_priv_to_dev(priv); 795 struct renesas_usbhs_driver_pipe_config *pipe_configs = 796 usbhs_get_dparam(priv, pipe_configs); 797 int pipe_size = usbhs_get_dparam(priv, pipe_size); 798 int i; 799 800 /* This driver expects 1st pipe is DCP */ 801 if (pipe_configs[0].type != USB_ENDPOINT_XFER_CONTROL) { 802 dev_err(dev, "1st PIPE is not DCP\n"); 803 return -EINVAL; 804 } 805 806 info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL); 807 if (!info->pipe) 808 return -ENOMEM; 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