static int cpu_boost_init(void)
{
int cpu, ret;
struct cpu_sync *s;
cpufreq_register_notifier(&boost_adjust_nb, CPUFREQ_POLICY_NOTIFIER);
cpu_boost_wq = alloc_workqueue("cpuboost_wq", WQ_HIGHPRI, 0);
if (!cpu_boost_wq)
return -EFAULT;
INIT_WORK(&input_boost_work, do_input_boost);
for_each_possible_cpu(cpu) {
s = &per_cpu(sync_info, cpu);
s->cpu = cpu;
spin_lock_init(&s->lock);
INIT_DELAYED_WORK(&s->boost_rem, do_boost_rem);
INIT_DELAYED_WORK(&s->input_boost_rem, do_input_boost_rem);
}
atomic_notifier_chain_register(&migration_notifier_head,
&boost_migration_nb);
ret = smpboot_register_percpu_thread(&cpuboost_threads);
if (ret)
pr_err("Cannot register cpuboost threads.\n");
ret = input_register_handler(&cpuboost_input_handler);
if (ret)
pr_err("Cannot register cpuboost input handler.\n");
return ret;
}
static int cpu_boost_init(void)
{
int cpu, ret;
struct cpu_sync *s;
cpu_boost_wq = alloc_workqueue("cpuboost_wq", WQ_HIGHPRI, 0);
if (!cpu_boost_wq)
return -EFAULT;
INIT_WORK(&input_boost_work, do_input_boost);
for_each_possible_cpu(cpu) {
s = &per_cpu(sync_info, cpu);
s->cpu = cpu;
init_waitqueue_head(&s->sync_wq);
atomic_set(&s->being_woken, 0);
spin_lock_init(&s->lock);
INIT_DELAYED_WORK(&s->boost_rem, do_boost_rem);
INIT_DELAYED_WORK(&s->input_boost_rem, do_input_boost_rem);
s->thread = kthread_run(boost_mig_sync_thread, (void *)cpu,
"boost_sync/%d", cpu);
set_cpus_allowed(s->thread, *cpumask_of(cpu));
}
cpufreq_register_notifier(&boost_adjust_nb, CPUFREQ_POLICY_NOTIFIER);
atomic_notifier_chain_register(&migration_notifier_head,
&boost_migration_nb);
ret = input_register_handler(&cpuboost_input_handler);
return 0;
}
int __init intelli_plug_init(void)
{
int rc;
//pr_info("intelli_plug: scheduler delay is: %d\n", delay);
pr_info("intelli_plug: version %d.%d by faux123\n",
INTELLI_PLUG_MAJOR_VERSION,
INTELLI_PLUG_MINOR_VERSION);
rc = input_register_handler(&intelli_plug_input_handler);
#ifdef CONFIG_POWERSUSPEND
register_power_suspend(&intelli_plug_power_suspend_driver);
#endif
intelliplug_wq = alloc_workqueue("intelliplug",
WQ_HIGHPRI | WQ_UNBOUND, 1);
intelliplug_boost_wq = alloc_workqueue("iplug_boost",
WQ_HIGHPRI | WQ_UNBOUND, 1);
INIT_DELAYED_WORK(&intelli_plug_work, intelli_plug_work_fn);
INIT_DELAYED_WORK(&intelli_plug_boost, intelli_plug_boost_fn);
queue_delayed_work_on(0, intelliplug_wq, &intelli_plug_work,
msecs_to_jiffies(10));
return 0;
}
static int __devinit alsa_to_h2w_probe(struct platform_device *pdev)
{
struct alsa_to_h2w_data *switch_data;
int ret = 0;
switch_data = kzalloc(sizeof(struct alsa_to_h2w_data), GFP_KERNEL);
if (!switch_data)
return -ENOMEM;
headset_switch_data = switch_data;
switch_data->sdev.name = "h2w";
switch_data->sdev.print_name = headset_print_name;
switch_data->sdev.print_state = headset_print_state;
ret = switch_dev_register(&switch_data->sdev);
if (ret < 0)
goto err_switch_dev_register;
platform_set_drvdata(pdev, switch_data);
INIT_WORK(&switch_data->work, alsa_to_h2w_work);
if (input_register_handler(&alsa_to_h2w_handler))
pr_info("input_register_handler failed\n");
return 0;
err_switch_dev_register:
kfree(switch_data);
return ret;
}
int __init keybdev_init(void)
#endif
{
input_register_handler(&keybdev_handler);
kbd_ledfunc = keybdev_ledfunc;
return 0;
}
static int __init init(void)
{
if (input_register_handler(&boost_input_handler))
pr_info("Unable to register the input handler\n");
return 0;
}
static int cpu_boost_init(void)
{
int cpu, ret;
struct cpu_sync *s;
cpufreq_register_notifier(&boost_adjust_nb, CPUFREQ_POLICY_NOTIFIER);
cpu_boost_wq = alloc_workqueue("cpuboost_wq", WQ_HIGHPRI, 0);
if (!cpu_boost_wq)
return -EFAULT;
INIT_WORK(&input_boost_work, do_input_boost);
for_each_possible_cpu(cpu) {
s = &per_cpu(sync_info, cpu);
s->cpu = cpu;
init_waitqueue_head(&s->sync_wq);
spin_lock_init(&s->lock);
INIT_DELAYED_WORK(&s->boost_rem, do_boost_rem);
INIT_DELAYED_WORK(&s->input_boost_rem, do_input_boost_rem);
s->thread = kthread_run(boost_mig_sync_thread, (void *)cpu,
"boost_sync/%d", cpu);
#if defined(CONFIG_ARCH_MSM8974) || defined(CONFIG_ARCH_MSM8974PRO)
kthread_bind(s->thread, cpu);
#endif
}
atomic_notifier_chain_register(&migration_notifier_head,
&boost_migration_nb);
ret = input_register_handler(&cpuboost_input_handler);
return 0;
}
static int init(void)
{
INIT_WORK(&touchboost_inputopen.inputopen_work, boost_input_open);
input_register_handler(&boost_input_handler);
return 0;
}
static void __init touch_dvfs_handler_init(void)
{
int ret;
INIT_WORK(&kona_dvfs_data.dvfs_work, touch_dvfs_work);
ret = input_register_handler(&touch_dvfs_handler);
if (ret < 0)
pr_err("tsp: failed to register touch dvfs handler\n");
}
static int __init doubletap2wake_init(void)
{
int rc = 0;
doubletap2wake_pwrdev = input_allocate_device();
if (!doubletap2wake_pwrdev) {
pr_err("Can't allocate suspend autotest power button\n");
goto err_alloc_dev;
}
input_set_capability(doubletap2wake_pwrdev, EV_KEY, KEY_POWER);
doubletap2wake_pwrdev->name = "dt2w_pwrkey";
doubletap2wake_pwrdev->phys = "dt2w_pwrkey/input0";
rc = input_register_device(doubletap2wake_pwrdev);
if (rc) {
pr_err("%s: input_register_device err=%d\n", __func__, rc);
goto err_input_dev;
}
dt2w_input_wq = create_workqueue("dt2wiwq");
if (!dt2w_input_wq) {
pr_err("%s: Failed to create dt2wiwq workqueue\n", __func__);
return -EFAULT;
}
INIT_WORK(&dt2w_input_work, dt2w_input_callback);
rc = input_register_handler(&dt2w_input_handler);
if (rc)
pr_err("%s: Failed to register dt2w_input_handler\n", __func__);
#ifdef CONFIG_HAS_EARLYSUSPEND
register_early_suspend(&dt2w_early_suspend_handler);
#endif
#ifndef ANDROID_TOUCH_DECLARED
android_touch_kobj = kobject_create_and_add("android_touch", NULL) ;
if (android_touch_kobj == NULL) {
pr_warn("%s: android_touch_kobj create_and_add failed\n", __func__);
}
#endif
rc = sysfs_create_file(android_touch_kobj, &dev_attr_doubletap2wake.attr);
if (rc) {
pr_warn("%s: sysfs_create_file failed for doubletap2wake\n", __func__);
}
rc = sysfs_create_file(android_touch_kobj, &dev_attr_doubletap2wake_version.attr);
if (rc) {
pr_warn("%s: sysfs_create_file failed for doubletap2wake_version\n", __func__);
}
err_input_dev:
input_free_device(doubletap2wake_pwrdev);
err_alloc_dev:
pr_info(LOGTAG"%s done\n", __func__);
return 0;
}
static inline void sysrq_register_handler(void)
{
int error;
error = input_register_handler(&sysrq_handler);
if (error)
pr_err("Failed to register input handler, error %d", error);
else
sysrq_handler_registered = true;
}
static int __init cpu_iboost_init(void)
{
struct boost_policy *b;
int cpu, ret;
boost_wq = alloc_workqueue("cpu_iboost_wq", WQ_HIGHPRI, 0);
if (!boost_wq) {
pr_err("Failed to allocate workqueue\n");
ret = -EFAULT;
goto err;
}
cpufreq_register_notifier(&cpu_do_boost_nb, CPUFREQ_POLICY_NOTIFIER);
INIT_DELAYED_WORK(&fb_boost_work, fb_boost_fn);
fb_register_client(&fb_boost_nb);
for_each_possible_cpu(cpu) {
b = &per_cpu(boost_info, cpu);
b->cpu = cpu;
INIT_DELAYED_WORK(&b->ib_restore_work, ib_restore_main);
init_waitqueue_head(&b->sync_wq);
atomic_set(&b->being_woken, 0);
spin_lock_init(&b->lock);
INIT_DELAYED_WORK(&b->mig_boost_rem, do_mig_boost_rem);
b->thread = kthread_run(boost_mig_sync_thread, (void *)cpu,
"boost_sync/%d", cpu);
set_cpus_allowed(b->thread, *cpumask_of(cpu));
}
atomic_notifier_chain_register(&migration_notifier_head, &boost_migration_nb);
INIT_WORK(&boost_work, ib_boost_main);
ret = input_register_handler(&cpu_iboost_input_handler);
if (ret) {
pr_err("Failed to register input handler, err: %d\n", ret);
goto err;
}
cpu_iboost_kobject = kobject_create_and_add("cpu_input_boost", kernel_kobj);
if (!cpu_iboost_kobject) {
pr_err("Failed to create kobject\n");
goto err;
}
ret = sysfs_create_group(cpu_iboost_kobject, &cpu_iboost_attr_group);
if (ret) {
pr_err("Failed to create sysfs interface\n");
kobject_put(cpu_iboost_kobject);
}
err:
return ret;
}
static int __init boost_init(void)
{
int ret;
pm_qos_add_request(&touchboost_cpu_qos_min,
PM_QOS_CPUFREQ_MIN, PM_QOS_DEFAULT_VALUE);
pm_qos_add_request(&touchboost_ddr_qos_min,
PM_QOS_DDR_DEVFREQ_MIN, PM_QOS_DEFAULT_VALUE);
pm_qos_add_request(&touchboost_gpu3d_qos_min,
PM_QOS_GPUFREQ_3D_MIN, PM_QOS_DEFAULT_VALUE);
pm_qos_add_request(&touchboost_gpu2d_qos_min,
PM_QOS_GPUFREQ_2D_MIN, PM_QOS_DEFAULT_VALUE);
INIT_WORK(&touchboost_wk, touchboost_work);
#ifdef CONFIG_DEBUG_FS
debugfs_create_u32("touchbst_enable", 0644, NULL,
&touch_boost_enabled);
#endif
ret = input_register_handler(&touchboost_handler);
if (ret)
pr_err("touchboost_handler register failed");
return input_register_handler(&keyboost_handler);
}
static int __init thunderplug_init(void)
{
int ret = 0;
int sysfs_result;
printk(KERN_DEBUG "[%s]\n",__func__);
thunderplug_kobj = kobject_create_and_add("thunderplug", kernel_kobj);
if (!thunderplug_kobj) {
pr_err("%s Interface create failed!\n",
__FUNCTION__);
return -ENOMEM;
}
sysfs_result = sysfs_create_group(thunderplug_kobj, &thunderplug_attr_group);
if (sysfs_result) {
pr_info("%s sysfs create failed!\n", __FUNCTION__);
kobject_put(thunderplug_kobj);
}
lcd_worker.notifier_call = lcd_notifier_callback;
lcd_register_client(&lcd_worker);
pr_info("%s : registering input boost", THUNDERPLUG);
ret = input_register_handler(&tplug_input_handler);
if (ret) {
pr_err("%s: Failed to register input handler: %d\n",
THUNDERPLUG, ret);
}
tplug_wq = alloc_workqueue("tplug",
WQ_HIGHPRI | WQ_UNBOUND, 1);
tplug_resume_wq = alloc_workqueue("tplug_resume",
WQ_HIGHPRI | WQ_UNBOUND, 1);
tplug_boost_wq = alloc_workqueue("tplug_boost",
WQ_HIGHPRI | WQ_UNBOUND, 1);
INIT_DELAYED_WORK(&tplug_work, tplug_work_fn);
INIT_DELAYED_WORK(&tplug_resume_work, tplug_resume_work_fn);
INIT_DELAYED_WORK(&tplug_boost, tplug_boost_work_fn);
queue_delayed_work_on(0, tplug_wq, &tplug_work,
msecs_to_jiffies(10));
pr_info("%s: init\n", THUNDERPLUG);
return ret;
}
int __init intelli_plug_init(void)
{
int rc;
#if defined (CONFIG_POWERSUSPEND) || defined(CONFIG_HAS_EARLYSUSPEND)
int cpu;
struct cpufreq_policy *policy;
struct ip_cpu_info *l_ip_info;
#endif
nr_possible_cores = num_possible_cpus();
pr_info("intelli_plug: version %d.%d by faux123\n",
INTELLI_PLUG_MAJOR_VERSION,
INTELLI_PLUG_MINOR_VERSION);
if (nr_possible_cores > 2) {
nr_run_hysteresis = NR_RUN_HYSTERESIS_QUAD;
nr_run_profile_sel = 0;
} else {
nr_run_hysteresis = NR_RUN_HYSTERESIS_DUAL;
nr_run_profile_sel = NR_RUN_ECO_MODE_PROFILE;
}
#if defined (CONFIG_POWERSUSPEND) || defined(CONFIG_HAS_EARLYSUSPEND)
for_each_online_cpu(cpu) {
l_ip_info = &per_cpu(ip_info, cpu);
policy = cpufreq_cpu_get(cpu);
l_ip_info->sys_max = policy->cpuinfo.max_freq;
l_ip_info->cur_max = policy->max;
}
#endif
rc = input_register_handler(&intelli_plug_input_handler);
#ifdef CONFIG_POWERSUSPEND
register_power_suspend(&intelli_plug_power_suspend_driver);
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
register_early_suspend(&intelli_plug_early_suspend_driver);
#endif
intelliplug_wq = alloc_workqueue("intelliplug",
WQ_HIGHPRI | WQ_UNBOUND, 1);
intelliplug_boost_wq = alloc_workqueue("iplug_boost",
WQ_HIGHPRI | WQ_UNBOUND, 1);
INIT_DELAYED_WORK(&intelli_plug_work, intelli_plug_work_fn);
INIT_DELAYED_WORK(&intelli_plug_boost, intelli_plug_boost_fn);
queue_delayed_work_on(0, intelliplug_wq, &intelli_plug_work,
msecs_to_jiffies(10));
return 0;
}
static void kgdboc_restore_input_helper(struct work_struct *dummy)
{
/*
*/
mutex_lock(&kgdboc_reset_mutex);
if (input_register_handler(&kgdboc_reset_handler) == 0)
input_unregister_handler(&kgdboc_reset_handler);
mutex_unlock(&kgdboc_reset_mutex);
}
static void kgdboc_restore_input_helper(struct work_struct *dummy)
{
/*
* We need to take a mutex to prevent several instances of
* this work running on different CPUs so they don't try
* to register again already registered handler.
*/
mutex_lock(&kgdboc_reset_mutex);
if (input_register_handler(&kgdboc_reset_handler) == 0)
input_unregister_handler(&kgdboc_reset_handler);
mutex_unlock(&kgdboc_reset_mutex);
}
static int __init keybdev_init(void)
{
input_register_handler(&keybdev_handler);
kbd_ledfunc = keybdev_ledfunc;
if (jp_kbd_109) {
x86_keycodes[0xb5] = 0x73; /* backslash, underscore */
x86_keycodes[0xb6] = 0x70;
x86_keycodes[0xb7] = 0x7d; /* Yen, pipe */
x86_keycodes[0xb8] = 0x79;
x86_keycodes[0xb9] = 0x7b;
}
return 0;
}
static int mac_hid_start_emulation(void)
{
int err;
err = mac_hid_create_emumouse();
if (err)
return err;
err = input_register_handler(&mac_hid_emumouse_handler);
if (err) {
mac_hid_destroy_emumouse();
return err;
}
return 0;
}
static int init(void)
{
input_boost_wq = alloc_workqueue("input_boost_wq", WQ_FREEZABLE | WQ_HIGHPRI, 1);
if (!input_boost_wq)
return -EFAULT;
INIT_WORK(&input_boost_work, do_input_boost);
INIT_DELAYED_WORK(&rem_input_boost, do_rem_input_boost);
INIT_WORK(&touchboost_inputopen.inputopen_work, boost_input_open);
input_register_handler(&boost_input_handler);
cpufreq_register_notifier(&boost_adjust_nb, CPUFREQ_POLICY_NOTIFIER);
return 0;
}
static int touch_boost_init(void)
{
int ret;
touch_boost_wq = alloc_workqueue("touch_boost_wq", WQ_HIGHPRI, 0);
if (!touch_boost_wq)
return -EFAULT;
INIT_WORK(&input_boost_work, do_input_boost);
INIT_DELAYED_WORK(&input_boost_rem, do_input_boost_rem);
ret = input_register_handler(&touchboost_input_handler);
if (ret)
pr_err("Cannot register touchboost input handler.\n");
return ret;
}
static int __init cfboost_init(void)
{
int ret;
cfb_wq = create_workqueue("icfb-wq");
if (!cfb_wq)
return -ENOMEM;
INIT_WORK(&boost, cfb_boost);
INIT_DELAYED_WORK(&unboost, cfb_unboost);
ret = input_register_handler(&cfb_input_handler);
if (ret) {
destroy_workqueue(cfb_wq);
return ret;
}
pm_qos_add_request(&qos_req, PM_QOS_CPU_FREQ_MIN,
PM_QOS_DEFAULT_VALUE);
return 0;
}
static int init(void)
{
int ret;
input_boost_wq = alloc_workqueue("input_boost_wq", WQ_FREEZABLE | WQ_HIGHPRI, 1);
if (!input_boost_wq)
return -EFAULT;
INIT_WORK(&input_boost_work, do_input_boost);
INIT_DELAYED_WORK(&rem_input_boost, do_rem_input_boost);
ret = input_register_handler(&boost_input_handler);
if (ret) {
pr_err("Failed to register input handler, error: %d", ret);
return ret;
}
cpufreq_register_notifier(&boost_adjust_nb, CPUFREQ_POLICY_NOTIFIER);
return 0;
}
int __init intelli_plug_init(void)
{
int rc;
//pr_info("intelli_plug: scheduler delay is: %d\n", delay);
pr_info("intelli_plug: version %d.%d by faux123\n",
INTELLI_PLUG_MAJOR_VERSION,
INTELLI_PLUG_MINOR_VERSION);
sampling_time = DEF_SAMPLING_MS;
rc = input_register_handler(&intelli_plug_input_handler);
INIT_DELAYED_WORK(&intelli_plug_work, intelli_plug_work_fn);
schedule_delayed_work_on(0, &intelli_plug_work,
msecs_to_jiffies(sampling_time));
#ifdef CONFIG_HAS_EARLYSUSPEND
register_early_suspend(&intelli_plug_early_suspend_struct_driver);
#endif
return 0;
}
static int cpu_boost_init(void)
{
int cpu, ret;
struct cpu_sync *s;
cpu_boost_wq = alloc_workqueue("cpuboost_wq", WQ_HIGHPRI, 0);
if (!cpu_boost_wq)
return -EFAULT;
INIT_WORK(&input_boost_work, do_input_boost);
INIT_DELAYED_WORK(&input_boost_rem, do_input_boost_rem);
for_each_possible_cpu(cpu) {
s = &per_cpu(sync_info, cpu);
s->cpu = cpu;
}
cpufreq_register_notifier(&boost_adjust_nb, CPUFREQ_POLICY_NOTIFIER);
ret = input_register_handler(&cpuboost_input_handler);
return ret;
}
int __init sleepy_plug_init(void)
{
int rc;
pr_info("sleepy_plug: version %d.%d by rmbq\n",
SLEEPY_PLUG_MAJOR_VERSION,
SLEEPY_PLUG_MINOR_VERSION);
rc = input_register_handler(&sleepy_plug_input_handler);
sleepy_plug_wq = alloc_workqueue("sleepyplug",
WQ_HIGHPRI | WQ_UNBOUND, 1);
#ifdef CONFIG_POWERSUSPEND
register_power_suspend(&sleepy_plug_power_suspend_driver);
#endif
INIT_DELAYED_WORK(&sleepy_plug_work, sleepy_plug_work_fn);
queue_delayed_work_on(0, sleepy_plug_wq, &sleepy_plug_work,
msecs_to_jiffies(10));
return 0;
}
int __init rfkill_handler_init(void)
{
switch (rfkill_master_switch_mode) {
case RFKILL_INPUT_MASTER_UNBLOCKALL:
rfkill_master_switch_op = RFKILL_GLOBAL_OP_UNBLOCK;
break;
case RFKILL_INPUT_MASTER_RESTORE:
rfkill_master_switch_op = RFKILL_GLOBAL_OP_RESTORE;
break;
case RFKILL_INPUT_MASTER_UNLOCK:
rfkill_master_switch_op = RFKILL_GLOBAL_OP_UNLOCK;
break;
default:
return -EINVAL;
}
spin_lock_init(&rfkill_op_lock);
/* Avoid delay at first schedule */
rfkill_last_scheduled =
jiffies - msecs_to_jiffies(RFKILL_OPS_DELAY) - 1;
return input_register_handler(&rfkill_handler);
}
int __init intelli_plug_init(void)
{
int rc;
nr_possible_cores = num_possible_cpus();
pr_info("intelli_plug: version %d.%d by faux123\n",
INTELLI_PLUG_MAJOR_VERSION,
INTELLI_PLUG_MINOR_VERSION);
if (nr_possible_cores > 2) {
nr_run_hysteresis = NR_RUN_HYSTERESIS_QUAD;
nr_run_profile_sel = 0;
} else {
nr_run_hysteresis = NR_RUN_HYSTERESIS_DUAL;
nr_run_profile_sel = NR_RUN_ECO_MODE_PROFILE;
}
rc = input_register_handler(&intelli_plug_input_handler);
#ifdef CONFIG_POWERSUSPEND
register_power_suspend(&intelli_plug_power_suspend_driver);
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
register_early_suspend(&intelli_plug_early_suspend_driver);
#endif
intelliplug_wq = alloc_workqueue("intelliplug",
WQ_HIGHPRI | WQ_UNBOUND, 1);
intelliplug_boost_wq = alloc_workqueue("iplug_boost",
WQ_HIGHPRI | WQ_UNBOUND, 1);
INIT_DELAYED_WORK(&intelli_plug_work, intelli_plug_work_fn);
INIT_DELAYED_WORK(&intelli_plug_boost, intelli_plug_boost_fn);
queue_delayed_work_on(0, intelliplug_wq, &intelli_plug_work,
msecs_to_jiffies(10));
return 0;
}
static int __init sweep2wake_init(void)
{
int rc = 0;
printk(KERN_INFO "sweep2sleep: %s version %s\n", DRIVER_DESCRIPTION,
DRIVER_VERSION);
printk(KERN_INFO "sweep2sleep: by %s\n", DRIVER_AUTHOR);
sweep2wake_pwrdev = input_allocate_device();
input_set_capability(sweep2wake_pwrdev, EV_KEY, KEY_POWER);
sweep2wake_pwrdev->name = "s2s_pwrkey";
sweep2wake_pwrdev->phys = "s2s_pwrkey/input0";
rc = input_register_device(sweep2wake_pwrdev);
s2s_input_wq = create_workqueue("s2siwq");
INIT_WORK(&s2s_input_work, s2s_input_callback);
rc = input_register_handler(&s2s_input_handler);
return 0;
}
static int __init apmpower_init(void)
{
return input_register_handler(&apmpower_handler);
}
