[deliverable/linux.git] / drivers / usb / renesas_usbhs / pipe.c

/*
 * Renesas USB driver
 *
 * Copyright (C) 2011 Renesas Solutions Corp.
 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
#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)];
}

/*
 *		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);
}

/*
 *		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);
}

/*
 *		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 val;

	/*
	 * 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 {
		val  = usbhsp_pipectrl_get(pipe);
		val &= CSSTS | PID_MASK;
		if (!val)
			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;
}

/*
 *		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);
		/* fall-through */
	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);
}

/*
 *		pipe setup
 */
static int usbhsp_possible_double_buffer(struct usbhs_pipe *pipe)
{
	/*
	 * only ISO / BULK pipe can use double buffer
	 */
	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) ||
	    usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
		return 1;

	return 0;
}

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

	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 */
	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
	    usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
		dblb = (is_double) ? DBLB : 0;

	/* 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) ||
	    (!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() */

	return	type	|
		bfre	|
		dblb	|
		cntmd	|
		dir	|
		shtnak	|
		epnum;
}

static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe)
{
	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
	struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
	struct device *dev = usbhs_priv_to_dev(priv);
	int pipe_num = usbhs_pipe_number(pipe);
	int is_double = usbhsp_possible_double_buffer(pipe);
	u16 buff_size;
	u16 bufnmb;
	u16 bufnmb_cnt;

	/*
	 * PIPEBUF
	 *
	 * see
	 *  - "Register Descriptions" - "PIPEBUF" register
	 *  - "Features"  - "Pipe configuration"
	 *  - "Operation" - "FIFO Buffer Memory"
	 *  - "Operation" - "Pipe Control"
	 *
	 * ex) if pipe6 - pipe9 are USB_ENDPOINT_XFER_INT (SH7724)
	 *
	 * BUFNMB:	PIPE
	 * 0:		pipe0 (DCP 256byte)
	 * 1:		-
	 * 2:		-
	 * 3:		-
	 * 4:		pipe6 (INT 64byte)
	 * 5:		pipe7 (INT 64byte)
	 * 6:		pipe8 (INT 64byte)
	 * 7:		pipe9 (INT 64byte)
	 * 8 - xx:	free (for BULK, ISOC)
	 */

	/*
	 * FIXME
	 *
	 * it doesn't have good buffer allocator
	 *
	 * DCP : 256 byte
	 * BULK: 512 byte
	 * INT :  64 byte
	 * ISOC: 512 byte
	 */
	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_CONTROL))
		buff_size = 256;
	else if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
		buff_size = 64;
	else
		buff_size = 512;

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

	/* BUFNMB has been reserved for INT pipe
	 * see above */
	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT)) {
		bufnmb = pipe_num - 2;
	} else {
		bufnmb = info->bufnmb_last;
		info->bufnmb_last += bufnmb_cnt + 1;

		/*
		 * double buffer
		 */
		if (is_double)
			info->bufnmb_last += bufnmb_cnt + 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)
{
	if (devsel > 0xA) {
		struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
		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, epnum);
}

/*
 *		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);
}

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);
}

void usbhs_pipe_clear(struct usbhs_pipe *pipe)
{
	usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
	usbhsp_pipectrl_set(pipe, ACLRM, 0);
}

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;
}

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

	/*
	 * FIXME
	 *
	 * driver needs good allocator.
	 *
	 * find first free buffer area (BULK, ISOC)
	 * (DCP, INT area is fixed)
	 *
	 * buffer number 0 - 3 have been reserved for DCP
	 * see
	 *	usbhsp_to_bufnmb
	 */
	info->bufnmb_last = 4;
	usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
		if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
			info->bufnmb_last++;

		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;
	}

	pipecfg  = usbhsp_setup_pipecfg(pipe, is_host, dir_in);
	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_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_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);
	u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
	int pipe_size = usbhs_get_dparam(priv, pipe_size);
	int i;

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

	info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL);
	if (!info->pipe) {
		dev_err(dev, "Could not allocate pipe\n");
		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_type[i] & USB_ENDPOINT_XFERTYPE_MASK;

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

	return 0;
}

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

	kfree(info->pipe);
}
Commit	Line	Data
f1407d5c KM	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>
f1407d5c KM	18	#include <linux/slab.h>
	19	#include "./common.h"
	20	#include "./pipe.h"
	21
	22	/*
	23	* macros
	24	*/
f1407d5c KM	25	#define usbhsp_addr_offset(p) ((usbhs_pipe_number(p) - 1) * 2)
f1407d5c KM	26
f1407d5c KM	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
f1407d5c KM	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
3cf8ed12 KM	42	char usbhs_pipe_name(struct usbhs_pipe pipe)
	43	{
	44	return usbhsp_pipe_name[usbhs_pipe_type(pipe)];
	45	}
	46
f1407d5c KM	47	/*
	48	* DCPCTR/PIPEnCTR functions
	49	*/
	50	static void usbhsp_pipectrl_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
	51	{
e8d548d5	52	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
f1407d5c KM	53	int offset = usbhsp_addr_offset(pipe);
f1407d5c KM	54
e8d548d5	55	if (usbhs_pipe_is_dcp(pipe))
f1407d5c KM	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	{
e8d548d5	63	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
f1407d5c KM	64	int offset = usbhsp_addr_offset(pipe);
f1407d5c KM	65
e8d548d5	66	if (usbhs_pipe_is_dcp(pipe))
f1407d5c KM	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	{
e8d548d5	79	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
f1407d5c	80
e8d548d5	81	if (usbhs_pipe_is_dcp(pipe))
f1407d5c KM	82	usbhs_bset(priv, dcp_reg, mask, val);
	83	else
	84	usbhs_bset(priv, pipe_reg, mask, val);
	85	}
	86
f1407d5c KM	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	* PIPEBUF
	97	*/
	98	static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
	99	{
e8d548d5	100	if (usbhs_pipe_is_dcp(pipe))
f1407d5c KM	101	return;
	102
	103	__usbhsp_pipe_xxx_set(pipe, 0, PIPEBUF, mask, val);
	104	}
	105
	106	/*
	107	* DCPMAXP/PIPEMAXP
	108	*/
	109	static void usbhsp_pipe_maxp_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
	110	{
	111	__usbhsp_pipe_xxx_set(pipe, DCPMAXP, PIPEMAXP, mask, val);
	112	}
	113
f1407d5c KM	114	/*
	115	* pipe control functions
	116	*/
	117	static void usbhsp_pipe_select(struct usbhs_pipe *pipe)
	118	{
e8d548d5	119	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
f1407d5c KM	120
	121	/*
	122	* On pipe, this is necessary before
	123	* accesses to below registers.
	124	*
	125	* PIPESEL : usbhsp_pipe_select
	126	* PIPECFG : usbhsp_pipe_cfg_xxx
	127	* PIPEBUF : usbhsp_pipe_buf_xxx
	128	* PIPEMAXP : usbhsp_pipe_maxp_xxx
	129	* PIPEPERI
	130	*/
	131
	132	/*
	133	* if pipe is dcp, no pipe is selected.
	134	* it is no problem, because dcp have its register
	135	*/
	136	usbhs_write(priv, PIPESEL, 0xF & usbhs_pipe_number(pipe));
	137	}
	138
	139	static int usbhsp_pipe_barrier(struct usbhs_pipe *pipe)
	140	{
e8d548d5	141	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
f1407d5c KM	142	int timeout = 1024;
	143	u16 val;
	144
	145	/*
	146	* make sure....
	147	*
	148	* Modify these bits when CSSTS = 0, PID = NAK, and no pipe number is
	149	* specified by the CURPIPE bits.
	150	* When changing the setting of this bit after changing
	151	* the PID bits for the selected pipe from BUF to NAK,
	152	* check that CSSTS = 0 and PBUSY = 0.
	153	*/
	154
	155	/*
	156	* CURPIPE bit = 0
	157	*
	158	* see also
	159	* "Operation"
	160	* - "Pipe Control"
	161	* - "Pipe Control Registers Switching Procedure"
	162	*/
	163	usbhs_write(priv, CFIFOSEL, 0);
e8d548d5	164	usbhs_pipe_disable(pipe);
f1407d5c KM	165
	166	do {
	167	val = usbhsp_pipectrl_get(pipe);
	168	val &= CSSTS \| PID_MASK;
	169	if (!val)
	170	return 0;
	171
	172	udelay(10);
	173
	174	} while (timeout--);
	175
f1407d5c KM	176	return -EBUSY;
	177	}
	178
e8d548d5	179	int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe)
f1407d5c KM	180	{
	181	u16 val;
	182
	183	val = usbhsp_pipectrl_get(pipe);
	184	if (val & BSTS)
	185	return 0;
	186
	187	return -EBUSY;
	188	}
	189
	190	/*
	191	* PID ctrl
	192	*/
	193	static void __usbhsp_pid_try_nak_if_stall(struct usbhs_pipe *pipe)
	194	{
	195	u16 pid = usbhsp_pipectrl_get(pipe);
	196
	197	pid &= PID_MASK;
	198
	199	/*
	200	* see
	201	* "Pipe n Control Register" - "PID"
	202	*/
	203	switch (pid) {
	204	case PID_STALL11:
	205	usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
	206	/* fall-through */
	207	case PID_STALL10:
	208	usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
	209	}
	210	}
	211
e8d548d5	212	void usbhs_pipe_disable(struct usbhs_pipe *pipe)
f1407d5c	213	{
c786e09c KM	214	int timeout = 1024;
	215	u16 val;
	216
f1407d5c KM	217	/* see "Pipe n Control Register" - "PID" */
	218	__usbhsp_pid_try_nak_if_stall(pipe);
	219
	220	usbhsp_pipectrl_set(pipe, PID_MASK, PID_NAK);
c786e09c KM	221
	222	do {
	223	val = usbhsp_pipectrl_get(pipe);
	224	val &= PBUSY;
	225	if (!val)
	226	break;
	227
	228	udelay(10);
	229	} while (timeout--);
f1407d5c KM	230	}
f1407d5c KM	231
e8d548d5	232	void usbhs_pipe_enable(struct usbhs_pipe *pipe)
f1407d5c KM	233	{
	234	/* see "Pipe n Control Register" - "PID" */
	235	__usbhsp_pid_try_nak_if_stall(pipe);
	236
	237	usbhsp_pipectrl_set(pipe, PID_MASK, PID_BUF);
	238	}
	239
e8d548d5	240	void usbhs_pipe_stall(struct usbhs_pipe *pipe)
f1407d5c KM	241	{
	242	u16 pid = usbhsp_pipectrl_get(pipe);
	243
	244	pid &= PID_MASK;
	245
	246	/*
	247	* see
	248	* "Pipe n Control Register" - "PID"
	249	*/
	250	switch (pid) {
	251	case PID_NAK:
	252	usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL10);
	253	break;
	254	case PID_BUF:
	255	usbhsp_pipectrl_set(pipe, PID_MASK, PID_STALL11);
	256	break;
	257	}
	258	}
	259
9cf1b06e KM	260	int usbhs_pipe_is_stall(struct usbhs_pipe *pipe)
	261	{
	262	u16 pid = usbhsp_pipectrl_get(pipe) & PID_MASK;
	263
	264	return (int)(pid == PID_STALL10 \|\| pid == PID_STALL11);
	265	}
	266
f1407d5c KM	267	/*
	268	* pipe setup
	269	*/
	270	static int usbhsp_possible_double_buffer(struct usbhs_pipe *pipe)
	271	{
	272	/*
	273	* only ISO / BULK pipe can use double buffer
	274	*/
356db7ed KM	275	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) \|\|
356db7ed KM	276	usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
f1407d5c KM	277	return 1;
	278
	279	return 0;
	280	}
	281
	282	static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe,
f5aa889f KM	283	int is_host,
f5aa889f KM	284	int dir_in)
f1407d5c KM	285	{
	286	u16 type = 0;
	287	u16 bfre = 0;
	288	u16 dblb = 0;
	289	u16 cntmd = 0;
	290	u16 dir = 0;
	291	u16 epnum = 0;
	292	u16 shtnak = 0;
	293	u16 type_array[] = {
	294	[USB_ENDPOINT_XFER_BULK] = TYPE_BULK,
	295	[USB_ENDPOINT_XFER_INT] = TYPE_INT,
	296	[USB_ENDPOINT_XFER_ISOC] = TYPE_ISO,
	297	};
	298	int is_double = usbhsp_possible_double_buffer(pipe);
	299
e8d548d5	300	if (usbhs_pipe_is_dcp(pipe))
f1407d5c KM	301	return -EINVAL;
	302
	303	/*
	304	* PIPECFG
	305	*
	306	* see
	307	* - "Register Descriptions" - "PIPECFG" register
	308	* - "Features" - "Pipe configuration"
	309	* - "Operation" - "Pipe Control"
	310	*/
	311
	312	/* TYPE */
356db7ed	313	type = type_array[usbhs_pipe_type(pipe)];
f1407d5c KM	314
f1407d5c KM	315	/* BFRE */
356db7ed KM	316	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) \|\|
356db7ed KM	317	usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
f1407d5c KM	318	bfre = 0; /* FIXME */
	319
	320	/* DBLB */
356db7ed KM	321	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) \|\|
356db7ed KM	322	usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
f1407d5c KM	323	dblb = (is_double) ? DBLB : 0;
	324
	325	/* CNTMD */
356db7ed	326	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
f1407d5c KM	327	cntmd = 0; /* FIXME */
	328
	329	/* DIR */
f5aa889f	330	if (dir_in)
ad6f2a8b	331	usbhsp_flags_set(pipe, IS_DIR_HOST);
f1407d5c	332
f5aa889f KM	333	if ((is_host && !dir_in) \|\|
f5aa889f KM	334	(!is_host && dir_in))
f1407d5c KM	335	dir \|= DIR_OUT;
f1407d5c KM	336
ad6f2a8b KM	337	if (!dir)
	338	usbhsp_flags_set(pipe, IS_DIR_IN);
	339
f1407d5c	340	/* SHTNAK */
356db7ed	341	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) &&
f1407d5c KM	342	!dir)
	343	shtnak = SHTNAK;
	344
	345	/* EPNUM */
f5aa889f	346	epnum = 0; /* see usbhs_pipe_config_update() */
f1407d5c KM	347
	348	return type \|
	349	bfre \|
	350	dblb \|
	351	cntmd \|
	352	dir \|
	353	shtnak \|
	354	epnum;
	355	}
	356
f5aa889f	357	static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe)
f1407d5c	358	{
e8d548d5 KM	359	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
e8d548d5 KM	360	struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
f1407d5c KM	361	struct device *dev = usbhs_priv_to_dev(priv);
	362	int pipe_num = usbhs_pipe_number(pipe);
	363	int is_double = usbhsp_possible_double_buffer(pipe);
	364	u16 buff_size;
	365	u16 bufnmb;
	366	u16 bufnmb_cnt;
	367
	368	/*
	369	* PIPEBUF
	370	*
	371	* see
	372	* - "Register Descriptions" - "PIPEBUF" register
	373	* - "Features" - "Pipe configuration"
	374	* - "Operation" - "FIFO Buffer Memory"
	375	* - "Operation" - "Pipe Control"
	376	*
	377	* ex) if pipe6 - pipe9 are USB_ENDPOINT_XFER_INT (SH7724)
	378	*
	379	* BUFNMB: PIPE
	380	* 0: pipe0 (DCP 256byte)
	381	* 1: -
	382	* 2: -
	383	* 3: -
	384	* 4: pipe6 (INT 64byte)
	385	* 5: pipe7 (INT 64byte)
	386	* 6: pipe8 (INT 64byte)
	387	* 7: pipe9 (INT 64byte)
	388	* 8 - xx: free (for BULK, ISOC)
	389	*/
	390
	391	/*
	392	* FIXME
	393	*
	394	* it doesn't have good buffer allocator
	395	*
	396	* DCP : 256 byte
	397	* BULK: 512 byte
	398	* INT : 64 byte
	399	* ISOC: 512 byte
	400	*/
356db7ed	401	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_CONTROL))
f1407d5c	402	buff_size = 256;
356db7ed	403	else if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
f1407d5c KM	404	buff_size = 64;
	405	else
	406	buff_size = 512;
	407
	408	/* change buff_size to register value */
	409	bufnmb_cnt = (buff_size / 64) - 1;
	410
	411	/* BUFNMB has been reserved for INT pipe
	412	* see above */
356db7ed	413	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT)) {
f1407d5c KM	414	bufnmb = pipe_num - 2;
	415	} else {
	416	bufnmb = info->bufnmb_last;
	417	info->bufnmb_last += bufnmb_cnt + 1;
	418
	419	/*
	420	* double buffer
	421	*/
	422	if (is_double)
	423	info->bufnmb_last += bufnmb_cnt + 1;
	424	}
	425
	426	dev_dbg(dev, "pipe : %d : buff_size 0x%x: bufnmb 0x%x\n",
	427	pipe_num, buff_size, bufnmb);
	428
	429	return (0x1f & bufnmb_cnt) << 10 \|
	430	(0xff & bufnmb) << 0;
	431	}
	432
bc6fbf59 KM	433	void usbhs_pipe_config_update(struct usbhs_pipe *pipe, u16 devsel,
bc6fbf59 KM	434	u16 epnum, u16 maxp)
f5aa889f	435	{
bc6fbf59 KM	436	if (devsel > 0xA) {
	437	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
	438	struct device *dev = usbhs_priv_to_dev(priv);
	439
	440	dev_err(dev, "devsel error %d\n", devsel);
	441
	442	devsel = 0;
	443	}
	444
f5aa889f KM	445	usbhsp_pipe_barrier(pipe);
f5aa889f KM	446
7fd097e7 KM	447	pipe->maxp = maxp;
7fd097e7 KM	448
f5aa889f	449	usbhsp_pipe_select(pipe);
bc6fbf59 KM	450	usbhsp_pipe_maxp_set(pipe, 0xFFFF,
	451	(devsel << 12) \|
	452	maxp);
f5aa889f KM	453
	454	if (!usbhs_pipe_is_dcp(pipe))
	455	usbhsp_pipe_cfg_set(pipe, 0x000F, epnum);
	456	}
	457
f1407d5c KM	458	/*
	459	* pipe control
	460	*/
	461	int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe)
	462	{
7fd097e7 KM	463	/*
	464	* see
	465	* usbhs_pipe_config_update()
	466	* usbhs_dcp_malloc()
	467	*/
	468	return pipe->maxp;
f1407d5c KM	469	}
	470
	471	int usbhs_pipe_is_dir_in(struct usbhs_pipe *pipe)
	472	{
	473	return usbhsp_flags_has(pipe, IS_DIR_IN);
	474	}
	475
ad6f2a8b KM	476	int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe)
	477	{
	478	return usbhsp_flags_has(pipe, IS_DIR_HOST);
	479	}
	480
3edeee38	481	void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence)
f1407d5c	482	{
6e6db82b	483	u16 mask = (SQCLR \| SQSET);
3edeee38 KM	484	u16 val;
	485
	486	/*
	487	* sequence
	488	* 0 : data0
	489	* 1 : data1
	490	* -1 : no change
	491	*/
	492	switch (sequence) {
	493	case 0:
	494	val = SQCLR;
	495	break;
	496	case 1:
	497	val = SQSET;
	498	break;
	499	default:
	500	return;
	501	}
6e6db82b KM	502
6e6db82b KM	503	usbhsp_pipectrl_set(pipe, mask, val);
f1407d5c KM	504	}
f1407d5c KM	505
08e6c611 KM	506	void usbhs_pipe_clear(struct usbhs_pipe *pipe)
	507	{
	508	usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
	509	usbhsp_pipectrl_set(pipe, ACLRM, 0);
	510	}
	511
f1407d5c KM	512	static struct usbhs_pipe usbhsp_get_pipe(struct usbhs_priv priv, u32 type)
	513	{
	514	struct usbhs_pipe pos, pipe;
	515	int i;
	516
	517	/*
	518	* find target pipe
	519	*/
	520	pipe = NULL;
	521	usbhs_for_each_pipe_with_dcp(pos, priv, i) {
356db7ed	522	if (!usbhs_pipe_type_is(pos, type))
f1407d5c KM	523	continue;
	524	if (usbhsp_flags_has(pos, IS_USED))
	525	continue;
	526
	527	pipe = pos;
	528	break;
	529	}
	530
	531	if (!pipe)
	532	return NULL;
	533
	534	/*
	535	* initialize pipe flags
	536	*/
	537	usbhsp_flags_init(pipe);
	538	usbhsp_flags_set(pipe, IS_USED);
	539
	540	return pipe;
	541	}
	542
4bd04811	543	void usbhs_pipe_init(struct usbhs_priv *priv,
e73a9891	544	int (dma_map_ctrl)(struct usbhs_pkt pkt, int map))
f1407d5c	545	{
e8d548d5	546	struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
f1407d5c KM	547	struct usbhs_pipe *pipe;
	548	int i;
	549
	550	/*
	551	* FIXME
	552	*
	553	* driver needs good allocator.
	554	*
	555	* find first free buffer area (BULK, ISOC)
	556	* (DCP, INT area is fixed)
	557	*
	558	* buffer number 0 - 3 have been reserved for DCP
	559	* see
	560	* usbhsp_to_bufnmb
	561	*/
	562	info->bufnmb_last = 4;
	563	usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
356db7ed	564	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
f1407d5c KM	565	info->bufnmb_last++;
	566
	567	usbhsp_flags_init(pipe);
d77e3f4e	568	pipe->fifo = NULL;
f1407d5c	569	pipe->mod_private = NULL;
6acb95d4	570	INIT_LIST_HEAD(&pipe->list);
45e13e6e	571
e8d548d5	572	/* pipe force init */
08e6c611	573	usbhs_pipe_clear(pipe);
f1407d5c	574	}
4bd04811	575
e73a9891	576	info->dma_map_ctrl = dma_map_ctrl;
f1407d5c KM	577	}
	578
	579	struct usbhs_pipe usbhs_pipe_malloc(struct usbhs_priv priv,
f5aa889f KM	580	int endpoint_type,
f5aa889f KM	581	int dir_in)
f1407d5c KM	582	{
f1407d5c KM	583	struct device *dev = usbhs_priv_to_dev(priv);
f1407d5c	584	struct usbhs_pipe *pipe;
0deb3e77	585	int is_host = usbhs_mod_is_host(priv);
f1407d5c	586	int ret;
f5aa889f	587	u16 pipecfg, pipebuf;
f1407d5c	588
f5aa889f	589	pipe = usbhsp_get_pipe(priv, endpoint_type);
f429ea3f KM	590	if (!pipe) {
f429ea3f KM	591	dev_err(dev, "can't get pipe (%s)\n",
f5aa889f	592	usbhsp_pipe_name[endpoint_type]);
f1407d5c	593	return NULL;
f429ea3f	594	}
f1407d5c	595
6acb95d4 KM	596	INIT_LIST_HEAD(&pipe->list);
6acb95d4 KM	597
e8d548d5	598	usbhs_pipe_disable(pipe);
f1407d5c KM	599
	600	/* make sure pipe is not busy */
	601	ret = usbhsp_pipe_barrier(pipe);
	602	if (ret < 0) {
	603	dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe));
	604	return NULL;
	605	}
	606
f5aa889f KM	607	pipecfg = usbhsp_setup_pipecfg(pipe, is_host, dir_in);
f5aa889f KM	608	pipebuf = usbhsp_setup_pipebuff(pipe);
f1407d5c	609
f1407d5c KM	610	usbhsp_pipe_select(pipe);
	611	usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg);
	612	usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf);
f1407d5c	613
6e6db82b	614	usbhs_pipe_sequence_data0(pipe);
f1407d5c KM	615
	616	dev_dbg(dev, "enable pipe %d : %s (%s)\n",
	617	usbhs_pipe_number(pipe),
3cf8ed12	618	usbhs_pipe_name(pipe),
f1407d5c KM	619	usbhs_pipe_is_dir_in(pipe) ? "in" : "out");
f1407d5c KM	620
f5aa889f KM	621	/*
	622	* epnum / maxp are still not set to this pipe.
	623	* call usbhs_pipe_config_update() after this function !!
	624	*/
	625
f1407d5c KM	626	return pipe;
	627	}
	628
d77e3f4e KM	629	void usbhs_pipe_select_fifo(struct usbhs_pipe pipe, struct usbhs_fifo fifo)
	630	{
	631	if (pipe->fifo)
	632	pipe->fifo->pipe = NULL;
	633
	634	pipe->fifo = fifo;
	635
	636	if (fifo)
	637	fifo->pipe = pipe;
	638	}
	639
	640
f1407d5c KM	641	/*
	642	* dcp control
	643	*/
	644	struct usbhs_pipe usbhs_dcp_malloc(struct usbhs_priv priv)
	645	{
	646	struct usbhs_pipe *pipe;
	647
	648	pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL);
	649	if (!pipe)
	650	return NULL;
	651
f5aa889f KM	652	INIT_LIST_HEAD(&pipe->list);
f5aa889f KM	653
f1407d5c	654	/*
f5aa889f	655	* call usbhs_pipe_config_update() after this function !!
f1407d5c KM	656	*/
f1407d5c KM	657
f1407d5c KM	658	return pipe;
	659	}
	660
	661	void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
	662	{
e2eddc61 KM	663	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
e2eddc61 KM	664
e8d548d5	665	WARN_ON(!usbhs_pipe_is_dcp(pipe));
f1407d5c	666
e8d548d5	667	usbhs_pipe_enable(pipe);
e2eddc61 KM	668
	669	if (!usbhs_mod_is_host(priv)) /* funconly */
	670	usbhsp_pipectrl_set(pipe, CCPL, CCPL);
f1407d5c KM	671	}
f1407d5c KM	672
92352071 KM	673	void usbhs_dcp_dir_for_host(struct usbhs_pipe *pipe, int dir_out)
	674	{
	675	usbhsp_pipe_cfg_set(pipe, DIR_OUT,
	676	dir_out ? DIR_OUT : 0);
	677	}
	678
f1407d5c KM	679	/*
	680	* pipe module function
	681	*/
	682	int usbhs_pipe_probe(struct usbhs_priv *priv)
	683	{
e8d548d5	684	struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
f1407d5c KM	685	struct usbhs_pipe *pipe;
	686	struct device *dev = usbhs_priv_to_dev(priv);
	687	u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
	688	int pipe_size = usbhs_get_dparam(priv, pipe_size);
	689	int i;
	690
	691	/* This driver expects 1st pipe is DCP */
	692	if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) {
	693	dev_err(dev, "1st PIPE is not DCP\n");
	694	return -EINVAL;
	695	}
	696
	697	info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL);
	698	if (!info->pipe) {
	699	dev_err(dev, "Could not allocate pipe\n");
	700	return -ENOMEM;
	701	}
	702
	703	info->size = pipe_size;
	704
	705	/*
	706	* init pipe
	707	*/
	708	usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
	709	pipe->priv = priv;
356db7ed KM	710
	711	usbhs_pipe_type(pipe) =
	712	pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK;
f1407d5c KM	713
	714	dev_dbg(dev, "pipe %x\t: %s\n",
	715	i, usbhsp_pipe_name[pipe_type[i]]);
	716	}
	717
	718	return 0;
	719	}
	720
	721	void usbhs_pipe_remove(struct usbhs_priv *priv)
	722	{
e8d548d5	723	struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
f1407d5c KM	724
	725	kfree(info->pipe);
	726	}