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


/* arch/arm/mach-msm/qdsp5/audpp.c
 *
 * common code to deal with the AUDPP dsp task (audio postproc)
 *
 * 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/kernel.h>
#include <linux/module.h>
#include <linux/wait.h>
#include <linux/delay.h>

#include <asm/atomic.h>
#include <asm/ioctls.h>
#include <mach/msm_adsp.h>

#include "audmgr.h"

#include <mach/qdsp5/qdsp5audppcmdi.h>
#include <mach/qdsp5/qdsp5audppmsg.h>

/* for queue ids - should be relative to module number*/
#include "adsp.h"

#include "evlog.h"


enum {
	EV_NULL,
	EV_ENABLE,
	EV_DISABLE,
	EV_EVENT,
	EV_DATA,
};

static const char *dsp_log_strings[] = {
	"NULL",
	"ENABLE",
	"DISABLE",
	"EVENT",
	"DATA",
};

DECLARE_LOG(dsp_log, 64, dsp_log_strings);

static int __init _dsp_log_init(void)
{
	return ev_log_init(&dsp_log);
}
module_init(_dsp_log_init);
#define LOG(id,arg) ev_log_write(&dsp_log, id, arg)

static DEFINE_MUTEX(audpp_lock);

#define CH_COUNT 5
#define AUDPP_CLNT_MAX_COUNT 6
#define AUDPP_AVSYNC_INFO_SIZE 7

struct audpp_state {
	struct msm_adsp_module *mod;
	audpp_event_func func[AUDPP_CLNT_MAX_COUNT];
	void *private[AUDPP_CLNT_MAX_COUNT];
	struct mutex *lock;
	unsigned open_count;
	unsigned enabled;

	/* which channels are actually enabled */
	unsigned avsync_mask;

	/* flags, 48 bits sample/bytes counter per channel */
	uint16_t avsync[CH_COUNT * AUDPP_CLNT_MAX_COUNT + 1];
};

struct audpp_state the_audpp_state = {
	.lock = &audpp_lock,
};

int audpp_send_queue1(void *cmd, unsigned len)
{
	return msm_adsp_write(the_audpp_state.mod,
			      QDSP_uPAudPPCmd1Queue, cmd, len);
}
EXPORT_SYMBOL(audpp_send_queue1);

int audpp_send_queue2(void *cmd, unsigned len)
{
	return msm_adsp_write(the_audpp_state.mod,
			      QDSP_uPAudPPCmd2Queue, cmd, len);
}
EXPORT_SYMBOL(audpp_send_queue2);

int audpp_send_queue3(void *cmd, unsigned len)
{
	return msm_adsp_write(the_audpp_state.mod,
			      QDSP_uPAudPPCmd3Queue, cmd, len);
}
EXPORT_SYMBOL(audpp_send_queue3);

static int audpp_dsp_config(int enable)
{
	audpp_cmd_cfg cmd;

	cmd.cmd_id = AUDPP_CMD_CFG;
	cmd.cfg = enable ? AUDPP_CMD_CFG_ENABLE : AUDPP_CMD_CFG_SLEEP;

	return audpp_send_queue1(&cmd, sizeof(cmd));
}

static void audpp_broadcast(struct audpp_state *audpp, unsigned id,
			    uint16_t *msg)
{
	unsigned n;
	for (n = 0; n < AUDPP_CLNT_MAX_COUNT; n++) {
		if (audpp->func[n])
			audpp->func[n] (audpp->private[n], id, msg);
	}
}

static void audpp_notify_clnt(struct audpp_state *audpp, unsigned clnt_id,
			      unsigned id, uint16_t *msg)
{
	if (clnt_id < AUDPP_CLNT_MAX_COUNT && audpp->func[clnt_id])
		audpp->func[clnt_id] (audpp->private[clnt_id], id, msg);
}

static void audpp_dsp_event(void *data, unsigned id, size_t len,
			    void (*getevent)(void *ptr, size_t len))
{
	struct audpp_state *audpp = data;
	uint16_t msg[8];

	if (id == AUDPP_MSG_AVSYNC_MSG) {
		getevent(audpp->avsync, sizeof(audpp->avsync));

		/* mask off any channels we're not watching to avoid
		 * cases where we might get one last update after
		 * disabling avsync and end up in an odd state when
		 * we next read...
		 */
		audpp->avsync[0] &= audpp->avsync_mask;
		return;
	}

	getevent(msg, sizeof(msg));

	LOG(EV_EVENT, (id << 16) | msg[0]);
	LOG(EV_DATA, (msg[1] << 16) | msg[2]);

	switch (id) {
	case AUDPP_MSG_STATUS_MSG:{
			unsigned cid = msg[0];
			pr_info("audpp: status %d %d %d\n", cid, msg[1],
				msg[2]);
			if ((cid < 5) && audpp->func[cid])
				audpp->func[cid] (audpp->private[cid], id, msg);
			break;
		}
	case AUDPP_MSG_HOST_PCM_INTF_MSG:
		if (audpp->func[5])
			audpp->func[5] (audpp->private[5], id, msg);
		break;
	case AUDPP_MSG_PCMDMAMISSED:
		pr_err("audpp: DMA missed obj=%x\n", msg[0]);
		break;
	case AUDPP_MSG_CFG_MSG:
		if (msg[0] == AUDPP_MSG_ENA_ENA) {
			pr_info("audpp: ENABLE\n");
			audpp->enabled = 1;
			audpp_broadcast(audpp, id, msg);
		} else if (msg[0] == AUDPP_MSG_ENA_DIS) {
			pr_info("audpp: DISABLE\n");
			audpp->enabled = 0;
			audpp_broadcast(audpp, id, msg);
		} else {
			pr_err("audpp: invalid config msg %d\n", msg[0]);
		}
		break;
	case AUDPP_MSG_ROUTING_ACK:
		audpp_broadcast(audpp, id, msg);
		break;
	case AUDPP_MSG_FLUSH_ACK:
		audpp_notify_clnt(audpp, msg[0], id, msg);
		break;
	default:
	  pr_info("audpp: unhandled msg id %x\n", id);
	}
}

static struct msm_adsp_ops adsp_ops = {
	.event = audpp_dsp_event,
};

static void audpp_fake_event(struct audpp_state *audpp, int id,
			     unsigned event, unsigned arg)
{
	uint16_t msg[1];
	msg[0] = arg;
	audpp->func[id] (audpp->private[id], event, msg);
}

int audpp_enable(int id, audpp_event_func func, void *private)
{
	struct audpp_state *audpp = &the_audpp_state;
	int res = 0;

	if (id < -1 || id > 4)
		return -EINVAL;

	if (id == -1)
		id = 5;

	mutex_lock(audpp->lock);
	if (audpp->func[id]) {
		res = -EBUSY;
		goto out;
	}

	audpp->func[id] = func;
	audpp->private[id] = private;

	LOG(EV_ENABLE, 1);
	if (audpp->open_count++ == 0) {
		pr_info("audpp: enable\n");
		res = msm_adsp_get("AUDPPTASK", &audpp->mod, &adsp_ops, audpp);
		if (res < 0) {
			pr_err("audpp: cannot open AUDPPTASK\n");
			audpp->open_count = 0;
			audpp->func[id] = NULL;
			audpp->private[id] = NULL;
			goto out;
		}
		LOG(EV_ENABLE, 2);
		msm_adsp_enable(audpp->mod);
		audpp_dsp_config(1);
	} else {
		unsigned long flags;
		local_irq_save(flags);
		if (audpp->enabled)
			audpp_fake_event(audpp, id,
					 AUDPP_MSG_CFG_MSG, AUDPP_MSG_ENA_ENA);
		local_irq_restore(flags);
	}

	res = 0;
out:
	mutex_unlock(audpp->lock);
	return res;
}
EXPORT_SYMBOL(audpp_enable);

void audpp_disable(int id, void *private)
{
	struct audpp_state *audpp = &the_audpp_state;
	unsigned long flags;

	if (id < -1 || id > 4)
		return;

	if (id == -1)
		id = 5;

	mutex_lock(audpp->lock);
	LOG(EV_DISABLE, 1);
	if (!audpp->func[id])
		goto out;
	if (audpp->private[id] != private)
		goto out;

	local_irq_save(flags);
	audpp_fake_event(audpp, id, AUDPP_MSG_CFG_MSG, AUDPP_MSG_ENA_DIS);
	audpp->func[id] = NULL;
	audpp->private[id] = NULL;
	local_irq_restore(flags);

	if (--audpp->open_count == 0) {
		pr_info("audpp: disable\n");
		LOG(EV_DISABLE, 2);
		audpp_dsp_config(0);
		msm_adsp_disable(audpp->mod);
		msm_adsp_put(audpp->mod);
		audpp->mod = NULL;
	}
out:
	mutex_unlock(audpp->lock);
}
EXPORT_SYMBOL(audpp_disable);

#define BAD_ID(id) ((id < 0) || (id >= CH_COUNT))

void audpp_avsync(int id, unsigned rate)
{
	unsigned long flags;
	audpp_cmd_avsync cmd;

	if (BAD_ID(id))
		return;

	local_irq_save(flags);
	if (rate)
		the_audpp_state.avsync_mask |= (1 << id);
	else
		the_audpp_state.avsync_mask &= (~(1 << id));
	the_audpp_state.avsync[0] &= the_audpp_state.avsync_mask;
	local_irq_restore(flags);

	cmd.cmd_id = AUDPP_CMD_AVSYNC;
	cmd.object_number = id;
	cmd.interrupt_interval_lsw = rate;
	cmd.interrupt_interval_msw = rate >> 16;
	audpp_send_queue1(&cmd, sizeof(cmd));
}
EXPORT_SYMBOL(audpp_avsync);

unsigned audpp_avsync_sample_count(int id)
{
	uint16_t *avsync = the_audpp_state.avsync;
	unsigned val;
	unsigned long flags;
	unsigned mask;

	if (BAD_ID(id))
		return 0;

	mask = 1 << id;
	id = id * AUDPP_AVSYNC_INFO_SIZE + 2;
	local_irq_save(flags);
	if (avsync[0] & mask)
		val = (avsync[id] << 16) | avsync[id + 1];
	else
		val = 0;
	local_irq_restore(flags);

	return val;
}
EXPORT_SYMBOL(audpp_avsync_sample_count);

unsigned audpp_avsync_byte_count(int id)
{
	uint16_t *avsync = the_audpp_state.avsync;
	unsigned val;
	unsigned long flags;
	unsigned mask;

	if (BAD_ID(id))
		return 0;

	mask = 1 << id;
	id = id * AUDPP_AVSYNC_INFO_SIZE + 5;
	local_irq_save(flags);
	if (avsync[0] & mask)
		val = (avsync[id] << 16) | avsync[id + 1];
	else
		val = 0;
	local_irq_restore(flags);

	return val;
}
EXPORT_SYMBOL(audpp_avsync_byte_count);

#define AUDPP_CMD_CFG_OBJ_UPDATE 0x8000
#define AUDPP_CMD_VOLUME_PAN 0

int audpp_set_volume_and_pan(unsigned id, unsigned volume, int pan)
{
	/* cmd, obj_cfg[7], cmd_type, volume, pan */
	uint16_t cmd[11];

	if (id > 6)
		return -EINVAL;

	memset(cmd, 0, sizeof(cmd));
	cmd[0] = AUDPP_CMD_CFG_OBJECT_PARAMS;
	cmd[1 + id] = AUDPP_CMD_CFG_OBJ_UPDATE;
	cmd[8] = AUDPP_CMD_VOLUME_PAN;
	cmd[9] = volume;
	cmd[10] = pan;

	return audpp_send_queue3(cmd, sizeof(cmd));
}
EXPORT_SYMBOL(audpp_set_volume_and_pan);

int audpp_pause(unsigned id, int pause)
{
	/* pause 1 = pause 0 = resume */
	u16 pause_cmd[AUDPP_CMD_DEC_CTRL_LEN / sizeof(unsigned short)];

	if (id >= CH_COUNT)
		return -EINVAL;

	memset(pause_cmd, 0, sizeof(pause_cmd));

	pause_cmd[0] = AUDPP_CMD_DEC_CTRL;
	if (pause == 1)
		pause_cmd[1 + id] = AUDPP_CMD_UPDATE_V | AUDPP_CMD_PAUSE_V;
	else if (pause == 0)
		pause_cmd[1 + id] = AUDPP_CMD_UPDATE_V | AUDPP_CMD_RESUME_V;
	else
		return -EINVAL;

	return audpp_send_queue1(pause_cmd, sizeof(pause_cmd));
}
EXPORT_SYMBOL(audpp_pause);

int audpp_flush(unsigned id)
{
	u16 flush_cmd[AUDPP_CMD_DEC_CTRL_LEN / sizeof(unsigned short)];

	if (id >= CH_COUNT)
		return -EINVAL;

	memset(flush_cmd, 0, sizeof(flush_cmd));

	flush_cmd[0] = AUDPP_CMD_DEC_CTRL;
	flush_cmd[1 + id] = AUDPP_CMD_UPDATE_V | AUDPP_CMD_FLUSH_V;

	return audpp_send_queue1(flush_cmd, sizeof(flush_cmd));
}
EXPORT_SYMBOL(audpp_flush);
Commit	Line	Data
caff4cae IM	1
	2	/* arch/arm/mach-msm/qdsp5/audpp.c
	3	*
	4	* common code to deal with the AUDPP dsp task (audio postproc)
	5	*
	6	* Copyright (C) 2008 Google, Inc.
	7	*
	8	* This software is licensed under the terms of the GNU General Public
	9	* License version 2, as published by the Free Software Foundation, and
	10	* may be copied, distributed, and modified under those terms.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	*/
	18
	19	#include <linux/kernel.h>
	20	#include <linux/module.h>
	21	#include <linux/wait.h>
	22	#include <linux/delay.h>
	23
	24	#include <asm/atomic.h>
	25	#include <asm/ioctls.h>
	26	#include <mach/msm_adsp.h>
	27
	28	#include "audmgr.h"
	29
	30	#include <mach/qdsp5/qdsp5audppcmdi.h>
	31	#include <mach/qdsp5/qdsp5audppmsg.h>
	32
	33	/* for queue ids - should be relative to module number*/
	34	#include "adsp.h"
	35
	36	#include "evlog.h"
	37
	38
	39	enum {
	40	EV_NULL,
	41	EV_ENABLE,
	42	EV_DISABLE,
	43	EV_EVENT,
	44	EV_DATA,
	45	};
	46
	47	static const char *dsp_log_strings[] = {
	48	"NULL",
	49	"ENABLE",
	50	"DISABLE",
	51	"EVENT",
	52	"DATA",
	53	};
	54
	55	DECLARE_LOG(dsp_log, 64, dsp_log_strings);
	56
	57	static int __init _dsp_log_init(void)
	58	{
	59	return ev_log_init(&dsp_log);
	60	}
	61	module_init(_dsp_log_init);
	62	#define LOG(id,arg) ev_log_write(&dsp_log, id, arg)
	63
	64	static DEFINE_MUTEX(audpp_lock);
65
66	#define CH_COUNT 5
67	#define AUDPP_CLNT_MAX_COUNT 6
68	#define AUDPP_AVSYNC_INFO_SIZE 7
69
70	struct audpp_state {
71	struct msm_adsp_module *mod;
72	audpp_event_func func[AUDPP_CLNT_MAX_COUNT];
73	void *private[AUDPP_CLNT_MAX_COUNT];
74	struct mutex *lock;
75	unsigned open_count;
76	unsigned enabled;
77
78	/* which channels are actually enabled */
79	unsigned avsync_mask;
80
81	/* flags, 48 bits sample/bytes counter per channel */
82	uint16_t avsync[CH_COUNT * AUDPP_CLNT_MAX_COUNT + 1];
83	};
84
85	struct audpp_state the_audpp_state = {
86	.lock = &audpp_lock,
87	};
88
89	int audpp_send_queue1(void *cmd, unsigned len)
90	{
91	return msm_adsp_write(the_audpp_state.mod,
92	QDSP_uPAudPPCmd1Queue, cmd, len);
93	}
94	EXPORT_SYMBOL(audpp_send_queue1);
95
96	int audpp_send_queue2(void *cmd, unsigned len)
97	{
98	return msm_adsp_write(the_audpp_state.mod,
99	QDSP_uPAudPPCmd2Queue, cmd, len);
100	}
101	EXPORT_SYMBOL(audpp_send_queue2);
102
103	int audpp_send_queue3(void *cmd, unsigned len)
104	{
105	return msm_adsp_write(the_audpp_state.mod,
106	QDSP_uPAudPPCmd3Queue, cmd, len);
107	}
108	EXPORT_SYMBOL(audpp_send_queue3);
109
110	static int audpp_dsp_config(int enable)
111	{
112	audpp_cmd_cfg cmd;
113
114	cmd.cmd_id = AUDPP_CMD_CFG;
115	cmd.cfg = enable ? AUDPP_CMD_CFG_ENABLE : AUDPP_CMD_CFG_SLEEP;
116
117	return audpp_send_queue1(&cmd, sizeof(cmd));
118	}
119
120	static void audpp_broadcast(struct audpp_state *audpp, unsigned id,
121	uint16_t *msg)
122	{
123	unsigned n;
124	for (n = 0; n < AUDPP_CLNT_MAX_COUNT; n++) {
125	if (audpp->func[n])
126	audpp->func[n] (audpp->private[n], id, msg);
127	}
128	}
129
130	static void audpp_notify_clnt(struct audpp_state *audpp, unsigned clnt_id,
131	unsigned id, uint16_t *msg)
132	{
133	if (clnt_id < AUDPP_CLNT_MAX_COUNT && audpp->func[clnt_id])
134	audpp->func[clnt_id] (audpp->private[clnt_id], id, msg);
135	}
136
137	static void audpp_dsp_event(void *data, unsigned id, size_t len,
138	void (getevent)(void ptr, size_t len))
139	{
140	struct audpp_state *audpp = data;
141	uint16_t msg[8];
142
143	if (id == AUDPP_MSG_AVSYNC_MSG) {
144	getevent(audpp->avsync, sizeof(audpp->avsync));
145
146	/* mask off any channels we're not watching to avoid
147	* cases where we might get one last update after
148	* disabling avsync and end up in an odd state when
149	* we next read...
150	*/
151	audpp->avsync[0] &= audpp->avsync_mask;
152	return;
153	}
154
155	getevent(msg, sizeof(msg));
156
157	LOG(EV_EVENT, (id << 16) \| msg[0]);
158	LOG(EV_DATA, (msg[1] << 16) \| msg[2]);
159
160	switch (id) {
161	case AUDPP_MSG_STATUS_MSG:{
162	unsigned cid = msg[0];
163	pr_info("audpp: status %d %d %d\n", cid, msg[1],
164	msg[2]);
165	if ((cid < 5) && audpp->func[cid])
166	audpp->func[cid] (audpp->private[cid], id, msg);
167	break;
168	}
169	case AUDPP_MSG_HOST_PCM_INTF_MSG:
170	if (audpp->func[5])
171	audpp->func[5] (audpp->private[5], id, msg);
172	break;
173	case AUDPP_MSG_PCMDMAMISSED:
174	pr_err("audpp: DMA missed obj=%x\n", msg[0]);
175	break;
176	case AUDPP_MSG_CFG_MSG:
177	if (msg[0] == AUDPP_MSG_ENA_ENA) {
178	pr_info("audpp: ENABLE\n");
179	audpp->enabled = 1;
180	audpp_broadcast(audpp, id, msg);
181	} else if (msg[0] == AUDPP_MSG_ENA_DIS) {
182	pr_info("audpp: DISABLE\n");
183	audpp->enabled = 0;
184	audpp_broadcast(audpp, id, msg);
185	} else {
186	pr_err("audpp: invalid config msg %d\n", msg[0]);
187	}
188	break;
189	case AUDPP_MSG_ROUTING_ACK:
190	audpp_broadcast(audpp, id, msg);
191	break;
192	case AUDPP_MSG_FLUSH_ACK:
193	audpp_notify_clnt(audpp, msg[0], id, msg);
194	break;
195	default:
196	pr_info("audpp: unhandled msg id %x\n", id);
197	}
198	}
199
200	static struct msm_adsp_ops adsp_ops = {
201	.event = audpp_dsp_event,
202	};
203
204	static void audpp_fake_event(struct audpp_state *audpp, int id,
205	unsigned event, unsigned arg)
206	{
207	uint16_t msg[1];
208	msg[0] = arg;
209	audpp->func[id] (audpp->private[id], event, msg);
210	}
211
212	int audpp_enable(int id, audpp_event_func func, void *private)
213	{
214	struct audpp_state *audpp = &the_audpp_state;
215	int res = 0;
216
217	if (id < -1 \|\| id > 4)
218	return -EINVAL;
219
220	if (id == -1)
221	id = 5;
222
223	mutex_lock(audpp->lock);
224	if (audpp->func[id]) {
225	res = -EBUSY;
226	goto out;
227	}
228
229	audpp->func[id] = func;
230	audpp->private[id] = private;
231
232	LOG(EV_ENABLE, 1);
233	if (audpp->open_count++ == 0) {
234	pr_info("audpp: enable\n");
235	res = msm_adsp_get("AUDPPTASK", &audpp->mod, &adsp_ops, audpp);
236	if (res < 0) {
237	pr_err("audpp: cannot open AUDPPTASK\n");
238	audpp->open_count = 0;
239	audpp->func[id] = NULL;
240	audpp->private[id] = NULL;
241	goto out;
242	}
243	LOG(EV_ENABLE, 2);
244	msm_adsp_enable(audpp->mod);
245	audpp_dsp_config(1);
246	} else {
247	unsigned long flags;
248	local_irq_save(flags);
249	if (audpp->enabled)
250	audpp_fake_event(audpp, id,
251	AUDPP_MSG_CFG_MSG, AUDPP_MSG_ENA_ENA);
252	local_irq_restore(flags);
253	}
254
255	res = 0;
256	out:
257	mutex_unlock(audpp->lock);
258	return res;
259	}
260	EXPORT_SYMBOL(audpp_enable);
261
262	void audpp_disable(int id, void *private)
263	{
264	struct audpp_state *audpp = &the_audpp_state;
265	unsigned long flags;
266
267	if (id < -1 \|\| id > 4)
268	return;
269
270	if (id == -1)
271	id = 5;
272
273	mutex_lock(audpp->lock);
274	LOG(EV_DISABLE, 1);
275	if (!audpp->func[id])
276	goto out;
277	if (audpp->private[id] != private)
278	goto out;
279
280	local_irq_save(flags);
281	audpp_fake_event(audpp, id, AUDPP_MSG_CFG_MSG, AUDPP_MSG_ENA_DIS);
282	audpp->func[id] = NULL;
283	audpp->private[id] = NULL;
284	local_irq_restore(flags);
285
286	if (--audpp->open_count == 0) {
287	pr_info("audpp: disable\n");
288	LOG(EV_DISABLE, 2);
289	audpp_dsp_config(0);
290	msm_adsp_disable(audpp->mod);
291	msm_adsp_put(audpp->mod);
292	audpp->mod = NULL;
293	}
294	out:
295	mutex_unlock(audpp->lock);
296	}
297	EXPORT_SYMBOL(audpp_disable);
298
299	#define BAD_ID(id) ((id < 0) \|\| (id >= CH_COUNT))
300
301	void audpp_avsync(int id, unsigned rate)
302	{
303	unsigned long flags;
304	audpp_cmd_avsync cmd;
305
306	if (BAD_ID(id))
307	return;
308
309	local_irq_save(flags);
310	if (rate)
311	the_audpp_state.avsync_mask \|= (1 << id);
312	else
313	the_audpp_state.avsync_mask &= (~(1 << id));
314	the_audpp_state.avsync[0] &= the_audpp_state.avsync_mask;
315	local_irq_restore(flags);
316
317	cmd.cmd_id = AUDPP_CMD_AVSYNC;
318	cmd.object_number = id;
319	cmd.interrupt_interval_lsw = rate;
320	cmd.interrupt_interval_msw = rate >> 16;
321	audpp_send_queue1(&cmd, sizeof(cmd));
322	}
323	EXPORT_SYMBOL(audpp_avsync);
324
325	unsigned audpp_avsync_sample_count(int id)
326	{
327	uint16_t *avsync = the_audpp_state.avsync;
328	unsigned val;
329	unsigned long flags;
330	unsigned mask;
331
332	if (BAD_ID(id))
333	return 0;
334
335	mask = 1 << id;
336	id = id * AUDPP_AVSYNC_INFO_SIZE + 2;
337	local_irq_save(flags);
338	if (avsync[0] & mask)
339	val = (avsync[id] << 16) \| avsync[id + 1];
340	else
341	val = 0;
342	local_irq_restore(flags);
343
344	return val;
345	}
346	EXPORT_SYMBOL(audpp_avsync_sample_count);
347
348	unsigned audpp_avsync_byte_count(int id)
349	{
350	uint16_t *avsync = the_audpp_state.avsync;
351	unsigned val;
352	unsigned long flags;
353	unsigned mask;
354
355	if (BAD_ID(id))
356	return 0;
357
358	mask = 1 << id;
359	id = id * AUDPP_AVSYNC_INFO_SIZE + 5;
360	local_irq_save(flags);
361	if (avsync[0] & mask)
362	val = (avsync[id] << 16) \| avsync[id + 1];
363	else
364	val = 0;
365	local_irq_restore(flags);
366
367	return val;
368	}
369	EXPORT_SYMBOL(audpp_avsync_byte_count);
370
371	#define AUDPP_CMD_CFG_OBJ_UPDATE 0x8000
372	#define AUDPP_CMD_VOLUME_PAN 0
373
374	int audpp_set_volume_and_pan(unsigned id, unsigned volume, int pan)
375	{
376	/* cmd, obj_cfg[7], cmd_type, volume, pan */
377	uint16_t cmd[11];
378
379	if (id > 6)
380	return -EINVAL;
381
382	memset(cmd, 0, sizeof(cmd));
383	cmd[0] = AUDPP_CMD_CFG_OBJECT_PARAMS;
384	cmd[1 + id] = AUDPP_CMD_CFG_OBJ_UPDATE;
385	cmd[8] = AUDPP_CMD_VOLUME_PAN;
386	cmd[9] = volume;
387	cmd[10] = pan;
388
389	return audpp_send_queue3(cmd, sizeof(cmd));
390	}
391	EXPORT_SYMBOL(audpp_set_volume_and_pan);
392
393	int audpp_pause(unsigned id, int pause)
394	{
395	/* pause 1 = pause 0 = resume */
396	u16 pause_cmd[AUDPP_CMD_DEC_CTRL_LEN / sizeof(unsigned short)];
397
398	if (id >= CH_COUNT)
399	return -EINVAL;
400
401	memset(pause_cmd, 0, sizeof(pause_cmd));
402
403	pause_cmd[0] = AUDPP_CMD_DEC_CTRL;
404	if (pause == 1)
405	pause_cmd[1 + id] = AUDPP_CMD_UPDATE_V \| AUDPP_CMD_PAUSE_V;
406	else if (pause == 0)
407	pause_cmd[1 + id] = AUDPP_CMD_UPDATE_V \| AUDPP_CMD_RESUME_V;
408	else
409	return -EINVAL;
410
411	return audpp_send_queue1(pause_cmd, sizeof(pause_cmd));
412	}
413	EXPORT_SYMBOL(audpp_pause);
414
415	int audpp_flush(unsigned id)
416	{
417	u16 flush_cmd[AUDPP_CMD_DEC_CTRL_LEN / sizeof(unsigned short)];
418
419	if (id >= CH_COUNT)
420	return -EINVAL;
421
422	memset(flush_cmd, 0, sizeof(flush_cmd));
423
424	flush_cmd[0] = AUDPP_CMD_DEC_CTRL;
425	flush_cmd[1 + id] = AUDPP_CMD_UPDATE_V \| AUDPP_CMD_FLUSH_V;
426
427	return audpp_send_queue1(flush_cmd, sizeof(flush_cmd));
428	}
429	EXPORT_SYMBOL(audpp_flush);