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 #define usbhsp_type(p) ((p)->pipe_type) 33 #define usbhsp_type_is(p, t) ((p)->pipe_type == t) 34 35 /* 36 * for debug 37 */ 38 static char *usbhsp_pipe_name[] = { 39 [USB_ENDPOINT_XFER_CONTROL] = "DCP", 40 [USB_ENDPOINT_XFER_BULK] = "BULK", 41 [USB_ENDPOINT_XFER_INT] = "INT", 42 [USB_ENDPOINT_XFER_ISOC] = "ISO", 43 }; 44 45 /* 46 * usb request functions 47 */ 48 void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req) 49 { 50 u16 val; 51 52 val = usbhs_read(priv, USBREQ); 53 req->bRequest = (val >> 8) & 0xFF; 54 req->bRequestType = (val >> 0) & 0xFF; 55 56 req->wValue = usbhs_read(priv, USBVAL); 57 req->wIndex = usbhs_read(priv, USBINDX); 58 req->wLength = usbhs_read(priv, USBLENG); 59 } 60 61 void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req) 62 { 63 usbhs_write(priv, USBREQ, (req->bRequest << 8) | req->bRequestType); 64 usbhs_write(priv, USBVAL, req->wValue); 65 usbhs_write(priv, USBINDX, req->wIndex); 66 usbhs_write(priv, USBLENG, req->wLength); 67 } 68 69 /* 70 * DCPCTR/PIPEnCTR functions 71 */ 72 static void usbhsp_pipectrl_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 73 { 74 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 75 int offset = usbhsp_addr_offset(pipe); 76 77 if (usbhs_pipe_is_dcp(pipe)) 78 usbhs_bset(priv, DCPCTR, mask, val); 79 else 80 usbhs_bset(priv, PIPEnCTR + offset, mask, val); 81 } 82 83 static u16 usbhsp_pipectrl_get(struct usbhs_pipe *pipe) 84 { 85 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 86 int offset = usbhsp_addr_offset(pipe); 87 88 if (usbhs_pipe_is_dcp(pipe)) 89 return usbhs_read(priv, DCPCTR); 90 else 91 return usbhs_read(priv, PIPEnCTR + offset); 92 } 93 94 /* 95 * DCP/PIPE functions 96 */ 97 static void __usbhsp_pipe_xxx_set(struct usbhs_pipe *pipe, 98 u16 dcp_reg, u16 pipe_reg, 99 u16 mask, u16 val) 100 { 101 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 102 103 if (usbhs_pipe_is_dcp(pipe)) 104 usbhs_bset(priv, dcp_reg, mask, val); 105 else 106 usbhs_bset(priv, pipe_reg, mask, val); 107 } 108 109 static u16 __usbhsp_pipe_xxx_get(struct usbhs_pipe *pipe, 110 u16 dcp_reg, u16 pipe_reg) 111 { 112 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 113 114 if (usbhs_pipe_is_dcp(pipe)) 115 return usbhs_read(priv, dcp_reg); 116 else 117 return usbhs_read(priv, pipe_reg); 118 } 119 120 /* 121 * DCPCFG/PIPECFG functions 122 */ 123 static void usbhsp_pipe_cfg_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 124 { 125 __usbhsp_pipe_xxx_set(pipe, DCPCFG, PIPECFG, mask, val); 126 } 127 128 /* 129 * PIPEBUF 130 */ 131 static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 132 { 133 if (usbhs_pipe_is_dcp(pipe)) 134 return; 135 136 __usbhsp_pipe_xxx_set(pipe, 0, PIPEBUF, mask, val); 137 } 138 139 /* 140 * DCPMAXP/PIPEMAXP 141 */ 142 static void usbhsp_pipe_maxp_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 143 { 144 __usbhsp_pipe_xxx_set(pipe, DCPMAXP, PIPEMAXP, mask, val); 145 } 146 147 static u16 usbhsp_pipe_maxp_get(struct usbhs_pipe *pipe) 148 { 149 return __usbhsp_pipe_xxx_get(pipe, DCPMAXP, PIPEMAXP); 150 } 151 152 /* 153 * pipe control functions 154 */ 155 static void usbhsp_pipe_select(struct usbhs_pipe *pipe) 156 { 157 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 158 159 /* 160 * On pipe, this is necessary before 161 * accesses to below registers. 162 * 163 * PIPESEL : usbhsp_pipe_select 164 * PIPECFG : usbhsp_pipe_cfg_xxx 165 * PIPEBUF : usbhsp_pipe_buf_xxx 166 * PIPEMAXP : usbhsp_pipe_maxp_xxx 167 * PIPEPERI 168 */ 169 170 /* 171 * if pipe is dcp, no pipe is selected. 172 * it is no problem, because dcp have its register 173 */ 174 usbhs_write(priv, PIPESEL, 0xF & usbhs_pipe_number(pipe)); 175 } 176 177 static int usbhsp_pipe_barrier(struct usbhs_pipe *pipe) 178 { 179 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 180 int timeout = 1024; 181 u16 val; 182 183 /* 184 * make sure.... 185 * 186 * Modify these bits when CSSTS = 0, PID = NAK, and no pipe number is 187 * specified by the CURPIPE bits. 188 * When changing the setting of this bit after changing 189 * the PID bits for the selected pipe from BUF to NAK, 190 * check that CSSTS = 0 and PBUSY = 0. 191 */ 192 193 /* 194 * CURPIPE bit = 0 195 * 196 * see also 197 * "Operation" 198 * - "Pipe Control" 199 * - "Pipe Control Registers Switching Procedure" 200 */ 201 usbhs_write(priv, CFIFOSEL, 0); 202 usbhs_pipe_disable(pipe); 203 204 do { 205 val = usbhsp_pipectrl_get(pipe); 206 val &= CSSTS | PID_MASK; 207 if (!val) 208 return 0; 209 210 udelay(10); 211 212 } while (timeout--); 213 214 return -EBUSY; 215 } 216 217 int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe) 218 { 219 u16 val; 220 221 val = usbhsp_pipectrl_get(pipe); 222 if (val & BSTS) 223 return 0; 224 225 return -EBUSY; 226 } 227 228 /* 229 * PID ctrl 230 */ 231 static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe) 232 { 233 u16 pid = usbhsp_pipectrl_get(pipe); 234 235 pid &= PID_MASK; 236 237 /* 238 * see 239 * "Pipe n Control Register" - "PID" 240 */ 241 switch (pid) { 242 case PID_STALL11: 243 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10); 244 /* fall-through */ 245 case PID_STALL10: 246 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK); 247 } 248 } 249 250 void usbhs_pipe_disable(struct usbhs_pipe *pipe) 251 { 252 int timeout = 1024; 253 u16 val; 254 255 /* see "Pipe n Control Register" - "PID" */ 256 __usbhsp_pid_try_nak_if_stall(pipe); 257 258 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK); 259 260 do { 261 val = usbhsp_pipectrl_get(pipe); 262 val &= PBUSY; 263 if (!val) 264 break; 265 266 udelay(10); 267 } while (timeout--); 268 } 269 270 void usbhs_pipe_enable(struct usbhs_pipe *pipe) 271 { 272 /* see "Pipe n Control Register" - "PID" */ 273 __usbhsp_pid_try_nak_if_stall(pipe); 274 275 usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF); 276 } 277 278 void usbhs_pipe_stall(struct usbhs_pipe *pipe) 279 { 280 u16 pid = usbhsp_pipectrl_get(pipe); 281 282 pid &= PID_MASK; 283 284 /* 285 * see 286 * "Pipe n Control Register" - "PID" 287 */ 288 switch (pid) { 289 case PID_NAK: 290 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10); 291 break; 292 case PID_BUF: 293 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11); 294 break; 295 } 296 } 297 298 /* 299 * pipe setup 300 */ 301 static int usbhsp_possible_double_buffer(struct usbhs_pipe *pipe) 302 { 303 /* 304 * only ISO / BULK pipe can use double buffer 305 */ 306 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK) || 307 usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC)) 308 return 1; 309 310 return 0; 311 } 312 313 static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe, 314 const struct usb_endpoint_descriptor *desc, 315 int is_host) 316 { 317 u16 type = 0; 318 u16 bfre = 0; 319 u16 dblb = 0; 320 u16 cntmd = 0; 321 u16 dir = 0; 322 u16 epnum = 0; 323 u16 shtnak = 0; 324 u16 type_array[] = { 325 [USB_ENDPOINT_XFER_BULK] = TYPE_BULK, 326 [USB_ENDPOINT_XFER_INT] = TYPE_INT, 327 [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO, 328 }; 329 int is_double = usbhsp_possible_double_buffer(pipe); 330 331 if (usbhs_pipe_is_dcp(pipe)) 332 return -EINVAL; 333 334 /* 335 * PIPECFG 336 * 337 * see 338 * - "Register Descriptions" - "PIPECFG" register 339 * - "Features" - "Pipe configuration" 340 * - "Operation" - "Pipe Control" 341 */ 342 343 /* TYPE */ 344 type = type_array[usbhsp_type(pipe)]; 345 346 /* BFRE */ 347 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC) || 348 usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 349 bfre = 0; /* FIXME */ 350 351 /* DBLB */ 352 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC) || 353 usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 354 dblb = (is_double) ? DBLB : 0; 355 356 /* CNTMD */ 357 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 358 cntmd = 0; /* FIXME */ 359 360 /* DIR */ 361 if (usb_endpoint_dir_in(desc)) 362 usbhsp_flags_set(pipe, IS_DIR_HOST); 363 364 if ((is_host && usb_endpoint_dir_out(desc)) || 365 (!is_host && usb_endpoint_dir_in(desc))) 366 dir |= DIR_OUT; 367 368 if (!dir) 369 usbhsp_flags_set(pipe, IS_DIR_IN); 370 371 /* SHTNAK */ 372 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK) && 373 !dir) 374 shtnak = SHTNAK; 375 376 /* EPNUM */ 377 epnum = 0xF & usb_endpoint_num(desc); 378 379 return type | 380 bfre | 381 dblb | 382 cntmd | 383 dir | 384 shtnak | 385 epnum; 386 } 387 388 static u16 usbhsp_setup_pipemaxp(struct usbhs_pipe *pipe, 389 const struct usb_endpoint_descriptor *desc, 390 int is_host) 391 { 392 /* host should set DEVSEL */ 393 394 /* reutn MXPS */ 395 return PIPE_MAXP_MASK & le16_to_cpu(desc->wMaxPacketSize); 396 } 397 398 static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe, 399 const struct usb_endpoint_descriptor *desc, 400 int is_host) 401 { 402 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe); 403 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 404 struct device *dev = usbhs_priv_to_dev(priv); 405 int pipe_num = usbhs_pipe_number(pipe); 406 int is_double = usbhsp_possible_double_buffer(pipe); 407 u16 buff_size; 408 u16 bufnmb; 409 u16 bufnmb_cnt; 410 411 /* 412 * PIPEBUF 413 * 414 * see 415 * - "Register Descriptions" - "PIPEBUF" register 416 * - "Features" - "Pipe configuration" 417 * - "Operation" - "FIFO Buffer Memory" 418 * - "Operation" - "Pipe Control" 419 * 420 * ex) if pipe6 - pipe9 are USB_ENDPOINT_XFER_INT (SH7724) 421 * 422 * BUFNMB: PIPE 423 * 0: pipe0 (DCP 256byte) 424 * 1: - 425 * 2: - 426 * 3: - 427 * 4: pipe6 (INT 64byte) 428 * 5: pipe7 (INT 64byte) 429 * 6: pipe8 (INT 64byte) 430 * 7: pipe9 (INT 64byte) 431 * 8 - xx: free (for BULK, ISOC) 432 */ 433 434 /* 435 * FIXME 436 * 437 * it doesn't have good buffer allocator 438 * 439 * DCP : 256 byte 440 * BULK: 512 byte 441 * INT : 64 byte 442 * ISOC: 512 byte 443 */ 444 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_CONTROL)) 445 buff_size = 256; 446 else if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT)) 447 buff_size = 64; 448 else 449 buff_size = 512; 450 451 /* change buff_size to register value */ 452 bufnmb_cnt = (buff_size / 64) - 1; 453 454 /* BUFNMB has been reserved for INT pipe 455 * see above */ 456 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT)) { 457 bufnmb = pipe_num - 2; 458 } else { 459 bufnmb = info->bufnmb_last; 460 info->bufnmb_last += bufnmb_cnt + 1; 461 462 /* 463 * double buffer 464 */ 465 if (is_double) 466 info->bufnmb_last += bufnmb_cnt + 1; 467 } 468 469 dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n", 470 pipe_num, buff_size, bufnmb); 471 472 return (0x1f & bufnmb_cnt) << 10 | 473 (0xff & bufnmb) << 0; 474 } 475 476 /* 477 * pipe control 478 */ 479 int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe) 480 { 481 u16 mask = usbhs_pipe_is_dcp(pipe) ? DCP_MAXP_MASK : PIPE_MAXP_MASK; 482 483 usbhsp_pipe_select(pipe); 484 485 return (int)(usbhsp_pipe_maxp_get(pipe) & mask); 486 } 487 488 int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe) 489 { 490 return usbhsp_flags_has(pipe, IS_DIR_IN); 491 } 492 493 int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe) 494 { 495 return usbhsp_flags_has(pipe, IS_DIR_HOST); 496 } 497 498 void usbhs_pipe_clear_sequence(struct usbhs_pipe *pipe) 499 { 500 usbhsp_pipectrl_set(pipe, SQCLR, SQCLR); 501 } 502 503 void usbhs_pipe_clear(struct usbhs_pipe *pipe) 504 { 505 usbhsp_pipectrl_set(pipe, ACLRM, ACLRM); 506 usbhsp_pipectrl_set(pipe, ACLRM, 0); 507 } 508 509 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type) 510 { 511 struct usbhs_pipe *pos, *pipe; 512 int i; 513 514 /* 515 * find target pipe 516 */ 517 pipe = NULL; 518 usbhs_for_each_pipe_with_dcp(pos, priv, i) { 519 if (!usbhsp_type_is(pos, type)) 520 continue; 521 if (usbhsp_flags_has(pos, IS_USED)) 522 continue; 523 524 pipe = pos; 525 break; 526 } 527 528 if (!pipe) 529 return NULL; 530 531 /* 532 * initialize pipe flags 533 */ 534 usbhsp_flags_init(pipe); 535 usbhsp_flags_set(pipe, IS_USED); 536 537 return pipe; 538 } 539 540 void usbhs_pipe_init(struct usbhs_priv *priv, 541 void (*done)(struct usbhs_pkt *pkt), 542 int (*dma_map_ctrl)(struct usbhs_pkt *pkt, int map)) 543 { 544 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 545 struct device *dev = usbhs_priv_to_dev(priv); 546 struct usbhs_pipe *pipe; 547 int i; 548 549 if (!done) { 550 dev_err(dev, "no done function\n"); 551 return; 552 } 553 554 /* 555 * FIXME 556 * 557 * driver needs good allocator. 558 * 559 * find first free buffer area (BULK, ISOC) 560 * (DCP, INT area is fixed) 561 * 562 * buffer number 0 - 3 have been reserved for DCP 563 * see 564 * usbhsp_to_bufnmb 565 */ 566 info->bufnmb_last = 4; 567 usbhs_for_each_pipe_with_dcp(pipe, priv, i) { 568 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT)) 569 info->bufnmb_last++; 570 571 usbhsp_flags_init(pipe); 572 pipe->fifo = NULL; 573 pipe->mod_private = NULL; 574 INIT_LIST_HEAD(&pipe->list); 575 576 /* pipe force init */ 577 usbhs_pipe_clear(pipe); 578 } 579 580 info->done = done; 581 info->dma_map_ctrl = dma_map_ctrl; 582 } 583 584 struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv, 585 const struct usb_endpoint_descriptor *desc) 586 { 587 struct device *dev = usbhs_priv_to_dev(priv); 588 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 589 struct usbhs_pipe *pipe; 590 int is_host = usbhs_mod_is_host(priv, mod); 591 int ret; 592 u16 pipecfg, pipebuf, pipemaxp; 593 594 pipe = usbhsp_get_pipe(priv, usb_endpoint_type(desc)); 595 if (!pipe) { 596 dev_err(dev, "can't get pipe (%s)\n", 597 usbhsp_pipe_name[usb_endpoint_type(desc)]); 598 return NULL; 599 } 600 601 INIT_LIST_HEAD(&pipe->list); 602 603 usbhs_pipe_disable(pipe); 604 605 /* make sure pipe is not busy */ 606 ret = usbhsp_pipe_barrier(pipe); 607 if (ret < 0) { 608 dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe)); 609 return NULL; 610 } 611 612 pipecfg = usbhsp_setup_pipecfg(pipe, desc, is_host); 613 pipebuf = usbhsp_setup_pipebuff(pipe, desc, is_host); 614 pipemaxp = usbhsp_setup_pipemaxp(pipe, desc, is_host); 615 616 usbhsp_pipe_select(pipe); 617 usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg); 618 usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf); 619 usbhsp_pipe_maxp_set(pipe, 0xFFFF, pipemaxp); 620 621 usbhs_pipe_clear_sequence(pipe); 622 623 dev_dbg(dev, "enable pipe %d : %s (%s)\n", 624 usbhs_pipe_number(pipe), 625 usbhsp_pipe_name[usb_endpoint_type(desc)], 626 usbhs_pipe_is_dir_in(pipe) ? "in" : "out"); 627 628 return pipe; 629 } 630 631 void usbhs_pipe_select_fifo(struct usbhs_pipe *pipe, struct usbhs_fifo *fifo) 632 { 633 if (pipe->fifo) 634 pipe->fifo->pipe = NULL; 635 636 pipe->fifo = fifo; 637 638 if (fifo) 639 fifo->pipe = pipe; 640 } 641 642 643 /* 644 * dcp control 645 */ 646 struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv) 647 { 648 struct usbhs_pipe *pipe; 649 650 pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL); 651 if (!pipe) 652 return NULL; 653 654 /* 655 * dcpcfg : default 656 * dcpmaxp : default 657 * pipebuf : nothing to do 658 */ 659 660 usbhsp_pipe_select(pipe); 661 usbhs_pipe_clear_sequence(pipe); 662 INIT_LIST_HEAD(&pipe->list); 663 664 return pipe; 665 } 666 667 void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe) 668 { 669 WARN_ON(!usbhs_pipe_is_dcp(pipe)); 670 671 usbhs_pipe_enable(pipe); 672 usbhsp_pipectrl_set(pipe, CCPL, CCPL); 673 } 674 675 /* 676 * pipe module function 677 */ 678 int usbhs_pipe_probe(struct usbhs_priv *priv) 679 { 680 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 681 struct usbhs_pipe *pipe; 682 struct device *dev = usbhs_priv_to_dev(priv); 683 u32 *pipe_type = usbhs_get_dparam(priv, pipe_type); 684 int pipe_size = usbhs_get_dparam(priv, pipe_size); 685 int i; 686 687 /* This driver expects 1st pipe is DCP */ 688 if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) { 689 dev_err(dev, "1st PIPE is not DCP\n"); 690 return -EINVAL; 691 } 692 693 info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL); 694 if (!info->pipe) { 695 dev_err(dev, "Could not allocate pipe\n"); 696 return -ENOMEM; 697 } 698 699 info->size = pipe_size; 700 701 /* 702 * init pipe 703 */ 704 usbhs_for_each_pipe_with_dcp(pipe, priv, i) { 705 pipe->priv = priv; 706 usbhsp_type(pipe) = pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK; 707 708 dev_dbg(dev, "pipe %x\t: %s\n", 709 i, usbhsp_pipe_name[pipe_type[i]]); 710 } 711 712 return 0; 713 } 714 715 void usbhs_pipe_remove(struct usbhs_priv *priv) 716 { 717 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv); 718 719 kfree(info->pipe); 720 } 721