kbdsensor.cpp

   1 /**
   2  *
   3  * Atkbd style sensor
   4  *
   5  * Copyright (C) 2011-2013 The Android-x86 Open Source Project
   6  *
   7  * by Chih-Wei Huang <cwhuang@linux.org.tw>
   8  *
   9  * Licensed under GPLv2 or later
  10  *
  11  **/
  12
  13 #define LOG_TAG "KbdSensor"
  14
  15 #include <cmath>
  16 #include <cerrno>
  17 #include <cstdlib>
  18 #include <cstring>
  19 #include <sys/stat.h>
  20 #include <poll.h>
  21 #include <fcntl.h>
  22 #include <dirent.h>
  23 #include <cutils/log.h>
  24 #include <linux/input.h>
  25 #include <linux/uinput.h>
  26 #include <hardware/sensors.h>
  27 #include <cutils/properties.h>
  28
  29 struct KbdSensorKeys {
  30         char name[64];
  31         int keys[8];
  32 } KeysType[] = {
  33         { "", { } },
  34         { "AT Translated Set 2 keyboard", { EV_KEY, KEY_UP, KEY_RIGHT, KEY_DOWN, KEY_LEFT, KEY_LEFTALT, KEY_LEFTCTRL, 1 } },
  35         { "AT Translated Set 2 keyboard", { EV_MSC, 91, 115, 123, 109, KEY_LEFTALT, KEY_LEFTCTRL, 3 } },
  36         { "AT Translated Set 2 keyboard", { EV_KEY, KEY_F5, KEY_F8, KEY_F6, KEY_F7, KEY_LEFTALT, KEY_LEFTCTRL, 1 } },
  37         { "AT Translated Set 2 keyboard", { EV_KEY, KEY_F9, KEY_F12, KEY_F10, KEY_F11, KEY_LEFTALT, KEY_LEFTCTRL, 1 } },
  38         { "Asus Laptop extra buttons", { EV_KEY, KEY_F9, KEY_F12, KEY_F10, KEY_F11, KEY_LEFTALT, KEY_LEFTCTRL, 2 } },
  39         { "HP WMI hotkeys", { -1, KEY_DIRECTION, 0, 0, 0, 0, 0, 3 } },
  40 };
  41
  42 const int ID_ACCELERATION = (SENSORS_HANDLE_BASE + 0);
  43
  44 template <typename T> struct SensorFd : T {
  45         SensorFd(const struct hw_module_t *module, struct hw_device_t **device);
  46 };
  47
  48 template <typename T> SensorFd<T>::SensorFd(const struct hw_module_t *module, struct hw_device_t **device)
  49 {
  50         this->common.tag     = HARDWARE_DEVICE_TAG;
  51         this->common.version = 0;
  52         this->common.module  = const_cast<struct hw_module_t *>(module);
  53         *device              = &this->common;
  54         ALOGD("%s: module=%p dev=%p", __FUNCTION__, module, *device);
  55 }
  56
  57 struct SensorPollContext : SensorFd<sensors_poll_device_t> {
  58   public:
  59         SensorPollContext(const struct hw_module_t *module, struct hw_device_t **device);
  60         ~SensorPollContext();
  61
  62   private:
  63         static int poll_close(struct hw_device_t *dev);
  64         static int poll_activate(struct sensors_poll_device_t *dev, int handle, int enabled);
  65         static int poll_setDelay(struct sensors_poll_device_t *dev, int handle, int64_t ns);
  66         static int poll_poll(struct sensors_poll_device_t *dev, sensors_event_t *data, int count);
  67
  68         int doPoll(sensors_event_t *data, int count);
  69
  70         enum {
  71                 ROT_0,
  72                 ROT_90,
  73                 ROT_180,
  74                 ROT_270
  75         };
  76
  77         bool enabled;
  78         int rotation;
  79         struct timespec delay;
  80         struct pollfd pfd;
  81         sensors_event_t orients[4];
  82         KbdSensorKeys *ktype;
  83 };
  84
  85 SensorPollContext::SensorPollContext(const struct hw_module_t *module, struct hw_device_t **device)
  86       : SensorFd<sensors_poll_device_t>(module, device), enabled(false), rotation(ROT_0), ktype(KeysType)
  87 {
  88         common.close = poll_close;
  89         activate     = poll_activate;
  90         setDelay     = poll_setDelay;
  91         poll         = poll_poll;
  92
  93         int &fd = pfd.fd;
  94         const char *dirname = "/dev/input";
  95         char prop[PROPERTY_VALUE_MAX];
  96         if (property_get("hal.sensors.kbd.keys", prop, 0))
  97                 sscanf(prop, "%s,%d,%d,%d,%d,%d,%d,%d,%d", ktype->name, ktype->keys,
  98                                 ktype->keys + 1, ktype->keys + 2, ktype->keys + 3, ktype->keys + 4, ktype->keys + 5, ktype->keys + 6, ktype->keys + 7);
  99         else if (property_get("hal.sensors.kbd.type", prop, 0))
 100                 ktype = &KeysType[atoi(prop)];
 101         else
 102                 ktype = 0;
 103         if (DIR *dir = opendir(dirname)) {
 104                 char name[PATH_MAX];
 105                 while (struct dirent *de = readdir(dir)) {
 106                         if (de->d_name[0] != 'e') // not eventX
 107                                 continue;
 108                         snprintf(name, PATH_MAX, "%s/%s", dirname, de->d_name);
 109                         fd = open(name, O_RDWR);
 110                         if (fd < 0) {
 111                                 ALOGE("could not open %s, %s", name, strerror(errno));
 112                                 continue;
 113                         }
 114                         name[sizeof(name) - 1] = '\0';
 115                         if (ioctl(fd, EVIOCGNAME(sizeof(name) - 1), &name) < 1) {
 116                                 ALOGE("could not get device name for %s, %s\n", name, strerror(errno));
 117                                 name[0] = '\0';
 118                         }
 119
 120                         if (ktype) {
 121                                 if (!strcmp(name, ktype->name))
 122                                         break;
 123                         } else {
 124                                 ktype = KeysType + (sizeof(KeysType) / sizeof(KeysType[0]));
 125                                 while (--ktype != KeysType)
 126                                         if (!strcmp(name, ktype->name))
 127                                                 break;
 128                                 if (ktype != KeysType)
 129                                         break;
 130                                 else
 131                                         ktype = 0;
 132                         }
 133                         close(fd);
 134                         fd = -1;
 135                 }
 136                 ALOGI_IF(fd >= 0, "Open %s ok, fd=%d", name, fd);
 137                 closedir(dir);
 138         }
 139
 140         pfd.events = POLLIN;
 141         orients[ROT_0].version = sizeof(sensors_event_t);
 142         orients[ROT_0].sensor = ID_ACCELERATION;
 143         orients[ROT_0].type = SENSOR_TYPE_ACCELEROMETER;
 144         orients[ROT_0].acceleration.status = SENSOR_STATUS_ACCURACY_HIGH;
 145         orients[ROT_270] = orients[ROT_180] = orients[ROT_90] = orients[ROT_0];
 146         const double angle = 20.0;
 147         const double cos_angle = GRAVITY_EARTH * cos(angle / M_PI);
 148         const double sin_angle = GRAVITY_EARTH * sin(angle / M_PI);
 149         orients[ROT_0].acceleration.x   = 0.0;
 150         orients[ROT_0].acceleration.y   = cos_angle;
 151         orients[ROT_0].acceleration.z   = sin_angle;
 152         orients[ROT_90].acceleration.x  = cos_angle;
 153         orients[ROT_90].acceleration.y  = 0.0;
 154         orients[ROT_90].acceleration.z  = sin_angle;
 155         orients[ROT_180].acceleration.x = 0.0;
 156         orients[ROT_180].acceleration.y = -cos_angle;
 157         orients[ROT_180].acceleration.z = -sin_angle;
 158         orients[ROT_270].acceleration.x = -cos_angle;
 159         orients[ROT_270].acceleration.y = 0.0;
 160         orients[ROT_270].acceleration.z = -sin_angle;
 161
 162         delay.tv_sec = 0;
 163         delay.tv_nsec = 200000000L;
 164
 165         ALOGD("%s: dev=%p fd=%d", __FUNCTION__, this, fd);
 166 }
 167
 168 SensorPollContext::~SensorPollContext()
 169 {
 170         close(pfd.fd);
 171 }
 172
 173 int SensorPollContext::poll_close(struct hw_device_t *dev)
 174 {
 175         ALOGD("%s: dev=%p", __FUNCTION__, dev);
 176         delete reinterpret_cast<SensorPollContext *>(dev);
 177         return 0;
 178 }
 179
 180 int SensorPollContext::poll_activate(struct sensors_poll_device_t *dev, int handle, int enabled)
 181 {
 182         ALOGD("%s: dev=%p handle=%d enabled=%d", __FUNCTION__, dev, handle, enabled);
 183         SensorPollContext *ctx = reinterpret_cast<SensorPollContext *>(dev);
 184         ctx->enabled = enabled;
 185         return 0;
 186 }
 187
 188 int SensorPollContext::poll_setDelay(struct sensors_poll_device_t *dev, int handle, int64_t ns)
 189 {
 190         ALOGD("%s: dev=%p delay-ns=%lld", __FUNCTION__, dev, ns);
 191         return 0;
 192 }
 193
 194 int SensorPollContext::poll_poll(struct sensors_poll_device_t *dev, sensors_event_t *data, int count)
 195 {
 196         ALOGV("%s: dev=%p data=%p count=%d", __FUNCTION__, dev, data, count);
 197         SensorPollContext *ctx = reinterpret_cast<SensorPollContext *>(dev);
 198         return ctx->doPoll(data, count);
 199 }
 200
 201 int SensorPollContext::doPoll(sensors_event_t *data, int count)
 202 {
 203         nanosleep(&delay, 0);
 204         int *keys = ktype->keys;
 205         while (int pollres = ::poll(&pfd, 1, -1)) {
 206                 if (pollres < 0) {
 207                         ALOGE("%s: poll %d error: %s", __FUNCTION__, pfd.fd, strerror(errno));
 208                         break;
 209                 }
 210                 if (!(pfd.revents & POLLIN)) {
 211                         ALOGW("%s: ignore revents %d", __FUNCTION__, pfd.revents);
 212                         continue;
 213                 }
 214
 215                 struct input_event iev;
 216                 size_t res = ::read(pfd.fd, &iev, sizeof(iev));
 217                 if (res < sizeof(iev)) {
 218                         ALOGW("insufficient input data(%d)? fd=%d", res, pfd.fd);
 219                         continue;
 220                 }
 221                 ALOGV("type=%d scancode=%d value=%d from fd=%d", iev.type, iev.code, iev.value, pfd.fd);
 222                 if (iev.type == keys[0]) {
 223                         int rot;
 224                         int input = (keys[0] == EV_MSC) ? iev.value : iev.code;
 225                         if (input == keys[1])
 226                                 rot = ROT_0;
 227                         else if (input == keys[2])
 228                                 rot = ROT_90;
 229                         else if (input == keys[3])
 230                                 rot = ROT_180;
 231                         else if (input == keys[4])
 232                                 rot = ROT_270;
 233                         else if (input == keys[5] || input == keys[6])
 234                                 rot = rotation;
 235                         else
 236                                 rot = -1;
 237
 238                         if (rot >= 0) {
 239                                 if (rot != rotation) {
 240                                         ALOGI("orientation changed from %d to %d", rotation * 90, rot * 90);
 241                                         rotation = rot;
 242                                 }
 243                                 if (enabled && count > 0)
 244                                         break;
 245                         }
 246                 } else if (iev.type == EV_KEY && iev.code == keys[1] && iev.value) {
 247                         if (rotation == ROT_270)
 248                                 rotation = ROT_0;
 249                         else
 250                                 rotation++;
 251                         break;
 252                 } else if (iev.type == EV_SW && iev.code == SW_TABLET_MODE) {
 253                         if (!iev.value)
 254                                 rotation = ROT_0;
 255                         else if (rotation == ROT_0)
 256                                 rotation = ROT_90;
 257                         break;
 258                 }
 259         }
 260
 261         int cnt;
 262         struct timespec t;
 263         data[0] = orients[rotation];
 264         t.tv_sec = t.tv_nsec = 0;
 265         clock_gettime(CLOCK_MONOTONIC, &t);
 266         data[0].timestamp = int64_t(t.tv_sec) * 1000000000LL + t.tv_nsec;
 267         for (cnt = 1; cnt < keys[7] && cnt < count; ++cnt) {
 268                 data[cnt] = data[cnt - 1];
 269                 data[cnt].timestamp += delay.tv_nsec;
 270                 nanosleep(&delay, 0);
 271         }
 272         ALOGV("%s: dev=%p fd=%d rotation=%d cnt=%d", __FUNCTION__, this, pfd.fd, rotation * 90, cnt);
 273         return cnt;
 274 }
 275
 276 static int open_kbd_sensor(const struct hw_module_t *module, const char *id, struct hw_device_t **device)
 277 {
 278         ALOGD("%s: id=%s", __FUNCTION__, id);
 279         return new SensorPollContext(module, device) ? 0 : -EINVAL;
 280 }
 281
 282 static struct sensor_t sSensorListInit[] = {
 283         {
 284                 name: "Kbd Orientation Sensor",
 285                 vendor: "Android-x86 Open Source Project",
 286                 version: 1,
 287                 handle: ID_ACCELERATION,
 288                 type: SENSOR_TYPE_ACCELEROMETER,
 289                 maxRange: 2.8f,
 290                 resolution: 1.0f/4032.0f,
 291                 power: 3.0f,
 292                 minDelay: 0,
 293                 fifoReservedEventCount: 0,
 294                 fifoMaxEventCount: 0,
 295                 reserved: { }
 296         }
 297 };
 298
 299 static int sensors_get_sensors_list(struct sensors_module_t *module, struct sensor_t const **list)
 300 {
 301         *list = sSensorListInit;
 302         return sizeof(sSensorListInit) / sizeof(struct sensor_t);
 303 }
 304
 305 static struct hw_module_methods_t sensors_methods = {
 306         open: open_kbd_sensor
 307 };
 308
 309 struct sensors_module_t HAL_MODULE_INFO_SYM = {
 310         common: {
 311                 tag: HARDWARE_MODULE_TAG,
 312                 version_major: 2,
 313                 version_minor: 3,
 314                 id: SENSORS_HARDWARE_MODULE_ID,
 315                 name: "Kbd Orientation Sensor",
 316                 author: "Chih-Wei Huang",
 317                 methods: &sensors_methods,
 318                 dso: 0,
 319                 reserved: { }
 320         },
 321         get_sensors_list: sensors_get_sensors_list
 322 };