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;
32 static void do_restart(void)
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");
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;
73 keyp = pdata->keys_down;
74 while ((key = *keyp++)) {
80 keyp = pdata->keys_up;
81 while ((key = *keyp++)) {
87 size = sizeof(struct keycombo_platform_data)
88 + sizeof(int) * (down_size + 1);
89 pdata_child = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
92 memcpy(pdata_child->keys_down, pdata->keys_down,
93 sizeof(int) * down_size);
95 pdata_child->keys_up = devm_kzalloc(&pdev->dev, up_size + 1,
97 if (!pdata_child->keys_up)
99 memcpy(pdata_child->keys_up, pdata->keys_up,
100 sizeof(int) * up_size);
101 if (!pdata_child->keys_up)
104 state->reset_fn = pdata->reset_fn;
105 pdata_child->key_down_fn = do_reset_fn;
106 pdata_child->priv = state;
107 pdata_child->key_down_delay = pdata->key_down_delay;
108 ret = platform_device_add_data(state->pdev_child, pdata_child, size);
111 platform_set_drvdata(pdev, state);
112 return platform_device_add(state->pdev_child);
114 platform_device_put(state->pdev_child);
118 int keyreset_remove(struct platform_device *pdev)
120 struct keyreset_state *state = platform_get_drvdata(pdev);
121 platform_device_put(state->pdev_child);
126 struct platform_driver keyreset_driver = {
127 .driver.name = KEYRESET_NAME,
128 .probe = keyreset_probe,
129 .remove = keyreset_remove,
132 static int __init keyreset_init(void)
134 return platform_driver_register(&keyreset_driver);
137 static void __exit keyreset_exit(void)
139 return platform_driver_unregister(&keyreset_driver);
142 module_init(keyreset_init);
143 module_exit(keyreset_exit);