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