split out flags
[ms2-fixes] / debounce.c
1 #include <linux/module.h>
2 #include <linux/device.h>
3 #include <linux/platform_device.h>
4 #include <linux/gpio_event.h>
5
6 #define PREFIX "debounce: "
7
8 static int debounce_delay = 15;
9
10 static unsigned old_flags = 0;
11 ktime_t old_debounce_delay;
12 ktime_t old_settle_time;
13 ktime_t old_poll_time;
14 static struct gpio_event_matrix_info *gpio_evmi = NULL;
15
16 module_param(debounce_delay, int, S_IRUSR | S_IRGRP | S_IROTH);
17 MODULE_PARM_DESC(debounce_delay, "debouncing delay (ms), default: 15");
18
19 static int find_ms2_dev(struct device *dev, void *data)
20 {
21 if (!strncmp((char*)data, dev_name(dev), strlen((char*)data))) {
22 printk(KERN_INFO PREFIX "Found it\n");
23 return 1;
24 }
25 return 0;
26 }
27
28 static ssize_t show_debounce_delay(struct device *dev, struct device_attribute *attr, char *buf)
29 {
30 if (!gpio_evmi)
31 return -ENODEV;
32
33 return snprintf(buf, PAGE_SIZE, "%ld\n", (gpio_evmi->debounce_delay.tv.nsec / NSEC_PER_MSEC));
34 }
35
36 static void set_debounce_delay(long delay)
37 {
38 if (gpio_evmi->debounce_delay.tv.nsec != delay * NSEC_PER_MSEC) {
39 printk(KERN_INFO PREFIX "Changing debounce_delay\n");
40 gpio_evmi->debounce_delay.tv.nsec = delay * NSEC_PER_MSEC;
41 debounce_delay = delay;
42 printk(KERN_INFO PREFIX "debounce_delay: %u\n", gpio_evmi->debounce_delay.tv.nsec);
43 }
44
45 #if 0
46 if (gpio_evmi->debounce_delay.tv.nsec != 0) {
47 if (!(gpio_evmi->flags & GPIOKPF_DEBOUNCE)) {
48 printk(KERN_INFO PREFIX "Activating debounce\n");
49 gpio_evmi->flags |= GPIOKPF_DEBOUNCE;
50 }
51 } else {
52 if (gpio_evmi->flags & GPIOKPF_DEBOUNCE) {
53 printk(KERN_INFO PREFIX "Deactivating debounce\n");
54 gpio_evmi->flags &= ~GPIOKPF_DEBOUNCE;
55 }
56 }
57 #endif
58 }
59
60 static ssize_t store_debounce_delay(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
61 {
62 long int delay;
63
64 if (!gpio_evmi)
65 return -ENODEV;
66
67 sscanf(buf, "%ld", &delay);
68 set_debounce_delay(delay);
69
70 return count;
71 }
72
73 static ssize_t show_settle_time(struct device *dev, struct device_attribute *attr, char *buf)
74 {
75 if (!gpio_evmi)
76 return -ENODEV;
77
78 return snprintf(buf, PAGE_SIZE, "%ld\n", (gpio_evmi->settle_time.tv.nsec / NSEC_PER_USEC));
79 }
80
81 static ssize_t store_settle_time(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
82 {
83 long int delay;
84
85 if (!gpio_evmi)
86 return -ENODEV;
87
88 sscanf(buf, "%ld", &delay);
89 gpio_evmi->settle_time.tv.nsec = delay * NSEC_PER_USEC;
90
91 return count;
92 }
93
94 static ssize_t show_poll_time(struct device *dev, struct device_attribute *attr, char *buf)
95 {
96 if (!gpio_evmi)
97 return -ENODEV;
98
99 return snprintf(buf, PAGE_SIZE, "%ld\n", (gpio_evmi->poll_time.tv.nsec / NSEC_PER_MSEC));
100 }
101
102 static ssize_t store_poll_time(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
103 {
104 long int delay;
105
106 if (!gpio_evmi)
107 return -ENODEV;
108
109 sscanf(buf, "%ld", &delay);
110 gpio_evmi->poll_time.tv.nsec = delay * NSEC_PER_MSEC;
111
112 return count;
113 }
114
115 static ssize_t show_flags(struct device *dev, struct device_attribute *attr, char *buf)
116 {
117 if (!gpio_evmi)
118 return -ENODEV;
119
120 return snprintf(buf, PAGE_SIZE, "0x%x\n", gpio_evmi->flags);
121 }
122
123 static ssize_t store_flags(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
124 {
125 unsigned flags;
126
127 if (!gpio_evmi)
128 return -ENODEV;
129
130 sscanf(buf, "0x%x", &flags);
131
132 printk(KERN_INFO PREFIX "flags: 0x%x\n", flags);
133
134 if (flags & GPIOKPF_DRIVE_INACTIVE)
135 return count;
136
137 gpio_evmi->flags = flags;
138
139 return count;
140 }
141
142 static ssize_t show_debounce_flag(struct device *dev, struct device_attribute *attr, char *buf)
143 {
144 if (!gpio_evmi)
145 return -ENODEV;
146
147 return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_DEBOUNCE) ? 1 : 0);
148 }
149
150 static ssize_t store_debounce_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
151 {
152 unsigned flag;
153
154 if (!gpio_evmi)
155 return -ENODEV;
156
157 sscanf(buf, "%u", &flag);
158
159 if (flag) {
160 gpio_evmi->flags |= GPIOKPF_DEBOUNCE;
161 } else {
162 gpio_evmi->flags &= ~GPIOKPF_DEBOUNCE;
163 }
164
165 return count;
166 }
167
168 static ssize_t show_remove_some_phantom_keys_flag(struct device *dev, struct device_attribute *attr, char *buf)
169 {
170 if (!gpio_evmi)
171 return -ENODEV;
172
173 return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_REMOVE_SOME_PHANTOM_KEYS) ? 1 : 0);
174 }
175
176 static ssize_t store_remove_some_phantom_keys_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
177 {
178 unsigned flag;
179
180 if (!gpio_evmi)
181 return -ENODEV;
182
183 sscanf(buf, "%u", &flag);
184
185 if (flag) {
186 gpio_evmi->flags |= GPIOKPF_REMOVE_SOME_PHANTOM_KEYS;
187 } else {
188 gpio_evmi->flags &= ~GPIOKPF_REMOVE_SOME_PHANTOM_KEYS;
189 }
190
191 return count;
192 }
193
194 static ssize_t show_print_unmapped_keys_flag(struct device *dev, struct device_attribute *attr, char *buf)
195 {
196 if (!gpio_evmi)
197 return -ENODEV;
198
199 return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_PRINT_UNMAPPED_KEYS) ? 1 : 0);
200 }
201
202 static ssize_t store_print_unmapped_keys_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
203 {
204 unsigned flag;
205
206 if (!gpio_evmi)
207 return -ENODEV;
208
209 sscanf(buf, "%u", &flag);
210
211 if (flag) {
212 gpio_evmi->flags |= GPIOKPF_PRINT_UNMAPPED_KEYS;
213 } else {
214 gpio_evmi->flags &= ~GPIOKPF_PRINT_UNMAPPED_KEYS;
215 }
216
217 return count;
218 }
219
220 static ssize_t show_print_mapped_keys_flag(struct device *dev, struct device_attribute *attr, char *buf)
221 {
222 if (!gpio_evmi)
223 return -ENODEV;
224
225 return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_PRINT_MAPPED_KEYS) ? 1 : 0);
226 }
227
228 static ssize_t store_print_mapped_keys_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
229 {
230 unsigned flag;
231
232 if (!gpio_evmi)
233 return -ENODEV;
234
235 sscanf(buf, "%u", &flag);
236
237 if (flag) {
238 gpio_evmi->flags |= GPIOKPF_PRINT_MAPPED_KEYS;
239 } else {
240 gpio_evmi->flags &= ~GPIOKPF_PRINT_MAPPED_KEYS;
241 }
242
243 return count;
244 }
245
246 static ssize_t show_print_phantom_keys_flag(struct device *dev, struct device_attribute *attr, char *buf)
247 {
248 if (!gpio_evmi)
249 return -ENODEV;
250
251 return snprintf(buf, PAGE_SIZE, "%u\n", (gpio_evmi->flags & GPIOKPF_PRINT_PHANTOM_KEYS) ? 1 : 0);
252 }
253
254 static ssize_t store_print_phantom_keys_flag(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
255 {
256 unsigned flag;
257
258 if (!gpio_evmi)
259 return -ENODEV;
260
261 sscanf(buf, "%u", &flag);
262
263 if (flag) {
264 gpio_evmi->flags |= GPIOKPF_PRINT_PHANTOM_KEYS;
265 } else {
266 gpio_evmi->flags &= ~GPIOKPF_PRINT_PHANTOM_KEYS;
267 }
268
269 return count;
270 }
271
272 static DEVICE_ATTR(debounce_delay, (S_IRUGO | S_IWUGO), show_debounce_delay, store_debounce_delay);
273 static DEVICE_ATTR(settle_time, (S_IRUGO | S_IWUGO), show_settle_time, store_settle_time);
274 static DEVICE_ATTR(poll_time, (S_IRUGO | S_IWUGO), show_poll_time, store_poll_time);
275 static DEVICE_ATTR(flags, (S_IRUGO), show_flags, store_flags);
276 static DEVICE_ATTR(debounce_flag, (S_IRUGO | S_IWUGO), show_debounce_flag, store_debounce_flag);
277 static DEVICE_ATTR(remove_some_phantom_keys_flag, (S_IRUGO | S_IWUGO), show_remove_some_phantom_keys_flag, store_remove_some_phantom_keys_flag);
278 static DEVICE_ATTR(print_unmapped_keys_flag, (S_IRUGO | S_IWUGO), show_print_unmapped_keys_flag, store_print_unmapped_keys_flag);
279 static DEVICE_ATTR(print_mapped_keys_flag, (S_IRUGO | S_IWUGO), show_print_mapped_keys_flag, store_print_mapped_keys_flag);
280 static DEVICE_ATTR(print_phantom_keys_flag, (S_IRUGO | S_IWUGO), show_print_phantom_keys_flag, store_print_phantom_keys_flag);
281
282 static void debounce_release(struct device *dev)
283 {
284 }
285
286 static struct device debounce_device = {
287 .init_name = "debounce",
288 .release = debounce_release,
289 };
290
291 static int __init debounce_init(void)
292 {
293 struct device *event_dev = NULL;
294 struct gpio_event_platform_data *gpio_epd;
295 struct gpio_event_info *gpio_ei;
296 int err = 0;
297
298 printk(KERN_INFO PREFIX "Searching for " GPIO_EVENT_DEV_NAME "...\n");
299
300 event_dev = device_find_child(&platform_bus, GPIO_EVENT_DEV_NAME, find_ms2_dev);
301 if (event_dev == NULL)
302 return -ENODEV;
303
304 gpio_epd = (struct gpio_event_platform_data*)event_dev->platform_data;
305 printk(KERN_INFO PREFIX "And there is a %s connected...\n", gpio_epd->name);
306 if (strcmp(gpio_epd->name, "sholes-keypad"))
307 return -ENODEV;
308
309 gpio_ei = (struct gpio_event_info*)gpio_epd->info[0];
310 gpio_evmi = container_of(gpio_ei, struct gpio_event_matrix_info, info);
311
312 err = device_register(&debounce_device);
313 if (err) {
314 return err;
315 }
316
317 err = device_create_file(&debounce_device, &dev_attr_debounce_delay);
318 err = device_create_file(&debounce_device, &dev_attr_settle_time);
319 err = device_create_file(&debounce_device, &dev_attr_poll_time);
320 err = device_create_file(&debounce_device, &dev_attr_flags);
321 err = device_create_file(&debounce_device, &dev_attr_debounce_flag);
322 err = device_create_file(&debounce_device, &dev_attr_remove_some_phantom_keys_flag);
323 err = device_create_file(&debounce_device, &dev_attr_print_unmapped_keys_flag);
324 err = device_create_file(&debounce_device, &dev_attr_print_mapped_keys_flag);
325 err = device_create_file(&debounce_device, &dev_attr_print_phantom_keys_flag);
326
327 printk(KERN_INFO PREFIX "settle_time: %u\n", gpio_evmi->settle_time.tv.nsec);
328 printk(KERN_INFO PREFIX "poll_time: %u\n", gpio_evmi->poll_time.tv.nsec);
329 printk(KERN_INFO PREFIX "debounce_delay: %u\n", gpio_evmi->debounce_delay.tv.nsec);
330 printk(KERN_INFO PREFIX "flags: 0x%x\n", gpio_evmi->flags);
331
332 old_debounce_delay = gpio_evmi->debounce_delay;
333 old_settle_time = gpio_evmi->settle_time;
334 old_poll_time = gpio_evmi->poll_time;
335 old_flags = gpio_evmi->flags;
336
337 set_debounce_delay(debounce_delay);
338
339 printk(KERN_INFO PREFIX "flags: 0x%x\n", gpio_evmi->flags);
340
341 return 0;
342 }
343
344 static void __exit debounce_exit(void)
345 {
346 if (gpio_evmi) {
347 if (gpio_evmi->debounce_delay.tv.nsec != old_debounce_delay.tv.nsec) {
348 printk(KERN_INFO PREFIX "Restoring debounce_delay\n");
349 gpio_evmi->debounce_delay = old_debounce_delay;
350 printk(KERN_INFO PREFIX "debounce_delay: %u\n", gpio_evmi->debounce_delay.tv.nsec);
351 }
352 if (gpio_evmi->flags != old_flags) {
353 printk(KERN_INFO PREFIX "Restoring flags\n");
354 gpio_evmi->flags = old_flags;
355 printk(KERN_INFO PREFIX "flags: 0x%x\n", gpio_evmi->flags);
356 }
357 gpio_evmi->settle_time = old_settle_time;
358 gpio_evmi->poll_time = old_poll_time;
359 }
360 device_remove_file(&debounce_device, &dev_attr_debounce_delay);
361 device_remove_file(&debounce_device, &dev_attr_settle_time);
362 device_remove_file(&debounce_device, &dev_attr_poll_time);
363 device_remove_file(&debounce_device, &dev_attr_flags);
364 device_remove_file(&debounce_device, &dev_attr_debounce_flag);
365 device_remove_file(&debounce_device, &dev_attr_remove_some_phantom_keys_flag);
366 device_remove_file(&debounce_device, &dev_attr_print_unmapped_keys_flag);
367 device_remove_file(&debounce_device, &dev_attr_print_mapped_keys_flag);
368 device_remove_file(&debounce_device, &dev_attr_print_phantom_keys_flag);
369 device_unregister(&debounce_device);
370 }
371
372 module_init(debounce_init);
373 module_exit(debounce_exit);
374
375 MODULE_LICENSE("GPL");
376 MODULE_AUTHOR("Michael Gernoth <michael@gernoth.net>");
Impressum, Datenschutz