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
load_fw_direct(const char * fn,volatile u8 __iomem * mem,struct ivtv * itv,long size)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
ivtv_halt_firmware(struct ivtv * itv)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
ivtv_firmware_versions(struct ivtv * itv)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
ivtv_firmware_copy(struct ivtv * itv)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
ivtv_search_mailbox(const volatile u8 __iomem * mem,u32 size)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
ivtv_firmware_init(struct ivtv * itv)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
ivtv_init_mpeg_decoder(struct ivtv * itv)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 */
ivtv_firmware_restart(struct ivtv * itv)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. */
ivtv_firmware_check(struct ivtv * itv,char * where)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