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/io.h> 19 #include <linux/slab.h> 20 #include "./common.h" 21 #include "./pipe.h" 22 23 /* 24 * macros 25 */ 26 #define usbhsp_priv_to_pipeinfo(pr) (&(pr)->pipe_info) 27 #define usbhsp_pipe_to_priv(p) ((p)->priv) 28 29 #define usbhsp_addr_offset(p) ((usbhs_pipe_number(p) - 1) * 2) 30 31 #define usbhsp_is_dcp(p) ((p)->priv->pipe_info.pipe == (p)) 32 33 #define usbhsp_flags_set(p, f) ((p)->flags |= USBHS_PIPE_FLAGS_##f) 34 #define usbhsp_flags_clr(p, f) ((p)->flags &= ~USBHS_PIPE_FLAGS_##f) 35 #define usbhsp_flags_has(p, f) ((p)->flags & USBHS_PIPE_FLAGS_##f) 36 #define usbhsp_flags_init(p) do {(p)->flags = 0; } while (0) 37 38 #define usbhsp_type(p) ((p)->pipe_type) 39 #define usbhsp_type_is(p, t) ((p)->pipe_type == t) 40 41 /* 42 * for debug 43 */ 44 static char *usbhsp_pipe_name[] = { 45 [USB_ENDPOINT_XFER_CONTROL] = "DCP", 46 [USB_ENDPOINT_XFER_BULK] = "BULK", 47 [USB_ENDPOINT_XFER_INT] = "INT", 48 [USB_ENDPOINT_XFER_ISOC] = "ISO", 49 }; 50 51 /* 52 * usb request functions 53 */ 54 void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req) 55 { 56 u16 val; 57 58 val = usbhs_read(priv, USBREQ); 59 req->bRequest = (val >> 8) & 0xFF; 60 req->bRequestType = (val >> 0) & 0xFF; 61 62 req->wValue = usbhs_read(priv, USBVAL); 63 req->wIndex = usbhs_read(priv, USBINDX); 64 req->wLength = usbhs_read(priv, USBLENG); 65 } 66 67 void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req) 68 { 69 usbhs_write(priv, USBREQ, (req->bRequest << 8) | req->bRequestType); 70 usbhs_write(priv, USBVAL, req->wValue); 71 usbhs_write(priv, USBINDX, req->wIndex); 72 usbhs_write(priv, USBLENG, req->wLength); 73 } 74 75 /* 76 * DCPCTR/PIPEnCTR functions 77 */ 78 static void usbhsp_pipectrl_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 79 { 80 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 81 int offset = usbhsp_addr_offset(pipe); 82 83 if (usbhsp_is_dcp(pipe)) 84 usbhs_bset(priv, DCPCTR, mask, val); 85 else 86 usbhs_bset(priv, PIPEnCTR + offset, mask, val); 87 } 88 89 static u16 usbhsp_pipectrl_get(struct usbhs_pipe *pipe) 90 { 91 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 92 int offset = usbhsp_addr_offset(pipe); 93 94 if (usbhsp_is_dcp(pipe)) 95 return usbhs_read(priv, DCPCTR); 96 else 97 return usbhs_read(priv, PIPEnCTR + offset); 98 } 99 100 /* 101 * DCP/PIPE functions 102 */ 103 static void __usbhsp_pipe_xxx_set(struct usbhs_pipe *pipe, 104 u16 dcp_reg, u16 pipe_reg, 105 u16 mask, u16 val) 106 { 107 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 108 109 if (usbhsp_is_dcp(pipe)) 110 usbhs_bset(priv, dcp_reg, mask, val); 111 else 112 usbhs_bset(priv, pipe_reg, mask, val); 113 } 114 115 static u16 __usbhsp_pipe_xxx_get(struct usbhs_pipe *pipe, 116 u16 dcp_reg, u16 pipe_reg) 117 { 118 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 119 120 if (usbhsp_is_dcp(pipe)) 121 return usbhs_read(priv, dcp_reg); 122 else 123 return usbhs_read(priv, pipe_reg); 124 } 125 126 /* 127 * DCPCFG/PIPECFG functions 128 */ 129 static void usbhsp_pipe_cfg_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 130 { 131 __usbhsp_pipe_xxx_set(pipe, DCPCFG, PIPECFG, mask, val); 132 } 133 134 /* 135 * PIPEBUF 136 */ 137 static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 138 { 139 if (usbhsp_is_dcp(pipe)) 140 return; 141 142 __usbhsp_pipe_xxx_set(pipe, 0, PIPEBUF, mask, val); 143 } 144 145 /* 146 * DCPMAXP/PIPEMAXP 147 */ 148 static void usbhsp_pipe_maxp_set(struct usbhs_pipe *pipe, u16 mask, u16 val) 149 { 150 __usbhsp_pipe_xxx_set(pipe, DCPMAXP, PIPEMAXP, mask, val); 151 } 152 153 static u16 usbhsp_pipe_maxp_get(struct usbhs_pipe *pipe) 154 { 155 return __usbhsp_pipe_xxx_get(pipe, DCPMAXP, PIPEMAXP); 156 } 157 158 /* 159 * pipe control functions 160 */ 161 static void usbhsp_pipe_select(struct usbhs_pipe *pipe) 162 { 163 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 164 165 /* 166 * On pipe, this is necessary before 167 * accesses to below registers. 168 * 169 * PIPESEL : usbhsp_pipe_select 170 * PIPECFG : usbhsp_pipe_cfg_xxx 171 * PIPEBUF : usbhsp_pipe_buf_xxx 172 * PIPEMAXP : usbhsp_pipe_maxp_xxx 173 * PIPEPERI 174 */ 175 176 /* 177 * if pipe is dcp, no pipe is selected. 178 * it is no problem, because dcp have its register 179 */ 180 usbhs_write(priv, PIPESEL, 0xF & usbhs_pipe_number(pipe)); 181 } 182 183 static int usbhsp_pipe_barrier(struct usbhs_pipe *pipe) 184 { 185 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 186 int timeout = 1024; 187 u16 val; 188 189 /* 190 * make sure.... 191 * 192 * Modify these bits when CSSTS = 0, PID = NAK, and no pipe number is 193 * specified by the CURPIPE bits. 194 * When changing the setting of this bit after changing 195 * the PID bits for the selected pipe from BUF to NAK, 196 * check that CSSTS = 0 and PBUSY = 0. 197 */ 198 199 /* 200 * CURPIPE bit = 0 201 * 202 * see also 203 * "Operation" 204 * - "Pipe Control" 205 * - "Pipe Control Registers Switching Procedure" 206 */ 207 usbhs_write(priv, CFIFOSEL, 0); 208 usbhs_fifo_disable(pipe); 209 210 do { 211 val = usbhsp_pipectrl_get(pipe); 212 val &= CSSTS | PID_MASK; 213 if (!val) 214 return 0; 215 216 udelay(10); 217 218 } while (timeout--); 219 220 return -EBUSY; 221 } 222 223 static int usbhsp_pipe_is_accessible(struct usbhs_pipe *pipe) 224 { 225 u16 val; 226 227 val = usbhsp_pipectrl_get(pipe); 228 if (val & BSTS) 229 return 0; 230 231 return -EBUSY; 232 } 233 234 /* 235 * PID ctrl 236 */ 237 static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe) 238 { 239 u16 pid = usbhsp_pipectrl_get(pipe); 240 241 pid &= PID_MASK; 242 243 /* 244 * see 245 * "Pipe n Control Register" - "PID" 246 */ 247 switch (pid) { 248 case PID_STALL11: 249 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10); 250 /* fall-through */ 251 case PID_STALL10: 252 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK); 253 } 254 } 255 256 void usbhs_fifo_disable(struct usbhs_pipe *pipe) 257 { 258 int timeout = 1024; 259 u16 val; 260 261 /* see "Pipe n Control Register" - "PID" */ 262 __usbhsp_pid_try_nak_if_stall(pipe); 263 264 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK); 265 266 do { 267 val = usbhsp_pipectrl_get(pipe); 268 val &= PBUSY; 269 if (!val) 270 break; 271 272 udelay(10); 273 } while (timeout--); 274 } 275 276 void usbhs_fifo_enable(struct usbhs_pipe *pipe) 277 { 278 /* see "Pipe n Control Register" - "PID" */ 279 __usbhsp_pid_try_nak_if_stall(pipe); 280 281 usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF); 282 } 283 284 void usbhs_fifo_stall(struct usbhs_pipe *pipe) 285 { 286 u16 pid = usbhsp_pipectrl_get(pipe); 287 288 pid &= PID_MASK; 289 290 /* 291 * see 292 * "Pipe n Control Register" - "PID" 293 */ 294 switch (pid) { 295 case PID_NAK: 296 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10); 297 break; 298 case PID_BUF: 299 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11); 300 break; 301 } 302 } 303 304 /* 305 * CFIFO ctrl 306 */ 307 void usbhs_fifo_send_terminator(struct usbhs_pipe *pipe) 308 { 309 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 310 311 usbhs_bset(priv, CFIFOCTR, BVAL, BVAL); 312 } 313 314 static void usbhsp_fifo_clear(struct usbhs_pipe *pipe) 315 { 316 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 317 318 usbhs_write(priv, CFIFOCTR, BCLR); 319 } 320 321 static int usbhsp_fifo_barrier(struct usbhs_priv *priv) 322 { 323 int timeout = 1024; 324 325 do { 326 /* The FIFO port is accessible */ 327 if (usbhs_read(priv, CFIFOCTR) & FRDY) 328 return 0; 329 330 udelay(10); 331 } while (timeout--); 332 333 return -EBUSY; 334 } 335 336 static int usbhsp_fifo_rcv_len(struct usbhs_priv *priv) 337 { 338 return usbhs_read(priv, CFIFOCTR) & DTLN_MASK; 339 } 340 341 static int usbhsp_fifo_select(struct usbhs_pipe *pipe, int write) 342 { 343 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 344 struct device *dev = usbhs_priv_to_dev(priv); 345 int timeout = 1024; 346 u16 mask = ((1 << 5) | 0xF); /* mask of ISEL | CURPIPE */ 347 u16 base = usbhs_pipe_number(pipe); /* CURPIPE */ 348 349 if (usbhsp_is_dcp(pipe)) 350 base |= (1 == write) << 5; /* ISEL */ 351 352 /* "base" will be used below */ 353 usbhs_write(priv, CFIFOSEL, base | MBW_32); 354 355 /* check ISEL and CURPIPE value */ 356 while (timeout--) { 357 if (base == (mask & usbhs_read(priv, CFIFOSEL))) 358 return 0; 359 udelay(10); 360 } 361 362 dev_err(dev, "fifo select error\n"); 363 364 return -EIO; 365 } 366 367 int usbhs_fifo_prepare_write(struct usbhs_pipe *pipe) 368 { 369 return usbhsp_fifo_select(pipe, 1); 370 } 371 372 int usbhs_fifo_write(struct usbhs_pipe *pipe, u8 *buf, int len) 373 { 374 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 375 void __iomem *addr = priv->base + CFIFO; 376 int maxp = usbhs_pipe_get_maxpacket(pipe); 377 int total_len; 378 int i, ret; 379 380 ret = usbhsp_pipe_is_accessible(pipe); 381 if (ret < 0) 382 return ret; 383 384 ret = usbhsp_fifo_select(pipe, 1); 385 if (ret < 0) 386 return ret; 387 388 ret = usbhsp_fifo_barrier(priv); 389 if (ret < 0) 390 return ret; 391 392 len = min(len, maxp); 393 total_len = len; 394 395 /* 396 * FIXME 397 * 398 * 32-bit access only 399 */ 400 if (len >= 4 && 401 !((unsigned long)buf & 0x03)) { 402 iowrite32_rep(addr, buf, len / 4); 403 len %= 4; 404 buf += total_len - len; 405 } 406 407 /* the rest operation */ 408 for (i = 0; i < len; i++) 409 iowrite8(buf[i], addr + (0x03 - (i & 0x03))); 410 411 if (total_len < maxp) 412 usbhs_fifo_send_terminator(pipe); 413 414 return total_len; 415 } 416 417 int usbhs_fifo_prepare_read(struct usbhs_pipe *pipe) 418 { 419 int ret; 420 421 /* 422 * select pipe and enable it to prepare packet receive 423 */ 424 ret = usbhsp_fifo_select(pipe, 0); 425 if (ret < 0) 426 return ret; 427 428 usbhs_fifo_enable(pipe); 429 430 return ret; 431 } 432 433 int usbhs_fifo_read(struct usbhs_pipe *pipe, u8 *buf, int len) 434 { 435 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 436 void __iomem *addr = priv->base + CFIFO; 437 int rcv_len; 438 int i, ret; 439 int total_len; 440 u32 data = 0; 441 442 ret = usbhsp_fifo_select(pipe, 0); 443 if (ret < 0) 444 return ret; 445 446 ret = usbhsp_fifo_barrier(priv); 447 if (ret < 0) 448 return ret; 449 450 rcv_len = usbhsp_fifo_rcv_len(priv); 451 452 /* 453 * Buffer clear if Zero-Length packet 454 * 455 * see 456 * "Operation" - "FIFO Buffer Memory" - "FIFO Port Function" 457 */ 458 if (0 == rcv_len) { 459 usbhsp_fifo_clear(pipe); 460 return 0; 461 } 462 463 len = min(rcv_len, len); 464 total_len = len; 465 466 /* 467 * FIXME 468 * 469 * 32-bit access only 470 */ 471 if (len >= 4 && 472 !((unsigned long)buf & 0x03)) { 473 ioread32_rep(addr, buf, len / 4); 474 len %= 4; 475 buf += rcv_len - len; 476 } 477 478 /* the rest operation */ 479 for (i = 0; i < len; i++) { 480 if (!(i & 0x03)) 481 data = ioread32(addr); 482 483 buf[i] = (data >> ((i & 0x03) * 8)) & 0xff; 484 } 485 486 return total_len; 487 } 488 489 /* 490 * pipe setup 491 */ 492 static int usbhsp_possible_double_buffer(struct usbhs_pipe *pipe) 493 { 494 /* 495 * only ISO / BULK pipe can use double buffer 496 */ 497 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK) || 498 usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC)) 499 return 1; 500 501 return 0; 502 } 503 504 static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe, 505 const struct usb_endpoint_descriptor *desc, 506 int is_host) 507 { 508 u16 type = 0; 509 u16 bfre = 0; 510 u16 dblb = 0; 511 u16 cntmd = 0; 512 u16 dir = 0; 513 u16 epnum = 0; 514 u16 shtnak = 0; 515 u16 type_array[] = { 516 [USB_ENDPOINT_XFER_BULK] = TYPE_BULK, 517 [USB_ENDPOINT_XFER_INT] = TYPE_INT, 518 [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO, 519 }; 520 int is_double = usbhsp_possible_double_buffer(pipe); 521 522 if (usbhsp_is_dcp(pipe)) 523 return -EINVAL; 524 525 /* 526 * PIPECFG 527 * 528 * see 529 * - "Register Descriptions" - "PIPECFG" register 530 * - "Features" - "Pipe configuration" 531 * - "Operation" - "Pipe Control" 532 */ 533 534 /* TYPE */ 535 type = type_array[usbhsp_type(pipe)]; 536 537 /* BFRE */ 538 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC) || 539 usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 540 bfre = 0; /* FIXME */ 541 542 /* DBLB */ 543 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC) || 544 usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 545 dblb = (is_double) ? DBLB : 0; 546 547 /* CNTMD */ 548 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK)) 549 cntmd = 0; /* FIXME */ 550 551 /* DIR */ 552 if (usb_endpoint_dir_in(desc)) 553 usbhsp_flags_set(pipe, IS_DIR_IN); 554 555 if ((is_host && usb_endpoint_dir_out(desc)) || 556 (!is_host && usb_endpoint_dir_in(desc))) 557 dir |= DIR_OUT; 558 559 /* SHTNAK */ 560 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK) && 561 !dir) 562 shtnak = SHTNAK; 563 564 /* EPNUM */ 565 epnum = 0xF & usb_endpoint_num(desc); 566 567 return type | 568 bfre | 569 dblb | 570 cntmd | 571 dir | 572 shtnak | 573 epnum; 574 } 575 576 static u16 usbhsp_setup_pipemaxp(struct usbhs_pipe *pipe, 577 const struct usb_endpoint_descriptor *desc, 578 int is_host) 579 { 580 /* host should set DEVSEL */ 581 582 /* reutn MXPS */ 583 return PIPE_MAXP_MASK & le16_to_cpu(desc->wMaxPacketSize); 584 } 585 586 static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe, 587 const struct usb_endpoint_descriptor *desc, 588 int is_host) 589 { 590 struct usbhs_priv *priv = usbhsp_pipe_to_priv(pipe); 591 struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv); 592 struct device *dev = usbhs_priv_to_dev(priv); 593 int pipe_num = usbhs_pipe_number(pipe); 594 int is_double = usbhsp_possible_double_buffer(pipe); 595 u16 buff_size; 596 u16 bufnmb; 597 u16 bufnmb_cnt; 598 599 /* 600 * PIPEBUF 601 * 602 * see 603 * - "Register Descriptions" - "PIPEBUF" register 604 * - "Features" - "Pipe configuration" 605 * - "Operation" - "FIFO Buffer Memory" 606 * - "Operation" - "Pipe Control" 607 * 608 * ex) if pipe6 - pipe9 are USB_ENDPOINT_XFER_INT (SH7724) 609 * 610 * BUFNMB: PIPE 611 * 0: pipe0 (DCP 256byte) 612 * 1: - 613 * 2: - 614 * 3: - 615 * 4: pipe6 (INT 64byte) 616 * 5: pipe7 (INT 64byte) 617 * 6: pipe8 (INT 64byte) 618 * 7: pipe9 (INT 64byte) 619 * 8 - xx: free (for BULK, ISOC) 620 */ 621 622 /* 623 * FIXME 624 * 625 * it doesn't have good buffer allocator 626 * 627 * DCP : 256 byte 628 * BULK: 512 byte 629 * INT : 64 byte 630 * ISOC: 512 byte 631 */ 632 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_CONTROL)) 633 buff_size = 256; 634 else if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT)) 635 buff_size = 64; 636 else 637 buff_size = 512; 638 639 /* change buff_size to register value */ 640 bufnmb_cnt = (buff_size / 64) - 1; 641 642 /* BUFNMB has been reserved for INT pipe 643 * see above */ 644 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT)) { 645 bufnmb = pipe_num - 2; 646 } else { 647 bufnmb = info->bufnmb_last; 648 info->bufnmb_last += bufnmb_cnt + 1; 649 650 /* 651 * double buffer 652 */ 653 if (is_double) 654 info->bufnmb_last += bufnmb_cnt + 1; 655 } 656 657 dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n", 658 pipe_num, buff_size, bufnmb); 659 660 return (0x1f & bufnmb_cnt) << 10 | 661 (0xff & bufnmb) << 0; 662 } 663 664 /* 665 * pipe control 666 */ 667 int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe) 668 { 669 u16 mask = usbhsp_is_dcp(pipe) ? DCP_MAXP_MASK : PIPE_MAXP_MASK; 670 671 usbhsp_pipe_select(pipe); 672 673 return (int)(usbhsp_pipe_maxp_get(pipe) & mask); 674 } 675 676 int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe) 677 { 678 return usbhsp_flags_has(pipe, IS_DIR_IN); 679 } 680 681 void usbhs_pipe_clear_sequence(struct usbhs_pipe *pipe) 682 { 683 usbhsp_pipectrl_set(pipe, SQCLR, SQCLR); 684 } 685 686 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type) 687 { 688 struct usbhs_pipe *pos, *pipe; 689 int i; 690 691 /* 692 * find target pipe 693 */ 694 pipe = NULL; 695 usbhs_for_each_pipe_with_dcp(pos, priv, i) { 696 if (!usbhsp_type_is(pos, type)) 697 continue; 698 if (usbhsp_flags_has(pos, IS_USED)) 699 continue; 700 701 pipe = pos; 702 break; 703 } 704 705 if (!pipe) 706 return NULL; 707 708 /* 709 * initialize pipe flags 710 */ 711 usbhsp_flags_init(pipe); 712 usbhsp_flags_set(pipe, IS_USED); 713 714 return pipe; 715 } 716 717 void usbhs_pipe_init(struct usbhs_priv *priv) 718 { 719 struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv); 720 struct usbhs_pipe *pipe; 721 int i; 722 723 /* 724 * FIXME 725 * 726 * driver needs good allocator. 727 * 728 * find first free buffer area (BULK, ISOC) 729 * (DCP, INT area is fixed) 730 * 731 * buffer number 0 - 3 have been reserved for DCP 732 * see 733 * usbhsp_to_bufnmb 734 */ 735 info->bufnmb_last = 4; 736 usbhs_for_each_pipe_with_dcp(pipe, priv, i) { 737 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT)) 738 info->bufnmb_last++; 739 740 usbhsp_flags_init(pipe); 741 pipe->mod_private = NULL; 742 743 usbhsp_fifo_clear(pipe); 744 } 745 } 746 747 struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv, 748 const struct usb_endpoint_descriptor *desc) 749 { 750 struct device *dev = usbhs_priv_to_dev(priv); 751 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 752 struct usbhs_pipe *pipe; 753 int is_host = usbhs_mod_is_host(priv, mod); 754 int ret; 755 u16 pipecfg, pipebuf, pipemaxp; 756 757 pipe = usbhsp_get_pipe(priv, usb_endpoint_type(desc)); 758 if (!pipe) { 759 dev_err(dev, "can't get pipe (%s)\n", 760 usbhsp_pipe_name[usb_endpoint_type(desc)]); 761 return NULL; 762 } 763 764 usbhs_fifo_disable(pipe); 765 766 /* make sure pipe is not busy */ 767 ret = usbhsp_pipe_barrier(pipe); 768 if (ret < 0) { 769 dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe)); 770 return NULL; 771 } 772 773 pipecfg = usbhsp_setup_pipecfg(pipe, desc, is_host); 774 pipebuf = usbhsp_setup_pipebuff(pipe, desc, is_host); 775 pipemaxp = usbhsp_setup_pipemaxp(pipe, desc, is_host); 776 777 /* buffer clear 778 * see PIPECFG :: BFRE */ 779 usbhsp_pipectrl_set(pipe, ACLRM, ACLRM); 780 usbhsp_pipectrl_set(pipe, ACLRM, 0); 781 782 usbhsp_pipe_select(pipe); 783 usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg); 784 usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf); 785 usbhsp_pipe_maxp_set(pipe, 0xFFFF, pipemaxp); 786 787 usbhs_pipe_clear_sequence(pipe); 788 789 dev_dbg(dev, "enable pipe %d : %s (%s)\n", 790 usbhs_pipe_number(pipe), 791 usbhsp_pipe_name[usb_endpoint_type(desc)], 792 usbhs_pipe_is_dir_in(pipe) ? "in" : "out"); 793 794 return pipe; 795 } 796 797 /* 798 * dcp control 799 */ 800 struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv) 801 { 802 struct usbhs_pipe *pipe; 803 804 pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL); 805 if (!pipe) 806 return NULL; 807 808 /* 809 * dcpcfg : default 810 * dcpmaxp : default 811 * pipebuf : nothing to do 812 */ 813 814 usbhsp_pipe_select(pipe); 815 usbhs_pipe_clear_sequence(pipe); 816 817 return pipe; 818 } 819 820 void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe) 821 { 822 WARN_ON(!usbhsp_is_dcp(pipe)); 823 824 usbhs_fifo_enable(pipe); 825 usbhsp_pipectrl_set(pipe, CCPL, CCPL); 826 } 827 828 829 /* 830 * pipe module function 831 */ 832 int usbhs_pipe_probe(struct usbhs_priv *priv) 833 { 834 struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv); 835 struct usbhs_pipe *pipe; 836 struct device *dev = usbhs_priv_to_dev(priv); 837 u32 *pipe_type = usbhs_get_dparam(priv, pipe_type); 838 int pipe_size = usbhs_get_dparam(priv, pipe_size); 839 int i; 840 841 /* This driver expects 1st pipe is DCP */ 842 if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) { 843 dev_err(dev, "1st PIPE is not DCP\n"); 844 return -EINVAL; 845 } 846 847 info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL); 848 if (!info->pipe) { 849 dev_err(dev, "Could not allocate pipe\n"); 850 return -ENOMEM; 851 } 852 853 info->size = pipe_size; 854 855 /* 856 * init pipe 857 */ 858 usbhs_for_each_pipe_with_dcp(pipe, priv, i) { 859 pipe->priv = priv; 860 usbhsp_type(pipe) = pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK; 861 862 dev_dbg(dev, "pipe %x\t: %s\n", 863 i, usbhsp_pipe_name[pipe_type[i]]); 864 } 865 866 return 0; 867 } 868 869 void usbhs_pipe_remove(struct usbhs_priv *priv) 870 { 871 struct usbhs_pipe_info *info = usbhsp_priv_to_pipeinfo(priv); 872 873 kfree(info->pipe); 874 } 875