2 * accelerometer - exports device orientation through property
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.
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
21 * Copyright (C) 2011 Red Hat, Inc.
23 * Bastien Nocera <hadess@hadess.net>
25 * orientation_calc() from the sensorfw package
26 * Copyright (C) 2009-2010 Nokia Corporation
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>
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.
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.
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.
50 #include <sys/types.h>
57 #include <linux/limits.h>
58 #include <linux/input.h>
61 #include "libudev-private.h"
63 /* we must use this kernel-compatible implementation */
64 #define BITS_PER_LONG (sizeof(unsigned long) * 8)
65 #define NBITS(x) ((((x)-1)/BITS_PER_LONG)+1)
66 #define OFF(x) ((x)%BITS_PER_LONG)
67 #define BIT(x) (1UL<<OFF(x))
68 #define LONG(x) ((x)/BITS_PER_LONG)
69 #define test_bit(bit, array) ((array[LONG(bit)] >> OFF(bit)) & 1)
73 static void log_fn(struct udev *udev, int priority,
74 const char *file, int line, const char *fn,
75 const char *format, va_list args)
78 fprintf(stderr, "%s: ", fn);
79 vfprintf(stderr, format, args);
81 vsyslog(priority, format, args);
86 ORIENTATION_UNDEFINED,
88 ORIENTATION_BOTTOM_UP,
93 static const char *orientations[] = {
102 #define ORIENTATION_UP_UP ORIENTATION_NORMAL
104 #define DEFAULT_THRESHOLD 250
105 #define RADIANS_TO_DEGREES 180.0/M_PI
106 #define SAME_AXIS_LIMIT 5
108 #define THRESHOLD_LANDSCAPE 25
109 #define THRESHOLD_PORTRAIT 20
112 orientation_to_string (OrientationUp o)
114 return orientations[o];
118 string_to_orientation (const char *orientation)
122 if (orientation == NULL)
123 return ORIENTATION_UNDEFINED;
124 for (i = 0; orientations[i] != NULL; i++) {
125 if (streq (orientation, orientations[i]))
128 return ORIENTATION_UNDEFINED;
132 orientation_calc (OrientationUp prev,
136 OrientationUp ret = prev;
139 rotation = round(atan((double) x / sqrt(y * y + z * z)) * RADIANS_TO_DEGREES);
141 if (abs(rotation) > THRESHOLD_PORTRAIT) {
142 ret = (rotation < 0) ? ORIENTATION_LEFT_UP : ORIENTATION_RIGHT_UP;
144 /* Some threshold to switching between portrait modes */
145 if (prev == ORIENTATION_LEFT_UP || prev == ORIENTATION_RIGHT_UP) {
146 if (abs(rotation) < SAME_AXIS_LIMIT) {
152 /* Landscape check */
153 rotation = round(atan((double) y / sqrt(x * x + z * z)) * RADIANS_TO_DEGREES);
155 if (abs(rotation) > THRESHOLD_LANDSCAPE) {
156 ret = (rotation < 0) ? ORIENTATION_BOTTOM_UP : ORIENTATION_NORMAL;
158 /* Some threshold to switching between landscape modes */
159 if (prev == ORIENTATION_BOTTOM_UP || prev == ORIENTATION_NORMAL) {
160 if (abs(rotation) < SAME_AXIS_LIMIT) {
171 get_prev_orientation(struct udev_device *dev)
175 value = udev_device_get_property_value(dev, "ID_INPUT_ACCELEROMETER_ORIENTATION");
177 return ORIENTATION_UNDEFINED;
178 return string_to_orientation(value);
181 #define SET_AXIS(axis, code_) if (ev[i].code == code_) { if (got_##axis == 0) { axis = ev[i].value; got_##axis = 1; } }
184 static void test_orientation(struct udev *udev,
185 struct udev_device *dev,
188 OrientationUp old, new;
190 struct input_event ev[64];
192 int got_x, got_y, got_z;
193 int x = 0, y = 0, z = 0;
196 old = get_prev_orientation(dev);
198 if ((fd = open(devpath, O_RDONLY)) < 0)
201 got_x = got_y = got_z = 0;
206 r = read(fd, ev, sizeof(struct input_event) * 64);
208 if (r < (int) sizeof(struct input_event)) {
213 for (i = 0; i < r / (int) sizeof(struct input_event); i++) {
215 if (ev[i].type == EV_ABS) {
221 if (ev[i].type == EV_SYN && ev[i].code == SYN_REPORT) {
224 if (got_x && got_y && got_z)
232 if (!got_x || !got_y || !got_z)
235 new = orientation_calc(old, x, y, z);
236 snprintf(text, sizeof(text), "ID_INPUT_ACCELEROMETER_ORIENTATION=%s", orientation_to_string(new));
240 static void help(void)
242 printf("Usage: accelerometer [options] <device path>\n"
243 " --debug debug to stderr\n"
244 " --help print this help text\n\n");
247 int main (int argc, char** argv)
250 struct udev_device *dev;
252 static const struct option options[] = {
253 { "debug", no_argument, NULL, 'd' },
254 { "help", no_argument, NULL, 'h' },
258 char devpath[PATH_MAX];
260 struct udev_enumerate *enumerate;
261 struct udev_list_entry *list_entry;
268 udev_set_log_fn(udev, log_fn);
270 /* CLI argument parsing */
274 option = getopt_long(argc, argv, "dxh", options, NULL);
281 log_set_max_level(LOG_DEBUG);
282 udev_set_log_priority(udev, LOG_DEBUG);
292 if (argv[optind] == NULL) {
298 snprintf(devpath, sizeof(devpath), "/sys/%s", argv[optind]);
299 dev = udev_device_new_from_syspath(udev, devpath);
301 fprintf(stderr, "unable to access '%s'\n", devpath);
305 /* Get the children devices and find the devnode */
307 enumerate = udev_enumerate_new(udev);
308 udev_enumerate_add_match_parent(enumerate, dev);
309 udev_enumerate_scan_devices(enumerate);
310 udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(enumerate)) {
311 struct udev_device *device;
314 device = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerate),
315 udev_list_entry_get_name(list_entry));
318 /* Already found it */
319 if (devnode != NULL) {
320 udev_device_unref(device);
324 node = udev_device_get_devnode(device);
326 udev_device_unref(device);
329 /* Use the event sub-device */
330 if (strstr(node, "/event") == NULL) {
331 udev_device_unref(device);
335 devnode = strdup(node);
336 udev_device_unref(device);
339 if (devnode == NULL) {
340 fprintf(stderr, "unable to get device node for '%s'\n", devpath);
344 log_debug("opening accelerometer device %s\n", devnode);
345 test_orientation(udev, dev, devnode);