[linux-2.6-block.git] / drivers / media / video / ivtv / ivtv-firmware.c

/*
    ivtv firmware functions.
    Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
    Copyright (C) 2004  Chris Kennedy <c@groovy.org>
    Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    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
 */

#include "ivtv-driver.h"
#include "ivtv-mailbox.h"
#include "ivtv-firmware.h"
#include <linux/firmware.h>

#define IVTV_MASK_SPU_ENABLE 		0xFFFFFFFE
#define IVTV_MASK_VPU_ENABLE15 		0xFFFFFFF6
#define IVTV_MASK_VPU_ENABLE16 		0xFFFFFFFB
#define IVTV_CMD_VDM_STOP 		0x00000000
#define IVTV_CMD_AO_STOP 		0x00000005
#define IVTV_CMD_APU_PING 		0x00000000
#define IVTV_CMD_VPU_STOP15 		0xFFFFFFFE
#define IVTV_CMD_VPU_STOP16 		0xFFFFFFEE
#define IVTV_CMD_HW_BLOCKS_RST 		0xFFFFFFFF
#define IVTV_CMD_SPU_STOP 		0x00000001
#define IVTV_CMD_SDRAM_PRECHARGE_INIT 	0x0000001A
#define IVTV_CMD_SDRAM_REFRESH_INIT 	0x80000640
#define IVTV_SDRAM_SLEEPTIME 		(60 * HZ / 100)	/* 600 ms */

#define IVTV_DECODE_INIT_MPEG_FILENAME 	"v4l-cx2341x-init.mpg"
#define IVTV_DECODE_INIT_MPEG_SIZE 	(152*1024)

/* Encoder/decoder firmware sizes */
#define IVTV_FW_ENC_SIZE 		(376836)
#define IVTV_FW_DEC_SIZE 		(256*1024)

static int load_fw_direct(const char *fn, volatile u8 __iomem *mem, struct ivtv *itv, long size)
{
	const struct firmware *fw = NULL;
	int retries = 3;

retry:
	if (retries && request_firmware(&fw, fn, &itv->dev->dev) == 0) {
		int i;
		volatile u32 __iomem *dst = (volatile u32 __iomem *)mem;
		const u32 *src = (const u32 *)fw->data;

		if (fw->size != size) {
			/* Due to race conditions in firmware loading (esp. with udev <0.95)
			   the wrong file was sometimes loaded. So we check filesizes to
			   see if at least the right-sized file was loaded. If not, then we
			   retry. */
			IVTV_INFO("retry: file loaded was not %s (expected size %ld, got %zd)\n", fn, size, fw->size);
			release_firmware(fw);
			retries--;
			goto retry;
		}
		for (i = 0; i < fw->size; i += 4) {
			/* no need for endianness conversion on the ppc */
			__raw_writel(*src, dst);
			dst++;
			src++;
		}
		release_firmware(fw);
		IVTV_INFO("loaded %s firmware (%zd bytes)\n", fn, fw->size);
		return size;
	}
	IVTV_ERR("unable to open firmware %s (must be %ld bytes)\n", fn, size);
	IVTV_ERR("did you put the firmware in the hotplug firmware directory?\n");
	return -ENOMEM;
}

void ivtv_halt_firmware(struct ivtv *itv)
{
	IVTV_DEBUG_INFO("Preparing for firmware halt.\n");
	if (itv->has_cx23415 && itv->dec_mbox.mbox)
		ivtv_vapi(itv, CX2341X_DEC_HALT_FW, 0);
	if (itv->enc_mbox.mbox)
		ivtv_vapi(itv, CX2341X_ENC_HALT_FW, 0);

	ivtv_sleep_timeout(HZ / 100, 0);
	itv->enc_mbox.mbox = itv->dec_mbox.mbox = NULL;

	IVTV_DEBUG_INFO("Stopping VDM\n");
	write_reg(IVTV_CMD_VDM_STOP, IVTV_REG_VDM);

	IVTV_DEBUG_INFO("Stopping AO\n");
	write_reg(IVTV_CMD_AO_STOP, IVTV_REG_AO);

	IVTV_DEBUG_INFO("pinging (?) APU\n");
	write_reg(IVTV_CMD_APU_PING, IVTV_REG_APU);

	IVTV_DEBUG_INFO("Stopping VPU\n");
	if (!itv->has_cx23415)
		write_reg(IVTV_CMD_VPU_STOP16, IVTV_REG_VPU);
	else
		write_reg(IVTV_CMD_VPU_STOP15, IVTV_REG_VPU);

	IVTV_DEBUG_INFO("Resetting Hw Blocks\n");
	write_reg(IVTV_CMD_HW_BLOCKS_RST, IVTV_REG_HW_BLOCKS);

	IVTV_DEBUG_INFO("Stopping SPU\n");
	write_reg(IVTV_CMD_SPU_STOP, IVTV_REG_SPU);

	ivtv_sleep_timeout(HZ / 100, 0);

	IVTV_DEBUG_INFO("init Encoder SDRAM pre-charge\n");
	write_reg(IVTV_CMD_SDRAM_PRECHARGE_INIT, IVTV_REG_ENC_SDRAM_PRECHARGE);

	IVTV_DEBUG_INFO("init Encoder SDRAM refresh to 1us\n");
	write_reg(IVTV_CMD_SDRAM_REFRESH_INIT, IVTV_REG_ENC_SDRAM_REFRESH);

	if (itv->has_cx23415) {
		IVTV_DEBUG_INFO("init Decoder SDRAM pre-charge\n");
		write_reg(IVTV_CMD_SDRAM_PRECHARGE_INIT, IVTV_REG_DEC_SDRAM_PRECHARGE);

		IVTV_DEBUG_INFO("init Decoder SDRAM refresh to 1us\n");
		write_reg(IVTV_CMD_SDRAM_REFRESH_INIT, IVTV_REG_DEC_SDRAM_REFRESH);
	}

	IVTV_DEBUG_INFO("Sleeping for %dms (600 recommended)\n",
		   (int)(IVTV_SDRAM_SLEEPTIME * 1000 / HZ));
	ivtv_sleep_timeout(IVTV_SDRAM_SLEEPTIME, 0);
}

void ivtv_firmware_versions(struct ivtv *itv)
{
	u32 data[CX2341X_MBOX_MAX_DATA];

	/* Encoder */
	ivtv_vapi_result(itv, data, CX2341X_ENC_GET_VERSION, 0);
	IVTV_INFO("Encoder revision: 0x%08x\n", data[0]);

	if (data[0] != 0x02060039)
		IVTV_WARN("Recommended firmware version is 0x02060039.\n");

	if (itv->has_cx23415) {
		/* Decoder */
		ivtv_vapi_result(itv, data, CX2341X_DEC_GET_VERSION, 0);
		IVTV_INFO("Decoder revision: 0x%08x\n", data[0]);
	}
}

static int ivtv_firmware_copy(struct ivtv *itv)
{
	IVTV_DEBUG_INFO("Loading encoder image\n");
	if (load_fw_direct(CX2341X_FIRM_ENC_FILENAME,
		   itv->enc_mem, itv, IVTV_FW_ENC_SIZE) != IVTV_FW_ENC_SIZE) {
		IVTV_DEBUG_WARN("failed loading encoder firmware\n");
		return -3;
	}
	if (!itv->has_cx23415)
		return 0;

	IVTV_DEBUG_INFO("Loading decoder image\n");
	if (load_fw_direct(CX2341X_FIRM_DEC_FILENAME,
		   itv->dec_mem, itv, IVTV_FW_DEC_SIZE) != IVTV_FW_DEC_SIZE) {
		IVTV_DEBUG_WARN("failed loading decoder firmware\n");
		return -1;
	}
	return 0;
}

static volatile struct ivtv_mailbox __iomem *ivtv_search_mailbox(const volatile u8 __iomem *mem, u32 size)
{
	int i;

	/* mailbox is preceeded by a 16 byte 'magic cookie' starting at a 256-byte
	   address boundary */
	for (i = 0; i < size; i += 0x100) {
		if (readl(mem + i)      == 0x12345678 &&
		    readl(mem + i + 4)  == 0x34567812 &&
		    readl(mem + i + 8)  == 0x56781234 &&
		    readl(mem + i + 12) == 0x78123456) {
			return (volatile struct ivtv_mailbox __iomem *)(mem + i + 16);
		}
	}
	return NULL;
}

int ivtv_firmware_init(struct ivtv *itv)
{
	int err;

	ivtv_halt_firmware(itv);

	/* load firmware */
	err = ivtv_firmware_copy(itv);
	if (err) {
		IVTV_DEBUG_WARN("Error %d loading firmware\n", err);
		return err;
	}

	/* start firmware */
	write_reg(read_reg(IVTV_REG_SPU) & IVTV_MASK_SPU_ENABLE, IVTV_REG_SPU);
	ivtv_sleep_timeout(HZ / 10, 0);
	if (itv->has_cx23415)
		write_reg(read_reg(IVTV_REG_VPU) & IVTV_MASK_VPU_ENABLE15, IVTV_REG_VPU);
	else
		write_reg(read_reg(IVTV_REG_VPU) & IVTV_MASK_VPU_ENABLE16, IVTV_REG_VPU);
	ivtv_sleep_timeout(HZ / 10, 0);

	/* find mailboxes and ping firmware */
	itv->enc_mbox.mbox = ivtv_search_mailbox(itv->enc_mem, IVTV_ENCODER_SIZE);
	if (itv->enc_mbox.mbox == NULL)
		IVTV_ERR("Encoder mailbox not found\n");
	else if (ivtv_vapi(itv, CX2341X_ENC_PING_FW, 0)) {
		IVTV_ERR("Encoder firmware dead!\n");
		itv->enc_mbox.mbox = NULL;
	}
	if (itv->enc_mbox.mbox == NULL)
		return -ENODEV;

	if (!itv->has_cx23415)
		return 0;

	itv->dec_mbox.mbox = ivtv_search_mailbox(itv->dec_mem, IVTV_DECODER_SIZE);
	if (itv->dec_mbox.mbox == NULL)
		IVTV_ERR("Decoder mailbox not found\n");
	else if (itv->has_cx23415 && ivtv_vapi(itv, CX2341X_DEC_PING_FW, 0)) {
		IVTV_ERR("Decoder firmware dead!\n");
		itv->dec_mbox.mbox = NULL;
	}
	return itv->dec_mbox.mbox ? 0 : -ENODEV;
}

void ivtv_init_mpeg_decoder(struct ivtv *itv)
{
	u32 data[CX2341X_MBOX_MAX_DATA];
	long readbytes;
	volatile u8 __iomem *mem_offset;

	data[0] = 0;
	data[1] = itv->params.width;	/* YUV source width */
	data[2] = itv->params.height;
	data[3] = itv->params.audio_properties;	/* Audio settings to use,
							   bitmap. see docs. */
	if (ivtv_api(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, data)) {
		IVTV_ERR("ivtv_init_mpeg_decoder failed to set decoder source\n");
		return;
	}

	if (ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1) != 0) {
		IVTV_ERR("ivtv_init_mpeg_decoder failed to start playback\n");
		return;
	}
	ivtv_api_get_data(&itv->dec_mbox, IVTV_MBOX_DMA, data);
	mem_offset = itv->dec_mem + data[1];

	if ((readbytes = load_fw_direct(IVTV_DECODE_INIT_MPEG_FILENAME,
		mem_offset, itv, IVTV_DECODE_INIT_MPEG_SIZE)) <= 0) {
		IVTV_DEBUG_WARN("failed to read mpeg decoder initialisation file %s\n",
				IVTV_DECODE_INIT_MPEG_FILENAME);
	} else {
		ivtv_vapi(itv, CX2341X_DEC_SCHED_DMA_FROM_HOST, 3, 0, readbytes, 0);
		ivtv_sleep_timeout(HZ / 10, 0);
	}
	ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 4, 0, 0, 0, 1);
}
Commit	Line	Data
1a0adaf3 HV	1	/*
	2	ivtv firmware functions.
	3	Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
	4	Copyright (C) 2004 Chris Kennedy <c@groovy.org>
	5	Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
	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 as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	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	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*/
	21
	22	#include "ivtv-driver.h"
	23	#include "ivtv-mailbox.h"
	24	#include "ivtv-firmware.h"
	25	#include <linux/firmware.h>
	26
	27	#define IVTV_MASK_SPU_ENABLE 0xFFFFFFFE
	28	#define IVTV_MASK_VPU_ENABLE15 0xFFFFFFF6
	29	#define IVTV_MASK_VPU_ENABLE16 0xFFFFFFFB
	30	#define IVTV_CMD_VDM_STOP 0x00000000
	31	#define IVTV_CMD_AO_STOP 0x00000005
	32	#define IVTV_CMD_APU_PING 0x00000000
	33	#define IVTV_CMD_VPU_STOP15 0xFFFFFFFE
	34	#define IVTV_CMD_VPU_STOP16 0xFFFFFFEE
	35	#define IVTV_CMD_HW_BLOCKS_RST 0xFFFFFFFF
	36	#define IVTV_CMD_SPU_STOP 0x00000001
	37	#define IVTV_CMD_SDRAM_PRECHARGE_INIT 0x0000001A
	38	#define IVTV_CMD_SDRAM_REFRESH_INIT 0x80000640
	39	#define IVTV_SDRAM_SLEEPTIME (60 * HZ / 100) /* 600 ms */
	40
	41	#define IVTV_DECODE_INIT_MPEG_FILENAME "v4l-cx2341x-init.mpg"
	42	#define IVTV_DECODE_INIT_MPEG_SIZE (152*1024)
	43
	44	/* Encoder/decoder firmware sizes */
	45	#define IVTV_FW_ENC_SIZE (376836)
	46	#define IVTV_FW_DEC_SIZE (256*1024)
	47
	48	static int load_fw_direct(const char fn, volatile u8 __iomem mem, struct ivtv *itv, long size)
	49	{
	50	const struct firmware *fw = NULL;
	51	int retries = 3;
	52
	53	retry:
	54	if (retries && request_firmware(&fw, fn, &itv->dev->dev) == 0) {
	55	int i;
	56	volatile u32 __iomem dst = (volatile u32 __iomem )mem;
	57	const u32 src = (const u32 )fw->data;
	58
a957641b	59	if (fw->size != size) {
1a0adaf3 HV	60	/* Due to race conditions in firmware loading (esp. with udev <0.95)
	61	the wrong file was sometimes loaded. So we check filesizes to
	62	see if at least the right-sized file was loaded. If not, then we
	63	retry. */
	64	IVTV_INFO("retry: file loaded was not %s (expected size %ld, got %zd)\n", fn, size, fw->size);
	65	release_firmware(fw);
	66	retries--;
	67	goto retry;
	68	}
	69	for (i = 0; i < fw->size; i += 4) {
	70	/* no need for endianness conversion on the ppc */
	71	__raw_writel(*src, dst);
	72	dst++;
	73	src++;
	74	}
	75	release_firmware(fw);
	76	IVTV_INFO("loaded %s firmware (%zd bytes)\n", fn, fw->size);
	77	return size;
	78	}
	79	IVTV_ERR("unable to open firmware %s (must be %ld bytes)\n", fn, size);
	80	IVTV_ERR("did you put the firmware in the hotplug firmware directory?\n");
	81	return -ENOMEM;
	82	}
	83
	84	void ivtv_halt_firmware(struct ivtv *itv)
	85	{
	86	IVTV_DEBUG_INFO("Preparing for firmware halt.\n");
	87	if (itv->has_cx23415 && itv->dec_mbox.mbox)
	88	ivtv_vapi(itv, CX2341X_DEC_HALT_FW, 0);
	89	if (itv->enc_mbox.mbox)
	90	ivtv_vapi(itv, CX2341X_ENC_HALT_FW, 0);
	91
	92	ivtv_sleep_timeout(HZ / 100, 0);
	93	itv->enc_mbox.mbox = itv->dec_mbox.mbox = NULL;
	94
	95	IVTV_DEBUG_INFO("Stopping VDM\n");
	96	write_reg(IVTV_CMD_VDM_STOP, IVTV_REG_VDM);
	97
	98	IVTV_DEBUG_INFO("Stopping AO\n");
	99	write_reg(IVTV_CMD_AO_STOP, IVTV_REG_AO);
	100
	101	IVTV_DEBUG_INFO("pinging (?) APU\n");
	102	write_reg(IVTV_CMD_APU_PING, IVTV_REG_APU);
	103
	104	IVTV_DEBUG_INFO("Stopping VPU\n");
	105	if (!itv->has_cx23415)
	106	write_reg(IVTV_CMD_VPU_STOP16, IVTV_REG_VPU);
	107	else
	108	write_reg(IVTV_CMD_VPU_STOP15, IVTV_REG_VPU);
	109
	110	IVTV_DEBUG_INFO("Resetting Hw Blocks\n");
	111	write_reg(IVTV_CMD_HW_BLOCKS_RST, IVTV_REG_HW_BLOCKS);
	112
	113	IVTV_DEBUG_INFO("Stopping SPU\n");
	114	write_reg(IVTV_CMD_SPU_STOP, IVTV_REG_SPU);
	115
	116	ivtv_sleep_timeout(HZ / 100, 0);
	117
	118	IVTV_DEBUG_INFO("init Encoder SDRAM pre-charge\n");
	119	write_reg(IVTV_CMD_SDRAM_PRECHARGE_INIT, IVTV_REG_ENC_SDRAM_PRECHARGE);
	120
	121	IVTV_DEBUG_INFO("init Encoder SDRAM refresh to 1us\n");
	122	write_reg(IVTV_CMD_SDRAM_REFRESH_INIT, IVTV_REG_ENC_SDRAM_REFRESH);
	123
124	if (itv->has_cx23415) {
125	IVTV_DEBUG_INFO("init Decoder SDRAM pre-charge\n");
126	write_reg(IVTV_CMD_SDRAM_PRECHARGE_INIT, IVTV_REG_DEC_SDRAM_PRECHARGE);
127
128	IVTV_DEBUG_INFO("init Decoder SDRAM refresh to 1us\n");
129	write_reg(IVTV_CMD_SDRAM_REFRESH_INIT, IVTV_REG_DEC_SDRAM_REFRESH);
130	}
131
132	IVTV_DEBUG_INFO("Sleeping for %dms (600 recommended)\n",
133	(int)(IVTV_SDRAM_SLEEPTIME * 1000 / HZ));
134	ivtv_sleep_timeout(IVTV_SDRAM_SLEEPTIME, 0);
135	}
136
137	void ivtv_firmware_versions(struct ivtv *itv)
138	{
139	u32 data[CX2341X_MBOX_MAX_DATA];
140
141	/* Encoder */
142	ivtv_vapi_result(itv, data, CX2341X_ENC_GET_VERSION, 0);
143	IVTV_INFO("Encoder revision: 0x%08x\n", data[0]);
144
145	if (data[0] != 0x02060039)
146	IVTV_WARN("Recommended firmware version is 0x02060039.\n");
147
148	if (itv->has_cx23415) {
149	/* Decoder */
150	ivtv_vapi_result(itv, data, CX2341X_DEC_GET_VERSION, 0);
151	IVTV_INFO("Decoder revision: 0x%08x\n", data[0]);
152	}
153	}
154
155	static int ivtv_firmware_copy(struct ivtv *itv)
156	{
157	IVTV_DEBUG_INFO("Loading encoder image\n");
158	if (load_fw_direct(CX2341X_FIRM_ENC_FILENAME,
159	itv->enc_mem, itv, IVTV_FW_ENC_SIZE) != IVTV_FW_ENC_SIZE) {
160	IVTV_DEBUG_WARN("failed loading encoder firmware\n");
161	return -3;
162	}
163	if (!itv->has_cx23415)
164	return 0;
165
166	IVTV_DEBUG_INFO("Loading decoder image\n");
167	if (load_fw_direct(CX2341X_FIRM_DEC_FILENAME,
168	itv->dec_mem, itv, IVTV_FW_DEC_SIZE) != IVTV_FW_DEC_SIZE) {
169	IVTV_DEBUG_WARN("failed loading decoder firmware\n");
170	return -1;
171	}
172	return 0;
173	}
174
175	static volatile struct ivtv_mailbox __iomem ivtv_search_mailbox(const volatile u8 __iomem mem, u32 size)
176	{
177	int i;
178
179	/* mailbox is preceeded by a 16 byte 'magic cookie' starting at a 256-byte
180	address boundary */
181	for (i = 0; i < size; i += 0x100) {
182	if (readl(mem + i) == 0x12345678 &&
183	readl(mem + i + 4) == 0x34567812 &&
184	readl(mem + i + 8) == 0x56781234 &&
185	readl(mem + i + 12) == 0x78123456) {
186	return (volatile struct ivtv_mailbox __iomem *)(mem + i + 16);
187	}
188	}
189	return NULL;
190	}
191
192	int ivtv_firmware_init(struct ivtv *itv)
193	{
194	int err;
195
196	ivtv_halt_firmware(itv);
197
198	/* load firmware */
199	err = ivtv_firmware_copy(itv);
200	if (err) {
201	IVTV_DEBUG_WARN("Error %d loading firmware\n", err);
202	return err;
203	}
204
205	/* start firmware */
206	write_reg(read_reg(IVTV_REG_SPU) & IVTV_MASK_SPU_ENABLE, IVTV_REG_SPU);
207	ivtv_sleep_timeout(HZ / 10, 0);
208	if (itv->has_cx23415)
209	write_reg(read_reg(IVTV_REG_VPU) & IVTV_MASK_VPU_ENABLE15, IVTV_REG_VPU);
210	else
211	write_reg(read_reg(IVTV_REG_VPU) & IVTV_MASK_VPU_ENABLE16, IVTV_REG_VPU);
212	ivtv_sleep_timeout(HZ / 10, 0);
213
214	/* find mailboxes and ping firmware */
215	itv->enc_mbox.mbox = ivtv_search_mailbox(itv->enc_mem, IVTV_ENCODER_SIZE);
216	if (itv->enc_mbox.mbox == NULL)
217	IVTV_ERR("Encoder mailbox not found\n");
218	else if (ivtv_vapi(itv, CX2341X_ENC_PING_FW, 0)) {
219	IVTV_ERR("Encoder firmware dead!\n");
220	itv->enc_mbox.mbox = NULL;
221	}
222	if (itv->enc_mbox.mbox == NULL)
223	return -ENODEV;
224
225	if (!itv->has_cx23415)
226	return 0;
227
228	itv->dec_mbox.mbox = ivtv_search_mailbox(itv->dec_mem, IVTV_DECODER_SIZE);
229	if (itv->dec_mbox.mbox == NULL)
230	IVTV_ERR("Decoder mailbox not found\n");
231	else if (itv->has_cx23415 && ivtv_vapi(itv, CX2341X_DEC_PING_FW, 0)) {
232	IVTV_ERR("Decoder firmware dead!\n");
233	itv->dec_mbox.mbox = NULL;
234	}
235	return itv->dec_mbox.mbox ? 0 : -ENODEV;
236	}
237
238	void ivtv_init_mpeg_decoder(struct ivtv *itv)
239	{
240	u32 data[CX2341X_MBOX_MAX_DATA];
241	long readbytes;
242	volatile u8 __iomem *mem_offset;
243
244	data[0] = 0;
245	data[1] = itv->params.width; /* YUV source width */
246	data[2] = itv->params.height;
247	data[3] = itv->params.audio_properties; /* Audio settings to use,
248	bitmap. see docs. */
249	if (ivtv_api(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, data)) {
250	IVTV_ERR("ivtv_init_mpeg_decoder failed to set decoder source\n");
251	return;
252	}
253
254	if (ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1) != 0) {
255	IVTV_ERR("ivtv_init_mpeg_decoder failed to start playback\n");
256	return;
257	}
258	ivtv_api_get_data(&itv->dec_mbox, IVTV_MBOX_DMA, data);
259	mem_offset = itv->dec_mem + data[1];
260
261	if ((readbytes = load_fw_direct(IVTV_DECODE_INIT_MPEG_FILENAME,
262	mem_offset, itv, IVTV_DECODE_INIT_MPEG_SIZE)) <= 0) {
263	IVTV_DEBUG_WARN("failed to read mpeg decoder initialisation file %s\n",
264	IVTV_DECODE_INIT_MPEG_FILENAME);
265	} else {
266	ivtv_vapi(itv, CX2341X_DEC_SCHED_DMA_FROM_HOST, 3, 0, readbytes, 0);
267	ivtv_sleep_timeout(HZ / 10, 0);
268	}
269	ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 4, 0, 0, 0, 1);
270	}