[net-next-2.6.git] / drivers / staging / dream / qdsp5 / audmgr.c

/* arch/arm/mach-msm/qdsp5/audmgr.c
 *
 * interface to "audmgr" service on the baseband cpu
 *
 * Copyright (C) 2008 Google, Inc.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * 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.
 *
 */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/kthread.h>
#include <linux/wait.h>

#include <asm/atomic.h>
#include <mach/msm_rpcrouter.h>

#include "audmgr.h"

#define STATE_CLOSED    0
#define STATE_DISABLED  1
#define STATE_ENABLING  2
#define STATE_ENABLED   3
#define STATE_DISABLING 4
#define STATE_ERROR	5

static void rpc_ack(struct msm_rpc_endpoint *ept, uint32_t xid)
{
	uint32_t rep[6];

	rep[0] = cpu_to_be32(xid);
	rep[1] = cpu_to_be32(1);
	rep[2] = cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED);
	rep[3] = cpu_to_be32(RPC_ACCEPTSTAT_SUCCESS);
	rep[4] = 0;
	rep[5] = 0;

	msm_rpc_write(ept, rep, sizeof(rep));
}

static void process_audmgr_callback(struct audmgr *am,
				   struct rpc_audmgr_cb_func_ptr *args,
				   int len)
{
	if (len < (sizeof(uint32_t) * 3))
		return;
	if (be32_to_cpu(args->set_to_one) != 1)
		return;

	switch (be32_to_cpu(args->status)) {
	case RPC_AUDMGR_STATUS_READY:
		if (len < sizeof(uint32_t) * 4)
			break;
		am->handle = be32_to_cpu(args->u.handle);
		pr_info("audmgr: rpc READY handle=0x%08x\n", am->handle);
		break;
	case RPC_AUDMGR_STATUS_CODEC_CONFIG: {
		uint32_t volume;
		if (len < sizeof(uint32_t) * 4)
			break;
		volume = be32_to_cpu(args->u.volume);
		pr_info("audmgr: rpc CODEC_CONFIG volume=0x%08x\n", volume);
		am->state = STATE_ENABLED;
		wake_up(&am->wait);
		break;
	}
	case RPC_AUDMGR_STATUS_PENDING:
		pr_err("audmgr: PENDING?\n");
		break;
	case RPC_AUDMGR_STATUS_SUSPEND:
		pr_err("audmgr: SUSPEND?\n");
		break;
	case RPC_AUDMGR_STATUS_FAILURE:
		pr_err("audmgr: FAILURE\n");
		break;
	case RPC_AUDMGR_STATUS_VOLUME_CHANGE:
		pr_err("audmgr: VOLUME_CHANGE?\n");
		break;
	case RPC_AUDMGR_STATUS_DISABLED:
		pr_err("audmgr: DISABLED\n");
		am->state = STATE_DISABLED;
		wake_up(&am->wait);
		break;
	case RPC_AUDMGR_STATUS_ERROR:
		pr_err("audmgr: ERROR?\n");
		am->state = STATE_ERROR;
		wake_up(&am->wait);
		break;
	default:
		break;
	}
}

static void process_rpc_request(uint32_t proc, uint32_t xid,
				void *data, int len, void *private)
{
	struct audmgr *am = private;
	uint32_t *x = data;

	if (0) {
		int n = len / 4;
		pr_info("rpc_call proc %d:", proc);
		while (n--)
			printk(" %08x", be32_to_cpu(*x++));
		printk("\n");
	}

	if (proc == AUDMGR_CB_FUNC_PTR)
		process_audmgr_callback(am, data, len);
	else
		pr_err("audmgr: unknown rpc proc %d\n", proc);
	rpc_ack(am->ept, xid);
}

#define RPC_TYPE_REQUEST 0
#define RPC_TYPE_REPLY 1

#define RPC_VERSION 2

#define RPC_COMMON_HDR_SZ  (sizeof(uint32_t) * 2)
#define RPC_REQUEST_HDR_SZ (sizeof(struct rpc_request_hdr))
#define RPC_REPLY_HDR_SZ   (sizeof(uint32_t) * 3)
#define RPC_REPLY_SZ       (sizeof(uint32_t) * 6)

static int audmgr_rpc_thread(void *data)
{
	struct audmgr *am = data;
	struct rpc_request_hdr *hdr = NULL;
	uint32_t type;
	int len;

	pr_info("audmgr_rpc_thread() start\n");

	while (!kthread_should_stop()) {
		if (hdr) {
			kfree(hdr);
			hdr = NULL;
		}
		len = msm_rpc_read(am->ept, (void **) &hdr, -1, -1);
		if (len < 0) {
			pr_err("audmgr: rpc read failed (%d)\n", len);
			break;
		}
		if (len < RPC_COMMON_HDR_SZ)
			continue;

		type = be32_to_cpu(hdr->type);
		if (type == RPC_TYPE_REPLY) {
			struct rpc_reply_hdr *rep = (void *) hdr;
			uint32_t status;
			if (len < RPC_REPLY_HDR_SZ)
				continue;
			status = be32_to_cpu(rep->reply_stat);
			if (status == RPCMSG_REPLYSTAT_ACCEPTED) {
				status = be32_to_cpu(rep->data.acc_hdr.accept_stat);
				pr_info("audmgr: rpc_reply status %d\n", status);
			} else {
				pr_info("audmgr: rpc_reply denied!\n");
			}
			/* process reply */
			continue;
		}

		if (len < RPC_REQUEST_HDR_SZ)
			continue;

		process_rpc_request(be32_to_cpu(hdr->procedure),
				    be32_to_cpu(hdr->xid),
				    (void *) (hdr + 1),
				    len - sizeof(*hdr),
				    data);
	}
	pr_info("audmgr_rpc_thread() exit\n");
	if (hdr) {
		kfree(hdr);
		hdr = NULL;
	}
	am->task = NULL;
	wake_up(&am->wait);
	return 0;
}

struct audmgr_enable_msg {
	struct rpc_request_hdr hdr;
	struct rpc_audmgr_enable_client_args args;
};

struct audmgr_disable_msg {
	struct rpc_request_hdr hdr;
	uint32_t handle;
};

int audmgr_open(struct audmgr *am)
{
	int rc;

	if (am->state != STATE_CLOSED)
		return 0;

	am->ept = msm_rpc_connect(AUDMGR_PROG,
				AUDMGR_VERS,
				MSM_RPC_UNINTERRUPTIBLE);

	init_waitqueue_head(&am->wait);

	if (IS_ERR(am->ept)) {
		rc = PTR_ERR(am->ept);
		am->ept = NULL;
		pr_err("audmgr: failed to connect to audmgr svc\n");
		return rc;
	}

	am->task = kthread_run(audmgr_rpc_thread, am, "audmgr_rpc");
	if (IS_ERR(am->task)) {
		rc = PTR_ERR(am->task);
		am->task = NULL;
		msm_rpc_close(am->ept);
		am->ept = NULL;
		return rc;
	}

	am->state = STATE_DISABLED;
	return 0;
}
EXPORT_SYMBOL(audmgr_open);

int audmgr_close(struct audmgr *am)
{
	return -EBUSY;
}
EXPORT_SYMBOL(audmgr_close);

int audmgr_enable(struct audmgr *am, struct audmgr_config *cfg)
{
	struct audmgr_enable_msg msg;
	int rc;

	if (am->state == STATE_ENABLED)
		return 0;

	if (am->state == STATE_DISABLING)
		pr_err("audmgr: state is DISABLING in enable?\n");
	am->state = STATE_ENABLING;

	msg.args.set_to_one = cpu_to_be32(1);
	msg.args.tx_sample_rate = cpu_to_be32(cfg->tx_rate);
	msg.args.rx_sample_rate = cpu_to_be32(cfg->rx_rate);
	msg.args.def_method = cpu_to_be32(cfg->def_method);
	msg.args.codec_type = cpu_to_be32(cfg->codec);
	msg.args.snd_method = cpu_to_be32(cfg->snd_method);
	msg.args.cb_func = cpu_to_be32(0x11111111);
	msg.args.client_data = cpu_to_be32(0x11223344);

	msm_rpc_setup_req(&msg.hdr, AUDMGR_PROG, msm_rpc_get_vers(am->ept),
			  AUDMGR_ENABLE_CLIENT);

	rc = msm_rpc_write(am->ept, &msg, sizeof(msg));
	if (rc < 0)
		return rc;

	rc = wait_event_timeout(am->wait, am->state != STATE_ENABLING, 15 * HZ);
	if (rc == 0) {
		pr_err("audmgr_enable: ARM9 did not reply to RPC am->state = %d\n", am->state);
		BUG();
	}
	if (am->state == STATE_ENABLED)
		return 0;

	pr_err("audmgr: unexpected state %d while enabling?!\n", am->state);
	return -ENODEV;
}
EXPORT_SYMBOL(audmgr_enable);

int audmgr_disable(struct audmgr *am)
{
	struct audmgr_disable_msg msg;
	int rc;

	if (am->state == STATE_DISABLED)
		return 0;

	msm_rpc_setup_req(&msg.hdr, AUDMGR_PROG, msm_rpc_get_vers(am->ept),
			  AUDMGR_DISABLE_CLIENT);
	msg.handle = cpu_to_be32(am->handle);

	am->state = STATE_DISABLING;

	rc = msm_rpc_write(am->ept, &msg, sizeof(msg));
	if (rc < 0)
		return rc;

	rc = wait_event_timeout(am->wait, am->state != STATE_DISABLING, 15 * HZ);
	if (rc == 0) {
		pr_err("audmgr_disable: ARM9 did not reply to RPC am->state = %d\n", am->state);
		BUG();
	}

	if (am->state == STATE_DISABLED)
		return 0;

	pr_err("audmgr: unexpected state %d while disabling?!\n", am->state);
	return -ENODEV;
}
EXPORT_SYMBOL(audmgr_disable);
Commit	Line	Data
caff4cae IM	1	/* arch/arm/mach-msm/qdsp5/audmgr.c
	2	*
	3	* interface to "audmgr" service on the baseband cpu
	4	*
	5	* Copyright (C) 2008 Google, Inc.
	6	*
	7	* This software is licensed under the terms of the GNU General Public
	8	* License version 2, as published by the Free Software Foundation, and
	9	* may be copied, distributed, and modified under those terms.
	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	*/
	17
	18	#include <linux/module.h>
	19	#include <linux/fs.h>
	20	#include <linux/uaccess.h>
5a0e3ad6	21	#include <linux/slab.h>
caff4cae IM	22	#include <linux/kthread.h>
	23	#include <linux/wait.h>
	24
	25	#include <asm/atomic.h>
	26	#include <mach/msm_rpcrouter.h>
	27
	28	#include "audmgr.h"
	29
	30	#define STATE_CLOSED 0
	31	#define STATE_DISABLED 1
	32	#define STATE_ENABLING 2
	33	#define STATE_ENABLED 3
	34	#define STATE_DISABLING 4
	35	#define STATE_ERROR 5
	36
	37	static void rpc_ack(struct msm_rpc_endpoint *ept, uint32_t xid)
	38	{
	39	uint32_t rep[6];
	40
	41	rep[0] = cpu_to_be32(xid);
	42	rep[1] = cpu_to_be32(1);
	43	rep[2] = cpu_to_be32(RPCMSG_REPLYSTAT_ACCEPTED);
	44	rep[3] = cpu_to_be32(RPC_ACCEPTSTAT_SUCCESS);
	45	rep[4] = 0;
	46	rep[5] = 0;
	47
	48	msm_rpc_write(ept, rep, sizeof(rep));
	49	}
	50
	51	static void process_audmgr_callback(struct audmgr *am,
	52	struct rpc_audmgr_cb_func_ptr *args,
	53	int len)
	54	{
	55	if (len < (sizeof(uint32_t) * 3))
	56	return;
	57	if (be32_to_cpu(args->set_to_one) != 1)
	58	return;
	59
	60	switch (be32_to_cpu(args->status)) {
	61	case RPC_AUDMGR_STATUS_READY:
	62	if (len < sizeof(uint32_t) * 4)
	63	break;
	64	am->handle = be32_to_cpu(args->u.handle);
	65	pr_info("audmgr: rpc READY handle=0x%08x\n", am->handle);
	66	break;
	67	case RPC_AUDMGR_STATUS_CODEC_CONFIG: {
	68	uint32_t volume;
	69	if (len < sizeof(uint32_t) * 4)
	70	break;
	71	volume = be32_to_cpu(args->u.volume);
	72	pr_info("audmgr: rpc CODEC_CONFIG volume=0x%08x\n", volume);
	73	am->state = STATE_ENABLED;
	74	wake_up(&am->wait);
	75	break;
	76	}
	77	case RPC_AUDMGR_STATUS_PENDING:
	78	pr_err("audmgr: PENDING?\n");
	79	break;
	80	case RPC_AUDMGR_STATUS_SUSPEND:
	81	pr_err("audmgr: SUSPEND?\n");
	82	break;
	83	case RPC_AUDMGR_STATUS_FAILURE:
	84	pr_err("audmgr: FAILURE\n");
	85	break;
86	case RPC_AUDMGR_STATUS_VOLUME_CHANGE:
87	pr_err("audmgr: VOLUME_CHANGE?\n");
88	break;
89	case RPC_AUDMGR_STATUS_DISABLED:
90	pr_err("audmgr: DISABLED\n");
91	am->state = STATE_DISABLED;
92	wake_up(&am->wait);
93	break;
94	case RPC_AUDMGR_STATUS_ERROR:
95	pr_err("audmgr: ERROR?\n");
96	am->state = STATE_ERROR;
97	wake_up(&am->wait);
98	break;
99	default:
100	break;
101	}
102	}
103
104	static void process_rpc_request(uint32_t proc, uint32_t xid,
105	void data, int len, void private)
106	{
107	struct audmgr *am = private;
108	uint32_t *x = data;
109
110	if (0) {
111	int n = len / 4;
112	pr_info("rpc_call proc %d:", proc);
113	while (n--)
114	printk(" %08x", be32_to_cpu(*x++));
115	printk("\n");
116	}
117
118	if (proc == AUDMGR_CB_FUNC_PTR)
119	process_audmgr_callback(am, data, len);
120	else
121	pr_err("audmgr: unknown rpc proc %d\n", proc);
122	rpc_ack(am->ept, xid);
123	}
124
125	#define RPC_TYPE_REQUEST 0
126	#define RPC_TYPE_REPLY 1
127
128	#define RPC_VERSION 2
129
130	#define RPC_COMMON_HDR_SZ (sizeof(uint32_t) * 2)
131	#define RPC_REQUEST_HDR_SZ (sizeof(struct rpc_request_hdr))
132	#define RPC_REPLY_HDR_SZ (sizeof(uint32_t) * 3)
133	#define RPC_REPLY_SZ (sizeof(uint32_t) * 6)
134
135	static int audmgr_rpc_thread(void *data)
136	{
137	struct audmgr *am = data;
138	struct rpc_request_hdr *hdr = NULL;
139	uint32_t type;
140	int len;
141
142	pr_info("audmgr_rpc_thread() start\n");
143
144	while (!kthread_should_stop()) {
145	if (hdr) {
146	kfree(hdr);
147	hdr = NULL;
148	}
149	len = msm_rpc_read(am->ept, (void **) &hdr, -1, -1);
150	if (len < 0) {
151	pr_err("audmgr: rpc read failed (%d)\n", len);
152	break;
153	}
154	if (len < RPC_COMMON_HDR_SZ)
155	continue;
156
157	type = be32_to_cpu(hdr->type);
158	if (type == RPC_TYPE_REPLY) {
159	struct rpc_reply_hdr rep = (void ) hdr;
160	uint32_t status;
161	if (len < RPC_REPLY_HDR_SZ)
162	continue;
163	status = be32_to_cpu(rep->reply_stat);
164	if (status == RPCMSG_REPLYSTAT_ACCEPTED) {
165	status = be32_to_cpu(rep->data.acc_hdr.accept_stat);
166	pr_info("audmgr: rpc_reply status %d\n", status);
167	} else {
168	pr_info("audmgr: rpc_reply denied!\n");
169	}
170	/* process reply */
171	continue;
172	}
173
174	if (len < RPC_REQUEST_HDR_SZ)
175	continue;
176
177	process_rpc_request(be32_to_cpu(hdr->procedure),
178	be32_to_cpu(hdr->xid),
179	(void *) (hdr + 1),
180	len - sizeof(*hdr),
181	data);
182	}
183	pr_info("audmgr_rpc_thread() exit\n");
184	if (hdr) {
185	kfree(hdr);
186	hdr = NULL;
187	}
188	am->task = NULL;
189	wake_up(&am->wait);
190	return 0;
191	}
192
193	struct audmgr_enable_msg {
194	struct rpc_request_hdr hdr;
195	struct rpc_audmgr_enable_client_args args;
196	};
197
198	struct audmgr_disable_msg {
199	struct rpc_request_hdr hdr;
200	uint32_t handle;
201	};
202
203	int audmgr_open(struct audmgr *am)
204	{
205	int rc;
206
207	if (am->state != STATE_CLOSED)
208	return 0;
209
210	am->ept = msm_rpc_connect(AUDMGR_PROG,
211	AUDMGR_VERS,
212	MSM_RPC_UNINTERRUPTIBLE);
213
214	init_waitqueue_head(&am->wait);
215
216	if (IS_ERR(am->ept)) {
217	rc = PTR_ERR(am->ept);
218	am->ept = NULL;
219	pr_err("audmgr: failed to connect to audmgr svc\n");
220	return rc;
221	}
222
223	am->task = kthread_run(audmgr_rpc_thread, am, "audmgr_rpc");
224	if (IS_ERR(am->task)) {
225	rc = PTR_ERR(am->task);
226	am->task = NULL;
227	msm_rpc_close(am->ept);
228	am->ept = NULL;
229	return rc;
230	}
231
232	am->state = STATE_DISABLED;
233	return 0;
234	}
235	EXPORT_SYMBOL(audmgr_open);
236
237	int audmgr_close(struct audmgr *am)
238	{
239	return -EBUSY;
240	}
241	EXPORT_SYMBOL(audmgr_close);
242
243	int audmgr_enable(struct audmgr am, struct audmgr_config cfg)
244	{
245	struct audmgr_enable_msg msg;
246	int rc;
247
248	if (am->state == STATE_ENABLED)
249	return 0;
250
251	if (am->state == STATE_DISABLING)
252	pr_err("audmgr: state is DISABLING in enable?\n");
253	am->state = STATE_ENABLING;
254
255	msg.args.set_to_one = cpu_to_be32(1);
256	msg.args.tx_sample_rate = cpu_to_be32(cfg->tx_rate);
257	msg.args.rx_sample_rate = cpu_to_be32(cfg->rx_rate);
258	msg.args.def_method = cpu_to_be32(cfg->def_method);
259	msg.args.codec_type = cpu_to_be32(cfg->codec);
260	msg.args.snd_method = cpu_to_be32(cfg->snd_method);
261	msg.args.cb_func = cpu_to_be32(0x11111111);
262	msg.args.client_data = cpu_to_be32(0x11223344);
263
264	msm_rpc_setup_req(&msg.hdr, AUDMGR_PROG, msm_rpc_get_vers(am->ept),
265	AUDMGR_ENABLE_CLIENT);
266
267	rc = msm_rpc_write(am->ept, &msg, sizeof(msg));
268	if (rc < 0)
269	return rc;
270
271	rc = wait_event_timeout(am->wait, am->state != STATE_ENABLING, 15 * HZ);
272	if (rc == 0) {
273	pr_err("audmgr_enable: ARM9 did not reply to RPC am->state = %d\n", am->state);
274	BUG();
275	}
276	if (am->state == STATE_ENABLED)
277	return 0;
278
279	pr_err("audmgr: unexpected state %d while enabling?!\n", am->state);
280	return -ENODEV;
281	}
282	EXPORT_SYMBOL(audmgr_enable);
283
284	int audmgr_disable(struct audmgr *am)
285	{
286	struct audmgr_disable_msg msg;
287	int rc;
288
289	if (am->state == STATE_DISABLED)
290	return 0;
291
292	msm_rpc_setup_req(&msg.hdr, AUDMGR_PROG, msm_rpc_get_vers(am->ept),
293	AUDMGR_DISABLE_CLIENT);
294	msg.handle = cpu_to_be32(am->handle);
295
296	am->state = STATE_DISABLING;
297
298	rc = msm_rpc_write(am->ept, &msg, sizeof(msg));
299	if (rc < 0)
300	return rc;
301
302	rc = wait_event_timeout(am->wait, am->state != STATE_DISABLING, 15 * HZ);
303	if (rc == 0) {
304	pr_err("audmgr_disable: ARM9 did not reply to RPC am->state = %d\n", am->state);
305	BUG();
306	}
307
308	if (am->state == STATE_DISABLED)
309	return 0;
310
311	pr_err("audmgr: unexpected state %d while disabling?!\n", am->state);
312	return -ENODEV;
313	}
314	EXPORT_SYMBOL(audmgr_disable);