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; }