drivers/media/sprd_isp/isp2.0/sharkl/src/isp_k_bdn.c

   1 /*
   2  * Copyright (C) 2012 Spreadtrum Communications Inc.
   3  *
   4  * This software is licensed under the terms of the GNU General Public
   5  * License version 2, as published by the Free Software Foundation, and
   6  * may be copied, distributed, and modified under those terms.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <linux/uaccess.h>
  15 #include <linux/sprd_mm.h>
  16 #include <video/sprd_isp.h>
  17 #include "isp_reg.h"
  18
  19 #define DENOISE_DISWEI_NUM_MAX      256
  20 #define DENOISE_RANWEI_NUM_MAX      256
  21
  22 static const uint8_t diswei_tab[DENOISE_DISWEI_NUM_MAX][19] = {
  23 #include "denoise_diswei.h"
  24 };
  25
  26 static const uint8_t ranwei_tab[DENOISE_RANWEI_NUM_MAX][31] = {
  27 #include "denoise_ranwei.h"
  28 };
  29
  30 int32_t isp_k_bdn_block(struct isp_io_param *param)
  31 {
  32         int32_t ret = 0;
  33         uint32_t i = 0, val = 0, addr = 0;
  34         struct isp_dev_wavelet_denoise_info denoise_info;
  35
  36         memset(&denoise_info, 0x00, sizeof(denoise_info));
  37
  38         ret = copy_from_user((void *)&denoise_info, param->property_param, sizeof(denoise_info));
  39         if (0 != ret) {
  40                 printk("isp_k_wavelet_denoise_block: copy error, ret=0x%x\n", (uint32_t)ret);
  41                 return -1;
  42         }
  43
  44         if (DENOISE_DISWEI_NUM_MAX < denoise_info.diswei_level
  45                 || DENOISE_RANWEI_NUM_MAX < denoise_info.ranwei_level) {
  46                 printk("isp_k_wavelet_denoise_block: index error: %d %d\n",
  47                         denoise_info.diswei_level, denoise_info.ranwei_level);
  48                 return -1;
  49         }
  50
  51         addr = ISP_WAVE_DISWEI_0;
  52         for (i = 0; i < 16; i += 4) {
  53                 val = (diswei_tab[denoise_info.diswei_level][i + 3] << 24)
  54                         | (diswei_tab[denoise_info.diswei_level][i + 2] << 16)
  55                         | (diswei_tab[denoise_info.diswei_level][i + 1] << 8)
  56                         | diswei_tab[denoise_info.diswei_level][i];
  57                 REG_WR(addr, val);
  58                 addr += 4;
  59         }
  60         val = (diswei_tab[denoise_info.diswei_level][18] << 16)
  61                 | (diswei_tab[denoise_info.diswei_level][17] << 8)
  62                 | diswei_tab[denoise_info.diswei_level][16];
  63         REG_WR(ISP_WAVE_DISWEI_4, val);
  64
  65         addr = ISP_WAVE_RANWEI_0;
  66         for (i = 0; i < 28; i += 4) {
  67                 val = (ranwei_tab[denoise_info.ranwei_level][i + 3] << 24)
  68                         | (ranwei_tab[denoise_info.ranwei_level][i + 2] << 16)
  69                         | (ranwei_tab[denoise_info.ranwei_level][i + 1] << 8)
  70                         | ranwei_tab[denoise_info.ranwei_level][i];
  71                 REG_WR(addr, val);
  72                 addr += 4;
  73         }
  74         val = (ranwei_tab[denoise_info.ranwei_level][30] << 16)
  75                 | (ranwei_tab[denoise_info.ranwei_level][29] << 8)
  76                 | ranwei_tab[denoise_info.ranwei_level][28];
  77         REG_WR(ISP_WAVE_RANWEI_7, val);
  78
  79         if (denoise_info.bypass) {
  80                 REG_OWR(ISP_WAVE_PARAM, BIT_0);
  81         } else {
  82                 REG_MWR(ISP_WAVE_PARAM, BIT_0, 0);
  83         }
  84
  85         return ret;
  86 }
  87
  88 static int32_t isp_k_bdn_bypass(struct isp_io_param *param)
  89 {
  90         int32_t ret = 0;
  91         uint32_t bypass = 0;
  92
  93         ret = copy_from_user((void *)&bypass, param->property_param, sizeof(bypass));
  94         if (0 != ret) {
  95                 printk("isp_k_wavelet_denoise_bypass: copy error, ret=0x%x\n", (uint32_t)ret);
  96                 return -1;
  97         }
  98
  99         if (bypass) {
 100                 REG_OWR(ISP_WAVE_PARAM, BIT_0);
 101         } else {
 102                 REG_MWR(ISP_WAVE_PARAM, BIT_0, 0);
 103         }
 104
 105         return ret;
 106 }
 107
 108 static int32_t isp_k_bdn_slice_size(struct isp_io_param *param)
 109 {
 110         int32_t ret = 0;
 111         uint32_t val = 0;
 112         struct isp_img_size size = {0, 0};
 113
 114         ret = copy_from_user((void *)&size, param->property_param, sizeof(size));
 115         if (0 != ret) {
 116                 printk("isp_k_wavelet_denoise_slice_size: copy error, ret=0x%x\n", (uint32_t)ret);
 117                 return -1;
 118         }
 119
 120         val = ((size.height & 0xFFFF) << 16) | (size.width & 0xFFFF);
 121         REG_WR(ISP_WAVE_SLICE_SIZE, val);
 122
 123         return ret;
 124 }
 125
 126 static int32_t isp_k_bdn_diswei(struct isp_io_param *param)
 127 {
 128         int32_t ret = 0;
 129         uint32_t i = 0, val = 0, addr = 0;
 130         uint32_t diswei_index = 0;
 131
 132         ret = copy_from_user((void *)&diswei_index, param->property_param, sizeof(diswei_index));
 133         if (0 != ret) {
 134                 printk("isp_k_wavelet_denoise_diswei: copy error, ret=0x%x\n", (uint32_t)ret);
 135                 return -1;
 136         }
 137
 138         if (DENOISE_DISWEI_NUM_MAX < diswei_index) {
 139                 printk("isp_k_wavelet_denoise_diswei: index error: %d\n", diswei_index);
 140                 return -1;
 141         }
 142
 143         addr = ISP_WAVE_DISWEI_0;
 144         for (i = 0; i < 16; i += 4) {
 145                 val = (diswei_tab[diswei_index][i + 3] << 24)
 146                         | (diswei_tab[diswei_index][i + 2] << 16)
 147                         | (diswei_tab[diswei_index][i + 1] << 8)
 148                         | diswei_tab[diswei_index][i];
 149                 REG_WR(addr, val);
 150                 addr += 4;
 151         }
 152         val = (diswei_tab[diswei_index][18] << 16)
 153                 | (diswei_tab[diswei_index][17] << 8)
 154                 | diswei_tab[diswei_index][16];
 155         REG_WR(ISP_WAVE_DISWEI_4, val);
 156
 157         return ret;
 158 }
 159
 160 static int32_t isp_k_bdn_ranwei(struct isp_io_param *param)
 161 {
 162         int32_t ret = 0;
 163         uint32_t i = 0, val = 0, addr = 0;
 164         uint32_t ranwei_index = 0;
 165
 166         ret = copy_from_user((void *)&ranwei_index, param->property_param, sizeof(ranwei_index));
 167         if (0 != ret) {
 168                 printk("isp_k_wavelet_denoise_ranwei: copy error, ret=0x%x\n", (uint32_t)ret);
 169                 return -1;
 170         }
 171
 172         if (DENOISE_RANWEI_NUM_MAX < ranwei_index) {
 173                 printk("isp_k_wavelet_denoise_ranwei: index error: %d\n", ranwei_index);
 174                 return -1;
 175         }
 176
 177         addr = ISP_WAVE_RANWEI_0;
 178         for (i = 0; i < 28; i += 4) {
 179                 val = (ranwei_tab[ranwei_index][i + 3] << 24)
 180                         | (ranwei_tab[ranwei_index][i + 2] << 16)
 181                         | (ranwei_tab[ranwei_index][i + 1] << 8)
 182                         | ranwei_tab[ranwei_index][i];
 183                 REG_WR(addr, val);
 184                 addr += 4;
 185         }
 186         val = (ranwei_tab[ranwei_index][30] << 16)
 187                 | (ranwei_tab[ranwei_index][29] << 8)
 188                 | ranwei_tab[ranwei_index][28];
 189         REG_WR(ISP_WAVE_RANWEI_7, val);
 190
 191         return ret;
 192 }
 193
 194 int32_t isp_k_cfg_bdn(struct isp_io_param *param)
 195 {
 196         int32_t ret = 0;
 197
 198         if (!param) {
 199                 printk("isp_k_cfg_bdn: param is null error.\n");
 200                 return -1;
 201         }
 202
 203         if (NULL == param->property_param) {
 204                 printk("isp_k_cfg_bdn: property_param is null error.\n");
 205                 return -1;
 206         }
 207
 208         switch(param->property) {
 209         case ISP_PRO_BDN_BLOCK:
 210                 ret = isp_k_bdn_block(param);
 211                 break;
 212         case ISP_PRO_BDN_BYPASS:
 213                 ret = isp_k_bdn_bypass(param);
 214                 break;
 215         case ISP_PRO_BDN_SLICE_SIZE:
 216                 ret = isp_k_bdn_slice_size(param);
 217                 break;
 218         case ISP_PRO_BDN_DISWEI:
 219                 ret = isp_k_bdn_diswei(param);
 220                 break;
 221         case ISP_PRO_BDN_RANWEI:
 222                 ret = isp_k_bdn_ranwei(param);
 223                 break;
 224         default:
 225                 printk("isp_k_cfg_bdn: fail cmd id:%d, not supported.\n", param->property);
 226                 break;
 227         }
 228
 229         return ret;
 230 }