tablet-mode/tablet-mode.c

   1 /**
   2  * Convert SW_TABLET_MODE events to SW_LID events for Android
   3  *
   4  * Copyright 2012 The Android-x86 Open Source Project
   5  *
   6  * Author: Stefan Seidel <android@stefanseidel.info>
   7  *
   8  * Licensed under GPLv2 or later
   9  *
  10  **/
  11
  12 #define LOG_TAG "tablet-mode"
  13
  14 #include <sys/stat.h>
  15 #include <poll.h>
  16 #include <fcntl.h>
  17 #include <errno.h>
  18 #include <dirent.h>
  19 #include <string.h>
  20 #include <cutils/log.h>
  21 #include <linux/input.h>
  22 #include <linux/uinput.h>
  23
  24 /* we must use this kernel-compatible implementation */
  25 #define BITS_PER_LONG (sizeof(long) * 8)
  26 #define NBITS(x) ((((x)-1)/BITS_PER_LONG)+1)
  27 #define OFF(x)  ((x)%BITS_PER_LONG)
  28 #define BIT(x)  (1UL<<OFF(x))
  29 #define LONG(x) ((x)/BITS_PER_LONG)
  30 #define test_bit(bit, array)    ((array[LONG(bit)] >> OFF(bit)) & 1)
  31
  32 int openfd(void)
  33 {
  34         int fd;
  35         const char *dirname = "/dev/input";
  36         DIR *dir;
  37         if ((dir = opendir(dirname))) {
  38                 struct dirent *de;
  39                 unsigned long caps[NBITS(SW_TABLET_MODE+1)];
  40                 while ((de = readdir(dir))) {
  41                         if (de->d_name[0] != 'e') // eventX
  42                                 continue;
  43                         char name[PATH_MAX];
  44                         snprintf(name, PATH_MAX, "%s/%s", dirname, de->d_name);
  45                         fd = open(name, O_RDONLY);
  46                         if (fd < 0) {
  47                                 ALOGE("could not open %s, %s", name, strerror(errno));
  48                                 continue;
  49                         }
  50                         memset(caps, 0, sizeof(caps));
  51                         if (ioctl(fd, EVIOCGBIT(EV_SW, sizeof(caps)), caps) < 1) {
  52                                 ALOGE("could not get device caps for %s, %s\n", name, strerror(errno));
  53                                 continue;
  54                         }
  55                         if (test_bit(SW_TABLET_MODE, caps)) {
  56                                 ALOGI("open %s(%s) ok", de->d_name, name);
  57                                 return fd;
  58                         }
  59                         close(fd);
  60                 }
  61                 closedir(dir);
  62         }
  63         return -1;
  64 }
  65
  66 void send_switch(int ufd, int state) {
  67         struct input_event nev;
  68         ALOGI("Tablet Mode Switch to %d\n", state);
  69         memset(&nev, 0, sizeof(struct input_event));
  70         nev.type = EV_SW;
  71         nev.code = SW_LID;
  72         nev.value = !!state;
  73         write(ufd, &nev, sizeof(struct input_event));
  74         nev.type = EV_SYN;
  75         nev.code = SYN_REPORT;
  76         nev.value = 0;
  77         write(ufd, &nev, sizeof(struct input_event));
  78 }
  79
  80 int main(void)
  81 {
  82         int ifd = openfd();
  83         if (ifd < 0) {
  84                 ALOGE("could not find any tablet mode switch, exiting.");
  85                 return -1;
  86         }
  87
  88         sleep(10); //wait some time or otherwise EventHub might not pick up our events correctly!?
  89
  90         int ufd = open("/dev/uinput", O_WRONLY | O_NDELAY);
  91         if (ufd >= 0) {
  92                 struct uinput_user_dev ud;
  93                 memset(&ud, 0, sizeof(struct uinput_user_dev));
  94                 strcpy(ud.name, "Android Tablet Lid Switch");
  95                 write(ufd, &ud, sizeof(struct uinput_user_dev));
  96                 ioctl(ufd, UI_SET_EVBIT, EV_SW);
  97                 ioctl(ufd, UI_SET_SWBIT, SW_LID);
  98                 ioctl(ufd, UI_DEV_CREATE, 0);
  99         } else {
 100                 ALOGE("could not open uinput device: %s", strerror(errno));
 101                 return -1;
 102         }
 103
 104         // send initial switch state
 105         unsigned long sw_state[NBITS(SW_TABLET_MODE+1)];
 106         memset(sw_state, 0, sizeof(sw_state));
 107         if (ioctl(ifd, EVIOCGSW(sizeof(sw_state)), sw_state) >= 0) {
 108                 send_switch(ufd, test_bit(SW_TABLET_MODE, sw_state) ? 1 : 0);
 109         }
 110
 111         // read events and pass them on modified
 112         while (1) {
 113                 struct input_event iev;
 114                 size_t res = read(ifd, &iev, sizeof(struct input_event));
 115                 if (res < sizeof(struct input_event)) {
 116                         ALOGW("insufficient input data(%d)? fd=%d", res, ifd);
 117                         continue;
 118                 }
 119                 //LOGV("type=%d scancode=%d value=%d from fd=%d", iev.type, iev.code, iev.value, ifd);
 120                 if (iev.type == EV_SW && iev.code == SW_TABLET_MODE) {
 121                         send_switch(ufd, iev.value);
 122                 }
 123         }
 124
 125         return 0;
 126 }