chiark / gitweb /
net-match: fix Driver= match
[elogind.git] / src / udev / accelerometer / accelerometer.c
1 /*
2  * accelerometer - exports device orientation through property
3  *
4  * When an "change" event is received on an accelerometer,
5  * open its device node, and from the value, as well as the previous
6  * value of the property, calculate the device's new orientation,
7  * and export it as ID_INPUT_ACCELEROMETER_ORIENTATION.
8  *
9  * Possible values are:
10  * undefined
11  * * normal
12  * * bottom-up
13  * * left-up
14  * * right-up
15  *
16  * The property will be persistent across sessions, and the new
17  * orientations can be deducted from the previous one (it allows
18  * for a threshold for switching between opposite ends of the
19  * orientation).
20  *
21  * Copyright (C) 2011 Red Hat, Inc.
22  * Author:
23  *   Bastien Nocera <hadess@hadess.net>
24  *
25  * orientation_calc() from the sensorfw package
26  * Copyright (C) 2009-2010 Nokia Corporation
27  * Authors:
28  *   Üstün Ergenoglu <ext-ustun.ergenoglu@nokia.com>
29  *   Timo Rongas <ext-timo.2.rongas@nokia.com>
30  *   Lihan Guo <lihan.guo@digia.com>
31  *
32  * This program is free software; you can redistribute it and/or modify
33  * it under the terms of the GNU General Public License as published by
34  * the Free Software Foundation; either version 2 of the License, or
35  * (at your option) any later version.
36  *
37  * This program is distributed in the hope that it will be useful,
38  * but WITHOUT ANY WARRANTY; without even the implied warranty of
39  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
40  * GNU General Public License for more details.
41  *
42  * You should have received a copy of the GNU General Public License along
43  * with this program; if not, write to the Free Software Foundation, Inc.,
44  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
45  */
46
47 #include <stdio.h>
48 #include <string.h>
49 #include <stdbool.h>
50 #include <math.h>
51 #include <sys/types.h>
52 #include <sys/stat.h>
53 #include <fcntl.h>
54 #include <stdlib.h>
55 #include <unistd.h>
56 #include <getopt.h>
57 #include <limits.h>
58 #include <linux/limits.h>
59 #include <linux/input.h>
60
61 #include "libudev.h"
62 #include "libudev-private.h"
63
64 /* we must use this kernel-compatible implementation */
65 #define BITS_PER_LONG (sizeof(unsigned long) * 8)
66 #define NBITS(x) ((((x)-1)/BITS_PER_LONG)+1)
67 #define OFF(x)  ((x)%BITS_PER_LONG)
68 #define BIT(x)  (1UL<<OFF(x))
69 #define LONG(x) ((x)/BITS_PER_LONG)
70 #define test_bit(bit, array)    ((array[LONG(bit)] >> OFF(bit)) & 1)
71
72 static int debug = 0;
73
74 _printf_(6,0)
75 static void log_fn(struct udev *udev, int priority,
76                    const char *file, int line, const char *fn,
77                    const char *format, va_list args)
78 {
79         if (debug) {
80                 fprintf(stderr, "%s: ", fn);
81                 vfprintf(stderr, format, args);
82         } else {
83                 vsyslog(priority, format, args);
84         }
85 }
86
87 typedef enum {
88         ORIENTATION_UNDEFINED,
89         ORIENTATION_NORMAL,
90         ORIENTATION_BOTTOM_UP,
91         ORIENTATION_LEFT_UP,
92         ORIENTATION_RIGHT_UP
93 } OrientationUp;
94
95 static const char *orientations[] = {
96         "undefined",
97         "normal",
98         "bottom-up",
99         "left-up",
100         "right-up",
101         NULL
102 };
103
104 #define ORIENTATION_UP_UP ORIENTATION_NORMAL
105
106 #define DEFAULT_THRESHOLD 250
107 #define RADIANS_TO_DEGREES 180.0/M_PI
108 #define SAME_AXIS_LIMIT 5
109
110 #define THRESHOLD_LANDSCAPE  25
111 #define THRESHOLD_PORTRAIT  20
112
113 static const char *
114 orientation_to_string (OrientationUp o)
115 {
116         return orientations[o];
117 }
118
119 static OrientationUp
120 string_to_orientation (const char *orientation)
121 {
122         int i;
123
124         if (orientation == NULL)
125                 return ORIENTATION_UNDEFINED;
126         for (i = 0; orientations[i] != NULL; i++) {
127                 if (streq (orientation, orientations[i]))
128                         return i;
129         }
130         return ORIENTATION_UNDEFINED;
131 }
132
133 static OrientationUp
134 orientation_calc (OrientationUp prev,
135                   int x, int y, int z)
136 {
137         int rotation;
138         OrientationUp ret = prev;
139
140         /* Portrait check */
141         rotation = round(atan((double) x / sqrt(y * y + z * z)) * RADIANS_TO_DEGREES);
142
143         if (abs(rotation) > THRESHOLD_PORTRAIT) {
144                 ret = (rotation < 0) ? ORIENTATION_LEFT_UP : ORIENTATION_RIGHT_UP;
145
146                 /* Some threshold to switching between portrait modes */
147                 if (prev == ORIENTATION_LEFT_UP || prev == ORIENTATION_RIGHT_UP) {
148                         if (abs(rotation) < SAME_AXIS_LIMIT) {
149                                 ret = prev;
150                         }
151                 }
152
153         } else {
154                 /* Landscape check */
155                 rotation = round(atan((double) y / sqrt(x * x + z * z)) * RADIANS_TO_DEGREES);
156
157                 if (abs(rotation) > THRESHOLD_LANDSCAPE) {
158                         ret = (rotation < 0) ? ORIENTATION_BOTTOM_UP : ORIENTATION_NORMAL;
159
160                         /* Some threshold to switching between landscape modes */
161                         if (prev == ORIENTATION_BOTTOM_UP || prev == ORIENTATION_NORMAL) {
162                                 if (abs(rotation) < SAME_AXIS_LIMIT) {
163                                         ret = prev;
164                                 }
165                         }
166                 }
167         }
168
169         return ret;
170 }
171
172 static OrientationUp
173 get_prev_orientation(struct udev_device *dev)
174 {
175         const char *value;
176
177         value = udev_device_get_property_value(dev, "ID_INPUT_ACCELEROMETER_ORIENTATION");
178         if (value == NULL)
179                 return ORIENTATION_UNDEFINED;
180         return string_to_orientation(value);
181 }
182
183 #define SET_AXIS(axis, code_) if (ev[i].code == code_) { if (got_##axis == 0) { axis = ev[i].value; got_##axis = true; } }
184
185 /* accelerometers */
186 static void test_orientation(struct udev *udev,
187                              struct udev_device *dev,
188                              const char *devpath)
189 {
190         OrientationUp old, new;
191         _cleanup_close_ int fd = -1;
192         struct input_event ev[64];
193         bool got_syn = false;
194         bool got_x = false, got_y = false, got_z = false;
195         int x = 0, y = 0, z = 0;
196         char text[64];
197
198         old = get_prev_orientation(dev);
199
200         fd = open(devpath, O_RDONLY|O_CLOEXEC);
201         if (fd < 0)
202                 return;
203
204         while (1) {
205                 int i, r;
206
207                 r = read(fd, ev, sizeof(struct input_event) * 64);
208
209                 if (r < (int) sizeof(struct input_event))
210                         return;
211
212                 for (i = 0; i < r / (int) sizeof(struct input_event); i++) {
213                         if (got_syn) {
214                                 if (ev[i].type == EV_ABS) {
215                                         SET_AXIS(x, ABS_X);
216                                         SET_AXIS(y, ABS_Y);
217                                         SET_AXIS(z, ABS_Z);
218                                 }
219                         }
220                         if (ev[i].type == EV_SYN && ev[i].code == SYN_REPORT)
221                                 got_syn = true;
222                         if (got_x && got_y && got_z)
223                                 goto read_dev;
224                 }
225         }
226
227 read_dev:
228         new = orientation_calc(old, x, y, z);
229         snprintf(text, sizeof(text),
230                  "ID_INPUT_ACCELEROMETER_ORIENTATION=%s", orientation_to_string(new));
231         puts(text);
232 }
233
234 static void help(void)
235 {
236         printf("Usage: accelerometer [options] <device path>\n"
237                "  --debug         debug to stderr\n"
238                "  --help          print this help text\n\n");
239 }
240
241 int main (int argc, char** argv)
242 {
243         struct udev *udev;
244         struct udev_device *dev;
245
246         static const struct option options[] = {
247                 { "debug", no_argument, NULL, 'd' },
248                 { "help", no_argument, NULL, 'h' },
249                 {}
250         };
251
252         char devpath[PATH_MAX];
253         char *devnode;
254         struct udev_enumerate *enumerate;
255         struct udev_list_entry *list_entry;
256
257         udev = udev_new();
258         if (udev == NULL)
259                 return 1;
260
261         log_open();
262         udev_set_log_fn(udev, log_fn);
263
264         /* CLI argument parsing */
265         while (1) {
266                 int option;
267
268                 option = getopt_long(argc, argv, "dxh", options, NULL);
269                 if (option == -1)
270                         break;
271
272                 switch (option) {
273                 case 'd':
274                         debug = 1;
275                         log_set_max_level(LOG_DEBUG);
276                         udev_set_log_priority(udev, LOG_DEBUG);
277                         break;
278                 case 'h':
279                         help();
280                         exit(0);
281                 default:
282                         exit(1);
283                 }
284         }
285
286         if (argv[optind] == NULL) {
287                 help();
288                 exit(1);
289         }
290
291         /* get the device */
292         snprintf(devpath, sizeof(devpath), "/sys/%s", argv[optind]);
293         dev = udev_device_new_from_syspath(udev, devpath);
294         if (dev == NULL) {
295                 fprintf(stderr, "unable to access '%s'\n", devpath);
296                 return 1;
297         }
298
299         /* Get the children devices and find the devnode */
300         devnode = NULL;
301         enumerate = udev_enumerate_new(udev);
302         udev_enumerate_add_match_parent(enumerate, dev);
303         udev_enumerate_scan_devices(enumerate);
304         udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(enumerate)) {
305                 struct udev_device *device;
306                 const char *node;
307
308                 device = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerate),
309                                                       udev_list_entry_get_name(list_entry));
310                 if (device == NULL)
311                         continue;
312                 /* Already found it */
313                 if (devnode != NULL) {
314                         udev_device_unref(device);
315                         continue;
316                 }
317
318                 node = udev_device_get_devnode(device);
319                 if (node == NULL) {
320                         udev_device_unref(device);
321                         continue;
322                 }
323                 /* Use the event sub-device */
324                 if (strstr(node, "/event") == NULL) {
325                         udev_device_unref(device);
326                         continue;
327                 }
328
329                 devnode = strdup(node);
330                 udev_device_unref(device);
331         }
332
333         if (devnode == NULL) {
334                 fprintf(stderr, "unable to get device node for '%s'\n", devpath);
335                 return 0;
336         }
337
338         log_debug("opening accelerometer device %s", devnode);
339         test_orientation(udev, dev, devnode);
340         free(devnode);
341         log_close();
342         return 0;
343 }