static ssize_t mipi_novatek_auto_brightness_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct msm_fb_data_type *mfd;
mfd = platform_get_drvdata(msd.msm_pdev);
if (sysfs_streq(buf, "0"))
msd.dstat.auto_brightness = 0;
else if (sysfs_streq(buf, "1"))
msd.dstat.auto_brightness = 1;
else if (sysfs_streq(buf, "2"))
msd.dstat.auto_brightness = 2;
else if (sysfs_streq(buf, "3"))
msd.dstat.auto_brightness = 3;
else if (sysfs_streq(buf, "4"))
msd.dstat.auto_brightness = 4;
else if (sysfs_streq(buf, "5"))
msd.dstat.auto_brightness = 5;
else if (sysfs_streq(buf, "6"))
msd.dstat.auto_brightness = 6;
else
pr_info("%s: Invalid argument!!", __func__);
pr_info("%s : level (%d), bl_level (%d) \n",
__func__, msd.dstat.auto_brightness, mfd->bl_level);
#ifdef CONFIG_SAMSUNG_CMC624
if (samsung_has_cmc624()) {
cabc_onoff_ctrl(msd.dstat.auto_brightness);
}
#endif
return size;
}
static ssize_t mipi_samsung_disp_acl_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct msm_fb_data_type *mfd;
mfd = platform_get_drvdata(msd.msm_pdev);
if (!mfd->panel_power_on) {
pr_info("%s: panel is off state. updating state value.\n",
__func__);
if (sysfs_streq(buf, "1") && !msd.dstat.acl_on)
msd.dstat.acl_on = true;
else if (sysfs_streq(buf, "0") && msd.dstat.acl_on)
msd.dstat.acl_on = false;
else
pr_info("%s: Invalid argument!!", __func__);
} else {
if (sysfs_streq(buf, "1") && !msd.dstat.acl_on) {
if (msd.mpd->set_acl(mfd->bl_level))
mipi_samsung_disp_send_cmd(
mfd, PANEL_ACL_OFF, true);
else {
mipi_samsung_disp_send_cmd(
mfd, PANEL_ACL_ON, true);
mipi_samsung_disp_send_cmd(
mfd, PANEL_ACL_UPDATE, true);
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_HD_PT)
if (samsung_has_cmc624())
cabc_onoff_ctrl(1);
#endif
}
msd.dstat.acl_on = true;
} else if (sysfs_streq(buf, "0") && msd.dstat.acl_on) {
mipi_samsung_disp_send_cmd(mfd, PANEL_ACL_OFF, true);
msd.dstat.acl_on = false;
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_HD_PT)
if (samsung_has_cmc624())
cabc_onoff_ctrl(0);
#endif
} else {
pr_info("%s: Invalid argument!!", __func__);
}
}
return size;
}
void mipi_samsung_oled_display_fast_init()
{
struct msm_fb_data_type *mfd;
if (samsung_has_cmc624())
msd.mpd->prepare_fast_cmd_array(LCD_Get_Value());
else
msd.mpd->prepare_fast_cmd_array(bypass_LCD_Id());
mfd = platform_get_drvdata(msd.msm_pdev);
mipi_samsung_disp_send_cmd(mfd, PANEL_READY_TO_ON_FAST, false);
mipi_samsung_disp_send_cmd(mfd, PANEL_ON, false);
}
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 void mipi_samsung_disp_backlight(struct msm_fb_data_type *mfd)
{
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_CMD_QHD_PT)
mfd->backlight_ctrl_ongoing = TRUE;
#else
mfd->backlight_ctrl_ongoing = FALSE;
#endif
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_HD_PT) \
|| defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT)
if (msd.mpd->prepare_brightness_control_cmd_array) {
int cmds_sent;
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_HD_PT)
if (!samsung_has_cmc624())
cmds_sent = msd.mpd->prepare_brightness_control_cmd_array(
bypass_LCD_Id(), mfd->bl_level);
else
cmds_sent = msd.mpd->prepare_brightness_control_cmd_array(
LCD_Get_Value(), mfd->bl_level);
#else
cmds_sent = msd.mpd->prepare_brightness_control_cmd_array(
0, mfd->bl_level);
#endif
pr_debug("cmds_sent: %x\n", cmds_sent);
if (cmds_sent < 0)
goto end;
mipi_samsung_disp_send_cmd(mfd, PANEL_BRIGHT_CTRL, true);
goto end;
}
#endif
#if defined(CONFIG_MIPI_SAMSUNG_ESD_REFRESH)
if (msd.esd_refresh == true)
goto end;
#endif
pr_info("mipi_samsung_disp_backlight %d\n", mfd->bl_level);
if (!msd.mpd->set_gamma || !mfd->panel_power_on ||\
mfd->resume_state == MIPI_SUSPEND_STATE)
goto end;
if (msd.mpd->set_gamma(mfd->bl_level, msd.dstat.gamma_mode) < 0)
goto end;
pr_info("mipi_samsung_disp_backlight %d\n", mfd->bl_level);
mipi_samsung_disp_send_cmd(mfd, PANEL_GAMMA_UPDATE, true);
#ifdef USE_ELVSS
if (msd.mpd->set_elvss)
mipi_samsung_disp_send_cmd(mfd, PANEL_ELVSS_UPDATE, true);
#endif
#ifdef USE_ACL
if (msd.mpd->set_acl && msd.dstat.acl_on && msd.mpd->set_acl(mfd->bl_level))
mipi_samsung_disp_send_cmd(mfd, PANEL_ACL_OFF, true);
if (msd.mpd->set_acl && msd.dstat.acl_on && !msd.mpd->set_acl(mfd->bl_level)) {
#if !defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_CMD_QHD_PT)
mipi_samsung_disp_send_cmd(mfd, PANEL_ACL_ON, true);
#endif
mipi_samsung_disp_send_cmd(mfd, PANEL_ACL_UPDATE, true);
}
#endif
end:
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_CMD_QHD_PT)
mfd->backlight_ctrl_ongoing = FALSE;
#endif
return;
}
static int mipi_samsung_disp_on(struct platform_device *pdev)
{
struct msm_fb_data_type *mfd;
struct mipi_panel_info *mipi;
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_HD_PT) \
|| defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT) \
|| defined(CONFIG_FB_MSM_MIPI_MAGNA_OLED_VIDEO_WVGA_PT)
static int boot_on;
#endif
mfd = platform_get_drvdata(pdev);
if (unlikely(!mfd))
return -ENODEV;
if (unlikely(mfd->key != MFD_KEY))
return -EINVAL;
mipi = &mfd->panel_info.mipi;
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_CMD_QHD_PT)
mipi_samsung_disp_send_cmd(mfd, MTP_READ_ENABLE, false);
#endif
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT) \
|| defined(CONFIG_FB_MSM_MIPI_MAGNA_OLED_VIDEO_WVGA_PT)
if (boot_on == 0)
mipi_samsung_disp_send_cmd(mfd, MTP_READ_ENABLE, false);
#endif
#ifdef USE_READ_ID
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT) \
|| defined(CONFIG_FB_MSM_MIPI_MAGNA_OLED_VIDEO_WVGA_PT)
if (boot_on == 0)
msd.mpd->manufacture_id = mipi_samsung_manufacture_id(mfd);
#elif defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_CMD_QHD_PT)
msd.mpd->manufacture_id = mipi_samsung_manufacture_id(mfd);
#elif defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_HD_PT)
if (!samsung_has_cmc624())
msd.mpd->manufacture_id = mipi_samsung_manufacture_id(mfd);
else
msd.mpd->manufacture_id = LCD_Get_Value();
#endif
#endif
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_CMD_QHD_PT)
if (!msd.dstat.is_elvss_loaded) {
read_reg(ELVSS_REGISTER, ELVSS_DATA_SIZE,
msd.mpd->lcd_elvss_data,
FALSE, mfd); /* read ELVSS data */
msd.dstat.is_elvss_loaded = true;
}
if (!msd.dstat.is_smart_dim_loaded) {
/* Load MTP Data */
int i;
read_reg(MTP_REGISTER, MTP_DATA_SIZE,
(u8 *)&(msd.mpd->smart_s6e39a0x02.MTP),
FALSE, mfd);
for (i = 0; i < MTP_DATA_SIZE; i++) {
pr_info("%s MTP DATA[%d] : %02x\n", __func__, i,
((char *)&(msd.mpd->smart_s6e39a0x02.MTP))[i]);
}
smart_dimming_init(&(msd.mpd->smart_s6e39a0x02));
#ifdef READ_MTP_ONCE
msd.dstat.is_smart_dim_loaded = true;
#else
msd.dstat.is_smart_dim_loaded = false;
#endif
msd.dstat.gamma_mode = GAMMA_SMART;
}
#endif
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_HD_PT)
if (!msd.dstat.is_elvss_loaded) {
if (!samsung_has_cmc624())
msd.mpd->lcd_elvss_data[0] = elvss_value;
else
msd.mpd->lcd_elvss_data[0] = LCD_ID3();
msd.dstat.is_elvss_loaded = true;
}
if (!msd.dstat.is_smart_dim_loaded) {
/*Load MTP Data*/
char pBuffer[256] = {0,};
int i;
struct SMART_DIM *psmart;
char *mtp_data;
int mtp_cnt;
psmart = &(msd.mpd->smart_s6e8aa0x01);
mtp_data = (char *)&(msd.mpd->smart_s6e8aa0x01.MTP);
if (samsung_has_cmc624()) {
memcpy(mtp_data, mtp_read_data, GAMMA_SET_MAX);
pr_info("%s This board support CMC", __func__);
} else {
mtp_cnt = find_mtp(mfd, mtp_data);
pr_info("%s MTP is determined : %d", __func__, mtp_cnt);
}
for (i = 0; i < MTP_DATA_SIZE; i++)
snprintf(pBuffer + strnlen(pBuffer, 256), 256, " %02x",
mtp_data[i]);
pr_info("MTP: %s", pBuffer);
psmart->plux_table = msd.mpd->lux_table;
psmart->lux_table_max = msd.mpd->lux_table_max_cnt;
if (samsung_has_cmc624())
psmart->ldi_revision = LCD_Get_Value();
else
psmart->ldi_revision = bypass_LCD_Id();
smart_dimming_init(psmart);
msd.dstat.is_smart_dim_loaded = true;
msd.dstat.gamma_mode = GAMMA_SMART;
}
if (msd.mpd->gamma_initial && boot_on == 0) {
msd.mpd->smart_s6e8aa0x01.brightness_level = 180;
generate_gamma(&msd.mpd->smart_s6e8aa0x01,
&(msd.mpd->gamma_initial[2]), GAMMA_SET_MAX);
if (recovery_boot_mode == 0)
boot_on = 1;
} else {
get_min_lux_table(&(msd.mpd->gamma_initial[2]),
GAMMA_SET_MAX);
reset_gamma_level();
}
#endif
#if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OLED_VIDEO_WVGA_PT)
if (!msd.dstat.is_smart_dim_loaded) {
/* Load MTP Data */
int i, mtp_cnt, err_cnt;
char *mtp_data = (char *)&(msd.mpd->smart_s6e63m0.MTP);
for (err_cnt = 0; err_cnt < 10; err_cnt++) {
mtp_cnt = find_mtp(mfd, mtp_data);
if (mtp_cnt != 0)
break;
}
pr_info("%s MTP is determined:%d err_cnt:%d",
__func__, mtp_cnt, err_cnt);
for (i = 0; i < MTP_DATA_SIZE_S6E63M0; i++) {
pr_info("%s MTP DATA[%d] : %02x\n", __func__, i,
mtp_data[i]);
}
smart_dimming_init(&(msd.mpd->smart_s6e63m0));
msd.dstat.is_smart_dim_loaded = true;
msd.dstat.gamma_mode = GAMMA_SMART;
}
if (msd.mpd->gamma_initial && boot_on == 0) {
msd.mpd->smart_s6e63m0.brightness_level = 140;
generate_gamma(&msd.mpd->smart_s6e63m0,
&(msd.mpd->gamma_initial[2]), GAMMA_SET_MAX);
if (recovery_boot_mode == 0)
boot_on = 1;
} else {
msd.mpd->smart_s6e63m0.brightness_level = 30;
generate_gamma(&msd.mpd->smart_s6e63m0,
&(msd.mpd->gamma_initial[2]), GAMMA_SET_MAX);
reset_gamma_level();
}
#endif
#if defined(CONFIG_FB_MSM_MIPI_MAGNA_OLED_VIDEO_WVGA_PT)
if (!msd.dstat.is_smart_dim_loaded) {
/* Load MTP Data */
int i, mtp_cnt, err_cnt;
char *mtp_data = (char *)&(msd.mpd->smart_ea8868.MTP);
if (bypass_lcd_id == 0x4a) {
for (err_cnt = 0; err_cnt < 10; err_cnt++) {
mtp_cnt = find_mtp(mfd, mtp_data);
if (mtp_cnt != 0)
break;
}
pr_info("%s MTP is determined:%d err_cnt:%d",
__func__, mtp_cnt, err_cnt);
for (i = 0; i < MTP_DATA_SIZE_EA8868; i++) {
pr_info("%s MTP DATA[%d] : %02x\n",
__func__, i, mtp_data[i]);
}
} else {
pr_info("%s MTP is not used LDI_ID: 0x%x",
__func__, bypass_lcd_id);
memset(mtp_data, 0x0, MTP_DATA_SIZE_EA8868);
}
smart_dimming_init(&(msd.mpd->smart_ea8868));
msd.dstat.is_smart_dim_loaded = true;
msd.dstat.gamma_mode = GAMMA_SMART;
}
if (msd.mpd->gamma_initial && boot_on == 0) {
msd.mpd->smart_ea8868.brightness_level = 180;
generate_gamma(&msd.mpd->smart_ea8868,
&(msd.mpd->gamma_initial[1]), GAMMA_SET_MAX);
if (recovery_boot_mode == 0)
boot_on = 1;
} else {
msd.mpd->smart_ea8868.brightness_level = get_gamma_lux();
generate_gamma(&msd.mpd->smart_ea8868,
&(msd.mpd->gamma_initial[1]), GAMMA_SET_MAX);
reset_gamma_level();
}
#endif
if (unlikely(first_on)) {
first_on = false;
return 0;
}
mipi_samsung_disp_send_cmd(mfd, PANEL_READY_TO_ON, false);
if (mipi->mode == DSI_VIDEO_MODE)
mipi_samsung_disp_send_cmd(mfd, PANEL_ON, false);
#if !defined(CONFIG_HAS_EARLYSUSPEND)
mipi_samsung_disp_send_cmd(mfd, PANEL_LATE_ON, false);
#endif
#if defined(CONFIG_MIPI_SAMSUNG_ESD_REFRESH)
#if defined(CONFIG_MACH_JAGUAR)
if (system_rev >= 16)
set_esd_enable();
if (msd.esd_refresh == true)
mipi_samsung_disp_send_cmd(mfd, PANEL_LATE_ON, false);
#else
set_esd_enable();
#endif
#endif
#ifdef READ_REGISTER_ESD
queue_delayed_work(msd.mpd->esd_workqueue,
&(msd.mpd->esd_work), ESD_INTERVAL * HZ);
wake_lock(&(msd.mpd->esd_wake_lock));
#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_esd_refresh_probe(struct platform_device *pdev)
{
struct esd_data_t *p_esd_data;
struct sec_esd_platform_data *pdata = pdev->dev.platform_data;
unsigned int irq_type;
#ifdef ESD_DEBUG
struct device *esd_device;
#endif
int ret = 0;
if (pdata == NULL) {
pr_err("ESD Platform data is Null !!!!!\n");
return -1;
}
#ifndef ESD_DEBUG
if (pdata->esd_gpio_irq == -1) {
/* Do nothing ESD not supported in this revision */
return 0;
}
#endif
#if defined(CONFIG_MACH_GOGH)
if (system_rev > 0x01)
irq_type = IRQF_TRIGGER_FALLING;
else {
/* Gogh 0.1rev has ESD protection chip irq
trigger is low.....HIGH...low */
irq_type = IRQF_TRIGGER_RISING;
}
#else
/* ESD irq through VGH, irq trigger is HIGH....low....HIGH */
irq_type = IRQF_TRIGGER_FALLING;
#endif
p_esd_data = kzalloc(sizeof(struct esd_data_t), GFP_KERNEL);
if (p_esd_data == NULL) {
pr_err("%s : Failed to allocate memory.\n", __func__);
return -ENOMEM;
}
esd_enable = p_esd_data;
p_esd_data->pdata = pdata;
p_esd_data->esd_count = 0;
p_esd_data->esd_ignore = false;
p_esd_data->esd_irq_enable = true;
p_esd_data->esd_processed_count = 0;
wake_lock_init(&p_esd_data->det_wake_lock,
WAKE_LOCK_SUSPEND, "esd_det");
INIT_WORK(&p_esd_data->det_work, sec_esd_work_func);
INIT_DELAYED_WORK(&p_esd_data->esd_enable_delay,\
set_esd_enable_work_func);
dev_set_drvdata(&pdev->dev, p_esd_data);
#ifdef ESD_DEBUG
esd_device = device_create(sec_class, NULL, 0, p_esd_data, "sec_esd");
if (IS_ERR(esd_device)) {
pr_err("Failed to create device for the factory test\n");
ret = -ENODEV;
}
ret = sysfs_create_file(&esd_device->kobj,
&dev_attr_esd_check.attr);
if (ret) {
pr_err("sysfs create fail-%s\n",
dev_attr_esd_check.attr.name);
}
#endif
ret = request_threaded_irq(pdata->esd_gpio_irq, NULL,
sec_esd_irq_handler,
irq_type |
IRQF_ONESHOT, "esd_detect", p_esd_data);
if (ret) {
pr_err("%s : Failed to request_irq.:ret=%d", __func__, ret);
goto err_request_detect_irq;
}
#if defined(CONFIG_SAMSUNG_CMC624)
if (samsung_has_cmc624()) {
ret = request_threaded_irq(pdata->esd_gpio_cmc_irq, NULL,
sec_esd_irq_handler,
IRQF_TRIGGER_RISING |
IRQF_ONESHOT, "esd_detect2", p_esd_data);
if (ret) {
pr_err("%s:Fail to request_irq.:ret=%d", __func__, ret);
goto err_request_detect_irq2;
}
}
#endif
set_esd_disable();
return 0;
#if defined(CONFIG_SAMSUNG_CMC624)
err_request_detect_irq2:
free_irq(pdata->esd_gpio_irq, p_esd_data);
#endif
err_request_detect_irq:
wake_lock_destroy(&p_esd_data->det_wake_lock);
kfree(p_esd_data);
esd_enable = NULL;
dev_set_drvdata(&pdev->dev, NULL);
return -1;
}
int __init msm8930_init_gpiomux(void)
{
int rc = msm_gpiomux_init(NR_GPIO_IRQS);
if (rc) {
pr_err(KERN_ERR "msm_gpiomux_init failed %d\n", rc);
return rc;
}
#if defined(CONFIG_MACH_MELIUS_CHN_CTC)
msm_gpiomux_install(sensor_config,
ARRAY_SIZE(sensor_config));
#endif
#if defined(CONFIG_KS8851) || defined(CONFIG_KS8851_MODULE)
msm_gpiomux_install(msm8960_ethernet_configs,
ARRAY_SIZE(msm8960_ethernet_configs));
#endif
msm_gpiomux_install(msm8960_gsbi_configs,
ARRAY_SIZE(msm8960_gsbi_configs));
#ifdef CONFIG_RADIO_USE_MI2S
msm_gpiomux_install(msm8960_mi2s_configs,
ARRAY_SIZE(msm8960_mi2s_configs));
#endif
#if !defined(CONFIG_MACH_MELIUS_SKT) && !defined(CONFIG_MACH_MELIUS_KTT) && \
!defined(CONFIG_MACH_MELIUS_LGT) && !defined(CONFIG_MACH_MELIUS_CHN_CTC) && \
!defined(CONFIG_MACH_MELIUS_EUR_LTE) && !defined(CONFIG_MACH_MELIUS_EUR_OPEN) && !defined(CONFIG_MACH_CRATER_CHN_CTC)
msm_gpiomux_install(msm8960_atmel_configs,
ARRAY_SIZE(msm8960_atmel_configs));
#endif
#ifdef CONFIG_2MIC_ES305
msm_gpiomux_install(audience_suspend_configs,
ARRAY_SIZE(audience_suspend_configs));
#endif
#ifdef CONFIG_SLIMBUS_MSM_CTRL
msm_gpiomux_install(msm8960_slimbus_config,
ARRAY_SIZE(msm8960_slimbus_config));
msm_gpiomux_install(msm8960_audio_codec_configs,
ARRAY_SIZE(msm8960_audio_codec_configs));
msm_gpiomux_install(msm8960_audio_mbhc_configs,
ARRAY_SIZE(msm8960_audio_mbhc_configs));
#else
if (system_rev < CLK_REVISION) {
msm_gpiomux_install(msm8960_audio_i2s_rx_codec_configs_rev10,
ARRAY_SIZE(msm8960_audio_i2s_rx_codec_configs_rev10));
msm_gpiomux_install(msm8960_audio_i2s_tx_codec_configs_rev10,
ARRAY_SIZE(msm8960_audio_i2s_tx_codec_configs_rev10));
} else {
msm_gpiomux_install(msm8960_audio_i2s_rx_codec_configs,
ARRAY_SIZE(msm8960_audio_i2s_rx_codec_configs));
msm_gpiomux_install(msm8960_audio_i2s_tx_codec_configs,
ARRAY_SIZE(msm8960_audio_i2s_tx_codec_configs));
}
#endif
msm_gpiomux_install(msm8960_audio_spkr_configs,
ARRAY_SIZE(msm8960_audio_spkr_configs));
#ifdef CONFIG_AUXPCM_INTERFACE
msm_gpiomux_install(msm8960_audio_auxpcm_configs,
ARRAY_SIZE(msm8960_audio_auxpcm_configs));
#endif
msm_gpiomux_install(wcnss_5wire_interface,
ARRAY_SIZE(wcnss_5wire_interface));
if (machine_is_msm8930_mtp() || machine_is_msm8930_fluid() ||
machine_is_msm8930_cdp()) {
#if !defined(CONFIG_RADIO_USE_MI2S) && !defined(CONFIG_TDMB)
msm_gpiomux_install(hap_lvl_shft_config,
ARRAY_SIZE(hap_lvl_shft_config));
#endif
#ifdef MSM8930_PHASE_2
msm_gpiomux_install(msm8930_hsusb_configs,
ARRAY_SIZE(msm8930_hsusb_configs));
#endif
}
if (PLATFORM_IS_CHARM25())
msm_gpiomux_install(mdm_configs,
ARRAY_SIZE(mdm_configs));
#ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL
msm_gpiomux_install(msm8960_hdmi_configs,
ARRAY_SIZE(msm8960_hdmi_configs));
#endif
#if defined(CONFIG_VIDEO_MHL_V2)
msm_gpiomux_install(msm8930_mhl_configs,
ARRAY_SIZE(msm8930_mhl_configs));
#endif
/* requested by HW team for IORA test */
#if (defined(CONFIG_MACH_MELIUS_SPR) || defined(CONFIG_MACH_MELIUS_USC))
msm_gpiomux_install(msm8930_fgchg_configs,
ARRAY_SIZE(msm8930_fgchg_configs));
#endif
msm_gpiomux_install(msm8960_mdp_vsync_configs,
ARRAY_SIZE(msm8960_mdp_vsync_configs));
msm_gpiomux_install(gpio_keys_config_mux,
ARRAY_SIZE(gpio_keys_config_mux));
#ifdef CONFIG_USB_SWITCH_FSA9485
msm_gpiomux_install(msm8960_fsa9485_configs,
ARRAY_SIZE(msm8960_fsa9485_configs));
#endif
#ifdef CONFIG_LEDS_AN30259A
msm_gpiomux_install(msm8930_leds_configs,
ARRAY_SIZE(msm8930_leds_configs));
#endif
#if defined(CONFIG_IR_REMOCON_FPGA)
msm_gpiomux_install(msm8930_fpga_resetn_configs,
ARRAY_SIZE(msm8930_fpga_resetn_configs));
msm_gpiomux_install(msm8930_fpga_irq_configs,
ARRAY_SIZE(msm8930_fpga_irq_configs));
#endif
msm_gpiomux_install(msm8930_sd_det_config,
ARRAY_SIZE(msm8930_sd_det_config));
#ifdef CONFIG_SAMSUNG_CMC624
if (samsung_has_cmc624()) {
msm_gpiomux_install(msm8x30_cmc624_configs,
ARRAY_SIZE(msm8x30_cmc624_configs));
}
#endif
#if defined(CONFIG_MACH_MELIUS_CHN_CTC)
msm_gpiomux_install(msm8x30_uartsel_configs,
ARRAY_SIZE(msm8x30_uartsel_configs));
#endif
#if defined(CONFIG_MACH_MELIUS_CHN_CTC) || defined(CONFIG_MACH_CRATER_CHN_CTC)
msm_gpiomux_install(msm8x30_simsel_configs,
ARRAY_SIZE(msm8x30_simsel_configs));
#endif
msm_gpiomux_install(msm8930_suspend_melius_configs,
ARRAY_SIZE(msm8930_suspend_melius_configs));
#if defined (CONFIG_MACH_MELIUS_SPR)
msm_gpiomux_install(pmic_gpio_configs,
ARRAY_SIZE(pmic_gpio_configs));
#endif
config_melius_gpio_init_sleep_gpio();
return 0;
}
