release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/media/video/ivtv/ivtv-firmware.c

   1 /*
   2     ivtv firmware functions.
   3     Copyright (C) 2003-2004  Kevin Thayer <nufan_wfk at yahoo.com>
   4     Copyright (C) 2004  Chris Kennedy <c@groovy.org>
   5     Copyright (C) 2005-2007  Hans Verkuil <hverkuil@xs4all.nl>
   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)
  92                 ivtv_vapi(itv, CX2341X_DEC_HALT_FW, 0);
  93         if (itv->enc_mbox.mbox)
  94                 ivtv_vapi(itv, CX2341X_ENC_HALT_FW, 0);
  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");
 100         write_reg(IVTV_CMD_VDM_STOP, IVTV_REG_VDM);
 101
 102         IVTV_DEBUG_INFO("Stopping AO\n");
 103         write_reg(IVTV_CMD_AO_STOP, IVTV_REG_AO);
 104
 105         IVTV_DEBUG_INFO("pinging (?) APU\n");
 106         write_reg(IVTV_CMD_APU_PING, IVTV_REG_APU);
 107
 108         IVTV_DEBUG_INFO("Stopping VPU\n");
 109         if (!itv->has_cx23415)
 110                 write_reg(IVTV_CMD_VPU_STOP16, IVTV_REG_VPU);
 111         else
 112                 write_reg(IVTV_CMD_VPU_STOP15, IVTV_REG_VPU);
 113
 114         IVTV_DEBUG_INFO("Resetting Hw Blocks\n");
 115         write_reg(IVTV_CMD_HW_BLOCKS_RST, IVTV_REG_HW_BLOCKS);
 116
 117         IVTV_DEBUG_INFO("Stopping SPU\n");
 118         write_reg(IVTV_CMD_SPU_STOP, IVTV_REG_SPU);
 119
 120         ivtv_msleep_timeout(10, 0);
 121
 122         IVTV_DEBUG_INFO("init Encoder SDRAM pre-charge\n");
 123         write_reg(IVTV_CMD_SDRAM_PRECHARGE_INIT, IVTV_REG_ENC_SDRAM_PRECHARGE);
 124
 125         IVTV_DEBUG_INFO("init Encoder SDRAM refresh to 1us\n");
 126         write_reg(IVTV_CMD_SDRAM_REFRESH_INIT, IVTV_REG_ENC_SDRAM_REFRESH);
 127
 128         if (itv->has_cx23415) {
 129                 IVTV_DEBUG_INFO("init Decoder SDRAM pre-charge\n");
 130                 write_reg(IVTV_CMD_SDRAM_PRECHARGE_INIT, IVTV_REG_DEC_SDRAM_PRECHARGE);
 131
 132                 IVTV_DEBUG_INFO("init Decoder SDRAM refresh to 1us\n");
 133                 write_reg(IVTV_CMD_SDRAM_REFRESH_INIT, IVTV_REG_DEC_SDRAM_REFRESH);
 134         }
 135
 136         IVTV_DEBUG_INFO("Sleeping for %dms\n", IVTV_SDRAM_SLEEPTIME);
 137         ivtv_msleep_timeout(IVTV_SDRAM_SLEEPTIME, 0);
 138 }
 139
 140 void ivtv_firmware_versions(struct ivtv *itv)
 141 {
 142         u32 data[CX2341X_MBOX_MAX_DATA];
 143
 144         /* Encoder */
 145         ivtv_vapi_result(itv, data, CX2341X_ENC_GET_VERSION, 0);
 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 */
 153                 ivtv_vapi_result(itv, data, CX2341X_DEC_GET_VERSION, 0);
 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 preceeded 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 */
 209         write_reg(read_reg(IVTV_REG_SPU) & IVTV_MASK_SPU_ENABLE, IVTV_REG_SPU);
 210         ivtv_msleep_timeout(100, 0);
 211         if (itv->has_cx23415)
 212                 write_reg(read_reg(IVTV_REG_VPU) & IVTV_MASK_VPU_ENABLE15, IVTV_REG_VPU);
 213         else
 214                 write_reg(read_reg(IVTV_REG_VPU) & IVTV_MASK_VPU_ENABLE16, IVTV_REG_VPU);
 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 */
 239                 ivtv_yuv_filter_check(itv);
 240         }
 241         return itv->dec_mbox.mbox ? 0 : -ENODEV;
 242 }
 243
 244 void ivtv_init_mpeg_decoder(struct ivtv *itv)
 245 {
 246         u32 data[CX2341X_MBOX_MAX_DATA];
 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",
 270                                 IVTV_DECODE_INIT_MPEG_FILENAME);
 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;
 282         v4l2_std_id std;
 283         struct ivtv_open_id fh;
 284         fh.itv = itv;
 285
 286         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)
 287                 /* Display test image during restart */
 288                 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
 289                     SAA7127_INPUT_TYPE_TEST_IMAGE,
 290                     itv->card->video_outputs[itv->active_output].video_output,
 291                     0);
 292
 293         mutex_lock(&itv->udma.lock);
 294
 295         rc = ivtv_firmware_init(itv);
 296         if (rc) {
 297                 mutex_unlock(&itv->udma.lock);
 298                 return rc;
 299         }
 300
 301         /* Allow settings to reload */
 302         ivtv_mailbox_cache_invalidate(itv);
 303
 304         /* Restore video standard */
 305         std = itv->std;
 306         itv->std = 0;
 307         ivtv_s_std(NULL, &fh, &std);
 308
 309         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
 310                 ivtv_init_mpeg_decoder(itv);
 311
 312                 /* Restore framebuffer if active */
 313                 if (itv->ivtvfb_restore)
 314                         itv->ivtvfb_restore(itv);
 315
 316                 /* Restore alpha settings */
 317                 ivtv_set_osd_alpha(itv);
 318
 319                 /* Restore normal output */
 320                 ivtv_call_hw(itv, IVTV_HW_SAA7127, video, s_routing,
 321                     SAA7127_INPUT_TYPE_NORMAL,
 322                     itv->card->video_outputs[itv->active_output].video_output,
 323                     0);
 324         }
 325
 326         mutex_unlock(&itv->udma.lock);
 327         return rc;
 328 }
 329
 330 /* Check firmware running state. The checks fall through
 331    allowing multiple failures to be logged. */
 332 int ivtv_firmware_check(struct ivtv *itv, char *where)
 333 {
 334         int res = 0;
 335
 336         /* Check encoder is still running */
 337         if (ivtv_vapi(itv, CX2341X_ENC_PING_FW, 0) < 0) {
 338                 IVTV_WARN("Encoder has died : %s\n", where);
 339                 res = -1;
 340         }
 341
 342         /* Also check audio. Only check if not in use & encoder is okay */
 343         if (!res && !atomic_read(&itv->capturing) &&
 344             (!atomic_read(&itv->decoding) ||
 345              (atomic_read(&itv->decoding) < 2 && test_bit(IVTV_F_I_DEC_YUV,
 346                                                              &itv->i_flags)))) {
 347
 348                 if (ivtv_vapi(itv, CX2341X_ENC_MISC, 1, 12) < 0) {
 349                         IVTV_WARN("Audio has died (Encoder OK) : %s\n", where);
 350                         res = -2;
 351                 }
 352         }
 353
 354         if (itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT) {
 355                 /* Second audio check. Skip if audio already failed */
 356                 if (res != -2 && read_dec(0x100) != read_dec(0x104)) {
 357                         /* Wait & try again to be certain. */
 358                         ivtv_msleep_timeout(14, 0);
 359                         if (read_dec(0x100) != read_dec(0x104)) {
 360                                 IVTV_WARN("Audio has died (Decoder) : %s\n",
 361                                           where);
 362                                 res = -1;
 363                         }
 364                 }
 365
 366                 /* Check decoder is still running */
 367                 if (ivtv_vapi(itv, CX2341X_DEC_PING_FW, 0) < 0) {
 368                         IVTV_WARN("Decoder has died : %s\n", where);
 369                         res = -1;
 370                 }
 371         }
 372
 373         /* If something failed & currently idle, try to reload */
 374         if (res && !atomic_read(&itv->capturing) &&
 375                                                 !atomic_read(&itv->decoding)) {
 376                 IVTV_INFO("Detected in %s that firmware had failed - "
 377                           "Reloading\n", where);
 378                 res = ivtv_firmware_restart(itv);
 379                 /*
 380                  * Even if restarted ok, still signal a problem had occured.
 381                  * The caller can come through this function again to check
 382                  * if things are really ok after the restart.
 383                  */
 384                 if (!res) {
 385                         IVTV_INFO("Firmware restart okay\n");
 386                         res = -EAGAIN;
 387                 } else {
 388                         IVTV_INFO("Firmware restart failed\n");
 389                 }
 390         } else if (res) {
 391                 res = -EIO;
 392         }
 393
 394         return res;
 395 }