[GitHub/mt8127/android_kernel_alcatel_ttab.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);
}

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

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_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)
		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	18	#include <linux/slab.h>
cc502bb7 PB	19	#include "common.h"
cc502bb7 PB	20	#include "pipe.h"
f1407d5c KM	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
1c90ee0b KM	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
f1407d5c KM	171	/*
	172	* PIPEBUF
	173	*/
	174	static void usbhsp_pipe_buf_set(struct usbhs_pipe *pipe, u16 mask, u16 val)
	175	{
e8d548d5	176	if (usbhs_pipe_is_dcp(pipe))
f1407d5c KM	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
f1407d5c KM	190	/*
	191	* pipe control functions
	192	*/
	193	static void usbhsp_pipe_select(struct usbhs_pipe *pipe)
	194	{
e8d548d5	195	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
f1407d5c KM	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	{
e8d548d5	217	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
f1407d5c KM	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);
e8d548d5	240	usbhs_pipe_disable(pipe);
f1407d5c KM	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
f1407d5c KM	252	return -EBUSY;
	253	}
	254
e8d548d5	255	int usbhs_pipe_is_accessible(struct usbhs_pipe *pipe)
f1407d5c KM	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
e8d548d5	288	void usbhs_pipe_disable(struct usbhs_pipe *pipe)
f1407d5c	289	{
c786e09c KM	290	int timeout = 1024;
	291	u16 val;
	292
f1407d5c KM	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);
c786e09c KM	297
	298	do {
	299	val = usbhsp_pipectrl_get(pipe);
	300	val &= PBUSY;
	301	if (!val)
	302	break;
	303
	304	udelay(10);
	305	} while (timeout--);
f1407d5c KM	306	}
f1407d5c KM	307
e8d548d5	308	void usbhs_pipe_enable(struct usbhs_pipe *pipe)
f1407d5c KM	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
e8d548d5	316	void usbhs_pipe_stall(struct usbhs_pipe *pipe)
f1407d5c KM	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
9cf1b06e KM	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
1c90ee0b KM	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
f1407d5c KM	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	*/
356db7ed KM	376	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) \|\|
356db7ed KM	377	usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC))
f1407d5c KM	378	return 1;
	379
	380	return 0;
	381	}
	382
	383	static u16 usbhsp_setup_pipecfg(struct usbhs_pipe *pipe,
f5aa889f KM	384	int is_host,
f5aa889f KM	385	int dir_in)
f1407d5c KM	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
e8d548d5	401	if (usbhs_pipe_is_dcp(pipe))
f1407d5c KM	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 */
356db7ed	414	type = type_array[usbhs_pipe_type(pipe)];
f1407d5c KM	415
f1407d5c KM	416	/* BFRE */
356db7ed KM	417	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) \|\|
356db7ed KM	418	usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
f1407d5c KM	419	bfre = 0; /* FIXME */
	420
	421	/* DBLB */
356db7ed KM	422	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_ISOC) \|\|
356db7ed KM	423	usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
f1407d5c KM	424	dblb = (is_double) ? DBLB : 0;
	425
	426	/* CNTMD */
356db7ed	427	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK))
f1407d5c KM	428	cntmd = 0; /* FIXME */
	429
	430	/* DIR */
f5aa889f	431	if (dir_in)
ad6f2a8b	432	usbhsp_flags_set(pipe, IS_DIR_HOST);
f1407d5c	433
14ff96e0	434	if (!!is_host ^ !!dir_in)
f1407d5c KM	435	dir \|= DIR_OUT;
f1407d5c KM	436
ad6f2a8b KM	437	if (!dir)
	438	usbhsp_flags_set(pipe, IS_DIR_IN);
	439
f1407d5c	440	/* SHTNAK */
356db7ed	441	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_BULK) &&
f1407d5c KM	442	!dir)
	443	shtnak = SHTNAK;
	444
	445	/* EPNUM */
f5aa889f	446	epnum = 0; /* see usbhs_pipe_config_update() */
f1407d5c KM	447
	448	return type \|
	449	bfre \|
	450	dblb \|
	451	cntmd \|
	452	dir \|
	453	shtnak \|
	454	epnum;
	455	}
	456
f5aa889f	457	static u16 usbhsp_setup_pipebuff(struct usbhs_pipe *pipe)
f1407d5c	458	{
e8d548d5 KM	459	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
e8d548d5 KM	460	struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
f1407d5c KM	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	*/
356db7ed	501	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_CONTROL))
f1407d5c	502	buff_size = 256;
356db7ed	503	else if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
f1407d5c KM	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 */
356db7ed	513	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT)) {
f1407d5c KM	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
bc6fbf59 KM	533	void usbhs_pipe_config_update(struct usbhs_pipe *pipe, u16 devsel,
bc6fbf59 KM	534	u16 epnum, u16 maxp)
f5aa889f	535	{
bc6fbf59 KM	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
f5aa889f KM	545	usbhsp_pipe_barrier(pipe);
f5aa889f KM	546
7fd097e7 KM	547	pipe->maxp = maxp;
7fd097e7 KM	548
f5aa889f	549	usbhsp_pipe_select(pipe);
bc6fbf59 KM	550	usbhsp_pipe_maxp_set(pipe, 0xFFFF,
	551	(devsel << 12) \|
	552	maxp);
f5aa889f KM	553
	554	if (!usbhs_pipe_is_dcp(pipe))
	555	usbhsp_pipe_cfg_set(pipe, 0x000F, epnum);
	556	}
	557
f1407d5c KM	558	/*
	559	* pipe control
	560	*/
	561	int usbhs_pipe_get_maxpacket(struct usbhs_pipe *pipe)
	562	{
7fd097e7 KM	563	/*
	564	* see
	565	* usbhs_pipe_config_update()
	566	* usbhs_dcp_malloc()
	567	*/
	568	return pipe->maxp;
f1407d5c KM	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
ad6f2a8b KM	576	int usbhs_pipe_is_dir_host(struct usbhs_pipe *pipe)
	577	{
	578	return usbhsp_flags_has(pipe, IS_DIR_HOST);
	579	}
	580
3edeee38	581	void usbhs_pipe_data_sequence(struct usbhs_pipe *pipe, int sequence)
f1407d5c	582	{
6e6db82b	583	u16 mask = (SQCLR \| SQSET);
3edeee38 KM	584	u16 val;
	585
	586	/*
	587	* sequence
	588	* 0 : data0
	589	* 1 : data1
	590	* -1 : no change
	591	*/
	592	switch (sequence) {
	593	case 0:
	594	val = SQCLR;
	595	break;
	596	case 1:
	597	val = SQSET;
	598	break;
	599	default:
	600	return;
	601	}
6e6db82b KM	602
6e6db82b KM	603	usbhsp_pipectrl_set(pipe, mask, val);
f1407d5c KM	604	}
f1407d5c KM	605
08e6c611 KM	606	void usbhs_pipe_clear(struct usbhs_pipe *pipe)
	607	{
	608	usbhsp_pipectrl_set(pipe, ACLRM, ACLRM);
	609	usbhsp_pipectrl_set(pipe, ACLRM, 0);
	610	}
	611
f1407d5c KM	612	static struct usbhs_pipe usbhsp_get_pipe(struct usbhs_priv priv, u32 type)
	613	{
	614	struct usbhs_pipe pos, pipe;
	615	int i;
	616
	617	/*
	618	* find target pipe
	619	*/
	620	pipe = NULL;
	621	usbhs_for_each_pipe_with_dcp(pos, priv, i) {
356db7ed	622	if (!usbhs_pipe_type_is(pos, type))
f1407d5c KM	623	continue;
	624	if (usbhsp_flags_has(pos, IS_USED))
	625	continue;
	626
	627	pipe = pos;
	628	break;
	629	}
	630
	631	if (!pipe)
	632	return NULL;
	633
	634	/*
	635	* initialize pipe flags
	636	*/
	637	usbhsp_flags_init(pipe);
	638	usbhsp_flags_set(pipe, IS_USED);
	639
	640	return pipe;
	641	}
	642
4bd04811	643	void usbhs_pipe_init(struct usbhs_priv *priv,
e73a9891	644	int (dma_map_ctrl)(struct usbhs_pkt pkt, int map))
f1407d5c	645	{
e8d548d5	646	struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
f1407d5c KM	647	struct usbhs_pipe *pipe;
	648	int i;
	649
	650	/*
	651	* FIXME
	652	*
	653	* driver needs good allocator.
	654	*
	655	* find first free buffer area (BULK, ISOC)
	656	* (DCP, INT area is fixed)
	657	*
	658	* buffer number 0 - 3 have been reserved for DCP
	659	* see
	660	* usbhsp_to_bufnmb
	661	*/
	662	info->bufnmb_last = 4;
	663	usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
356db7ed	664	if (usbhs_pipe_type_is(pipe, USB_ENDPOINT_XFER_INT))
f1407d5c KM	665	info->bufnmb_last++;
	666
	667	usbhsp_flags_init(pipe);
d77e3f4e	668	pipe->fifo = NULL;
f1407d5c	669	pipe->mod_private = NULL;
6acb95d4	670	INIT_LIST_HEAD(&pipe->list);
45e13e6e	671
e8d548d5	672	/* pipe force init */
08e6c611	673	usbhs_pipe_clear(pipe);
f1407d5c	674	}
4bd04811	675
e73a9891	676	info->dma_map_ctrl = dma_map_ctrl;
f1407d5c KM	677	}
	678
	679	struct usbhs_pipe usbhs_pipe_malloc(struct usbhs_priv priv,
f5aa889f KM	680	int endpoint_type,
f5aa889f KM	681	int dir_in)
f1407d5c KM	682	{
f1407d5c KM	683	struct device *dev = usbhs_priv_to_dev(priv);
f1407d5c	684	struct usbhs_pipe *pipe;
0deb3e77	685	int is_host = usbhs_mod_is_host(priv);
f1407d5c	686	int ret;
f5aa889f	687	u16 pipecfg, pipebuf;
f1407d5c	688
f5aa889f	689	pipe = usbhsp_get_pipe(priv, endpoint_type);
f429ea3f KM	690	if (!pipe) {
f429ea3f KM	691	dev_err(dev, "can't get pipe (%s)\n",
f5aa889f	692	usbhsp_pipe_name[endpoint_type]);
f1407d5c	693	return NULL;
f429ea3f	694	}
f1407d5c	695
6acb95d4 KM	696	INIT_LIST_HEAD(&pipe->list);
6acb95d4 KM	697
e8d548d5	698	usbhs_pipe_disable(pipe);
f1407d5c KM	699
	700	/* make sure pipe is not busy */
	701	ret = usbhsp_pipe_barrier(pipe);
	702	if (ret < 0) {
	703	dev_err(dev, "pipe setup failed %d\n", usbhs_pipe_number(pipe));
	704	return NULL;
	705	}
	706
f5aa889f KM	707	pipecfg = usbhsp_setup_pipecfg(pipe, is_host, dir_in);
f5aa889f KM	708	pipebuf = usbhsp_setup_pipebuff(pipe);
f1407d5c	709
f1407d5c KM	710	usbhsp_pipe_select(pipe);
	711	usbhsp_pipe_cfg_set(pipe, 0xFFFF, pipecfg);
	712	usbhsp_pipe_buf_set(pipe, 0xFFFF, pipebuf);
f1407d5c	713
6e6db82b	714	usbhs_pipe_sequence_data0(pipe);
f1407d5c KM	715
	716	dev_dbg(dev, "enable pipe %d : %s (%s)\n",
	717	usbhs_pipe_number(pipe),
3cf8ed12	718	usbhs_pipe_name(pipe),
f1407d5c KM	719	usbhs_pipe_is_dir_in(pipe) ? "in" : "out");
f1407d5c KM	720
f5aa889f KM	721	/*
	722	* epnum / maxp are still not set to this pipe.
	723	* call usbhs_pipe_config_update() after this function !!
	724	*/
	725
f1407d5c KM	726	return pipe;
	727	}
	728
d77e3f4e KM	729	void usbhs_pipe_select_fifo(struct usbhs_pipe pipe, struct usbhs_fifo fifo)
	730	{
	731	if (pipe->fifo)
	732	pipe->fifo->pipe = NULL;
	733
	734	pipe->fifo = fifo;
	735
	736	if (fifo)
	737	fifo->pipe = pipe;
	738	}
	739
	740
f1407d5c KM	741	/*
	742	* dcp control
	743	*/
	744	struct usbhs_pipe usbhs_dcp_malloc(struct usbhs_priv priv)
	745	{
	746	struct usbhs_pipe *pipe;
	747
	748	pipe = usbhsp_get_pipe(priv, USB_ENDPOINT_XFER_CONTROL);
	749	if (!pipe)
	750	return NULL;
	751
f5aa889f KM	752	INIT_LIST_HEAD(&pipe->list);
f5aa889f KM	753
f1407d5c	754	/*
f5aa889f	755	* call usbhs_pipe_config_update() after this function !!
f1407d5c KM	756	*/
f1407d5c KM	757
f1407d5c KM	758	return pipe;
	759	}
	760
	761	void usbhs_dcp_control_transfer_done(struct usbhs_pipe *pipe)
	762	{
e2eddc61 KM	763	struct usbhs_priv *priv = usbhs_pipe_to_priv(pipe);
e2eddc61 KM	764
e8d548d5	765	WARN_ON(!usbhs_pipe_is_dcp(pipe));
f1407d5c	766
e8d548d5	767	usbhs_pipe_enable(pipe);
e2eddc61 KM	768
	769	if (!usbhs_mod_is_host(priv)) /* funconly */
	770	usbhsp_pipectrl_set(pipe, CCPL, CCPL);
f1407d5c KM	771	}
f1407d5c KM	772
92352071 KM	773	void usbhs_dcp_dir_for_host(struct usbhs_pipe *pipe, int dir_out)
	774	{
	775	usbhsp_pipe_cfg_set(pipe, DIR_OUT,
	776	dir_out ? DIR_OUT : 0);
	777	}
	778
f1407d5c KM	779	/*
	780	* pipe module function
	781	*/
	782	int usbhs_pipe_probe(struct usbhs_priv *priv)
	783	{
e8d548d5	784	struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
f1407d5c KM	785	struct usbhs_pipe *pipe;
	786	struct device *dev = usbhs_priv_to_dev(priv);
	787	u32 *pipe_type = usbhs_get_dparam(priv, pipe_type);
	788	int pipe_size = usbhs_get_dparam(priv, pipe_size);
	789	int i;
	790
	791	/* This driver expects 1st pipe is DCP */
	792	if (pipe_type[0] != USB_ENDPOINT_XFER_CONTROL) {
	793	dev_err(dev, "1st PIPE is not DCP\n");
	794	return -EINVAL;
	795	}
	796
	797	info->pipe = kzalloc(sizeof(struct usbhs_pipe) * pipe_size, GFP_KERNEL);
	798	if (!info->pipe) {
	799	dev_err(dev, "Could not allocate pipe\n");
	800	return -ENOMEM;
	801	}
	802
	803	info->size = pipe_size;
	804
	805	/*
	806	* init pipe
	807	*/
	808	usbhs_for_each_pipe_with_dcp(pipe, priv, i) {
	809	pipe->priv = priv;
356db7ed KM	810
	811	usbhs_pipe_type(pipe) =
	812	pipe_type[i] & USB_ENDPOINT_XFERTYPE_MASK;
f1407d5c KM	813
	814	dev_dbg(dev, "pipe %x\t: %s\n",
	815	i, usbhsp_pipe_name[pipe_type[i]]);
	816	}
	817
	818	return 0;
	819	}
	820
	821	void usbhs_pipe_remove(struct usbhs_priv *priv)
	822	{
e8d548d5	823	struct usbhs_pipe_info *info = usbhs_priv_to_pipeinfo(priv);
f1407d5c KM	824
	825	kfree(info->pipe);
	826	}