drivers/media/pci/ivtv/ivtv-firmware.c

   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  "/*(DEBLOBBED)*/"
  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 && reject_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 /*(DEBLOBBED)*/