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