void mdnie_lite_tuning_init(void)
{
init_mdnie_class();
mipi_dsi_buf_alloc(&mdnie_tun_tx_buf, DSI_BUF_SIZE);
mipi_dsi_buf_alloc(&mdnie_tun_rx_buf, DSI_BUF_SIZE);
}
static int __devinit mipi_hx8389b_lcd_probe(struct platform_device *pdev)
{
struct platform_device *pthisdev = NULL;
#if defined(CONFIG_LCD_CLASS_DEVICE)
struct lcd_device *lcd_device;
int ret;
#endif
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
struct backlight_device *bd;
#endif
pr_debug("%s\n", __func__);
pthisdev = msm_fb_add_device(pdev);
mutex_init(&dsi_tx_mutex);
#if defined(CONFIG_LCD_CLASS_DEVICE)
lcd_device = lcd_device_register("panel", &pdev->dev, NULL,
&mipi_lcd_props);
if (IS_ERR(lcd_device)) {
int ret = PTR_ERR(lcd_device);
printk(KERN_ERR "lcd : failed to register device\n");
return ret;
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_type.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_type.attr.name);
}
#endif
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
bd = backlight_device_register("panel", &lcd_device->dev,
NULL, NULL, NULL);
if (IS_ERR(bd)) {
ret = PTR_ERR(bd);
pr_info("backlight : failed to register device\n");
return ret;
}
#endif
#if defined(CONFIG_MDNIE_LITE_TUNING)
/* mdnie sysfs create */
init_mdnie_class();
#endif
return 0;
}
static int mdnie_pwm_probe(struct platform_device *pdev)
{
struct backlight_device *bd;
printk("MDNIE_PWM Probe START!!!\n");
bd = backlight_device_register("s5p_bl", &pdev->dev, pdev, &mdnie_pwm_ops);
if (IS_ERR(bd))
return PTR_ERR(bd);
platform_set_drvdata(pdev, bd);
bd->props.max_brightness = MDNIE_PWM_MAX_INTENSITY;
bd->props.brightness = MDNIE_PWM_DEFAULT_INTENSITY;
mdnie_pwm_gpio_init();
// s5p_mdine_pwm_enable(1);
// mdnie_pwm_set_intensity(bd);
dev_info(&pdev->dev, "mdnie_pwm backlight driver is enabled.\n");
bl_pdev = pdev;
#ifdef CONFIG_HAS_EARLYSUSPEND
st_early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
st_early_suspend.suspend = mdnie_pwm_early_suspend;
st_early_suspend.resume = mdnie_pwm_early_resume;
register_early_suspend(&st_early_suspend);
#endif /* CONFIG_HAS_EARLYSUSPEND */
#ifdef CONFIG_FB_S3C_MDNIE
init_mdnie_class(); //set mDNIe UI mode, Outdoormode
#endif
printk("MDNIE_PWM Probe END!!!\n");
return 0;
}
static int __devinit mipi_novatek_disp_probe(struct platform_device *pdev)
{
struct platform_device *msm_fb_added_dev;
#if defined(CONFIG_LCD_CLASS_DEVICE)
struct lcd_device *lcd_device;
int ret;
#endif
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
struct backlight_device *bd;
#endif
msd.dstat.acl_on = false;
is_lcd_on = LCD_STATUS_ON;
if (pdev->id == 0) {
msd.mipi_novatek_disp_pdata = pdev->dev.platform_data;
#ifdef CONFIG_SAMSUNG_CMC624
if (samsung_has_cmc624()) {
printk(KERN_DEBUG "Is_There_cmc624 : CMC624 is there!!!!");
samsung_cmc624_init();
} else {
printk(KERN_DEBUG "Is_There_cmc624 : CMC624 is not there!!!!");
}
#endif
return 0;
}
msm_fb_added_dev = msm_fb_add_device(pdev);
#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_LCD_CLASS_DEVICE)
msd.msm_pdev = msm_fb_added_dev;
#endif
#if defined(CONFIG_HAS_EARLYSUSPEND)
msd.early_suspend.suspend = mipi_novatek_disp_early_suspend;
msd.early_suspend.resume = mipi_novatek_disp_late_resume;
msd.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
register_early_suspend(&msd.early_suspend);
#endif
#if defined(CONFIG_LCD_CLASS_DEVICE)
lcd_device = lcd_device_register("panel", &pdev->dev, NULL,
&mipi_novatek_disp_props);
if (IS_ERR(lcd_device)) {
ret = PTR_ERR(lcd_device);
printk(KERN_ERR "lcd : failed to register device\n");
return ret;
}
#ifdef WA_FOR_FACTORY_MODE
sysfs_remove_file(&lcd_device->dev.kobj,
&dev_attr_lcd_power.attr);
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_power.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_power.attr.name);
}
#endif
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_type.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_type.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_gamma_mode.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_gamma_mode.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_power_reduce.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_power_reduce.attr.name);
}
#if defined(CONFIG_MACH_MELIUS)
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_siop_enable.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_siop_enable.attr.name);
}
#endif
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
bd = backlight_device_register("panel", &lcd_device->dev,
NULL, NULL, NULL);
if (IS_ERR(bd)) {
ret = PTR_ERR(bd);
pr_info("backlight : failed to register device\n");
return ret;
}
ret = sysfs_create_file(&bd->dev.kobj,
&dev_attr_auto_brightness.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_auto_brightness.attr.name);
}
#endif
#endif
#ifdef CONFIG_SAMSUNG_CMC624
if (samsung_has_cmc624()) {
ret = cmc624_sysfs_init();
if (ret < 0)
pr_debug("CMC624 sysfs initialize FAILED\n");
}
else
#if defined(CONFIG_FB_MDP4_ENHANCE)
init_mdnie_class();
#endif
#endif
pr_debug("%s:Display probe completed\n", __func__);
return 0;
}
static int __devinit lcd_probe(struct platform_device *pdev)
{
int ret = 0;
int default_gamma_value;
if (pdev->id == 0) {
pdata = pdev->dev.platform_data;
DPRINT("%s\n", __func__);
return 0;
}
DPRINT("%s+ \n", __func__);
pMFD = platform_get_drvdata(pdev);
// get default-gamma address from gamma table
for( default_gamma_value = 0; default_gamma_value <= MAX_GAMMA_VALUE; default_gamma_value++)
if( lcd_Gamma22_Meterial13_table[default_gamma_value].lux >= DEFAULT_CANDELA_VALUE ) break;
s6e8aa0_lcd.stored_gamma = default_gamma_value;
s6e8aa0_lcd.stored_elvss = default_gamma_value;
s6e8aa0_lcd.lcd_gamma = -1;
s6e8aa0_lcd.enabled_acl= 1;
s6e8aa0_lcd.stored_acl= default_gamma_value;
s6e8aa0_lcd.lcd_acl = -1;
s6e8aa0_lcd.lcd_state.display_on = false;
s6e8aa0_lcd.lcd_state.initialized= false;
s6e8aa0_lcd.lcd_state.powered_up= false;
s6e8aa0_lcd.factory_id_line = lcd_id_unknown;
s6e8aa0_lcd.factory_id_material = lcd_id_unknown;
s6e8aa0_lcd.factory_id_material = lcd_id_unknown;
s6e8aa0_lcd.factory_id_boardDCDC = lcd_id_unknown;
s6e8aa0_lcd.factory_id_lcdDCDC = lcd_id_unknown;
s6e8aa0_lcd.lcd_brightness_table = lcd_Gamma22_Meterial13_table;
s6e8aa0_lcd.lcd_acl_table = lcd_acl_table;
s6e8aa0_lcd.lcd_elvss_table = lcd_elvss_table;
s6e8aa0_lcd.eachElvss_value = 0;
s6e8aa0_lcd.eachElvss_vector = 0;
s6e8aa0_lcd.isSmartDimming = FALSE;
s6e8aa0_lcd.isSmartDimming_loaded = FALSE;
mutex_init( &(s6e8aa0_lcd.lock) );
#ifdef CONFIG_HAS_EARLYSUSPEND
s6e8aa0_lcd.early_suspend.suspend = early_suspend;
s6e8aa0_lcd.early_suspend.resume = late_resume;
s6e8aa0_lcd.early_suspend.level = LCD_OFF_GAMMA_VALUE;
register_early_suspend(&s6e8aa0_lcd.early_suspend);
#endif
DPRINT("msm_fb_add_device +\n");
msm_fb_add_device(pdev);
DPRINT("msm_fb_add_device -\n");
/////////////[ sysfs
pwm_backlight_class = class_create(THIS_MODULE, "pwm-backlight");
if (IS_ERR(pwm_backlight_class))
pr_err("Failed to create class(pwm_backlight)!\n");
pwm_backlight_dev = device_create(pwm_backlight_class,
NULL, 0, NULL, "device");
if (IS_ERR(pwm_backlight_dev))
pr_err("Failed to create device(pwm_backlight_dev)!\n");
ret = device_create_file(pwm_backlight_dev, &dev_attr_acl_set);
if (ret < 0)
dev_err(&(pdev->dev), "failed to add sysfs entries\n");
ret = device_create_file(pwm_backlight_dev, &dev_attr_lcdtype);
if (ret < 0)
dev_err(&(pdev->dev), "failed to add sysfs entries\n");
ret = device_create_file(pwm_backlight_dev, &dev_attr_octa_lcdtype);
if (ret < 0)
DPRINT("octa_lcdtype failed to add sysfs entries\n");
// dev_err(&(pdev->dev), "failed to add sysfs entries\n");
ret = device_create_file(pwm_backlight_dev, &dev_attr_lcd_power);
if (ret < 0)
DPRINT("lcd_power failed to add sysfs entries\n");
// dev_err(&(pdev->dev), "failed to add sysfs entries\n");
// mdnie sysfs create
init_mdnie_class();
////////////]
DPRINT("%s- \n", __func__);
return 0;
}
int mdss_dsi_panel_init(struct device_node *node,
struct mdss_dsi_ctrl_pdata *ctrl_pdata,
bool cmd_cfg_cont_splash)
{
int rc = 0;
static const char *panel_name;
bool cont_splash_enabled;
#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
int disp_esd_gpio;
#endif
#if defined(CONFIG_LCD_CLASS_DEVICE)
struct lcd_device *lcd_device;
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
struct backlight_device *bd = NULL;
#endif
#endif
#if defined(CONFIG_LCD_CLASS_DEVICE)
struct device_node *np = NULL;
struct platform_device *pdev = NULL;
np = of_parse_phandle(node,
"qcom,mdss-dsi-panel-controller", 0);
if (!np) {
pr_err("%s: Dsi controller node not initialized\n", __func__);
return -EPROBE_DEFER;
}
pdev = of_find_device_by_node(np);
#endif
#if defined(CONFIG_BACKLIGHT_IC_KTD253)
mutex_init(&bg_lock);
#endif
#if defined(CONFIG_FB_MSM8x26_MDSS_CHECK_LCD_CONNECTION)
printk("%s: LCD attached status: %d !\n",
__func__, get_samsung_lcd_attached());
#endif
#ifdef DDI_VIDEO_ENHANCE_TUNING
mutex_init(&msd.lock);
#endif
if (!node) {
pr_err("%s: no panel node\n", __func__);
return -ENODEV;
}
pr_debug("%s:%d\n", __func__, __LINE__);
panel_name = of_get_property(node, "qcom,mdss-dsi-panel-name", NULL);
if (!panel_name)
pr_info("%s:%d, Panel name not specified\n",
__func__, __LINE__);
else
pr_info("%s: Panel Name = %s\n", __func__, panel_name);
#if defined(CONFIG_BACKLIGHT_IC_KTD2801)
virt_mmss_gp0_base = ioremap(MMSS_GP0_BASE,MMSS_GP0_SIZE);
if(virt_mmss_gp0_base == NULL) {
pr_err("%s: I/O remap failed \n", __func__);
return 0;
}
#endif
rc = mdss_panel_parse_dt(node, ctrl_pdata);
if (rc) {
pr_err("%s:%d panel dt parse failed\n", __func__, __LINE__);
return rc;
}
#if defined(CONFIG_SEC_VICTOR3GDSDTV_PROJECT)
gpio_tlmm_config(GPIO_CFG(34, 0, GPIO_CFG_INPUT,GPIO_CFG_PULL_DOWN,GPIO_CFG_8MA),GPIO_CFG_ENABLE);
#else
gpio_tlmm_config(GPIO_CFG(24, 0, GPIO_CFG_INPUT,GPIO_CFG_PULL_DOWN,GPIO_CFG_8MA),GPIO_CFG_ENABLE);
gpio_set_value(24, 0);
#endif
cont_splash_enabled = of_property_read_bool(node,
"qcom,cont-splash-enabled");
if (!cont_splash_enabled) {
pr_info("%s:%d Continuous splash flag not found.\n",
__func__, __LINE__);
ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 0;
} else {
pr_info("%s:%d Continuous splash flag enabled.\n",
__func__, __LINE__);
ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 1;
}
#if defined(CONFIG_FB_MSM8x26_MDSS_CHECK_LCD_CONNECTION)
pr_err("CONFIG_LCD_CONNECTION_CHECK is set kky\n");
if (get_samsung_lcd_attached() == 0)
{
printk("%s: aaaLCD not connected.... Disabling Continous Splash!\n",__func__);
// ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 0;
}
#endif
ctrl_pdata->on = mdss_dsi_panel_on;
ctrl_pdata->off = mdss_dsi_panel_off;
ctrl_pdata->panel_reset = mdss_dsi_himax_panel_reset;
ctrl_pdata->panel_data.set_backlight = mdss_dsi_panel_bl_ctrl;
#if defined(CONFIG_LCD_CLASS_DEVICE)
lcd_device = lcd_device_register("panel", &pdev->dev, NULL,
&mdss_himax_disp_props);
if (IS_ERR(lcd_device)) {
rc = PTR_ERR(lcd_device);
printk(KERN_ERR "lcd : failed to register device\n");
return rc;
}
sysfs_remove_file(&lcd_device->dev.kobj,&dev_attr_lcd_power.attr);
rc = sysfs_create_file(&lcd_device->dev.kobj,&dev_attr_lcd_power.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",dev_attr_lcd_power.attr.name);
}
rc = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_type.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_type.attr.name);
}
rc= sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_siop_enable.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",
dev_attr_siop_enable.attr.name);
}
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
bd = backlight_device_register("panel", &lcd_device->dev,
NULL, NULL, NULL);
if (IS_ERR(bd)) {
rc = PTR_ERR(bd);
pr_info("backlight : failed to register device\n");
return rc;
}
rc= sysfs_create_file(&bd->dev.kobj,
&dev_attr_auto_brightness.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",
dev_attr_auto_brightness.attr.name);
}
#endif
#endif
#if defined(DDI_VIDEO_ENHANCE_TUNING)
rc = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_tuning.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",
dev_attr_tuning.attr.name);
}
#endif
#if defined(CONFIG_MDNIE_LITE_TUNING) || defined(CONFIG_MDNIE_VIDEO_ENHANCED)
pr_info("[%s] CONFIG_MDNIE_LITE_TUNING ok ! initclass called!\n",__func__);
init_mdnie_class();
#if defined(CONFIG_MDNIE_LITE_TUNING)
mdnie_lite_tuning_init(&msd);
#endif
#endif
#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
#ifdef ESD_DEBUG
rc = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_esd_check.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",
dev_attr_esd_check.attr.name);
}
#endif
msd.msm_pdev = pdev;
disp_esd_gpio =of_get_named_gpio(node,"qcom,oled-esd-gpio", 0);
err_fg_gpio = gpio_to_irq(disp_esd_gpio);
rc = gpio_request(disp_esd_gpio, "err_fg");
if (rc) {
pr_err("request gpio GPIO_ESD failed, ret=%d\n",rc);
gpio_free(disp_esd_gpio);
return rc;
}
gpio_tlmm_config(GPIO_CFG(disp_esd_gpio, 0, GPIO_CFG_INPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA),GPIO_CFG_ENABLE);
rc = gpio_direction_input(disp_esd_gpio);
if (unlikely(rc < 0)) {
pr_err("%s: failed to set gpio %d as input (%d)\n",
__func__, disp_esd_gpio, rc);
}
#endif
return 0;
}
static int __devinit mipi_samsung_disp_probe(struct platform_device *pdev)
{
struct platform_device *msm_fb_added_dev;
#if defined(CONFIG_LCD_CLASS_DEVICE)
struct lcd_device *lcd_device;
#endif
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
struct backlight_device *bd = NULL;
#endif
int ret = 0;
int i;
msd.dstat.acl_on = false;
if (pdev->id == 0) {
msd.mipi_samsung_disp_pdata = pdev->dev.platform_data;
return 0;
}
msm_fb_added_dev = msm_fb_add_device(pdev);
mutex_init(&dsi_tx_mutex);
#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_LCD_CLASS_DEVICE)
msd.msm_pdev = msm_fb_added_dev;
#endif
#if defined(CONFIG_HAS_EARLYSUSPEND)
msd.early_suspend.suspend = mipi_samsung_disp_early_suspend;
msd.early_suspend.resume = mipi_samsung_disp_late_resume;
msd.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
register_early_suspend(&msd.early_suspend);
#endif
msd.mpd->lcd_no = get_disp_switch();
for (i = 0; i < LCD_LOTS; i++) {
msd.dstat.is_elvss_loaded[i] = false;
msd.dstat.is_smart_dim_loaded[i] = false;
}
#if defined(CONFIG_LCD_CLASS_DEVICE)
lcd_device = lcd_device_register("panel", &pdev->dev, NULL,
&mipi_samsung_disp_props);
if (IS_ERR(lcd_device)) {
ret = PTR_ERR(lcd_device);
printk(KERN_ERR "lcd : failed to register device\n");
return ret;
}
#ifdef WA_FOR_FACTORY_MODE
sysfs_remove_file(&lcd_device->dev.kobj,
&dev_attr_lcd_power.attr);
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_power.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_power.attr.name);
}
#endif
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_type.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_type.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_gamma_mode.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_gamma_mode.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_power_reduce.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_power_reduce.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_siop_enable.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_siop_enable.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_backlight.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_backlight.attr.name);
}
#if defined(CONFIG_RUNTIME_MIPI_CLK_CHANGE)
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_fps_change.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_fps_change.attr.name);
}
#endif
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
bd = backlight_device_register("panel", &lcd_device->dev,
NULL, NULL, NULL);
if (IS_ERR(bd)) {
ret = PTR_ERR(bd);
pr_info("backlight : failed to register device\n");
return ret;
}
ret = sysfs_create_file(&bd->dev.kobj,
&dev_attr_auto_brightness.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_auto_brightness.attr.name);
}
#endif
#endif
#if defined(CONFIG_MDNIE_LITE_TUNING) \
|| defined(CONFIG_FB_MDP4_ENHANCE)
init_mdnie_class();
#endif
#if defined(DDI_VIDEO_ENHANCE_TUNING)
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_tuning.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_tuning.attr.name);
}
#endif
return 0;
}
static int __devinit mipi_samsung_disp_probe(struct platform_device *pdev)
{
int ret;
struct platform_device *msm_fb_added_dev;
#if defined(CONFIG_LCD_CLASS_DEVICE)
struct lcd_device *lcd_device;
#endif
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
struct backlight_device *bd = NULL;
#endif
msd.dstat.acl_on = false;
if (pdev->id == 0) {
msd.mipi_samsung_disp_pdata = pdev->dev.platform_data;
#ifdef CONFIG_SAMSUNG_CMC624
if (samsung_has_cmc624()) {
printk(KERN_DEBUG "Is_There_cmc624 : CMC624 is there!!!!");
samsung_cmc624_init();
first_on = false;
} else {
printk(KERN_DEBUG "Is_There_cmc624 : CMC624 is not there!!!!");
first_on = false;
}
#else
first_on = false;
#endif
return 0;
}
msm_fb_added_dev = msm_fb_add_device(pdev);
#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_LCD_CLASS_DEVICE)
msd.msm_pdev = msm_fb_added_dev;
#endif
#if defined(CONFIG_HAS_EARLYSUSPEND)
msd.early_suspend.suspend = mipi_samsung_disp_early_suspend;
msd.early_suspend.resume = mipi_samsung_disp_late_resume;
msd.early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 10;
register_early_suspend(&msd.early_suspend);
#endif
#if defined(CONFIG_LCD_CLASS_DEVICE)
lcd_device = lcd_device_register("panel", &pdev->dev, NULL,
&mipi_samsung_disp_props);
if (IS_ERR(lcd_device)) {
ret = PTR_ERR(lcd_device);
printk(KERN_ERR "lcd : failed to register device\n");
return ret;
}
#ifdef WA_FOR_FACTORY_MODE
sysfs_remove_file(&lcd_device->dev.kobj,
&dev_attr_lcd_power.attr);
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_power.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_power.attr.name);
}
#endif
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_type.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_type.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_gamma_mode.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_gamma_mode.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_power_reduce.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_power_reduce.attr.name);
}
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
bd = backlight_device_register("panel", &lcd_device->dev,
NULL, NULL, NULL);
if (IS_ERR(bd)) {
ret = PTR_ERR(bd);
pr_info("backlight : failed to register device\n");
return ret;
}
ret = sysfs_create_file(&bd->dev.kobj,
&dev_attr_auto_brightness.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_auto_brightness.attr.name);
}
#endif
#endif
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_CMD_QHD_PT) \
|| defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT) \
|| defined(CONFIG_FB_MSM_MIPI_MAGNA_OLED_VIDEO_QHD_PT) \
|| defined(CONFIG_FB_MSM_MIPI_MAGNA_OLED_VIDEO_WVGA_PT)
/* mdnie sysfs create */
init_mdnie_class();
#elif defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_HD_PT)
if (samsung_has_cmc624()) {
ret = cmc624_sysfs_init();
if (ret < 0)
pr_debug("CMC624 sysfs initialize FAILED\n");
} else
init_mdnie_class();
#endif
#ifdef READ_REGISTER_ESD
msd.mpd->esd_workqueue = create_singlethread_workqueue("esd_workqueue");
if (!msd.mpd->esd_workqueue) {
pr_info("esd_workqueue create fail\n");
return -ENOMEM;
}
INIT_DELAYED_WORK(&(msd.mpd->esd_work), esd_test_work_func);
wake_lock_init(&(msd.mpd->esd_wake_lock),
WAKE_LOCK_SUSPEND, "esd_workqueue_lock");
#endif
return 0;
}
static int __devinit mipi_samsung_disp_probe(struct platform_device *pdev)
{
int ret;
struct platform_device *msm_fb_added_dev;
struct lcd_device *lcd_device;
struct backlight_device *bd = NULL;
printk(KERN_INFO "[lcd] mipi_samsung_disp_probe start\n");
if (pdev->id == 0) {
msd.mipi_samsung_disp_pdata = pdev->dev.platform_data;
printk(KERN_INFO
"[lcd] pdev->id =%d, pdev-name = %s\n", pdev->id, pdev->name);
printk(KERN_INFO "[lcd] mipi_samsung_disp_probe end since pdev-id is 0\n");
return 0;
}
printk(KERN_INFO "[lcd] msm_fb_add_device : %s\n", pdev->name);
msm_fb_added_dev = msm_fb_add_device(pdev);
mutex_init(&dsi_tx_mutex);
#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_LCD_CLASS_DEVICE)
msd.msm_pdev = msm_fb_added_dev;
#endif
#if defined(CONFIG_HAS_EARLYSUSPEND)
msd.early_suspend.suspend = mipi_samsung_disp_early_suspend;
msd.early_suspend.resume = mipi_samsung_disp_late_resume;
msd.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
register_early_suspend(&msd.early_suspend);
#endif
#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
INIT_WORK(&err_fg_work, err_fg_work_func);
err_fg_gpio = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_ERR_FG);
ret = gpio_request(err_fg_gpio, "err_fg");
if (ret) {
pr_err("request gpio err_fg failed, rc=%d\n", ret);
return -ENODEV;
}
ret = pm8xxx_gpio_config(err_fg_gpio, &gpio_get_param);
if (ret) {
pr_err("gpio_config err_fg_gpio failed (3), rc=%d\n", ret);
return -EINVAL;
}
ret = request_threaded_irq(PM8921_GPIO_IRQ(PM8921_IRQ_BASE, PMIC_GPIO_ERR_FG),
NULL, err_fg_irq_handler, IRQF_TRIGGER_RISING | IRQF_ONESHOT, "esd_detect", NULL);
if (ret) {
pr_err("%s : Failed to request_irq.:ret=%d", __func__, ret);
}
disable_irq(PM8921_GPIO_IRQ(PM8921_IRQ_BASE, PMIC_GPIO_ERR_FG));
#endif
#if defined(CONFIG_LCD_CLASS_DEVICE)
printk(KERN_INFO "[lcd] lcd_device_register for panel start\n");
lcd_device = lcd_device_register("panel", &pdev->dev, NULL,
&mipi_samsung_disp_props);
if (IS_ERR(lcd_device)) {
ret = PTR_ERR(lcd_device);
printk(KERN_ERR "lcd : failed to register device\n");
return ret;
}
sysfs_remove_file(&lcd_device->dev.kobj,
&dev_attr_lcd_power.attr);
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_power.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_power.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_type.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_type.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_backlight.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_backlight.attr.name);
}
#if defined(RUMTIME_MIPI_CLK_CHANGE)
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_fps_change.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_fps_change.attr.name);
}
#endif
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_siop_enable.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_siop_enable.attr.name);
}
printk(KERN_INFO "[lcd] backlight_device_register for panel start\n");
bd = backlight_device_register("panel", &lcd_device->dev,
NULL, NULL, NULL);
if (IS_ERR(bd)) {
ret = PTR_ERR(bd);
pr_info("backlight : failed to register device\n");
return ret;
}
ret = sysfs_create_file(&bd->dev.kobj,
&dev_attr_auto_brightness.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_auto_brightness.attr.name);
}
#endif
#if defined(CONFIG_FB_MDP4_ENHANCE)
init_mdnie_class();
#elif defined(CONFIG_MDNIE_LITE_TUNING)
pr_info("[%s] CONFIG_MDNIE_LITE_TUNING ok ! init class called!\n",
__func__);
mdnie_lite_tuning_init();
#endif
#if defined(DDI_VIDEO_ENHANCE_TUNING)
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_tuning.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_tuning.attr.name);
}
#endif
printk(KERN_INFO "[lcd] mipi_samsung_disp_probe end\n");
return 0;
}
static int __devinit tl2796_probe(struct spi_device *spi)
{
struct s5p_lcd *lcd;
int ret;
lcd = kzalloc(sizeof(*lcd), GFP_KERNEL);
if (!lcd) {
pr_err("failed to allocate for lcd\n");
ret = -ENOMEM;
goto err_alloc;
}
mutex_init(&lcd->lock);
spi->bits_per_word = 8;
if (spi_setup(spi)) {
pr_err("failed to setup spi\n");
ret = -EINVAL;
goto err_setup;
}
lcd->g_spi = spi;
lcd->dev = &spi->dev;
lcd->bl = 255;
if (!spi->dev.platform_data) {
dev_err(lcd->dev, "failed to get platform data\n");
ret = -EINVAL;
goto err_setup;
}
// lcd->data = (struct s5p_panel_data *)spi->dev.platform_data;
//determinate of LCD type
lcd->lcd_type = get_lcdtype();
ret = gpio_request(GPIO_LCD_BL_PWM, "lcd_bl_pwm");
if (ret < 0) {
dev_err(lcd->dev, "unable to request gpio for backlight\n");
return ret;
}
s3c_gpio_cfgpin(GPIO_LCD_BL_PWM, (0x2 << 0));
lcd->backlight_pwm_dev = pwm_request(0, "backlight-pwm");
if (IS_ERR(lcd->backlight_pwm_dev)) {
dev_err(lcd->dev, "unable to request PWM for backlight\n");
} else
dev_err(lcd->dev, "got pwm for backlight\n");
pwm_config(lcd->backlight_pwm_dev, (bl_freq_count*70)/100, bl_freq_count);
pwm_enable(lcd->backlight_pwm_dev);
lcd->bl_dev = backlight_device_register("s5p_bl",
&spi->dev, lcd, &s5p_bl_ops, NULL);
if (!lcd->bl_dev) {
dev_err(lcd->dev, "failed to register backlight\n");
ret = -EINVAL;
goto err_setup;
}
lcd->bl_dev->props.max_brightness = 255;
lcd->lcd_dev = lcd_device_register("s5p_lcd", &spi->dev, lcd, &s5p_lcd_ops);
if (!lcd->lcd_dev)
{
dev_err(lcd->dev, "failed to register lcd\n");
ret = -EINVAL;
goto err_setup_lcd;
}
// Class and device file creation
printk(KERN_ERR "ldi_class create\n");
lcd->ldi_class = class_create(THIS_MODULE, "ldi_class");
if (IS_ERR(lcd->ldi_class))
pr_err("Failed to create class(ldi_class)!\n");
lcd->ldi_dev = device_create(lcd->ldi_class, &spi->dev, 0, lcd, "ldi_dev");
if (IS_ERR(lcd->ldi_dev))
pr_err("Failed to create device(ldi_dev)!\n");
if (!lcd->ldi_dev) {
dev_err(lcd->dev, "failed to register device(ldi_dev)\n");
ret = -EINVAL;
goto err_setup_ldi;
}
if (device_create_file(lcd->ldi_dev, &dev_attr_update_brightness_cmd) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_update_brightness_cmd.attr.name);
spi_set_drvdata(spi, lcd);
tl2796_ldi_enable(lcd);
#ifdef CONFIG_FB_S3C_MDNIE
init_mdnie_class(); //set mDNIe UI mode, Outdoormode
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
lcd->early_suspend.suspend = tl2796_early_suspend;
lcd->early_suspend.resume = tl2796_late_resume;
lcd->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1;
register_early_suspend(&lcd->early_suspend);
#endif
gprintk("tl2796_probe successfully probed\n", __func__);
return 0;
err_setup_ldi:
lcd_device_unregister(lcd->lcd_dev);
err_setup_lcd:
backlight_device_unregister(lcd->bl_dev);
err_setup:
mutex_destroy(&lcd->lock);
kfree(lcd);
err_alloc:
return ret;
}
static int __devinit mipi_samsung_disp_probe(struct platform_device *pdev)
{
struct platform_device *msm_fb_added_dev;
#if defined(CONFIG_LCD_CLASS_DEVICE)
struct lcd_device *lcd_device;
int ret;
#endif
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
struct backlight_device *bd;
#endif
msd.dstat.acl_on = false;
if (pdev->id == 0) {
msd.mipi_samsung_disp_pdata = pdev->dev.platform_data;
first_on = false;
return 0;
}
msm_fb_added_dev = msm_fb_add_device(pdev);
mutex_init(&dsi_tx_mutex);
#if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_LCD_CLASS_DEVICE)
msd.msm_pdev = msm_fb_added_dev;
#endif
#if defined(CONFIG_HAS_EARLYSUSPEND)
msd.early_suspend.suspend = mipi_samsung_disp_early_suspend;
msd.early_suspend.resume = mipi_samsung_disp_late_resume;
msd.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
register_early_suspend(&msd.early_suspend);
#endif
#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
INIT_WORK(&err_fg_work, err_fg_work_func);
err_fg_gpio = MSM_GPIO_TO_INT(GPIO_ESD_VGH_DET);
ret = gpio_request(GPIO_ESD_VGH_DET, "err_fg");
if (ret) {
pr_err("request gpio GPIO_LCD_ESD_DET failed, ret=%d\n",ret);
gpio_free(GPIO_ESD_VGH_DET);
return ret;
}
gpio_tlmm_config(GPIO_CFG(GPIO_ESD_VGH_DET, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA),GPIO_CFG_ENABLE);
ret = request_threaded_irq(err_fg_gpio, NULL, err_fg_irq_handler,
IRQF_TRIGGER_HIGH | IRQF_ONESHOT, "esd_detect", NULL);
if (ret) {
pr_err("%s : Failed to request_irq. :ret=%d", __func__, ret);
}
disable_irq(err_fg_gpio);
#endif
#if defined(CONFIG_LCD_CLASS_DEVICE)
lcd_device = lcd_device_register("panel", &pdev->dev, NULL,
&mipi_samsung_disp_props);
if (IS_ERR(lcd_device)) {
ret = PTR_ERR(lcd_device);
printk(KERN_ERR "lcd : failed to register device\n");
return ret;
}
#ifdef WA_FOR_FACTORY_MODE
sysfs_remove_file(&lcd_device->dev.kobj,
&dev_attr_lcd_power.attr);
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_power.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_power.attr.name);
}
#endif
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_type.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_type.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_gamma_mode.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_gamma_mode.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_power_reduce.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_power_reduce.attr.name);
}
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
bd = backlight_device_register("panel", &lcd_device->dev,
NULL, NULL, NULL);
if (IS_ERR(bd)) {
ret = PTR_ERR(bd);
pr_info("backlight : failed to register device\n");
return ret;
}
ret = sysfs_create_file(&bd->dev.kobj,
&dev_attr_auto_brightness.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_auto_brightness.attr.name);
}
#endif
#endif
#if defined(CONFIG_MDNIE_LITE_TUNING) \
|| defined(CONFIG_FB_MDP4_ENHANCE)
/* mdnie sysfs create */
init_mdnie_class();
#endif
mipi_dsi_buf_alloc(&mdnie_tune_tx_buf, DSI_BUF_SIZE);
#if defined(DDI_VIDEO_ENHANCE_TUNING)
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_tuning.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_tuning.attr.name);
}
#endif
return 0;
}
