| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * Support for Intel Camera Imaging ISP subsystem. |
| * Copyright (c) 2015, Intel Corporation. |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms and conditions of the GNU General Public License, |
| * version 2, as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| */ |
| |
| #include "hmm.h" |
| |
| #include "assert_support.h" |
| #include "ia_css_debug.h" |
| #include "ia_css_sdis_types.h" |
| #include "sdis/common/ia_css_sdis_common.host.h" |
| #include "ia_css_sdis.host.h" |
| |
| const struct ia_css_dvs_coefficients default_sdis_config = { |
| .grid = { 0, 0, 0, 0, 0, 0, 0, 0 }, |
| .hor_coefs = NULL, |
| .ver_coefs = NULL |
| }; |
| |
| static void |
| fill_row(short *private, const short *public, unsigned int width, |
| unsigned int padding) |
| { |
| assert((int)width >= 0); |
| assert((int)padding >= 0); |
| memcpy(private, public, width * sizeof(short)); |
| memset(&private[width], 0, padding * sizeof(short)); |
| } |
| |
| void ia_css_sdis_horicoef_vmem_encode( |
| struct sh_css_isp_sdis_hori_coef_tbl *to, |
| const struct ia_css_dvs_coefficients *from, |
| unsigned int size) |
| { |
| unsigned int aligned_width = from->grid.aligned_width * |
| from->grid.bqs_per_grid_cell; |
| unsigned int width = from->grid.num_hor_coefs; |
| int padding = aligned_width - width; |
| unsigned int stride = size / IA_CSS_DVS_NUM_COEF_TYPES / sizeof(short); |
| unsigned int total_bytes = aligned_width * IA_CSS_DVS_NUM_COEF_TYPES * sizeof( |
| short); |
| short *public = from->hor_coefs; |
| short *private = (short *)to; |
| unsigned int type; |
| |
| /* Copy the table, add padding */ |
| assert(padding >= 0); |
| assert(total_bytes <= size); |
| assert(size % (IA_CSS_DVS_NUM_COEF_TYPES * ISP_VEC_NELEMS * sizeof( |
| short)) == 0); |
| |
| for (type = 0; type < IA_CSS_DVS_NUM_COEF_TYPES; type++) { |
| fill_row(&private[type * stride], &public[type * width], width, padding); |
| } |
| } |
| |
| void ia_css_sdis_vertcoef_vmem_encode( |
| struct sh_css_isp_sdis_vert_coef_tbl *to, |
| const struct ia_css_dvs_coefficients *from, |
| unsigned int size) |
| { |
| unsigned int aligned_height = from->grid.aligned_height * |
| from->grid.bqs_per_grid_cell; |
| unsigned int height = from->grid.num_ver_coefs; |
| int padding = aligned_height - height; |
| unsigned int stride = size / IA_CSS_DVS_NUM_COEF_TYPES / sizeof(short); |
| unsigned int total_bytes = aligned_height * IA_CSS_DVS_NUM_COEF_TYPES * |
| sizeof(short); |
| short *public = from->ver_coefs; |
| short *private = (short *)to; |
| unsigned int type; |
| |
| /* Copy the table, add padding */ |
| assert(padding >= 0); |
| assert(total_bytes <= size); |
| assert(size % (IA_CSS_DVS_NUM_COEF_TYPES * ISP_VEC_NELEMS * sizeof( |
| short)) == 0); |
| |
| for (type = 0; type < IA_CSS_DVS_NUM_COEF_TYPES; type++) { |
| fill_row(&private[type * stride], &public[type * height], height, padding); |
| } |
| } |
| |
| void ia_css_sdis_horiproj_encode( |
| struct sh_css_isp_sdis_hori_proj_tbl *to, |
| const struct ia_css_dvs_coefficients *from, |
| unsigned int size) |
| { |
| (void)to; |
| (void)from; |
| (void)size; |
| } |
| |
| void ia_css_sdis_vertproj_encode( |
| struct sh_css_isp_sdis_vert_proj_tbl *to, |
| const struct ia_css_dvs_coefficients *from, |
| unsigned int size) |
| { |
| (void)to; |
| (void)from; |
| (void)size; |
| } |
| |
| void ia_css_get_isp_dis_coefficients( |
| struct ia_css_stream *stream, |
| short *horizontal_coefficients, |
| short *vertical_coefficients) |
| { |
| struct ia_css_isp_parameters *params; |
| unsigned int hor_num_isp, ver_num_isp; |
| unsigned int hor_num_3a, ver_num_3a; |
| int i; |
| struct ia_css_binary *dvs_binary; |
| |
| IA_CSS_ENTER("void"); |
| |
| assert(horizontal_coefficients); |
| assert(vertical_coefficients); |
| |
| params = stream->isp_params_configs; |
| |
| /* Only video pipe supports DVS */ |
| dvs_binary = ia_css_stream_get_dvs_binary(stream); |
| if (!dvs_binary) |
| return; |
| |
| hor_num_isp = dvs_binary->dis.coef.pad.width; |
| ver_num_isp = dvs_binary->dis.coef.pad.height; |
| hor_num_3a = dvs_binary->dis.coef.dim.width; |
| ver_num_3a = dvs_binary->dis.coef.dim.height; |
| |
| for (i = 0; i < IA_CSS_DVS_NUM_COEF_TYPES; i++) { |
| fill_row(&horizontal_coefficients[i * hor_num_isp], |
| ¶ms->dvs_coefs.hor_coefs[i * hor_num_3a], hor_num_3a, |
| hor_num_isp - hor_num_3a); |
| } |
| for (i = 0; i < SH_CSS_DIS_VER_NUM_COEF_TYPES(dvs_binary); i++) { |
| fill_row(&vertical_coefficients[i * ver_num_isp], |
| ¶ms->dvs_coefs.ver_coefs[i * ver_num_3a], ver_num_3a, |
| ver_num_isp - ver_num_3a); |
| } |
| |
| IA_CSS_LEAVE("void"); |
| } |
| |
| size_t |
| ia_css_sdis_hor_coef_tbl_bytes( |
| const struct ia_css_binary *binary) |
| { |
| if (binary->info->sp.pipeline.isp_pipe_version == 1) |
| return sizeof(short) * IA_CSS_DVS_NUM_COEF_TYPES * binary->dis.coef.pad.width; |
| else |
| return sizeof(short) * IA_CSS_DVS2_NUM_COEF_TYPES * binary->dis.coef.pad.width; |
| } |
| |
| size_t |
| ia_css_sdis_ver_coef_tbl_bytes( |
| const struct ia_css_binary *binary) |
| { |
| return sizeof(short) * SH_CSS_DIS_VER_NUM_COEF_TYPES(binary) * |
| binary->dis.coef.pad.height; |
| } |
| |
| void |
| ia_css_sdis_init_info( |
| struct ia_css_sdis_info *dis, |
| unsigned int sc_3a_dis_width, |
| unsigned int sc_3a_dis_padded_width, |
| unsigned int sc_3a_dis_height, |
| unsigned int isp_pipe_version, |
| unsigned int enabled) |
| { |
| if (!enabled) { |
| *dis = (struct ia_css_sdis_info) { }; |
| return; |
| } |
| |
| dis->deci_factor_log2 = SH_CSS_DIS_DECI_FACTOR_LOG2; |
| |
| dis->grid.dim.width = |
| _ISP_BQS(sc_3a_dis_width) >> SH_CSS_DIS_DECI_FACTOR_LOG2; |
| dis->grid.dim.height = |
| _ISP_BQS(sc_3a_dis_height) >> SH_CSS_DIS_DECI_FACTOR_LOG2; |
| dis->grid.pad.width = |
| CEIL_SHIFT(_ISP_BQS(sc_3a_dis_padded_width), SH_CSS_DIS_DECI_FACTOR_LOG2); |
| dis->grid.pad.height = |
| CEIL_SHIFT(_ISP_BQS(sc_3a_dis_height), SH_CSS_DIS_DECI_FACTOR_LOG2); |
| |
| dis->coef.dim.width = |
| (_ISP_BQS(sc_3a_dis_width) >> SH_CSS_DIS_DECI_FACTOR_LOG2) << |
| SH_CSS_DIS_DECI_FACTOR_LOG2; |
| dis->coef.dim.height = |
| (_ISP_BQS(sc_3a_dis_height) >> SH_CSS_DIS_DECI_FACTOR_LOG2) << |
| SH_CSS_DIS_DECI_FACTOR_LOG2; |
| dis->coef.pad.width = |
| __ISP_SDIS_HOR_COEF_NUM_VECS(sc_3a_dis_padded_width) * ISP_VEC_NELEMS; |
| dis->coef.pad.height = |
| __ISP_SDIS_VER_COEF_NUM_VECS(sc_3a_dis_height) * ISP_VEC_NELEMS; |
| if (isp_pipe_version == 1) { |
| dis->proj.dim.width = |
| _ISP_BQS(sc_3a_dis_height) >> SH_CSS_DIS_DECI_FACTOR_LOG2; |
| dis->proj.dim.height = |
| _ISP_BQS(sc_3a_dis_width) >> SH_CSS_DIS_DECI_FACTOR_LOG2; |
| } else { |
| dis->proj.dim.width = |
| (_ISP_BQS(sc_3a_dis_width) >> SH_CSS_DIS_DECI_FACTOR_LOG2) * |
| (_ISP_BQS(sc_3a_dis_height) >> SH_CSS_DIS_DECI_FACTOR_LOG2); |
| dis->proj.dim.height = |
| (_ISP_BQS(sc_3a_dis_width) >> SH_CSS_DIS_DECI_FACTOR_LOG2) * |
| (_ISP_BQS(sc_3a_dis_height) >> SH_CSS_DIS_DECI_FACTOR_LOG2); |
| } |
| dis->proj.pad.width = |
| __ISP_SDIS_HOR_PROJ_NUM_ISP(sc_3a_dis_padded_width, |
| sc_3a_dis_height, |
| SH_CSS_DIS_DECI_FACTOR_LOG2, |
| isp_pipe_version); |
| dis->proj.pad.height = |
| __ISP_SDIS_VER_PROJ_NUM_ISP(sc_3a_dis_padded_width, |
| SH_CSS_DIS_DECI_FACTOR_LOG2); |
| } |
| |
| void ia_css_sdis_clear_coefficients( |
| struct ia_css_dvs_coefficients *dvs_coefs) |
| { |
| dvs_coefs->hor_coefs = NULL; |
| dvs_coefs->ver_coefs = NULL; |
| } |
| |
| int |
| ia_css_get_dvs_statistics( |
| struct ia_css_dvs_statistics *host_stats, |
| const struct ia_css_isp_dvs_statistics *isp_stats) { |
| struct ia_css_isp_dvs_statistics_map *map; |
| int ret = 0; |
| |
| IA_CSS_ENTER("host_stats=%p, isp_stats=%p", host_stats, isp_stats); |
| |
| assert(host_stats); |
| assert(isp_stats); |
| |
| map = ia_css_isp_dvs_statistics_map_allocate(isp_stats, NULL); |
| if (map) |
| { |
| hmm_load(isp_stats->data_ptr, map->data_ptr, isp_stats->size); |
| ia_css_translate_dvs_statistics(host_stats, map); |
| ia_css_isp_dvs_statistics_map_free(map); |
| } else |
| { |
| IA_CSS_ERROR("out of memory"); |
| ret = -ENOMEM; |
| } |
| |
| IA_CSS_LEAVE_ERR(ret); |
| return ret; |
| } |
| |
| void |
| ia_css_translate_dvs_statistics( |
| struct ia_css_dvs_statistics *host_stats, |
| const struct ia_css_isp_dvs_statistics_map *isp_stats) |
| { |
| unsigned int hor_num_isp, ver_num_isp, hor_num_dvs, ver_num_dvs, i; |
| s32 *hor_ptr_dvs, *ver_ptr_dvs, *hor_ptr_isp, *ver_ptr_isp; |
| |
| assert(host_stats); |
| assert(host_stats->hor_proj); |
| assert(host_stats->ver_proj); |
| assert(isp_stats); |
| assert(isp_stats->hor_proj); |
| assert(isp_stats->ver_proj); |
| |
| IA_CSS_ENTER("hproj=%p, vproj=%p, haddr=%p, vaddr=%p", |
| host_stats->hor_proj, host_stats->ver_proj, |
| isp_stats->hor_proj, isp_stats->ver_proj); |
| |
| hor_num_isp = host_stats->grid.aligned_height; |
| ver_num_isp = host_stats->grid.aligned_width; |
| hor_ptr_isp = isp_stats->hor_proj; |
| ver_ptr_isp = isp_stats->ver_proj; |
| hor_num_dvs = host_stats->grid.height; |
| ver_num_dvs = host_stats->grid.width; |
| hor_ptr_dvs = host_stats->hor_proj; |
| ver_ptr_dvs = host_stats->ver_proj; |
| |
| for (i = 0; i < IA_CSS_DVS_NUM_COEF_TYPES; i++) { |
| memcpy(hor_ptr_dvs, hor_ptr_isp, hor_num_dvs * sizeof(int32_t)); |
| hor_ptr_isp += hor_num_isp; |
| hor_ptr_dvs += hor_num_dvs; |
| |
| memcpy(ver_ptr_dvs, ver_ptr_isp, ver_num_dvs * sizeof(int32_t)); |
| ver_ptr_isp += ver_num_isp; |
| ver_ptr_dvs += ver_num_dvs; |
| } |
| |
| IA_CSS_LEAVE("void"); |
| } |
| |
| struct ia_css_isp_dvs_statistics * |
| ia_css_isp_dvs_statistics_allocate( |
| const struct ia_css_dvs_grid_info *grid) |
| { |
| struct ia_css_isp_dvs_statistics *me; |
| int hor_size, ver_size; |
| |
| assert(grid); |
| |
| IA_CSS_ENTER("grid=%p", grid); |
| |
| if (!grid->enable) |
| return NULL; |
| |
| me = kvcalloc(1, sizeof(*me), GFP_KERNEL); |
| if (!me) |
| goto err; |
| |
| hor_size = CEIL_MUL(sizeof(int) * IA_CSS_DVS_NUM_COEF_TYPES * |
| grid->aligned_height, |
| HIVE_ISP_DDR_WORD_BYTES); |
| ver_size = CEIL_MUL(sizeof(int) * IA_CSS_DVS_NUM_COEF_TYPES * |
| grid->aligned_width, |
| HIVE_ISP_DDR_WORD_BYTES); |
| |
| me->size = hor_size + ver_size; |
| me->data_ptr = hmm_alloc(me->size, HMM_BO_PRIVATE, 0, NULL, 0); |
| if (me->data_ptr == mmgr_NULL) |
| goto err; |
| me->hor_size = hor_size; |
| me->hor_proj = me->data_ptr; |
| me->ver_size = ver_size; |
| me->ver_proj = me->data_ptr + hor_size; |
| |
| IA_CSS_LEAVE("return=%p", me); |
| |
| return me; |
| err: |
| ia_css_isp_dvs_statistics_free(me); |
| |
| IA_CSS_LEAVE("return=%p", NULL); |
| |
| return NULL; |
| } |
| |
| struct ia_css_isp_dvs_statistics_map * |
| ia_css_isp_dvs_statistics_map_allocate( |
| const struct ia_css_isp_dvs_statistics *isp_stats, |
| void *data_ptr) |
| { |
| struct ia_css_isp_dvs_statistics_map *me; |
| /* Windows compiler does not like adding sizes to a void * |
| * so we use a local char * instead. */ |
| char *base_ptr; |
| |
| me = kvmalloc(sizeof(*me), GFP_KERNEL); |
| if (!me) { |
| IA_CSS_LOG("cannot allocate memory"); |
| goto err; |
| } |
| |
| me->data_ptr = data_ptr; |
| me->data_allocated = !data_ptr; |
| |
| if (!me->data_ptr) { |
| me->data_ptr = kvmalloc(isp_stats->size, GFP_KERNEL); |
| if (!me->data_ptr) { |
| IA_CSS_LOG("cannot allocate memory"); |
| goto err; |
| } |
| } |
| base_ptr = me->data_ptr; |
| |
| me->size = isp_stats->size; |
| /* GCC complains when we assign a char * to a void *, so these |
| * casts are necessary unfortunately. */ |
| me->hor_proj = (void *)base_ptr; |
| me->ver_proj = (void *)(base_ptr + isp_stats->hor_size); |
| |
| return me; |
| err: |
| if (me) |
| kvfree(me); |
| return NULL; |
| } |
| |
| void |
| ia_css_isp_dvs_statistics_map_free(struct ia_css_isp_dvs_statistics_map *me) |
| { |
| if (me) { |
| if (me->data_allocated) |
| kvfree(me->data_ptr); |
| kvfree(me); |
| } |
| } |
| |
| void |
| ia_css_isp_dvs_statistics_free(struct ia_css_isp_dvs_statistics *me) |
| { |
| if (me) { |
| hmm_free(me->data_ptr); |
| kvfree(me); |
| } |
| } |
| |
| void ia_css_sdis_horicoef_debug_dtrace( |
| const struct ia_css_dvs_coefficients *config, unsigned int level) |
| { |
| (void)config; |
| (void)level; |
| } |
| |
| void ia_css_sdis_vertcoef_debug_dtrace( |
| const struct ia_css_dvs_coefficients *config, unsigned int level) |
| { |
| (void)config; |
| (void)level; |
| } |
| |
| void ia_css_sdis_horiproj_debug_dtrace( |
| const struct ia_css_dvs_coefficients *config, unsigned int level) |
| { |
| (void)config; |
| (void)level; |
| } |
| |
| void ia_css_sdis_vertproj_debug_dtrace( |
| const struct ia_css_dvs_coefficients *config, unsigned int level) |
| { |
| (void)config; |
| (void)level; |
| } |