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 #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 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type)
 504 {
 505         struct usbhs_pipe *pos, *pipe;
 506         int i;
 507
 508         /*
 509          * find target pipe
 510          */
 511         pipe = NULL;
 512         usbhs_for_each_pipe_with_dcp(pos, priv, i) {
 513                 if (!usbhsp_type_is(pos, type))
 514                         continue;
 515                 if (usbhsp_flags_has(pos, IS_USED))
 516                         continue;
 517
 518                 pipe = pos;
 519                 break;
 520         }
 521
 522         if (!pipe)
 523                 return NULL;
 524
 525         /*
 526          * initialize pipe flags
 527          */
 528         usbhsp_flags_init(pipe);
 529         usbhsp_flags_set(pipe, IS_USED);
 530
 531         return pipe;
 532 }
 533
 534 void usbhs_pipe_init(struct usbhs_priv *priv,
 535                      void (*done)(struct usbhs_pkt *pkt))
 536 {
 537         struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 538         struct device *dev = usbhs_priv_to_dev(priv);
 539         struct usbhs_pipe *pipe;
 540         int i;
 541
 542         if (!done) {
 543                 dev_err(dev, "no done function\n");
 544                 return;
 545         }
 546
 547         /*
 548          * FIXME
 549          *
 550          * driver needs good allocator.
 551          *
 552          * find first free buffer area (BULK, ISOC)
 553          * (DCP, INT area is fixed)
 554          *
 555          * buffer number 0 - 3 have been reserved for DCP
 556          * see
 557          *      usbhsp_to_bufnmb
 558          */
 559         info->bufnmb_last = 4;
 560         usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
 561                 if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_INT))
 562                         info->bufnmb_last++;
 563
 564                 usbhsp_flags_init(pipe);
 565                 pipe->mod_private = NULL;
 566                 INIT_LIST_HEAD(&pipe->list);
 567
 568                 /* pipe force init */
 569                 usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
 570                 usbhsp_pipectrl_set(pipe, ACLRM, 0);
 571         }
 572
 573         info->done = done;
 574 }
 575
 576 struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv,
 577                                      const struct usb_endpoint_descriptor *desc)
 578 {
 579         struct device *dev = usbhs_priv_to_dev(priv);
 580         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
 581         struct usbhs_pipe *pipe;
 582         int is_host = usbhs_mod_is_host(priv, mod);
 583         int ret;
 584         u16 pipecfg, pipebuf, pipemaxp;
 585
 586         pipe = usbhsp_get_pipe(priv, usb_endpoint_type(desc));
 587         if (!pipe) {
 588                 dev_err(dev, "can't get pipe (%s)\n",
 589                         usbhsp_pipe_name[usb_endpoint_type(desc)]);
 590                 return NULL;
 591         }
 592
 593         INIT_LIST_HEAD(&pipe->list);
 594
 595         usbhs_pipe_disable(pipe);
 596
 597         /* make sure pipe is not busy */
 598         ret = usbhsp_pipe_barrier(pipe);
 599         if (ret < 0) {
 600                 dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe));
 601                 return NULL;
 602         }
 603
 604         pipecfg  = usbhsp_setup_pipecfg(pipe,  desc, is_host);
 605         pipebuf  = usbhsp_setup_pipebuff(pipe, desc, is_host);
 606         pipemaxp = usbhsp_setup_pipemaxp(pipe, desc, is_host);
 607
 608         usbhsp_pipe_select(pipe);
 609         usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg);
 610         usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf);
 611         usbhsp_pipe_maxp_set(pipe, 0xFFFF, pipemaxp);
 612
 613         usbhs_pipe_clear_sequence(pipe);
 614
 615         dev_dbg(dev, "enable pipe %d : %s (%s)\n",
 616                 usbhs_pipe_number(pipe),
 617                 usbhsp_pipe_name[usb_endpoint_type(desc)],
 618                 usbhs_pipe_is_dir_in(pipe) ? "in" : "out");
 619
 620         return pipe;
 621 }
 622
 623 /*
 624  *              dcp control
 625  */
 626 struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv)
 627 {
 628         struct usbhs_pipe *pipe;
 629
 630         pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL);
 631         if (!pipe)
 632                 return NULL;
 633
 634         /*
 635          * dcpcfg  : default
 636          * dcpmaxp : default
 637          * pipebuf : nothing to do
 638          */
 639
 640         usbhsp_pipe_select(pipe);
 641         usbhs_pipe_clear_sequence(pipe);
 642         INIT_LIST_HEAD(&pipe->list);
 643
 644         return pipe;
 645 }
 646
 647 void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
 648 {
 649         WARN_ON(!usbhs_pipe_is_dcp(pipe));
 650
 651         usbhs_pipe_enable(pipe);
 652         usbhsp_pipectrl_set(pipe, CCPL, CCPL);
 653 }
 654
 655 /*
 656  *              pipe module function
 657  */
 658 int usbhs_pipe_probe(struct usbhs_priv *priv)
 659 {
 660         struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 661         struct usbhs_pipe *pipe;
 662         struct device *dev = usbhs_priv_to_dev(priv);
 663         u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
 664         int pipe_size = usbhs_get_dparam(priv, pipe_size);
 665         int i;
 666
 667         /* This driver expects 1st pipe is DCP */
 668         if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) {
 669                 dev_err(dev, "1st PIPE is not DCP\n");
 670                 return -EINVAL;
 671         }
 672
 673         info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL);
 674         if (!info->pipe) {
 675                 dev_err(dev, "Could not allocate pipe\n");
 676                 return -ENOMEM;
 677         }
 678
 679         info->size = pipe_size;
 680
 681         /*
 682          * init pipe
 683          */
 684         usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
 685                 pipe->priv = priv;
 686                 usbhsp_type(pipe) = pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK;
 687
 688                 dev_dbg(dev, "pipe %x\t: %s\n",
 689                         i, usbhsp_pipe_name[pipe_type[i]]);
 690         }
 691
 692         return 0;
 693 }
 694
 695 void usbhs_pipe_remove(struct usbhs_priv *priv)
 696 {
 697         struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 698
 699         kfree(info->pipe);
 700 }