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: &fw, name: fn, device: &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(val: *src, addr: 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, args: 0); |
81 | if (itv->enc_mbox.mbox) |
82 | ivtv_vapi(itv, CX2341X_ENC_HALT_FW, args: 0); |
83 | |
84 | ivtv_msleep_timeout(msecs: 10, intr: 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(msecs: 10, intr: 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, intr: 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, args: 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, args: 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 | mem: 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 | mem: 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(addr: mem + i) == 0x12345678 && |
174 | readl(addr: mem + i + 4) == 0x34567812 && |
175 | readl(addr: mem + i + 8) == 0x56781234 && |
176 | readl(addr: 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(msecs: 100, intr: 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(msecs: 100, intr: 0); |
204 | |
205 | /* find mailboxes and ping firmware */ |
206 | itv->enc_mbox.mbox = ivtv_search_mailbox(mem: 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, args: 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(mem: 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, args: 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, args: 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, args: 2, 0, 1) != 0) { |
249 | IVTV_ERR("ivtv_init_mpeg_decoder failed to start playback\n" ); |
250 | return; |
251 | } |
252 | ivtv_api_get_data(mbdata: &itv->dec_mbox, IVTV_MBOX_DMA, argc: 2, data); |
253 | mem_offset = itv->dec_mem + data[1]; |
254 | |
255 | if ((readbytes = load_fw_direct(IVTV_DECODE_INIT_MPEG_FILENAME, |
256 | mem: 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, args: 3, 0, readbytes, 0); |
261 | ivtv_msleep_timeout(msecs: 100, intr: 0); |
262 | } |
263 | ivtv_vapi(itv, CX2341X_DEC_STOP_PLAYBACK, args: 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(lock: &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(lock: &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, args: 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(v: &itv->capturing) && |
335 | (!atomic_read(v: &itv->decoding) || |
336 | (atomic_read(v: &itv->decoding) < 2 && test_bit(IVTV_F_I_DEC_YUV, |
337 | &itv->i_flags)))) { |
338 | |
339 | if (ivtv_vapi(itv, CX2341X_ENC_MISC, args: 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(msecs: 14, intr: 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, args: 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(v: &itv->capturing) && |
366 | !atomic_read(v: &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 | |