drivers/usb/renesas_usbhs/pipe.c

   1 /*
   2  * Renesas USB driver
   3  *
   4  * Copyright (C) 2011 Renesas Solutions Corp.
   5  * Kuninori Morimoto <[email protected]>
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  15  *
  16  */
  17 #include <linux/delay.h>
  18 #include <linux/slab.h>
  19 #include "common.h"
  20 #include "pipe.h"
  21
  22 /*
  23  *              macros
  24  */
  25 #define usbhsp_addr_offset(p)   ((usbhs_pipe_number(p) - 1) * 2)
  26
  27 #define usbhsp_flags_set(p, f)  ((p)->flags |=  USBHS_PIPE_FLAGS_##f)
  28 #define usbhsp_flags_clr(p, f)  ((p)->flags &= ~USBHS_PIPE_FLAGS_##f)
  29 #define usbhsp_flags_has(p, f)  ((p)->flags &   USBHS_PIPE_FLAGS_##f)
  30 #define usbhsp_flags_init(p)    do {(p)->flags = 0; } while (0)
  31
  32 /*
  33  * for debug
  34  */
  35 static char *usbhsp_pipe_name[] = {
  36         [USB_ENDPOINT_XFER_CONTROL]     = "DCP",
  37         [USB_ENDPOINT_XFER_BULK]        = "BULK",
  38         [USB_ENDPOINT_XFER_INT]         = "INT",
  39         [USB_ENDPOINT_XFER_ISOC]        = "ISO",
  40 };
  41
  42 char *usbhs_pipe_name(struct usbhs_pipe *pipe)
  43 {
  44         return usbhsp_pipe_name[usbhs_pipe_type(pipe)];
  45 }
  46
  47 /*
  48  *              DCPCTR/PIPEnCTR functions
  49  */
  50 static void usbhsp_pipectrl_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
  51 {
  52         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
  53         int offset = usbhsp_addr_offset(pipe);
  54
  55         if (usbhs_pipe_is_dcp(pipe))
  56                 usbhs_bset(priv, DCPCTR, mask, val);
  57         else
  58                 usbhs_bset(priv, PIPEnCTR + offset, mask, val);
  59 }
  60
  61 static u16 usbhsp_pipectrl_get(struct usbhs_pipe *pipe)
  62 {
  63         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
  64         int offset = usbhsp_addr_offset(pipe);
  65
  66         if (usbhs_pipe_is_dcp(pipe))
  67                 return usbhs_read(priv, DCPCTR);
  68         else
  69                 return usbhs_read(priv, PIPEnCTR + offset);
  70 }
  71
  72 /*
  73  *              DCP/PIPE functions
  74  */
  75 static void __usbhsp_pipe_xxx_set(struct usbhs_pipe *pipe,
  76                                   u16 dcp_reg, u16 pipe_reg,
  77                                   u16 mask, u16 val)
  78 {
  79         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
  80
  81         if (usbhs_pipe_is_dcp(pipe))
  82                 usbhs_bset(priv, dcp_reg, mask, val);
  83         else
  84                 usbhs_bset(priv, pipe_reg, mask, val);
  85 }
  86
  87 /*
  88  *              DCPCFG/PIPECFG functions
  89  */
  90 static void usbhsp_pipe_cfg_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
  91 {
  92         __usbhsp_pipe_xxx_set(pipe, DCPCFG, PIPECFG, mask, val);
  93 }
  94
  95 /*
  96  *              PIPEnTRN/PIPEnTRE functions
  97  */
  98 static void usbhsp_pipe_trn_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
  99 {
 100         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 101         struct device *dev = usbhs_priv_to_dev(priv);
 102         int num = usbhs_pipe_number(pipe);
 103         u16 reg;
 104
 105         /*
 106          * It is impossible to calculate address,
 107          * since PIPEnTRN addresses were mapped randomly.
 108          */
 109 #define CASE_PIPExTRN(a)                \
 110         case 0x ## a:                   \
 111                 reg = PIPE ## a ## TRN; \
 112                 break;
 113
 114         switch (num) {
 115         CASE_PIPExTRN(1);
 116         CASE_PIPExTRN(2);
 117         CASE_PIPExTRN(3);
 118         CASE_PIPExTRN(4);
 119         CASE_PIPExTRN(5);
 120         CASE_PIPExTRN(B);
 121         CASE_PIPExTRN(C);
 122         CASE_PIPExTRN(D);
 123         CASE_PIPExTRN(E);
 124         CASE_PIPExTRN(F);
 125         CASE_PIPExTRN(9);
 126         CASE_PIPExTRN(A);
 127         default:
 128                 dev_err(dev, "unknown pipe (%d)\n", num);
 129                 return;
 130         }
 131         __usbhsp_pipe_xxx_set(pipe, 0, reg, mask, val);
 132 }
 133
 134 static void usbhsp_pipe_tre_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
 135 {
 136         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 137         struct device *dev = usbhs_priv_to_dev(priv);
 138         int num = usbhs_pipe_number(pipe);
 139         u16 reg;
 140
 141         /*
 142          * It is impossible to calculate address,
 143          * since PIPEnTRE addresses were mapped randomly.
 144          */
 145 #define CASE_PIPExTRE(a)                        \
 146         case 0x ## a:                           \
 147                 reg = PIPE ## a ## TRE;         \
 148                 break;
 149
 150         switch (num) {
 151         CASE_PIPExTRE(1);
 152         CASE_PIPExTRE(2);
 153         CASE_PIPExTRE(3);
 154         CASE_PIPExTRE(4);
 155         CASE_PIPExTRE(5);
 156         CASE_PIPExTRE(B);
 157         CASE_PIPExTRE(C);
 158         CASE_PIPExTRE(D);
 159         CASE_PIPExTRE(E);
 160         CASE_PIPExTRE(F);
 161         CASE_PIPExTRE(9);
 162         CASE_PIPExTRE(A);
 163         default:
 164                 dev_err(dev, "unknown pipe (%d)\n", num);
 165                 return;
 166         }
 167
 168         __usbhsp_pipe_xxx_set(pipe, 0, reg, mask, val);
 169 }
 170
 171 /*
 172  *              PIPEBUF
 173  */
 174 static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
 175 {
 176         if (usbhs_pipe_is_dcp(pipe))
 177                 return;
 178
 179         __usbhsp_pipe_xxx_set(pipe, 0, PIPEBUF, mask, val);
 180 }
 181
 182 /*
 183  *              DCPMAXP/PIPEMAXP
 184  */
 185 static void usbhsp_pipe_maxp_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
 186 {
 187         __usbhsp_pipe_xxx_set(pipe, DCPMAXP, PIPEMAXP, mask, val);
 188 }
 189
 190 /*
 191  *              pipe control functions
 192  */
 193 static void usbhsp_pipe_select(struct usbhs_pipe *pipe)
 194 {
 195         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 196
 197         /*
 198          * On pipe, this is necessary before
 199          * accesses to below registers.
 200          *
 201          * PIPESEL      : usbhsp_pipe_select
 202          * PIPECFG      : usbhsp_pipe_cfg_xxx
 203          * PIPEBUF      : usbhsp_pipe_buf_xxx
 204          * PIPEMAXP     : usbhsp_pipe_maxp_xxx
 205          * PIPEPERI
 206          */
 207
 208         /*
 209          * if pipe is dcp, no pipe is selected.
 210          * it is no problem, because dcp have its register
 211          */
 212         usbhs_write(priv, PIPESEL, 0xF & usbhs_pipe_number(pipe));
 213 }
 214
 215 static int usbhsp_pipe_barrier(struct usbhs_pipe *pipe)
 216 {
 217         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 218         int timeout = 1024;
 219         u16 val;
 220
 221         /*
 222          * make sure....
 223          *
 224          * Modify these bits when CSSTS = 0, PID = NAK, and no pipe number is
 225          * specified by the CURPIPE bits.
 226          * When changing the setting of this bit after changing
 227          * the PID bits for the selected pipe from BUF to NAK,
 228          * check that CSSTS = 0 and PBUSY = 0.
 229          */
 230
 231         /*
 232          * CURPIPE bit = 0
 233          *
 234          * see also
 235          *  "Operation"
 236          *  - "Pipe Control"
 237          *   - "Pipe Control Registers Switching Procedure"
 238          */
 239         usbhs_write(priv, CFIFOSEL, 0);
 240         usbhs_pipe_disable(pipe);
 241
 242         do {
 243                 val  = usbhsp_pipectrl_get(pipe);
 244                 val &= CSSTS | PID_MASK;
 245                 if (!val)
 246                         return 0;
 247
 248                 udelay(10);
 249
 250         } while (timeout--);
 251
 252         return -EBUSY;
 253 }
 254
 255 int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe)
 256 {
 257         u16 val;
 258
 259         val = usbhsp_pipectrl_get(pipe);
 260         if (val & BSTS)
 261                 return 0;
 262
 263         return -EBUSY;
 264 }
 265
 266 /*
 267  *              PID ctrl
 268  */
 269 static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe)
 270 {
 271         u16 pid = usbhsp_pipectrl_get(pipe);
 272
 273         pid &= PID_MASK;
 274
 275         /*
 276          * see
 277          * "Pipe n Control Register" - "PID"
 278          */
 279         switch (pid) {
 280         case PID_STALL11:
 281                 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
 282                 /* fall-through */
 283         case PID_STALL10:
 284                 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
 285         }
 286 }
 287
 288 void usbhs_pipe_disable(struct usbhs_pipe *pipe)
 289 {
 290         int timeout = 1024;
 291         u16 val;
 292
 293         /* see "Pipe n Control Register" - "PID" */
 294         __usbhsp_pid_try_nak_if_stall(pipe);
 295
 296         usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
 297
 298         do {
 299                 val  = usbhsp_pipectrl_get(pipe);
 300                 val &= PBUSY;
 301                 if (!val)
 302                         break;
 303
 304                 udelay(10);
 305         } while (timeout--);
 306 }
 307
 308 void usbhs_pipe_enable(struct usbhs_pipe *pipe)
 309 {
 310         /* see "Pipe n Control Register" - "PID" */
 311         __usbhsp_pid_try_nak_if_stall(pipe);
 312
 313         usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF);
 314 }
 315
 316 void usbhs_pipe_stall(struct usbhs_pipe *pipe)
 317 {
 318         u16 pid = usbhsp_pipectrl_get(pipe);
 319
 320         pid &= PID_MASK;
 321
 322         /*
 323          * see
 324          * "Pipe n Control Register" - "PID"
 325          */
 326         switch (pid) {
 327         case PID_NAK:
 328                 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
 329                 break;
 330         case PID_BUF:
 331                 usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11);
 332                 break;
 333         }
 334 }
 335
 336 int usbhs_pipe_is_stall(struct usbhs_pipe *pipe)
 337 {
 338         u16 pid = usbhsp_pipectrl_get(pipe) & PID_MASK;
 339
 340         return (int)(pid == PID_STALL10 || pid == PID_STALL11);
 341 }
 342
 343 void usbhs_pipe_set_trans_count_if_bulk(struct usbhs_pipe *pipe, int len)
 344 {
 345         if (!usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
 346                 return;
 347
 348         /*
 349          * clear and disable transfer counter for IN/OUT pipe
 350          */
 351         usbhsp_pipe_tre_set(pipe, TRCLR | TRENB, TRCLR);
 352
 353         /*
 354          * Only IN direction bulk pipe can use transfer count.
 355          * Without using this function,
 356          * received data will break if it was large data size.
 357          * see PIPEnTRN/PIPEnTRE for detail
 358          */
 359         if (usbhs_pipe_is_dir_in(pipe)) {
 360                 int maxp = usbhs_pipe_get_maxpacket(pipe);
 361
 362                 usbhsp_pipe_trn_set(pipe, 0xffff, DIV_ROUND_UP(len, maxp));
 363                 usbhsp_pipe_tre_set(pipe, TRENB, TRENB); /* enable */
 364         }
 365 }
 366
 367
 368 /*
 369  *              pipe setup
 370  */
 371 static int usbhsp_possible_double_buffer(struct usbhs_pipe *pipe)
 372 {
 373         /*
 374          * only ISO / BULK pipe can use double buffer
 375          */
 376         if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) ||
 377             usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
 378                 return 1;
 379
 380         return 0;
 381 }
 382
 383 static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe,
 384                                 int is_host,
 385                                 int dir_in)
 386 {
 387         u16 type = 0;
 388         u16 bfre = 0;
 389         u16 dblb = 0;
 390         u16 cntmd = 0;
 391         u16 dir = 0;
 392         u16 epnum = 0;
 393         u16 shtnak = 0;
 394         u16 type_array[] = {
 395                 [USB_ENDPOINT_XFER_BULK] = TYPE_BULK,
 396                 [USB_ENDPOINT_XFER_INT]  = TYPE_INT,
 397                 [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO,
 398         };
 399         int is_double = usbhsp_possible_double_buffer(pipe);
 400
 401         if (usbhs_pipe_is_dcp(pipe))
 402                 return -EINVAL;
 403
 404         /*
 405          * PIPECFG
 406          *
 407          * see
 408          *  - "Register Descriptions" - "PIPECFG" register
 409          *  - "Features"  - "Pipe configuration"
 410          *  - "Operation" - "Pipe Control"
 411          */
 412
 413         /* TYPE */
 414         type = type_array[usbhs_pipe_type(pipe)];
 415
 416         /* BFRE */
 417         if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
 418             usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
 419                 bfre = 0; /* FIXME */
 420
 421         /* DBLB */
 422         if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
 423             usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
 424                 dblb = (is_double) ? DBLB : 0;
 425
 426         /* CNTMD */
 427         if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
 428                 cntmd = 0; /* FIXME */
 429
 430         /* DIR */
 431         if (dir_in)
 432                 usbhsp_flags_set(pipe, IS_DIR_HOST);
 433
 434         if (!!is_host ^ !!dir_in)
 435                 dir |= DIR_OUT;
 436
 437         if (!dir)
 438                 usbhsp_flags_set(pipe, IS_DIR_IN);
 439
 440         /* SHTNAK */
 441         if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) &&
 442             !dir)
 443                 shtnak = SHTNAK;
 444
 445         /* EPNUM */
 446         epnum = 0; /* see usbhs_pipe_config_update() */
 447
 448         return  type    |
 449                 bfre    |
 450                 dblb    |
 451                 cntmd   |
 452                 dir     |
 453                 shtnak  |
 454                 epnum;
 455 }
 456
 457 static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe)
 458 {
 459         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 460         struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 461         struct device *dev = usbhs_priv_to_dev(priv);
 462         int pipe_num = usbhs_pipe_number(pipe);
 463         int is_double = usbhsp_possible_double_buffer(pipe);
 464         u16 buff_size;
 465         u16 bufnmb;
 466         u16 bufnmb_cnt;
 467
 468         /*
 469          * PIPEBUF
 470          *
 471          * see
 472          *  - "Register Descriptions" - "PIPEBUF" register
 473          *  - "Features"  - "Pipe configuration"
 474          *  - "Operation" - "FIFO Buffer Memory"
 475          *  - "Operation" - "Pipe Control"
 476          *
 477          * ex) if pipe6 - pipe9 are USB_ENDPOINT_XFER_INT (SH7724)
 478          *
 479          * BUFNMB:      PIPE
 480          * 0:           pipe0 (DCP 256byte)
 481          * 1:           -
 482          * 2:           -
 483          * 3:           -
 484          * 4:           pipe6 (INT 64byte)
 485          * 5:           pipe7 (INT 64byte)
 486          * 6:           pipe8 (INT 64byte)
 487          * 7:           pipe9 (INT 64byte)
 488          * 8 - xx:      free (for BULK, ISOC)
 489          */
 490
 491         /*
 492          * FIXME
 493          *
 494          * it doesn't have good buffer allocator
 495          *
 496          * DCP : 256 byte
 497          * BULK: 512 byte
 498          * INT :  64 byte
 499          * ISOC: 512 byte
 500          */
 501         if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_CONTROL))
 502                 buff_size = 256;
 503         else if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
 504                 buff_size = 64;
 505         else
 506                 buff_size = 512;
 507
 508         /* change buff_size to register value */
 509         bufnmb_cnt = (buff_size / 64) - 1;
 510
 511         /* BUFNMB has been reserved for INT pipe
 512          * see above */
 513         if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT)) {
 514                 bufnmb = pipe_num - 2;
 515         } else {
 516                 bufnmb = info->bufnmb_last;
 517                 info->bufnmb_last += bufnmb_cnt + 1;
 518
 519                 /*
 520                  * double buffer
 521                  */
 522                 if (is_double)
 523                         info->bufnmb_last += bufnmb_cnt + 1;
 524         }
 525
 526         dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n",
 527                 pipe_num, buff_size, bufnmb);
 528
 529         return  (0x1f & bufnmb_cnt)     << 10 |
 530                 (0xff & bufnmb)         <<  0;
 531 }
 532
 533 void usbhs_pipe_config_update(struct usbhs_pipe *pipe, u16 devsel,
 534                               u16 epnum, u16 maxp)
 535 {
 536         if (devsel > 0xA) {
 537                 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 538                 struct device *dev = usbhs_priv_to_dev(priv);
 539
 540                 dev_err(dev, "devsel error %d\n", devsel);
 541
 542                 devsel = 0;
 543         }
 544
 545         usbhsp_pipe_barrier(pipe);
 546
 547         pipe->maxp = maxp;
 548
 549         usbhsp_pipe_select(pipe);
 550         usbhsp_pipe_maxp_set(pipe, 0xFFFF,
 551                              (devsel << 12) |
 552                              maxp);
 553
 554         if (!usbhs_pipe_is_dcp(pipe))
 555                 usbhsp_pipe_cfg_set(pipe,  0x000F, epnum);
 556 }
 557
 558 /*
 559  *              pipe control
 560  */
 561 int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe)
 562 {
 563         /*
 564          * see
 565          *      usbhs_pipe_config_update()
 566          *      usbhs_dcp_malloc()
 567          */
 568         return pipe->maxp;
 569 }
 570
 571 int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe)
 572 {
 573         return usbhsp_flags_has(pipe, IS_DIR_IN);
 574 }
 575
 576 int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe)
 577 {
 578         return usbhsp_flags_has(pipe, IS_DIR_HOST);
 579 }
 580
 581 void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence)
 582 {
 583         u16 mask = (SQCLR | SQSET);
 584         u16 val;
 585
 586         /*
 587          * sequence
 588          *  0  : data0
 589          *  1  : data1
 590          *  -1 : no change
 591          */
 592         switch (sequence) {
 593         case 0:
 594                 val = SQCLR;
 595                 break;
 596         case 1:
 597                 val = SQSET;
 598                 break;
 599         default:
 600                 return;
 601         }
 602
 603         usbhsp_pipectrl_set(pipe, mask, val);
 604 }
 605
 606 void usbhs_pipe_clear(struct usbhs_pipe *pipe)
 607 {
 608         usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
 609         usbhsp_pipectrl_set(pipe, ACLRM, 0);
 610 }
 611
 612 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type)
 613 {
 614         struct usbhs_pipe *pos, *pipe;
 615         int i;
 616
 617         /*
 618          * find target pipe
 619          */
 620         pipe = NULL;
 621         usbhs_for_each_pipe_with_dcp(pos, priv, i) {
 622                 if (!usbhs_pipe_type_is(pos, type))
 623                         continue;
 624                 if (usbhsp_flags_has(pos, IS_USED))
 625                         continue;
 626
 627                 pipe = pos;
 628                 break;
 629         }
 630
 631         if (!pipe)
 632                 return NULL;
 633
 634         /*
 635          * initialize pipe flags
 636          */
 637         usbhsp_flags_init(pipe);
 638         usbhsp_flags_set(pipe, IS_USED);
 639
 640         return pipe;
 641 }
 642
 643 void usbhs_pipe_init(struct usbhs_priv *priv,
 644                      int (*dma_map_ctrl)(struct usbhs_pkt *pkt, int map))
 645 {
 646         struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 647         struct usbhs_pipe *pipe;
 648         int i;
 649
 650         /*
 651          * FIXME
 652          *
 653          * driver needs good allocator.
 654          *
 655          * find first free buffer area (BULK, ISOC)
 656          * (DCP, INT area is fixed)
 657          *
 658          * buffer number 0 - 3 have been reserved for DCP
 659          * see
 660          *      usbhsp_to_bufnmb
 661          */
 662         info->bufnmb_last = 4;
 663         usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
 664                 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
 665                         info->bufnmb_last++;
 666
 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
 714         usbhs_pipe_sequence_data0(pipe);
 715
 716         dev_dbg(dev, "enable pipe %d : %s (%s)\n",
 717                 usbhs_pipe_number(pipe),
 718                 usbhs_pipe_name(pipe),
 719                 usbhs_pipe_is_dir_in(pipe) ? "in" : "out");
 720
 721         /*
 722          * epnum / maxp are still not set to this pipe.
 723          * call usbhs_pipe_config_update() after this function !!
 724          */
 725
 726         return pipe;
 727 }
 728
 729 void usbhs_pipe_select_fifo(struct usbhs_pipe *pipe, struct usbhs_fifo *fifo)
 730 {
 731         if (pipe->fifo)
 732                 pipe->fifo->pipe = NULL;
 733
 734         pipe->fifo = fifo;
 735
 736         if (fifo)
 737                 fifo->pipe = pipe;
 738 }
 739
 740
 741 /*
 742  *              dcp control
 743  */
 744 struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv)
 745 {
 746         struct usbhs_pipe *pipe;
 747
 748         pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL);
 749         if (!pipe)
 750                 return NULL;
 751
 752         INIT_LIST_HEAD(&pipe->list);
 753
 754         /*
 755          * call usbhs_pipe_config_update() after this function !!
 756          */
 757
 758         return pipe;
 759 }
 760
 761 void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
 762 {
 763         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 764
 765         WARN_ON(!usbhs_pipe_is_dcp(pipe));
 766
 767         usbhs_pipe_enable(pipe);
 768
 769         if (!usbhs_mod_is_host(priv)) /* funconly */
 770                 usbhsp_pipectrl_set(pipe, CCPL, CCPL);
 771 }
 772
 773 void usbhs_dcp_dir_for_host(struct usbhs_pipe *pipe, int dir_out)
 774 {
 775         usbhsp_pipe_cfg_set(pipe, DIR_OUT,
 776                             dir_out ? DIR_OUT : 0);
 777 }
 778
 779 /*
 780  *              pipe module function
 781  */
 782 int usbhs_pipe_probe(struct usbhs_priv *priv)
 783 {
 784         struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 785         struct usbhs_pipe *pipe;
 786         struct device *dev = usbhs_priv_to_dev(priv);
 787         u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
 788         int pipe_size = usbhs_get_dparam(priv, pipe_size);
 789         int i;
 790
 791         /* This driver expects 1st pipe is DCP */
 792         if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) {
 793                 dev_err(dev, "1st PIPE is not DCP\n");
 794                 return -EINVAL;
 795         }
 796
 797         info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL);
 798         if (!info->pipe) {
 799                 dev_err(dev, "Could not allocate pipe\n");
 800                 return -ENOMEM;
 801         }
 802
 803         info->size = pipe_size;
 804
 805         /*
 806          * init pipe
 807          */
 808         usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
 809                 pipe->priv = priv;
 810
 811                 usbhs_pipe_type(pipe) =
 812                         pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK;
 813
 814                 dev_dbg(dev, "pipe %x\t: %s\n",
 815                         i, usbhsp_pipe_name[pipe_type[i]]);
 816         }
 817
 818         return 0;
 819 }
 820
 821 void usbhs_pipe_remove(struct usbhs_priv *priv)
 822 {
 823         struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 824
 825         kfree(info->pipe);
 826 }