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