static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct gpio_keys_button *button = NULL;
struct gpio_button_data *bdata = NULL;
struct device *dev = &pdev->dev;
struct gpio_keys_platform_data alt_pdata;
struct input_dev *input;
int i, error;
int wakeup = 0;
#ifdef CONFIG_SENSORS_HALL
int ret;
struct device *sec_key;
#endif
if (!pdata) {
error = gpio_keys_get_devtree_pdata(dev, &alt_pdata);
if (error)
return error;
pdata = &alt_pdata;
}
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
#ifdef CONFIG_SENSORS_HALL
#if defined (CONFIG_SEC_MILLET_PROJECT) || defined (CONFIG_SEC_BERLUTI_PROJECT)
ret = gpio_request(pdata->gpio_flip_cover,"HALL");
if(ret)
printk(KERN_CRIT "[HALL IC] gpio Request FAIL\n");
else {
gpio_tlmm_config(GPIO_CFG(pdata->gpio_flip_cover,0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL,GPIO_CFG_2MA),GPIO_CFG_DISABLE);
}
#endif
ddata->gpio_flip_cover = pdata->gpio_flip_cover;
ddata->irq_flip_cover = gpio_to_irq(ddata->gpio_flip_cover);
wake_lock_init(&ddata->flip_wake_lock, WAKE_LOCK_SUSPEND,
"flip_wake_lock");
#endif
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
#ifdef CONFIG_SENSORS_HALL
if(ddata->gpio_flip_cover != 0) {
input->evbit[0] |= BIT_MASK(EV_SW);
input_set_capability(input, EV_SW, SW_FLIP);
}
#endif
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
button = &pdata->buttons[i];
bdata = &ddata->data[i];
error = gpio_keys_setup_key(pdev, input, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
/* get current state of buttons that are connected to GPIOs */
for (i = 0; i < pdata->nbuttons; i++) {
bdata = &ddata->data[i];
if (gpio_is_valid(bdata->button->gpio))
gpio_keys_gpio_report_event(bdata);
}
input_sync(input);
#ifdef CONFIG_SENSORS_HALL
sec_key = device_create(sec_class, NULL, 0, NULL, "sec_key");
if (IS_ERR(sec_key))
pr_err("Failed to create device(sec_key)!\n");
ret = device_create_file(sec_key, &dev_attr_sec_key_pressed);
if (ret) {
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_sec_key_pressed.attr.name);
}
#if defined(CONFIG_SENSORS_HALL)
if(ddata->gpio_flip_cover != 0) {
ret = device_create_file(sec_key, &dev_attr_hall_detect);
if (ret < 0) {
pr_err("Failed to create device file(%s)!, error: %d\n",
dev_attr_hall_detect.attr.name, ret);
}
}
#if defined (CONFIG_SEC_MILLET_PROJECT) || defined (CONFIG_SEC_BERLUTI_PROJECT)
if (!lvs1_1p8) {
lvs1_1p8 = regulator_get(dev, "8226_lvs1");
if(!lvs1_1p8)
printk(KERN_CRIT "%s: regulator_get for 8226_lvs1 failed\n", __func__);
else {
ret = regulator_enable(lvs1_1p8);
if (ret){
regulator_put(lvs1_1p8);
printk(KERN_CRIT "%s: Failed to enable regulator lvs1_1p8.\n",__func__);
}
}
}
#endif
#endif
ret = device_create_file(sec_key, &dev_attr_wakeup_keys);
if (ret < 0) {
pr_err("Failed to create device file(%s), error: %d\n",
dev_attr_wakeup_keys.attr.name, ret);
}
dev_set_drvdata(sec_key, ddata);
#endif
device_init_wakeup(&pdev->dev, wakeup);
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0)
gpio_remove_key(&ddata->data[i]);
platform_set_drvdata(pdev, NULL);
#ifdef CONFIG_SENSORS_HALL
wake_lock_destroy(&ddata->flip_wake_lock);
#endif
fail1:
input_free_device(input);
kfree(ddata);
/* If we have no platform_data, we allocated buttons dynamically. */
if (!pdev->dev.platform_data)
kfree(pdata->buttons);
return error;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct gpio_keys_platform_data alt_pdata;
struct input_dev *input;
int i, error;
int wakeup = 0;
if (!pdata) {
error = gpio_keys_get_devtree_pdata(dev, &alt_pdata);
if (error)
return error;
pdata = &alt_pdata;
}
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
const struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
error = gpio_keys_setup_key(pdev, input, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
/* get current state of buttons that are connected to GPIOs */
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_button_data *bdata = &ddata->data[i];
if (gpio_is_valid(bdata->button->gpio))
gpio_keys_gpio_report_event(bdata);
}
input_sync(input);
device_init_wakeup(&pdev->dev, wakeup);
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0)
gpio_remove_key(&ddata->data[i]);
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
/* If we have no platform_data, we allocated buttons dynamically. */
if (!pdev->dev.platform_data)
kfree(pdata->buttons);
return error;
}
static int gpio_keys_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
struct gpio_keys_drvdata *ddata;
struct input_dev *input;
size_t size;
int i, error;
int wakeup = 0;
if (!pdata) {
pdata = gpio_keys_get_devtree_pdata(dev);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
}
size = sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data);
ddata = devm_kzalloc(dev, size, GFP_KERNEL);
if (!ddata) {
dev_err(dev, "failed to allocate state\n");
return -ENOMEM;
}
input = devm_input_allocate_device(dev);
if (!input) {
dev_err(dev, "failed to allocate input device\n");
return -ENOMEM;
}
ddata->pdata = pdata;
ddata->input = input;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
const struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
error = gpio_keys_setup_key(pdev, input, bdata, button);
if (error)
return error;
if (button->wakeup)
wakeup = 1;
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
return error;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto err_remove_group;
}
device_init_wakeup(&pdev->dev, wakeup);
return 0;
err_remove_group:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
return error;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct input_dev *input;
int i, error;
int wakeup = 0;
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
unsigned int type = button->type ?: EV_KEY;
bdata->input = input;
bdata->button = button;
error = gpio_keys_setup_key(pdev, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
input_set_capability(input, type, button->code);
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
/* get current state of buttons */
for (i = 0; i < pdata->nbuttons; i++)
gpio_keys_report_event(&ddata->data[i]);
input_sync(input);
device_init_wakeup(&pdev->dev, wakeup);
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0) {
free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
if (ddata->data[i].timer_debounce)
del_timer_sync(&ddata->data[i].timer);
cancel_work_sync(&ddata->data[i].work);
gpio_free(pdata->buttons[i].gpio);
}
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
return error;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct gpio_keys_platform_data alt_pdata;
struct input_dev *input;
int i, error;
int wakeup = 0;
if (!pdata) {
error = gpio_keys_get_devtree_pdata(dev, &alt_pdata);
if (error)
return error;
pdata = &alt_pdata;
}
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
#ifdef CONFIG_SENSORS_HALL
ddata->gpio_flip_cover = pdata->gpio_flip_cover;
ddata->irq_flip_cover = gpio_to_irq(ddata->gpio_flip_cover);;
wake_lock_init(&ddata->flip_wake_lock, WAKE_LOCK_SUSPEND,
"flip wake lock");
#endif
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
#ifdef CONFIG_SENSORS_HALL
input->evbit[0] |= BIT_MASK(EV_SW);
input_set_capability(input, EV_SW, SW_FLIP);
#endif
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
error = gpio_keys_setup_key(pdev, input, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
#ifdef KEY_BOOSTER
if (button->code == KEY_HOMEPAGE) {
error = gpio_key_init_dvfs(bdata);
if (error < 0) {
dev_err(dev, "Fail get dvfs level for touch booster\n");
goto fail2;
}
}
#endif
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
ddata->sec_key =
device_create(sec_class, NULL, 0, ddata, "sec_key");
if (IS_ERR(ddata->sec_key))
dev_err(dev, "Failed to create sec_key device\n");
error = sysfs_create_group(&ddata->sec_key->kobj, &sec_key_attr_group);
if (error) {
dev_err(dev, "Failed to create the test sysfs: %d\n",
error);
goto fail2;
}
#ifdef CONFIG_SENSORS_HALL
init_hall_ic_irq(input);
#endif
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
/* get current state of buttons */
for (i = 0; i < pdata->nbuttons; i++)
gpio_keys_gpio_report_event(&ddata->data[i]);
input_sync(input);
device_init_wakeup(&pdev->dev, wakeup);
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
sysfs_remove_group(&ddata->sec_key->kobj, &sec_key_attr_group);
fail2:
while (--i >= 0)
gpio_remove_key(&ddata->data[i]);
platform_set_drvdata(pdev, NULL);
#ifdef CONFIG_SENSORS_HALL
wake_lock_destroy(&ddata->flip_wake_lock);
#endif
fail1:
input_free_device(input);
kfree(ddata);
/* If we have no platform_data, we allocated buttons dynamically. */
if (!pdev->dev.platform_data)
kfree(pdata->buttons);
return error;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct input_dev *input;
int i, error;
int wakeup = 0;
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
#ifdef CONFIG_MACH_GC1
ddata->gpio_strobe_insert = pdata->gpio_strobe_insert;
#endif
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
#ifdef CONFIG_MACH_GC1
input->evbit[0] |= BIT_MASK(EV_SW);
input_set_capability(input, EV_SW, SW_STROBE_INSERT);
#endif
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
unsigned int type = button->type ?: EV_KEY;
bdata->input = input;
bdata->button = button;
error = gpio_keys_setup_key(pdev, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
input_set_capability(input, type, button->code);
#ifdef CONFIG_TOUCH_WAKE
set_powerkeydev(input);
#endif
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
ddata->sec_key =
device_create(sec_class, NULL, 0, ddata, "sec_key");
if (IS_ERR(ddata->sec_key))
dev_err(dev, "Failed to create sec_key device\n");
error = sysfs_create_group(&ddata->sec_key->kobj, &sec_key_attr_group);
if (error) {
dev_err(dev, "Failed to create the test sysfs: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
/* get current state of buttons */
for (i = 0; i < pdata->nbuttons; i++)
gpio_keys_report_event(&ddata->data[i]);
input_sync(input);
#ifdef CONFIG_FAST_BOOT
/*Fake power off*/
input_set_capability(input, EV_KEY, KEY_FAKE_PWR);
setup_timer(&fake_timer, gpio_keys_fake_off_check,
(unsigned long)input);
wake_lock_init(&fake_lock, WAKE_LOCK_SUSPEND, "fake_lock");
#endif
device_init_wakeup(&pdev->dev, wakeup);
#if defined(CONFIG_MACH_KONA)
#ifdef AUTO_POWER_ON_OFF_FLAG
init_timer(&poweroff_keypad_timer);
poweroff_keypad_timer.function = poweroff_keypad_timer_handler;
poweroff_keypad_timer.data = (unsigned long)&ddata->data[0];
poweroff_keypad_timer.expires = jiffies + 40*HZ;
add_timer(&poweroff_keypad_timer);
printk("AUTO_POWER_ON_OFF_FLAG Test Start !!!\n");
#endif
#endif
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
sysfs_remove_group(&ddata->sec_key->kobj, &sec_key_attr_group);
fail2:
while (--i >= 0) {
free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
if (ddata->data[i].timer_debounce)
del_timer_sync(&ddata->data[i].timer);
cancel_work_sync(&ddata->data[i].work);
gpio_free(pdata->buttons[i].gpio);
}
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
return error;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct input_dev *input;
int i, error, ret;
int wakeup = 0;
struct kobject *keyboard_kobj;
doCheck = true;
printk("[KEY] gpio_keys_probe\n");
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
#ifdef CONFIG_TOUCHSCREEN_SYNAPTICS_SWEEP2WAKE
if (!strcmp(input->name, "gpio-keys")) {
sweep2wake_setdev(input);
printk(KERN_INFO "[sweep2wake]: set device %s\n", input->name);
}
#endif
PWR_MISTOUCH_gpio = pdata->PWR_MISTOUCH_gpio;
mistouch_gpio_normal = pdata->mistouch_gpio_normal;
mistouch_gpio_active = pdata->mistouch_gpio_active;
if ( PWR_MISTOUCH_gpio ) {
gpio_free(PWR_MISTOUCH_gpio);
ret = gpio_request(PWR_MISTOUCH_gpio, "PWR_MISTOUCH");
if (ret < 0) {
pr_err("[KEY]Requesting GPIO %d failes\n", PWR_MISTOUCH_gpio);
}
if ( mistouch_gpio_normal != NULL )
mistouch_gpio_normal();
else
pr_err("[KEY] mistouch_gpio_normal() is NULL\n");
}
delay_wq = create_singlethread_workqueue("gpio_key_work");
INIT_DELAYED_WORK(&delay_work, Mistouch_powerkey_func);
wake_lock_init(&key_reset_clr_wake_lock, WAKE_LOCK_SUSPEND, "gpio_input_pwr_clear");
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
unsigned int type = button->type ?: EV_KEY;
bdata->input = input;
bdata->button = button;
error = gpio_keys_setup_key(pdev, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
input_set_capability(input, type, button->code);
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
keyboard_kobj = kobject_create_and_add("keyboard", NULL);
if (keyboard_kobj == NULL) {
printk(KERN_ERR "[KEY] KEY_ERR: %s: subsystem_register failed\n", __func__);
return -ENOMEM;
}
if (sysfs_create_file(keyboard_kobj, &dev_attr_vol_wakeup.attr))
pr_err("%s: sysfs_create_file error", __func__);
wakeup_bitmask = 0;
set_wakeup = 0;
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
/* get current state of buttons */
for (i = 0; i < pdata->nbuttons; i++) {
if (KEY_POWER != pdata->buttons[i].code)
gpio_keys_report_event(&ddata->data[i]);
}
input_sync(input);
device_init_wakeup(&pdev->dev, wakeup);
wake_lock_init(&power_key_wake_lock, WAKE_LOCK_SUSPEND, "power_key_wake_lock");
pr_info("[KEY] gpio_keys_probe end.\n");
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0) {
free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
if (ddata->data[i].timer_debounce)
del_timer_sync(&ddata->data[i].timer);
cancel_work_sync(&ddata->data[i].work);
gpio_free(pdata->buttons[i].gpio);
}
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
return error;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct gpio_keys_platform_data alt_pdata;
struct input_dev *input;
int i, error;
int wakeup = 0;
int ret;
struct device *sec_key;
if (!pdata) {
error = gpio_keys_get_devtree_pdata(dev, &alt_pdata);
if (error)
return error;
pdata = &alt_pdata;
}
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
#ifdef CONFIG_SENSORS_HALL
ddata->gpio_flip_cover = pdata->gpio_flip_cover;
ddata->irq_flip_cover = gpio_to_irq(ddata->gpio_flip_cover);
#endif
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
#ifdef CONFIG_SENSORS_HALL
input->evbit[0] |= BIT_MASK(EV_SW);
input_set_capability(input, EV_SW, SW_FLIP);
#endif
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
error = gpio_keys_setup_key(pdev, input, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
/* get current state of buttons that are connected to GPIOs */
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_button_data *bdata = &ddata->data[i];
if (gpio_is_valid(bdata->button->gpio))
gpio_keys_gpio_report_event(bdata);
}
input_sync(input);
sec_key = device_create(sec_class, NULL, 0, NULL, "sec_key");
if (IS_ERR(sec_key))
pr_err("Failed to create device(sec_key)!\n");
#if defined(CONFIG_SENSORS_HALL)
ret = device_create_file(sec_key, &dev_attr_hall_detect);
if (ret < 0) {
pr_err("Failed to create device file(%s)!, error: %d\n",
dev_attr_hall_detect.attr.name, ret);
}
#endif
ret = device_create_file(sec_key, &dev_attr_sec_key_pressed);
if (ret) {
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_sec_key_pressed.attr.name);
}
ret = device_create_file(sec_key, &dev_attr_wakeup_keys);
if (ret < 0) {
pr_err("Failed to create device file(%s), error: %d\n",
dev_attr_wakeup_keys.attr.name, ret);
}
dev_set_drvdata(sec_key, ddata);
device_init_wakeup(&pdev->dev, wakeup);
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0)
gpio_remove_key(&ddata->data[i]);
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
/* If we have no platform_data, we allocated buttons dynamically. */
if (!pdev->dev.platform_data)
kfree(pdata->buttons);
return error;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct gpio_keys_platform_data alt_pdata;
struct input_dev *input;
int i, error;
int wakeup = 0;
if (!pdata) {
error = gpio_keys_get_devtree_pdata(dev, &alt_pdata);
if (error)
return error;
pdata = &alt_pdata;
}
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
const struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
error = gpio_keys_setup_key(pdev, input, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
//&*&*&*CT1_20120516, add GSesor lock switch pin detection
ddata->lock_status= gpio_get_value(TEGRA_GPIO_PQ2); //get KB_COL2 pin status
ddata->sdev.name = FUNCTION_NAME;
ddata->sdev.print_name = print_switch_name;
ddata->sdev.print_state = print_switch_state;
ddata->sdev.state = 0;
error = switch_dev_register(&ddata->sdev);
if (error < 0)
{
printk("Error registering switch!\n");
goto fail4;
}
error = gpio_request(TEGRA_GPIO_PQ2, "glocksensor_irq");
if (error < 0) {
dev_err(dev, "failed to request TEGRA_GPIO_PQ2 error %d\n",
error);
goto fail4;
}
error = gpio_direction_input(TEGRA_GPIO_PQ2);
if (error < 0) {
dev_err(dev, "failed to configure direction for TEGRA_GPIO_PQ2 error %d\n",
error);
goto fail4;
}
tegra_gpio_enable(TEGRA_GPIO_PQ2);
ddata->lock_status= gpio_get_value(TEGRA_GPIO_PQ2);
switch_set_state(&ddata->sdev, ddata->lock_status);
error = request_threaded_irq(gpio_to_irq(TEGRA_GPIO_PQ2),NULL, process_interrupt, IRQF_TRIGGER_FALLING |IRQF_TRIGGER_RISING, "glocksensor_irq", ddata);
if( error )
{
dev_err(dev, "Unable to register swith interrupt device, error: %d\n",
error);
goto fail5;
}
//&*&*&*CT2_20120516, add GSesor lock switch pin detection
/* get current state of buttons that are connected to GPIOs */
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_button_data *bdata = &ddata->data[i];
if (gpio_is_valid(bdata->button->gpio))
gpio_keys_gpio_report_event(bdata);
}
input_sync(input);
//&*&*&*HC1_20120514
if (input != NULL)
g_pwr_input = input;
//&*&*&*HC2_20120514
device_init_wakeup(&pdev->dev, wakeup);
return 0;
//&*&*&*CT1_20120516, add GSesor lock switch pin detection
fail5:
switch_dev_unregister(&ddata->sdev);
fail4:
gpio_free(TEGRA_GPIO_PQ2);
//&*&*&*CT2_20120516, add GSesor lock switch pin detection
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0)
gpio_remove_key(&ddata->data[i]);
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
/* If we have no platform_data, we allocated buttons dynamically. */
if (!pdev->dev.platform_data)
kfree(pdata->buttons);
return error;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct input_dev *input;
int i, error;
int wakeup = 0;
struct device *sec_key;
#if defined(CONFIG_MACH_AEGIS2) || defined(CONFIG_MACH_APEXQ)
struct device *sec_qwerty_flip ;
#endif
int ret;
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = "sec_keys";
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
/* Enable keyled for gpio keys */
if (pdata->keyled) {
__set_bit(EV_LED, input->evbit);
__set_bit(LED_MISC, input->ledbit);
}
for (i = 0; i < pdata->nbuttons; i++) {
struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
unsigned int type = button->type ?: EV_KEY;
bdata->input = input;
bdata->button = button;
error = gpio_keys_setup_key(pdev, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
input_set_capability(input, type, button->code);
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
/* get current state of buttons */
for (i = 0; i < pdata->nbuttons; i++)
gpio_keys_report_event(&ddata->data[i]);
input_sync(input);
sec_key = device_create(sec_class, NULL, 0, NULL, "sec_key");
if (IS_ERR(sec_key))
pr_err("Failed to create device(sec_key)!\n");
ret = device_create_file(sec_key, &dev_attr_sec_key_pressed);
if (ret) {
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_sec_key_pressed.attr.name);
}
#if defined(CONFIG_MACH_AEGIS2) || defined(CONFIG_MACH_APEXQ)
sec_qwerty_flip = device_create(sec_class, NULL, 0, NULL,
"sec_qwerty_flip");
if (IS_ERR(sec_qwerty_flip))
pr_err("Failed to create device(sec_qwerty_flip)!\n");
ret = device_create_file(sec_qwerty_flip,
&dev_attr_sec_qwerty_flip_pressed);
if (ret) {
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_sec_qwerty_flip_pressed.attr.name);
}
#endif
ret = device_create_file(sec_key, &dev_attr_wakeup_keys);
if (ret < 0) {
pr_err("Failed to create device file(%s), error: %d\n",
dev_attr_wakeup_keys.attr.name, ret);
}
dev_set_drvdata(sec_key, ddata);
#if defined(CONFIG_MACH_AEGIS2) || defined(CONFIG_MACH_APEXQ)
dev_set_drvdata(sec_qwerty_flip, ddata);
#endif
device_init_wakeup(&pdev->dev, 1);
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0) {
free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
if (ddata->data[i].timer_debounce)
del_timer_sync(&ddata->data[i].timer);
cancel_work_sync(&ddata->data[i].work);
gpio_free(pdata->buttons[i].gpio);
}
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
return error;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct device *dev = &pdev->dev;
struct gpio_keys_platform_data alt_pdata;
struct input_dev *input;
int i, error;
int wakeup = 0;
if (!pdata) {
error = gpio_keys_get_devtree_pdata(dev, &alt_pdata);
if (error)
return error;
pdata = &alt_pdata;
}
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
#if 0
error = gpio_request(GPIO_CAMERA_CTRL, NULL);
if (error < 0) {
printk("[%s]Failed to request GPIO %d, error %d\n",
__func__,GPIO_CAMERA_CTRL, error);
//return error;
}
#endif
Printlog("[%s]hw_id = %d \n",__func__,board_type_with_hw_id());
camera_ctrl= (board_type_with_hw_id() > DVT2_BOARD_HW_ID);
Printlog("[%s] camera_ctrl :%d \n",__func__,camera_ctrl);
// camera_ctrl = gpio_get_value(GPIO_CAMERA_CTRL);
if(camera_ctrl){//for after DVT3 to cahnge camera gpio define
for (i = 4; i <8; i++) {
const struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
error = gpio_keys_setup_key(pdev, input, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
}
}else{ //for before DVT3.
for (i = 0; i < pdata->nbuttons-4; i++) {
const struct gpio_keys_button *button = &pdata->buttons[i];
struct gpio_button_data *bdata = &ddata->data[i];
error = gpio_keys_setup_key(pdev, input, bdata, button);
if (error)
goto fail2;
if (button->wakeup)
wakeup = 1;
}
}
//PrintAA("[%s] GPIO_CAMERA_CTRL value:%d",__func__,camera_ctrl);
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
if(camera_ctrl){//for after DVT3 to cahnge camera gpio define
/* get current state of buttons that are connected to GPIOs */
for (i = 4; i < 8; i++) {
struct gpio_button_data *bdata = &ddata->data[i];
if (gpio_is_valid(bdata->button->gpio))
gpio_keys_gpio_report_event(bdata);
}
}else{//for before DVT3
/* get current state of buttons that are connected to GPIOs */
for (i = 0; i < pdata->nbuttons-4; i++) {
struct gpio_button_data *bdata = &ddata->data[i];
if (gpio_is_valid(bdata->button->gpio))
gpio_keys_gpio_report_event(bdata);
}
}
input_sync(input);
device_init_wakeup(&pdev->dev, wakeup);
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
if(camera_ctrl)
while (--i >= 4)
gpio_remove_key(&ddata->data[i]);
else{
while (--i >= 0) //for before DVT3.
gpio_remove_key(&ddata->data[i]);
}
platform_set_drvdata(pdev, NULL);
fail1:
input_free_device(input);
kfree(ddata);
/* If we have no platform_data, we allocated buttons dynamically. */
if (!pdev->dev.platform_data)
kfree(pdata->buttons);
return error;
}
static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
const struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
struct gpio_keys_drvdata *ddata;
struct gpio_keys_button *button = NULL;
struct gpio_button_data *bdata = NULL;
struct device *dev = &pdev->dev;
struct gpio_keys_platform_data alt_pdata;
struct input_dev *input;
int i, error;
int wakeup = 0;
int ret;
struct device *sec_key;
#ifdef CONFIG_SEC_PATEK_PROJECT
struct device *sec_keypad;
struct device *sec_flip;
#endif
if (!pdata) {
error = gpio_keys_get_devtree_pdata(dev, &alt_pdata);
if (error)
return error;
pdata = &alt_pdata;
}
ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data),
GFP_KERNEL);
input = input_allocate_device();
if (!ddata || !input) {
dev_err(dev, "failed to allocate state\n");
error = -ENOMEM;
goto fail1;
}
ddata->input = input;
ddata->n_buttons = pdata->nbuttons;
ddata->enable = pdata->enable;
ddata->disable = pdata->disable;
#ifdef CONFIG_SENSORS_HALL_DEBOUNCE
ddata->debounce_set = pdata->debounce_set;
#endif
#ifdef CONFIG_SENSORS_HALL
#if defined (CONFIG_SEC_MILLET_PROJECT) || defined (CONFIG_SEC_BERLUTI_PROJECT)\
|| defined (CONFIG_SEC_MATISSE_PROJECT) || defined (CONFIG_SEC_ATLANTIC_PROJECT)\
|| defined (CONFIG_SEC_MEGA2_PROJECT) || defined (CONFIG_SEC_T8_PROJECT) || defined (CONFIG_SEC_T10_PROJECT) || defined(CONFIG_SEC_HESTIA_PROJECT)
ret = gpio_request(pdata->gpio_flip_cover,"HALL");
if(ret)
printk(KERN_CRIT "[HALL IC] gpio Request FAIL\n");
else {
gpio_tlmm_config(GPIO_CFG(pdata->gpio_flip_cover,0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL,GPIO_CFG_2MA),GPIO_CFG_DISABLE);
}
#endif
ddata->gpio_flip_cover = pdata->gpio_flip_cover;
ddata->flip_code = pdata->flip_code;
ddata->irq_flip_cover = gpio_to_irq(ddata->gpio_flip_cover);
wake_lock_init(&ddata->flip_wake_lock, WAKE_LOCK_SUSPEND,
"flip_wake_lock");
flip_status_before = -1;
#endif
mutex_init(&ddata->disable_lock);
#ifdef CONFIG_SENSORS_HALL_IRQ_CTRL
mutex_init(&ddata->irq_lock);
#endif
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = &pdev->dev;
#ifdef CONFIG_SENSORS_HALL
if(ddata->gpio_flip_cover != 0) {
input->evbit[0] |= BIT_MASK(EV_SW);
input_set_capability(input, EV_SW, ddata->flip_code);
}
#endif
#ifdef CONFIG_SENSORS_HALL_IRQ_CTRL
ddata->gsm_area = false;
ddata->cover_state = false;
ddata->workaround_set = pdata->workaround_set;
drv_data = ddata;
#endif
#ifdef CONFIG_SENSORS_HALL_DEBOUNCE
ddata->debounce_set = false;
#endif
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
button = &pdata->buttons[i];
bdata = &ddata->data[i];
error = gpio_keys_setup_key(pdev, input, bdata, button);
if (error)
goto fail2;
#ifdef KEY_BOOSTER
error = gpio_key_init_dvfs(bdata);
if (error < 0) {
dev_err(dev, "Fail get dvfs level for touch booster\n");
goto fail2;
}
#endif
if (button->wakeup)
wakeup = 1;
}
error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
goto fail2;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
goto fail3;
}
/* get current state of buttons that are connected to GPIOs */
for (i = 0; i < pdata->nbuttons; i++) {
bdata = &ddata->data[i];
if (gpio_is_valid(bdata->button->gpio))
gpio_keys_gpio_report_event(bdata);
}
input_sync(input);
sec_key = device_create(sec_class, NULL, 0, NULL, "sec_key");
if (IS_ERR(sec_key))
pr_err("Failed to create device(sec_key)!\n");
#ifdef CONFIG_SEC_PATEK_PROJECT
sec_keypad=device_create(sec_class, NULL, 0, NULL, "sec_keypad");
if (device_create_file(sec_keypad, &dev_attr_brightness) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_brightness.attr.name);
sec_flip = device_create(sec_class, NULL, 0, NULL, "sec_flip");
if (device_create_file(sec_flip, &dev_attr_flipStatus) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_flipStatus.attr.name);
#endif
ret = device_create_file(sec_key, &dev_attr_sec_key_pressed);
if (ret) {
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_sec_key_pressed.attr.name);
}
#if defined(CONFIG_SEC_S_PROJECT)
ret = device_create_file(sec_key, &dev_attr_sec_key_pressed_code);
if (ret) {
pr_err("Failed to create device file in sysfs entries(%s)!\n",
dev_attr_sec_key_pressed_code.attr.name);
}
#endif
#ifdef CONFIG_SENSORS_HALL_IRQ_CTRL
if(ddata->gpio_flip_cover != 0) {
ret = device_create_file(sec_key, &dev_attr_hall_irq_ctrl);
if (ret < 0) {
pr_err("Failed to create device file(%s)!, error: %d\n",
dev_attr_hall_irq_ctrl.attr.name, ret);
}
}
#endif
#if defined(CONFIG_SENSORS_HALL)
if(ddata->gpio_flip_cover != 0) {
ret = device_create_file(sec_key, &dev_attr_hall_detect);
if (ret < 0) {
pr_err("Failed to create device file(%s)!, error: %d\n",
dev_attr_hall_detect.attr.name, ret);
}
}
#if defined(CONFIG_SENSORS_HALL_DEBOUNCE)
if(ddata->gpio_flip_cover != 0) {
ret = device_create_file(sec_key, &dev_attr_hall_irq_ctrl);
if (ret < 0) {
pr_err("Failed to create device file(%s)!, error: %d\n",
dev_attr_hall_irq_ctrl.attr.name, ret);
}
}
#endif
#if defined (CONFIG_SEC_MILLET_PROJECT) || defined (CONFIG_SEC_BERLUTI_PROJECT) || defined (CONFIG_SEC_T8_PROJECT)
if (!lvs1_1p8) {
lvs1_1p8 = regulator_get(dev, "8226_lvs1");
if(!lvs1_1p8)
printk(KERN_CRIT "%s: regulator_get for 8226_lvs1 failed\n", __func__);
else {
ret = regulator_enable(lvs1_1p8);
if (ret){
regulator_put(lvs1_1p8);
printk(KERN_CRIT "%s: Failed to enable regulator lvs1_1p8.\n",__func__);
}
}
}
#endif
#endif
#ifdef CONFIG_USE_VM_KEYBOARD_REJECT
reject_keyboard_specific_key = false;
ret = device_create_file(sec_key, &dev_attr_reject_key_comb);
if (ret < 0) {
pr_err("Failed to create device file(%s), error: %d\n",
dev_attr_reject_key_comb.attr.name, ret);
}
#endif
ret = device_create_file(sec_key, &dev_attr_wakeup_keys);
if (ret < 0) {
pr_err("Failed to create device file(%s), error: %d\n",
dev_attr_wakeup_keys.attr.name, ret);
}
dev_set_drvdata(sec_key, ddata);
device_init_wakeup(&pdev->dev, wakeup);
#if defined(CONFIG_SEC_PATEK_PROJECT)
keypadled_powerset(&pdev->dev);
dev_set_drvdata(sec_flip, ddata);
#endif
#ifdef PERIODIC_CHECK_GPIOS
INIT_DELAYED_WORK_DEFERRABLE(&g_gpio_check_work,
sec_gpiocheck_work);
schedule_delayed_work(&g_gpio_check_work,
msecs_to_jiffies(0));
#endif
return 0;
fail3:
sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
fail2:
while (--i >= 0)
gpio_remove_key(&ddata->data[i]);
platform_set_drvdata(pdev, NULL);
#ifdef CONFIG_SENSORS_HALL
wake_lock_destroy(&ddata->flip_wake_lock);
#endif
fail1:
input_free_device(input);
kfree(ddata);
/* If we have no platform_data, we allocated buttons dynamically. */
if (!pdev->dev.platform_data)
kfree(pdata->buttons);
return error;
}
static int gpio_keys_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
struct fwnode_handle *child = NULL;
struct gpio_keys_drvdata *ddata;
struct input_dev *input;
size_t size;
int i, error;
int wakeup = 0;
if (!pdata) {
pdata = gpio_keys_get_devtree_pdata(dev);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
}
size = sizeof(struct gpio_keys_drvdata) +
pdata->nbuttons * sizeof(struct gpio_button_data);
ddata = devm_kzalloc(dev, size, GFP_KERNEL);
if (!ddata) {
dev_err(dev, "failed to allocate state\n");
return -ENOMEM;
}
ddata->keymap = devm_kcalloc(dev,
pdata->nbuttons, sizeof(ddata->keymap[0]),
GFP_KERNEL);
if (!ddata->keymap)
return -ENOMEM;
input = devm_input_allocate_device(dev);
if (!input) {
dev_err(dev, "failed to allocate input device\n");
return -ENOMEM;
}
ddata->pdata = pdata;
ddata->input = input;
mutex_init(&ddata->disable_lock);
platform_set_drvdata(pdev, ddata);
input_set_drvdata(input, ddata);
input->name = pdata->name ? : pdev->name;
input->phys = "gpio-keys/input0";
input->dev.parent = dev;
input->open = gpio_keys_open;
input->close = gpio_keys_close;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0100;
input->keycode = ddata->keymap;
input->keycodesize = sizeof(ddata->keymap[0]);
input->keycodemax = pdata->nbuttons;
/* Enable auto repeat feature of Linux input subsystem */
if (pdata->rep)
__set_bit(EV_REP, input->evbit);
for (i = 0; i < pdata->nbuttons; i++) {
const struct gpio_keys_button *button = &pdata->buttons[i];
if (!dev_get_platdata(dev)) {
child = device_get_next_child_node(dev, child);
if (!child) {
dev_err(dev,
"missing child device node for entry %d\n",
i);
return -EINVAL;
}
}
error = gpio_keys_setup_key(pdev, input, ddata,
button, i, child);
if (error) {
fwnode_handle_put(child);
return error;
}
if (button->wakeup)
wakeup = 1;
}
fwnode_handle_put(child);
error = devm_device_add_group(dev, &gpio_keys_attr_group);
if (error) {
dev_err(dev, "Unable to export keys/switches, error: %d\n",
error);
return error;
}
error = input_register_device(input);
if (error) {
dev_err(dev, "Unable to register input device, error: %d\n",
error);
return error;
}
device_init_wakeup(dev, wakeup);
return 0;
}
