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