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