[mirror_ubuntu-bionic-kernel.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 "ivtv-yuv.h"
#include "ivtv-ioctl.h"
#include "ivtv-cards.h"
#include <linux/firmware.h>
#include <media/saa7127.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 		600

#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->pdev->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++;
		}
		IVTV_INFO("Loaded %s firmware (%zd bytes)\n", fn, fw->size);
		release_firmware(fw);
		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_msleep_timeout(10, 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_msleep_timeout(10, 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\n", IVTV_SDRAM_SLEEPTIME);
	ivtv_msleep_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 preceded 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_msleep_timeout(100, 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_msleep_timeout(100, 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;
	} else {
		/* Firmware okay, so check yuv output filter table */
		ivtv_yuv_filter_check(itv);
	}
	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->cxhdl.width;	/* YUV source width */
	data[2] = itv->cxhdl.height;
	data[3] = itv->cxhdl.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, 2, 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_msleep_timeout(100, 0);
	}
	ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 4, 0, 0, 0, 1);
}

/* Try to restart the card & restore previous settings */
int ivtv_firmware_restart(struct ivtv *itv)
{
	int rc = 0;
	v4l2_std_id std;
	struct ivtv_open_id fh;
	fh.itv = itv;

	if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
		/* Display test image during restart */
		ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
		    SAA7127_INPUT_TYPE_TEST_IMAGE,
		    itv->card->video_outputs[itv->active_output].video_output,
		    0);

	mutex_lock(&itv->udma.lock);

	rc = ivtv_firmware_init(itv);
	if (rc) {
		mutex_unlock(&itv->udma.lock);
		return rc;
	}

	/* Allow settings to reload */
	ivtv_mailbox_cache_invalidate(itv);

	/* Restore video standard */
	std = itv->std;
	itv->std = 0;
	ivtv_s_std(NULL, &fh, &std);

	if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
		ivtv_init_mpeg_decoder(itv);

		/* Restore framebuffer if active */
		if (itv->ivtvfb_restore)
			itv->ivtvfb_restore(itv);

		/* Restore alpha settings */
		ivtv_set_osd_alpha(itv);

		/* Restore normal output */
		ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
		    SAA7127_INPUT_TYPE_NORMAL,
		    itv->card->video_outputs[itv->active_output].video_output,
		    0);
	}

	mutex_unlock(&itv->udma.lock);
	return rc;
}

/* Check firmware running state. The checks fall through
   allowing multiple failures to be logged. */
int ivtv_firmware_check(struct ivtv *itv, char *where)
{
	int res = 0;

	/* Check encoder is still running */
	if (ivtv_vapi(itv, CX2341X_ENC_PING_FW, 0) < 0) {
		IVTV_WARN("Encoder has died : %s\n", where);
		res = -1;
	}

	/* Also check audio. Only check if not in use & encoder is okay */
	if (!res && !atomic_read(&itv->capturing) &&
	    (!atomic_read(&itv->decoding) ||
	     (atomic_read(&itv->decoding) < 2 && test_bit(IVTV_F_I_DEC_YUV,
							     &itv->i_flags)))) {

		if (ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12) < 0) {
			IVTV_WARN("Audio has died (Encoder OK) : %s\n", where);
			res = -2;
		}
	}

	if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
		/* Second audio check. Skip if audio already failed */
		if (res != -2 && read_dec(0x100) != read_dec(0x104)) {
			/* Wait & try again to be certain. */
			ivtv_msleep_timeout(14, 0);
			if (read_dec(0x100) != read_dec(0x104)) {
				IVTV_WARN("Audio has died (Decoder) : %s\n",
					  where);
				res = -1;
			}
		}

		/* Check decoder is still running */
		if (ivtv_vapi(itv, CX2341X_DEC_PING_FW, 0) < 0) {
			IVTV_WARN("Decoder has died : %s\n", where);
			res = -1;
		}
	}

	/* If something failed & currently idle, try to reload */
	if (res && !atomic_read(&itv->capturing) &&
						!atomic_read(&itv->decoding)) {
		IVTV_INFO("Detected in %s that firmware had failed - "
			  "Reloading\n", where);
		res = ivtv_firmware_restart(itv);
		/*
		 * Even if restarted ok, still signal a problem had occurred.
		 * The caller can come through this function again to check
		 * if things are really ok after the restart.
		 */
		if (!res) {
			IVTV_INFO("Firmware restart okay\n");
			res = -EAGAIN;
		} else {
			IVTV_INFO("Firmware restart failed\n");
		}
	} else if (res) {
		res = -EIO;
	}

	return res;
}
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"
a54d1dea	25	#include "ivtv-yuv.h"
215659d1 IA	26	#include "ivtv-ioctl.h"
215659d1 IA	27	#include "ivtv-cards.h"
1a0adaf3	28	#include <linux/firmware.h>
215659d1	29	#include <media/saa7127.h>
1a0adaf3 HV	30
	31	#define IVTV_MASK_SPU_ENABLE 0xFFFFFFFE
	32	#define IVTV_MASK_VPU_ENABLE15 0xFFFFFFF6
	33	#define IVTV_MASK_VPU_ENABLE16 0xFFFFFFFB
	34	#define IVTV_CMD_VDM_STOP 0x00000000
	35	#define IVTV_CMD_AO_STOP 0x00000005
	36	#define IVTV_CMD_APU_PING 0x00000000
	37	#define IVTV_CMD_VPU_STOP15 0xFFFFFFFE
	38	#define IVTV_CMD_VPU_STOP16 0xFFFFFFEE
	39	#define IVTV_CMD_HW_BLOCKS_RST 0xFFFFFFFF
	40	#define IVTV_CMD_SPU_STOP 0x00000001
	41	#define IVTV_CMD_SDRAM_PRECHARGE_INIT 0x0000001A
	42	#define IVTV_CMD_SDRAM_REFRESH_INIT 0x80000640
201700d3	43	#define IVTV_SDRAM_SLEEPTIME 600
1a0adaf3 HV	44
	45	#define IVTV_DECODE_INIT_MPEG_FILENAME "v4l-cx2341x-init.mpg"
	46	#define IVTV_DECODE_INIT_MPEG_SIZE (152*1024)
	47
	48	/* Encoder/decoder firmware sizes */
	49	#define IVTV_FW_ENC_SIZE (376836)
	50	#define IVTV_FW_DEC_SIZE (256*1024)
	51
	52	static int load_fw_direct(const char fn, volatile u8 __iomem mem, struct ivtv *itv, long size)
	53	{
	54	const struct firmware *fw = NULL;
	55	int retries = 3;
	56
	57	retry:
8ac05ae3	58	if (retries && request_firmware(&fw, fn, &itv->pdev->dev) == 0) {
1a0adaf3 HV	59	int i;
	60	volatile u32 __iomem dst = (volatile u32 __iomem )mem;
	61	const u32 src = (const u32 )fw->data;
	62
a957641b	63	if (fw->size != size) {
1a0adaf3 HV	64	/* Due to race conditions in firmware loading (esp. with udev <0.95)
	65	the wrong file was sometimes loaded. So we check filesizes to
	66	see if at least the right-sized file was loaded. If not, then we
	67	retry. */
ae38d93b	68	IVTV_INFO("Retry: file loaded was not %s (expected size %ld, got %zd)\n", fn, size, fw->size);
1a0adaf3 HV	69	release_firmware(fw);
	70	retries--;
	71	goto retry;
	72	}
	73	for (i = 0; i < fw->size; i += 4) {
	74	/* no need for endianness conversion on the ppc */
	75	__raw_writel(*src, dst);
	76	dst++;
	77	src++;
	78	}
ae38d93b	79	IVTV_INFO("Loaded %s firmware (%zd bytes)\n", fn, fw->size);
be9a5c7d	80	release_firmware(fw);
1a0adaf3 HV	81	return size;
1a0adaf3 HV	82	}
ae38d93b HV	83	IVTV_ERR("Unable to open firmware %s (must be %ld bytes)\n", fn, size);
ae38d93b HV	84	IVTV_ERR("Did you put the firmware in the hotplug firmware directory?\n");
1a0adaf3 HV	85	return -ENOMEM;
	86	}
	87
	88	void ivtv_halt_firmware(struct ivtv *itv)
	89	{
	90	IVTV_DEBUG_INFO("Preparing for firmware halt.\n");
	91	if (itv->has_cx23415 && itv->dec_mbox.mbox)
	92	ivtv_vapi(itv, CX2341X_DEC_HALT_FW, 0);
	93	if (itv->enc_mbox.mbox)
	94	ivtv_vapi(itv, CX2341X_ENC_HALT_FW, 0);
	95
201700d3	96	ivtv_msleep_timeout(10, 0);
1a0adaf3 HV	97	itv->enc_mbox.mbox = itv->dec_mbox.mbox = NULL;
	98
	99	IVTV_DEBUG_INFO("Stopping VDM\n");
	100	write_reg(IVTV_CMD_VDM_STOP, IVTV_REG_VDM);
	101
	102	IVTV_DEBUG_INFO("Stopping AO\n");
	103	write_reg(IVTV_CMD_AO_STOP, IVTV_REG_AO);
	104
	105	IVTV_DEBUG_INFO("pinging (?) APU\n");
	106	write_reg(IVTV_CMD_APU_PING, IVTV_REG_APU);
	107
	108	IVTV_DEBUG_INFO("Stopping VPU\n");
	109	if (!itv->has_cx23415)
	110	write_reg(IVTV_CMD_VPU_STOP16, IVTV_REG_VPU);
	111	else
	112	write_reg(IVTV_CMD_VPU_STOP15, IVTV_REG_VPU);
	113
	114	IVTV_DEBUG_INFO("Resetting Hw Blocks\n");
	115	write_reg(IVTV_CMD_HW_BLOCKS_RST, IVTV_REG_HW_BLOCKS);
	116
	117	IVTV_DEBUG_INFO("Stopping SPU\n");
	118	write_reg(IVTV_CMD_SPU_STOP, IVTV_REG_SPU);
	119
201700d3	120	ivtv_msleep_timeout(10, 0);
1a0adaf3 HV	121
	122	IVTV_DEBUG_INFO("init Encoder SDRAM pre-charge\n");
	123	write_reg(IVTV_CMD_SDRAM_PRECHARGE_INIT, IVTV_REG_ENC_SDRAM_PRECHARGE);
	124
	125	IVTV_DEBUG_INFO("init Encoder SDRAM refresh to 1us\n");
	126	write_reg(IVTV_CMD_SDRAM_REFRESH_INIT, IVTV_REG_ENC_SDRAM_REFRESH);
	127
	128	if (itv->has_cx23415) {
	129	IVTV_DEBUG_INFO("init Decoder SDRAM pre-charge\n");
	130	write_reg(IVTV_CMD_SDRAM_PRECHARGE_INIT, IVTV_REG_DEC_SDRAM_PRECHARGE);
	131
	132	IVTV_DEBUG_INFO("init Decoder SDRAM refresh to 1us\n");
	133	write_reg(IVTV_CMD_SDRAM_REFRESH_INIT, IVTV_REG_DEC_SDRAM_REFRESH);
	134	}
	135
201700d3 MCC	136	IVTV_DEBUG_INFO("Sleeping for %dms\n", IVTV_SDRAM_SLEEPTIME);
201700d3 MCC	137	ivtv_msleep_timeout(IVTV_SDRAM_SLEEPTIME, 0);
1a0adaf3 HV	138	}
	139
	140	void ivtv_firmware_versions(struct ivtv *itv)
	141	{
	142	u32 data[CX2341X_MBOX_MAX_DATA];
	143
	144	/* Encoder */
	145	ivtv_vapi_result(itv, data, CX2341X_ENC_GET_VERSION, 0);
	146	IVTV_INFO("Encoder revision: 0x%08x\n", data[0]);
	147
	148	if (data[0] != 0x02060039)
	149	IVTV_WARN("Recommended firmware version is 0x02060039.\n");
	150
	151	if (itv->has_cx23415) {
	152	/* Decoder */
	153	ivtv_vapi_result(itv, data, CX2341X_DEC_GET_VERSION, 0);
	154	IVTV_INFO("Decoder revision: 0x%08x\n", data[0]);
	155	}
	156	}
	157
	158	static int ivtv_firmware_copy(struct ivtv *itv)
	159	{
	160	IVTV_DEBUG_INFO("Loading encoder image\n");
	161	if (load_fw_direct(CX2341X_FIRM_ENC_FILENAME,
	162	itv->enc_mem, itv, IVTV_FW_ENC_SIZE) != IVTV_FW_ENC_SIZE) {
	163	IVTV_DEBUG_WARN("failed loading encoder firmware\n");
	164	return -3;
	165	}
	166	if (!itv->has_cx23415)
	167	return 0;
	168
	169	IVTV_DEBUG_INFO("Loading decoder image\n");
	170	if (load_fw_direct(CX2341X_FIRM_DEC_FILENAME,
	171	itv->dec_mem, itv, IVTV_FW_DEC_SIZE) != IVTV_FW_DEC_SIZE) {
	172	IVTV_DEBUG_WARN("failed loading decoder firmware\n");
	173	return -1;
	174	}
	175	return 0;
	176	}
	177
	178	static volatile struct ivtv_mailbox __iomem ivtv_search_mailbox(const volatile u8 __iomem mem, u32 size)
	179	{
	180	int i;
	181
25985edc	182	/* mailbox is preceded by a 16 byte 'magic cookie' starting at a 256-byte
1a0adaf3 HV	183	address boundary */
	184	for (i = 0; i < size; i += 0x100) {
	185	if (readl(mem + i) == 0x12345678 &&
	186	readl(mem + i + 4) == 0x34567812 &&
	187	readl(mem + i + 8) == 0x56781234 &&
	188	readl(mem + i + 12) == 0x78123456) {
	189	return (volatile struct ivtv_mailbox __iomem *)(mem + i + 16);
	190	}
	191	}
	192	return NULL;
	193	}
	194
	195	int ivtv_firmware_init(struct ivtv *itv)
	196	{
	197	int err;
	198
	199	ivtv_halt_firmware(itv);
	200
	201	/* load firmware */
	202	err = ivtv_firmware_copy(itv);
	203	if (err) {
	204	IVTV_DEBUG_WARN("Error %d loading firmware\n", err);
	205	return err;
	206	}
	207
	208	/* start firmware */
	209	write_reg(read_reg(IVTV_REG_SPU) & IVTV_MASK_SPU_ENABLE, IVTV_REG_SPU);
201700d3	210	ivtv_msleep_timeout(100, 0);
1a0adaf3 HV	211	if (itv->has_cx23415)
	212	write_reg(read_reg(IVTV_REG_VPU) & IVTV_MASK_VPU_ENABLE15, IVTV_REG_VPU);
	213	else
	214	write_reg(read_reg(IVTV_REG_VPU) & IVTV_MASK_VPU_ENABLE16, IVTV_REG_VPU);
201700d3	215	ivtv_msleep_timeout(100, 0);
1a0adaf3 HV	216
	217	/* find mailboxes and ping firmware */
	218	itv->enc_mbox.mbox = ivtv_search_mailbox(itv->enc_mem, IVTV_ENCODER_SIZE);
	219	if (itv->enc_mbox.mbox == NULL)
	220	IVTV_ERR("Encoder mailbox not found\n");
	221	else if (ivtv_vapi(itv, CX2341X_ENC_PING_FW, 0)) {
	222	IVTV_ERR("Encoder firmware dead!\n");
	223	itv->enc_mbox.mbox = NULL;
	224	}
	225	if (itv->enc_mbox.mbox == NULL)
	226	return -ENODEV;
	227
	228	if (!itv->has_cx23415)
	229	return 0;
	230
	231	itv->dec_mbox.mbox = ivtv_search_mailbox(itv->dec_mem, IVTV_DECODER_SIZE);
a54d1dea	232	if (itv->dec_mbox.mbox == NULL) {
1a0adaf3	233	IVTV_ERR("Decoder mailbox not found\n");
a54d1dea	234	} else if (itv->has_cx23415 && ivtv_vapi(itv, CX2341X_DEC_PING_FW, 0)) {
1a0adaf3 HV	235	IVTV_ERR("Decoder firmware dead!\n");
1a0adaf3 HV	236	itv->dec_mbox.mbox = NULL;
a54d1dea IA	237	} else {
	238	/* Firmware okay, so check yuv output filter table */
	239	ivtv_yuv_filter_check(itv);
1a0adaf3 HV	240	}
	241	return itv->dec_mbox.mbox ? 0 : -ENODEV;
	242	}
	243
	244	void ivtv_init_mpeg_decoder(struct ivtv *itv)
	245	{
	246	u32 data[CX2341X_MBOX_MAX_DATA];
	247	long readbytes;
	248	volatile u8 __iomem *mem_offset;
	249
	250	data[0] = 0;
f7b80e69 HV	251	data[1] = itv->cxhdl.width; /* YUV source width */
	252	data[2] = itv->cxhdl.height;
	253	data[3] = itv->cxhdl.audio_properties; /* Audio settings to use,
1a0adaf3 HV	254	bitmap. see docs. */
	255	if (ivtv_api(itv, CX2341X_DEC_SET_DECODER_SOURCE, 4, data)) {
	256	IVTV_ERR("ivtv_init_mpeg_decoder failed to set decoder source\n");
	257	return;
	258	}
	259
	260	if (ivtv_vapi(itv, CX2341X_DEC_START_PLAYBACK, 2, 0, 1) != 0) {
	261	IVTV_ERR("ivtv_init_mpeg_decoder failed to start playback\n");
	262	return;
	263	}
587808d5	264	ivtv_api_get_data(&itv->dec_mbox, IVTV_MBOX_DMA, 2, data);
1a0adaf3 HV	265	mem_offset = itv->dec_mem + data[1];
	266
	267	if ((readbytes = load_fw_direct(IVTV_DECODE_INIT_MPEG_FILENAME,
	268	mem_offset, itv, IVTV_DECODE_INIT_MPEG_SIZE)) <= 0) {
	269	IVTV_DEBUG_WARN("failed to read mpeg decoder initialisation file %s\n",
	270	IVTV_DECODE_INIT_MPEG_FILENAME);
	271	} else {
	272	ivtv_vapi(itv, CX2341X_DEC_SCHED_DMA_FROM_HOST, 3, 0, readbytes, 0);
201700d3	273	ivtv_msleep_timeout(100, 0);
1a0adaf3 HV	274	}
	275	ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, 4, 0, 0, 0, 1);
	276	}
914610e8	277
215659d1 IA	278	/* Try to restart the card & restore previous settings */
	279	int ivtv_firmware_restart(struct ivtv *itv)
	280	{
	281	int rc = 0;
	282	v4l2_std_id std;
	283	struct ivtv_open_id fh;
	284	fh.itv = itv;
	285
	286	if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
	287	/* Display test image during restart */
	288	ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
	289	SAA7127_INPUT_TYPE_TEST_IMAGE,
	290	itv->card->video_outputs[itv->active_output].video_output,
	291	0);
	292
	293	mutex_lock(&itv->udma.lock);
	294
	295	rc = ivtv_firmware_init(itv);
	296	if (rc) {
	297	mutex_unlock(&itv->udma.lock);
	298	return rc;
	299	}
	300
	301	/* Allow settings to reload */
	302	ivtv_mailbox_cache_invalidate(itv);
	303
	304	/* Restore video standard */
	305	std = itv->std;
	306	itv->std = 0;
	307	ivtv_s_std(NULL, &fh, &std);
	308
	309	if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
	310	ivtv_init_mpeg_decoder(itv);
	311
	312	/* Restore framebuffer if active */
	313	if (itv->ivtvfb_restore)
	314	itv->ivtvfb_restore(itv);
	315
	316	/* Restore alpha settings */
	317	ivtv_set_osd_alpha(itv);
	318
	319	/* Restore normal output */
	320	ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
	321	SAA7127_INPUT_TYPE_NORMAL,
	322	itv->card->video_outputs[itv->active_output].video_output,
	323	0);
	324	}
	325
	326	mutex_unlock(&itv->udma.lock);
	327	return rc;
	328	}
	329
914610e8 IA	330	/* Check firmware running state. The checks fall through
	331	allowing multiple failures to be logged. */
	332	int ivtv_firmware_check(struct ivtv itv, char where)
	333	{
	334	int res = 0;
	335
	336	/* Check encoder is still running */
	337	if (ivtv_vapi(itv, CX2341X_ENC_PING_FW, 0) < 0) {
	338	IVTV_WARN("Encoder has died : %s\n", where);
	339	res = -1;
	340	}
	341
	342	/* Also check audio. Only check if not in use & encoder is okay */
	343	if (!res && !atomic_read(&itv->capturing) &&
	344	(!atomic_read(&itv->decoding) \|\|
	345	(atomic_read(&itv->decoding) < 2 && test_bit(IVTV_F_I_DEC_YUV,
	346	&itv->i_flags)))) {
	347
	348	if (ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12) < 0) {
	349	IVTV_WARN("Audio has died (Encoder OK) : %s\n", where);
	350	res = -2;
	351	}
	352	}
	353
	354	if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
	355	/* Second audio check. Skip if audio already failed */
	356	if (res != -2 && read_dec(0x100) != read_dec(0x104)) {
	357	/* Wait & try again to be certain. */
	358	ivtv_msleep_timeout(14, 0);
	359	if (read_dec(0x100) != read_dec(0x104)) {
	360	IVTV_WARN("Audio has died (Decoder) : %s\n",
	361	where);
	362	res = -1;
	363	}
	364	}
	365
	366	/* Check decoder is still running */
	367	if (ivtv_vapi(itv, CX2341X_DEC_PING_FW, 0) < 0) {
	368	IVTV_WARN("Decoder has died : %s\n", where);
	369	res = -1;
	370	}
	371	}
	372
215659d1 IA	373	/* If something failed & currently idle, try to reload */
	374	if (res && !atomic_read(&itv->capturing) &&
	375	!atomic_read(&itv->decoding)) {
	376	IVTV_INFO("Detected in %s that firmware had failed - "
	377	"Reloading\n", where);
	378	res = ivtv_firmware_restart(itv);
	379	/*
25985edc	380	* Even if restarted ok, still signal a problem had occurred.
215659d1 IA	381	* The caller can come through this function again to check
	382	* if things are really ok after the restart.
	383	*/
	384	if (!res) {
	385	IVTV_INFO("Firmware restart okay\n");
	386	res = -EAGAIN;
	387	} else {
	388	IVTV_INFO("Firmware restart failed\n");
	389	}
	390	} else if (res) {
	391	res = -EIO;
	392	}
	393
914610e8 IA	394	return res;
914610e8 IA	395	}