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