[deliverable/linux.git] / drivers / misc / ti-st / st_ll.c

/*
 *  Shared Transport driver
 *	HCI-LL module responsible for TI proprietary HCI_LL protocol
 *  Copyright (C) 2009-2010 Texas Instruments
 *  Author: Pavan Savoy <pavan_savoy@ti.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 *
 *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#define pr_fmt(fmt) "(stll) :" fmt
#include <linux/skbuff.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/ti_wilink_st.h>

/**********************************************************************/
/* internal functions */
static void send_ll_cmd(struct st_data_s *st_data,
	unsigned char cmd)
{

	pr_debug("%s: writing %x", __func__, cmd);
	st_int_write(st_data, &cmd, 1);
	return;
}

static void ll_device_want_to_sleep(struct st_data_s *st_data)
{
	struct kim_data_s	*kim_data;
	struct ti_st_plat_data	*pdata;

	pr_debug("%s", __func__);
	/* sanity check */
	if (st_data->ll_state != ST_LL_AWAKE)
		pr_err("ERR hcill: ST_LL_GO_TO_SLEEP_IND"
			  "in state %ld", st_data->ll_state);

	send_ll_cmd(st_data, LL_SLEEP_ACK);
	/* update state */
	st_data->ll_state = ST_LL_ASLEEP;

	/* communicate to platform about chip asleep */
	kim_data = st_data->kim_data;
	pdata = kim_data->kim_pdev->dev.platform_data;
	if (pdata->chip_asleep)
		pdata->chip_asleep(NULL);
}

static void ll_device_want_to_wakeup(struct st_data_s *st_data)
{
	struct kim_data_s	*kim_data;
	struct ti_st_plat_data	*pdata;

	/* diff actions in diff states */
	switch (st_data->ll_state) {
	case ST_LL_ASLEEP:
		send_ll_cmd(st_data, LL_WAKE_UP_ACK);	/* send wake_ack */
		break;
	case ST_LL_ASLEEP_TO_AWAKE:
		/* duplicate wake_ind */
		pr_err("duplicate wake_ind while waiting for Wake ack");
		break;
	case ST_LL_AWAKE:
		/* duplicate wake_ind */
		pr_err("duplicate wake_ind already AWAKE");
		break;
	case ST_LL_AWAKE_TO_ASLEEP:
		/* duplicate wake_ind */
		pr_err("duplicate wake_ind");
		break;
	}
	/* update state */
	st_data->ll_state = ST_LL_AWAKE;

	/* communicate to platform about chip wakeup */
	kim_data = st_data->kim_data;
	pdata = kim_data->kim_pdev->dev.platform_data;
	if (pdata->chip_awake)
		pdata->chip_awake(NULL);
}

/**********************************************************************/
/* functions invoked by ST Core */

/* called when ST Core wants to
 * enable ST LL */
void st_ll_enable(struct st_data_s *ll)
{
	ll->ll_state = ST_LL_AWAKE;
}

/* called when ST Core /local module wants to
 * disable ST LL */
void st_ll_disable(struct st_data_s *ll)
{
	ll->ll_state = ST_LL_INVALID;
}

/* called when ST Core wants to update the state */
void st_ll_wakeup(struct st_data_s *ll)
{
	if (likely(ll->ll_state != ST_LL_AWAKE)) {
		send_ll_cmd(ll, LL_WAKE_UP_IND);	/* WAKE_IND */
		ll->ll_state = ST_LL_ASLEEP_TO_AWAKE;
	} else {
		/* don't send the duplicate wake_indication */
		pr_err(" Chip already AWAKE ");
	}
}

/* called when ST Core wants the state */
unsigned long st_ll_getstate(struct st_data_s *ll)
{
	pr_debug(" returning state %ld", ll->ll_state);
	return ll->ll_state;
}

/* called from ST Core, when a PM related packet arrives */
unsigned long st_ll_sleep_state(struct st_data_s *st_data,
	unsigned char cmd)
{
	switch (cmd) {
	case LL_SLEEP_IND:	/* sleep ind */
		pr_debug("sleep indication recvd");
		ll_device_want_to_sleep(st_data);
		break;
	case LL_SLEEP_ACK:	/* sleep ack */
		pr_err("sleep ack rcvd: host shouldn't");
		break;
	case LL_WAKE_UP_IND:	/* wake ind */
		pr_debug("wake indication recvd");
		ll_device_want_to_wakeup(st_data);
		break;
	case LL_WAKE_UP_ACK:	/* wake ack */
		pr_debug("wake ack rcvd");
		st_data->ll_state = ST_LL_AWAKE;
		break;
	default:
		pr_err(" unknown input/state ");
		return -EINVAL;
	}
	return 0;
}

/* Called from ST CORE to initialize ST LL */
long st_ll_init(struct st_data_s *ll)
{
	/* set state to invalid */
	ll->ll_state = ST_LL_INVALID;
	return 0;
}

/* Called from ST CORE to de-initialize ST LL */
long st_ll_deinit(struct st_data_s *ll)
{
	return 0;
}
Commit	Line	Data
1d065ab6 PS	1	/*
	2	* Shared Transport driver
	3	* HCI-LL module responsible for TI proprietary HCI_LL protocol
a0cc2f3b PS	4	* Copyright (C) 2009-2010 Texas Instruments
a0cc2f3b PS	5	* Author: Pavan Savoy <pavan_savoy@ti.com>
1d065ab6 PS	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
	20	*/
	21
	22	#define pr_fmt(fmt) "(stll) :" fmt
83ef41f0 PS	23	#include <linux/skbuff.h>
83ef41f0 PS	24	#include <linux/module.h>
0d7c5f25	25	#include <linux/platform_device.h>
e5558679	26	#include <linux/ti_wilink_st.h>
1d065ab6 PS	27
	28	/**********************************************************************/
	29	/* internal functions */
	30	static void send_ll_cmd(struct st_data_s *st_data,
	31	unsigned char cmd)
	32	{
	33
6710fcff	34	pr_debug("%s: writing %x", __func__, cmd);
1d065ab6 PS	35	st_int_write(st_data, &cmd, 1);
	36	return;
	37	}
	38
	39	static void ll_device_want_to_sleep(struct st_data_s *st_data)
	40	{
0d7c5f25 PS	41	struct kim_data_s *kim_data;
	42	struct ti_st_plat_data *pdata;
	43
e6d9e64e	44	pr_debug("%s", __func__);
1d065ab6 PS	45	/* sanity check */
	46	if (st_data->ll_state != ST_LL_AWAKE)
	47	pr_err("ERR hcill: ST_LL_GO_TO_SLEEP_IND"
	48	"in state %ld", st_data->ll_state);
	49
	50	send_ll_cmd(st_data, LL_SLEEP_ACK);
	51	/* update state */
	52	st_data->ll_state = ST_LL_ASLEEP;
0d7c5f25 PS	53
	54	/* communicate to platform about chip asleep */
	55	kim_data = st_data->kim_data;
c0bd1b9e	56	pdata = kim_data->kim_pdev->dev.platform_data;
0d7c5f25 PS	57	if (pdata->chip_asleep)
0d7c5f25 PS	58	pdata->chip_asleep(NULL);
1d065ab6 PS	59	}
	60
	61	static void ll_device_want_to_wakeup(struct st_data_s *st_data)
	62	{
0d7c5f25 PS	63	struct kim_data_s *kim_data;
	64	struct ti_st_plat_data *pdata;
	65
1d065ab6 PS	66	/* diff actions in diff states */
	67	switch (st_data->ll_state) {
	68	case ST_LL_ASLEEP:
	69	send_ll_cmd(st_data, LL_WAKE_UP_ACK); /* send wake_ack */
	70	break;
	71	case ST_LL_ASLEEP_TO_AWAKE:
	72	/* duplicate wake_ind */
	73	pr_err("duplicate wake_ind while waiting for Wake ack");
	74	break;
	75	case ST_LL_AWAKE:
	76	/* duplicate wake_ind */
	77	pr_err("duplicate wake_ind already AWAKE");
	78	break;
	79	case ST_LL_AWAKE_TO_ASLEEP:
	80	/* duplicate wake_ind */
	81	pr_err("duplicate wake_ind");
	82	break;
	83	}
	84	/* update state */
	85	st_data->ll_state = ST_LL_AWAKE;
0d7c5f25 PS	86
	87	/* communicate to platform about chip wakeup */
	88	kim_data = st_data->kim_data;
c0bd1b9e	89	pdata = kim_data->kim_pdev->dev.platform_data;
f3d9d365	90	if (pdata->chip_awake)
0d7c5f25	91	pdata->chip_awake(NULL);
1d065ab6 PS	92	}
	93
	94	/**********************************************************************/
	95	/* functions invoked by ST Core */
	96
	97	/* called when ST Core wants to
	98	* enable ST LL */
	99	void st_ll_enable(struct st_data_s *ll)
	100	{
	101	ll->ll_state = ST_LL_AWAKE;
	102	}
	103
	104	/* called when ST Core /local module wants to
	105	* disable ST LL */
	106	void st_ll_disable(struct st_data_s *ll)
	107	{
	108	ll->ll_state = ST_LL_INVALID;
	109	}
	110
	111	/* called when ST Core wants to update the state */
	112	void st_ll_wakeup(struct st_data_s *ll)
	113	{
	114	if (likely(ll->ll_state != ST_LL_AWAKE)) {
	115	send_ll_cmd(ll, LL_WAKE_UP_IND); /* WAKE_IND */
	116	ll->ll_state = ST_LL_ASLEEP_TO_AWAKE;
	117	} else {
	118	/* don't send the duplicate wake_indication */
	119	pr_err(" Chip already AWAKE ");
	120	}
	121	}
	122
	123	/* called when ST Core wants the state */
	124	unsigned long st_ll_getstate(struct st_data_s *ll)
	125	{
e6d9e64e	126	pr_debug(" returning state %ld", ll->ll_state);
1d065ab6 PS	127	return ll->ll_state;
	128	}
	129
	130	/* called from ST Core, when a PM related packet arrives */
	131	unsigned long st_ll_sleep_state(struct st_data_s *st_data,
	132	unsigned char cmd)
	133	{
	134	switch (cmd) {
	135	case LL_SLEEP_IND: /* sleep ind */
6710fcff	136	pr_debug("sleep indication recvd");
1d065ab6 PS	137	ll_device_want_to_sleep(st_data);
	138	break;
	139	case LL_SLEEP_ACK: /* sleep ack */
	140	pr_err("sleep ack rcvd: host shouldn't");
	141	break;
	142	case LL_WAKE_UP_IND: /* wake ind */
6710fcff	143	pr_debug("wake indication recvd");
1d065ab6 PS	144	ll_device_want_to_wakeup(st_data);
	145	break;
	146	case LL_WAKE_UP_ACK: /* wake ack */
6710fcff	147	pr_debug("wake ack rcvd");
1d065ab6 PS	148	st_data->ll_state = ST_LL_AWAKE;
	149	break;
	150	default:
	151	pr_err(" unknown input/state ");
70442664	152	return -EINVAL;
1d065ab6	153	}
320920cb	154	return 0;
1d065ab6 PS	155	}
	156
	157	/* Called from ST CORE to initialize ST LL */
	158	long st_ll_init(struct st_data_s *ll)
	159	{
	160	/* set state to invalid */
	161	ll->ll_state = ST_LL_INVALID;
	162	return 0;
	163	}
	164
	165	/* Called from ST CORE to de-initialize ST LL */
	166	long st_ll_deinit(struct st_data_s *ll)
	167	{
	168	return 0;
	169	}