Google Git
Sign in
nest-open-source / manifest_repos / kernel / 38bda478e46f3b6ec246861d597470685679add1 / . / drivers / amlogic / media / vout / lcd / backlight / bl_ldim / ldim_debug.c
blob: d16f7b7b75137d54225714ff77db8444b07d9047 [file] [log] [blame]
// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
* Copyright (c) 2019 Amlogic, Inc. All rights reserved.
*/
#include <linux/version.h>
#include <linux/string.h>
#include <linux/io.h>
#include <linux/mm.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include <linux/major.h>
#include <linux/sched.h>
#include <linux/vmalloc.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/platform_device.h>
#include <linux/amlogic/media/vout/lcd/aml_ldim.h>
#include <linux/amlogic/media/vout/lcd/aml_bl.h>
#include <linux/amlogic/media/vout/lcd/ldim_fw.h>
#include "../../lcd_common.h"
#include "ldim_drv.h"
#include "ldim_reg.h"
#include <linux/amlogic/gki_module.h>
#define LDIM_DBG_REG_RW_MODE_NULL 0
#define LDIM_DBG_REG_RW_MODE_RN 1
#define LDIM_DBG_REG_RW_MODE_RS 2
#define LDIM_DBG_REG_RW_MODE_WM 3
#define LDIM_DBG_REG_RW_MODE_WN 4
#define LDIM_DBG_REG_RW_MODE_WS 5
#define LDIM_DBG_REG_RW_MODE_ERR 6
#define LDIM_DBG_REG_FLAG_VCBUS 0
#define LDIM_DBG_REG_FLAG_APBBUS 1
/* 1: unlocked, 0: locked, negative: locked, possible waiters */
static struct mutex ldim_dbg_mutex;
/*for dbg reg use*/
struct ldim_dbg_reg_s {
unsigned int rw_mode;
unsigned int bus_flag;
unsigned int addr;
unsigned int size;
};
#define LDIM_DBG_ATTR_CMD_NULL 0
#define LDIM_DBG_ATTR_CMD_RD 1
#define LDIM_DBG_ATTR_CMD_WR 2
#define LDIM_DBG_ATTR_CMD_ERR 3
#define LDIM_DBG_ATTR_MODE_SINGLE 0
#define LDIM_DBG_ATTR_MODE_BL_MATRIX 1
#define LDIM_DBG_ATTR_MODE_TEST_MATRIX 2
#define LDIM_DBG_ATTR_MODE_SEG_HIST 3
#define LDIM_DBG_ATTR_MODE_GLB_HIST 4
#define LDIM_DBG_ATTR_MODE_MAX_RGB 5
#define LDIM_DBG_ATTR_MODE_GAIN_LUT 6
#define LDIM_DBG_ATTR_MODE_MIN_GAIN_LUT 7
#define LDIM_DBG_ATTR_MODE_DTH_LUT 8
#define LDIM_DBG_ATTR_MODE_BL_DIM_CURVE 9
#define LDIM_DBG_ATTR_MODE_LD_WHIST 10
/*for dbg cmd use*/
struct ldim_dbg_attr_s {
unsigned int cmd;
unsigned int chip_type;
unsigned int mode;
unsigned int data;
};
static struct ldim_dbg_reg_s dbg_reg = {
.rw_mode = LDIM_DBG_REG_RW_MODE_NULL,
.bus_flag = LDIM_DBG_REG_FLAG_VCBUS,
.addr = 0,
.size = 0,
};
struct ldim_dbg_attr_s dbg_attr = {
.cmd = LDIM_DBG_ATTR_CMD_NULL,
.chip_type = LCD_CHIP_MAX,
.mode = LDIM_DBG_ATTR_MODE_SINGLE,
.data = 0,
};
static int ldim_debug_buf_save(char *path, unsigned char *save_buf,
unsigned int size)
{
struct file *filp = NULL;
loff_t pos = 0;
void *buf = NULL;
mm_segment_t old_fs = get_fs();
if (!save_buf) {
LDIMERR("%s: save_buf is null\n", __func__);
return -1;
}
if (size == 0) {
LDIMERR("%s: size is zero\n", __func__);
return -1;
}
set_fs(KERNEL_DS);
filp = filp_open(path, O_RDWR | O_CREAT, 0666);
if (IS_ERR(filp)) {
LDIMERR("%s: create %s error\n", __func__, path);
set_fs(old_fs);
return -1;
}
pos = 0;
buf = (void *)save_buf;
vfs_write(filp, buf, size, &pos);
vfs_fsync(filp, 0);
filp_close(filp, NULL);
set_fs(old_fs);
pr_info("debug file %s save finished\n", path);
return 0;
}
static void ldim_int_table_print(unsigned int n, unsigned int *table)
{
int i = 0, len;
char *buf;
if (!table) {
LDIMERR("table is null\n");
return;
}
len = n * 8 + 20;
buf = kcalloc(len, sizeof(char), GFP_KERNEL);
if (!buf)
return;
pr_info("table:\n");
len = 0;
for (i = 0; i < n; i++)
len += sprintf(buf + len, "\t%d", table[i]);
pr_info("%s\n", buf);
kfree(buf);
}
static void ldim_comp_gain_lut_print(int index)
{
int i, j, len;
char *buf;
len = 32 * 8 + 20;
buf = kcalloc(len, sizeof(char), GFP_KERNEL);
if (!buf)
return;
if (index == 0xff) {
pr_info("comp gain lut:\n");
for (i = 0; i < 16; i++) {
pr_info(" %d:\n", i);
len = 0;
for (j = 0; j < 32; j++) {
if (j == 16)
len += sprintf(buf + len, "\n");
len += sprintf(buf + len, "\t%d",
ld_remap_lut[i][j]);
}
pr_info("%s\n", buf);
}
} else if (index < 16) {
pr_info("comp gain lut %d:\n", index);
len = 0;
for (j = 0; j < 32; j++) {
if (j == 16)
len += sprintf(buf + len, "\n");
len += sprintf(buf + len, "\t%d",
ld_remap_lut[index][j]);
}
pr_info("%s\n", buf);
} else {
pr_info("comp gain lut invalid index %d\n", index);
}
pr_info("\n");
kfree(buf);
}
static void ldim_min_gain_lut_print(void)
{
int j, len;
unsigned int *table;
char *buf;
len = 64 * 8 + 20;
buf = kcalloc(len, sizeof(char), GFP_KERNEL);
if (!buf)
return;
pr_info("min_gain_lut:\n");
len = 0;
table = ldc_min_gain_lut;
for (j = 0; j < 64; j++) {
if (j == 16)
len += sprintf(buf + len, "\n");
len += sprintf(buf + len, " %d", table[j]);
}
pr_info("%s\n", buf);
pr_info("\n");
kfree(buf);
}
static void ldim_dither_lut_print(void)
{
int i, j, len;
char *buf;
len = 16 * 8 + 20;
buf = kcalloc(len, sizeof(char), GFP_KERNEL);
if (!buf)
return;
pr_info("dither_lut:\n");
for (i = 0; i < 32; i++) {
len = 0;
for (j = 0; j < 16; j++)
len += sprintf(buf + len, " %d", ldc_dither_lut[i][j]);
pr_info("%s\n", buf);
}
pr_info("\n");
kfree(buf);
}
static void ldim_dump_histgram(struct aml_ldim_driver_s *ldim_drv)
{
unsigned int i, j, k, n, len;
unsigned int *p = NULL;
char *buf;
n = 16 * 10 + 20;
buf = kcalloc(n, sizeof(char), GFP_KERNEL);
if (!buf)
return;
len = ldim_drv->conf->seg_row * ldim_drv->conf->seg_col * 16;
p = kcalloc(len, sizeof(unsigned int), GFP_KERNEL);
if (!p) {
kfree(buf);
return;
}
memcpy(p, ldim_drv->stts->hist_matrix, len * sizeof(unsigned int));
for (i = 0; i < ldim_drv->conf->seg_row; i++) {
pr_info("%s: row %d:\n", __func__, i);
for (j = 0; j < ldim_drv->conf->seg_col; j++) {
len = sprintf(buf, "col %d:\n", j);
for (k = 0; k < 16; k++) {
n = i * 16 * ldim_drv->conf->seg_col
+ j * 16 + k;
len += sprintf(buf + len,
"\t0x%x", *(p + n));
if (k == 7)
len += sprintf(buf + len, "\n");
}
pr_info("%s\n\n", buf);
}
}
kfree(buf);
kfree(p);
}
static void ldim_dump_histgram_t7(struct aml_ldim_driver_s *ldim_drv)
{
unsigned int i, j, k, n, size;
struct ldim_seg_hist_s *seg_hist = NULL;
char *buf;
n = 256 * 10 + 48;
buf = kcalloc(n, sizeof(char), GFP_KERNEL);
if (!buf)
return;
size = ldim_drv->conf->seg_col * ldim_drv->conf->seg_row;
seg_hist = kcalloc(size, sizeof(struct ldim_seg_hist_s), GFP_KERNEL);
if (!seg_hist)
goto ldim_dump_histgram_t7_err;
memcpy(seg_hist, ldim_drv->stts->seg_hist,
size * sizeof(struct ldim_seg_hist_s));
pr_info("%s: seg_hist:\n", __func__);
for (i = 0; i < ldim_drv->conf->seg_row; i++) {
pr_info("row[%d]:\n", i);
n = 0;
for (j = 0; j < ldim_drv->conf->seg_col; j++) {
k = i * ldim_drv->conf->seg_col + j;
n += sprintf(buf + n, " %6u %6u %6u %6u\n",
seg_hist[k].weight_avg,
seg_hist[k].weight_avg_95,
seg_hist[k].max_index,
seg_hist[k].min_index);
}
pr_info("%s\n", buf);
}
pr_info("\n");
kfree(seg_hist);
ldim_dump_histgram_t7_err:
kfree(buf);
}
static void ldim_dump_matrix_info_max_rgb(struct aml_ldim_driver_s *ldim_drv)
{
unsigned int i, j, n, len;
unsigned int *p = NULL;
char *buf;
n = ldim_drv->conf->seg_col * 30 + 20;
buf = kcalloc(n, sizeof(char), GFP_KERNEL);
if (!buf)
return;
len = ldim_drv->conf->seg_col * ldim_drv->conf->seg_row * 3;
p = kcalloc(len, sizeof(unsigned int), GFP_KERNEL);
if (!p) {
kfree(buf);
return;
}
memcpy(p, ldim_drv->stts->max_rgb, len * sizeof(unsigned int));
pr_info("%s max_rgb:\n", __func__);
for (i = 0; i < ldim_drv->conf->seg_row; i++) {
len = 0;
for (j = 0; j < ldim_drv->conf->seg_col; j++) {
n = i * ldim_drv->conf->seg_col + j;
len += sprintf(buf + len, "\t(R:%4d, G:%4d, B:%4d)",
p[n * 3],
p[n * 3 + 1],
p[n * 3 + 2]);
if ((j + 1) % 4 == 0)
len += sprintf(buf + len, "\n\n");
}
pr_info("%s\n\n", buf);
}
kfree(buf);
kfree(p);
}
static void ldim_dump_bl_matrix(struct aml_ldim_driver_s *ldim_drv)
{
unsigned int i, j, n, len;
unsigned int *local_buf = NULL;
unsigned int *spi_buf = NULL;
char *buf;
n = ldim_drv->conf->seg_col * 10 + 20;
buf = kcalloc(n, sizeof(char), GFP_KERNEL);
if (!buf)
return;
len = ldim_drv->conf->seg_row * ldim_drv->conf->seg_col;
local_buf = kcalloc(len, sizeof(unsigned int), GFP_KERNEL);
if (!local_buf) {
kfree(buf);
return;
}
spi_buf = kcalloc(len, sizeof(unsigned int), GFP_KERNEL);
if (!spi_buf) {
kfree(buf);
kfree(local_buf);
return;
}
memcpy(local_buf, &ldim_drv->local_bl_matrix[0],
len * sizeof(unsigned int));
memcpy(spi_buf, &ldim_drv->bl_matrix_cur[0],
len * sizeof(unsigned int));
pr_info("%s: (bl_matrix_dbg = %d)\n",
__func__, ldim_drv->fw->bl_matrix_dbg);
for (i = 0; i < ldim_drv->conf->seg_row; i++) {
len = 0;
for (j = 0; j < ldim_drv->conf->seg_col; j++) {
n = ldim_drv->conf->seg_col * i + j;
len += sprintf(buf + len, "\t%4d", local_buf[n]);
}
pr_info("%s\n", buf);
}
pr_info("current black_frm: %d, litgain: %d\n",
ldim_drv->fw->ctrl->black_frm,
ldim_drv->litgain);
pr_info("ldim_dev brightness transfer_matrix:\n");
for (i = 0; i < ldim_drv->conf->seg_row; i++) {
len = 0;
for (j = 0; j < ldim_drv->conf->seg_col; j++) {
n = ldim_drv->conf->seg_col * i + j;
len += sprintf(buf + len, "\t%4d", spi_buf[n]);
}
pr_info("%s\n", buf);
}
pr_info("\n");
kfree(buf);
kfree(local_buf);
kfree(spi_buf);
}
static void ldim_get_test_matrix_info(struct aml_ldim_driver_s *ldim_drv)
{
unsigned int i, n, len;
unsigned int *temp_buf = ldim_drv->test_matrix;
char *buf;
n = ldim_drv->conf->seg_col * ldim_drv->conf->seg_row;
len = n * 10 + 20;
buf = kcalloc(len, sizeof(char), GFP_KERNEL);
if (!buf)
return;
pr_info("%s:\n", __func__);
pr_info("ldim test_mode: %d, test_matrix:\n", ldim_drv->test_bl_en);
len = 0;
for (i = 1; i < n; i++)
len += sprintf(buf + len, "\t%4d", temp_buf[i]);
pr_info("%s\n", buf);
kfree(buf);
}
static void ldim_stts_data_dump(struct aml_ldim_driver_s *ldim_drv)
{
unsigned int i, j, k, m, n, hist_len, max_len;
unsigned int *p_hist = NULL, *p_max = NULL;
char *buf;
n = 16 * 20 + 20;
buf = kcalloc(n, sizeof(char), GFP_KERNEL);
if (!buf)
return;
hist_len = ldim_drv->conf->seg_row * ldim_drv->conf->seg_col * 16;
p_hist = kcalloc(hist_len, sizeof(unsigned int), GFP_KERNEL);
if (!p_hist)
goto ldim_stts_data_dump_exit_0;
max_len = ldim_drv->conf->seg_col * ldim_drv->conf->seg_row * 3;
p_max = kcalloc(max_len, sizeof(unsigned int), GFP_KERNEL);
if (!p_max)
goto ldim_stts_data_dump_exit_1;
memcpy(p_hist, ldim_drv->stts->hist_matrix,
hist_len * sizeof(unsigned int));
memcpy(p_max, ldim_drv->stts->max_rgb, max_len * sizeof(unsigned int));
pr_info("%s: hist data:\n", __func__);
for (i = 0; i < ldim_drv->conf->seg_row; i++) {
for (j = 0; j < ldim_drv->conf->seg_col; j++) {
n = 0;
m = (i * ldim_drv->conf->seg_col + j) * 16;
for (k = 0; k < 16; k++)
n += sprintf(buf + n, " 0x%x,", p_hist[m + k]);
pr_info("%s\n", buf);
}
pr_info("\n");
}
pr_info("\n%s: maxrgb data:\n", __func__);
for (i = 0; i < ldim_drv->conf->seg_row; i++) {
n = 0;
for (j = 0; j < ldim_drv->conf->seg_col; j++) {
m = (i * ldim_drv->conf->seg_col + j) * 3;
n += sprintf(buf + n, " %d, %d, %d,",
p_max[m], p_max[m + 1], p_max[m + 2]);
}
pr_info("%s\n", buf);
}
kfree(p_max);
ldim_stts_data_dump_exit_1:
kfree(p_hist);
ldim_stts_data_dump_exit_0:
kfree(buf);
}
static void ldim_stts_data_dump_t7(struct aml_ldim_driver_s *ldim_drv)
{
unsigned int i, j, k, n, size, glb_len;
unsigned int *glb_hist = NULL;
struct ldim_seg_hist_s *seg_hist = NULL;
unsigned int glb_sum, glb_cnt, glb_apl;
char *buf;
n = 80 * 20 + 20;
buf = kcalloc(n, sizeof(char), GFP_KERNEL);
if (!buf)
return;
glb_len = 64;
glb_hist = kcalloc(glb_len, sizeof(unsigned int), GFP_KERNEL);
if (!glb_hist)
goto ldim_stts_data_dump_t7_exit_0;
size = ldim_drv->conf->seg_col * ldim_drv->conf->seg_row;
seg_hist = kcalloc(size, sizeof(struct ldim_seg_hist_s), GFP_KERNEL);
if (!seg_hist)
goto ldim_stts_data_dump_t7_exit_1;
memcpy(glb_hist, ldim_drv->stts->global_hist,
glb_len * sizeof(unsigned int));
memcpy(seg_hist, ldim_drv->stts->seg_hist,
size * sizeof(struct ldim_seg_hist_s));
glb_sum = ldim_drv->stts->global_hist_sum;
glb_cnt = ldim_drv->stts->global_hist_cnt;
glb_apl = ldim_drv->stts->global_apl;
n = 0;
pr_info("%s: glb_hist:\n", __func__);
for (i = 0; i < glb_len; i++) {
n += sprintf(buf + n, " 0x%08x\n", glb_hist[i]);
if ((i + 1) % 8 == 0)
n += sprintf(buf + n, "\n");
}
pr_info("%s\n", buf);
pr_info("glb_hist sum=0x%x, cnt=0x%x, apl=%d\n\n",
glb_sum, glb_cnt, glb_apl);
pr_info("%s: seg_hist:\n", __func__);
for (i = 0; i < ldim_drv->conf->seg_row; i++) {
pr_info("row[%d]:\n", i);
n = 0;
for (j = 0; j < ldim_drv->conf->seg_col; j++) {
k = i * ldim_drv->conf->seg_col + j;
n += sprintf(buf + n, " %6u %6u %6u %6u\n",
seg_hist[k].weight_avg,
seg_hist[k].weight_avg_95,
seg_hist[k].max_index,
seg_hist[k].min_index);
}
pr_info("%s\n", buf);
}
pr_info("\n");
kfree(seg_hist);
ldim_stts_data_dump_t7_exit_1:
kfree(glb_hist);
ldim_stts_data_dump_t7_exit_0:
kfree(buf);
}
static int ldim_int_table_dbg_print(char *buf, unsigned int n,
unsigned int *table)
{
unsigned int i, len = 0;
len = sprintf(buf, "for_tool:");
for (i = 0; i < n; i++)
len += sprintf(buf + len, " %d", table[i]);
len += sprintf(buf + len, "\n");
return len;
}
static int ldim_gain_lut_dbg_line_print(char *buf, unsigned int index)
{
unsigned int j, k, len = 0;
unsigned int *table;
if (index >= 16)
return sprintf(buf, "invalid index: %d", index);
if (dbg_attr.chip_type == LCD_CHIP_T7 ||
dbg_attr.chip_type == LCD_CHIP_T3) {
k = 64;
table = ldc_gain_lut_array[index];
} else {
k = 32;
table = ld_remap_lut[index];
}
len = sprintf(buf, "for_tool: %d", k);
for (j = 0; j < k; j++)
len += sprintf(buf + len, " %d", table[j]);
len += sprintf(buf + len, "\n");
return len;
}
static int ldim_min_gain_lut_dbg_print(char *buf)
{
unsigned int j, len = 0;
unsigned int *table;
len = sprintf(buf, "for_tool:");
table = ldc_min_gain_lut;
for (j = 0; j < 64; j++)
len += sprintf(buf + len, " %d", table[j]);
len += sprintf(buf + len, "\n");
return len;
}
static void ldim_dither_lut_file_save(char *path)
{
unsigned int i, j, len;
char *buf;
len = 32 * 16 * 4 + 20;
buf = kcalloc(len, sizeof(char), GFP_KERNEL);
if (!buf)
return;
len = sprintf(buf, "for_tool: 32 16");
for (i = 0; i < 32; i++) {
for (j = 0; j < 16; j++)
len += sprintf(buf + len, " %d", ldc_dither_lut[i][j]);
}
len += sprintf(buf + len, "\n");
ldim_debug_buf_save(path, buf, len);
kfree(buf);
}
static void ldim_bl_matrix_file_save(struct aml_ldim_driver_s *ldim_drv,
char *path)
{
unsigned int i, n, len;
unsigned int *p = NULL;
char *buf;
len = ldim_drv->conf->seg_row * ldim_drv->conf->seg_col * 8 + 30;
buf = kcalloc(len, sizeof(char), GFP_KERNEL);
if (!buf)
return;
n = ldim_drv->conf->seg_row * ldim_drv->conf->seg_col;
p = kcalloc(n, sizeof(unsigned int), GFP_KERNEL);
if (!p) {
kfree(buf);
return;
}
memcpy(p, ldim_drv->local_bl_matrix, (n * sizeof(unsigned int)));
len = sprintf(buf, "for_tool: %d %d",
ldim_drv->conf->seg_row, ldim_drv->conf->seg_col);
for (i = 0; i < n; i++)
len += sprintf(buf + len, " %d", p[i]);
len += sprintf(buf + len, "\n");
ldim_debug_buf_save(path, buf, len);
kfree(buf);
kfree(p);
}
static void ldim_hist_file_save(struct aml_ldim_driver_s *ldim_drv, char *path)
{
unsigned int i, j, k, n, len, seg_row, seg_col;
unsigned int *p = NULL;
char *buf;
seg_row = ldim_drv->conf->seg_row;
seg_col = ldim_drv->conf->seg_col;
n = seg_row * seg_col * 16;
len = n * 10 + 30;
buf = kcalloc(len, sizeof(char), GFP_KERNEL);
if (!buf)
return;
p = kcalloc(n, sizeof(unsigned int), GFP_KERNEL);
if (!p) {
kfree(buf);
return;
}
memcpy(p, ldim_drv->stts->hist_matrix, n * sizeof(unsigned int));
len = sprintf(buf, "for_tool: %d 16", seg_row * seg_col);
for (i = 0; i < seg_row; i++) {
for (j = 0; j < seg_col; j++) {
for (k = 0; k < 16; k++) {
n = i * 16 * seg_col + j * 16 + k;
len += sprintf(buf + len, " 0x%x", *(p + n));
}
}
}
len += sprintf(buf + len, "\n");
ldim_debug_buf_save(path, buf, len);
kfree(buf);
kfree(p);
}
static void ldim_hist_file_save_t7(struct aml_ldim_driver_s *ldim_drv,
char *path)
{
unsigned int i, j, k, n, len;
struct ldim_seg_hist_s *p = NULL;
char *buf;
n = ldim_drv->conf->seg_row * ldim_drv->conf->seg_col;
len = n * 4 * 10 + 30;
buf = kcalloc(len, sizeof(char), GFP_KERNEL);
if (!buf)
return;
p = kcalloc(n, sizeof(*p), GFP_KERNEL);
if (!p) {
kfree(buf);
return;
}
memcpy(p, ldim_drv->stts->seg_hist, n * sizeof(struct ldim_seg_hist_s));
len = sprintf(buf, "for_tool: %d 4", n);
for (i = 0; i < ldim_drv->conf->seg_row; i++) {
for (j = 0; j < ldim_drv->conf->seg_col; j++) {
k = i * ldim_drv->conf->seg_col + j;
len += sprintf(buf + len, " 0x%x 0x%x 0x%x 0x%x",
p[k].weight_avg,
p[k].weight_avg_95,
p[k].max_index,
p[k].min_index);
}
}
len += sprintf(buf + len, "\n");
ldim_debug_buf_save(path, buf, len);
kfree(buf);
kfree(p);
}
static void ldim_max_rgb_file_save(struct aml_ldim_driver_s *ldim_drv,
char *path)
{
unsigned int i, j, n, len;
unsigned int *p = NULL;
char *buf;
n = ldim_drv->conf->seg_col * ldim_drv->conf->seg_row * 3 * 30 + 30;
buf = kcalloc(n, sizeof(char), GFP_KERNEL);
if (!buf)
return;
len = ldim_drv->conf->seg_col * ldim_drv->conf->seg_row * 3;
p = kcalloc(len, sizeof(unsigned int), GFP_KERNEL);
if (!p) {
kfree(buf);
return;
}
memcpy(p, ldim_drv->stts->max_rgb, len * sizeof(unsigned int));
len = sprintf(buf, "for_tool: %d 3",
ldim_drv->conf->seg_row * ldim_drv->conf->seg_col);
for (i = 0; i < ldim_drv->conf->seg_row; i++) {
for (j = 0; j < ldim_drv->conf->seg_col; j++) {
n = i * ldim_drv->conf->seg_col + j;
len += sprintf(buf + len, " %d %d %d",
p[n * 3], p[n * 3 + 1], p[n * 3 + 2]);
}
}
len += sprintf(buf + len, "\n");
ldim_debug_buf_save(path, buf, len);
kfree(buf);
kfree(p);
}
static void ldim_test_matrix_file_save(struct aml_ldim_driver_s *ldim_drv,
char *path)
{
unsigned int i, n, len;
unsigned int *p = ldim_drv->test_matrix;
char *buf;
n = ldim_drv->conf->seg_col * ldim_drv->conf->seg_row;
len = n * 10 + 30;
buf = kcalloc(len, sizeof(char), GFP_KERNEL);
if (!buf)
return;
len = sprintf(buf, "for_tool: %d %d",
ldim_drv->conf->seg_row, ldim_drv->conf->seg_col);
for (i = 0; i < n; i++)
len += sprintf(buf + len, " %d", p[i]);
len += sprintf(buf + len, "\n");
ldim_debug_buf_save(path, buf, len);
kfree(buf);
}
static ssize_t ldim_attr_show(struct class *cla, struct class_attribute *attr,
char *buf)
{
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
struct ldim_fw_s *fw;
ssize_t len = 0;
if (!ldim_drv->fw)
return sprintf(buf, "%s: error: fw is null\n", __func__);
mutex_lock(&ldim_dbg_mutex);
fw = ldim_drv->fw;
if (dbg_attr.cmd == LDIM_DBG_ATTR_CMD_NULL ||
dbg_attr.cmd == LDIM_DBG_ATTR_CMD_ERR) {
mutex_unlock(&ldim_dbg_mutex);
return sprintf(buf, "%s: error\n", __func__);
}
switch (dbg_attr.mode) {
case LDIM_DBG_ATTR_MODE_SINGLE:
len += sprintf(buf + len, "for_tool:%d\n", dbg_attr.data);
break;
case LDIM_DBG_ATTR_MODE_BL_MATRIX:
case LDIM_DBG_ATTR_MODE_TEST_MATRIX:
case LDIM_DBG_ATTR_MODE_SEG_HIST:
case LDIM_DBG_ATTR_MODE_MAX_RGB:
case LDIM_DBG_ATTR_MODE_DTH_LUT:
//none for temp file read lut
break;
case LDIM_DBG_ATTR_MODE_GLB_HIST:
len = ldim_int_table_dbg_print(buf, 64,
ldim_drv->stts->global_hist);
break;
case LDIM_DBG_ATTR_MODE_GAIN_LUT:
len = ldim_gain_lut_dbg_line_print(buf, dbg_attr.data);
break;
case LDIM_DBG_ATTR_MODE_MIN_GAIN_LUT:
len = ldim_min_gain_lut_dbg_print(buf);
break;
case LDIM_DBG_ATTR_MODE_BL_DIM_CURVE:
len = ldim_int_table_dbg_print(buf, 17,
fw->ctrl->bl_remap_curve);
break;
case LDIM_DBG_ATTR_MODE_LD_WHIST:
len = ldim_int_table_dbg_print(buf, 16,
fw->ctrl->fw_ld_whist);
break;
default:
len = sprintf(buf, "%s: error\n", __func__);
break;
}
mutex_unlock(&ldim_dbg_mutex);
return len;
}
static int ldim_attr_tuning_new(struct aml_ldim_driver_s *ldim_drv, char **parm)
{
struct ldc_prm_s *prm;
struct ldim_comp_s *comp;
unsigned int val;
int i, j, k;
prm = ldim_drv->fw->ctrl->prm_ldc;
comp = ldim_drv->comp;
if (!strcmp(parm[0], "fw_sel")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->fw->fw_sel;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
ldim_drv->fw->fw_sel = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->fw->fw_sel;
ldim_config_update_t7(ldim_drv);
}
pr_info("fw_sel = %d\n", ldim_drv->fw->fw_sel);
} else if (!strcmp(parm[0], "ldc_hist_mode")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_mode;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_hist_mode = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_mode;
}
pr_info("ldc_hist_mode = %d\n", prm->ldc_hist_mode);
} else if (!strcmp(parm[0], "ldc_hist_blend_mode")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_blend_mode;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_hist_blend_mode = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_blend_mode;
}
pr_info("ldc_hist_blend_mode = %d\n", prm->ldc_hist_blend_mode);
} else if (!strcmp(parm[0], "ldc_hist_blend_alpha")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_blend_alpha;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_hist_blend_alpha = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_blend_alpha;
}
pr_info("ldc_hist_blend_alpha = %d\n",
prm->ldc_hist_blend_alpha);
} else if (!strcmp(parm[0], "ldc_hist_adap_blend_max_gain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data =
prm->ldc_hist_adap_blend_max_gain;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_hist_adap_blend_max_gain = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_max_gain;
}
pr_info("ldc_hist_adap_blend_max_gain = %d\n",
prm->ldc_hist_adap_blend_max_gain);
} else if (!strcmp(parm[0], "ldc_hist_adap_blend_diff_th1")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data =
prm->ldc_hist_adap_blend_diff_th1;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_hist_adap_blend_diff_th1 = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_diff_th1;
}
pr_info("ldc_hist_adap_blend_diff_th1 = %d\n",
prm->ldc_hist_adap_blend_diff_th1);
} else if (!strcmp(parm[0], "ldc_hist_adap_blend_diff_th2")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data =
prm->ldc_hist_adap_blend_diff_th2;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_hist_adap_blend_diff_th2 = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_diff_th2;
}
pr_info("ldc_hist_adap_blend_diff_th2 = %d\n",
prm->ldc_hist_adap_blend_diff_th2);
} else if (!strcmp(parm[0], "ldc_hist_adap_blend_th0")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_th0;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_hist_adap_blend_th0 = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_th0;
}
pr_info("ldc_hist_adap_blend_th0 = %d\n",
prm->ldc_hist_adap_blend_th0);
} else if (!strcmp(parm[0], "ldc_hist_adap_blend_thn")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_thn;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_hist_adap_blend_thn = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_thn;
}
pr_info("ldc_hist_adap_blend_thn = %d\n",
prm->ldc_hist_adap_blend_thn);
} else if (!strcmp(parm[0], "ldc_hist_adap_blend_gain_0")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_gain_0;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_hist_adap_blend_gain_0 = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_gain_0;
}
pr_info("ldc_hist_adap_blend_gain_0 = %d\n",
prm->ldc_hist_adap_blend_gain_0);
} else if (!strcmp(parm[0], "ldc_hist_adap_blend_gain_1")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_gain_1;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_hist_adap_blend_gain_1 = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_hist_adap_blend_gain_1;
}
pr_info("ldc_hist_adap_blend_gain_1 = %d\n",
prm->ldc_hist_adap_blend_gain_1);
} else if (!strcmp(parm[0], "ldc_init_bl_min")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_init_bl_min;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_init_bl_min = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_init_bl_min;
}
pr_info("ldc_init_bl_min = %d\n", prm->ldc_init_bl_min);
} else if (!strcmp(parm[0], "ldc_init_bl_max")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_init_bl_max;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_init_bl_max = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_init_bl_max;
}
pr_info("ldc_init_bl_max = %d\n", prm->ldc_init_bl_max);
} else if (!strcmp(parm[0], "ldc_dimming_curve_en")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_dimming_curve_en;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_dimming_curve_en = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_dimming_curve_en;
}
pr_info("ldc_dimming_curve_en = %d\n",
prm->ldc_dimming_curve_en);
} else if (!strcmp(parm[0], "ldc_sf_mode")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sf_mode;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_sf_mode = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sf_mode;
}
pr_info("ldc_sf_mode = %d\n", prm->ldc_sf_mode);
} else if (!strcmp(parm[0], "ldc_sf_gain_up")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sf_gain_up;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_sf_gain_up = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sf_gain_up;
}
pr_info("ldc_sf_gain_up = %d\n", prm->ldc_sf_gain_up);
} else if (!strcmp(parm[0], "ldc_sf_gain_dn")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sf_gain_dn;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_sf_gain_dn = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sf_gain_dn;
}
pr_info("ldc_sf_gain_dn = %d\n", prm->ldc_sf_gain_dn);
} else if (!strcmp(parm[0], "ldc_sf_tsf_3x3")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sf_tsf_3x3;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_sf_tsf_3x3 = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sf_tsf_3x3;
}
pr_info("ldc_sf_tsf_3x3 = %d\n", prm->ldc_sf_tsf_3x3);
} else if (!strcmp(parm[0], "ldc_sf_tsf_5x5")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sf_tsf_5x5;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_sf_tsf_5x5 = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sf_tsf_5x5;
}
pr_info("ldc_sf_tsf_5x5 = %d\n", prm->ldc_sf_tsf_5x5);
} else if (!strcmp(parm[0], "ldc_bs_bl_mode")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_bl_mode;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_bs_bl_mode = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_bl_mode;
}
pr_info("ldc_bs_bl_mode = %d\n", prm->ldc_bs_bl_mode);
} else if (!strcmp(parm[0], "ldc_glb_apl")) { //read only
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_glb_apl;
goto ldim_attr_tuning_new_end;
}
goto ldim_attr_tuning_new_err;
}
pr_info("ldc_glb_apl = %d\n", prm->ldc_glb_apl);
} else if (!strcmp(parm[0], "ldc_bs_glb_apl_gain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_glb_apl_gain;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_bs_glb_apl_gain = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_glb_apl_gain;
}
pr_info("ldc_bs_glb_apl_gain = %d\n", prm->ldc_bs_glb_apl_gain);
} else if (!strcmp(parm[0], "ldc_bs_dark_scene_bl_th")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_dark_scene_bl_th;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_bs_dark_scene_bl_th = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_dark_scene_bl_th;
}
pr_info("ldc_bs_dark_scene_bl_th = %d\n",
prm->ldc_bs_dark_scene_bl_th);
} else if (!strcmp(parm[0], "ldc_bs_gain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_gain;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_bs_gain = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_gain;
}
pr_info("ldc_bs_gain = %d\n", prm->ldc_bs_gain);
} else if (!strcmp(parm[0], "ldc_bs_limit_gain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_limit_gain;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_bs_limit_gain = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_limit_gain;
}
pr_info("ldc_bs_limit_gain = %d\n", prm->ldc_bs_limit_gain);
} else if (!strcmp(parm[0], "ldc_bs_loc_apl_gain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_loc_apl_gain;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_bs_loc_apl_gain = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_loc_apl_gain;
}
pr_info("ldc_bs_loc_apl_gain = %d\n", prm->ldc_bs_loc_apl_gain);
} else if (!strcmp(parm[0], "ldc_bs_loc_max_min_gain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_loc_max_min_gain;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_bs_loc_max_min_gain = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_loc_max_min_gain;
}
pr_info("ldc_bs_loc_max_min_gain = %d\n",
prm->ldc_bs_loc_max_min_gain);
} else if (!strcmp(parm[0], "ldc_bs_loc_dark_scene_bl_th")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data =
prm->ldc_bs_loc_dark_scene_bl_th;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_bs_loc_dark_scene_bl_th = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_bs_loc_dark_scene_bl_th;
}
pr_info("ldc_bs_loc_dark_scene_bl_th = %d\n",
prm->ldc_bs_loc_dark_scene_bl_th);
} else if (!strcmp(parm[0], "ldc_tf_en")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_en;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_tf_en = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_en;
}
pr_info("ldc_tf_en = %d\n", prm->ldc_tf_en);
} else if (!strcmp(parm[0], "ldc_tf_sc_flag")) { //read only
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_sc_flag;
goto ldim_attr_tuning_new_end;
}
goto ldim_attr_tuning_new_err;
}
pr_info("ldc_tf_sc_flag = %d\n", prm->ldc_tf_sc_flag);
} else if (!strcmp(parm[0], "ldc_tf_low_alpha")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_low_alpha;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_tf_low_alpha = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_low_alpha;
}
pr_info("ldc_tf_low_alpha = %d\n", prm->ldc_tf_low_alpha);
} else if (!strcmp(parm[0], "ldc_tf_high_alpha")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_high_alpha;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_tf_high_alpha = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_high_alpha;
}
pr_info("ldc_tf_high_alpha = %d\n", prm->ldc_tf_high_alpha);
} else if (!strcmp(parm[0], "ldc_tf_low_alpha_sc")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_low_alpha_sc;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_tf_low_alpha_sc = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_low_alpha_sc;
}
pr_info("ldc_tf_low_alpha_sc = %d\n", prm->ldc_tf_low_alpha_sc);
} else if (!strcmp(parm[0], "ldc_tf_high_alpha_sc")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_high_alpha_sc;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_tf_high_alpha_sc = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_tf_high_alpha_sc;
}
pr_info("ldc_tf_high_alpha_sc = %d\n",
prm->ldc_tf_high_alpha_sc);
} else if (!strcmp(parm[0], "ldc_sc_hist_diff_th")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sc_hist_diff_th;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_sc_hist_diff_th = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sc_hist_diff_th;
}
pr_info("ldc_sc_hist_diff_th = %d\n",
prm->ldc_sc_hist_diff_th);
} else if (!strcmp(parm[0], "ldc_sc_apl_diff_th")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sc_apl_diff_th;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
prm->ldc_sc_apl_diff_th = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = prm->ldc_sc_apl_diff_th;
}
pr_info("ldc_sc_apl_diff_th = %d\n",
prm->ldc_sc_apl_diff_th);
} else if (!strcmp(parm[0], "ldc_bl_buf_diff")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = comp->ldc_bl_buf_diff;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
comp->ldc_bl_buf_diff = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = comp->ldc_bl_buf_diff;
ldim_config_update_t7(ldim_drv);
}
pr_info("ldc_bl_buf_diff = %d\n", comp->ldc_bl_buf_diff);
} else if (!strcmp(parm[0], "ldc_glb_gain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = comp->ldc_glb_gain;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
comp->ldc_glb_gain = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = comp->ldc_glb_gain;
ldim_config_update_t7(ldim_drv);
}
pr_info("ldc_glb_gain = %d\n", comp->ldc_glb_gain);
} else if (!strcmp(parm[0], "ldc_dth_en")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = comp->ldc_dth_en;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
comp->ldc_dth_en = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = comp->ldc_dth_en;
ldim_config_update_t7(ldim_drv);
}
pr_info("ldc_dth_en = %d\n", comp->ldc_dth_en);
} else if (!strcmp(parm[0], "ldc_dth_bw")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = comp->ldc_dth_bw;
goto ldim_attr_tuning_new_end;
}
if (kstrtouint(parm[1], 10, &val) < 0)
goto ldim_attr_tuning_new_err;
comp->ldc_dth_bw = val;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = comp->ldc_dth_bw;
ldim_config_update_t7(ldim_drv);
}
pr_info("ldc_dth_bw = %d\n", comp->ldc_dth_bw);
} else if (!strcmp(parm[0], "glb_hist")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_GLB_HIST;
goto ldim_attr_tuning_new_end;
}
goto ldim_attr_tuning_new_err;
}
ldim_int_table_print(64, ldim_drv->stts->global_hist);
} else if (!strcmp(parm[0], "min_gain_lut")) {
if (!parm[1]) {
ldim_min_gain_lut_print();
goto ldim_attr_tuning_new_end;
}
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_MIN_GAIN_LUT;
goto ldim_attr_tuning_new_end;
}
if (!strcmp(parm[1], "w")) {
if (parm[65]) {
for (j = 0; j < 64; j++) {
if (kstrtouint(parm[j + 2], 10,
&val) < 0)
goto ldim_attr_tuning_new_err;
ldc_min_gain_lut[j] = val;
}
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_MIN_GAIN_LUT;
ldc_min_gain_lut_set();
}
goto ldim_attr_tuning_new_end;
}
if (parm[64]) {
for (j = 0; j < 64; j++) {
if (kstrtouint(parm[j + 1], 10,
&ldc_min_gain_lut[j]) < 0)
goto ldim_attr_tuning_new_err;
}
ldc_min_gain_lut_set();
}
goto ldim_attr_tuning_new_err;
} else if (!strcmp(parm[0], "dither_lut")) {
if (!parm[1]) {
ldim_dither_lut_print();
goto ldim_attr_tuning_new_end;
}
if (!strcmp(parm[1], "rf")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_DTH_LUT;
ldim_dither_lut_file_save(parm[2]);
goto ldim_attr_tuning_new_end;
}
if (!strcmp(parm[1], "w")) {
if (!parm[512 + 3])
goto ldim_attr_tuning_new_err;
if (kstrtouint(parm[2], 10, &i) < 0)
goto ldim_attr_tuning_new_err;
if (kstrtouint(parm[3], 10, &j) < 0)
goto ldim_attr_tuning_new_err;
if (i != 32 || j != 16)
goto ldim_attr_tuning_new_err;
for (i = 0; i < 32; i++) {
for (j = 0; j < 16; j++) {
k = i * 16 + j;
if (kstrtouint(parm[k + 4], 10,
&val) < 0)
goto ldim_attr_tuning_new_err;
ldc_dither_lut[i][j] = val;
}
}
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_DTH_LUT;
ldc_dither_lut_set();
goto ldim_attr_tuning_new_end;
}
goto ldim_attr_tuning_new_err;
} else {
goto ldim_attr_tuning_new_err;
}
ldim_attr_tuning_new_end:
return 0;
ldim_attr_tuning_new_err:
return -1;
}
static ssize_t ldim_attr_store(struct class *cla, struct class_attribute *attr,
const char *buf, size_t len)
{
struct aml_bl_drv_s *bdrv = aml_bl_get_driver(0);
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
struct ldim_fw_s *fw = ldim_drv->fw;
struct ldim_fw_custom_s *fw_cus_pre = aml_ldim_get_fw_cus_pre();
struct ldim_fw_custom_s *fw_cus_post = aml_ldim_get_fw_cus_post();
struct fw_ctrl_s *fw_ctrl;
struct ld_reg_s *nprm;
unsigned int n = 0;
char *buf_orig, *ps, *token;
char **parm = NULL;
char str[3] = {' ', '\n', '\0'};
unsigned int seg_size;
int i, j, k;
unsigned int *table;
int ret;
unsigned int seg_row = 0, seg_col = 0;
unsigned int blk_mode = 0, ldim_bl_en = 0, hvcnt_bypass = 0;
unsigned long val1 = 0;
if (!fw)
return len;
if (!fw->ctrl)
return len;
fw_ctrl = fw->ctrl;
nprm = fw_ctrl->nprm;
if (!buf)
return len;
mutex_lock(&ldim_dbg_mutex);
buf_orig = kstrdup(buf, GFP_KERNEL);
if (!buf_orig) {
mutex_unlock(&ldim_dbg_mutex);
return len;
}
parm = kcalloc(640, sizeof(char *), GFP_KERNEL);
if (!parm) {
kfree(buf_orig);
mutex_unlock(&ldim_dbg_mutex);
return len;
}
ps = buf_orig;
while (1) {
token = strsep(&ps, str);
if (!token)
break;
if (*token == '\0')
continue;
parm[n++] = token;
}
dbg_attr.chip_type = bdrv->data->chip_type;
seg_size = ldim_drv->conf->seg_row * ldim_drv->conf->seg_col;
if (bdrv->data->chip_type == LCD_CHIP_T7 ||
bdrv->data->chip_type == LCD_CHIP_T3) {
ret = ldim_attr_tuning_new(ldim_drv, parm);
if (ret == 0)
goto ldim_attr_store_end;
}
if (!strcmp(parm[0], "hist")) {
if (parm[2]) {
if (!strcmp(parm[1], "rf")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SEG_HIST;
if (dbg_attr.chip_type == LCD_CHIP_T7 ||
dbg_attr.chip_type == LCD_CHIP_T3) {
ldim_hist_file_save_t7(ldim_drv,
parm[2]);
} else {
ldim_hist_file_save(ldim_drv, parm[2]);
}
goto ldim_attr_store_end;
}
goto ldim_attr_store_err;
}
if (dbg_attr.chip_type == LCD_CHIP_T7 ||
dbg_attr.chip_type == LCD_CHIP_T3)
ldim_dump_histgram_t7(ldim_drv);
else
ldim_dump_histgram(ldim_drv);
} else if (!strcmp(parm[0], "maxrgb")) {
if (dbg_attr.chip_type == LCD_CHIP_T7 ||
dbg_attr.chip_type == LCD_CHIP_T3)
goto ldim_attr_store_end;
if (parm[2]) {
if (!strcmp(parm[1], "rf")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_MAX_RGB;
ldim_max_rgb_file_save(ldim_drv, parm[2]);
goto ldim_attr_store_end;
}
goto ldim_attr_store_err;
}
ldim_dump_matrix_info_max_rgb(ldim_drv);
} else if (!strcmp(parm[0], "stts")) {
if (dbg_attr.chip_type == LCD_CHIP_T7 ||
dbg_attr.chip_type == LCD_CHIP_T3)
ldim_stts_data_dump_t7(ldim_drv);
else
ldim_stts_data_dump(ldim_drv);
} else if (!strcmp(parm[0], "matrix")) {
if (parm[2]) {
if (!strcmp(parm[1], "rf")) {
ldim_bl_matrix_file_save(ldim_drv, parm[2]);
goto ldim_attr_store_end;
}
goto ldim_attr_store_err;
}
ldim_dump_bl_matrix(ldim_drv);
} else if (!strcmp(parm[0], "bl_matrix_dbg")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = fw->bl_matrix_dbg;
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &fw->bl_matrix_dbg) < 0)
goto ldim_attr_store_err;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = fw->bl_matrix_dbg;
}
pr_info("fw bl_matrix_dbg: %d\n", fw->bl_matrix_dbg);
} else if (!strcmp(parm[0], "db_load")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", ldim_drv->load_db_en);
goto ldim_attr_store_end;
}
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->load_db_en = val1 ? 1 : 0;
}
pr_info("fw para load db: %d\n", ldim_drv->load_db_en);
} else if (!strcmp(parm[0], "db_print")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n",
ldim_drv->db_print_flag);
goto ldim_attr_store_end;
}
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->db_print_flag = val1 ? 1 : 0;
}
pr_info("db_print_flag: %d\n", ldim_drv->db_print_flag);
} else if (!strcmp(parm[0], "remap_init")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d %d %d %d %d\n",
ldim_drv->conf->seg_row,
ldim_drv->conf->seg_col,
ldim_drv->conf->bl_mode,
ldim_drv->conf->func_en,
ldim_drv->conf->hvcnt_bypass);
goto ldim_attr_store_end;
}
}
if (parm[5]) {
if (kstrtouint(parm[1], 10, &seg_row) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[2], 10, &seg_col) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[3], 10, &blk_mode) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[4], 10, &ldim_bl_en) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[5], 10, &hvcnt_bypass) < 0)
goto ldim_attr_store_err;
ldim_drv->conf->seg_row = (unsigned char)seg_row;
ldim_drv->conf->seg_col = (unsigned char)seg_col;
ldim_drv->conf->bl_mode = (unsigned char)blk_mode;
ldim_drv->conf->func_en = (unsigned char)ldim_bl_en;
ldim_drv->conf->hvcnt_bypass = (unsigned char)hvcnt_bypass;
if (ldim_drv->data->drv_init)
ldim_drv->data->drv_init(ldim_drv);
pr_info("**************ldim init ok*************\n");
}
pr_info("remap_init param: %d %d %d %d %d\n",
ldim_drv->conf->seg_row, ldim_drv->conf->seg_col,
ldim_drv->conf->bl_mode,
ldim_drv->conf->func_en,
ldim_drv->conf->hvcnt_bypass);
} else if (!strcmp(parm[0], "ldim_stts_init")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d %d\n",
ldim_drv->conf->seg_row,
ldim_drv->conf->seg_col);
goto ldim_attr_store_end;
}
}
if (parm[2]) {
if (kstrtouint(parm[1], 10, &seg_row) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[2], 10, &seg_col) < 0)
goto ldim_attr_store_err;
ldim_drv->conf->seg_row = (unsigned char)seg_row;
ldim_drv->conf->seg_col = (unsigned char)seg_col;
if (ldim_drv->data->drv_init)
ldim_drv->data->drv_init(ldim_drv);
pr_info("************ldim stts init ok*************\n");
}
pr_info("ldim_stts_init param: %d %d\n",
ldim_drv->conf->seg_row, ldim_drv->conf->seg_col);
} else if (!strcmp(parm[0], "frm_size")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d %d\n",
ldim_drv->conf->hsize,
ldim_drv->conf->vsize);
goto ldim_attr_store_end;
}
}
pr_info("frm_width: %d, frm_height: %d\n",
ldim_drv->conf->hsize, ldim_drv->conf->vsize);
} else if (!strcmp(parm[0], "func") ||
!strcmp(parm[0], "func_en")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->conf->func_en;
goto ldim_attr_store_end;
}
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->conf->func_en = val1 ? 1 : 0;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->conf->func_en;
if (dbg_attr.chip_type != LCD_CHIP_T7 &&
dbg_attr.chip_type != LCD_CHIP_T3) {
if (ldim_drv->data &&
ldim_drv->data->func_ctrl) {
ldim_drv->data->func_ctrl(ldim_drv,
ldim_drv->conf->func_en);
}
}
}
pr_info("ldim_func_en: %d\n", ldim_drv->conf->func_en);
} else if (!strcmp(parm[0], "remap") ||
!strcmp(parm[0], "remapping_en")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->conf->remap_en;
goto ldim_attr_store_end;
}
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
if (val1) {
if (ldim_drv->func_en) {
ldim_drv->conf->remap_en = 1;
if (dbg_attr.chip_type != LCD_CHIP_T7 &&
dbg_attr.chip_type !=
LCD_CHIP_T3)
ldim_remap_ctrl(1);
} else {
pr_info("error: ldim_func is disabled\n");
}
} else {
ldim_drv->conf->remap_en = 0;
if (dbg_attr.chip_type != LCD_CHIP_T7 &&
dbg_attr.chip_type != LCD_CHIP_T3)
ldim_remap_ctrl(0);
}
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->conf->func_en;
}
pr_info("ldim_remap_en: %d\n", ldim_drv->conf->remap_en);
} else if (!strcmp(parm[0], "demo")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->conf->demo_en;
goto ldim_attr_store_end;
}
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->conf->demo_en = val1 ? 1 : 0;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->conf->demo_en;
if (ldim_drv->remap_en) {
if (ldim_drv->conf->demo_en) {
ldim_drv->demo_en = 1;
nprm->reg_ld_rgb_mapping_demo = 1;
ldim_wr_reg_bits(REG_LD_RGB_MOD,
1, 19, 1);
} else {
ldim_drv->demo_en = 0;
nprm->reg_ld_rgb_mapping_demo = 0;
ldim_wr_reg_bits(REG_LD_RGB_MOD,
0, 19, 1);
}
} else {
ldim_drv->demo_en = 0;
pr_info("error: ldim_remap is disabled\n");
}
}
pr_info("ldim_demo_en: %d\n", ldim_drv->demo_en);
} else if (!strcmp(parm[0], "data_min")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->data_min;
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &ldim_drv->data_min) < 0)
goto ldim_attr_store_err;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->data_min;
ldim_drv->set_level(ldim_drv->brightness_level);
}
LDIMPR("brightness data_min: %d\n", ldim_drv->data_min);
} else if (!strcmp(parm[0], "litgain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->litgain;
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &ldim_drv->litgain) < 0)
goto ldim_attr_store_err;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->litgain;
}
pr_info("litgain = %d\n", ldim_drv->litgain);
} else if (!strcmp(parm[0], "black_frm_en")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->black_frm_en;
goto ldim_attr_store_end;
}
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->black_frm_en = (unsigned char)val1;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->black_frm_en;
}
pr_info("black_frm_en = %d\n", ldim_drv->black_frm_en);
} else if (!strcmp(parm[0], "brightness_bypass")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->brightness_bypass;
goto ldim_attr_store_end;
}
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->brightness_bypass = (unsigned char)val1;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->brightness_bypass;
if (ldim_drv->brightness_bypass == 0)
ldim_drv->set_level(ldim_drv->brightness_level);
}
pr_info("brightness_bypass = %d\n",
ldim_drv->brightness_bypass);
} else if (!strcmp(parm[0], "test_mode")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->test_bl_en;
pr_info("for_tool:%d\n", ldim_drv->test_bl_en);
goto ldim_attr_store_end;
}
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->test_bl_en = (unsigned char)val1;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_SINGLE;
dbg_attr.data = ldim_drv->test_bl_en;
}
LDIMPR("test_mode: %d\n", ldim_drv->test_bl_en);
ldim_drv->level_update = 1;
} else if (!strcmp(parm[0], "test_matrix")) {
if (parm[2]) {
if (!strcmp(parm[1], "rf")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_TEST_MATRIX;
ldim_test_matrix_file_save(ldim_drv, parm[2]);
ldim_drv->level_update = 1;
goto ldim_attr_store_end;
}
goto ldim_attr_store_err;
}
if (parm[1]) {
if (!strcmp(parm[1], "w")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_TEST_MATRIX;
if (!parm[seg_size + 3])
goto ldim_attr_store_err;
if (kstrtouint(parm[2], 10, &i) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[3], 10, &j) < 0)
goto ldim_attr_store_err;
if (i != ldim_drv->conf->seg_row ||
j != ldim_drv->conf->seg_col)
goto ldim_attr_store_err;
for (i = 0; i < seg_size; i++) {
if (kstrtouint(parm[i + 4], 10, &j) < 0)
goto ldim_attr_store_err;
ldim_drv->test_matrix[i] = j;
}
ldim_drv->level_update = 1;
goto ldim_attr_store_end;
}
}
goto ldim_attr_store_err;
} else if (!strcmp(parm[0], "test_set")) {
if (parm[2]) {
if (kstrtouint(parm[1], 10, &i) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[2], 10, &j) < 0)
goto ldim_attr_store_err;
if (i < seg_size) {
ldim_drv->test_matrix[i] = j;
LDIMPR("set test_matrix[%d] = %4d\n", i, j);
} else {
LDIMERR("invalid index for test_matrix[%d]\n", i);
}
ldim_drv->level_update = 1;
goto ldim_attr_store_end;
}
ldim_get_test_matrix_info(ldim_drv);
} else if (!strcmp(parm[0], "test_set_all")) {
if (parm[1]) {
if (kstrtouint(parm[1], 10, &j) < 0)
goto ldim_attr_store_err;
for (i = 0; i < seg_size; i++)
ldim_drv->test_matrix[i] = j;
LDIMPR("set all test_matrix to %4d\n", j);
ldim_drv->level_update = 1;
goto ldim_attr_store_end;
}
ldim_get_test_matrix_info(ldim_drv);
} else if (!strcmp(parm[0], "bl_remap_curve")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_BL_DIM_CURVE;
goto ldim_attr_store_end;
}
}
if (parm[17]) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_BL_DIM_CURVE;
for (i = 0; i < 17; i++) {
if (kstrtouint(parm[i + 1], 10,
&fw_ctrl->bl_remap_curve[i]) < 0)
goto ldim_attr_store_err;
}
}
ldim_int_table_print(17, fw_ctrl->bl_remap_curve);
} else if (!strcmp(parm[0], "fw_LD_Whist") ||
!strcmp(parm[0], "fw_ld_whist")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_LD_WHIST;
goto ldim_attr_store_end;
}
}
if (parm[16]) {
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_WR;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_LD_WHIST;
for (i = 0; i < 16; i++) {
if (kstrtouint(parm[i + 1], 10,
&fw_ctrl->fw_ld_whist[i]) < 0) {
goto ldim_attr_store_err;
}
}
}
ldim_int_table_print(16, fw_ctrl->fw_ld_whist);
} else if (!strcmp(parm[0], "ld_remap_lut") ||
!strcmp(parm[0], "comp_gain_lut")) {
if (parm[2]) {
if (!strcmp(parm[1], "lr")) { /* line read */
if (kstrtouint(parm[2], 10, &i) < 0)
goto ldim_attr_store_err;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_GAIN_LUT;
dbg_attr.data = i;
goto ldim_attr_store_end;
}
if (!strcmp(parm[1], "lw")) { /* line write */
if (kstrtouint(parm[2], 10, &i) < 0)
goto ldim_attr_store_err;
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_RD;
dbg_attr.mode = LDIM_DBG_ATTR_MODE_GAIN_LUT;
dbg_attr.data = i;
if (dbg_attr.chip_type == LCD_CHIP_T7 ||
dbg_attr.chip_type == LCD_CHIP_T3) {
k = 64;
table = ldc_gain_lut_array[i];
} else {
k = 32;
table = ld_remap_lut[i];
}
if (!parm[k + 2])
goto ldim_attr_store_err;
for (j = 0; j < k; j++) {
if (kstrtouint(parm[j + 3], 10,
&table[j]) < 0)
goto ldim_attr_store_err;
}
if (ldim_drv->data->remap_lut_update)
ldim_drv->data->remap_lut_update();
goto ldim_attr_store_end;
}
goto ldim_attr_store_err;
}
if (parm[1]) {
if (kstrtouint(parm[1], 10, &i) < 0)
goto ldim_attr_store_err;
ldim_comp_gain_lut_print(i);
}
if (!parm[1]) {
ldim_comp_gain_lut_print(0xff);
goto ldim_attr_store_end;
}
} else if (!strcmp(parm[0], "Sf_bypass")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
fw_ctrl->sf_bypass = (unsigned char)val1;
}
pr_info("Sf_bypass = %d\n", fw_ctrl->sf_bypass);
} else if (!strcmp(parm[0], "Boost_light_bypass")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
fw_ctrl->boost_light_bypass = (unsigned char)val1;
}
pr_info("Boost_light_bypass = %d\n",
fw_ctrl->boost_light_bypass);
} else if (!strcmp(parm[0], "Lpf_bypass")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
fw_ctrl->lpf_bypass = (unsigned char)val1;
}
pr_info("Lpf_bypass = %d\n", fw_ctrl->lpf_bypass);
} else if (!strcmp(parm[0], "Ld_remap_bypass")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n",
fw_ctrl->ld_remap_bypass);
goto ldim_attr_store_end;
}
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
fw_ctrl->ld_remap_bypass = (unsigned char)val1;
}
pr_info("Ld_remap_bypass = %d\n", fw_ctrl->ld_remap_bypass);
} else if (!strcmp(parm[0], "ov_gain")) {
if (parm[1]) {
if (kstrtouint(parm[1], 10, &fw_ctrl->ov_gain) < 0)
goto ldim_attr_store_err;
}
pr_info("ov_gain = %d\n", fw_ctrl->ov_gain);
} else if (!strcmp(parm[0], "fw_LD_ThSF_l")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->fw_ld_thsf_l);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10,
&fw_ctrl->fw_ld_thsf_l) < 0) {
goto ldim_attr_store_err;
}
}
pr_info("fw_LD_ThSF_l = %d\n", fw_ctrl->fw_ld_thsf_l);
} else if (!strcmp(parm[0], "fw_LD_ThTF_l")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->fw_ld_thtf_l);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10,
&fw_ctrl->fw_ld_thtf_l) < 0) {
goto ldim_attr_store_err;
}
}
pr_info("fw_LD_ThTF_l = %d\n", fw_ctrl->fw_ld_thtf_l);
} else if (!strcmp(parm[0], "fw_ld_thist")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->fw_ld_thist);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10,
&fw_ctrl->fw_ld_thist) < 0) {
goto ldim_attr_store_err;
}
}
pr_info("fw_ld_thist = %d\n", fw_ctrl->fw_ld_thist);
} else if (!strcmp(parm[0], "boost_gain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->boost_gain);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10,
&fw_ctrl->boost_gain) < 0) {
goto ldim_attr_store_err;
}
}
pr_info("boost_gain = %d\n", fw_ctrl->boost_gain);
} else if (!strcmp(parm[0], "TF_alpha")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->tf_alpha);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &fw_ctrl->tf_alpha) < 0)
goto ldim_attr_store_err;
}
pr_info("TF_alpha = %d\n", fw_ctrl->tf_alpha);
} else if (!strcmp(parm[0], "lpf_gain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->lpf_gain);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &fw_ctrl->lpf_gain) < 0)
goto ldim_attr_store_err;
}
pr_info("lpf_gain = %d\n", fw_ctrl->lpf_gain);
} else if (!strcmp(parm[0], "lpf_res")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->lpf_res);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &fw_ctrl->lpf_res) < 0)
goto ldim_attr_store_err;
}
pr_info("lpf_res = %d\n", fw_ctrl->lpf_res);
} else if (!strcmp(parm[0], "rgb_base")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->rgb_base);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &fw_ctrl->rgb_base) < 0)
goto ldim_attr_store_err;
}
pr_info("rgb_base = %d\n", fw_ctrl->rgb_base);
} else if (!strcmp(parm[0], "avg_gain")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->avg_gain);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &fw_ctrl->avg_gain) < 0)
goto ldim_attr_store_err;
}
pr_info("avg_gain = %d\n", fw_ctrl->avg_gain);
} else if (!strcmp(parm[0], "fw_rgb_diff_th")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n",
fw_ctrl->fw_rgb_diff_th);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10,
&fw_ctrl->fw_rgb_diff_th) < 0) {
goto ldim_attr_store_err;
}
}
pr_info("fw_rgb_diff_th = %d\n", fw_ctrl->fw_rgb_diff_th);
} else if (!strcmp(parm[0], "fw_TF_sum_th")) {
if (parm[1]) {
if (kstrtouint(parm[1], 10, &fw_ctrl->fw_tf_sum_th) < 0)
goto ldim_attr_store_err;
}
pr_info("fw_TF_sum_th = %d\n", fw_ctrl->fw_tf_sum_th);
} else if (!strcmp(parm[0], "LPF_method")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->lpf_method);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &fw_ctrl->lpf_method) < 0)
goto ldim_attr_store_err;
}
pr_info("LPF_method = %d\n", fw_ctrl->lpf_method);
} else if (!strcmp(parm[0], "LD_TF_STEP_TH")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n",
fw_ctrl->ld_tf_step_th);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10,
&fw_ctrl->ld_tf_step_th) < 0) {
goto ldim_attr_store_err;
}
}
pr_info("LD_TF_STEP_TH = %d\n", fw_ctrl->ld_tf_step_th);
} else if (!strcmp(parm[0], "TF_step_method")) {
if (parm[1]) {
if (kstrtouint(parm[1], 10,
&fw_ctrl->tf_step_method) < 0) {
goto ldim_attr_store_err;
}
}
pr_info("TF_step_method = %d\n", fw_ctrl->tf_step_method);
} else if (!strcmp(parm[0], "TF_FRESH_BL")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->tf_fresh_bl);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &fw_ctrl->tf_fresh_bl) < 0)
goto ldim_attr_store_err;
}
pr_info("TF_FRESH_BL = %d\n", fw_ctrl->tf_fresh_bl);
} else if (!strcmp(parm[0], "TF_BLK_FRESH_BL")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n",
fw_ctrl->tf_blk_fresh_bl);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10,
&fw_ctrl->tf_blk_fresh_bl) < 0) {
goto ldim_attr_store_err;
}
}
pr_info("TF_BLK_FRESH_BL = %d\n", fw_ctrl->tf_blk_fresh_bl);
} else if (!strcmp(parm[0], "bbd_detect_en")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
fw_ctrl->bbd_detect_en = (unsigned char)val1;
}
pr_info("bbd_detect_en = %d\n", fw_ctrl->bbd_detect_en);
} else if (!strcmp(parm[0], "side_blk_diff_th")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n",
fw_ctrl->side_blk_diff_th);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10,
&fw_ctrl->side_blk_diff_th) < 0) {
goto ldim_attr_store_err;
}
}
pr_info("side_blk_diff_th = %d\n", fw_ctrl->side_blk_diff_th);
} else if (!strcmp(parm[0], "bbd_th")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n", fw_ctrl->bbd_th);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &fw_ctrl->bbd_th) < 0)
goto ldim_attr_store_err;
}
pr_info("bbd_th = %d\n", fw_ctrl->bbd_th);
} else if (!strcmp(parm[0], "diff_blk_luma_en")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
fw_ctrl->diff_blk_luma_en = (unsigned char)val1;
}
pr_info("diff_blk_luma_en = %d\n", fw_ctrl->diff_blk_luma_en);
} else if (!strcmp(parm[0], "avg_update_en")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->avg_update_en = (unsigned char)val1;
}
pr_info("avg_update_en = %d\n", ldim_drv->avg_update_en);
} else if (!strcmp(parm[0], "matrix_update_en")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->matrix_update_en = (unsigned char)val1;
}
pr_info("matrix_update_en = %d\n", ldim_drv->matrix_update_en);
} else if (!strcmp(parm[0], "alg_en")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->alg_en = (unsigned char)val1;
}
pr_info("ldim_alg_en = %d\n", ldim_drv->alg_en);
} else if (!strcmp(parm[0], "top_en")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->top_en = (unsigned char)val1;
}
pr_info("ldim_top_en = %d\n", ldim_drv->top_en);
} else if (!strcmp(parm[0], "hist_en")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->hist_en = (unsigned char)val1;
}
pr_info("ldim_hist_en = %d\n", ldim_drv->hist_en);
} else if (!strcmp(parm[0], "white_area_en")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
fw_ctrl->white_area_remap_en = (unsigned char)val1;
}
pr_info("white_area_remap_en = %d\n",
fw_ctrl->white_area_remap_en);
} else if (!strcmp(parm[0], "white_area_map")) {
if (parm[4]) {
if (kstrtouint(parm[1], 10,
&fw_ctrl->white_area_th_max) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[2], 10,
&fw_ctrl->white_area_th_min) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[3], 10,
&fw_ctrl->white_lvl_th_max) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[4], 10,
&fw_ctrl->white_lvl_th_min) < 0)
goto ldim_attr_store_err;
}
pr_info("white_area_th max = %d, min = %d\n",
fw_ctrl->white_area_th_max,
fw_ctrl->white_area_th_min);
pr_info("white_lvl_th max = %d, min = %d\n",
fw_ctrl->white_lvl_th_max,
fw_ctrl->white_lvl_th_min);
} else if (!strcmp(parm[0], "fw_hist_print")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
fw->fw_hist_print = (unsigned char)val1;
}
pr_info("fw_hist_print = %d\n", fw->fw_hist_print);
} else if (!strcmp(parm[0], "fw_print_frequent")) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n",
fw->fw_print_frequent);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10,
&fw->fw_print_frequent) < 0) {
goto ldim_attr_store_err;
}
fw_cus_pre->fw_print_frequent = fw->fw_print_frequent;
fw_cus_post->fw_print_frequent = fw->fw_print_frequent;
}
pr_info("fw_print_frequent = %d\n", fw->fw_print_frequent);
} else if ((!strcmp(parm[0], "Dbprint_lv")) ||
(!strcmp(parm[0], "fw_print"))) {
if (parm[1]) {
if (!strcmp(parm[1], "r")) {
pr_info("for_tool:%d\n",
fw->fw_print_lv);
goto ldim_attr_store_end;
}
if (kstrtouint(parm[1], 10, &fw->fw_print_lv) < 0)
goto ldim_attr_store_err;
fw_cus_pre->fw_print_lv = fw->fw_print_lv;
fw_cus_post->fw_print_lv = fw->fw_print_lv;
}
pr_info("fw_print_lv = %d\n", fw->fw_print_lv);
} else if (!strcmp(parm[0], "cus_fw_param")) {
if (parm[2]) {
if (kstrtouint(parm[1], 10, &i) < 0)
goto ldim_attr_store_err;
if (kstrtouint(parm[2], 10, &j) < 0)
goto ldim_attr_store_err;
if (fw_cus_pre->fw_alg_frm)
fw_cus_pre->param[i] = j;
if (fw_cus_post->fw_alg_frm)
fw_cus_post->param[i] = j;
}
for (k = 0; k < 32; k++) {
if (fw_cus_pre->fw_alg_frm) {
pr_info("cus_pre_data[%d] = %d\n",
k, fw_cus_pre->param[k]);
}
if (fw_cus_post->fw_alg_frm) {
pr_info("cus_post_data[%d] = %d\n",
k, fw_cus_post->param[k]);
}
}
} else if (!strcmp(parm[0], "info")) {
pr_info("ldim_drv_ver: %s\n", LDIM_DRV_VER);
if (ldim_drv->config_print)
ldim_drv->config_print();
pr_info("\nldim_seg_row = %d\n"
"ldim_seg_col = %d\n"
"ldim_bl_mode = %d\n\n",
ldim_drv->conf->seg_row, ldim_drv->conf->seg_col,
ldim_drv->conf->bl_mode);
pr_info("state = 0x%x\n"
"ldim_on_flag = %d\n"
"ldim_func_en = %d\n"
"ldim_remap_en = %d\n"
"ldim_demo_en = %d\n"
"ldim_ld_sel = %d\n"
"ldim_func_bypass = %d\n"
"ldim_test_bl_en = %d\n"
"ldim_test_remap_en = %d\n"
"ldim_avg_update_en = %d\n"
"ldim_matrix_update_en = %d\n"
"ldim_alg_en = %d\n"
"ldim_top_en = %d\n"
"ldim_hist_en = %d\n"
"ldim_data_min = %d\n"
"ldim_data_max = %d\n"
"litgain = %d\n"
"fw_valid = %d\n"
"fw_sel = %d\n"
"fw_flag = %d\n"
"ldim_irq_cnt = %d\n"
"duty_update_flag = %d\n\n",
ldim_drv->state,
ldim_drv->init_on_flag, ldim_drv->func_en,
ldim_drv->remap_en, ldim_drv->demo_en,
ldim_drv->ld_sel, ldim_drv->func_bypass,
ldim_drv->test_bl_en,
ldim_drv->test_remap_en,
ldim_drv->avg_update_en,
ldim_drv->matrix_update_en,
ldim_drv->alg_en, ldim_drv->top_en,
ldim_drv->hist_en,
ldim_drv->data_min, ldim_drv->data_max,
ldim_drv->litgain,
ldim_drv->fw->valid,
ldim_drv->fw->fw_sel,
ldim_drv->fw->flag,
ldim_drv->irq_cnt,
ldim_drv->duty_update_flag);
} else if (!strcmp(parm[0], "print")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_debug_print = (unsigned char)val1;
}
pr_info("ldim_debug_print = %d\n", ldim_debug_print);
} else if (!strcmp(parm[0], "duty_update_flag")) {
if (parm[1]) {
if (kstrtoul(parm[1], 10, &val1) < 0)
goto ldim_attr_store_err;
ldim_drv->duty_update_flag = (unsigned char)val1;
}
pr_info("duty_update_flag = %d\n", ldim_drv->duty_update_flag);
} else if ((!strcmp(parm[0], "alg")) ||
(!strcmp(parm[0], "fw"))) {
if (fw->fw_alg_para_print)
fw->fw_alg_para_print(fw);
else
pr_info("ldim_fw para_print is null\n");
} else {
pr_info("no support cmd!!!\n");
}
ldim_attr_store_end:
kfree(buf_orig);
kfree(parm);
mutex_unlock(&ldim_dbg_mutex);
return len;
ldim_attr_store_err:
dbg_attr.cmd = LDIM_DBG_ATTR_CMD_ERR;
pr_info("invalid cmd!!!\n");
kfree(buf_orig);
kfree(parm);
mutex_unlock(&ldim_dbg_mutex);
return -EINVAL;
}
static ssize_t ldim_func_en_show(struct class *class,
struct class_attribute *attr, char *buf)
{
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
int ret = 0;
ret = sprintf(buf, "%d\n", ldim_drv->func_en);
return ret;
}
static ssize_t ldim_func_en_store(struct class *class,
struct class_attribute *attr,
const char *buf, size_t count)
{
struct aml_bl_drv_s *bdrv = aml_bl_get_driver(0);
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
unsigned int val = 0;
int ret = 0;
ret = kstrtouint(buf, 10, &val);
LDIMPR("local diming function: %s\n", (val ? "enable" : "disable"));
ldim_drv->conf->func_en = val ? 1 : 0;
//LCD_CHIP_T3/T7 update in vsync isr
if (bdrv->data->chip_type != LCD_CHIP_T3 &&
bdrv->data->chip_type != LCD_CHIP_T7) {
if (ldim_drv->data && ldim_drv->data->func_ctrl)
ldim_drv->data->func_ctrl(ldim_drv,
ldim_drv->conf->func_en);
}
return count;
}
static ssize_t ldim_remap_show(struct class *class,
struct class_attribute *attr, char *buf)
{
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
int ret = 0;
ret = sprintf(buf, "%d\n", ldim_drv->remap_en);
return ret;
}
static ssize_t ldim_remap_store(struct class *class,
struct class_attribute *attr,
const char *buf, size_t count)
{
struct aml_bl_drv_s *bdrv = aml_bl_get_driver(0);
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
unsigned int val = 0;
int ret = 0;
ret = kstrtouint(buf, 10, &val);
LDIMPR("local diming remap: %s\n", (val ? "enable" : "disable"));
ldim_drv->conf->remap_en = val ? 1 : 0;
//LCD_CHIP_T3/T7 update in vsync isr
if (bdrv->data->chip_type != LCD_CHIP_T3 &&
bdrv->data->chip_type != LCD_CHIP_T7) {
ldim_remap_ctrl(ldim_drv->conf->remap_en);
}
return count;
}
static ssize_t ldim_para_show(struct class *class,
struct class_attribute *attr, char *buf)
{
struct ldim_fw_s *fw = aml_ldim_get_fw();
int len = 0;
len = sprintf(buf, "boost_gain=%d\n", fw->ctrl->boost_gain);
return len;
}
static ssize_t ldim_mem_show(struct class *class,
struct class_attribute *attr, char *buf)
{
struct aml_bl_drv_s *bdrv = aml_bl_get_driver(0);
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
int len = 0;
switch (bdrv->data->chip_type) {
case LCD_CHIP_TM2:
case LCD_CHIP_TM2B:
len = sprintf(buf,
"wr_mem1_paddr: 0x%lx\n"
"wr_mem1_vaddr: 0x%px\n"
"wr_mem2_paddr: 0x%lx\n"
"wr_mem2_vaddr: 0x%px\n"
"rd_mem1_paddr: 0x%lx\n"
"rd_mem1_vaddr: 0x%px\n"
"rd_mem2_paddr: 0x%lx\n"
"rd_mem2_vaddr: 0x%px\n",
(unsigned long)ldim_drv->rmem->wr_mem_paddr1,
ldim_drv->rmem->wr_mem_vaddr1,
(unsigned long)ldim_drv->rmem->wr_mem_paddr2,
ldim_drv->rmem->wr_mem_vaddr2,
(unsigned long)ldim_drv->rmem->rd_mem_paddr1,
ldim_drv->rmem->rd_mem_vaddr1,
(unsigned long)ldim_drv->rmem->rd_mem_paddr2,
ldim_drv->rmem->rd_mem_vaddr2);
break;
case LCD_CHIP_T7:
case LCD_CHIP_T3:
len = sprintf(buf,
"rsv_mem_paddr: 0x%lx\n"
"rsv_mem_size: 0x%x\n"
"profile_mem_paddr: 0x%lx\n"
"profile_mem_size: 0x%x\n"
"global_hist_paddr: 0x%lx\n"
"global_hist_vaddr: 0x%px\n"
"global_hist_mem_size: 0x%x\n"
"seg_hist_paddr: 0x%lx\n"
"seg_hist_vaddr: 0x%px\n"
"seg_hist_mem_size: 0x%x\n"
"duty_paddr: 0x%lx\n"
"duty_vaddr: 0x%px\n"
"duty_mem_size: 0x%x\n",
(unsigned long)ldim_drv->rmem->rsv_mem_paddr,
ldim_drv->rmem->rsv_mem_size,
(unsigned long)ldim_drv->rmem->profile_mem_paddr,
ldim_drv->rmem->profile_mem_size,
(unsigned long)ldim_drv->rmem->global_hist_paddr,
ldim_drv->rmem->global_hist_vaddr,
ldim_drv->rmem->global_hist_mem_size,
(unsigned long)ldim_drv->rmem->seg_hist_paddr,
ldim_drv->rmem->seg_hist_vaddr,
ldim_drv->rmem->seg_hist_mem_size,
(unsigned long)ldim_drv->rmem->duty_paddr,
ldim_drv->rmem->duty_vaddr,
ldim_drv->rmem->duty_mem_size);
break;
default:
len = sprintf(buf, "invalid");
break;
}
return len;
}
static ssize_t ldim_mem_store(struct class *class, struct class_attribute *attr,
const char *buf, size_t count)
{
int i, ret;
unsigned int *data_buf, region_num, data, index, temp;
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
region_num = ldim_drv->conf->seg_row * ldim_drv->conf->seg_col;
switch (buf[0]) {
case 'w':
data_buf = (unsigned int *)ldim_drv->rmem->wr_mem_vaddr1;
if (!data_buf) {
LDIMERR("wr buffer is null\n");
return count;
}
pr_info("ldim wr buffer:\n");
for (i = 0; i < region_num * 20; i++) {
pr_info(" 0x%p : %04x\n", data_buf, *data_buf);
data_buf++;
}
pr_info("\n");
break;
case 'r':
data_buf = (unsigned int *)ldim_drv->rmem->rd_mem_vaddr1;
if (!data_buf) {
LDIMERR("rd buffer is null\n");
return count;
}
pr_info("ldim rd buffer:\n");
for (i = 0; i < region_num; i++) {
pr_info(" 0x%p : %04x\n", data_buf, *data_buf);
data_buf++;
}
pr_info("\n");
break;
case 't':
if (!ldim_drv->rmem->rd_mem_vaddr1) {
LDIMERR("read_buf is null\n");
break;
}
data_buf = (unsigned int *)ldim_drv->rmem->rd_mem_vaddr1;
ret = sscanf(buf, "test %x %d", &data, &index);
if (ret == 2) {
ldim_drv->matrix_update_en = 0;
msleep(20);
data_buf += (index / 2);
if (index % 2) {
temp = *data_buf & 0xffff;
*data_buf = temp | (data << 16);
} else {
temp = *data_buf & 0xffff0000;
*data_buf = temp | data;
}
LDIMPR("set rd buffer %d to 0x%x\n", index, data);
} else if (ret == 1) {
ldim_drv->matrix_update_en = 0;
msleep(20);
temp = (region_num + 1) / 2;
for (i = 0; i < temp; i++) {
*data_buf = data | data << 16;
data_buf++;
}
LDIMPR("set all rd buffer to 0x%x\n", data);
} else {
ldim_drv->matrix_update_en = 1;
LDIMPR("disable mem test\n");
}
break;
default:
LDIMERR("no support cmd\n");
}
return count;
}
static ssize_t ldim_reg_show(struct class *class,
struct class_attribute *attr, char *buf)
{
struct aml_bl_drv_s *bdrv = aml_bl_get_driver(0);
int len = 0;
if (bdrv->data->chip_type == LCD_CHIP_TM2)
len = ldim_hw_reg_dump_tm2(buf);
else if (bdrv->data->chip_type == LCD_CHIP_TM2B)
len = ldim_hw_reg_dump_tm2b(buf);
else
len = ldim_hw_reg_dump(buf);
return len;
}
static ssize_t ldim_reg_store(struct class *class, struct class_attribute *attr,
const char *buf, size_t len)
{
unsigned int n = 0, i;
char *buf_orig, *ps, *token;
char *parm[3];
char str[3] = {' ', '\n', '\0'};
unsigned int reg, val, size, temp;
if (!buf)
return len;
buf_orig = kstrdup(buf, GFP_KERNEL);
if (!buf_orig)
return len;
ps = buf_orig;
while (1) {
token = strsep(&ps, str);
if (!token)
break;
if (*token == '\0')
continue;
parm[n++] = token;
}
if (!strcmp(parm[0], "rv")) {
if (!parm[1])
goto ldim_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_reg_store_err;
val = lcd_vcbus_read(reg);
pr_info("reg 0x%04x = 0x%08x\n", reg, val);
} else if (!strcmp(parm[0], "dv")) {
if (!parm[2])
goto ldim_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_reg_store_err;
if (kstrtouint(parm[2], 10, &size) < 0)
goto ldim_reg_store_err;
for (i = 0; i < size; i++) {
val = lcd_vcbus_read(reg + i);
pr_info("reg 0x%04x = 0x%08x\n", (reg + i), val);
}
} else if (!strcmp(parm[0], "wv")) {
if (!parm[2])
goto ldim_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_reg_store_err;
if (kstrtouint(parm[2], 16, &val) < 0)
goto ldim_reg_store_err;
lcd_vcbus_write(reg, val);
temp = lcd_vcbus_read(reg);
pr_info("write reg 0x%04x = 0x%08x, readback 0x%08x\n", reg, val, temp);
} else if (!strcmp(parm[0], "r")) {
if (!parm[1])
goto ldim_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_reg_store_err;
val = ldim_rd_reg(reg);
pr_info("ldim port reg 0x%04x = 0x%08x\n", reg, val);
} else if (!strcmp(parm[0], "d")) {
if (!parm[2])
goto ldim_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_reg_store_err;
if (kstrtouint(parm[2], 10, &size) < 0)
goto ldim_reg_store_err;
for (i = 0; i < size; i++) {
val = ldim_rd_reg(reg + i);
pr_info("ldim port reg 0x%04x = 0x%08x\n",
(reg + i), val);
}
} else if (!strcmp(parm[0], "w")) {
if (!parm[2])
goto ldim_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_reg_store_err;
if (kstrtouint(parm[2], 16, &val) < 0)
goto ldim_reg_store_err;
ldim_wr_reg(reg, val);
msleep(30); /* wait for rdma write */
temp = ldim_rd_reg(reg);
pr_info("write ldim port reg 0x%04x = 0x%08x, readback 0x%08x\n",
reg, val, temp);
} else {
pr_info("no support cmd!!!\n");
}
kfree(buf_orig);
return len;
ldim_reg_store_err:
LDIMERR("invalid parameters\n");
kfree(buf_orig);
return -EINVAL;
}
static ssize_t ldim_dbg_reg_show(struct class *class,
struct class_attribute *attr, char *buf)
{
int len = 0;
unsigned int i, reg;
mutex_lock(&ldim_dbg_mutex);
len += sprintf(buf + len, "for_tool:");
switch (dbg_reg.rw_mode) {
case LDIM_DBG_REG_RW_MODE_NULL:
len += sprintf(buf + len, "NULL");
break;
case LDIM_DBG_REG_RW_MODE_RN:
for (i = 0; i < dbg_reg.size; i++) {
reg = dbg_reg.addr + i;
len += sprintf(buf + len, "%04x=%08x ",
reg, lcd_vcbus_read(reg));
}
break;
case LDIM_DBG_REG_RW_MODE_RS:
reg = dbg_reg.addr;
for (i = 0; i < dbg_reg.size; i++) {
len += sprintf(buf + len, "%04x=%08x ",
reg, lcd_vcbus_read(reg));
}
break;
case LDIM_DBG_REG_RW_MODE_WM:
reg = dbg_reg.addr;
len += sprintf(buf + len, "%04x=%08x ",
reg, lcd_vcbus_read(reg));
break;
case LDIM_DBG_REG_RW_MODE_WN:
for (i = 0; i < dbg_reg.size; i++) {
reg = dbg_reg.addr + i;
len += sprintf(buf + len, "%04x=%08x ",
reg, lcd_vcbus_read(reg));
}
break;
case LDIM_DBG_REG_RW_MODE_WS:
reg = dbg_reg.addr;
for (i = 0; i < dbg_reg.size; i++) {
len += sprintf(buf + len, "%04x=%08x ",
reg, lcd_vcbus_read(reg));
}
break;
case LDIM_DBG_REG_RW_MODE_ERR:
len += sprintf(buf + len, "ERROR");
break;
default:
len += sprintf(buf + len, "ERROR");
dbg_reg.rw_mode = LDIM_DBG_REG_RW_MODE_NULL;
dbg_reg.addr = 0;
dbg_reg.size = 0;
break;
}
len += sprintf(buf + len, "\n");
mutex_unlock(&ldim_dbg_mutex);
return len;
}
static ssize_t ldim_dbg_reg_store(struct class *class, struct class_attribute *attr,
const char *buf, size_t len)
{
unsigned int n = 0, i;
char *buf_orig, *ps, *token;
char **parm = NULL;
char str[3] = {' ', '\n', '\0'};
unsigned int reg, mask, val, size, temp;
if (!buf)
return len;
mutex_lock(&ldim_dbg_mutex);
parm = kcalloc(1536, sizeof(char *), GFP_KERNEL);
if (!parm) {
mutex_unlock(&ldim_dbg_mutex);
return len;
}
buf_orig = kstrdup(buf, GFP_KERNEL);
if (!buf_orig) {
kfree(parm);
return len;
}
ps = buf_orig;
while (1) {
token = strsep(&ps, str);
if (!token)
break;
if (*token == '\0')
continue;
parm[n++] = token;
}
if (!strcmp(parm[0], "wmv")) {
if (!parm[3])
goto ldim_dbg_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_dbg_reg_store_err;
if (kstrtouint(parm[2], 16, &mask) < 0)
goto ldim_dbg_reg_store_err;
if (kstrtouint(parm[3], 16, &val) < 0)
goto ldim_dbg_reg_store_err;
dbg_reg.size = 1; /* for cat use */
dbg_reg.addr = reg;
dbg_reg.rw_mode = LDIM_DBG_REG_RW_MODE_WM;
temp = lcd_vcbus_read(reg);
temp &= ~mask;
temp |= val & mask;
lcd_vcbus_write(reg, temp);
} else if (!strcmp(parm[0], "wnv")) {//write reg auto inc
if (!parm[2])
goto ldim_dbg_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_dbg_reg_store_err;
if (kstrtouint(parm[2], 10, &size) < 0)
goto ldim_dbg_reg_store_err;
if (size == 0)
goto ldim_dbg_reg_store_err;
if (!parm[3 + size - 1])
goto ldim_dbg_reg_store_err;
dbg_reg.size = size; /* for cat use */
dbg_reg.addr = reg;
dbg_reg.rw_mode = LDIM_DBG_REG_RW_MODE_WN;
for (i = 0; i < size; i++) {
if (kstrtouint(parm[i + 3], 16, &val) < 0)
goto ldim_dbg_reg_store_err;
lcd_vcbus_write(reg + i, val);
}
} else if (!strcmp(parm[0], "wsv")) { //write reg static
if (!parm[2])
goto ldim_dbg_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_dbg_reg_store_err;
if (kstrtouint(parm[2], 10, &size) < 0)
goto ldim_dbg_reg_store_err;
if (size == 0)
goto ldim_dbg_reg_store_err;
if (!parm[3 + size - 1])
goto ldim_dbg_reg_store_err;
dbg_reg.size = size; /* for cat use */
dbg_reg.addr = reg;
dbg_reg.rw_mode = LDIM_DBG_REG_RW_MODE_WS;
for (i = 0; i < size; i++) {
if (kstrtouint(parm[i + 3], 16, &val) < 0)
goto ldim_dbg_reg_store_err;
lcd_vcbus_write(reg, val);
}
} else if (!strcmp(parm[0], "rnv")) { //read reg
if (!parm[1])
goto ldim_dbg_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_dbg_reg_store_err;
if (!parm[2]) { //read one reg
dbg_reg.size = 1; /* for cat use */
dbg_reg.addr = reg;
dbg_reg.rw_mode = LDIM_DBG_REG_RW_MODE_RN;
} else {
if (kstrtouint(parm[2], 10, &size) < 0)
goto ldim_dbg_reg_store_err;
if (size == 0)
goto ldim_dbg_reg_store_err;
dbg_reg.size = size; /* for cat use */
dbg_reg.addr = reg;
dbg_reg.rw_mode = LDIM_DBG_REG_RW_MODE_RN;
}
} else if (!strcmp(parm[0], "rsv")) { //read static reg
if (!parm[1])
goto ldim_dbg_reg_store_err;
if (kstrtouint(parm[1], 16, &reg) < 0)
goto ldim_dbg_reg_store_err;
if (!parm[2]) { //read one reg
dbg_reg.size = 1; /* for cat use */
dbg_reg.addr = reg;
dbg_reg.rw_mode = LDIM_DBG_REG_RW_MODE_RS;
} else {
if (kstrtouint(parm[2], 10, &size) < 0)
goto ldim_dbg_reg_store_err;
if (size == 0)
goto ldim_dbg_reg_store_err;
dbg_reg.size = size; /* for cat use */
dbg_reg.addr = reg;
dbg_reg.rw_mode = LDIM_DBG_REG_RW_MODE_RS;
}
} else {
goto ldim_dbg_reg_store_err;
}
kfree(buf_orig);
kfree(parm);
mutex_unlock(&ldim_dbg_mutex);
return len;
ldim_dbg_reg_store_err:
dbg_reg.rw_mode = LDIM_DBG_REG_RW_MODE_ERR;
LDIMERR("invalid parameters\n");
kfree(buf_orig);
kfree(parm);
mutex_unlock(&ldim_dbg_mutex);
return -EINVAL;
}
static ssize_t ldim_demo_show(struct class *class, struct class_attribute *attr, char *buf)
{
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
int ret = 0;
ret = sprintf(buf, "%d\n", ldim_drv->demo_en);
return ret;
}
static ssize_t ldim_demo_store(struct class *class, struct class_attribute *attr,
const char *buf, size_t count)
{
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
unsigned int val = 0;
if (kstrtouint(buf, 10, &val) < 0)
return count;
LDIMPR("local diming demo: %d\n", val);
ldim_drv->conf->demo_en = val ? 1 : 0;
if (val) {
if (ldim_drv->remap_en) {
ldim_drv->demo_en = 1;
ldim_drv->fw->ctrl->nprm->reg_ld_rgb_mapping_demo = 1;
ldim_hw_remap_demo_en(1);
} else {
pr_info("error: ldim_remap is disabled\n");
}
} else {
ldim_drv->demo_en = 0;
ldim_drv->fw->ctrl->nprm->reg_ld_rgb_mapping_demo = 0;
ldim_hw_remap_demo_en(0);
}
return count;
}
static void ldc_rmem_data_dump(struct aml_ldim_driver_s *ldim_drv)
{
if (ldim_drv->rmem->flag == 0) {
pr_info("ldc resv mem invalid\n");
return;
}
pr_info("ldc global hist:\n");
ldc_mem_dump(ldim_drv->rmem->global_hist_vaddr, ldim_drv->rmem->global_hist_mem_size);
pr_info("ldc seg hist:\n");
ldc_mem_dump(ldim_drv->rmem->seg_hist_vaddr, ldim_drv->rmem->seg_hist_mem_size);
pr_info("ldc duty:\n");
ldc_mem_dump(ldim_drv->rmem->duty_vaddr, ldim_drv->rmem->duty_mem_size);
}
static ssize_t ldim_debug_show(struct class *class, struct class_attribute *attr, char *buf)
{
ssize_t len = 0;
len += sprintf(buf + len,
"echo en <width> <height> <col> <row> > /sys/class/aml_ldim/attr\n");
len += sprintf(buf + len,
"echo reg > /sys/class/aml_ldim/attr\n");
len += sprintf(buf + len,
"echo save <type> <path> > /sys/class/aml_ldim/attr\n");
len += sprintf(buf + len,
"echo clr <type> > /sys/class/aml_ldim/attr\n");
len += sprintf(buf + len,
"echo dump <type> > /sys/class/aml_ldim/attr\n");
len += sprintf(buf + len,
" type: profile/lut/mem\n");
len += sprintf(buf + len,
"echo load <type> <path> > /sys/class/aml_ldim/attr\n");
len += sprintf(buf + len,
" type: profile/lut\n");
return len;
}
static unsigned int ldc_dbg_point_ctrl[][2] = {
//pnt_index, bit_width
{1, 12},
{2, 12},
{3, 12},
{4, 12},
{5, 12},
{6, 12},
{7, 16},
{8, 14}
};
static int ldc_debug_dummy(void)
{
pr_info("todo\n");
return 0;
}
static void ldc_gain_lut_load(struct aml_ldim_driver_s *ldim_drv, char *path)
{
unsigned int size = 0, file_size = 0, len = 0;
char *buf;
unsigned int *p;
struct file *filp = NULL;
loff_t pos = 0;
mm_segment_t old_fs = get_fs();
/*struct kstat stat;*/
unsigned int i, j, n;
char *ps, *token;
char str[4] = {',', ' ', '\n', '\0'};
set_fs(KERNEL_DS);
/*vfs_stat(path, &stat);
*file_size = stat.size;
*/
filp = filp_open(path, O_RDONLY, 0);
if (IS_ERR_OR_NULL(filp)) {
pr_info("read %s error or filp is NULL.\n", path);
return;
}
file_size = filp->f_inode->i_size;
buf = kzalloc((file_size + 2), GFP_KERNEL);
if (!buf) {
filp_close(filp, NULL);
set_fs(old_fs);
return;
}
size = vfs_read(filp, buf, file_size, &pos);
if (size < file_size) {
pr_info("%s read size %u < %u error.\n",
__func__, size, file_size);
filp_close(filp, NULL);
set_fs(old_fs);
kfree(buf);
return;
}
vfs_fsync(filp, 0);
filp_close(filp, NULL);
set_fs(old_fs);
ps = buf;
len = 0;
i = 0;
j = 0;
n = 0;
while (1) {
if (len >= file_size)
break;
if (!ps)
break;
token = strsep(&ps, str);
if (!token)
break;
if (*token == '\0') {
len++;
continue;
}
p = ldc_gain_lut_array[n];
if (kstrtouint(token, 16, &p[j]) < 0) {
kfree(buf);
return;
}
if (j == 63) {
j = 0;
n++;
} else {
j++;
}
len += (strlen(token) + 1);
i++;
}
if (ldim_drv->data->remap_lut_update)
ldim_drv->data->remap_lut_update();
pr_info("load setting file path: %s finish, total line %d\n", path, n);
kfree(buf);
}
static void ldim_time_print(unsigned long long *table)
{
unsigned int len, i;
char *buf;
buf = kcalloc(1024, sizeof(char), GFP_KERNEL);
if (!buf)
return;
len = 0;
for (i = 0; i < 9; i++)
len += sprintf(buf + len, " %lld,", table[i]);
len += sprintf(buf + len, " %lld", table[9]);
pr_info("%s\n", buf);
kfree(buf);
}
static ssize_t ldim_debug_store(struct class *class, struct class_attribute *attr,
const char *buf, size_t len)
{
struct aml_ldim_driver_s *ldim_drv = aml_ldim_get_driver();
unsigned int n = 0;
char *buf_orig, *ps, *token;
char **parm = NULL;
char str[3] = {' ', '\n', '\0'};
unsigned int temp, val, num;
int i, j;
if (!buf)
return len;
buf_orig = kstrdup(buf, GFP_KERNEL);
if (!buf_orig)
return len;
parm = kcalloc(128, sizeof(char *), GFP_KERNEL);
if (!parm) {
kfree(buf_orig);
return len;
}
ps = buf_orig;
while (1) {
token = strsep(&ps, str);
if (!token)
break;
if (*token == '\0')
continue;
parm[n++] = token;
}
num = ldim_drv->conf->seg_col * ldim_drv->conf->seg_row;
if (!strcmp(parm[0], "en")) {
if (!parm[1])
goto ldim_debug_store_err;
if (kstrtouint(parm[1], 10, &temp) < 0)
goto ldim_debug_store_err;
ldim_drv->func_en = temp ? 1 : 0;
if (ldim_drv->data && ldim_drv->data->func_ctrl)
ldim_drv->data->func_ctrl(ldim_drv, ldim_drv->func_en);
} else if (!strcmp(parm[0], "fw_sel")) {
if (parm[1]) {
if (kstrtouint(parm[1], 10, &temp) < 0)
goto ldim_debug_store_err;
ldim_drv->fw->fw_sel = (unsigned char)temp;
ldim_config_update_t7(ldim_drv);
}
pr_info("fw_sel = %d\n", ldim_drv->fw->fw_sel);
} else if (!strcmp(parm[0], "test")) {
if (!parm[1])
goto ldim_debug_store_err;
if (!strcmp(parm[1], "on")) {
ldim_drv->test_bl_en = 1;
goto ldim_debug_store_end;
}
if (!strcmp(parm[1], "off")) {
ldim_drv->test_bl_en = 0;
goto ldim_debug_store_end;
}
if (!strcmp(parm[1], "run")) {
ldim_drv->test_bl_en = 1;
for (i = 0; i < num; i++) {
for (j = 0; j < num; j++)
ldim_drv->test_matrix[j] = 0;
ldim_drv->test_matrix[i] = 4095;
msleep(500);
}
ldim_drv->test_bl_en = 0;
goto ldim_debug_store_end;
}
if (parm[2]) {
if (!strcmp(parm[1], "remap")) {
if (kstrtouint(parm[2], 10, &temp) < 0)
goto ldim_debug_store_err;
ldim_drv->test_remap_en = temp;
pr_info("test_remap_en = %d\n",
ldim_drv->test_remap_en);
goto ldim_debug_store_end;
}
}
if (parm[3]) {
if (kstrtouint(parm[2], 10, &temp) < 0)
goto ldim_debug_store_err;
if (kstrtouint(parm[3], 10, &val) < 0)
goto ldim_debug_store_err;
if (temp >= num)
goto ldim_debug_store_err;
ldim_drv->test_matrix[temp] = val;
} else if (parm[2]) {
if (kstrtouint(parm[2], 10, &val) < 0)
goto ldim_debug_store_err;
for (i = 0; i < num; i++)
ldim_drv->test_matrix[i] = val;
}
} else if (!strcmp(parm[0], "bypass")) {
if (!parm[1])
goto ldim_debug_store_err;
if (!strcmp(parm[1], "dev")) {
if (kstrtouint(parm[2], 10, &temp) < 0)
goto ldim_debug_store_err;
ldim_drv->dev_smr_bypass = temp;
}
} else if (!strcmp(parm[0], "print")) {
if (parm[1]) {
if (kstrtouint(parm[1], 10, &temp) < 0)
goto ldim_debug_store_err;
ldim_debug_print = (unsigned char)temp;
}
pr_info("ldim_debug_print = %d\n", ldim_debug_print);
} else if (!strcmp(parm[0], "pnt")) {
if (!parm[1])
goto ldim_debug_store_err;
if (!strcmp(parm[1], "off")) {
lcd_vcbus_setb(LDC_DGB_CTRL, 0, 0, 1);
pr_info("ldc dbg point off\n");
goto ldim_debug_store_end;
}
if (kstrtouint(parm[1], 10, &i) < 0)
goto ldim_debug_store_err;
if (i < 1 || i > 8) {
lcd_vcbus_setb(LDC_DGB_CTRL, 0, 0, 1);
pr_info("ldc dbg point off\n");
goto ldim_debug_store_end;
}
if (parm[2]) {
if (kstrtouint(parm[2], 10, &val) < 0)
goto ldim_debug_store_err;
} else {
val = ldc_dbg_point_ctrl[i - 1][1];
}
temp = val - 10;
lcd_vcbus_setb(LDC_DGB_CTRL, i, 1, 4);
lcd_vcbus_setb(LDC_DGB_CTRL, temp, 5, 4);
lcd_vcbus_setb(LDC_DGB_CTRL, 1, 0, 1);
} else if (!strcmp(parm[0], "time")) {
pr_info("arithmetic_time:\n");
ldim_time_print(ldim_drv->arithmetic_time);
pr_info("xfer_time:\n");
ldim_time_print(ldim_drv->xfer_time);
} else if (!strcmp(parm[0], "reg")) {
//dump reg todo
} else if (!strcmp(parm[0], "save")) { /* save buf to bin */
if (!parm[2])
goto ldim_debug_store_err;
if (!strcmp(parm[1], "profile")) {
//todo
ldc_debug_dummy();
} else if (!strcmp(parm[1], "lut")) {
//todo
ldc_debug_dummy();
} else if (!strcmp(parm[1], "mem")) {
if (ldim_drv->rmem->flag == 0) {
pr_info("ldc resv mem invalid\n");
goto ldim_debug_store_err;
}
ldc_mem_save(parm[2],
ldim_drv->rmem->rsv_mem_paddr,
ldim_drv->rmem->rsv_mem_size);
} else {
goto ldim_debug_store_err;
}
} else if (!strcmp(parm[0], "load")) { /*load bin to buf*/
if (!parm[2])
goto ldim_debug_store_err;
if (!strcmp(parm[1], "profile")) {
if (ldim_drv->rmem->flag == 0) {
pr_info("ldc resv mem invalid\n");
goto ldim_debug_store_err;
}
ldc_mem_write(parm[2],
ldim_drv->rmem->profile_mem_paddr,
ldim_drv->rmem->profile_mem_size);
} else if (!strcmp(parm[1], "lut")) {
ldc_gain_lut_load(ldim_drv, parm[2]);
} else {
goto ldim_debug_store_err;
}
} else if (!strcmp(parm[0], "clr")) {
if (!parm[2])
goto ldim_debug_store_err;
if (!strcmp(parm[1], "profile")) {
//todo
ldc_debug_dummy();
} else if (!strcmp(parm[1], "lut")) {
//todo
ldc_debug_dummy();
} else if (!strcmp(parm[1], "mem")) {
if (ldim_drv->rmem->flag == 0) {
pr_info("ldc resv mem invalid\n");
goto ldim_debug_store_err;
}
ldc_mem_clear(ldim_drv->rmem->rsv_mem_paddr,
ldim_drv->rmem->rsv_mem_size);
} else {
goto ldim_debug_store_err;
}
} else if (!strcmp(parm[0], "set")) {
if (!parm[1])
goto ldim_debug_store_err;
if (!strcmp(parm[1], "profile")) {
//todo
ldc_debug_dummy();
} else if (!strcmp(parm[1], "lut")) {
//todo
ldc_debug_dummy();
} else if (!strcmp(parm[1], "duty")) {
if (ldim_drv->rmem->flag == 0) {
pr_info("ldc resv mem invalid\n");
goto ldim_debug_store_err;
}
ldc_mem_set(ldim_drv->rmem->duty_paddr,
ldim_drv->rmem->duty_mem_size);
} else {
goto ldim_debug_store_err;
}
} else if (!strcmp(parm[0], "dump")) {
if (!parm[1])
goto ldim_debug_store_err;
if (!strcmp(parm[1], "profile")) {
//todo
ldc_debug_dummy();
} else if (!strcmp(parm[1], "lut")) {
//todo
ldc_debug_dummy();
} else if (!strcmp(parm[1], "mem")) {
ldc_rmem_data_dump(ldim_drv);
} else {
goto ldim_debug_store_err;
}
} else {
pr_info("no support cmd!!!\n");
}
ldim_debug_store_end:
kfree(buf_orig);
kfree(parm);
return len;
ldim_debug_store_err:
pr_info("invalid parameters\n");
kfree(buf_orig);
kfree(parm);
return -EINVAL;
}
static struct class_attribute aml_ldim_class_attrs[] = {
__ATTR(attr, 0644, ldim_attr_show, ldim_attr_store),
__ATTR(func_en, 0644, ldim_func_en_show, ldim_func_en_store),
__ATTR(remap, 0644, ldim_remap_show, ldim_remap_store),
__ATTR(para, 0644, ldim_para_show, NULL),
__ATTR(mem, 0644, ldim_mem_show, ldim_mem_store),
__ATTR(reg, 0644, ldim_reg_show, ldim_reg_store),
__ATTR(dbg_reg, 0644, ldim_dbg_reg_show, ldim_dbg_reg_store),
__ATTR(demo, 0644, ldim_demo_show, ldim_demo_store),
__ATTR(debug, 0644, ldim_debug_show, ldim_debug_store)
};
int aml_ldim_debug_probe(struct class *ldim_class)
{
int i;
for (i = 0; i < ARRAY_SIZE(aml_ldim_class_attrs); i++) {
if (class_create_file(ldim_class, &aml_ldim_class_attrs[i]) < 0)
return -1;
}
mutex_init(&ldim_dbg_mutex);
return 0;
}
void aml_ldim_debug_remove(struct class *ldim_class)
{
int i;
for (i = 0; i < ARRAY_SIZE(aml_ldim_class_attrs); i++)
class_remove_file(ldim_class, &aml_ldim_class_attrs[i]);
}