drivers/usb/renesas_usbhs/pipe.c

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