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