1 /* drivers/input/keyreset.c
3 * Copyright (C) 2014 Google, Inc.
5 * This software is licensed under the terms of the GNU General Public
6 * License version 2, as published by the Free Software Foundation, and
7 * may be copied, distributed, and modified under those terms.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
16 #include <linux/input.h>
17 #include <linux/keyreset.h>
18 #include <linux/module.h>
19 #include <linux/platform_device.h>
20 #include <linux/reboot.h>
21 #include <linux/sched.h>
22 #include <linux/slab.h>
23 #include <linux/syscalls.h>
24 #include <linux/keycombo.h>
26 struct keyreset_state {
27 int restart_requested;
28 int (*reset_fn)(void);
29 struct platform_device *pdev_child;
30 struct work_struct restart_work;
33 static void do_restart(struct work_struct *unused)
38 static void do_reset_fn(void *priv)
40 struct keyreset_state *state = priv;
41 if (state->restart_requested)
42 panic("keyboard reset failed, %d", state->restart_requested);
43 if (state->reset_fn) {
44 state->restart_requested = state->reset_fn();
46 pr_info("keyboard reset\n");
47 schedule_work(&state->restart_work);
48 state->restart_requested = 1;
52 static int keyreset_probe(struct platform_device *pdev)
55 struct keycombo_platform_data *pdata_child;
56 struct keyreset_platform_data *pdata = pdev->dev.platform_data;
57 int up_size = 0, down_size = 0, size;
59 struct keyreset_state *state;
63 state = devm_kzalloc(&pdev->dev, sizeof(*state), GFP_KERNEL);
67 state->pdev_child = platform_device_alloc(KEYCOMBO_NAME,
69 if (!state->pdev_child)
71 state->pdev_child->dev.parent = &pdev->dev;
72 INIT_WORK(&state->restart_work, do_restart);
74 keyp = pdata->keys_down;
75 while ((key = *keyp++)) {
81 keyp = pdata->keys_up;
82 while ((key = *keyp++)) {
88 size = sizeof(struct keycombo_platform_data)
89 + sizeof(int) * (down_size + 1);
90 pdata_child = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
93 memcpy(pdata_child->keys_down, pdata->keys_down,
94 sizeof(int) * down_size);
96 pdata_child->keys_up = devm_kzalloc(&pdev->dev, up_size + 1,
98 if (!pdata_child->keys_up)
100 memcpy(pdata_child->keys_up, pdata->keys_up,
101 sizeof(int) * up_size);
102 if (!pdata_child->keys_up)
105 state->reset_fn = pdata->reset_fn;
106 pdata_child->key_down_fn = do_reset_fn;
107 pdata_child->priv = state;
108 pdata_child->key_down_delay = pdata->key_down_delay;
109 ret = platform_device_add_data(state->pdev_child, pdata_child, size);
112 platform_set_drvdata(pdev, state);
113 return platform_device_add(state->pdev_child);
115 platform_device_put(state->pdev_child);
119 int keyreset_remove(struct platform_device *pdev)
121 struct keyreset_state *state = platform_get_drvdata(pdev);
122 platform_device_put(state->pdev_child);
127 struct platform_driver keyreset_driver = {
128 .driver.name = KEYRESET_NAME,
129 .probe = keyreset_probe,
130 .remove = keyreset_remove,
133 static int __init keyreset_init(void)
135 return platform_driver_register(&keyreset_driver);
138 static void __exit keyreset_exit(void)
140 return platform_driver_unregister(&keyreset_driver);
143 module_init(keyreset_init);
144 module_exit(keyreset_exit);