drivers/media/video/s5p-mfc/s5p_mfc_ctrl.c

   1 /*
   2  * linux/drivers/media/video/s5p-mfc/s5p_mfc_ctrl.c
   3  *
   4  * Copyright (c) 2010 Samsung Electronics Co., Ltd.
   5  *              http://www.samsung.com/
   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
  13 #include <linux/delay.h>
  14 #include <linux/err.h>
  15 #include <linux/firmware.h>
  16 #include <linux/jiffies.h>
  17 #include <linux/sched.h>
  18 #include "s5p_mfc_cmd.h"
  19 #include "s5p_mfc_common.h"
  20 #include "s5p_mfc_debug.h"
  21 #include "s5p_mfc_intr.h"
  22 #include "s5p_mfc_pm.h"
  23
  24 static void *s5p_mfc_bitproc_buf;
  25 static size_t s5p_mfc_bitproc_phys;
  26 static unsigned char *s5p_mfc_bitproc_virt;
  27
  28 /* Allocate and load firmware */
  29 int s5p_mfc_alloc_and_load_firmware(struct s5p_mfc_dev *dev)
  30 {
  31         struct firmware *fw_blob;
  32         size_t bank2_base_phys;
  33         void *b_base;
  34         int err;
  35
  36         /* Firmare has to be present as a separate file or compiled
  37          * into kernel. */
  38         mfc_debug_enter();
  39         err = request_firmware((const struct firmware **)&fw_blob,
  40                                      "mfc_fw.bin", dev->v4l2_dev.dev);
  41         if (err != 0) {
  42                 mfc_err("Firmware is not present in the /lib/firmware directory nor compiled in kernel\n");
  43                 return -EINVAL;
  44         }
  45         dev->fw_size = dev->variant->buf_size->fw;
  46         if (s5p_mfc_bitproc_buf) {
  47                 mfc_err("Attempting to allocate firmware when it seems that it is already loaded\n");
  48                 release_firmware(fw_blob);
  49                 return -ENOMEM;
  50         }
  51         s5p_mfc_bitproc_buf = vb2_dma_contig_memops.alloc(
  52                 dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], dev->fw_size);
  53         if (IS_ERR(s5p_mfc_bitproc_buf)) {
  54                 s5p_mfc_bitproc_buf = 0;
  55                 mfc_err("Allocating bitprocessor buffer failed\n");
  56                 release_firmware(fw_blob);
  57                 return -ENOMEM;
  58         }
  59         s5p_mfc_bitproc_phys = s5p_mfc_mem_cookie(
  60                 dev->alloc_ctx[MFC_BANK1_ALLOC_CTX], s5p_mfc_bitproc_buf);
  61         if (s5p_mfc_bitproc_phys & ((1 << MFC_BASE_ALIGN_ORDER) - 1)) {
  62                 mfc_err("The base memory for bank 1 is not aligned to 128KB\n");
  63                 vb2_dma_contig_memops.put(s5p_mfc_bitproc_buf);
  64                 s5p_mfc_bitproc_phys = 0;
  65                 s5p_mfc_bitproc_buf = 0;
  66                 release_firmware(fw_blob);
  67                 return -EIO;
  68         }
  69         s5p_mfc_bitproc_virt = vb2_dma_contig_memops.vaddr(s5p_mfc_bitproc_buf);
  70         if (!s5p_mfc_bitproc_virt) {
  71                 mfc_err("Bitprocessor memory remap failed\n");
  72                 vb2_dma_contig_memops.put(s5p_mfc_bitproc_buf);
  73                 s5p_mfc_bitproc_phys = 0;
  74                 s5p_mfc_bitproc_buf = 0;
  75                 release_firmware(fw_blob);
  76                 return -EIO;
  77         }
  78         dev->bank1 = s5p_mfc_bitproc_phys;
  79         if (HAS_PORTNUM(dev) && IS_TWOPORT(dev)) {
  80                 b_base = vb2_dma_contig_memops.alloc(
  81                         dev->alloc_ctx[MFC_BANK2_ALLOC_CTX], 1 << MFC_BANK2_ALIGN_ORDER);
  82                 if (IS_ERR(b_base)) {
  83                         vb2_dma_contig_memops.put(s5p_mfc_bitproc_buf);
  84                         s5p_mfc_bitproc_phys = 0;
  85                         s5p_mfc_bitproc_buf = 0;
  86                         mfc_err("Allocating bank2 base failed\n");
  87                         release_firmware(fw_blob);
  88                         return -ENOMEM;
  89                 }
  90                 bank2_base_phys = s5p_mfc_mem_cookie(
  91                         dev->alloc_ctx[MFC_BANK2_ALLOC_CTX], b_base);
  92                 vb2_dma_contig_memops.put(b_base);
  93                 if (bank2_base_phys & ((1 << MFC_BASE_ALIGN_ORDER) - 1)) {
  94                         mfc_err("The base memory for bank 2 is not aligned to 128KB\n");
  95                         vb2_dma_contig_memops.put(s5p_mfc_bitproc_buf);
  96                         s5p_mfc_bitproc_phys = 0;
  97                         s5p_mfc_bitproc_buf = 0;
  98                         release_firmware(fw_blob);
  99                         return -EIO;
 100                 }
 101                 dev->bank2 = bank2_base_phys;
 102         } else {
 103                 dev->bank2 = dev->bank1;
 104         }
 105         memcpy(s5p_mfc_bitproc_virt, fw_blob->data, fw_blob->size);
 106         wmb();
 107         release_firmware(fw_blob);
 108         mfc_debug_leave();
 109         return 0;
 110 }
 111
 112 /* Reload firmware to MFC */
 113 int s5p_mfc_reload_firmware(struct s5p_mfc_dev *dev)
 114 {
 115         struct firmware *fw_blob;
 116         int err;
 117
 118         /* Firmare has to be present as a separate file or compiled
 119          * into kernel. */
 120         mfc_debug_enter();
 121         err = request_firmware((const struct firmware **)&fw_blob,
 122                                      "mfc_fw.bin", dev->v4l2_dev.dev);
 123         if (err != 0) {
 124                 mfc_err("Firmware is not present in the /lib/firmware directory nor compiled in kernel\n");
 125                 return -EINVAL;
 126         }
 127         if (fw_blob->size > dev->fw_size) {
 128                 mfc_err("MFC firmware is too big to be loaded\n");
 129                 release_firmware(fw_blob);
 130                 return -ENOMEM;
 131         }
 132         if (s5p_mfc_bitproc_buf == 0 || s5p_mfc_bitproc_phys == 0) {
 133                 mfc_err("MFC firmware is not allocated or was not mapped correctly\n");
 134                 release_firmware(fw_blob);
 135                 return -EINVAL;
 136         }
 137         memcpy(s5p_mfc_bitproc_virt, fw_blob->data, fw_blob->size);
 138         wmb();
 139         release_firmware(fw_blob);
 140         mfc_debug_leave();
 141         return 0;
 142 }
 143
 144 /* Release firmware memory */
 145 int s5p_mfc_release_firmware(struct s5p_mfc_dev *dev)
 146 {
 147         /* Before calling this function one has to make sure
 148          * that MFC is no longer processing */
 149         if (!s5p_mfc_bitproc_buf)
 150                 return -EINVAL;
 151         vb2_dma_contig_memops.put(s5p_mfc_bitproc_buf);
 152         s5p_mfc_bitproc_virt =  0;
 153         s5p_mfc_bitproc_phys = 0;
 154         s5p_mfc_bitproc_buf = 0;
 155         return 0;
 156 }
 157
 158 /* Reset the device */
 159 int s5p_mfc_reset(struct s5p_mfc_dev *dev)
 160 {
 161         unsigned int mc_status;
 162         unsigned long timeout;
 163         int i;
 164
 165         mfc_debug_enter();
 166
 167         if (IS_MFCV6(dev)) {
 168                 /* Reset IP */
 169                 /*  except RISC, reset */
 170                 mfc_write(dev, 0xFEE, S5P_FIMV_MFC_RESET);
 171                 /*  reset release */
 172                 mfc_write(dev, 0x0, S5P_FIMV_MFC_RESET);
 173
 174                 /* Zero Initialization of MFC registers */
 175                 mfc_write(dev, 0, S5P_FIMV_RISC2HOST_CMD);
 176                 mfc_write(dev, 0, S5P_FIMV_HOST2RISC_CMD);
 177                 mfc_write(dev, 0, S5P_FIMV_FW_VERSION);
 178
 179                 for (i = 0; i < S5P_FIMV_REG_CLEAR_COUNT; i++)
 180                         mfc_write(dev, 0, S5P_FIMV_REG_CLEAR_BEGIN + (i*4));
 181
 182                 /* Reset */
 183                 mfc_write(dev, 0, S5P_FIMV_RISC_ON);
 184                 mfc_write(dev, 0x1FFF, S5P_FIMV_MFC_RESET);
 185                 mfc_write(dev, 0, S5P_FIMV_MFC_RESET);
 186         } else {
 187                 /* Stop procedure */
 188                 /*  reset RISC */
 189                 mfc_write(dev, 0x3f6, S5P_FIMV_SW_RESET);
 190                 /*  All reset except for MC */
 191                 mfc_write(dev, 0x3e2, S5P_FIMV_SW_RESET);
 192                 mdelay(10);
 193
 194                 timeout = jiffies + msecs_to_jiffies(MFC_BW_TIMEOUT);
 195                 /* Check MC status */
 196                 do {
 197                         if (time_after(jiffies, timeout)) {
 198                                 mfc_err("Timeout while resetting MFC\n");
 199                                 return -EIO;
 200                         }
 201
 202                         mc_status = mfc_read(dev, S5P_FIMV_MC_STATUS);
 203
 204                 } while (mc_status & 0x3);
 205
 206                 mfc_write(dev, 0x0, S5P_FIMV_SW_RESET);
 207                 mfc_write(dev, 0x3fe, S5P_FIMV_SW_RESET);
 208         }
 209
 210         mfc_debug_leave();
 211         return 0;
 212 }
 213
 214 static inline void s5p_mfc_init_memctrl(struct s5p_mfc_dev *dev)
 215 {
 216         if (IS_MFCV6(dev)) {
 217                 mfc_write(dev, dev->bank1, S5P_FIMV_RISC_BASE_ADDRESS);
 218                 mfc_debug(2, "Base Address : %08x\n", dev->bank1);
 219         } else {
 220                 mfc_write(dev, dev->bank1, S5P_FIMV_MC_DRAMBASE_ADR_A);
 221                 mfc_write(dev, dev->bank2, S5P_FIMV_MC_DRAMBASE_ADR_B);
 222                 mfc_debug(2, "Bank1: %08x, Bank2: %08x\n", dev->bank1, dev->bank2);
 223         }
 224 }
 225
 226 static inline void s5p_mfc_clear_cmds(struct s5p_mfc_dev *dev)
 227 {
 228         if (IS_MFCV6(dev)) {
 229                 /* Zero initialization should be done before RESET.
 230                  * Nothing to do here. */
 231         } else {
 232                 mfc_write(dev, 0xffffffff, S5P_FIMV_SI_CH0_INST_ID);
 233                 mfc_write(dev, 0xffffffff, S5P_FIMV_SI_CH1_INST_ID);
 234                 mfc_write(dev, 0, S5P_FIMV_RISC2HOST_CMD);
 235                 mfc_write(dev, 0, S5P_FIMV_HOST2RISC_CMD);
 236         }
 237 }
 238
 239 /* Initialize hardware */
 240 int s5p_mfc_init_hw(struct s5p_mfc_dev *dev)
 241 {
 242         unsigned int ver;
 243         int ret;
 244
 245         mfc_debug_enter();
 246         if (!s5p_mfc_bitproc_buf)
 247                 return -EINVAL;
 248
 249         /* 0. MFC reset */
 250         mfc_debug(2, "MFC reset..\n");
 251         s5p_mfc_clock_on();
 252         ret = s5p_mfc_reset(dev);
 253         if (ret) {
 254                 mfc_err("Failed to reset MFC - timeout\n");
 255                 return ret;
 256         }
 257         mfc_debug(2, "Done MFC reset..\n");
 258         /* 1. Set DRAM base Addr */
 259         s5p_mfc_init_memctrl(dev);
 260         /* 2. Initialize registers of channel I/F */
 261         s5p_mfc_clear_cmds(dev);
 262         /* 3. Release reset signal to the RISC */
 263         s5p_mfc_clean_dev_int_flags(dev);
 264         if (IS_MFCV6(dev))
 265                 mfc_write(dev, 0x1, S5P_FIMV_RISC_ON);
 266         else
 267                 mfc_write(dev, 0x3ff, S5P_FIMV_SW_RESET);
 268         mfc_debug(2, "Will now wait for completion of firmware transfer\n");
 269         if (s5p_mfc_wait_for_done_dev(dev, S5P_FIMV_R2H_CMD_FW_STATUS_RET)) {
 270                 mfc_err("Failed to load firmware\n");
 271                 s5p_mfc_reset(dev);
 272                 s5p_mfc_clock_off();
 273                 return -EIO;
 274         }
 275         s5p_mfc_clean_dev_int_flags(dev);
 276         /* 4. Initialize firmware */
 277         ret = s5p_mfc_sys_init_cmd(dev);
 278         if (ret) {
 279                 mfc_err("Failed to send command to MFC - timeout\n");
 280                 s5p_mfc_reset(dev);
 281                 s5p_mfc_clock_off();
 282                 return ret;
 283         }
 284         mfc_debug(2, "Ok, now will write a command to init the system\n");
 285         if (s5p_mfc_wait_for_done_dev(dev, S5P_FIMV_R2H_CMD_SYS_INIT_RET)) {
 286                 mfc_err("Failed to load firmware\n");
 287                 s5p_mfc_reset(dev);
 288                 s5p_mfc_clock_off();
 289                 return -EIO;
 290         }
 291         dev->int_cond = 0;
 292         if (dev->int_err != 0 || dev->int_type !=
 293                                         S5P_FIMV_R2H_CMD_SYS_INIT_RET) {
 294                 /* Failure. */
 295                 mfc_err("Failed to init firmware - error: %d int: %d\n",
 296                                                 dev->int_err, dev->int_type);
 297                 s5p_mfc_reset(dev);
 298                 s5p_mfc_clock_off();
 299                 return -EIO;
 300         }
 301         ver = mfc_read(dev, S5P_FIMV_FW_VERSION);
 302         mfc_debug(2, "MFC F/W version : %02xyy, %02xmm, %02xdd\n",
 303                 (ver >> 16) & 0xFF, (ver >> 8) & 0xFF, ver & 0xFF);
 304         s5p_mfc_clock_off();
 305         mfc_debug_leave();
 306         return 0;
 307 }
 308
 309
 310 /* Deinitialize hardware */
 311 void s5p_mfc_deinit_hw(struct s5p_mfc_dev *dev)
 312 {
 313         s5p_mfc_clock_on();
 314
 315         s5p_mfc_reset(dev);
 316         if (IS_MFCV6(dev))
 317                 s5p_mfc_release_dev_context_buffer(dev);
 318
 319         s5p_mfc_clock_off();
 320 }
 321
 322 int s5p_mfc_sleep(struct s5p_mfc_dev *dev)
 323 {
 324         int ret;
 325
 326         mfc_debug_enter();
 327         s5p_mfc_clock_on();
 328         s5p_mfc_clean_dev_int_flags(dev);
 329         ret = s5p_mfc_sleep_cmd(dev);
 330         if (ret) {
 331                 mfc_err("Failed to send command to MFC - timeout\n");
 332                 return ret;
 333         }
 334         if (s5p_mfc_wait_for_done_dev(dev, S5P_FIMV_R2H_CMD_SLEEP_RET)) {
 335                 mfc_err("Failed to sleep\n");
 336                 return -EIO;
 337         }
 338         s5p_mfc_clock_off();
 339         dev->int_cond = 0;
 340         if (dev->int_err != 0 || dev->int_type !=
 341                                                 S5P_FIMV_R2H_CMD_SLEEP_RET) {
 342                 /* Failure. */
 343                 mfc_err("Failed to sleep - error: %d int: %d\n", dev->int_err,
 344                                                                 dev->int_type);
 345                 return -EIO;
 346         }
 347         mfc_debug_leave();
 348         return ret;
 349 }
 350
 351 int s5p_mfc_wakeup(struct s5p_mfc_dev *dev)
 352 {
 353         int ret;
 354
 355         mfc_debug_enter();
 356         /* 0. MFC reset */
 357         mfc_debug(2, "MFC reset..\n");
 358         s5p_mfc_clock_on();
 359         ret = s5p_mfc_reset(dev);
 360         if (ret) {
 361                 mfc_err("Failed to reset MFC - timeout\n");
 362                 return ret;
 363         }
 364         mfc_debug(2, "Done MFC reset..\n");
 365         /* 1. Set DRAM base Addr */
 366         s5p_mfc_init_memctrl(dev);
 367         /* 2. Initialize registers of channel I/F */
 368         s5p_mfc_clear_cmds(dev);
 369         s5p_mfc_clean_dev_int_flags(dev);
 370         /* 3. Initialize firmware */
 371         ret = s5p_mfc_wakeup_cmd(dev);
 372         if (ret) {
 373                 mfc_err("Failed to send command to MFC - timeout\n");
 374                 return ret;
 375         }
 376         /* 4. Release reset signal to the RISC */
 377         if (IS_MFCV6(dev))
 378                 mfc_write(dev, 0x1, S5P_FIMV_RISC_ON);
 379         else
 380                 mfc_write(dev, 0x3ff, S5P_FIMV_SW_RESET);
 381         mfc_debug(2, "Ok, now will write a command to wakeup the system\n");
 382         if (s5p_mfc_wait_for_done_dev(dev, S5P_FIMV_R2H_CMD_WAKEUP_RET)) {
 383                 mfc_err("Failed to load firmware\n");
 384                 return -EIO;
 385         }
 386         s5p_mfc_clock_off();
 387         dev->int_cond = 0;
 388         if (dev->int_err != 0 || dev->int_type !=
 389                                                 S5P_FIMV_R2H_CMD_WAKEUP_RET) {
 390                 /* Failure. */
 391                 mfc_err("Failed to wakeup - error: %d int: %d\n", dev->int_err,
 392                                                                 dev->int_type);
 393                 return -EIO;
 394         }
 395         mfc_debug_leave();
 396         return 0;
 397 }
 398