drivers/media/video/samsung/tv20/s5p_stda_tvout_if.c - Issue 2036011: V4L/DVB : Add S5PV210 TV out driver support

Side by Side Diff: drivers/media/video/samsung/tv20/s5p_stda_tvout_if.c

Issue 2036011: V4L/DVB : Add S5PV210 TV out driver support (Closed) Base URL: swsolcc@12.23.106.100:kernel-samsung.git

Patch Set: Created 10 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
(Empty)
	1 /* linux/drivers/media/video/samsung/tv20/s5p_stda_tvout_if.c

	2 *

	3 * Copyright (c) 2010 Samsung Electronics Co., Ltd.

	4 * http://www.samsung.com/

	5 *

	6 * S5PV210 - TVOut interface ftn. file for Samsung TVOut driver

	7 *

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

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

	10 * published by the Free Software Foundation.

	11 */

	12

	13 #include <linux/module.h>

	14 #include <linux/kernel.h>

	15 #include <linux/stddef.h>

	16 #include <linux/ioctl.h>

	17 #include <linux/fs.h>

	18 #include <linux/clk.h>

	19

	20 #include <linux/io.h>

	21 #include <linux/uaccess.h>

	22

	23 #include <plat/clock.h>

	24

	25 #include "s5p_tv.h"

	26

	27 #ifdef CONFIG_TVOUT_DBG

	28 #define S5P_STDA_TVOUTIF_DEBUG 1

	29 #endif

	30

	31 #ifdef S5P_STDA_TVOUTIF_DEBUG

	32 #define TVOUTIFPRINTK(fmt, args...) \

	33 printk(KERN_INFO "\t[TVOUT_IF] %s: " fmt, __func__ , ## args)

	34 #else

	35 #define TVOUTIFPRINTK(fmt, args...)

	36 #endif

	37

	38 bool tv_if_init_param(void)

	39 {

	40 struct s5p_tv_status *st = &s5ptv_status;

	41

	42 /* Initialize GRPx Layer Parameters to Default Values */

	43 st->grp_burst = VM_BURST_16;

	44 st->grp_endian = TVOUT_LITTLE_ENDIAN_MODE;

	45

	46 /* Initialize BG Layer Parameters to Default Values */

	47 st->bg_dither.cr_dither_en = false;

	48 st->bg_dither.cb_dither_en = false;

	49 st->bg_dither.y_dither_en = false;

	50

	51 st->bg_color[0].color_y = 0;

	52 st->bg_color[0].color_cb = 128;

	53 st->bg_color[0].color_cr = 128;

	54 st->bg_color[1].color_y = 0;

	55 st->bg_color[1].color_cb = 128;

	56 st->bg_color[1].color_cr = 128;

	57 st->bg_color[2].color_y = 0;

	58 st->bg_color[2].color_cb = 128;

	59 st->bg_color[2].color_cr = 128;

	60

	61 /* Initialize Video Mixer Parameters to Default Values */

	62 st->vm_csc_coeff_default = true;

	63

	64 /* Initialize SDout Parameters to Default Values */

	65 st->sdout_sync_pin = SDOUT_SYNC_SIG_YG;

	66 st->sdout_vbi.wss_cvbs = true;

	67 st->sdout_vbi.caption_cvbs = SDOUT_INS_OTHERS;

	68 st->sdout_vbi.wss_y_svideo = true;

	69 st->sdout_vbi.caption_y_svideo = SDOUT_INS_OTHERS;

	70 st->sdout_vbi.cgmsa_rgb = true;

	71 st->sdout_vbi.wss_rgb = true;

	72 st->sdout_vbi.caption_rgb = SDOUT_INS_OTHERS;

	73 st->sdout_vbi.cgmsa_y_pb_pr = true;

	74 st->sdout_vbi.wss_y_pb_pr = true;

	75 st->sdout_vbi.caption_y_pb_pr = SDOUT_INS_OTHERS;

	76 st->sdout_offset_gain[0].channel = SDOUT_CHANNEL_0;

	77 st->sdout_offset_gain[0].offset = 0;

	78 st->sdout_offset_gain[0].gain = 0x800;

	79 st->sdout_offset_gain[1].channel = SDOUT_CHANNEL_1;

	80 st->sdout_offset_gain[1].offset = 0;

	81 st->sdout_offset_gain[1].gain = 0x800;

	82 st->sdout_offset_gain[2].channel = SDOUT_CHANNEL_2;

	83 st->sdout_offset_gain[2].offset = 0;

	84 st->sdout_offset_gain[2].gain = 0x800;

	85 st->sdout_delay.delay_y = 0x00;

	86 st->sdout_delay.offset_video_start = 0xfa;

	87 st->sdout_delay.offset_video_end = 0x00;

	88 st->sdout_color_sub_carrier_phase_adj = false;

	89 st->sdout_bri_hue_set.bright_hue_sat_adj = false;

	90 st->sdout_bri_hue_set.gain_brightness = 0x80;

	91 st->sdout_bri_hue_set.offset_brightness = 0x00;

	92 st->sdout_bri_hue_set.gain0_cb_hue_saturation = 0x00;

	93 st->sdout_bri_hue_set.gain1_cb_hue_saturation = 0x00;

	94 st->sdout_bri_hue_set.gain0_cr_hue_saturation = 0x00;

	95 st->sdout_bri_hue_set.gain1_cr_hue_saturation = 0x00;

	96 st->sdout_bri_hue_set.offset_cb_hue_saturation = 0x00;

	97 st->sdout_bri_hue_set.offset_cr_hue_saturation = 0x00;

	98 st->sdout_y_pb_pr_comp = false;

	99 st->sdout_rgb_compen.rgb_color_compensation = false;

	100 st->sdout_rgb_compen.max_rgb_cube = 0xeb;

	101 st->sdout_rgb_compen.min_rgb_cube = 0x10;

	102 st->sdout_cvbs_compen.cvbs_color_compensation = false;

	103 st->sdout_cvbs_compen.y_lower_mid = 0x200;

	104 st->sdout_cvbs_compen.y_bottom = 0x000;

	105 st->sdout_cvbs_compen.y_top = 0x3ff;

	106 st->sdout_cvbs_compen.y_upper_mid = 0x200;

	107 st->sdout_cvbs_compen.radius = 0x1ff;

	108 st->sdout_svideo_compen.y_color_compensation = false;

	109 st->sdout_svideo_compen.y_top = 0x3ff;

	110 st->sdout_svideo_compen.y_bottom = 0x000;

	111 st->sdout_svideo_compen.yc_cylinder = 0x1ff;

	112 st->sdout_comp_porch.back_525 = 0x8a;

	113 st->sdout_comp_porch.front_525 = 0x359;

	114 st->sdout_comp_porch.back_625 = 0x96;

	115 st->sdout_comp_porch.front_625 = 0x35c;

	116 st->sdout_rgb_sync.sync_type = SDOUT_VESA_RGB_SYNC_COMPOSITE;

	117 st->sdout_rgb_sync.vsync_active = TVOUT_POL_ACTIVE_HIGH;

	118 st->sdout_rgb_sync.hsync_active = TVOUT_POL_ACTIVE_HIGH;

	119 st->sdout_xtalk_cc[0].channel = SDOUT_CHANNEL_0;

	120 st->sdout_xtalk_cc[0].coeff2 = 0;

	121 st->sdout_xtalk_cc[0].coeff1 = 0;

	122 st->sdout_xtalk_cc[1].channel = SDOUT_CHANNEL_1;

	123 st->sdout_xtalk_cc[1].coeff2 = 0;

	124 st->sdout_xtalk_cc[1].coeff1 = 0;

	125 st->sdout_xtalk_cc[2].channel = SDOUT_CHANNEL_2;

	126 st->sdout_xtalk_cc[2].coeff2 = 0;

	127 st->sdout_xtalk_cc[2].coeff1 = 0;

	128 st->sdout_closed_capt.display_cc = 0;

	129 st->sdout_closed_capt.nondisplay_cc = 0;

	130 st->sdout_wss_525.copy_permit = SDO_525_COPY_PERMIT;

	131 st->sdout_wss_525.mv_psp = SDO_525_MV_PSP_OFF;

	132 st->sdout_wss_525.copy_info = SDO_525_COPY_INFO;

	133 st->sdout_wss_525.analog_on = false;

	134 st->sdout_wss_525.display_ratio = SDO_525_4_3_NORMAL;

	135 st->sdout_wss_625.surroun_f_sound = false;

	136 st->sdout_wss_625.copyright = false;

	137 st->sdout_wss_625.copy_protection = false;

	138 st->sdout_wss_625.text_subtitles = false;

	139 st->sdout_wss_625.open_subtitles = SDO_625_NO_OPEN_SUBTITLES;

	140 st->sdout_wss_625.camera_film = SDO_625_CAMERA;

	141 st->sdout_wss_625.color_encoding = SDO_625_NORMAL_PAL;

	142 st->sdout_wss_625.helper_signal = false;

	143 st->sdout_wss_625.display_ratio = SDO_625_4_3_FULL_576;

	144 st->sdout_cgms_525.copy_permit = SDO_525_COPY_PERMIT;

	145 st->sdout_cgms_525.mv_psp = SDO_525_MV_PSP_OFF;

	146 st->sdout_cgms_525.copy_info = SDO_525_COPY_INFO;

	147 st->sdout_cgms_525.analog_on = false;

	148 st->sdout_cgms_525.display_ratio = SDO_525_4_3_NORMAL;

	149 st->sdout_cgms_625.surroun_f_sound = false;

	150 st->sdout_cgms_625.copyright = false;

	151 st->sdout_cgms_625.copy_protection = false;

	152 st->sdout_cgms_625.text_subtitles = false;

	153 st->sdout_cgms_625.open_subtitles = SDO_625_NO_OPEN_SUBTITLES;

	154 st->sdout_cgms_625.camera_film = SDO_625_CAMERA;

	155 st->sdout_cgms_625.color_encoding = SDO_625_NORMAL_PAL;

	156 st->sdout_cgms_625.helper_signal = false;

	157 st->sdout_cgms_625.display_ratio = SDO_625_4_3_FULL_576;

	158

	159 /* Initialize HDMI video Parameters to Default Values */

	160 st->hdmi_video_blue_screen.enable = false;

	161 st->hdmi_color_range.y_min = 1;

	162 st->hdmi_color_range.y_max = 254;

	163 st->hdmi_color_range.c_min = 1;

	164 st->hdmi_color_range.c_max = 254;

	165 st->hdmi_av_info_frame.trans_type = HDMI_DO_NOT_TANS;

	166 st->hdmi_av_info_frame.check_sum = 0;

	167 st->hdmi_av_info_frame.data = st->avi_byte;

	168 st->hdmi_mpg_info_frame.trans_type = HDMI_DO_NOT_TANS;

	169 st->hdmi_mpg_info_frame.check_sum = 0;

	170 st->hdmi_mpg_info_frame.data = st->mpg_byte;

	171 memset((void *)(st->avi_byte), 0, 13);

	172 memset((void *)(st->mpg_byte), 0, 5);

	173 st->hdmi_tg_cmd.timing_correction_en = false;

	174 st->hdmi_tg_cmd.bt656_sync_en = false;

	175 st->hdmi_tg_cmd.tg_en = false;

	176

	177 /* Initialize HDMI Parameters to Default Values */

	178 st->hdmi_spd_info_frame.trans_type = HDMI_DO_NOT_TANS;

	179 st->hdmi_spd_info_frame.spd_header = st->spd_header;

	180 st->hdmi_spd_info_frame.spd_data = st->spd_data;

	181 memset((void *)(st->spd_header), 0, 3);

	182 memset((void *)(st->spd_data), 0, 8);

	183 st->hdcp_en = false;

	184 st->hdmi_audio_type = HDMI_AUDIO_PCM;

	185

	186 st->tvout_param_available = true;

	187

	188 return true;

	189 }

	190

	191

	192 bool tv_if_init_vm_reg(void)

	193 {

	194 u8 i = 0;

	195 enum s5p_tv_vmx_err merr = 0;

	196 struct s5p_tv_status *st = &s5ptv_status;

	197 enum s5p_tv_o_mode out_mode = st->tvout_param.out_mode;

	198 enum s5p_tv_disp_mode disp_mode = st->tvout_param.disp_mode;

	199

	200 bool cr_en = st->bg_dither.cr_dither_en;

	201 bool cb_en = st->bg_dither.cr_dither_en;

	202 bool y_en = st->bg_dither.cr_dither_en;

	203

	204 enum s5p_vmx_burst_mode burst = st->grp_burst;

	205 enum s5p_endian_type endian = st->grp_endian;

	206

	207

	208 merr = tv_vm_init_status_reg(burst, endian);

	209

	210 if (merr != VMIXER_NO_ERROR)

	211 return false;

	212

	213 merr = tv_vm_init_display_mode(disp_mode, out_mode);

	214

	215 if (merr != VMIXER_NO_ERROR)

	216 return false;

	217

	218 tv_vm_init_bg_dither_enable(cr_en, cb_en, y_en);

	219

	220 for (i = VMIXER_BG_COLOR_0; i <= VMIXER_BG_COLOR_2; i++) {

	221 merr = tv_vm_init_bg_color(i,

	222 st->bg_color[i].color_y,

	223 st->bg_color[i].color_cb,

	224 st->bg_color[i].color_cr);

	225

	226 if (merr != VMIXER_NO_ERROR)

	227 return false;

	228 }

	229

	230 switch (out_mode) {

	231

	232 case TVOUT_OUTPUT_COMPOSITE:

	233 case TVOUT_OUTPUT_SVIDEO:

	234 case TVOUT_OUTPUT_COMPONENT_YPBPR_INERLACED:

	235 case TVOUT_OUTPUT_COMPONENT_YPBPR_PROGRESSIVE:

	236 case TVOUT_OUTPUT_COMPONENT_RGB_PROGRESSIVE:

	237 tv_vm_init_csc_coef_default(VMIXER_CSC_RGB_TO_YUV601_FR);

	238 break;

	239

	240 case TVOUT_OUTPUT_HDMI_RGB:

	241 case TVOUT_OUTPUT_HDMI:

	242 case TVOUT_OUTPUT_DVI:

	243

	244 switch (disp_mode) {

	245

	246 case TVOUT_NTSC_M:

	247 case TVOUT_PAL_BDGHI:

	248 case TVOUT_PAL_M:

	249 case TVOUT_PAL_N:

	250 case TVOUT_PAL_NC:

	251 case TVOUT_PAL_60:

	252 case TVOUT_NTSC_443:

	253 break;

	254

	255 case TVOUT_480P_60_16_9:

	256 case TVOUT_480P_60_4_3:

	257 case TVOUT_480P_59:

	258 case TVOUT_576P_50_16_9:

	259 case TVOUT_576P_50_4_3:

	260 tv_vm_init_csc_coef_default(

	261 VMIXER_CSC_RGB_TO_YUV601_FR);

	262 break;

	263

	264 case TVOUT_720P_60:

	265 case TVOUT_720P_50:

	266 case TVOUT_720P_59:

	267 case TVOUT_1080I_60:

	268 case TVOUT_1080I_59:

	269 case TVOUT_1080I_50:

	270 case TVOUT_1080P_60:

	271 case TVOUT_1080P_30:

	272 case TVOUT_1080P_59:

	273 case TVOUT_1080P_50:

	274 tv_vm_init_csc_coef_default(

	275 VMIXER_CSC_RGB_TO_YUV709_FR);

	276 break;

	277 }

	278

	279 break;

	280

	281 default:

	282 TVOUTIFPRINTK("invalid tvout_param.out_mode parameter(%d)\n\r",

	283 out_mode);

	284 return false;

	285 }

	286

	287 tv_vm_start();

	288

	289 return true;

	290 }

	291

	292 bool tv_if_init_sd_reg(void)

	293 {

	294 u8 i = 0;

	295 enum s5p_tv_sd_err sderr = 0;

	296 struct s5p_tv_status *st = &s5ptv_status;

	297 enum s5p_tv_o_mode out_mode = st->tvout_param.out_mode;

	298 enum s5p_tv_disp_mode disp_mode = st->tvout_param.disp_mode;

	299 enum s5p_sd_order order = st->sdout_order;

	300

	301 u32 delay = st->sdout_delay.delay_y;

	302 u32 off_v_start = st->sdout_delay.offset_video_start;

	303 u32 off_v_end = st->sdout_delay.offset_video_end;

	304

	305 u32 g_bright = st->sdout_bri_hue_set.gain_brightness;

	306 u32 off_bright = st->sdout_bri_hue_set.offset_brightness;

	307 u32 g0_cb_h_sat = st->sdout_bri_hue_set.gain0_cb_hue_saturation;

	308 u32 g1_cb_h_sat = st->sdout_bri_hue_set.gain1_cb_hue_saturation;

	309 u32 g0_cr_h_sat = st->sdout_bri_hue_set.gain0_cr_hue_saturation;

	310 u32 g1_cr_h_sat = st->sdout_bri_hue_set.gain1_cr_hue_saturation;

	311 u32 off_cb_h_sat = st->sdout_bri_hue_set.offset_cb_hue_saturation;

	312 u32 off_cr_h_sat = st->sdout_bri_hue_set.offset_cr_hue_saturation;

	313

	314 u32 max_rgb_cube = st->sdout_rgb_compen.max_rgb_cube;

	315 u32 min_rgb_cube = st->sdout_rgb_compen.min_rgb_cube;

	316 u32 y_l_m_c = st->sdout_cvbs_compen.y_lower_mid;

	317 u32 y_b_c = st->sdout_cvbs_compen.y_bottom;

	318 u32 y_t_c = st->sdout_cvbs_compen.y_top;

	319 u32 y_u_m_c = st->sdout_cvbs_compen.y_upper_mid;

	320 u32 rad_c = st->sdout_cvbs_compen.radius;

	321 u32 y_t_s = st->sdout_svideo_compen.y_top;

	322 u32 y_b_s = st->sdout_svideo_compen.y_bottom;

	323 u32 y_cylinder_s = st->sdout_svideo_compen.yc_cylinder;

	324

	325 u32 back_525 = st->sdout_comp_porch.back_525;

	326 u32 front_525 = st->sdout_comp_porch.front_525;

	327 u32 back_625 = st->sdout_comp_porch.back_625;

	328 u32 front_625 = st->sdout_comp_porch.front_625;

	329

	330 u32 display_cc = st->sdout_closed_capt.display_cc;

	331 u32 nondisplay_cc = st->sdout_closed_capt.nondisplay_cc;

	332

	333 bool br_hue_sat_adj = st->sdout_bri_hue_set.bright_hue_sat_adj;

	334 bool wss_cvbs = st->sdout_vbi.wss_cvbs;

	335 bool wss_y_svideo = st->sdout_vbi.wss_y_svideo;

	336 bool cgmsa_rgb = st->sdout_vbi.cgmsa_rgb;

	337 bool wss_rgb = st->sdout_vbi.wss_rgb;

	338 bool cgmsa_y = st->sdout_vbi.cgmsa_y_pb_pr;

	339 bool wss_y = st->sdout_vbi.wss_y_pb_pr;

	340 bool phase_adj = st->sdout_color_sub_carrier_phase_adj;

	341 bool ypbpr_comp = st->sdout_y_pb_pr_comp;

	342 bool rgb_compen = st->sdout_rgb_compen.rgb_color_compensation;

	343 bool y_compen = st->sdout_svideo_compen.y_color_compensation;

	344 bool cvbs_compen = st->sdout_cvbs_compen.cvbs_color_compensation;

	345

	346 bool w5_analog_on = st->sdout_wss_525.analog_on;

	347 bool w6_surroun_f_sound = st->sdout_wss_625.surroun_f_sound;

	348 bool w6_copyright = st->sdout_wss_625.copyright;

	349 bool w6_copy_protection = st->sdout_wss_625.copy_protection;

	350 bool w6_text_subtitles = st->sdout_wss_625.text_subtitles;

	351 bool w6_helper_signal = st->sdout_wss_625.helper_signal;

	352

	353 bool c5_analog_on = st->sdout_cgms_525.analog_on;

	354 bool c6_surroun_f_sound = st->sdout_cgms_625.surroun_f_sound;

	355 bool c6_copyright = st->sdout_cgms_625.copyright;

	356 bool c6_copy_protection = st->sdout_cgms_625.copy_protection;

	357 bool c6_text_subtitles = st->sdout_cgms_625.text_subtitles;

	358 bool c6_helper_signal = st->sdout_cgms_625.helper_signal;

	359

	360 enum s5p_sd_level cpn_lev

	361 = st->sdout_video_scale_cfg.component_level;

	362 enum s5p_sd_level cps_lev

	363 = st->sdout_video_scale_cfg.composite_level;

	364 enum s5p_sd_vsync_ratio cpn_rat =

	365 st->sdout_video_scale_cfg.component_ratio;

	366 enum s5p_sd_vsync_ratio cps_rat =

	367 st->sdout_video_scale_cfg.composite_ratio;

	368 enum s5p_sd_closed_caption_type cap_cvbs =

	369 st->sdout_vbi.caption_cvbs;

	370 enum s5p_sd_closed_caption_type cap_y_svideo =

	371 st->sdout_vbi.caption_y_svideo;

	372 enum s5p_sd_closed_caption_type cap_rgb =

	373 st->sdout_vbi.caption_rgb;

	374 enum s5p_sd_closed_caption_type cap_y_pb_pr =

	375 st->sdout_vbi.caption_y_pb_pr;

	376 enum s5p_sd_sync_sig_pin sync_pin =

	377 st->sdout_sync_pin;

	378 enum s5p_sd_vesa_rgb_sync_type sync_type =

	379 st->sdout_rgb_sync.sync_type;

	380 enum s5p_tv_active_polarity vsync_active =

	381 st->sdout_rgb_sync.vsync_active;

	382 enum s5p_tv_active_polarity hsync_active =

	383 st->sdout_rgb_sync.hsync_active;

	384

	385 enum s5p_sd_525_copy_permit w5_copy_permit =

	386 st->sdout_wss_525.copy_permit;

	387 enum s5p_sd_525_mv_psp w5_mv_psp =

	388 st->sdout_wss_525.mv_psp;

	389 enum s5p_sd_525_copy_info w5_copy_info =

	390 st->sdout_wss_525.copy_info;

	391 enum s5p_sd_525_aspect_ratio w5_display_ratio =

	392 st->sdout_wss_525.display_ratio;

	393 enum s5p_sd_625_subtitles w6_open_subtitles =

	394 st->sdout_wss_625.open_subtitles;

	395 enum s5p_sd_625_camera_film w6_camera_film =

	396 st->sdout_wss_625.camera_film;

	397 enum s5p_sd_625_color_encoding w6_color_encoding =

	398 st->sdout_wss_625.color_encoding;

	399 enum s5p_sd_625_aspect_ratio w6_display_ratio =

	400 st->sdout_wss_625.display_ratio;

	401

	402 enum s5p_sd_525_copy_permit c5_copy_permit =

	403 st->sdout_cgms_525.copy_permit;

	404 enum s5p_sd_525_mv_psp c5_mv_psp =

	405 st->sdout_cgms_525.mv_psp;

	406 enum s5p_sd_525_copy_info c5_copy_info =

	407 st->sdout_cgms_525.copy_info;

	408 enum s5p_sd_525_aspect_ratio c5_display_ratio =

	409 st->sdout_cgms_525.display_ratio;

	410 enum s5p_sd_625_subtitles c6_open_subtitles =

	411 st->sdout_cgms_625.open_subtitles;

	412 enum s5p_sd_625_camera_film c6_camera_film =

	413 st->sdout_cgms_625.camera_film;

	414 enum s5p_sd_625_color_encoding c6_color_encoding =

	415 st->sdout_cgms_625.color_encoding;

	416 enum s5p_sd_625_aspect_ratio c6_display_ratio =

	417 st->sdout_cgms_625.display_ratio;

	418

	419 tv_sdout_sw_reset(true);

	420

	421 sderr = tv_sdout_init_display_mode(disp_mode, out_mode, order);

	422

	423 if (sderr != SDOUT_NO_ERROR)

	424 return false;

	425

	426 sderr = tv_sdout_init_video_scale_cfg(cpn_lev, cpn_rat,

	427 cps_lev, cps_rat);

	428

	429 if (sderr != SDOUT_NO_ERROR)

	430 return false;

	431

	432 sderr = tv_sdout_init_sync_signal_pin(sync_pin);

	433

	434 if (sderr != SDOUT_NO_ERROR)

	435 return false;

	436

	437 sderr = tv_sdout_init_vbi(wss_cvbs, cap_cvbs,

	438 wss_y_svideo, cap_y_svideo,

	439 cgmsa_rgb, wss_rgb, cap_rgb,

	440 cgmsa_y, wss_y, cap_y_pb_pr);

	441

	442 if (sderr != SDOUT_NO_ERROR)

	443 return false;

	444

	445 for (i = SDOUT_CHANNEL_0; i <= SDOUT_CHANNEL_2; i++) {

	446

	447 u32 offset = st->sdout_offset_gain[i].offset;

	448 u32 gain = st->sdout_offset_gain[i].gain;

	449

	450 sderr = tv_sdout_init_offset_gain(i, offset, gain);

	451

	452 if (sderr != SDOUT_NO_ERROR)

	453 return false;

	454 }

	455

	456

	457 tv_sdout_init_delay(delay, off_v_start, off_v_end);

	458

	459 tv_sdout_init_schlock(phase_adj);

	460

	461 tv_sdout_init_color_compensaton_onoff(br_hue_sat_adj, ypbpr_comp,

	462 rgb_compen, y_compen, cvbs_compen);

	463

	464 tv_sdout_init_brightness_hue_saturation(g_bright, off_bright,

	465 g0_cb_h_sat, g1_cb_h_sat, g0_cr_h_sat,

	466 g1_cr_h_sat, off_cb_h_sat, off_cr_h_sat);

	467

	468 tv_sdout_init_rgb_color_compensation(max_rgb_cube, min_rgb_cube);

	469

	470 tv_sdout_init_cvbs_color_compensation(y_l_m_c, y_b_c, y_t_c,

	471 y_u_m_c, rad_c);

	472

	473 tv_sdout_init_svideo_color_compensation(y_t_s, y_b_s, y_cylinder_s);

	474

	475 tv_sdout_init_component_porch(

	476 back_525, front_525, back_625, front_625);

	477

	478 sderr = tv_sdout_init_vesa_rgb_sync(

	479 sync_type, vsync_active, hsync_active);

	480

	481 if (sderr != SDOUT_NO_ERROR)

	482 return false;

	483

	484 for (i = SDOUT_CHANNEL_0; i <= SDOUT_CHANNEL_2; i++) {

	485 enum s5p_sd_channel_sel channel = st->sdout_xtalk_cc[i].channel;

	486 u32 coeff1 = st->sdout_xtalk_cc[i].coeff1;

	487 u32 coeff2 = st->sdout_xtalk_cc[i].coeff2;

	488

	489 sderr = tv_sdout_init_ch_xtalk_cancel_coef(

	490 channel, coeff2, coeff1);

	491

	492 if (sderr != SDOUT_NO_ERROR)

	493 return false;

	494 }

	495

	496 tv_sdout_init_closed_caption(display_cc, nondisplay_cc);

	497

	498 sderr = tv_sdout_init_wss525_data(w5_copy_permit, w5_mv_psp,

	499 w5_copy_info, w5_analog_on, w5_display_ratio);

	500

	501 if (sderr != SDOUT_NO_ERROR)

	502 return false;

	503

	504 sderr = tv_sdout_init_wss625_data(w6_surroun_f_sound, w6_copyright,

	505 w6_copy_protection, w6_text_subtitles,

	506 w6_open_subtitles, w6_camera_film,

	507 w6_color_encoding, w6_helper_signal,

	508 w6_display_ratio);

	509

	510 if (sderr != SDOUT_NO_ERROR)

	511 return false;

	512

	513 sderr = tv_sdout_init_cgmsa525_data(c5_copy_permit, c5_mv_psp,

	514 c5_copy_info, c5_analog_on,

	515 c5_display_ratio);

	516

	517 if (sderr != SDOUT_NO_ERROR)

	518 return false;

	519

	520 sderr = tv_sdout_init_cgmsa625_data(c6_surroun_f_sound, c6_copyright,

	521 c6_copy_protection, c6_text_subtitles,

	522 c6_open_subtitles, c6_camera_film,

	523 c6_color_encoding, c6_helper_signal,

	524 c6_display_ratio);

	525

	526 if (sderr != SDOUT_NO_ERROR)

	527 return false;

	528

	529 /* Disable All Interrupt */

	530 tv_sdout_set_interrupt_enable(false);

	531

	532 /* Clear All Interrupt Pending */

	533 tv_sdout_clear_interrupt_pending();

	534

	535 tv_sdout_start();

	536

	537 tv_powerset_dac_onoff(true);

	538

	539 for (i = SDOUT_CHANNEL_0; i <= SDOUT_CHANNEL_2; i++) {

	540

	541 bool dac = st->sdout_dac_on[i];

	542

	543 sderr = tv_sdout_init_dac_power_onoff(i, dac);

	544

	545 if (sderr != SDOUT_NO_ERROR)

	546 return false;

	547 }

	548

	549 return true;

	550 }

	551

	552 bool tv_if_init_hd_video_reg(void)

	553 {

	554 enum s5p_tv_hdmi_err herr = 0;

	555 enum s5p_tv_hdmi_csc_type cscType;

	556 struct s5p_tv_status *st = &s5ptv_status;

	557

	558 bool blue_enable = st->hdmi_video_blue_screen.enable;

	559 u8 cb_b = st->hdmi_video_blue_screen.cb_b;

	560 u8 y_g = st->hdmi_video_blue_screen.y_g;

	561 u8 cr_r = st->hdmi_video_blue_screen.cr_r;

	562

	563 u8 y_min = st->hdmi_color_range.y_min;

	564 u8 y_max = st->hdmi_color_range.y_max;

	565 u8 c_min = st->hdmi_color_range.c_min;

	566 u8 c_max = st->hdmi_color_range.c_max;

	567

	568 enum s5p_tv_disp_mode disp_mode = st->tvout_param.disp_mode;

	569 enum s5p_tv_o_mode out_mode = st->tvout_param.out_mode;

	570

	571 enum s5p_hdmi_transmit a_trans_type

	572 = st->hdmi_av_info_frame.trans_type;

	573 u8 a_check_sum = st->hdmi_av_info_frame.check_sum;

	574 u8 *a_data = st->hdmi_av_info_frame.data;

	575

	576 enum s5p_hdmi_transmit m_trans_type

	577 = st->hdmi_mpg_info_frame.trans_type;

	578 u8 m_check_sum = st->hdmi_mpg_info_frame.check_sum;

	579 u8 *m_data = st->hdmi_mpg_info_frame.data;

	580

	581 enum s5p_hdmi_transmit s_trans_type

	582 = st->hdmi_spd_info_frame.trans_type;

	583 u8 *spd_header = st->hdmi_spd_info_frame.spd_header;

	584 u8 *spd_data = st->hdmi_spd_info_frame.spd_data;

	585

	586 bool timing_correction_en = st->hdmi_tg_cmd.timing_correction_en;

	587 bool bt656_sync_en = st->hdmi_tg_cmd.bt656_sync_en;

	588 bool tg_en;

	589

	590

	591 herr = tv_hdmi_video_init_display_mode(disp_mode, out_mode);

	592

	593 if (herr != HDMI_NO_ERROR)

	594 return false;

	595

	596 tv_hdmi_video_init_bluescreen(blue_enable, cb_b, y_g, cr_r);

	597

	598

	599 tv_hdmi_video_init_color_range(y_min, y_max, c_min, c_max);

	600

	601 switch (out_mode) {

	602

	603 case TVOUT_OUTPUT_HDMI_RGB:

	604 case TVOUT_OUTPUT_HDMI:

	605 cscType = HDMI_BYPASS;

	606 break;

	607

	608 case TVOUT_OUTPUT_DVI:

	609 cscType = HDMI_CSC_YUV601_TO_RGB_LR;

	610 break;

	611

	612 default:

	613 TVOUTIFPRINTK("invalid out_mode parameter(%d)\n\r",

	614 out_mode);

	615 return false;

	616 }

	617

	618 herr = tv_hdmi_video_init_csc(cscType);

	619

	620 if (herr != HDMI_NO_ERROR)

	621 return false;

	622

	623 herr = tv_hdmi_video_init_avi_infoframe(a_trans_type,

	624 a_check_sum, a_data);

	625

	626 if (herr != HDMI_NO_ERROR)

	627 return false;

	628

	629 herr = tv_hdmi_video_init_mpg_infoframe(m_trans_type,

	630 m_check_sum, m_data);

	631

	632 if (herr != HDMI_NO_ERROR)

	633 return false;

	634

	635 herr = tv_hdmi_init_spd_infoframe(s_trans_type,

	636 spd_header, spd_data);

	637

	638 if (herr != HDMI_NO_ERROR)

	639 return false;

	640

	641 st->hdmi_tg_cmd.tg_en = true;

	642 tg_en = st->hdmi_tg_cmd.tg_en;

	643

	644 tv_hdmi_video_init_tg_cmd(

	645 timing_correction_en, bt656_sync_en, tg_en);

	646

	647 return true;

	648 }

	649

	650 unsigned char tv_if_video_avi_checksum(void)

	651 {

	652 u8 i;

	653 u32 sum = 0;

	654 struct s5p_tv_status *st = &s5ptv_status;

	655

	656 for (i = 0; i < 13; i++)

	657 sum += (u32)(st->avi_byte[i]);

	658

	659 return (u8)(0x100 - ((0x91 + sum) & 0xff));

	660 }

	661

	662 bool tv_if_init_avi_frame(struct tvout_output_if *tvout_if)

	663 {

	664 struct s5p_tv_status *st = &s5ptv_status;

	665 TVOUTIFPRINTK("(%d, %d)\n\r", tvout_if->disp_mode,

	666 tvout_if->out_mode);

	667

	668 st->hdmi_av_info_frame.trans_type = HDMI_TRANS_EVERY_SYNC;

	669 st->avi_byte[1] = AVI_ITU709;

	670 st->avi_byte[4] = AVI_NO_PIXEL_REPEAT;

	671

	672 switch (tvout_if->disp_mode) {

	673

	674 case TVOUT_480P_59:

	675 case TVOUT_480P_60_16_9:

	676 st->avi_byte[1] \|= AVI_PAR_16_9;

	677 st->avi_byte[3] = AVI_VIC_3;

	678 break;

	679

	680 case TVOUT_480P_60_4_3:

	681 st->avi_byte[1] \|= AVI_PAR_4_3;

	682 st->avi_byte[3] = AVI_VIC_2;

	683 break;

	684

	685 case TVOUT_576P_50_16_9:

	686 st->avi_byte[1] \|= AVI_PAR_16_9;

	687 st->avi_byte[3] = AVI_VIC_18;

	688 break;

	689

	690 case TVOUT_576P_50_4_3:

	691 st->avi_byte[1] \|= AVI_PAR_4_3;

	692 st->avi_byte[3] = AVI_VIC_17;

	693 break;

	694

	695 case TVOUT_720P_50:

	696 st->avi_byte[1] \|= AVI_PAR_16_9;

	697 st->avi_byte[3] = AVI_VIC_19;

	698 break;

	699

	700 case TVOUT_720P_60:

	701 case TVOUT_720P_59:

	702 st->avi_byte[1] \|= AVI_PAR_16_9;

	703 st->avi_byte[3] = AVI_VIC_4;

	704 break;

	705

	706 case TVOUT_1080I_50:

	707 st->avi_byte[1] \|= AVI_PAR_16_9;

	708 st->avi_byte[3] = AVI_VIC_20;

	709 break;

	710

	711 case TVOUT_1080I_59:

	712 case TVOUT_1080I_60:

	713 st->avi_byte[1] \|= AVI_PAR_16_9;

	714 st->avi_byte[3] = AVI_VIC_5;

	715 break;

	716

	717 case TVOUT_1080P_50:

	718 st->avi_byte[1] \|= AVI_PAR_16_9;

	719 st->avi_byte[3] = AVI_VIC_31;

	720 break;

	721

	722 case TVOUT_1080P_30:

	723 st->avi_byte[1] \|= AVI_PAR_16_9;

	724 st->avi_byte[3] = AVI_VIC_34;

	725

	726 case TVOUT_1080P_59:

	727 case TVOUT_1080P_60:

	728 st->avi_byte[1] \|= AVI_PAR_16_9;

	729 st->avi_byte[3] = AVI_VIC_16;

	730 break;

	731 default:

	732 TVOUTIFPRINTK("invalid disp_mode parameter(%d)\n\r",

	733 tvout_if->out_mode);

	734 return false;

	735 }

	736

	737 switch (tvout_if->out_mode) {

	738

	739 case TVOUT_OUTPUT_DVI:

	740 st->hdmi_av_info_frame.trans_type = HDMI_DO_NOT_TANS;

	741 st->avi_byte[0] = AVI_RGB_IF;

	742 st->avi_byte[1] = AVI_ITU601;

	743 break;

	744

	745 case TVOUT_OUTPUT_HDMI_RGB:

	746 st->hdmi_av_info_frame.trans_type = HDMI_TRANS_EVERY_SYNC;

	747 st->avi_byte[0] = AVI_RGB_IF;

	748 st->avi_byte[1] = AVI_ITU601;

	749 break;

	750

	751 case TVOUT_OUTPUT_HDMI:

	752 st->hdmi_av_info_frame.trans_type = HDMI_TRANS_EVERY_SYNC;

	753 st->avi_byte[0] = AVI_YCBCR444_IF;

	754 st->avi_byte[1] = AVI_ITU709;

	755 break;

	756

	757 default:

	758 TVOUTIFPRINTK("invalid out_mode parameter(%d)\n\r",

	759 tvout_if->out_mode);

	760 return false;

	761 }

	762

	763 st->hdmi_av_info_frame.check_sum = tv_if_video_avi_checksum();

	764

	765 TVOUTIFPRINTK("()\n\r");

	766 return true;

	767 }

	768

	769

	770 bool tv_if_init_hd_reg(void)

	771 {

	772 struct s5p_tv_status *st = &s5ptv_status;

	773

	774 TVOUTIFPRINTK("audio type : %d, hdcp : %s)\n\r",

	775 st->hdmi_audio_type, st->hdcp_en ? "enabled" : "disabled");

	776

	777 if (!tv_if_init_hd_video_reg())

	778 return false;

	779

	780 switch (st->hdmi_audio_type) {

	781

	782 case HDMI_AUDIO_PCM:

	783 /*

	784 * PCM, Samplingrate 48000, 16bit,

	785 * ignore framesize cuz stream is PCM.

	786 */

	787 tv_hdmi_audio_init(PCM, 48000, 16, 0);

	788 break;

	789

	790 case HDMI_AUDIO_NO:

	791 break;

	792

	793 default:

	794 TVOUTIFPRINTK("invalid hdmi_audio_type(%d)\n\r",

	795 st->hdmi_audio_type);

	796 return false;

	797 }

	798

	799 st->hpd_status = 1;

	800

	801 tv_hdmi_stop();

	802

	803 if (!tv_hdmi_start(st->hdmi_audio_type,

	804 (st->hdcp_en && st->hpd_status),

	805 st->hdcp_i2c_client)) {

	806 return false;

	807 }

	808

	809 return true;

	810 }

	811

	812 bool tv_if_start(void)

	813 {

	814 struct s5p_tv_status *st = &s5ptv_status;

	815 enum s5p_tv_clk_err cerr = HDMI_NO_ERROR;

	816

	817 enum s5p_tv_o_mode out_mode = st->tvout_param.out_mode;

	818

	819 tv_vm_set_underflow_interrupt_enable(VM_VIDEO_LAYER,

	820 false);

	821 tv_vm_set_underflow_interrupt_enable(VM_GPR0_LAYER,

	822 false);

	823 tv_vm_set_underflow_interrupt_enable(VM_GPR1_LAYER,

	824 false);

	825

	826 tv_if_stop();

	827

	828 if (st->vp_layer_enable)

	829 tv_vlayer_stop();

	830

	831 /* Clear All Interrupt Pending */

	832 tv_vm_clear_pend_all();

	833

	834

	835 /*

	836 * have not to call

	837 * another request function simultaneously

	838 */

	839 tv_poweron();

	840

	841 switch (out_mode) {

	842

	843 case TVOUT_OUTPUT_COMPOSITE:

	844 case TVOUT_OUTPUT_SVIDEO:

	845 case TVOUT_OUTPUT_COMPONENT_YPBPR_INERLACED:

	846 case TVOUT_OUTPUT_COMPONENT_YPBPR_PROGRESSIVE:

	847 case TVOUT_OUTPUT_COMPONENT_RGB_PROGRESSIVE:

	848 tv_clk_init_video_mixer(TVOUT_CLK_VMIXER_SRCCLK_VCLK_54);

	849 tv_clk_init_hpll(0, 0xffff, 108, 6, 3);

	850 break;

	851

	852 case TVOUT_OUTPUT_HDMI:

	853 case TVOUT_OUTPUT_HDMI_RGB:

	854 case TVOUT_OUTPUT_DVI:

	855 tv_clk_init_video_mixer(

	856 TVOUT_CLK_VMIXER_SRCCLK_MOUT_HPLL);

	857

	858 cerr = tv_clk_init_mout_hpll(

	859 S5P_TV_CLK_MOUT_HPLL_FOUT_HPLL);

	860

	861 if (cerr != S5P_TV_CLK_ERR_NO_ERROR)

	862 return false;

	863

	864 tv_clk_init_hdmi_ratio(0);

	865 break;

	866

	867 default:

	868 tv_if_stop();

	869 TVOUTIFPRINTK("invalid out_mode parameter(%d)\n\r",

	870 st->tvout_param.out_mode);

	871 st->tvout_param_available = false;

	872 return false;

	873 }

	874

	875 if (!tv_if_init_vm_reg())

	876 return false;

	877

	878 switch (out_mode) {

	879

	880 case TVOUT_OUTPUT_COMPOSITE:

	881 case TVOUT_OUTPUT_SVIDEO:

	882 case TVOUT_OUTPUT_COMPONENT_YPBPR_INERLACED:

	883 case TVOUT_OUTPUT_COMPONENT_YPBPR_PROGRESSIVE:

	884 case TVOUT_OUTPUT_COMPONENT_RGB_PROGRESSIVE:

	885 if (!tv_if_init_sd_reg())

	886 return false;

	887

	888 break;

	889

	890 case TVOUT_OUTPUT_DVI:

	891 st->hdmi_audio_type = HDMI_AUDIO_NO;

	892

	893 case TVOUT_OUTPUT_HDMI:

	894 case TVOUT_OUTPUT_HDMI_RGB:

	895 if (!tv_if_init_hd_reg())

	896 return false;

	897

	898 break;

	899

	900 default:

	901 tv_if_stop();

	902 TVOUTIFPRINTK("invalid out_mode parameter(%d)\n\r",

	903 out_mode);

	904 return false;

	905 }

	906

	907 st->tvout_output_enable = true;

	908

	909 tv_vm_set_underflow_interrupt_enable(VM_VIDEO_LAYER,

	910 true);

	911 tv_vm_set_underflow_interrupt_enable(VM_GPR0_LAYER,

	912 true);

	913 tv_vm_set_underflow_interrupt_enable(VM_GPR1_LAYER,

	914 true);

	915

	916 /* Clear All Interrupt Pending */

	917 tv_vm_clear_pend_all();

	918

	919 TVOUTIFPRINTK("()\n\r");

	920

	921 return true;

	922 }

	923

	924 /*

	925 * TV cut off sequence

	926 * VP stop -> Mixer stop -> HDMI stop -> HDMI TG stop

	927 * Above sequence should be satisfied.

	928 */

	929 bool tv_if_stop(void)

	930 {

	931 struct s5p_tv_status *st = &s5ptv_status;

	932

	933 bool t_corr_en = st->hdmi_tg_cmd.timing_correction_en;

	934 bool sync_en = st->hdmi_tg_cmd.bt656_sync_en;

	935 enum s5p_tv_o_mode out_mode = st->tvout_param.out_mode;

	936

	937 TVOUTIFPRINTK("tvout sub sys. stopped!!\n");

	938

	939 tv_vm_stop();

	940

	941 switch (out_mode) {

	942

	943 case TVOUT_OUTPUT_COMPOSITE:

	944 case TVOUT_OUTPUT_SVIDEO:

	945 case TVOUT_OUTPUT_COMPONENT_YPBPR_INERLACED:

	946 case TVOUT_OUTPUT_COMPONENT_YPBPR_PROGRESSIVE:

	947 case TVOUT_OUTPUT_COMPONENT_RGB_PROGRESSIVE:

	948 if (st->tvout_output_enable)

	949 tv_sdout_stop();

	950 break;

	951

	952 case TVOUT_OUTPUT_HDMI:

	953 case TVOUT_OUTPUT_HDMI_RGB:

	954 case TVOUT_OUTPUT_DVI:

	955 if (st->tvout_output_enable) {

	956 tv_hdmi_stop();

	957 tv_hdmi_video_init_tg_cmd(t_corr_en, sync_en, false);

	958 }

	959 break;

	960

	961 default:

	962 TVOUTIFPRINTK("invalid out_mode parameter(%d)\n\r", out_mode);

	963 return false;

	964 }

	965

	966 st->tvout_output_enable = false;

	967 st->tvout_param_available = false;

	968

	969 return true;

	970 }

	971

	972 /*

	973 * before call this ftn. set the status data!!

	974 */

	975 bool tv_if_set_disp(void)

	976 {

	977 struct s5p_tv_status *st = &s5ptv_status;

	978

	979 enum s5p_tv_disp_mode disp_mode = st->tvout_param.disp_mode;

	980 enum s5p_tv_o_mode out_mode = st->tvout_param.out_mode;

	981

	982 TVOUTIFPRINTK("(%d, %d)\n\r", disp_mode, out_mode);

	983

	984 switch (disp_mode) {

	985

	986 case TVOUT_NTSC_M:

	987 case TVOUT_NTSC_443:

	988 st->sdout_video_scale_cfg.component_level =

	989 S5P_TV_SD_LEVEL_0IRE;

	990 st->sdout_video_scale_cfg.component_ratio =

	991 SDOUT_VTOS_RATIO_7_3;

	992 st->sdout_video_scale_cfg.composite_level =

	993 S5P_TV_SD_LEVEL_75IRE;

	994 st->sdout_video_scale_cfg.composite_ratio =

	995 SDOUT_VTOS_RATIO_10_4;

	996 break;

	997

	998 case TVOUT_PAL_BDGHI:

	999 case TVOUT_PAL_M:

	1000 case TVOUT_PAL_N:

	1001 case TVOUT_PAL_NC:

	1002 case TVOUT_PAL_60:

	1003 st->sdout_video_scale_cfg.component_level =

	1004 S5P_TV_SD_LEVEL_0IRE;

	1005 st->sdout_video_scale_cfg.component_ratio =

	1006 SDOUT_VTOS_RATIO_7_3;

	1007 st->sdout_video_scale_cfg.composite_level =

	1008 S5P_TV_SD_LEVEL_0IRE;

	1009 st->sdout_video_scale_cfg.composite_ratio =

	1010 SDOUT_VTOS_RATIO_7_3;

	1011 break;

	1012

	1013 case TVOUT_480P_60_16_9:

	1014 case TVOUT_480P_60_4_3:

	1015 case TVOUT_576P_50_16_9:

	1016 case TVOUT_576P_50_4_3:

	1017 case TVOUT_720P_50:

	1018 case TVOUT_720P_60:

	1019 case TVOUT_1080I_50:

	1020 case TVOUT_1080I_60:

	1021 case TVOUT_1080P_50:

	1022 case TVOUT_1080P_60:

	1023 case TVOUT_1080P_30:

	1024 case TVOUT_480P_59:

	1025 case TVOUT_720P_59:

	1026 case TVOUT_1080I_59:

	1027 case TVOUT_1080P_59:

	1028 if (!tv_if_init_avi_frame(&st->tvout_param)) {

	1029 st->tvout_param_available = false;

	1030 return false;

	1031 }

	1032

	1033 break;

	1034

	1035 default:

	1036 TVOUTIFPRINTK("invalid disp_mode parameter(%d)\n\r", disp_mode);

	1037 st->tvout_param_available = false;

	1038 return false;

	1039 }

	1040

	1041 switch (out_mode) {

	1042

	1043 case TVOUT_OUTPUT_COMPOSITE:

	1044 st->sdout_order = S5P_TV_SD_O_ORDER_COMPOSITE_Y_C_CVBS;

	1045 st->sdout_dac_on[2] = false;

	1046 st->sdout_dac_on[1] = false;

	1047 st->sdout_dac_on[0] = true;

	1048 break;

	1049

	1050 case TVOUT_OUTPUT_SVIDEO:

	1051 st->sdout_order = S5P_TV_SD_O_ORDER_COMPOSITE_C_Y_CVBS;

	1052 st->sdout_dac_on[2] = true;

	1053 st->sdout_dac_on[1] = true;

	1054 st->sdout_dac_on[0] = false;

	1055 break;

	1056

	1057 case TVOUT_OUTPUT_COMPONENT_YPBPR_INERLACED:

	1058 case TVOUT_OUTPUT_COMPONENT_YPBPR_PROGRESSIVE:

	1059 case TVOUT_OUTPUT_COMPONENT_RGB_PROGRESSIVE:

	1060 st->sdout_order = S5P_TV_SD_O_ORDER_COMPONENT_RBG_PRPBY;

	1061 st->sdout_dac_on[2] = true;

	1062 st->sdout_dac_on[1] = true;

	1063 st->sdout_dac_on[0] = true;

	1064 break;

	1065

	1066 case TVOUT_OUTPUT_HDMI_RGB:

	1067 case TVOUT_OUTPUT_HDMI:

	1068 case TVOUT_OUTPUT_DVI:

	1069 st->hdmi_video_blue_screen.cb_b = 0;/128;/

	1070 st->hdmi_video_blue_screen.y_g = 0;

	1071 st->hdmi_video_blue_screen.cr_r = 0;/128;/

	1072 break;

	1073

	1074 default:

	1075 TVOUTIFPRINTK("invalid out_mode parameter(%d)\n\r", out_mode);

	1076 st->tvout_param_available = false;

	1077 return false;

	1078 }

	1079

	1080 tv_if_start();

	1081

	1082 return true;

	1083 }

OLD	NEW

« no previous file with comments | « drivers/media/video/samsung/tv20/s5p_stda_grp.c ('k') | drivers/media/video/samsung/tv20/s5p_stda_video_layer.c » ('j') | no next file with comments »