[deliverable/linux.git] / drivers / usb / renesas_usbhs / mod.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/interrupt.h>

#include "./common.h"
#include "./mod.h"

#define usbhs_priv_to_modinfo(priv) (&priv->mod_info)
#define usbhs_mod_info_call(priv, func, param...)	\
({						\
	struct usbhs_mod_info *info;		\
	info = usbhs_priv_to_modinfo(priv);	\
	!info->func ? 0 :			\
	 info->func(param);			\
})

/*
 *		autonomy
 *
 * these functions are used if platform doesn't have external phy.
 *  -> there is no "notify_hotplug" callback from platform
 *  -> call "notify_hotplug" by itself
 *  -> use own interrupt to connect/disconnect
 *  -> it mean module clock is always ON
 *             ~~~~~~~~~~~~~~~~~~~~~~~~~
 */
static int usbhsm_autonomy_get_vbus(struct platform_device *pdev)
{
	struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);

	return  VBSTS & usbhs_read(priv, INTSTS0);
}

static int usbhsm_autonomy_irq_vbus(struct usbhs_priv *priv,
				    struct usbhs_irq_state *irq_state)
{
	struct platform_device *pdev = usbhs_priv_to_pdev(priv);

	return usbhsc_drvcllbck_notify_hotplug(pdev);
}

void usbhs_mod_autonomy_mode(struct usbhs_priv *priv)
{
	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);

	info->irq_vbus		= usbhsm_autonomy_irq_vbus;
	priv->pfunc->get_vbus	= usbhsm_autonomy_get_vbus;

	usbhs_irq_callback_update(priv, NULL);
}

/*
 *		host / gadget functions
 *
 * renesas_usbhs host/gadget can register itself by below functions.
 * these functions are called when probe
 *
 */
void usbhs_mod_register(struct usbhs_priv *priv, struct usbhs_mod *mod, int id)
{
	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);

	info->mod[id]	= mod;
	mod->priv	= priv;
}

struct usbhs_mod *usbhs_mod_get(struct usbhs_priv *priv, int id)
{
	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
	struct usbhs_mod *ret = NULL;

	switch (id) {
	case USBHS_HOST:
	case USBHS_GADGET:
		ret = info->mod[id];
		break;
	}

	return ret;
}

int usbhs_mod_is_host(struct usbhs_priv *priv, struct usbhs_mod *mod)
{
	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);

	if (!mod)
		return -EINVAL;

	return info->mod[USBHS_HOST] == mod;
}

struct usbhs_mod *usbhs_mod_get_current(struct usbhs_priv *priv)
{
	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);

	return info->curt;
}

int usbhs_mod_change(struct usbhs_priv *priv, int id)
{
	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
	struct usbhs_mod *mod = NULL;
	int ret = 0;

	/* id < 0 mean no current */
	switch (id) {
	case USBHS_HOST:
	case USBHS_GADGET:
		mod = info->mod[id];
		break;
	default:
		ret = -EINVAL;
	}
	info->curt = mod;

	return ret;
}

static irqreturn_t usbhs_interrupt(int irq, void *data);
int usbhs_mod_probe(struct usbhs_priv *priv)
{
	struct device *dev = usbhs_priv_to_dev(priv);
	int ret;

	/*
	 * install host/gadget driver
	 */
	ret = usbhs_mod_gadget_probe(priv);
	if (ret < 0)
		return ret;

	/* irq settings */
	ret = request_irq(priv->irq, usbhs_interrupt,
			  0, dev_name(dev), priv);
	if (ret) {
		dev_err(dev, "irq request err\n");
		goto mod_init_gadget_err;
	}

	return ret;

mod_init_gadget_err:
	usbhs_mod_gadget_remove(priv);

	return ret;
}

void usbhs_mod_remove(struct usbhs_priv *priv)
{
	usbhs_mod_gadget_remove(priv);
	free_irq(priv->irq, priv);
}

/*
 *		status functions
 */
int usbhs_status_get_device_state(struct usbhs_irq_state *irq_state)
{
	int state = irq_state->intsts0 & DVSQ_MASK;

	switch (state) {
	case POWER_STATE:
	case DEFAULT_STATE:
	case ADDRESS_STATE:
	case CONFIGURATION_STATE:
		return state;
	}

	return -EIO;
}

int usbhs_status_get_ctrl_stage(struct usbhs_irq_state *irq_state)
{
	/*
	 * return value
	 *
	 * IDLE_SETUP_STAGE
	 * READ_DATA_STAGE
	 * READ_STATUS_STAGE
	 * WRITE_DATA_STAGE
	 * WRITE_STATUS_STAGE
	 * NODATA_STATUS_STAGE
	 * SEQUENCE_ERROR
	 */
	return (int)irq_state->intsts0 & CTSQ_MASK;
}

static void usbhs_status_get_each_irq(struct usbhs_priv *priv,
				      struct usbhs_irq_state *state)
{
	struct usbhs_mod *mod = usbhs_mod_get_current(priv);

	state->intsts0 = usbhs_read(priv, INTSTS0);
	state->intsts1 = usbhs_read(priv, INTSTS1);

	/* mask */
	if (mod) {
		state->brdysts = usbhs_read(priv, BRDYSTS);
		state->nrdysts = usbhs_read(priv, NRDYSTS);
		state->bempsts = usbhs_read(priv, BEMPSTS);

		state->bempsts &= mod->irq_bempsts;
		state->brdysts &= mod->irq_brdysts;
	}
}

/*
 *		interrupt
 */
#define INTSTS0_MAGIC 0xF800 /* acknowledge magical interrupt sources */
#define INTSTS1_MAGIC 0xA870 /* acknowledge magical interrupt sources */
static irqreturn_t usbhs_interrupt(int irq, void *data)
{
	struct usbhs_priv *priv = data;
	struct usbhs_irq_state irq_state;

	usbhs_status_get_each_irq(priv, &irq_state);

	/*
	 * clear interrupt
	 *
	 * The hardware is _very_ picky to clear interrupt bit.
	 * Especially INTSTS0_MAGIC, INTSTS1_MAGIC value.
	 *
	 * see
	 *	"Operation"
	 *	 - "Control Transfer (DCP)"
	 *	   - Function :: VALID bit should 0
	 */
	usbhs_write(priv, INTSTS0, ~irq_state.intsts0 & INTSTS0_MAGIC);
	usbhs_write(priv, INTSTS1, ~irq_state.intsts1 & INTSTS1_MAGIC);

	usbhs_write(priv, BRDYSTS, 0);
	usbhs_write(priv, NRDYSTS, 0);
	usbhs_write(priv, BEMPSTS, 0);

	/*
	 * call irq callback functions
	 * see also
	 *	usbhs_irq_setting_update
	 */
	if (irq_state.intsts0 & VBINT)
		usbhs_mod_info_call(priv, irq_vbus, priv, &irq_state);

	if (irq_state.intsts0 & DVST)
		usbhs_mod_call(priv, irq_dev_state, priv, &irq_state);

	if (irq_state.intsts0 & CTRT)
		usbhs_mod_call(priv, irq_ctrl_stage, priv, &irq_state);

	if (irq_state.intsts0 & BEMP)
		usbhs_mod_call(priv, irq_empty, priv, &irq_state);

	if (irq_state.intsts0 & BRDY)
		usbhs_mod_call(priv, irq_ready, priv, &irq_state);

	return IRQ_HANDLED;
}

void usbhs_irq_callback_update(struct usbhs_priv *priv, struct usbhs_mod *mod)
{
	u16 intenb0 = 0;
	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);

	/*
	 * BEMPENB/BRDYENB are picky.
	 * below method is required
	 *
	 *  - clear  INTSTS0
	 *  - update BEMPENB/BRDYENB
	 *  - update INTSTS0
	 */
	usbhs_write(priv, INTENB0, 0);

	usbhs_write(priv, BEMPENB, 0);
	usbhs_write(priv, BRDYENB, 0);

	/*
	 * see also
	 *	usbhs_interrupt
	 */

	/*
	 * it don't enable DVSE (intenb0) here
	 * but "mod->irq_dev_state" will be called.
	 */
	if (info->irq_vbus)
		intenb0 |= VBSE;

	if (mod) {
		if (mod->irq_ctrl_stage)
			intenb0 |= CTRE;

		if (mod->irq_empty && mod->irq_bempsts) {
			usbhs_write(priv, BEMPENB, mod->irq_bempsts);
			intenb0 |= BEMPE;
		}

		if (mod->irq_ready && mod->irq_brdysts) {
			usbhs_write(priv, BRDYENB, mod->irq_brdysts);
			intenb0 |= BRDYE;
		}
	}

	if (intenb0)
		usbhs_write(priv, INTENB0, intenb0);
}
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/interrupt.h>
	18
	19	#include "./common.h"
	20	#include "./mod.h"
	21
	22	#define usbhs_priv_to_modinfo(priv) (&priv->mod_info)
b002ff6e KM	23	#define usbhs_mod_info_call(priv, func, param...) \
	24	({ \
	25	struct usbhs_mod_info *info; \
	26	info = usbhs_priv_to_modinfo(priv); \
	27	!info->func ? 0 : \
	28	info->func(param); \
	29	})
	30
	31	/*
	32	* autonomy
	33	*
	34	* these functions are used if platform doesn't have external phy.
	35	* -> there is no "notify_hotplug" callback from platform
	36	* -> call "notify_hotplug" by itself
	37	* -> use own interrupt to connect/disconnect
	38	* -> it mean module clock is always ON
	39	* ~~~~~~~~~~~~~~~~~~~~~~~~~
	40	*/
	41	static int usbhsm_autonomy_get_vbus(struct platform_device *pdev)
	42	{
	43	struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
	44
	45	return VBSTS & usbhs_read(priv, INTSTS0);
	46	}
	47
	48	static int usbhsm_autonomy_irq_vbus(struct usbhs_priv *priv,
	49	struct usbhs_irq_state *irq_state)
	50	{
	51	struct platform_device *pdev = usbhs_priv_to_pdev(priv);
	52
	53	return usbhsc_drvcllbck_notify_hotplug(pdev);
	54	}
	55
	56	void usbhs_mod_autonomy_mode(struct usbhs_priv *priv)
	57	{
	58	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
	59
	60	info->irq_vbus = usbhsm_autonomy_irq_vbus;
	61	priv->pfunc->get_vbus = usbhsm_autonomy_get_vbus;
	62
	63	usbhs_irq_callback_update(priv, NULL);
	64	}
f1407d5c KM	65
	66	/*
	67	* host / gadget functions
	68	*
	69	* renesas_usbhs host/gadget can register itself by below functions.
	70	* these functions are called when probe
	71	*
	72	*/
	73	void usbhs_mod_register(struct usbhs_priv priv, struct usbhs_mod mod, int id)
	74	{
	75	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
	76
	77	info->mod[id] = mod;
	78	mod->priv = priv;
	79	}
	80
	81	struct usbhs_mod usbhs_mod_get(struct usbhs_priv priv, int id)
	82	{
	83	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
	84	struct usbhs_mod *ret = NULL;
	85
	86	switch (id) {
	87	case USBHS_HOST:
	88	case USBHS_GADGET:
	89	ret = info->mod[id];
	90	break;
	91	}
	92
	93	return ret;
	94	}
	95
	96	int usbhs_mod_is_host(struct usbhs_priv priv, struct usbhs_mod mod)
	97	{
	98	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
	99
	100	if (!mod)
	101	return -EINVAL;
	102
	103	return info->mod[USBHS_HOST] == mod;
	104	}
	105
	106	struct usbhs_mod usbhs_mod_get_current(struct usbhs_priv priv)
	107	{
	108	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
	109
	110	return info->curt;
	111	}
	112
	113	int usbhs_mod_change(struct usbhs_priv *priv, int id)
	114	{
	115	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
	116	struct usbhs_mod *mod = NULL;
	117	int ret = 0;
	118
	119	/* id < 0 mean no current */
	120	switch (id) {
	121	case USBHS_HOST:
	122	case USBHS_GADGET:
	123	mod = info->mod[id];
	124	break;
	125	default:
	126	ret = -EINVAL;
	127	}
	128	info->curt = mod;
129
130	return ret;
131	}
132
133	static irqreturn_t usbhs_interrupt(int irq, void *data);
134	int usbhs_mod_probe(struct usbhs_priv *priv)
135	{
136	struct device *dev = usbhs_priv_to_dev(priv);
137	int ret;
138
2f98382d KM	139	/*
	140	* install host/gadget driver
	141	*/
	142	ret = usbhs_mod_gadget_probe(priv);
	143	if (ret < 0)
	144	return ret;
	145
f1407d5c KM	146	/* irq settings */
f1407d5c KM	147	ret = request_irq(priv->irq, usbhs_interrupt,
b5dd18d8	148	0, dev_name(dev), priv);
2f98382d	149	if (ret) {
f1407d5c	150	dev_err(dev, "irq request err\n");
2f98382d KM	151	goto mod_init_gadget_err;
	152	}
	153
	154	return ret;
	155
	156	mod_init_gadget_err:
	157	usbhs_mod_gadget_remove(priv);
f1407d5c KM	158
	159	return ret;
	160	}
	161
	162	void usbhs_mod_remove(struct usbhs_priv *priv)
	163	{
2f98382d	164	usbhs_mod_gadget_remove(priv);
f1407d5c KM	165	free_irq(priv->irq, priv);
	166	}
	167
	168	/*
	169	* status functions
	170	*/
f1407d5c KM	171	int usbhs_status_get_device_state(struct usbhs_irq_state *irq_state)
	172	{
	173	int state = irq_state->intsts0 & DVSQ_MASK;
	174
	175	switch (state) {
	176	case POWER_STATE:
	177	case DEFAULT_STATE:
	178	case ADDRESS_STATE:
	179	case CONFIGURATION_STATE:
	180	return state;
	181	}
	182
	183	return -EIO;
	184	}
	185
	186	int usbhs_status_get_ctrl_stage(struct usbhs_irq_state *irq_state)
	187	{
	188	/*
	189	* return value
	190	*
	191	* IDLE_SETUP_STAGE
	192	* READ_DATA_STAGE
	193	* READ_STATUS_STAGE
	194	* WRITE_DATA_STAGE
	195	* WRITE_STATUS_STAGE
	196	* NODATA_STATUS_STAGE
	197	* SEQUENCE_ERROR
	198	*/
	199	return (int)irq_state->intsts0 & CTSQ_MASK;
	200	}
	201
	202	static void usbhs_status_get_each_irq(struct usbhs_priv *priv,
	203	struct usbhs_irq_state *state)
	204	{
	205	struct usbhs_mod *mod = usbhs_mod_get_current(priv);
	206
	207	state->intsts0 = usbhs_read(priv, INTSTS0);
	208	state->intsts1 = usbhs_read(priv, INTSTS1);
	209
f1407d5c	210	/* mask */
5ea68d54 KM	211	if (mod) {
	212	state->brdysts = usbhs_read(priv, BRDYSTS);
	213	state->nrdysts = usbhs_read(priv, NRDYSTS);
	214	state->bempsts = usbhs_read(priv, BEMPSTS);
	215
	216	state->bempsts &= mod->irq_bempsts;
	217	state->brdysts &= mod->irq_brdysts;
	218	}
f1407d5c KM	219	}
	220
	221	/*
	222	* interrupt
	223	*/
	224	#define INTSTS0_MAGIC 0xF800 /* acknowledge magical interrupt sources */
	225	#define INTSTS1_MAGIC 0xA870 /* acknowledge magical interrupt sources */
	226	static irqreturn_t usbhs_interrupt(int irq, void *data)
	227	{
	228	struct usbhs_priv *priv = data;
	229	struct usbhs_irq_state irq_state;
	230
	231	usbhs_status_get_each_irq(priv, &irq_state);
	232
	233	/*
	234	* clear interrupt
	235	*
	236	* The hardware is _very_ picky to clear interrupt bit.
	237	* Especially INTSTS0_MAGIC, INTSTS1_MAGIC value.
	238	*
	239	* see
	240	* "Operation"
	241	* - "Control Transfer (DCP)"
	242	* - Function :: VALID bit should 0
	243	*/
	244	usbhs_write(priv, INTSTS0, ~irq_state.intsts0 & INTSTS0_MAGIC);
	245	usbhs_write(priv, INTSTS1, ~irq_state.intsts1 & INTSTS1_MAGIC);
	246
	247	usbhs_write(priv, BRDYSTS, 0);
	248	usbhs_write(priv, NRDYSTS, 0);
	249	usbhs_write(priv, BEMPSTS, 0);
	250
	251	/*
	252	* call irq callback functions
	253	* see also
	254	* usbhs_irq_setting_update
	255	*/
b002ff6e KM	256	if (irq_state.intsts0 & VBINT)
	257	usbhs_mod_info_call(priv, irq_vbus, priv, &irq_state);
	258
f1407d5c KM	259	if (irq_state.intsts0 & DVST)
	260	usbhs_mod_call(priv, irq_dev_state, priv, &irq_state);
	261
	262	if (irq_state.intsts0 & CTRT)
	263	usbhs_mod_call(priv, irq_ctrl_stage, priv, &irq_state);
	264
	265	if (irq_state.intsts0 & BEMP)
	266	usbhs_mod_call(priv, irq_empty, priv, &irq_state);
	267
	268	if (irq_state.intsts0 & BRDY)
	269	usbhs_mod_call(priv, irq_ready, priv, &irq_state);
	270
	271	return IRQ_HANDLED;
	272	}
	273
	274	void usbhs_irq_callback_update(struct usbhs_priv priv, struct usbhs_mod mod)
	275	{
	276	u16 intenb0 = 0;
b002ff6e	277	struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
f1407d5c	278
651f5e49 KM	279	/*
	280	* BEMPENB/BRDYENB are picky.
	281	* below method is required
	282	*
	283	* - clear INTSTS0
	284	* - update BEMPENB/BRDYENB
	285	* - update INTSTS0
	286	*/
f1407d5c KM	287	usbhs_write(priv, INTENB0, 0);
	288
	289	usbhs_write(priv, BEMPENB, 0);
	290	usbhs_write(priv, BRDYENB, 0);
	291
	292	/*
	293	* see also
	294	* usbhs_interrupt
	295	*/
	296
	297	/*
	298	* it don't enable DVSE (intenb0) here
	299	* but "mod->irq_dev_state" will be called.
	300	*/
b002ff6e KM	301	if (info->irq_vbus)
b002ff6e KM	302	intenb0 \|= VBSE;
f1407d5c	303
5ea68d54 KM	304	if (mod) {
	305	if (mod->irq_ctrl_stage)
	306	intenb0 \|= CTRE;
f1407d5c	307
5ea68d54 KM	308	if (mod->irq_empty && mod->irq_bempsts) {
	309	usbhs_write(priv, BEMPENB, mod->irq_bempsts);
	310	intenb0 \|= BEMPE;
	311	}
f1407d5c	312
5ea68d54 KM	313	if (mod->irq_ready && mod->irq_brdysts) {
	314	usbhs_write(priv, BRDYENB, mod->irq_brdysts);
	315	intenb0 \|= BRDYE;
	316	}
f1407d5c KM	317	}
f1407d5c KM	318
651f5e49 KM	319	if (intenb0)
651f5e49 KM	320	usbhs_write(priv, INTENB0, intenb0);
f1407d5c	321	}