static int __init samsung_panel_init(void) { struct samsung_display_driver_data *vdd = samsung_get_vdd(); char panel_string[] = "qcom,mdss_dsi_nt51017_wxga_video"; vdd->panel_name = mdss_mdp_panel + 8; pr_info("%s : %s\n", __func__, vdd->panel_name); if (!strncmp(vdd->panel_name, panel_string, strlen(panel_string))) vdd->panel_func.samsung_panel_init = mdss_panel_init; return 0; }
static int __init samsung_panel_init(void) { struct samsung_display_driver_data *vdd = samsung_get_vdd(); char panel_string[] = "ss_dsi_panel_HX8369B_BV045WVM_WVGA"; vdd->panel_name = mdss_mdp_panel + 8; pr_info("%s : %s\n", __func__, vdd->panel_name); if (!strncmp(vdd->panel_name, panel_string, strlen(panel_string))) vdd->panel_func.samsung_panel_init = mdss_panel_init; return 0; }
static int __init samsung_panel_init(void) { struct samsung_display_driver_data *vdd = samsung_get_vdd(); char panel_string[] = "qcom,mdss_dsi_S6D77A1A01_wvga_video"; /*please rework as char panel_string[] = "ss_dsi_panel_S6D77A1A01_WVGA";*/ vdd->panel_name = mdss_mdp_panel + 8; pr_info("%s : %s\n", __func__, vdd->panel_name); if (!strncmp(vdd->panel_name, panel_string, strlen(panel_string))) vdd->panel_func.samsung_panel_init = mdss_panel_init; return 0; }
static int __init samsung_panel_init(void) { struct samsung_display_driver_data *vdd = samsung_get_vdd(); char panel_string[] = "qcom,mdss_dsi_S6D77A1A01_bv043wvm_wvga_video"; printk("sean:LINE%d %s : %s\n", __LINE__,__func__, mdss_mdp_panel); vdd->panel_name = mdss_mdp_panel + 8; pr_info("%s : %s\n", __func__, vdd->panel_name); if (!strncmp(vdd->panel_name, panel_string, strlen(panel_string))) vdd->panel_func.samsung_panel_init = mdss_panel_init_revB; else //vdd->panel_func.samsung_panel_init = NULL; return 0; return 0; }
void mdss_samsung_cabc_update_tft(int val) { static int prev_val; struct samsung_display_driver_data *vdd = samsung_get_vdd(); if (IS_ERR_OR_NULL(vdd)) { pr_err("%s vdd is error", __func__); return; } if(prev_val == val) return; if(val) mdss_samsung_send_cmd(vdd->ctrl_dsi[DISPLAY_1], PANEL_CABC_OFF); else if(vdd->mdss_panel_tft_outdoormode_update) vdd->mdss_panel_tft_outdoormode_update(vdd->ctrl_dsi[DISPLAY_1]); prev_val = val; }
static int backlight_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct backlight_platform_data *pdata; struct backlight_info *info; int error = 0; #if defined(CONFIG_BLIC_TUNING) struct class *backlight_class; struct device *backlight_dev; #endif struct samsung_display_driver_data *vdd = samsung_get_vdd(); pr_info("%s", __func__); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)){ pr_err("[BACKLIGHT] failed to check i2c functionality!\n"); return -EIO; } if (client->dev.of_node) { pdata = devm_kzalloc(&client->dev, sizeof(struct backlight_platform_data), GFP_KERNEL); if (!pdata) { dev_info(&client->dev, "Failed to allocate memory\n"); return -ENOMEM; } error = backlight_parse_dt(&client->dev, pdata); if (error) return error; } else pdata = client->dev.platform_data; backlight_request_gpio(pdata); bl_info = info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) { dev_info(&client->dev, "%s: fail to memory allocation.\n", __func__); return -ENOMEM; } info->client = client; info->pdata = pdata; mdss_samsung_parse_backlight_settings(&client->dev,&info->bl_ic_settings,"backlight-ic-tuning"); mdss_samsung_parse_backlight_settings(&client->dev,&info->bl_ic_outdoor_settings,"backlight-ic-tuning-outdoor"); mdss_samsung_parse_backlight_settings(&client->dev,&info->bl_ic_normal_settings,"backlight-ic-tuning-normal"); mdss_samsung_parse_backlight_settings(&client->dev,&info->bl_control,"backlight-i2c-bl-control"); #if defined(CONFIG_BLIC_TUNING) backlight_class = class_create(THIS_MODULE, "bl-dbg"); backlight_dev = device_create(backlight_class, NULL, 0, NULL, "ic-tuning"); if (IS_ERR(backlight_dev)) pr_err("Failed to create device(backlight_dev)!\n"); else { if (device_create_file(backlight_dev, &dev_attr_bl_ic_tune) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_bl_ic_tune.attr.name); if (device_create_file(backlight_dev, &dev_attr_bl_ic_name) < 0) pr_err("Failed to create device file(%s)!\n", dev_attr_bl_ic_name.attr.name); } #endif i2c_set_clientdata(client, info); vdd->panel_func.samsung_bl_ic_pwm_en = pwm_backlight_control; vdd->panel_func.samsung_bl_ic_outdoor = pwm_backlight_outdoor_control; return error; }
static int mdss_pll_probe(struct platform_device *pdev) { int rc = 0; const char *label; struct resource *pll_base_reg; struct resource *phy_base_reg; struct resource *dynamic_pll_base_reg; struct resource *gdsc_base_reg; struct mdss_pll_resources *pll_res; #if defined(CONFIG_FB_MSM_MDSS_SAMSUNG) struct samsung_display_driver_data *vdd = samsung_get_vdd(); #endif if (!pdev->dev.of_node) { pr_err("MDSS pll driver only supports device tree probe\n"); rc = -ENOTSUPP; goto error; } label = of_get_property(pdev->dev.of_node, "label", NULL); if (!label) pr_info("%d: MDSS pll label not specified\n", __LINE__); else pr_info("MDSS pll label = %s\n", label); pll_res = devm_kzalloc(&pdev->dev, sizeof(struct mdss_pll_resources), GFP_KERNEL); if (!pll_res) { pr_err("Failed to allocate the clock pll\n"); rc = -ENOMEM; goto error; } platform_set_drvdata(pdev, pll_res); rc = of_property_read_u32(pdev->dev.of_node, "cell-index", &pll_res->index); if (rc) { pr_err("Unable to get the cell-index rc=%d\n", rc); pll_res->index = 0; } pll_base_reg = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pll_base"); if (!pll_base_reg) { pr_err("Unable to get the pll base resources\n"); rc = -ENOMEM; goto io_error; } pll_res->pll_base = ioremap(pll_base_reg->start, resource_size(pll_base_reg)); if (!pll_res->pll_base) { pr_err("Unable to remap pll base resources\n"); rc = -ENOMEM; goto io_error; } #if defined(CONFIG_FB_MSM_MDSS_SAMSUNG) if (!strcmp(label, "MDSS DSI 0 PLL") || !strcmp(label, "MDSS DSI 1 PLL")) vdd->dump_info[pll_res->index].dsi_pll.virtual_addr = (size_t)pll_res->pll_base; #endif rc = mdss_pll_resource_parse(pdev, pll_res); if (rc) { pr_err("Pll resource parsing from dt failed rc=%d\n", rc); goto res_parse_error; } /* * DSI PLL 1 is leaking current whenever MDSS GDSC is toggled. Need to * map PLL1 registers along with the PLl0 so that we can manually turn * off PLL1. */ if (pll_res->pll_interface_type == MDSS_DSI_PLL_20NM) { struct resource *pll_1_base_reg; pll_1_base_reg = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pll_1_base"); if (pll_1_base_reg) { pll_res->pll_1_base = ioremap(pll_1_base_reg->start, resource_size(pll_1_base_reg)); if (!pll_res->pll_1_base) pr_err("Unable to remap pll 1 base resources\n"); } else { pr_err("Unable to get the pll 1 base resource\n"); } } phy_base_reg = platform_get_resource_byname(pdev, IORESOURCE_MEM, "phy_base"); if (!phy_base_reg) { /* This resource is mandatory for HDMI pll */ if (pll_res->pll_interface_type == MDSS_HDMI_PLL) { pr_err("Unable to get the phy base resources\n"); rc = -ENOMEM; goto phy_io_error; } } else { pll_res->phy_base = ioremap(phy_base_reg->start, resource_size(phy_base_reg)); if (!pll_res->phy_base) { pr_err("Unable to remap pll phy base resources\n"); rc = -ENOMEM; goto phy_io_error; } } dynamic_pll_base_reg = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dynamic_pll_base"); if (dynamic_pll_base_reg) { pll_res->dyn_pll_base = ioremap(dynamic_pll_base_reg->start, resource_size(dynamic_pll_base_reg)); if (!pll_res->dyn_pll_base) { pr_err("Unable to remap dynamic pll base resources\n"); rc = -ENOMEM; goto dyn_pll_io_error; } } gdsc_base_reg = platform_get_resource_byname(pdev, IORESOURCE_MEM, "gdsc_base"); if (!gdsc_base_reg) { pr_err("Unable to get the gdsc base resource\n"); rc = -ENOMEM; goto gdsc_io_error; } pll_res->gdsc_base = ioremap(gdsc_base_reg->start, resource_size(gdsc_base_reg)); if (!pll_res->gdsc_base) { pr_err("Unable to remap gdsc base resources\n"); rc = -ENOMEM; goto gdsc_io_error; } rc = mdss_pll_resource_init(pdev, pll_res); if (rc) { pr_err("Pll resource init failed rc=%d\n", rc); goto res_init_error; } rc = mdss_pll_clock_register(pdev, pll_res); if (rc) { pr_err("Pll clock register failed rc=%d\n", rc); goto clock_register_error; } return rc; clock_register_error: mdss_pll_resource_deinit(pdev, pll_res); res_init_error: if (pll_res->gdsc_base) iounmap(pll_res->gdsc_base); gdsc_io_error: if (pll_res->dyn_pll_base) iounmap(pll_res->dyn_pll_base); dyn_pll_io_error: if (pll_res->phy_base) iounmap(pll_res->phy_base); phy_io_error: if (pll_res->pll_1_base) iounmap(pll_res->pll_1_base); mdss_pll_resource_release(pdev, pll_res); res_parse_error: iounmap(pll_res->pll_base); io_error: devm_kfree(&pdev->dev, pll_res); error: return rc; }