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 /*
  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 int usbhs_pipe_is_running(struct usbhs_pipe *pipe)
 582 {
 583         return usbhsp_flags_has(pipe, IS_RUNNING);
 584 }
 585
 586 void usbhs_pipe_running(struct usbhs_pipe *pipe, int running)
 587 {
 588         if (running)
 589                 usbhsp_flags_set(pipe, IS_RUNNING);
 590         else
 591                 usbhsp_flags_clr(pipe, IS_RUNNING);
 592 }
 593
 594 void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence)
 595 {
 596         u16 mask = (SQCLR | SQSET);
 597         u16 val;
 598
 599         /*
 600          * sequence
 601          *  0  : data0
 602          *  1  : data1
 603          *  -1 : no change
 604          */
 605         switch (sequence) {
 606         case 0:
 607                 val = SQCLR;
 608                 break;
 609         case 1:
 610                 val = SQSET;
 611                 break;
 612         default:
 613                 return;
 614         }
 615
 616         usbhsp_pipectrl_set(pipe, mask, val);
 617 }
 618
 619 void usbhs_pipe_clear(struct usbhs_pipe *pipe)
 620 {
 621         if (usbhs_pipe_is_dcp(pipe)) {
 622                 usbhs_fifo_clear_dcp(pipe);
 623         } else {
 624                 usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
 625                 usbhsp_pipectrl_set(pipe, ACLRM, 0);
 626         }
 627 }
 628
 629 static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type)
 630 {
 631         struct usbhs_pipe *pos, *pipe;
 632         int i;
 633
 634         /*
 635          * find target pipe
 636          */
 637         pipe = NULL;
 638         usbhs_for_each_pipe_with_dcp(pos, priv, i) {
 639                 if (!usbhs_pipe_type_is(pos, type))
 640                         continue;
 641                 if (usbhsp_flags_has(pos, IS_USED))
 642                         continue;
 643
 644                 pipe = pos;
 645                 break;
 646         }
 647
 648         if (!pipe)
 649                 return NULL;
 650
 651         /*
 652          * initialize pipe flags
 653          */
 654         usbhsp_flags_init(pipe);
 655         usbhsp_flags_set(pipe, IS_USED);
 656
 657         return pipe;
 658 }
 659
 660 static void usbhsp_put_pipe(struct usbhs_pipe *pipe)
 661 {
 662         usbhsp_flags_init(pipe);
 663 }
 664
 665 void usbhs_pipe_init(struct usbhs_priv *priv,
 666                      int (*dma_map_ctrl)(struct usbhs_pkt *pkt, int map))
 667 {
 668         struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 669         struct usbhs_pipe *pipe;
 670         int i;
 671
 672         /*
 673          * FIXME
 674          *
 675          * driver needs good allocator.
 676          *
 677          * find first free buffer area (BULK, ISOC)
 678          * (DCP, INT area is fixed)
 679          *
 680          * buffer number 0 - 3 have been reserved for DCP
 681          * see
 682          *      usbhsp_to_bufnmb
 683          */
 684         info->bufnmb_last = 4;
 685         usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
 686                 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
 687                         info->bufnmb_last++;
 688
 689                 usbhsp_flags_init(pipe);
 690                 pipe->fifo = NULL;
 691                 pipe->mod_private = NULL;
 692                 INIT_LIST_HEAD(&pipe->list);
 693
 694                 /* pipe force init */
 695                 usbhs_pipe_clear(pipe);
 696         }
 697
 698         info->dma_map_ctrl = dma_map_ctrl;
 699 }
 700
 701 struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv,
 702                                      int endpoint_type,
 703                                      int dir_in)
 704 {
 705         struct device *dev = usbhs_priv_to_dev(priv);
 706         struct usbhs_pipe *pipe;
 707         int is_host = usbhs_mod_is_host(priv);
 708         int ret;
 709         u16 pipecfg, pipebuf;
 710
 711         pipe = usbhsp_get_pipe(priv, endpoint_type);
 712         if (!pipe) {
 713                 dev_err(dev, "can't get pipe (%s)\n",
 714                         usbhsp_pipe_name[endpoint_type]);
 715                 return NULL;
 716         }
 717
 718         INIT_LIST_HEAD(&pipe->list);
 719
 720         usbhs_pipe_disable(pipe);
 721
 722         /* make sure pipe is not busy */
 723         ret = usbhsp_pipe_barrier(pipe);
 724         if (ret < 0) {
 725                 dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe));
 726                 return NULL;
 727         }
 728
 729         pipecfg  = usbhsp_setup_pipecfg(pipe, is_host, dir_in);
 730         pipebuf  = usbhsp_setup_pipebuff(pipe);
 731
 732         usbhsp_pipe_select(pipe);
 733         usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg);
 734         usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf);
 735         usbhs_pipe_clear(pipe);
 736
 737         usbhs_pipe_sequence_data0(pipe);
 738
 739         dev_dbg(dev, "enable pipe %d : %s (%s)\n",
 740                 usbhs_pipe_number(pipe),
 741                 usbhs_pipe_name(pipe),
 742                 usbhs_pipe_is_dir_in(pipe) ? "in" : "out");
 743
 744         /*
 745          * epnum / maxp are still not set to this pipe.
 746          * call usbhs_pipe_config_update() after this function !!
 747          */
 748
 749         return pipe;
 750 }
 751
 752 void usbhs_pipe_free(struct usbhs_pipe *pipe)
 753 {
 754         usbhsp_put_pipe(pipe);
 755 }
 756
 757 void usbhs_pipe_select_fifo(struct usbhs_pipe *pipe, struct usbhs_fifo *fifo)
 758 {
 759         if (pipe->fifo)
 760                 pipe->fifo->pipe = NULL;
 761
 762         pipe->fifo = fifo;
 763
 764         if (fifo)
 765                 fifo->pipe = pipe;
 766 }
 767
 768
 769 /*
 770  *              dcp control
 771  */
 772 struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv)
 773 {
 774         struct usbhs_pipe *pipe;
 775
 776         pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL);
 777         if (!pipe)
 778                 return NULL;
 779
 780         INIT_LIST_HEAD(&pipe->list);
 781
 782         /*
 783          * call usbhs_pipe_config_update() after this function !!
 784          */
 785
 786         return pipe;
 787 }
 788
 789 void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
 790 {
 791         struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 792
 793         WARN_ON(!usbhs_pipe_is_dcp(pipe));
 794
 795         usbhs_pipe_enable(pipe);
 796
 797         if (!usbhs_mod_is_host(priv)) /* funconly */
 798                 usbhsp_pipectrl_set(pipe, CCPL, CCPL);
 799 }
 800
 801 void usbhs_dcp_dir_for_host(struct usbhs_pipe *pipe, int dir_out)
 802 {
 803         usbhsp_pipe_cfg_set(pipe, DIR_OUT,
 804                             dir_out ? DIR_OUT : 0);
 805 }
 806
 807 /*
 808  *              pipe module function
 809  */
 810 int usbhs_pipe_probe(struct usbhs_priv *priv)
 811 {
 812         struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 813         struct usbhs_pipe *pipe;
 814         struct device *dev = usbhs_priv_to_dev(priv);
 815         u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
 816         int pipe_size = usbhs_get_dparam(priv, pipe_size);
 817         int i;
 818
 819         /* This driver expects 1st pipe is DCP */
 820         if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) {
 821                 dev_err(dev, "1st PIPE is not DCP\n");
 822                 return -EINVAL;
 823         }
 824
 825         info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL);
 826         if (!info->pipe) {
 827                 dev_err(dev, "Could not allocate pipe\n");
 828                 return -ENOMEM;
 829         }
 830
 831         info->size = pipe_size;
 832
 833         /*
 834          * init pipe
 835          */
 836         usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
 837                 pipe->priv = priv;
 838
 839                 usbhs_pipe_type(pipe) =
 840                         pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK;
 841
 842                 dev_dbg(dev, "pipe %x\t: %s\n",
 843                         i, usbhsp_pipe_name[pipe_type[i]]);
 844         }
 845
 846         return 0;
 847 }
 848
 849 void usbhs_pipe_remove(struct usbhs_priv *priv)
 850 {
 851         struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 852
 853         kfree(info->pipe);
 854 }