static int msm_fb_detect_panel(const char *name)
{
if (panel_type == PANEL_ID_PYD_SHARP) {
if (!strcmp(name, "mipi_cmd_novatek_qhd"))
return 0;
} else if (panel_type == PANEL_ID_HOY_SONY_OTM) {
if (!strcmp(name, "mipi_cmd_orise_qhd"))
return 0;
} else if (panel_type == PANEL_ID_NONE) {
if (board_build_flag() != 1) {
if (!strcmp(name, "mipi_cmd_orise_qhd")) {
PR_DISP_WARN("%s: bootloader detect NO panel. Use default ID.", __func__);
panel_type = PANEL_ID_HOY_SONY_OTM;
return 0;
}
}
}
#ifdef CONFIG_FB_MSM_HDMI_MSM_PANEL
else if (!strcmp(name, "hdmi_msm"))
return 0;
#endif /* CONFIG_FB_MSM_HDMI_MSM_PANEL */
PR_DISP_WARN("%s: not supported '%s'", __func__, name);
return -ENODEV;
}
static bool specific_rom_check(void)
{
int rom_check_pass = 0;
#if defined(CONFIG_MACH_DUMMY) || defined(CONFIG_MACH_DUMMY) || defined(CONFIG_MACH_DUMMY)\
|| defined(CONFIG_MACH_DUMMY)
rom_check_pass = 1;
#endif
return ((board_build_flag() == BUILD_MODE_MFG) && rom_check_pass)?1:0;
}
static int __init jet_init_panel(void)
{
printk(KERN_INFO "%s: panel type = 0x%x, hboot type = 0x%x, board_mfg_mode = 0x%x\n",
__func__, panel_type, board_build_flag(), board_mfg_mode());
if (panel_type == PANEL_ID_NONE) {
if (board_mfg_mode() == 8 || board_mfg_mode() == 4) {
printk(KERN_INFO "%s: enter mfgkernel/powettest \n", __func__);
return 0;
}
else if (board_build_flag() == SHIP_BUILD) {
/* For shipping produce, the main source panel can cover the most device */
printk(KERN_INFO "%s: Use PANEL_ID_JET_SONY_NT_C2 be default panel!\n", __func__);
panel_type = PANEL_ID_JET_SONY_NT_C2;
}
else
panic("[DISP] PANEL_ID_NONE! panic");
}
return 0;
}
static void __init msm_fb_add_devices(void)
{
PR_DISP_INFO("panel ID= 0x%x\n", panel_type);
if (board_build_flag() != 1 && panel_type == PANEL_ID_NONE) {
PR_DISP_WARN("%s: bootloader detect NO panel. Use default ID.", __func__);
panel_type = PANEL_ID_HOY_SONY_OTM;
}
msm_fb_register_device("mdp", &mdp_pdata);
if (panel_type != PANEL_ID_NONE)
msm_fb_register_device("mipi_dsi", &mipi_pdata);
else {
gpio_tlmm_config(lcd_gpio_table[0], GPIO_CFG_ENABLE);
gpio_tlmm_config(lcd_gpio_table[1], GPIO_CFG_ENABLE);
gpio_tlmm_config(lcd_gpio_table[2], GPIO_CFG_ENABLE);
}
#ifdef CONFIG_MSM_BUS_SCALING
msm_fb_register_device("dtv", &dtv_pdata);
#endif
}
int gpio_event_input_func(struct gpio_event_input_devs *input_devs,
struct gpio_event_info *info, void **data, int func)
{
int ret;
int i;
unsigned long irqflags;
struct gpio_event_input_info *di;
struct gpio_input_state *ds = *data;
struct kobject *keyboard_kobj;
di = container_of(info, struct gpio_event_input_info, info);
if (func == GPIO_EVENT_FUNC_SUSPEND) {
if (ds->use_irq)
for (i = 0; i < di->keymap_size; i++)
disable_irq(gpio_to_irq(di->keymap[i].gpio));
hrtimer_cancel(&ds->timer);
return 0;
}
if (func == GPIO_EVENT_FUNC_RESUME) {
spin_lock_irqsave(&ds->irq_lock, irqflags);
if (ds->use_irq)
for (i = 0; i < di->keymap_size; i++)
enable_irq(gpio_to_irq(di->keymap[i].gpio));
hrtimer_start(&ds->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
spin_unlock_irqrestore(&ds->irq_lock, irqflags);
return 0;
}
if (func == GPIO_EVENT_FUNC_INIT) {
if (ktime_to_ns(di->poll_time) <= 0)
di->poll_time = ktime_set(0, 20 * NSEC_PER_MSEC);
*data = ds = kzalloc(sizeof(*ds) + sizeof(ds->key_state[0]) *
di->keymap_size, GFP_KERNEL);
if (ds == NULL) {
ret = -ENOMEM;
KEY_LOGE("gpio_event_input_func: "
"Failed to allocate private data\n");
goto err_ds_alloc_failed;
}
ds->debounce_count = di->keymap_size;
ds->input_devs = input_devs;
ds->info = di;
wake_lock_init(&ds->wake_lock, WAKE_LOCK_SUSPEND, "gpio_input");
spin_lock_init(&ds->irq_lock);
if (board_build_flag() == 0)
ds->debug_log = 0;
else
ds->debug_log = 1;
for (i = 0; i < di->keymap_size; i++) {
int dev = di->keymap[i].dev;
if (dev >= input_devs->count) {
KEY_LOGE("gpio_event_input_func: bad device "
"index %d >= %d for key code %d\n",
dev, input_devs->count,
di->keymap[i].code);
ret = -EINVAL;
goto err_bad_keymap;
}
input_set_capability(input_devs->dev[dev], di->type,
di->keymap[i].code);
ds->key_state[i].ds = ds;
ds->key_state[i].debounce = DEBOUNCE_UNKNOWN;
}
for (i = 0; i < di->keymap_size; i++) {
ret = gpio_request(di->keymap[i].gpio, "gpio_kp_in");
if (ret) {
KEY_LOGE("gpio_event_input_func: gpio_request "
"failed for %d\n", di->keymap[i].gpio);
goto err_gpio_request_failed;
}
ret = gpio_direction_input(di->keymap[i].gpio);
if (ret) {
KEY_LOGE("gpio_event_input_func: "
"gpio_direction_input failed for %d\n",
di->keymap[i].gpio);
goto err_gpio_configure_failed;
}
}
if (di->setup_input_gpio)
di->setup_input_gpio();
ret = gpio_event_input_request_irqs(ds);
keyboard_kobj = kobject_create_and_add("keyboard", NULL);
if (keyboard_kobj == NULL) {
KEY_LOGE("KEY_ERR: %s: subsystem_register failed\n", __func__);
ret = -ENOMEM;
return ret;
}
if (sysfs_create_file(keyboard_kobj, &dev_attr_vol_wakeup.attr))
KEY_LOGE("gpio_event_input_func: sysfs_create_file "
"return %d\n", ret);
wakeup_bitmask = 0;
set_wakeup = 0;
spin_lock_irqsave(&ds->irq_lock, irqflags);
ds->use_irq = ret == 0;
KEY_LOGI("GPIO Input Driver: Start gpio inputs for %s%s in %s "
"mode\n", input_devs->dev[0]->name,
(input_devs->count > 1) ? "..." : "",
ret == 0 ? "interrupt" : "polling");
hrtimer_init(&ds->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
ds->timer.function = gpio_event_input_timer_func;
hrtimer_start(&ds->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
spin_unlock_irqrestore(&ds->irq_lock, irqflags);
return 0;
}
ret = 0;
spin_lock_irqsave(&ds->irq_lock, irqflags);
hrtimer_cancel(&ds->timer);
if (ds->use_irq) {
for (i = di->keymap_size - 1; i >= 0; i--) {
free_irq(gpio_to_irq(di->keymap[i].gpio),
&ds->key_state[i]);
}
}
spin_unlock_irqrestore(&ds->irq_lock, irqflags);
for (i = di->keymap_size - 1; i >= 0; i--) {
err_gpio_configure_failed:
gpio_free(di->keymap[i].gpio);
err_gpio_request_failed:
;
}
err_bad_keymap:
wake_lock_destroy(&ds->wake_lock);
kfree(ds);
err_ds_alloc_failed:
return ret;
}
int gpio_event_input_func(struct gpio_event_input_devs *input_devs,
struct gpio_event_info *info, void **data, int func)
{
int ret;
int i;
unsigned long irqflags;
struct gpio_event_input_info *di;
struct gpio_input_state *ds = *data;
di = container_of(info, struct gpio_event_input_info, info);
if (func == GPIO_EVENT_FUNC_SUSPEND) {
if (ds->use_irq)
for (i = 0; i < di->keymap_size; i++)
disable_irq(gpio_to_irq(di->keymap[i].gpio));
#ifndef CONFIG_MFD_MAX8957
hrtimer_cancel(&ds->timer);
#else
for (i = 0; i < di->keymap_size; i++) {
if (cancel_delayed_work_sync(&(ds->key_state[i].key_work)))
KEY_LOGI("Cancel delayed debounce function of keycode:0x%X success.\n", ds->info->keymap[i].code);
else
KEY_LOGI("Cancel delayed debounce function of keycode:0x%X fail.\n", ds->info->keymap[i].code);
}
#endif
return 0;
}
if (func == GPIO_EVENT_FUNC_RESUME) {
spin_lock_irqsave(&ds->irq_lock, irqflags);
if (ds->use_irq)
for (i = 0; i < di->keymap_size; i++)
enable_irq(gpio_to_irq(di->keymap[i].gpio));
#ifndef CONFIG_MFD_MAX8957
hrtimer_start(&ds->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
#else
queue_delayed_work(ki_queue, &(ds->key_state[0].key_work), 0);
#endif
spin_unlock_irqrestore(&ds->irq_lock, irqflags);
return 0;
}
if (func == GPIO_EVENT_FUNC_INIT) {
if (ktime_to_ns(di->poll_time) <= 0)
di->poll_time = ktime_set(0, 20 * NSEC_PER_MSEC);
*data = ds = kzalloc(sizeof(*ds) + sizeof(ds->key_state[0]) *
di->keymap_size, GFP_KERNEL);
if (ds == NULL) {
ret = -ENOMEM;
KEY_LOGE("KEY_ERR: %s: "
"Failed to allocate private data\n", __func__);
goto err_ds_alloc_failed;
}
ds->debounce_count = di->keymap_size;
ds->input_devs = input_devs;
ds->info = di;
wake_lock_init(&ds->wake_lock, WAKE_LOCK_SUSPEND, "gpio_input");
spin_lock_init(&ds->irq_lock);
if (board_build_flag() == 0)
ds->debug_log = 0;
else
ds->debug_log = 1;
for (i = 0; i < di->keymap_size; i++) {
int dev = di->keymap[i].dev;
if (dev >= input_devs->count) {
KEY_LOGE("KEY_ERR: %s: bad device "
"index %d >= %d for key code %d\n",
__func__, dev, input_devs->count,
di->keymap[i].code);
ret = -EINVAL;
goto err_bad_keymap;
}
input_set_capability(input_devs->dev[dev], di->type,
di->keymap[i].code);
ds->key_state[i].ds = ds;
ds->key_state[i].debounce = DEBOUNCE_UNKNOWN;
}
for (i = 0; i < di->keymap_size; i++) {
ret = gpio_request(di->keymap[i].gpio, "gpio_kp_in");
if (ret) {
KEY_LOGE("KEY_ERR: %s: gpio_request "
"failed for %d\n", __func__, di->keymap[i].gpio);
goto err_gpio_request_failed;
}
ret = gpio_direction_input(di->keymap[i].gpio);
if (ret) {
KEY_LOGE("KEY_ERR: %s: "
"gpio_direction_input failed for %d\n",
__func__, di->keymap[i].gpio);
goto err_gpio_configure_failed;
}
}
if (di->setup_input_gpio)
di->setup_input_gpio();
#ifdef CONFIG_MFD_MAX8957
ki_queue = create_singlethread_workqueue("ki_queue");
#endif
ret = gpio_event_input_request_irqs(ds);
spin_lock_irqsave(&ds->irq_lock, irqflags);
ds->use_irq = ret == 0;
KEY_LOGI("GPIO Input Driver: Start gpio inputs for %s%s in %s "
"mode\n", input_devs->dev[0]->name,
(input_devs->count > 1) ? "..." : "",
ret == 0 ? "interrupt" : "polling");
#ifndef CONFIG_MFD_MAX8957
hrtimer_init(&ds->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
ds->timer.function = gpio_event_input_timer_func;
hrtimer_start(&ds->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
#else
for (i = 0; i < di->keymap_size; i++)
INIT_DELAYED_WORK(&(ds->key_state[i].key_work), gpio_event_input_delayed_func);
queue_delayed_work(ki_queue, &(ds->key_state[0].key_work), 0);
#endif
spin_unlock_irqrestore(&ds->irq_lock, irqflags);
return 0;
}
ret = 0;
spin_lock_irqsave(&ds->irq_lock, irqflags);
#ifndef CONFIG_MFD_MAX8957
hrtimer_cancel(&ds->timer);
#else
for (i = 0; i < di->keymap_size; i++) {
if (cancel_delayed_work_sync(&(ds->key_state[i].key_work)))
KEY_LOGI("Cancel delayed debounce function of keycode:0x%X success.\n", ds->info->keymap[i].code);
else
KEY_LOGI("Cancel delayed debounce function of keycode:0x%X fail.\n", ds->info->keymap[i].code);
}
#endif
if (ds->use_irq) {
for (i = di->keymap_size - 1; i >= 0; i--) {
free_irq(gpio_to_irq(di->keymap[i].gpio),
&ds->key_state[i]);
}
}
spin_unlock_irqrestore(&ds->irq_lock, irqflags);
for (i = di->keymap_size - 1; i >= 0; i--) {
err_gpio_configure_failed:
gpio_free(di->keymap[i].gpio);
err_gpio_request_failed:
;
}
err_bad_keymap:
wake_lock_destroy(&ds->wake_lock);
kfree(ds);
err_ds_alloc_failed:
return ret;
}
int gpio_event_input_func(struct gpio_event_input_devs *input_devs,
struct gpio_event_info *info, void **data, int func)
{
int ret;
int i;
unsigned long irqflags;
struct gpio_event_input_info *di;
struct gpio_input_state *ds = *data;
struct kobject *keyboard_kobj;
di = container_of(info, struct gpio_event_input_info, info);
#ifdef CONFIG_POWER_KEY_CLR_RESET
gis = di;
#endif
if (func == GPIO_EVENT_FUNC_SUSPEND) {
if (ds->use_irq)
for (i = 0; i < di->keymap_size; i++)
disable_irq(gpio_to_irq(di->keymap[i].gpio));
#ifndef CONFIG_MFD_MAX8957
hrtimer_cancel(&ds->timer);
#endif
return 0;
}
if (func == GPIO_EVENT_FUNC_RESUME) {
spin_lock_irqsave(&ds->irq_lock, irqflags);
if (ds->use_irq)
for (i = 0; i < di->keymap_size; i++)
enable_irq(gpio_to_irq(di->keymap[i].gpio));
#ifndef CONFIG_MFD_MAX8957
hrtimer_start(&ds->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
#endif
spin_unlock_irqrestore(&ds->irq_lock, irqflags);
return 0;
}
if (func == GPIO_EVENT_FUNC_INIT) {
#ifdef CONFIG_POWER_KEY_CLR_RESET
#ifdef CONFIG_OF
if (di->info.rrm1_mode && di->dt_clear_hw_reset) {
KEY_LOGI("First clear reset in Lab Test RRM1 mode.\n");
if (di->dt_clear_hw_reset)
di->dt_clear_hw_reset(di->clr_gpio);
#else
if (di->info.rrm1_mode && di->clear_hw_reset) {
KEY_LOGI("First clear reset in Lab Test RRM1 mode.\n");
if (di->clear_hw_reset)
di->clear_hw_reset();
#endif
}
#endif
if (ktime_to_ns(di->poll_time) <= 0)
di->poll_time = ktime_set(0, 20 * NSEC_PER_MSEC);
*data = ds = kzalloc(sizeof(*ds) + sizeof(ds->key_state[0]) *
di->keymap_size, GFP_KERNEL);
if (ds == NULL) {
ret = -ENOMEM;
KEY_LOGE("KEY_ERR: %s: "
"Failed to allocate private data\n", __func__);
goto err_ds_alloc_failed;
}
ds->debounce_count = di->keymap_size;
ds->input_devs = input_devs;
ds->info = di;
wake_lock_init(&ds->wake_lock, WAKE_LOCK_SUSPEND, "gpio_input");
#ifdef CONFIG_MFD_MAX8957
wake_lock_init(&ds->key_pressed_wake_lock, WAKE_LOCK_SUSPEND, "pwr_key_pressed");
#endif
#ifdef CONFIG_POWER_KEY_CLR_RESET
wake_lock_init(&key_reset_clr_wake_lock, WAKE_LOCK_SUSPEND, "gpio_input_pwr_clear");
#endif
spin_lock_init(&ds->irq_lock);
if (board_build_flag() == BUILD_MODE_SHIP)
ds->debug_log = 0;
else
ds->debug_log = 1;
for (i = 0; i < di->keymap_size; i++) {
int dev = di->keymap[i].dev;
if (dev >= input_devs->count) {
KEY_LOGE("KEY_ERR: %s: bad device "
"index %d >= %d for key code %d\n",
__func__, dev, input_devs->count,
di->keymap[i].code);
ret = -EINVAL;
goto err_bad_keymap;
}
input_set_capability(input_devs->dev[dev], di->type,
di->keymap[i].code);
ds->key_state[i].ds = ds;
ds->key_state[i].debounce = DEBOUNCE_UNKNOWN;
}
for (i = 0; i < di->keymap_size; i++) {
ret = gpio_request(di->keymap[i].gpio, "gpio_kp_in");
if (ret) {
KEY_LOGE("KEY_ERR: %s: gpio_request "
"failed for %d\n", __func__, di->keymap[i].gpio);
goto err_gpio_request_failed;
}
ret = gpio_direction_input(di->keymap[i].gpio);
if (ret) {
KEY_LOGE("KEY_ERR: %s: "
"gpio_direction_input failed for %d\n",
__func__, di->keymap[i].gpio);
goto err_gpio_configure_failed;
}
}
#ifdef CONFIG_OF
if (di->dt_setup_input_gpio)
di->dt_setup_input_gpio(di->keymap, di->keymap_size);
#else
if (di->setup_input_gpio)
di->setup_input_gpio();
#endif
#ifdef CONFIG_MFD_MAX8957
ki_queue = create_singlethread_workqueue("ki_queue");
#endif
ret = gpio_event_input_request_irqs(ds);
keyboard_kobj = kobject_create_and_add("keyboard", NULL);
if (keyboard_kobj == NULL) {
KEY_LOGE("KEY_ERR: %s: subsystem_register failed\n", __func__);
ret = -ENOMEM;
return ret;
}
if (sysfs_create_file(keyboard_kobj, &dev_attr_vol_wakeup.attr))
KEY_LOGE("KEY_ERR: %s: sysfs_create_file "
"return %d\n", __func__, ret);
if(board_mfg_mode() != MFG_MODE_NORMAL) {
KEY_LOGI("%s: mode: %d\n", __func__, board_mfg_mode());
ds->disable_reset_wq = create_singlethread_workqueue("disable reset wq");
INIT_DELAYED_WORK(&ds->disable_reset_work, disable_reset_func);
INIT_DELAYED_WORK(&ds->clear_hw_reset_work, clear_hw_reset_func);
gb_ddata = ds;
wake_lock_init(&disable_reset_wake_lock, WAKE_LOCK_SUSPEND, "gpio_input_disable_reset");
if (disable_reset_sysfs_init())
KEY_LOGE("KEY_ERR: %s: disable_reset_sysfs_init fail\n", __func__);
}
ds->disable_reset_flag = 0;
wakeup_bitmask = 0;
set_wakeup = 0;
spin_lock_irqsave(&ds->irq_lock, irqflags);
ds->use_irq = ret == 0;
KEY_LOGI("GPIO Input Driver: Start gpio inputs for %s%s in %s "
"mode\n", input_devs->dev[0]->name,
(input_devs->count > 1) ? "..." : "",
ret == 0 ? "interrupt" : "polling");
#ifndef CONFIG_MFD_MAX8957
hrtimer_init(&ds->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
ds->timer.function = gpio_event_input_timer_func;
hrtimer_start(&ds->timer, ktime_set(0, 0), HRTIMER_MODE_REL);
#endif
#if defined(CONFIG_KPDPWR_S2_DVDD_RESET) && defined(CONFIG_POWER_KEY_CLR_RESET)
hrtimer_init(&clr_kpd_reset_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
clr_kpd_reset_timer.function = clr_kpd_rst_timer_func;
hrtimer_init(&enable_kpd_s2_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
enable_kpd_s2_timer.function = enable_kpd_s2_timer_func;
#endif
spin_unlock_irqrestore(&ds->irq_lock, irqflags);
return 0;
}
ret = 0;
spin_lock_irqsave(&ds->irq_lock, irqflags);
#ifndef CONFIG_MFD_MAX8957
hrtimer_cancel(&ds->timer);
#endif
if (ds->use_irq) {
for (i = di->keymap_size - 1; i >= 0; i--) {
free_irq(gpio_to_irq(di->keymap[i].gpio),
&ds->key_state[i]);
}
}
spin_unlock_irqrestore(&ds->irq_lock, irqflags);
if(board_mfg_mode() != MFG_MODE_NORMAL)
wake_lock_destroy(&disable_reset_wake_lock);
for (i = di->keymap_size - 1; i >= 0; i--) {
err_gpio_configure_failed:
gpio_free(di->keymap[i].gpio);
err_gpio_request_failed:
;
}
err_bad_keymap:
wake_lock_destroy(&ds->wake_lock);
#ifdef CONFIG_MFD_MAX8957
wake_lock_destroy(&ds->key_pressed_wake_lock);
#endif
#ifdef CONFIG_POWER_KEY_CLR_RESET
wake_lock_destroy(&key_reset_clr_wake_lock);
#endif
kfree(ds);
err_ds_alloc_failed:
return ret;
}