Quelle  pipe.c  Sprache: unbekannt

// SPDX-License-Identifier: GPL-1.0+
/*
 * Renesas USB driver
 *
 * Copyright (C) 2011 Renesas Solutions Corp.
 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
 */
#include <linux/delay.h>
#include <linux/slab.h>
#include "common.h"
#include "pipe.h"

/*
 *  macros
 */
#define usbhsp_addr_offset(p) ((usbhs_pipe_number(p) - 1) * 2)

#define usbhsp_flags_set(p, f) ((p)->flags |=  USBHS_PIPE_FLAGS_##f)
#define usbhsp_flags_clr(p, f) ((p)->flags &= ~USBHS_PIPE_FLAGS_##f)
#define usbhsp_flags_has(p, f) ((p)->flags &   USBHS_PIPE_FLAGS_##f)
#define usbhsp_flags_init(p) do {(p)->flags = 0; } while (0)

/*
 * for debug
 */
static char *usbhsp_pipe_name[] = {
 [USB_ENDPOINT_XFER_CONTROL] = "DCP",
 [USB_ENDPOINT_XFER_BULK] = "BULK",
 [USB_ENDPOINT_XFER_INT]  = "INT",
 [USB_ENDPOINT_XFER_ISOC] = "ISO",
};

char *usbhs_pipe_name(struct usbhs_pipe *pipe)
{
 return usbhsp_pipe_name[usbhs_pipe_type(pipe)];
}

static struct renesas_usbhs_driver_pipe_config
*usbhsp_get_pipe_config(struct usbhs_priv *priv, int pipe_num)
{
 struct renesas_usbhs_driver_pipe_config *pipe_configs =
     usbhs_get_dparam(priv, pipe_configs);

 return &pipe_configs[pipe_num];
}

/*
 *  DCPCTR/PIPEnCTR functions
 */
static void usbhsp_pipectrl_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 int offset = usbhsp_addr_offset(pipe);

 if (usbhs_pipe_is_dcp(pipe))
  usbhs_bset(priv, DCPCTR, mask, val);
 else
  usbhs_bset(priv, PIPEnCTR + offset, mask, val);
}

static u16 usbhsp_pipectrl_get(struct usbhs_pipe *pipe)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 int offset = usbhsp_addr_offset(pipe);

 if (usbhs_pipe_is_dcp(pipe))
  return usbhs_read(priv, DCPCTR);
 else
  return usbhs_read(priv, PIPEnCTR + offset);
}

/*
 *  DCP/PIPE functions
 */
static void __usbhsp_pipe_xxx_set(struct usbhs_pipe *pipe,
      u16 dcp_reg, u16 pipe_reg,
      u16 mask, u16 val)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);

 if (usbhs_pipe_is_dcp(pipe))
  usbhs_bset(priv, dcp_reg, mask, val);
 else
  usbhs_bset(priv, pipe_reg, mask, val);
}

static u16 __usbhsp_pipe_xxx_get(struct usbhs_pipe *pipe,
     u16 dcp_reg, u16 pipe_reg)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);

 if (usbhs_pipe_is_dcp(pipe))
  return usbhs_read(priv, dcp_reg);
 else
  return usbhs_read(priv, pipe_reg);
}

/*
 *  DCPCFG/PIPECFG functions
 */
static void usbhsp_pipe_cfg_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
{
 __usbhsp_pipe_xxx_set(pipe, DCPCFG, PIPECFG, mask, val);
}

static u16 usbhsp_pipe_cfg_get(struct usbhs_pipe *pipe)
{
 return __usbhsp_pipe_xxx_get(pipe, DCPCFG, PIPECFG);
}

/*
 *  PIPEnTRN/PIPEnTRE functions
 */
static void usbhsp_pipe_trn_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 struct device *dev = usbhs_priv_to_dev(priv);
 int num = usbhs_pipe_number(pipe);
 u16 reg;

 /*
  * It is impossible to calculate address,
  * since PIPEnTRN addresses were mapped randomly.
 */
#define CASE_PIPExTRN(a)  \
 case 0x ## a:   \
  reg = PIPE ## a ## TRN; \
  break;

 switch (num) {
 CASE_PIPExTRN(1);
 CASE_PIPExTRN(2);
 CASE_PIPExTRN(3);
 CASE_PIPExTRN(4);
 CASE_PIPExTRN(5);
 CASE_PIPExTRN(B);
 CASE_PIPExTRN(C);
 CASE_PIPExTRN(D);
 CASE_PIPExTRN(E);
 CASE_PIPExTRN(F);
 CASE_PIPExTRN(9);
 CASE_PIPExTRN(A);
 default:
  dev_err(dev, "unknown pipe (%d)\n", num);
  return;
 }
 __usbhsp_pipe_xxx_set(pipe, 0, reg, mask, val);
}

static void usbhsp_pipe_tre_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 struct device *dev = usbhs_priv_to_dev(priv);
 int num = usbhs_pipe_number(pipe);
 u16 reg;

 /*
  * It is impossible to calculate address,
  * since PIPEnTRE addresses were mapped randomly.
 */
#define CASE_PIPExTRE(a)   \
 case 0x ## a:    \
  reg = PIPE ## a ## TRE;  \
  break;

 switch (num) {
 CASE_PIPExTRE(1);
 CASE_PIPExTRE(2);
 CASE_PIPExTRE(3);
 CASE_PIPExTRE(4);
 CASE_PIPExTRE(5);
 CASE_PIPExTRE(B);
 CASE_PIPExTRE(C);
 CASE_PIPExTRE(D);
 CASE_PIPExTRE(E);
 CASE_PIPExTRE(F);
 CASE_PIPExTRE(9);
 CASE_PIPExTRE(A);
 default:
  dev_err(dev, "unknown pipe (%d)\n", num);
  return;
 }

 __usbhsp_pipe_xxx_set(pipe, 0, reg, mask, val);
}

/*
 *  PIPEBUF
 */
static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
{
 if (usbhs_pipe_is_dcp(pipe))
  return;

 __usbhsp_pipe_xxx_set(pipe, 0, PIPEBUF, mask, val);
}

/*
 *  DCPMAXP/PIPEMAXP
 */
static void usbhsp_pipe_maxp_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
{
 __usbhsp_pipe_xxx_set(pipe, DCPMAXP, PIPEMAXP, mask, val);
}

/*
 *  pipe control functions
 */
static void usbhsp_pipe_select(struct usbhs_pipe *pipe)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);

 /*
  * On pipe, this is necessary before
  * accesses to below registers.
  *
  * PIPESEL : usbhsp_pipe_select
  * PIPECFG : usbhsp_pipe_cfg_xxx
  * PIPEBUF : usbhsp_pipe_buf_xxx
  * PIPEMAXP : usbhsp_pipe_maxp_xxx
  * PIPEPERI
 */

 /*
  * if pipe is dcp, no pipe is selected.
  * it is no problem, because dcp have its register
 */
 usbhs_write(priv, PIPESEL, 0xF & usbhs_pipe_number(pipe));
}

static int usbhsp_pipe_barrier(struct usbhs_pipe *pipe)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 int timeout = 1024;
 u16 mask = usbhs_mod_is_host(priv) ? (CSSTS | PID_MASK) : PID_MASK;

 /*
  * make sure....
  *
  * Modify these bits when CSSTS = 0, PID = NAK, and no pipe number is
  * specified by the CURPIPE bits.
  * When changing the setting of this bit after changing
  * the PID bits for the selected pipe from BUF to NAK,
  * check that CSSTS = 0 and PBUSY = 0.
 */

 /*
  * CURPIPE bit = 0
  *
  * see also
  *  "Operation"
  *  - "Pipe Control"
  *   - "Pipe Control Registers Switching Procedure"
 */
 usbhs_write(priv, CFIFOSEL, 0);
 usbhs_pipe_disable(pipe);

 do {
  if (!(usbhsp_pipectrl_get(pipe) & mask))
   return 0;

  udelay(10);

 } while (timeout--);

 return -EBUSY;
}

int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe)
{
 u16 val;

 val = usbhsp_pipectrl_get(pipe);
 if (val & BSTS)
  return 0;

 return -EBUSY;
}

bool usbhs_pipe_contains_transmittable_data(struct usbhs_pipe *pipe)
{
 u16 val;

 /* Do not support for DCP pipe */
 if (usbhs_pipe_is_dcp(pipe))
  return false;

 val = usbhsp_pipectrl_get(pipe);
 if (val & INBUFM)
  return true;

 return false;
}

/*
 *  PID ctrl
 */
static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe)
{
 u16 pid = usbhsp_pipectrl_get(pipe);

 pid &= PID_MASK;

 /*
  * see
  * "Pipe n Control Register" - "PID"
 */
 switch (pid) {
 case PID_STALL11:
  usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
  fallthrough;
 case PID_STALL10:
  usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
 }
}

void usbhs_pipe_disable(struct usbhs_pipe *pipe)
{
 int timeout = 1024;
 u16 val;

 /* see "Pipe n Control Register" - "PID" */
 __usbhsp_pid_try_nak_if_stall(pipe);

 usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);

 do {
  val  = usbhsp_pipectrl_get(pipe);
  val &= PBUSY;
  if (!val)
   break;

  udelay(10);
 } while (timeout--);
}

void usbhs_pipe_enable(struct usbhs_pipe *pipe)
{
 /* see "Pipe n Control Register" - "PID" */
 __usbhsp_pid_try_nak_if_stall(pipe);

 usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF);
}

void usbhs_pipe_stall(struct usbhs_pipe *pipe)
{
 u16 pid = usbhsp_pipectrl_get(pipe);

 pid &= PID_MASK;

 /*
  * see
  * "Pipe n Control Register" - "PID"
 */
 switch (pid) {
 case PID_NAK:
  usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
  break;
 case PID_BUF:
  usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11);
  break;
 }
}

int usbhs_pipe_is_stall(struct usbhs_pipe *pipe)
{
 u16 pid = usbhsp_pipectrl_get(pipe) & PID_MASK;

 return (int)(pid == PID_STALL10 || pid == PID_STALL11);
}

void usbhs_pipe_set_trans_count_if_bulk(struct usbhs_pipe *pipe, int len)
{
 if (!usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
  return;

 /*
  * clear and disable transfer counter for IN/OUT pipe
 */
 usbhsp_pipe_tre_set(pipe, TRCLR | TRENB, TRCLR);

 /*
  * Only IN direction bulk pipe can use transfer count.
  * Without using this function,
  * received data will break if it was large data size.
  * see PIPEnTRN/PIPEnTRE for detail
 */
 if (usbhs_pipe_is_dir_in(pipe)) {
  int maxp = usbhs_pipe_get_maxpacket(pipe);

  usbhsp_pipe_trn_set(pipe, 0xffff, DIV_ROUND_UP(len, maxp));
  usbhsp_pipe_tre_set(pipe, TRENB, TRENB); /* enable */
 }
}


/*
 *  pipe setup
 */
static int usbhsp_setup_pipecfg(struct usbhs_pipe *pipe, int is_host,
    int dir_in, u16 *pipecfg)
{
 u16 type = 0;
 u16 bfre = 0;
 u16 dblb = 0;
 u16 cntmd = 0;
 u16 dir = 0;
 u16 epnum = 0;
 u16 shtnak = 0;
 static const u16 type_array[] = {
  [USB_ENDPOINT_XFER_BULK] = TYPE_BULK,
  [USB_ENDPOINT_XFER_INT]  = TYPE_INT,
  [USB_ENDPOINT_XFER_ISOC] = TYPE_ISO,
 };

 if (usbhs_pipe_is_dcp(pipe))
  return -EINVAL;

 /*
  * PIPECFG
  *
  * see
  *  - "Register Descriptions" - "PIPECFG" register
  *  - "Features"  - "Pipe configuration"
  *  - "Operation" - "Pipe Control"
 */

 /* TYPE */
 type = type_array[usbhs_pipe_type(pipe)];

 /* BFRE */
 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
     usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
  bfre = 0; /* FIXME */

 /* DBLB: see usbhs_pipe_config_update() */

 /* CNTMD */
 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
  cntmd = 0; /* FIXME */

 /* DIR */
 if (dir_in)
  usbhsp_flags_set(pipe, IS_DIR_HOST);

 if (!!is_host ^ !!dir_in)
  dir |= DIR_OUT;

 if (!dir)
  usbhsp_flags_set(pipe, IS_DIR_IN);

 /* SHTNAK */
 if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) &&
     !dir)
  shtnak = SHTNAK;

 /* EPNUM */
 epnum = 0; /* see usbhs_pipe_config_update() */
 *pipecfg = type  |
     bfre  |
     dblb  |
     cntmd |
     dir  |
     shtnak |
     epnum;
 return 0;
}

static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 struct device *dev = usbhs_priv_to_dev(priv);
 int pipe_num = usbhs_pipe_number(pipe);
 u16 buff_size;
 u16 bufnmb;
 u16 bufnmb_cnt;
 struct renesas_usbhs_driver_pipe_config *pipe_config =
     usbhsp_get_pipe_config(priv, pipe_num);

 /*
  * PIPEBUF
  *
  * see
  *  - "Register Descriptions" - "PIPEBUF" register
  *  - "Features"  - "Pipe configuration"
  *  - "Operation" - "FIFO Buffer Memory"
  *  - "Operation" - "Pipe Control"
 */
 buff_size = pipe_config->bufsize;
 bufnmb = pipe_config->bufnum;

 /* change buff_size to register value */
 bufnmb_cnt = (buff_size / 64) - 1;

 dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n",
  pipe_num, buff_size, bufnmb);

 return (0x1f & bufnmb_cnt) << 10 |
  (0xff & bufnmb)  <<  0;
}

void usbhs_pipe_config_update(struct usbhs_pipe *pipe, u16 devsel,
         u16 epnum, u16 maxp)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
 int pipe_num = usbhs_pipe_number(pipe);
 struct renesas_usbhs_driver_pipe_config *pipe_config =
     usbhsp_get_pipe_config(priv, pipe_num);
 u16 dblb = pipe_config->double_buf ? DBLB : 0;

 if (devsel > 0xA) {
  struct device *dev = usbhs_priv_to_dev(priv);

  dev_err(dev, "devsel error %d\n", devsel);

  devsel = 0;
 }

 usbhsp_pipe_barrier(pipe);

 pipe->maxp = maxp;

 usbhsp_pipe_select(pipe);
 usbhsp_pipe_maxp_set(pipe, 0xFFFF,
        (devsel << 12) |
        maxp);

 if (!usbhs_pipe_is_dcp(pipe))
  usbhsp_pipe_cfg_set(pipe,  0x000F | DBLB, epnum | dblb);
}

/*
 *  pipe control
 */
int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe)
{
 /*
  * see
  * usbhs_pipe_config_update()
  * usbhs_dcp_malloc()
 */
 return pipe->maxp;
}

int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe)
{
 return usbhsp_flags_has(pipe, IS_DIR_IN);
}

int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe)
{
 return usbhsp_flags_has(pipe, IS_DIR_HOST);
}

int usbhs_pipe_is_running(struct usbhs_pipe *pipe)
{
 return usbhsp_flags_has(pipe, IS_RUNNING);
}

void usbhs_pipe_running(struct usbhs_pipe *pipe, int running)
{
 if (running)
  usbhsp_flags_set(pipe, IS_RUNNING);
 else
  usbhsp_flags_clr(pipe, IS_RUNNING);
}

void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence)
{
 u16 mask = (SQCLR | SQSET);
 u16 val;

 /*
  * sequence
  *  0  : data0
  *  1  : data1
  *  -1 : no change
 */
 switch (sequence) {
 case 0:
  val = SQCLR;
  break;
 case 1:
  val = SQSET;
  break;
 default:
  return;
 }

 usbhsp_pipectrl_set(pipe, mask, val);
}

static int usbhs_pipe_get_data_sequence(struct usbhs_pipe *pipe)
{
 return !!(usbhsp_pipectrl_get(pipe) & SQMON);
}

void usbhs_pipe_clear(struct usbhs_pipe *pipe)
{
 if (usbhs_pipe_is_dcp(pipe)) {
  usbhs_fifo_clear_dcp(pipe);
 } else {
  usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
  usbhsp_pipectrl_set(pipe, ACLRM, 0);
 }
}

/* Should call usbhsp_pipe_select() before */
void usbhs_pipe_clear_without_sequence(struct usbhs_pipe *pipe,
           int needs_bfre, int bfre_enable)
{
 int sequence;

 usbhsp_pipe_select(pipe);
 sequence = usbhs_pipe_get_data_sequence(pipe);
 if (needs_bfre)
  usbhsp_pipe_cfg_set(pipe, BFRE, bfre_enable ? BFRE : 0);
 usbhs_pipe_clear(pipe);
 usbhs_pipe_data_sequence(pipe, sequence);
}

void usbhs_pipe_config_change_bfre(struct usbhs_pipe *pipe, int enable)
{
 if (usbhs_pipe_is_dcp(pipe))
  return;

 usbhsp_pipe_select(pipe);
 /* check if the driver needs to change the BFRE value */
 if (!(enable ^ !!(usbhsp_pipe_cfg_get(pipe) & BFRE)))
  return;

 usbhs_pipe_clear_without_sequence(pipe, 1, enable);
}

static struct usbhs_pipe *usbhsp_get_pipe(struct usbhs_priv *priv, u32 type)
{
 struct usbhs_pipe *pos, *pipe;
 int i;

 /*
  * find target pipe
 */
 pipe = NULL;
 usbhs_for_each_pipe_with_dcp(pos, priv, i) {
  if (!usbhs_pipe_type_is(pos, type))
   continue;
  if (usbhsp_flags_has(pos, IS_USED))
   continue;

  pipe = pos;
  break;
 }

 if (!pipe)
  return NULL;

 /*
  * initialize pipe flags
 */
 usbhsp_flags_init(pipe);
 usbhsp_flags_set(pipe, IS_USED);

 return pipe;
}

static void usbhsp_put_pipe(struct usbhs_pipe *pipe)
{
 usbhsp_flags_init(pipe);
}

void usbhs_pipe_init(struct usbhs_priv *priv,
       int (*dma_map_ctrl)(struct device *dma_dev,
      struct usbhs_pkt *pkt, int map))
{
 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 struct usbhs_pipe *pipe;
 int i;

 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
  usbhsp_flags_init(pipe);
  pipe->fifo = NULL;
  pipe->mod_private = NULL;
  INIT_LIST_HEAD(&pipe->list);

  /* pipe force init */
  usbhs_pipe_clear(pipe);
 }

 info->dma_map_ctrl = dma_map_ctrl;
}

struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv,
         int endpoint_type,
         int dir_in)
{
 struct device *dev = usbhs_priv_to_dev(priv);
 struct usbhs_pipe *pipe;
 int is_host = usbhs_mod_is_host(priv);
 int ret;
 u16 pipecfg, pipebuf;

 pipe = usbhsp_get_pipe(priv, endpoint_type);
 if (!pipe) {
  dev_err(dev, "can't get pipe (%s)\n",
   usbhsp_pipe_name[endpoint_type]);
  return NULL;
 }

 INIT_LIST_HEAD(&pipe->list);

 usbhs_pipe_disable(pipe);

 /* make sure pipe is not busy */
 ret = usbhsp_pipe_barrier(pipe);
 if (ret < 0) {
  dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe));
  return NULL;
 }

 if (usbhsp_setup_pipecfg(pipe, is_host, dir_in, &pipecfg)) {
  dev_err(dev, "can't setup pipe\n");
  return NULL;
 }

 pipebuf  = usbhsp_setup_pipebuff(pipe);

 usbhsp_pipe_select(pipe);
 usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg);
 usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf);
 usbhs_pipe_clear(pipe);

 usbhs_pipe_sequence_data0(pipe);

 dev_dbg(dev, "enable pipe %d : %s (%s)\n",
  usbhs_pipe_number(pipe),
  usbhs_pipe_name(pipe),
  usbhs_pipe_is_dir_in(pipe) ? "in" : "out");

 /*
  * epnum / maxp are still not set to this pipe.
  * call usbhs_pipe_config_update() after this function !!
 */

 return pipe;
}

void usbhs_pipe_free(struct usbhs_pipe *pipe)
{
 usbhsp_pipe_select(pipe);
 usbhsp_pipe_cfg_set(pipe, 0xFFFF, 0);
 usbhsp_put_pipe(pipe);
}

void usbhs_pipe_select_fifo(struct usbhs_pipe *pipe, struct usbhs_fifo *fifo)
{
 if (pipe->fifo)
  pipe->fifo->pipe = NULL;

 pipe->fifo = fifo;

 if (fifo)
  fifo->pipe = pipe;
}


/*
 *  dcp control
 */
struct usbhs_pipe *usbhs_dcp_malloc(struct usbhs_priv *priv)
{
 struct usbhs_pipe *pipe;

 pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL);
 if (!pipe)
  return NULL;

 INIT_LIST_HEAD(&pipe->list);

 /*
  * call usbhs_pipe_config_update() after this function !!
 */

 return pipe;
}

void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
{
 struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);

 WARN_ON(!usbhs_pipe_is_dcp(pipe));

 usbhs_pipe_enable(pipe);

 if (!usbhs_mod_is_host(priv)) /* funconly */
  usbhsp_pipectrl_set(pipe, CCPL, CCPL);
}

void usbhs_dcp_dir_for_host(struct usbhs_pipe *pipe, int dir_out)
{
 usbhsp_pipe_cfg_set(pipe, DIR_OUT,
       dir_out ? DIR_OUT : 0);
}

/*
 *  pipe module function
 */
int usbhs_pipe_probe(struct usbhs_priv *priv)
{
 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
 struct usbhs_pipe *pipe;
 struct device *dev = usbhs_priv_to_dev(priv);
 struct renesas_usbhs_driver_pipe_config *pipe_configs =
     usbhs_get_dparam(priv, pipe_configs);
 int pipe_size = usbhs_get_dparam(priv, pipe_size);
 int i;

 /* This driver expects 1st pipe is DCP */
 if (pipe_configs[0].type != USB_ENDPOINT_XFER_CONTROL) {
  dev_err(dev, "1st PIPE is not DCP\n");
  return -EINVAL;
 }

 info->pipe = kcalloc(pipe_size, sizeof(struct usbhs_pipe),
        GFP_KERNEL);
 if (!info->pipe)
  return -ENOMEM;

 info->size = pipe_size;

 /*
  * init pipe
 */
 usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
  pipe->priv = priv;

  usbhs_pipe_type(pipe) =
   pipe_configs[i].type & USB_ENDPOINT_XFERTYPE_MASK;

  dev_dbg(dev, "pipe %x\t: %s\n",
   i, usbhsp_pipe_name[pipe_configs[i].type]);
 }

 return 0;
}

void usbhs_pipe_remove(struct usbhs_priv *priv)
{
 struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);

 kfree(info->pipe);
}