[linux-block.git] / drivers / media / pci / ivtv / ivtv-mailbox.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
    mailbox 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>

 */

#include "ivtv-driver.h"
#include "ivtv-mailbox.h"

#include <stdarg.h>

/* Firmware mailbox flags*/
#define IVTV_MBOX_FIRMWARE_DONE 0x00000004
#define IVTV_MBOX_DRIVER_DONE   0x00000002
#define IVTV_MBOX_DRIVER_BUSY   0x00000001
#define IVTV_MBOX_FREE		0x00000000

/* Firmware mailbox standard timeout */
#define IVTV_API_STD_TIMEOUT	0x02000000

#define API_CACHE	 (1 << 0)	/* Allow the command to be stored in the cache */
#define API_RESULT	 (1 << 1)	/* Allow 1 second for this cmd to end */
#define API_FAST_RESULT	 (3 << 1)	/* Allow 0.1 second for this cmd to end */
#define API_DMA		 (1 << 3)	/* DMA mailbox, has special handling */
#define API_HIGH_VOL	 (1 << 5)	/* High volume command (i.e. called during encoding or decoding) */
#define API_NO_WAIT_MB	 (1 << 4)	/* Command may not wait for a free mailbox */
#define API_NO_WAIT_RES	 (1 << 5)	/* Command may not wait for the result */
#define API_NO_POLL	 (1 << 6)	/* Avoid pointless polling */

struct ivtv_api_info {
	int flags;		/* Flags, see above */
	const char *name;	/* The name of the command */
};

#define API_ENTRY(x, f) [x] = { (f), #x }

static const struct ivtv_api_info api_info[256] = {
	/* MPEG encoder API */
	API_ENTRY(CX2341X_ENC_PING_FW,			API_FAST_RESULT),
	API_ENTRY(CX2341X_ENC_START_CAPTURE,		API_RESULT | API_NO_POLL),
	API_ENTRY(CX2341X_ENC_STOP_CAPTURE,		API_RESULT),
	API_ENTRY(CX2341X_ENC_SET_AUDIO_ID,		API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_VIDEO_ID,		API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_PCR_ID,		API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_FRAME_RATE,		API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_FRAME_SIZE,		API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_BIT_RATE,		API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_GOP_PROPERTIES,	API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_ASPECT_RATIO,		API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_DNR_FILTER_MODE,	API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_DNR_FILTER_PROPS,	API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_CORING_LEVELS,	API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_SPATIAL_FILTER_TYPE,	API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_VBI_LINE,		API_RESULT),
	API_ENTRY(CX2341X_ENC_SET_STREAM_TYPE,		API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_OUTPUT_PORT,		API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_AUDIO_PROPERTIES,	API_CACHE),
	API_ENTRY(CX2341X_ENC_HALT_FW,			API_FAST_RESULT),
	API_ENTRY(CX2341X_ENC_GET_VERSION,		API_FAST_RESULT),
	API_ENTRY(CX2341X_ENC_SET_GOP_CLOSURE,		API_CACHE),
	API_ENTRY(CX2341X_ENC_GET_SEQ_END,		API_RESULT),
	API_ENTRY(CX2341X_ENC_SET_PGM_INDEX_INFO,	API_FAST_RESULT),
	API_ENTRY(CX2341X_ENC_SET_VBI_CONFIG,		API_RESULT),
	API_ENTRY(CX2341X_ENC_SET_DMA_BLOCK_SIZE,	API_CACHE),
	API_ENTRY(CX2341X_ENC_GET_PREV_DMA_INFO_MB_10,	API_FAST_RESULT),
	API_ENTRY(CX2341X_ENC_GET_PREV_DMA_INFO_MB_9,	API_FAST_RESULT),
	API_ENTRY(CX2341X_ENC_SCHED_DMA_TO_HOST,	API_DMA | API_HIGH_VOL),
	API_ENTRY(CX2341X_ENC_INITIALIZE_INPUT,		API_RESULT),
	API_ENTRY(CX2341X_ENC_SET_FRAME_DROP_RATE,	API_CACHE),
	API_ENTRY(CX2341X_ENC_PAUSE_ENCODER,		API_RESULT),
	API_ENTRY(CX2341X_ENC_REFRESH_INPUT,		API_NO_WAIT_MB | API_HIGH_VOL),
	API_ENTRY(CX2341X_ENC_SET_COPYRIGHT,		API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_EVENT_NOTIFICATION,	API_RESULT),
	API_ENTRY(CX2341X_ENC_SET_NUM_VSYNC_LINES,	API_CACHE),
	API_ENTRY(CX2341X_ENC_SET_PLACEHOLDER,		API_CACHE),
	API_ENTRY(CX2341X_ENC_MUTE_VIDEO,		API_RESULT),
	API_ENTRY(CX2341X_ENC_MUTE_AUDIO,		API_RESULT),
	API_ENTRY(CX2341X_ENC_SET_VERT_CROP_LINE,	API_FAST_RESULT),
	API_ENTRY(CX2341X_ENC_MISC,			API_FAST_RESULT),
	/* Obsolete PULLDOWN API command */
	API_ENTRY(0xb1,					API_CACHE),

	/* MPEG decoder API */
	API_ENTRY(CX2341X_DEC_PING_FW,			API_FAST_RESULT),
	API_ENTRY(CX2341X_DEC_START_PLAYBACK,		API_RESULT | API_NO_POLL),
	API_ENTRY(CX2341X_DEC_STOP_PLAYBACK,		API_RESULT),
	API_ENTRY(CX2341X_DEC_SET_PLAYBACK_SPEED,	API_RESULT),
	API_ENTRY(CX2341X_DEC_STEP_VIDEO,		API_RESULT),
	API_ENTRY(CX2341X_DEC_SET_DMA_BLOCK_SIZE,	API_CACHE),
	API_ENTRY(CX2341X_DEC_GET_XFER_INFO,		API_FAST_RESULT),
	API_ENTRY(CX2341X_DEC_GET_DMA_STATUS,		API_FAST_RESULT),
	API_ENTRY(CX2341X_DEC_SCHED_DMA_FROM_HOST,	API_DMA | API_HIGH_VOL),
	API_ENTRY(CX2341X_DEC_PAUSE_PLAYBACK,		API_RESULT),
	API_ENTRY(CX2341X_DEC_HALT_FW,			API_FAST_RESULT),
	API_ENTRY(CX2341X_DEC_SET_STANDARD,		API_CACHE),
	API_ENTRY(CX2341X_DEC_GET_VERSION,		API_FAST_RESULT),
	API_ENTRY(CX2341X_DEC_SET_STREAM_INPUT,		API_CACHE),
	API_ENTRY(CX2341X_DEC_GET_TIMING_INFO,		API_RESULT /*| API_NO_WAIT_RES*/),
	API_ENTRY(CX2341X_DEC_SET_AUDIO_MODE,		API_CACHE),
	API_ENTRY(CX2341X_DEC_SET_EVENT_NOTIFICATION,	API_RESULT),
	API_ENTRY(CX2341X_DEC_SET_DISPLAY_BUFFERS,	API_CACHE),
	API_ENTRY(CX2341X_DEC_EXTRACT_VBI,		API_RESULT),
	API_ENTRY(CX2341X_DEC_SET_DECODER_SOURCE,	API_FAST_RESULT),
	API_ENTRY(CX2341X_DEC_SET_PREBUFFERING,		API_CACHE),

	/* OSD API */
	API_ENTRY(CX2341X_OSD_GET_FRAMEBUFFER,		API_FAST_RESULT),
	API_ENTRY(CX2341X_OSD_GET_PIXEL_FORMAT,		API_FAST_RESULT),
	API_ENTRY(CX2341X_OSD_SET_PIXEL_FORMAT,		API_CACHE),
	API_ENTRY(CX2341X_OSD_GET_STATE,		API_FAST_RESULT),
	API_ENTRY(CX2341X_OSD_SET_STATE,		API_CACHE),
	API_ENTRY(CX2341X_OSD_GET_OSD_COORDS,		API_FAST_RESULT),
	API_ENTRY(CX2341X_OSD_SET_OSD_COORDS,		API_CACHE),
	API_ENTRY(CX2341X_OSD_GET_SCREEN_COORDS,	API_FAST_RESULT),
	API_ENTRY(CX2341X_OSD_SET_SCREEN_COORDS,	API_CACHE),
	API_ENTRY(CX2341X_OSD_GET_GLOBAL_ALPHA,		API_FAST_RESULT),
	API_ENTRY(CX2341X_OSD_SET_GLOBAL_ALPHA,		API_CACHE),
	API_ENTRY(CX2341X_OSD_SET_BLEND_COORDS,		API_CACHE),
	API_ENTRY(CX2341X_OSD_GET_FLICKER_STATE,	API_FAST_RESULT),
	API_ENTRY(CX2341X_OSD_SET_FLICKER_STATE,	API_CACHE),
	API_ENTRY(CX2341X_OSD_BLT_COPY,			API_RESULT),
	API_ENTRY(CX2341X_OSD_BLT_FILL,			API_RESULT),
	API_ENTRY(CX2341X_OSD_BLT_TEXT,			API_RESULT),
	API_ENTRY(CX2341X_OSD_SET_FRAMEBUFFER_WINDOW,	API_CACHE),
	API_ENTRY(CX2341X_OSD_SET_CHROMA_KEY,		API_CACHE),
	API_ENTRY(CX2341X_OSD_GET_ALPHA_CONTENT_INDEX,	API_FAST_RESULT),
	API_ENTRY(CX2341X_OSD_SET_ALPHA_CONTENT_INDEX,	API_CACHE)
};

static int try_mailbox(struct ivtv *itv, struct ivtv_mailbox_data *mbdata, int mb)
{
	u32 flags = readl(&mbdata->mbox[mb].flags);
	int is_free = flags == IVTV_MBOX_FREE || (flags & IVTV_MBOX_FIRMWARE_DONE);

	/* if the mailbox is free, then try to claim it */
	if (is_free && !test_and_set_bit(mb, &mbdata->busy)) {
		write_sync(IVTV_MBOX_DRIVER_BUSY, &mbdata->mbox[mb].flags);
		return 1;
	}
	return 0;
}

/* Try to find a free mailbox. Note mailbox 0 is reserved for DMA and so is not
   attempted here. */
static int get_mailbox(struct ivtv *itv, struct ivtv_mailbox_data *mbdata, int flags)
{
	unsigned long then = jiffies;
	int i, mb;
	int max_mbox = mbdata->max_mbox;
	int retries = 100;

	/* All slow commands use the same mailbox, serializing them and also
	   leaving the other mailbox free for simple fast commands. */
	if ((flags & API_FAST_RESULT) == API_RESULT)
		max_mbox = 1;

	/* find free non-DMA mailbox */
	for (i = 0; i < retries; i++) {
		for (mb = 1; mb <= max_mbox; mb++)
			if (try_mailbox(itv, mbdata, mb))
				return mb;

		/* Sleep before a retry, if not atomic */
		if (!(flags & API_NO_WAIT_MB)) {
			if (time_after(jiffies,
				       then + msecs_to_jiffies(10*retries)))
			       break;
			ivtv_msleep_timeout(10, 0);
		}
	}
	return -ENODEV;
}

static void write_mailbox(volatile struct ivtv_mailbox __iomem *mbox, int cmd, int args, u32 data[])
{
	int i;

	write_sync(cmd, &mbox->cmd);
	write_sync(IVTV_API_STD_TIMEOUT, &mbox->timeout);

	for (i = 0; i < CX2341X_MBOX_MAX_DATA; i++)
		write_sync(data[i], &mbox->data[i]);

	write_sync(IVTV_MBOX_DRIVER_DONE | IVTV_MBOX_DRIVER_BUSY, &mbox->flags);
}

static void clear_all_mailboxes(struct ivtv *itv, struct ivtv_mailbox_data *mbdata)
{
	int i;

	for (i = 0; i <= mbdata->max_mbox; i++) {
		IVTV_DEBUG_WARN("Clearing mailbox %d: cmd 0x%08x flags 0x%08x\n",
			i, readl(&mbdata->mbox[i].cmd), readl(&mbdata->mbox[i].flags));
		write_sync(0, &mbdata->mbox[i].flags);
		clear_bit(i, &mbdata->busy);
	}
}

static int ivtv_api_call(struct ivtv *itv, int cmd, int args, u32 data[])
{
	struct ivtv_mailbox_data *mbdata = (cmd >= 128) ? &itv->enc_mbox : &itv->dec_mbox;
	volatile struct ivtv_mailbox __iomem *mbox;
	int api_timeout = msecs_to_jiffies(1000);
	int flags, mb, i;
	unsigned long then;

	/* sanity checks */
	if (NULL == mbdata) {
		IVTV_ERR("No mailbox allocated\n");
		return -ENODEV;
	}
	if (args < 0 || args > CX2341X_MBOX_MAX_DATA ||
	    cmd < 0 || cmd > 255 || api_info[cmd].name == NULL) {
		IVTV_ERR("Invalid MB call: cmd = 0x%02x, args = %d\n", cmd, args);
		return -EINVAL;
	}

	if (api_info[cmd].flags & API_HIGH_VOL) {
	    IVTV_DEBUG_HI_MB("MB Call: %s\n", api_info[cmd].name);
	}
	else {
	    IVTV_DEBUG_MB("MB Call: %s\n", api_info[cmd].name);
	}

	/* clear possibly uninitialized part of data array */
	for (i = args; i < CX2341X_MBOX_MAX_DATA; i++)
		data[i] = 0;

	/* If this command was issued within the last 30 minutes and with identical
	   data, then just return 0 as there is no need to issue this command again.
	   Just an optimization to prevent unnecessary use of mailboxes. */
	if (itv->api_cache[cmd].last_jiffies &&
	    time_before(jiffies,
			itv->api_cache[cmd].last_jiffies +
			msecs_to_jiffies(1800000)) &&
	    !memcmp(data, itv->api_cache[cmd].data, sizeof(itv->api_cache[cmd].data))) {
		itv->api_cache[cmd].last_jiffies = jiffies;
		return 0;
	}

	flags = api_info[cmd].flags;

	if (flags & API_DMA) {
		for (i = 0; i < 100; i++) {
			mb = i % (mbdata->max_mbox + 1);
			if (try_mailbox(itv, mbdata, mb)) {
				write_mailbox(&mbdata->mbox[mb], cmd, args, data);
				clear_bit(mb, &mbdata->busy);
				return 0;
			}
			IVTV_DEBUG_WARN("%s: mailbox %d not free %08x\n",
					api_info[cmd].name, mb, readl(&mbdata->mbox[mb].flags));
		}
		IVTV_WARN("Could not find free DMA mailbox for %s\n", api_info[cmd].name);
		clear_all_mailboxes(itv, mbdata);
		return -EBUSY;
	}

	if ((flags & API_FAST_RESULT) == API_FAST_RESULT)
		api_timeout = msecs_to_jiffies(100);

	mb = get_mailbox(itv, mbdata, flags);
	if (mb < 0) {
		IVTV_DEBUG_WARN("No free mailbox found (%s)\n", api_info[cmd].name);
		clear_all_mailboxes(itv, mbdata);
		return -EBUSY;
	}
	mbox = &mbdata->mbox[mb];
	write_mailbox(mbox, cmd, args, data);
	if (flags & API_CACHE) {
		memcpy(itv->api_cache[cmd].data, data, sizeof(itv->api_cache[cmd].data));
		itv->api_cache[cmd].last_jiffies = jiffies;
	}
	if ((flags & API_RESULT) == 0) {
		clear_bit(mb, &mbdata->busy);
		return 0;
	}

	/* Get results */
	then = jiffies;

	if (!(flags & API_NO_POLL)) {
		/* First try to poll, then switch to delays */
		for (i = 0; i < 100; i++) {
			if (readl(&mbox->flags) & IVTV_MBOX_FIRMWARE_DONE)
				break;
		}
	}
	while (!(readl(&mbox->flags) & IVTV_MBOX_FIRMWARE_DONE)) {
		if (time_after(jiffies, then + api_timeout)) {
			IVTV_DEBUG_WARN("Could not get result (%s)\n", api_info[cmd].name);
			/* reset the mailbox, but it is likely too late already */
			write_sync(0, &mbox->flags);
			clear_bit(mb, &mbdata->busy);
			return -EIO;
		}
		if (flags & API_NO_WAIT_RES)
			mdelay(1);
		else
			ivtv_msleep_timeout(1, 0);
	}
	if (time_after(jiffies, then + msecs_to_jiffies(100)))
		IVTV_DEBUG_WARN("%s took %u jiffies\n",
				api_info[cmd].name,
				jiffies_to_msecs(jiffies - then));

	for (i = 0; i < CX2341X_MBOX_MAX_DATA; i++)
		data[i] = readl(&mbox->data[i]);
	write_sync(0, &mbox->flags);
	clear_bit(mb, &mbdata->busy);
	return 0;
}

int ivtv_api(struct ivtv *itv, int cmd, int args, u32 data[])
{
	int res = ivtv_api_call(itv, cmd, args, data);

	/* Allow a single retry, probably already too late though.
	   If there is no free mailbox then that is usually an indication
	   of a more serious problem. */
	return (res == -EBUSY) ? ivtv_api_call(itv, cmd, args, data) : res;
}

int ivtv_api_func(void *priv, u32 cmd, int in, int out, u32 data[CX2341X_MBOX_MAX_DATA])
{
	return ivtv_api(priv, cmd, in, data);
}

int ivtv_vapi_result(struct ivtv *itv, u32 data[CX2341X_MBOX_MAX_DATA], int cmd, int args, ...)
{
	va_list ap;
	int i;

	va_start(ap, args);
	for (i = 0; i < args; i++) {
		data[i] = va_arg(ap, u32);
	}
	va_end(ap);
	return ivtv_api(itv, cmd, args, data);
}

int ivtv_vapi(struct ivtv *itv, int cmd, int args, ...)
{
	u32 data[CX2341X_MBOX_MAX_DATA];
	va_list ap;
	int i;

	va_start(ap, args);
	for (i = 0; i < args; i++) {
		data[i] = va_arg(ap, u32);
	}
	va_end(ap);
	return ivtv_api(itv, cmd, args, data);
}

/* This one is for stuff that can't sleep.. irq handlers, etc.. */
void ivtv_api_get_data(struct ivtv_mailbox_data *mbdata, int mb,
		       int argc, u32 data[])
{
	volatile u32 __iomem *p = mbdata->mbox[mb].data;
	int i;
	for (i = 0; i < argc; i++, p++)
		data[i] = readl(p);
}

/* Wipe api cache */
void ivtv_mailbox_cache_invalidate(struct ivtv *itv)
{
	int i;
	for (i = 0; i < 256; i++)
		itv->api_cache[i].last_jiffies = 0;
}
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
1a0adaf3 HV	2	/*
	3	mailbox functions
	4	Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
	5	Copyright (C) 2004 Chris Kennedy <c@groovy.org>
	6	Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
	7
1a0adaf3 HV	8	*/
1a0adaf3 HV	9
1a0adaf3 HV	10	#include "ivtv-driver.h"
	11	#include "ivtv-mailbox.h"
	12
bbdba43f MCC	13	#include <stdarg.h>
bbdba43f MCC	14
1a0adaf3 HV	15	/* Firmware mailbox flags*/
	16	#define IVTV_MBOX_FIRMWARE_DONE 0x00000004
	17	#define IVTV_MBOX_DRIVER_DONE 0x00000002
	18	#define IVTV_MBOX_DRIVER_BUSY 0x00000001
6e6a8b5a	19	#define IVTV_MBOX_FREE 0x00000000
1a0adaf3 HV	20
1a0adaf3 HV	21	/* Firmware mailbox standard timeout */
6e6a8b5a	22	#define IVTV_API_STD_TIMEOUT 0x02000000
1a0adaf3	23
6e6a8b5a MCC	24	#define API_CACHE (1 << 0) /* Allow the command to be stored in the cache */
6e6a8b5a MCC	25	#define API_RESULT (1 << 1) /* Allow 1 second for this cmd to end */
1a0adaf3	26	#define API_FAST_RESULT (3 << 1) /* Allow 0.1 second for this cmd to end */
6e6a8b5a MCC	27	#define API_DMA (1 << 3) /* DMA mailbox, has special handling */
	28	#define API_HIGH_VOL (1 << 5) /* High volume command (i.e. called during encoding or decoding) */
	29	#define API_NO_WAIT_MB (1 << 4) /* Command may not wait for a free mailbox */
1a0adaf3	30	#define API_NO_WAIT_RES (1 << 5) /* Command may not wait for the result */
0b3e29e6	31	#define API_NO_POLL (1 << 6) /* Avoid pointless polling */
1a0adaf3 HV	32
	33	struct ivtv_api_info {
	34	int flags; /* Flags, see above */
6e6a8b5a	35	const char name; / The name of the command */
1a0adaf3 HV	36	};
	37
	38	#define API_ENTRY(x, f) [x] = { (f), #x }
	39
	40	static const struct ivtv_api_info api_info[256] = {
	41	/* MPEG encoder API */
6e6a8b5a MCC	42	API_ENTRY(CX2341X_ENC_PING_FW, API_FAST_RESULT),
	43	API_ENTRY(CX2341X_ENC_START_CAPTURE, API_RESULT \| API_NO_POLL),
	44	API_ENTRY(CX2341X_ENC_STOP_CAPTURE, API_RESULT),
	45	API_ENTRY(CX2341X_ENC_SET_AUDIO_ID, API_CACHE),
	46	API_ENTRY(CX2341X_ENC_SET_VIDEO_ID, API_CACHE),
	47	API_ENTRY(CX2341X_ENC_SET_PCR_ID, API_CACHE),
	48	API_ENTRY(CX2341X_ENC_SET_FRAME_RATE, API_CACHE),
	49	API_ENTRY(CX2341X_ENC_SET_FRAME_SIZE, API_CACHE),
	50	API_ENTRY(CX2341X_ENC_SET_BIT_RATE, API_CACHE),
	51	API_ENTRY(CX2341X_ENC_SET_GOP_PROPERTIES, API_CACHE),
	52	API_ENTRY(CX2341X_ENC_SET_ASPECT_RATIO, API_CACHE),
	53	API_ENTRY(CX2341X_ENC_SET_DNR_FILTER_MODE, API_CACHE),
	54	API_ENTRY(CX2341X_ENC_SET_DNR_FILTER_PROPS, API_CACHE),
	55	API_ENTRY(CX2341X_ENC_SET_CORING_LEVELS, API_CACHE),
	56	API_ENTRY(CX2341X_ENC_SET_SPATIAL_FILTER_TYPE, API_CACHE),
	57	API_ENTRY(CX2341X_ENC_SET_VBI_LINE, API_RESULT),
	58	API_ENTRY(CX2341X_ENC_SET_STREAM_TYPE, API_CACHE),
	59	API_ENTRY(CX2341X_ENC_SET_OUTPUT_PORT, API_CACHE),
	60	API_ENTRY(CX2341X_ENC_SET_AUDIO_PROPERTIES, API_CACHE),
	61	API_ENTRY(CX2341X_ENC_HALT_FW, API_FAST_RESULT),
	62	API_ENTRY(CX2341X_ENC_GET_VERSION, API_FAST_RESULT),
	63	API_ENTRY(CX2341X_ENC_SET_GOP_CLOSURE, API_CACHE),
	64	API_ENTRY(CX2341X_ENC_GET_SEQ_END, API_RESULT),
	65	API_ENTRY(CX2341X_ENC_SET_PGM_INDEX_INFO, API_FAST_RESULT),
	66	API_ENTRY(CX2341X_ENC_SET_VBI_CONFIG, API_RESULT),
	67	API_ENTRY(CX2341X_ENC_SET_DMA_BLOCK_SIZE, API_CACHE),
	68	API_ENTRY(CX2341X_ENC_GET_PREV_DMA_INFO_MB_10, API_FAST_RESULT),
	69	API_ENTRY(CX2341X_ENC_GET_PREV_DMA_INFO_MB_9, API_FAST_RESULT),
	70	API_ENTRY(CX2341X_ENC_SCHED_DMA_TO_HOST, API_DMA \| API_HIGH_VOL),
	71	API_ENTRY(CX2341X_ENC_INITIALIZE_INPUT, API_RESULT),
	72	API_ENTRY(CX2341X_ENC_SET_FRAME_DROP_RATE, API_CACHE),
	73	API_ENTRY(CX2341X_ENC_PAUSE_ENCODER, API_RESULT),
	74	API_ENTRY(CX2341X_ENC_REFRESH_INPUT, API_NO_WAIT_MB \| API_HIGH_VOL),
	75	API_ENTRY(CX2341X_ENC_SET_COPYRIGHT, API_CACHE),
	76	API_ENTRY(CX2341X_ENC_SET_EVENT_NOTIFICATION, API_RESULT),
	77	API_ENTRY(CX2341X_ENC_SET_NUM_VSYNC_LINES, API_CACHE),
	78	API_ENTRY(CX2341X_ENC_SET_PLACEHOLDER, API_CACHE),
	79	API_ENTRY(CX2341X_ENC_MUTE_VIDEO, API_RESULT),
	80	API_ENTRY(CX2341X_ENC_MUTE_AUDIO, API_RESULT),
1a0adaf3	81	API_ENTRY(CX2341X_ENC_SET_VERT_CROP_LINE, API_FAST_RESULT),
6e6a8b5a	82	API_ENTRY(CX2341X_ENC_MISC, API_FAST_RESULT),
1a0adaf3	83	/* Obsolete PULLDOWN API command */
6e6a8b5a	84	API_ENTRY(0xb1, API_CACHE),
1a0adaf3 HV	85
1a0adaf3 HV	86	/* MPEG decoder API */
6e6a8b5a MCC	87	API_ENTRY(CX2341X_DEC_PING_FW, API_FAST_RESULT),
	88	API_ENTRY(CX2341X_DEC_START_PLAYBACK, API_RESULT \| API_NO_POLL),
	89	API_ENTRY(CX2341X_DEC_STOP_PLAYBACK, API_RESULT),
	90	API_ENTRY(CX2341X_DEC_SET_PLAYBACK_SPEED, API_RESULT),
	91	API_ENTRY(CX2341X_DEC_STEP_VIDEO, API_RESULT),
	92	API_ENTRY(CX2341X_DEC_SET_DMA_BLOCK_SIZE, API_CACHE),
	93	API_ENTRY(CX2341X_DEC_GET_XFER_INFO, API_FAST_RESULT),
	94	API_ENTRY(CX2341X_DEC_GET_DMA_STATUS, API_FAST_RESULT),
	95	API_ENTRY(CX2341X_DEC_SCHED_DMA_FROM_HOST, API_DMA \| API_HIGH_VOL),
	96	API_ENTRY(CX2341X_DEC_PAUSE_PLAYBACK, API_RESULT),
	97	API_ENTRY(CX2341X_DEC_HALT_FW, API_FAST_RESULT),
	98	API_ENTRY(CX2341X_DEC_SET_STANDARD, API_CACHE),
	99	API_ENTRY(CX2341X_DEC_GET_VERSION, API_FAST_RESULT),
	100	API_ENTRY(CX2341X_DEC_SET_STREAM_INPUT, API_CACHE),
	101	API_ENTRY(CX2341X_DEC_GET_TIMING_INFO, API_RESULT /\| API_NO_WAIT_RES/),
	102	API_ENTRY(CX2341X_DEC_SET_AUDIO_MODE, API_CACHE),
	103	API_ENTRY(CX2341X_DEC_SET_EVENT_NOTIFICATION, API_RESULT),
	104	API_ENTRY(CX2341X_DEC_SET_DISPLAY_BUFFERS, API_CACHE),
	105	API_ENTRY(CX2341X_DEC_EXTRACT_VBI, API_RESULT),
	106	API_ENTRY(CX2341X_DEC_SET_DECODER_SOURCE, API_FAST_RESULT),
	107	API_ENTRY(CX2341X_DEC_SET_PREBUFFERING, API_CACHE),
1a0adaf3 HV	108
1a0adaf3 HV	109	/* OSD API */
6e6a8b5a MCC	110	API_ENTRY(CX2341X_OSD_GET_FRAMEBUFFER, API_FAST_RESULT),
	111	API_ENTRY(CX2341X_OSD_GET_PIXEL_FORMAT, API_FAST_RESULT),
	112	API_ENTRY(CX2341X_OSD_SET_PIXEL_FORMAT, API_CACHE),
	113	API_ENTRY(CX2341X_OSD_GET_STATE, API_FAST_RESULT),
	114	API_ENTRY(CX2341X_OSD_SET_STATE, API_CACHE),
	115	API_ENTRY(CX2341X_OSD_GET_OSD_COORDS, API_FAST_RESULT),
	116	API_ENTRY(CX2341X_OSD_SET_OSD_COORDS, API_CACHE),
	117	API_ENTRY(CX2341X_OSD_GET_SCREEN_COORDS, API_FAST_RESULT),
	118	API_ENTRY(CX2341X_OSD_SET_SCREEN_COORDS, API_CACHE),
	119	API_ENTRY(CX2341X_OSD_GET_GLOBAL_ALPHA, API_FAST_RESULT),
	120	API_ENTRY(CX2341X_OSD_SET_GLOBAL_ALPHA, API_CACHE),
	121	API_ENTRY(CX2341X_OSD_SET_BLEND_COORDS, API_CACHE),
	122	API_ENTRY(CX2341X_OSD_GET_FLICKER_STATE, API_FAST_RESULT),
	123	API_ENTRY(CX2341X_OSD_SET_FLICKER_STATE, API_CACHE),
	124	API_ENTRY(CX2341X_OSD_BLT_COPY, API_RESULT),
	125	API_ENTRY(CX2341X_OSD_BLT_FILL, API_RESULT),
	126	API_ENTRY(CX2341X_OSD_BLT_TEXT, API_RESULT),
	127	API_ENTRY(CX2341X_OSD_SET_FRAMEBUFFER_WINDOW, API_CACHE),
	128	API_ENTRY(CX2341X_OSD_SET_CHROMA_KEY, API_CACHE),
	129	API_ENTRY(CX2341X_OSD_GET_ALPHA_CONTENT_INDEX, API_FAST_RESULT),
	130	API_ENTRY(CX2341X_OSD_SET_ALPHA_CONTENT_INDEX, API_CACHE)
1a0adaf3 HV	131	};
	132
	133	static int try_mailbox(struct ivtv itv, struct ivtv_mailbox_data mbdata, int mb)
	134	{
	135	u32 flags = readl(&mbdata->mbox[mb].flags);
	136	int is_free = flags == IVTV_MBOX_FREE \|\| (flags & IVTV_MBOX_FIRMWARE_DONE);
	137
	138	/* if the mailbox is free, then try to claim it */
	139	if (is_free && !test_and_set_bit(mb, &mbdata->busy)) {
	140	write_sync(IVTV_MBOX_DRIVER_BUSY, &mbdata->mbox[mb].flags);
	141	return 1;
	142	}
	143	return 0;
	144	}
	145
	146	/* Try to find a free mailbox. Note mailbox 0 is reserved for DMA and so is not
	147	attempted here. */
	148	static int get_mailbox(struct ivtv itv, struct ivtv_mailbox_data mbdata, int flags)
	149	{
	150	unsigned long then = jiffies;
	151	int i, mb;
	152	int max_mbox = mbdata->max_mbox;
	153	int retries = 100;
	154
	155	/* All slow commands use the same mailbox, serializing them and also
	156	leaving the other mailbox free for simple fast commands. */
	157	if ((flags & API_FAST_RESULT) == API_RESULT)
	158	max_mbox = 1;
	159
	160	/* find free non-DMA mailbox */
	161	for (i = 0; i < retries; i++) {
	162	for (mb = 1; mb <= max_mbox; mb++)
	163	if (try_mailbox(itv, mbdata, mb))
	164	return mb;
	165
	166	/* Sleep before a retry, if not atomic */
	167	if (!(flags & API_NO_WAIT_MB)) {
168c626c JL	168	if (time_after(jiffies,
168c626c JL	169	then + msecs_to_jiffies(10*retries)))
1a0adaf3	170	break;
201700d3	171	ivtv_msleep_timeout(10, 0);
1a0adaf3 HV	172	}
	173	}
	174	return -ENODEV;
	175	}
	176
	177	static void write_mailbox(volatile struct ivtv_mailbox __iomem *mbox, int cmd, int args, u32 data[])
	178	{
	179	int i;
	180
	181	write_sync(cmd, &mbox->cmd);
	182	write_sync(IVTV_API_STD_TIMEOUT, &mbox->timeout);
	183
	184	for (i = 0; i < CX2341X_MBOX_MAX_DATA; i++)
	185	write_sync(data[i], &mbox->data[i]);
	186
	187	write_sync(IVTV_MBOX_DRIVER_DONE \| IVTV_MBOX_DRIVER_BUSY, &mbox->flags);
	188	}
	189
	190	static void clear_all_mailboxes(struct ivtv itv, struct ivtv_mailbox_data mbdata)
	191	{
	192	int i;
	193
	194	for (i = 0; i <= mbdata->max_mbox; i++) {
	195	IVTV_DEBUG_WARN("Clearing mailbox %d: cmd 0x%08x flags 0x%08x\n",
	196	i, readl(&mbdata->mbox[i].cmd), readl(&mbdata->mbox[i].flags));
	197	write_sync(0, &mbdata->mbox[i].flags);
	198	clear_bit(i, &mbdata->busy);
	199	}
	200	}
	201
	202	static int ivtv_api_call(struct ivtv *itv, int cmd, int args, u32 data[])
	203	{
	204	struct ivtv_mailbox_data *mbdata = (cmd >= 128) ? &itv->enc_mbox : &itv->dec_mbox;
	205	volatile struct ivtv_mailbox __iomem *mbox;
201700d3	206	int api_timeout = msecs_to_jiffies(1000);
1a0adaf3 HV	207	int flags, mb, i;
	208	unsigned long then;
	209
	210	/* sanity checks */
	211	if (NULL == mbdata) {
	212	IVTV_ERR("No mailbox allocated\n");
	213	return -ENODEV;
	214	}
	215	if (args < 0 \|\| args > CX2341X_MBOX_MAX_DATA \|\|
	216	cmd < 0 \|\| cmd > 255 \|\| api_info[cmd].name == NULL) {
1aa32c2f	217	IVTV_ERR("Invalid MB call: cmd = 0x%02x, args = %d\n", cmd, args);
1a0adaf3 HV	218	return -EINVAL;
	219	}
	220
67632e17	221	if (api_info[cmd].flags & API_HIGH_VOL) {
1aa32c2f	222	IVTV_DEBUG_HI_MB("MB Call: %s\n", api_info[cmd].name);
67632e17 HV	223	}
67632e17 HV	224	else {
1aa32c2f	225	IVTV_DEBUG_MB("MB Call: %s\n", api_info[cmd].name);
67632e17	226	}
1a0adaf3 HV	227
	228	/* clear possibly uninitialized part of data array */
	229	for (i = args; i < CX2341X_MBOX_MAX_DATA; i++)
	230	data[i] = 0;
	231
	232	/* If this command was issued within the last 30 minutes and with identical
	233	data, then just return 0 as there is no need to issue this command again.
	234	Just an optimization to prevent unnecessary use of mailboxes. */
	235	if (itv->api_cache[cmd].last_jiffies &&
168c626c JL	236	time_before(jiffies,
	237	itv->api_cache[cmd].last_jiffies +
	238	msecs_to_jiffies(1800000)) &&
1a0adaf3 HV	239	!memcmp(data, itv->api_cache[cmd].data, sizeof(itv->api_cache[cmd].data))) {
	240	itv->api_cache[cmd].last_jiffies = jiffies;
	241	return 0;
	242	}
	243
	244	flags = api_info[cmd].flags;
	245
	246	if (flags & API_DMA) {
	247	for (i = 0; i < 100; i++) {
	248	mb = i % (mbdata->max_mbox + 1);
	249	if (try_mailbox(itv, mbdata, mb)) {
	250	write_mailbox(&mbdata->mbox[mb], cmd, args, data);
	251	clear_bit(mb, &mbdata->busy);
	252	return 0;
	253	}
	254	IVTV_DEBUG_WARN("%s: mailbox %d not free %08x\n",
	255	api_info[cmd].name, mb, readl(&mbdata->mbox[mb].flags));
	256	}
	257	IVTV_WARN("Could not find free DMA mailbox for %s\n", api_info[cmd].name);
	258	clear_all_mailboxes(itv, mbdata);
	259	return -EBUSY;
	260	}
	261
	262	if ((flags & API_FAST_RESULT) == API_FAST_RESULT)
201700d3	263	api_timeout = msecs_to_jiffies(100);
1a0adaf3 HV	264
	265	mb = get_mailbox(itv, mbdata, flags);
	266	if (mb < 0) {
	267	IVTV_DEBUG_WARN("No free mailbox found (%s)\n", api_info[cmd].name);
	268	clear_all_mailboxes(itv, mbdata);
	269	return -EBUSY;
	270	}
	271	mbox = &mbdata->mbox[mb];
	272	write_mailbox(mbox, cmd, args, data);
	273	if (flags & API_CACHE) {
	274	memcpy(itv->api_cache[cmd].data, data, sizeof(itv->api_cache[cmd].data));
	275	itv->api_cache[cmd].last_jiffies = jiffies;
	276	}
	277	if ((flags & API_RESULT) == 0) {
	278	clear_bit(mb, &mbdata->busy);
	279	return 0;
	280	}
	281
	282	/* Get results */
	283	then = jiffies;
	284
0b3e29e6 HV	285	if (!(flags & API_NO_POLL)) {
	286	/* First try to poll, then switch to delays */
	287	for (i = 0; i < 100; i++) {
	288	if (readl(&mbox->flags) & IVTV_MBOX_FIRMWARE_DONE)
	289	break;
	290	}
	291	}
1a0adaf3	292	while (!(readl(&mbox->flags) & IVTV_MBOX_FIRMWARE_DONE)) {
168c626c	293	if (time_after(jiffies, then + api_timeout)) {
1a0adaf3 HV	294	IVTV_DEBUG_WARN("Could not get result (%s)\n", api_info[cmd].name);
	295	/* reset the mailbox, but it is likely too late already */
	296	write_sync(0, &mbox->flags);
	297	clear_bit(mb, &mbdata->busy);
	298	return -EIO;
	299	}
	300	if (flags & API_NO_WAIT_RES)
	301	mdelay(1);
	302	else
0b3e29e6	303	ivtv_msleep_timeout(1, 0);
1a0adaf3	304	}
168c626c	305	if (time_after(jiffies, then + msecs_to_jiffies(100)))
201700d3 MCC	306	IVTV_DEBUG_WARN("%s took %u jiffies\n",
	307	api_info[cmd].name,
	308	jiffies_to_msecs(jiffies - then));
1a0adaf3 HV	309
	310	for (i = 0; i < CX2341X_MBOX_MAX_DATA; i++)
	311	data[i] = readl(&mbox->data[i]);
	312	write_sync(0, &mbox->flags);
	313	clear_bit(mb, &mbdata->busy);
	314	return 0;
	315	}
	316
	317	int ivtv_api(struct ivtv *itv, int cmd, int args, u32 data[])
	318	{
	319	int res = ivtv_api_call(itv, cmd, args, data);
	320
	321	/* Allow a single retry, probably already too late though.
	322	If there is no free mailbox then that is usually an indication
	323	of a more serious problem. */
	324	return (res == -EBUSY) ? ivtv_api_call(itv, cmd, args, data) : res;
	325	}
	326
ea48c13a	327	int ivtv_api_func(void *priv, u32 cmd, int in, int out, u32 data[CX2341X_MBOX_MAX_DATA])
1a0adaf3 HV	328	{
	329	return ivtv_api(priv, cmd, in, data);
	330	}
	331
	332	int ivtv_vapi_result(struct ivtv *itv, u32 data[CX2341X_MBOX_MAX_DATA], int cmd, int args, ...)
	333	{
	334	va_list ap;
	335	int i;
	336
	337	va_start(ap, args);
	338	for (i = 0; i < args; i++) {
	339	data[i] = va_arg(ap, u32);
	340	}
	341	va_end(ap);
	342	return ivtv_api(itv, cmd, args, data);
	343	}
	344
	345	int ivtv_vapi(struct ivtv *itv, int cmd, int args, ...)
	346	{
	347	u32 data[CX2341X_MBOX_MAX_DATA];
	348	va_list ap;
	349	int i;
	350
	351	va_start(ap, args);
	352	for (i = 0; i < args; i++) {
	353	data[i] = va_arg(ap, u32);
	354	}
	355	va_end(ap);
	356	return ivtv_api(itv, cmd, args, data);
	357	}
	358
	359	/* This one is for stuff that can't sleep.. irq handlers, etc.. */
587808d5 AW	360	void ivtv_api_get_data(struct ivtv_mailbox_data *mbdata, int mb,
587808d5 AW	361	int argc, u32 data[])
1a0adaf3	362	{
587808d5	363	volatile u32 __iomem *p = mbdata->mbox[mb].data;
1a0adaf3	364	int i;
587808d5 AW	365	for (i = 0; i < argc; i++, p++)
587808d5 AW	366	data[i] = readl(p);
1a0adaf3	367	}
215659d1 IA	368
	369	/* Wipe api cache */
	370	void ivtv_mailbox_cache_invalidate(struct ivtv *itv)
	371	{
	372	int i;
	373	for (i = 0; i < 256; i++)
	374	itv->api_cache[i].last_jiffies = 0;
	375	}