Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 73b9aac8 authored by Benet Clark's avatar Benet Clark
Browse files

msm: mdss: Add pr_debug functions to print postproc structures 



Added print functions for the postproc structures to aid in debugging.

Change-Id: I14ebb4d00f99f376967dc418112611e31030d21b
Signed-off-by: default avatarBenet Clark <benetc@codeaurora.org>
parent 33197d65

drivers/video/msm/mdss/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -3,7 +3,7 @@ mdss-mdp3-objs += mdp3_ppp.o mdp3_ppp_hwio.o mdp3_ppp_data.o 
obj-$(CONFIG_FB_MSM_MDSS_MDP3) += mdss-mdp3.o



mdss-mdp-objs := mdss_mdp.o mdss_mdp_ctl.o mdss_mdp_pipe.o mdss_mdp_util.o

mdss-mdp-objs += mdss_mdp_pp.o

mdss-mdp-objs += mdss_mdp_pp.o mdss_mdp_pp_debug.o

mdss-mdp-objs += mdss_mdp_intf_video.o

mdss-mdp-objs += mdss_mdp_intf_cmd.o

mdss-mdp-objs += mdss_mdp_intf_writeback.o

drivers/video/msm/mdss/mdss_mdp_pp.c

+1 −0
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 


#include "mdss_fb.h"

#include "mdss_mdp.h"

#include "mdss_mdp_pp.h"

#include <linux/uaccess.h>

#include <linux/spinlock.h>

#include <linux/delay.h>

drivers/video/msm/mdss/mdss_mdp_pp.h

0 → 100644
+53 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2014, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */



#ifndef MDSS_MDP_PP_DEBUG_H

#define MDSS_MDP_PP_DEBUG_H



#include <linux/msm_mdp.h>



void pp_print_lut(void *data, int size, char *tab, uint32_t type);

void pp_print_uint16_lut(uint16_t *data, int size, char *tab);

void pp_print_pcc_coeff(struct mdp_pcc_coeff *pcc_coeff, int tab_depth);

void pp_print_pcc_cfg_data(struct mdp_pcc_cfg_data *pcc_data, int tab_depth);

void pp_print_csc_cfg(struct mdp_csc_cfg *data, int tab_depth);

void pp_print_csc_cfg_data(struct mdp_csc_cfg_data *data, int tab_depth);

void pp_print_igc_lut_data(struct mdp_igc_lut_data *data, int tab_depth);

void pp_print_ar_gc_lut_data(struct mdp_ar_gc_lut_data *data, int tab_depth);

void pp_print_pgc_lut_data(struct mdp_pgc_lut_data *data, int tab_depth);

void pp_print_hist_lut_data(struct mdp_hist_lut_data *data, int tab_depth);

void pp_print_lut_cfg_data(struct mdp_lut_cfg_data *data, int tab_depth);

void pp_print_qseed_cfg(struct mdp_qseed_cfg *data, int tab_depth);

void pp_print_qseed_cfg_data(struct mdp_qseed_cfg_data *data, int tab_depth);

void pp_print_pa_cfg(struct mdp_pa_cfg *data, int tab_depth);

void pp_print_pa_cfg_data(struct mdp_pa_cfg_data *data, int tab_depth);

void pp_print_mem_col_cfg(struct mdp_pa_mem_col_cfg *data, int tab_depth);

void pp_print_pa_v2_data(struct mdp_pa_v2_data *data, int tab_depth);

void pp_print_pa_v2_cfg_data(struct mdp_pa_v2_cfg_data *data, int tab_depth);

void pp_print_dither_cfg_data(struct mdp_dither_cfg_data *data, int tab_depth);

void pp_print_gamut_cfg_data(struct mdp_gamut_cfg_data *data, int tab_depth);

void pp_print_ad_init(struct mdss_ad_init *data, int tab_depth);

void pp_print_ad_cfg(struct mdss_ad_cfg *data, int tab_depth);

void pp_print_ad_init_cfg(struct mdss_ad_init_cfg *data, int tab_depth);

void pp_print_ad_input(struct mdss_ad_input *data, int tab_depth);

void pp_print_histogram_cfg(struct mdp_histogram_cfg *data, int tab_depth);

void pp_print_sharp_cfg(struct mdp_sharp_cfg *data, int tab_depth);

void pp_print_calib_config_data(struct mdp_calib_config_data *data,

				int tab_depth);

void pp_print_calib_config_buffer(struct mdp_calib_config_buffer *data,

				int tab_depth);

void pp_print_calib_dcm_state(struct mdp_calib_dcm_state *data, int tab_depth);

void pp_print_mdss_calib_cfg(struct mdss_calib_cfg *data, int tab_depth);



#endif

drivers/video/msm/mdss/mdss_mdp_pp_debug.c

0 → 100644
+857 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2014, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 */



#include "mdss_fb.h"

#include "mdss_mdp.h"

#include "mdss_mdp_pp.h"



#define MAX_TAB_BUFFER_SIZE	12

#define MAX_LINE_BUFFER_SIZE 256



static inline void tab_prefix(char *tab_str, int n)

{

	while ((n)--)

		strlcat((tab_str), "\t", MAX_TAB_BUFFER_SIZE);

}



enum {

	UINT32,

	UINT16,

};



void pp_print_lut(void *data, int size, char *tab, uint32_t type)

{

	char buf[MAX_LINE_BUFFER_SIZE];

	int lines = size / 16;

	int last_start = lines * 16;

	int i, j;

	uint32_t read = 0;



	if (!data || !tab)

		return;



	buf[0] = '\0';

	for (i = 0; i < lines; i++) {

		buf[0] = '\0';

		read += snprintf(buf, MAX_LINE_BUFFER_SIZE - read,

			"%s", tab);

		for (j = 0; j < 16; j++) {

			if (type == UINT32)

				read += snprintf(buf + read,

					MAX_LINE_BUFFER_SIZE - read, "%04x ",

					((uint32_t *)data)[i*16+j]);

			else if (type == UINT16)

				read += snprintf(buf + read,

					MAX_LINE_BUFFER_SIZE - read, "%02x ",

					((uint16_t *)data)[i*16+j]);

		}

		snprintf(buf + read, MAX_LINE_BUFFER_SIZE - read, "\n");



		pr_debug("%s", buf);

		memset(buf, 0, sizeof(char) * MAX_LINE_BUFFER_SIZE);

		read = 0;

	}



	lines = size % 16;

	read += snprintf(buf, MAX_LINE_BUFFER_SIZE - read, "%s", tab);

	for (i = 0; i < lines; i++) {

		if (type == UINT32)

			read += snprintf(buf + read,

					MAX_LINE_BUFFER_SIZE - read, "%04x ",

					((uint32_t *)data)[last_start+i]);

		else if (type == UINT16)

			read += snprintf(buf + read,

					MAX_LINE_BUFFER_SIZE - read, "%02x ",

					((uint16_t *)data)[last_start+i]);

	}

	snprintf(buf + read, MAX_LINE_BUFFER_SIZE - read, "\n");

	pr_debug("%s", buf);

}



void pp_print_pcc_coeff(struct mdp_pcc_coeff *pcc_coeff, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!pcc_coeff || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_pcc_coeff:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sc: %x\n"

		"%sr: %x\n%sg: %x\n%sb: %x\n"

		"%srr: %x\n%sgg: %x\n%sbb: %x\n"

		"%srg: %x\n%sgb: %x\n%srb: %x\n"

		"%srgb_0: %x\n%srgb_1: %x\n",

		tab, pcc_coeff->c,

		tab, pcc_coeff->r,

		tab, pcc_coeff->g,

		tab, pcc_coeff->b,

		tab, pcc_coeff->rr,

		tab, pcc_coeff->gg,

		tab, pcc_coeff->bb,

		tab, pcc_coeff->rg,

		tab, pcc_coeff->gb,

		tab, pcc_coeff->rb,

		tab, pcc_coeff->rgb_0,

		tab, pcc_coeff->rgb_1);

}



void pp_print_pcc_cfg_data(struct mdp_pcc_cfg_data *pcc_data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!pcc_data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_pcc_cfg_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sblock: %x\n%sops: %x\n",

		tab, pcc_data->block,

		tab, pcc_data->ops);



	pp_print_pcc_coeff(&pcc_data->r, tab_depth + 1);

	pp_print_pcc_coeff(&pcc_data->g, tab_depth + 1);

	pp_print_pcc_coeff(&pcc_data->b, tab_depth + 1);

}



void pp_print_csc_cfg(struct mdp_csc_cfg *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_csc_cfg:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sflags: %x\n",

		tab, data->flags);



	pr_debug("%scsc_mv[]:\n", tab);

	pp_print_lut(&data->csc_mv[0], 9, tab, UINT32);

	pr_debug("%scsc_pre_bv[]:\n", tab);

	pp_print_lut(&data->csc_pre_bv[0], 3, tab, UINT32);

	pr_debug("%scsc_post_bv[]:\n", tab);

	pp_print_lut(&data->csc_post_bv[0], 3, tab, UINT32);

	pr_debug("%scsc_pre_lv[]:\n", tab);

	pp_print_lut(&data->csc_pre_lv[0], 6, tab, UINT32);

	pr_debug("%scsc_post_lv[]:\n", tab);

	pp_print_lut(&data->csc_post_lv[0], 6, tab, UINT32);

}



void pp_print_csc_cfg_data(struct mdp_csc_cfg_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[tab_depth] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_csc_cfg_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sblock: %x\n",

		tab, data->block);



	pp_print_csc_cfg(&data->csc_data, tab_depth + 1);

}



void pp_print_igc_lut_data(struct mdp_igc_lut_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[tab_depth] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_igc_lut_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sblock: %x\n"

		"%slen: %x\n"

		"%sops: %x\n",

		tab, data->block,

		tab, data->len,

		tab, data->ops);



	pr_debug("%sc0_c1_data[]:\n", tab);

	pp_print_lut(&data->c0_c1_data[0], data->len, tab, UINT32);

	pr_debug("%sc2_data[]:\n", tab);

	pp_print_lut(&data->c2_data[0], data->len, tab, UINT32);

}



void pp_print_ar_gc_lut_data(struct mdp_ar_gc_lut_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[tab_depth] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_ar_gc_lut_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sx_start: %x\n"

		"%sslope: %x\n"

		"%soffset: %x\n",

		tab, data->x_start,

		tab, data->slope,

		tab, data->offset);

}



void pp_print_pgc_lut_data(struct mdp_pgc_lut_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;

	int i;



	if (!data || tab_depth < 0)

		return;



	tab[tab_depth] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_pgc_lut_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sblock: %x\n"

		"%sflags: %x\n"

		"%snum_r_stages: %x\n"

		"%snum_g_stages: %x\n"

		"%snum_b_stages: %x\n",

		tab, data->block,

		tab, data->flags,

		tab, data->num_r_stages,

		tab, data->num_g_stages,

		tab, data->num_b_stages);



	for (i = 0; i < data->num_r_stages; i++) {

		pr_debug("%sr_data[%d]\n", tab, i);

		pp_print_ar_gc_lut_data(&data->r_data[i], tab_depth + 1);

	}

	for (i = 0; i < data->num_g_stages; i++) {

		pr_debug("%sg_data[%d]\n", tab, i);

		pp_print_ar_gc_lut_data(&data->g_data[i], tab_depth + 1);

	}

	for (i = 0; i < data->num_b_stages; i++) {

		pr_debug("%sb_data[%d]\n", tab, i);

		pp_print_ar_gc_lut_data(&data->b_data[i], tab_depth + 1);

	}

}



void pp_print_hist_lut_data(struct mdp_hist_lut_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[tab_depth] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_hist_lut_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sblock: %x\n"

		"%sops: %x\n"

		"%slen: %x\n",

		tab, data->block,

		tab, data->ops,

		tab, data->len);



	pr_debug("%sdata[]:\n", tab);

	pp_print_lut(&data->data[0], data->len, tab, UINT32);

}



void pp_print_lut_cfg_data(struct mdp_lut_cfg_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[tab_depth] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_lut_cfg_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%slut_type: %x\n",

		tab, data->lut_type);



	switch (data->lut_type) {

	case mdp_lut_igc:

		pp_print_igc_lut_data(&data->data.igc_lut_data, tab_depth + 1);

		break;

	case mdp_lut_pgc:

		pp_print_pgc_lut_data(&data->data.pgc_lut_data, tab_depth + 1);

		break;

	case mdp_lut_hist:

		pp_print_hist_lut_data(&data->data.hist_lut_data,

				tab_depth + 1);

		break;

	default:

		break;

	}

}



void pp_print_qseed_cfg(struct mdp_qseed_cfg *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[tab_depth] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_qseed_cfg:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%stable_num: %x\n"

		"%sops: %x\n"

		"%slen: %x\n",

		tab, data->table_num,

		tab, data->ops,

		tab, data->len);



	pr_debug("%sdata[]:\n", tab);

	pp_print_lut(&data->data[0], data->len, tab, UINT32);

}



void pp_print_qseed_cfg_data(struct mdp_qseed_cfg_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[tab_depth] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_qseed_cfg_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sblock: %x\n",

		tab, data->block);



	pp_print_qseed_cfg(&data->qseed_data, tab_depth + 1);

}



void pp_print_pa_cfg(struct mdp_pa_cfg *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_pa_cfg:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sflags: %x\n"

		"%shue_adj: %x\n"

		"%ssat_adj: %x\n"

		"%sval_adj: %x\n"

		"%scont_adj: %x\n",

		tab, data->flags,

		tab, data->hue_adj,

		tab, data->sat_adj,

		tab, data->val_adj,

		tab, data->cont_adj);

}



void pp_print_pa_cfg_data(struct mdp_pa_cfg_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_pa_cfg_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sblock: %x\n",

		tab, data->block);



	pp_print_pa_cfg(&data->pa_data, tab_depth + 1);

}



void pp_print_mem_col_cfg(struct mdp_pa_mem_col_cfg *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_pa_mem_col_cfg:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%scolor_adjust_p0: %x\n"

		"%scolor_adjust_p1: %x\n"

		"%shue_region: %x\n"

		"%ssat_region: %x\n"

		"%sval_region: %x\n",

		tab, data->color_adjust_p0,

		tab, data->color_adjust_p1,

		tab, data->hue_region,

		tab, data->sat_region,

		tab, data->val_region);

}



void pp_print_pa_v2_data(struct mdp_pa_v2_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_pa_v2_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sflags: %x\n"

		"%sglobal_hue_adj: %x\n"

		"%sglobal_sat_adj: %x\n"

		"%sglobal_val_adj: %x\n"

		"%sglobal_cont_adj: %x\n",

		tab, data->flags,

		tab, data->global_hue_adj,

		tab, data->global_sat_adj,

		tab, data->global_val_adj,

		tab, data->global_cont_adj);



	pp_print_mem_col_cfg(&data->skin_cfg, tab_depth + 1);

	pp_print_mem_col_cfg(&data->sky_cfg, tab_depth + 1);

	pp_print_mem_col_cfg(&data->fol_cfg, tab_depth + 1);



	pr_debug("%ssix_zone_len: %x\n"

		"%ssix_zone_thresh: %x\n",

		tab, data->six_zone_len,

		tab, data->six_zone_thresh);



	pr_debug("%ssix_zone_curve_p0[]:\n", tab);

	pp_print_lut(&data->six_zone_curve_p0[0], data->six_zone_len, tab,

			UINT32);

	pr_debug("%ssix_zone_curve_p1[]:\n", tab);

	pp_print_lut(&data->six_zone_curve_p1[0], data->six_zone_len, tab,

			UINT32);

}



void pp_print_pa_v2_cfg_data(struct mdp_pa_v2_cfg_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_pa_v2_cfg_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sblock: %x\n",

		tab, data->block);



	pp_print_pa_v2_data(&data->pa_v2_data, tab_depth + 1);

}



void pp_print_dither_cfg_data(struct mdp_dither_cfg_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_dither_cfg_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sblock: %x\n"

		"%sflags: %x\n"

		"%sg_y_depth: %x\n"

		"%sr_cr_depth: %x\n"

		"%sb_cb_depth: %x\n",

		tab, data->block,

		tab, data->flags,

		tab, data->g_y_depth,

		tab, data->r_cr_depth,

		tab, data->b_cb_depth);

}



void pp_print_gamut_cfg_data(struct mdp_gamut_cfg_data *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;

	int i;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_gamut_cfg_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sblock: %x\n"

		"%sflags: %x\n"

		"%sgamut_first: %x\n",

		tab, data->block,

		tab, data->flags,

		tab, data->gamut_first);



	pr_debug("%stbl_size[]:\n", tab);

	pp_print_lut(&data->tbl_size[0], MDP_GAMUT_TABLE_NUM, tab, UINT32);



	for (i = 0; i < MDP_GAMUT_TABLE_NUM; i++) {

		pr_debug("%sr_tbl[%d]:\n", tab, i);

		pp_print_lut(&data->r_tbl[i][0], data->tbl_size[i], tab,

				UINT16);

	}



	for (i = 0; i < MDP_GAMUT_TABLE_NUM; i++) {

		pr_debug("%sg_tbl[%d]:\n", tab, i);

		pp_print_lut(&data->g_tbl[i][0], data->tbl_size[i], tab,

				UINT16);

	}



	for (i = 0; i < MDP_GAMUT_TABLE_NUM; i++) {

		pr_debug("%sb_tbl[%d]:\n", tab, i);

		pp_print_lut(&data->b_tbl[i][0], data->tbl_size[i], tab,

				UINT16);

	}

}



void pp_print_ad_init(struct mdss_ad_init *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdss_ad_init:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sasym_lut[]:\n", tab);

	pp_print_lut(&data->asym_lut[0], 33, tab, UINT32);



	pr_debug("%scolor_corr_lut[]:\n", tab);

	pp_print_lut(&data->color_corr_lut[0], 33, tab, UINT32);



	pr_debug("%si_control[]:\n%s%x %x\n"

		"%sblack_lvl: %x\n"

		"%swhite_lvl: %x\n"

		"%svar: %x\n"

		"%slimit_ampl: %x\n"

		"%si_dither: %x\n"

		"%sslope_max: %x\n"

		"%sslope_min: %x\n"

		"%sdither_ctl: %x\n"

		"%sformat: %x\n"

		"%sauto_size: %x\n"

		"%sframe_w: %x\n"

		"%sframe_h: %x\n"

		"%slogo_v: %x\n"

		"%slogo_h: %x\n"

		"%sbl_lin_len: %x\n",

		tab, tab, data->i_control[0], data->i_control[1],

		tab, data->black_lvl,

		tab, data->white_lvl,

		tab, data->var,

		tab, data->limit_ampl,

		tab, data->i_dither,

		tab, data->slope_max,

		tab, data->slope_min,

		tab, data->dither_ctl,

		tab, data->format,

		tab, data->auto_size,

		tab, data->frame_w,

		tab, data->frame_h,

		tab, data->logo_v,

		tab, data->logo_h,

		tab, data->bl_lin_len);



	pr_debug("%sbl_lin[]:\n", tab);

	pp_print_lut(&data->bl_lin[0], data->bl_lin_len, tab, UINT32);



	pr_debug("%sbl_lin_inv[]:\n", tab);

	pp_print_lut(&data->bl_lin_inv[0], data->bl_lin_len, tab, UINT32);

}



void pp_print_ad_cfg(struct mdss_ad_cfg *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdss_ad_cfg:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%smode: %x\n",

		tab, data->mode);



	pr_debug("%sal_calib_lut[]:\n", tab);

	pp_print_lut(&data->al_calib_lut[0], 33, tab, UINT32);



	pr_debug("%sbacklight_min: %x\n"

		"%sbacklight_max: %x\n"

		"%sbacklight_scale: %x\n"

		"%samb_light_min: %x\n",

		tab, data->backlight_min,

		tab, data->backlight_max,

		tab, data->backlight_scale,

		tab, data->amb_light_min);



	pp_print_lut(&data->filter[0], 2, tab, UINT16);

	pp_print_lut(&data->calib[0], 4, tab, UINT16);



	pr_debug("%sstrength_limit: %x\n"

		"%st_filter_recursion: %x\n"

		"%sstab_itr: %x\n"

		"%sbl_ctrl_mode: %x\n",

		tab, data->strength_limit,

		tab, data->t_filter_recursion,

		tab, data->stab_itr,

		tab, data->bl_ctrl_mode);

}



void pp_print_ad_init_cfg(struct mdss_ad_init_cfg *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdss_ad_init_cfg:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sops: %x\n",

		tab, data->ops);



	if (data->ops & MDP_PP_AD_INIT)

		pp_print_ad_init(&data->params.init, tab_depth + 1);

	else if (data->ops & MDP_PP_AD_CFG)

		pp_print_ad_cfg(&data->params.cfg, tab_depth + 1);

}



void pp_print_ad_input(struct mdss_ad_input *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdss_ad_input:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%smode: %x\n",

		tab, data->mode);



	switch (data->mode) {

	case MDSS_AD_MODE_AUTO_BL:

	case MDSS_AD_MODE_AUTO_STR:

		pr_debug("%samb_light: %x\n",

			tab, data->in.amb_light);

		break;

	case MDSS_AD_MODE_TARG_STR:

	case MDSS_AD_MODE_MAN_STR:

		pr_debug("%sstrength: %x\n",

			tab, data->in.strength);

		break;

	case MDSS_AD_MODE_CALIB:

		pr_debug("%scalib_bl: %x\n",

			tab, data->in.calib_bl);

		break;

	default:

		break;

	}



	pr_debug("%soutput: %x\n",

		tab, data->output);

}



void pp_print_histogram_cfg(struct mdp_histogram_cfg *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_histogram_cfg:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sops: %x\n"

		"%sblock: %x\n"

		"%sframe_cnt: %x\n"

		"%sbit_mask: %x\n"

		"%snum_bins: %x\n",

		tab, data->ops,

		tab, data->block,

		tab, data->frame_cnt,

		tab, data->bit_mask,

		tab, data->num_bins);

}



void pp_print_sharp_cfg(struct mdp_sharp_cfg *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_sharp_cfg:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sflags: %x\n"

		"%sstrength: %x\n"

		"%sedge_thr: %x\n"

		"%ssmooth_thr: %x\n"

		"%snoise_thr: %x\n",

		tab, data->flags,

		tab, data->strength,

		tab, data->edge_thr,

		tab, data->smooth_thr,

		tab, data->noise_thr);

}



void pp_print_calib_config_data(struct mdp_calib_config_data *data,

				int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_calib_config_data:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sops: %x\n"

		"%saddr: %x\n"

		"%sdata: %x\n",

		tab, data->ops,

		tab, data->addr,

		tab, data->data);

}



void pp_print_calib_config_buffer(struct mdp_calib_config_buffer *data,

				int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_calib_config_buffer:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sops: %x\n"

		"%ssize: %x\n",

		tab, data->ops,

		tab, data->size);



	pr_debug("%sbuffer[]:\n", tab);

	pp_print_lut(&data->buffer[0], data->size, tab, UINT32);

}



void pp_print_calib_dcm_state(struct mdp_calib_dcm_state *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdp_calib_dcm_state:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sops: %x\n"

		"%sdcm_state: %x\n",

		tab, data->ops,

		tab, data->dcm_state);

}



void pp_print_mdss_calib_cfg(struct mdss_calib_cfg *data, int tab_depth)

{

	char tab[MAX_TAB_BUFFER_SIZE];

	int tmp = 1;



	if (!data || tab_depth < 0)

		return;



	tab[0] = '\0';

	tab_prefix(tab, tab_depth);

	pr_debug("%smdss_calib_cfg:\n", tab);

	tab_prefix(tab, tmp);



	pr_debug("%sops: %x\n"

		"%scalib_mask: %x\n",

		tab, data->ops,

		tab, data->calib_mask);

}