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