[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)

#define usbhsp_type(p)		((p)->pipe_type)
#define usbhsp_type_is(p, t)	((p)->pipe_type == t)

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

/*
 *		usb request functions
 */
void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
{
	u16 val;

	val = usbhs_read(priv, USBREQ);
	req->bRequest		= (val >> 8) & 0xFF;
	req->bRequestType	= (val >> 0) & 0xFF;

	req->wValue	= usbhs_read(priv, USBVAL);
	req->wIndex	= usbhs_read(priv, USBINDX);
	req->wLength	= usbhs_read(priv, USBLENG);
}

void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
{
	usbhs_write(priv, USBREQ,  (req->bRequest << 8) | req->bRequestType);
	usbhs_write(priv, USBVAL,  req->wValue);
	usbhs_write(priv, USBINDX, req->wIndex);
	usbhs_write(priv, USBLENG, req->wLength);
}

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

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

static u16 usbhsp_pipe_maxp_get(struct usbhs_pipe *pipe)
{
	return __usbhsp_pipe_xxx_get(pipe, DCPMAXP, PIPEMAXP);
}

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

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

	return 0;
}

static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe,
				const struct usb_endpoint_descriptor *desc,
				int is_host)
{
	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[usbhsp_type(pipe)];

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

	/* DBLB */
	if (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_ISOC) ||
	    usbhsp_type_is(pipe, USB_ENDPOINT_XFER_BULK))
		dblb = (is_double) ? DBLB : 0;

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

	/* DIR */
	if (usb_endpoint_dir_in(desc))
		usbhsp_flags_set(pipe, IS_DIR_HOST);

	if ((is_host  && usb_endpoint_dir_out(desc)) ||
	    (!is_host && usb_endpoint_dir_in(desc)))
		dir |= DIR_OUT;

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

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

	/* EPNUM */
	epnum = 0xF & usb_endpoint_num(desc);

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

static u16 usbhsp_setup_pipemaxp(struct usbhs_pipe *pipe,
				 const struct usb_endpoint_descriptor *desc,
				 int is_host)
{
	/* host should set DEVSEL */

	/* reutn MXPS */
	return PIPE_MAXP_MASK & le16_to_cpu(desc->wMaxPacketSize);
}

static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe,
				 const struct usb_endpoint_descriptor *desc,
				 int is_host)
{
	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 (usbhsp_type_is(pipe, USB_ENDPOINT_XFER_CONTROL))
		buff_size = 256;
	else if (usbhsp_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 (usbhsp_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;
}

/*
 *		pipe control
 */
int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe)
{
	u16 mask = usbhs_pipe_is_dcp(pipe) ? DCP_MAXP_MASK : PIPE_MAXP_MASK;

	usbhsp_pipe_select(pipe);

	return (int)(usbhsp_pipe_maxp_get(pipe) & mask);
}

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_clear_sequence(struct usbhs_pipe *pipe)
{
	usbhsp_pipectrl_set(pipe, SQCLR, SQCLR);
}

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 (!usbhsp_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,
		     void (*done)(struct usbhs_pkt *pkt))
{
	struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
	struct device *dev = usbhs_priv_to_dev(priv);
	struct usbhs_pipe *pipe;
	int i;

	if (!done) {
		dev_err(dev, "no done function\n");
		return;
	}

	/*
	 * 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 (usbhsp_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 */
		usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
		usbhsp_pipectrl_set(pipe, ACLRM, 0);
	}

	info->done = done;
}

struct usbhs_pipe *usbhs_pipe_malloc(struct usbhs_priv *priv,
				     const struct usb_endpoint_descriptor *desc)
{
	struct device *dev = usbhs_priv_to_dev(priv);
	struct usbhs_mod *mod = usbhs_mod_get_current(priv);
	struct usbhs_pipe *pipe;
	int is_host = usbhs_mod_is_host(priv, mod);
	int ret;
	u16 pipecfg, pipebuf, pipemaxp;

	pipe = usbhsp_get_pipe(priv, usb_endpoint_type(desc));
	if (!pipe) {
		dev_err(dev, "can't get pipe (%s)\n",
			usbhsp_pipe_name[usb_endpoint_type(desc)]);
		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,  desc, is_host);
	pipebuf  = usbhsp_setup_pipebuff(pipe, desc, is_host);
	pipemaxp = usbhsp_setup_pipemaxp(pipe, desc, is_host);

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

	usbhs_pipe_clear_sequence(pipe);

	dev_dbg(dev, "enable pipe %d : %s (%s)\n",
		usbhs_pipe_number(pipe),
		usbhsp_pipe_name[usb_endpoint_type(desc)],
		usbhs_pipe_is_dir_in(pipe) ? "in" : "out");

	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;

	/*
	 * dcpcfg  : default
	 * dcpmaxp : default
	 * pipebuf : nothing to do
	 */

	usbhsp_pipe_select(pipe);
	usbhs_pipe_clear_sequence(pipe);
	INIT_LIST_HEAD(&pipe->list);

	return pipe;
}

void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
{
	WARN_ON(!usbhs_pipe_is_dcp(pipe));

	usbhs_pipe_enable(pipe);
	usbhsp_pipectrl_set(pipe, CCPL, CCPL);
}

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