enumeration.c

   1 /*
   2  * Copyright (C) 2014 Intel Corporation.
   3  */
   4
   5 #include <dirent.h>
   6 #include <utils/Log.h>
   7 #include <hardware/sensors.h>
   8 #include "enumeration.h"
   9 #include "description.h"
  10 #include "utils.h"
  11
  12 /*
  13  * This table maps syfs entries in scan_elements directories to sensor types,
  14  * and will also be used to determine other sysfs names as well as the iio
  15  * device number associated to a specific sensor.
  16  */
  17
  18 struct sensor_catalog_entry_t sensor_catalog[] = {
  19         DECLARE_SENSOR3("accel",      SENSOR_TYPE_ACCELEROMETER,  "x", "y", "z")
  20         DECLARE_SENSOR3("anglvel",    SENSOR_TYPE_GYROSCOPE,      "x", "y", "z")
  21         DECLARE_SENSOR3("magn",       SENSOR_TYPE_MAGNETIC_FIELD, "x", "y", "z")
  22         DECLARE_SENSOR0("illuminance",SENSOR_TYPE_LIGHT                        )
  23         DECLARE_SENSOR3("incli",      SENSOR_TYPE_ORIENTATION,    "x", "y", "z")
  24         DECLARE_SENSOR4("rot",        SENSOR_TYPE_ROTATION_VECTOR,
  25                                          "quat_x", "quat_y", "quat_z", "quat_w")
  26         DECLARE_SENSOR0("temp",       SENSOR_TYPE_TEMPERATURE                  )
  27         DECLARE_SENSOR0("timestamp",  SENSOR_TYPE_DEVICE_PRIVATE_BASE          )
  28 };
  29
  30 #define CATALOG_SIZE    ARRAY_SIZE(sensor_catalog)
  31
  32
  33 /* We equate sensor handles to indices in these tables */
  34
  35 struct sensor_t      sensor_desc[MAX_SENSORS];  /* Android-level descriptors */
  36 struct sensor_info_t sensor_info[MAX_SENSORS];  /* Internal descriptors      */
  37 int sensor_count;                               /* Detected sensors          */
  38
  39
  40 static void add_sensor (int dev_num, int catalog_index, int use_polling)
  41 {
  42         int s;
  43         int sensor_type;
  44         char sysfs_path[PATH_MAX];
  45         const char* prefix;
  46         float scale;
  47
  48         if (sensor_count == MAX_SENSORS) {
  49                 ALOGE("Too many sensors!\n");
  50                 return;
  51         }
  52
  53         sensor_type = sensor_catalog[catalog_index].type;
  54
  55         /*
  56          * At this point we could check that the expected sysfs attributes are
  57          * present ; that would enable having multiple catalog entries with the
  58          * same sensor type, accomodating different sets of sysfs attributes.
  59          */
  60
  61         s = sensor_count;
  62
  63         sensor_info[s].dev_num          = dev_num;
  64         sensor_info[s].catalog_index    = catalog_index;
  65
  66         if (use_polling)
  67                 sensor_info[s].num_channels = 0;
  68         else
  69                 sensor_info[s].num_channels =
  70                                 sensor_catalog[catalog_index].num_channels;
  71
  72         prefix = sensor_catalog[catalog_index].tag;
  73
  74         /* Read name attribute, if available */
  75         sprintf(sysfs_path, NAME_PATH, dev_num);
  76         sysfs_read_str(sysfs_path, sensor_info[s].internal_name, MAX_NAME_SIZE);
  77
  78         /* See if we have general offsets and scale values for this sensor */
  79
  80         sprintf(sysfs_path, COMMON_OFFSET_PATH, dev_num, prefix);
  81         sysfs_read_float(sysfs_path, &sensor_info[s].offset);
  82
  83         sprintf(sysfs_path, COMMON_SCALE_PATH, dev_num, prefix);
  84         if (!sysfs_read_float(sysfs_path, &scale))
  85                 sensor_info[s].scale = scale;
  86         else
  87                 sensor_info[s].scale = 1;
  88
  89         /* Initialize Android-visible descriptor */
  90         sensor_desc[s].name             = sensor_get_name(s);
  91         sensor_desc[s].vendor           = sensor_get_vendor(s);
  92         sensor_desc[s].version          = sensor_get_version(s);
  93         sensor_desc[s].handle           = s;
  94         sensor_desc[s].type             = sensor_type;
  95         sensor_desc[s].maxRange         = sensor_get_max_range(s);
  96         sensor_desc[s].resolution       = sensor_get_resolution(s);
  97         sensor_desc[s].power            = sensor_get_power(s);
  98
  99         if (sensor_info[s].internal_name[0] == '\0') {
 100                 /*
 101                  * In case the kernel-mode driver doesn't expose a name for
 102                  * the iio device, use (null)-dev%d as the trigger name...
 103                  * This can be considered a kernel-mode iio driver bug.
 104                  */
 105                 ALOGW("Using null trigger on sensor %d (dev %d)\n", s, dev_num);
 106                 strcpy(sensor_info[s].internal_name, "(null)");
 107         }
 108
 109         sensor_count++;
 110 }
 111
 112
 113 static void discover_poll_sensors (int dev_num, char map[CATALOG_SIZE])
 114 {
 115         char base_dir[PATH_MAX];
 116         DIR *dir;
 117         char sysfs_dir[PATH_MAX];
 118         struct sensor *sensor;
 119         struct dirent *d;
 120         unsigned int i;
 121         int c;
 122
 123         memset(map, 0, CATALOG_SIZE);
 124
 125         snprintf(base_dir, sizeof(base_dir), BASE_PATH, dev_num);
 126
 127         dir = opendir(base_dir);
 128         if (!dir) {
 129                return;
 130         }
 131
 132         /* Enumerate entries in this iio device's base folder */
 133
 134         while ((d = readdir(dir))) {
 135                 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
 136                         continue;
 137
 138                 /* If the name matches a catalog entry, flag it */
 139                 for (i = 0; i<CATALOG_SIZE; i++)
 140                         for (c=0; c<sensor_catalog[i].num_channels; c++)
 141                                 if (!strcmp(d->d_name,
 142                                     sensor_catalog[i].channel[c].raw_path) ||
 143                                     !strcmp(d->d_name,
 144                                     sensor_catalog[i].channel[c].input_path)) {
 145                                 map[i] = 1;
 146                                 break;
 147                         }
 148         }
 149
 150         closedir(dir);
 151 }
 152
 153
 154 static void discover_trig_sensors (int dev_num, char map[CATALOG_SIZE])
 155 {
 156         char scan_elem_dir[PATH_MAX];
 157         DIR *dir;
 158         char sysfs_dir[PATH_MAX];
 159         struct sensor *sensor;
 160         struct dirent *d;
 161         unsigned int i;
 162
 163         memset(map, 0, CATALOG_SIZE);
 164
 165         /* Enumerate entries in this iio device's scan_elements folder */
 166
 167         snprintf(scan_elem_dir, sizeof(scan_elem_dir), CHANNEL_PATH, dev_num);
 168
 169         dir = opendir(scan_elem_dir);
 170         if (!dir) {
 171                return;
 172         }
 173
 174         while ((d = readdir(dir))) {
 175                 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
 176                         continue;
 177
 178                 /* Compare en entry to known ones and create matching sensors */
 179
 180                 for (i = 0; i<CATALOG_SIZE; i++)
 181                         if (!strcmp(d->d_name,
 182                                     sensor_catalog[i].channel[0].en_path)) {
 183                                 map[i] = 1;
 184                                 break;
 185                         }
 186         }
 187
 188         closedir(dir);
 189 }
 190
 191
 192 void enumerate_sensors (void)
 193 {
 194         /*
 195          * Discover supported sensors and allocate control structures for them.
 196          * Multiple sensors can potentially rely on a single iio device (each
 197          * using their own channels). We can't have multiple sensors of the same
 198          * type on the same device. In case of detection as both a poll-mode
 199          * and trigger-based sensor, use the trigger usage mode.
 200          */
 201         char poll_sensors[CATALOG_SIZE];
 202         char trig_sensors[CATALOG_SIZE];
 203         int dev_num;
 204         unsigned int i;
 205
 206         for (dev_num=0; dev_num<MAX_DEVICES; dev_num++) {
 207                 discover_poll_sensors(dev_num, poll_sensors);
 208                 discover_trig_sensors(dev_num, trig_sensors);
 209
 210                 for (i=0; i<CATALOG_SIZE; i++)
 211                         if (trig_sensors[i])
 212                                 add_sensor(dev_num, i, 0);
 213                         else
 214                                 if (poll_sensors[i])
 215                                         add_sensor(dev_num, i, 1);
 216         }
 217
 218         ALOGI("Discovered %d sensors\n", sensor_count);
 219 }
 220
 221
 222 void delete_enumeration_data (void)
 223 {
 224         /* Reset sensor count */
 225         sensor_count = 0;
 226 }
 227
 228
 229 int get_sensors_list(   struct sensors_module_t* module,
 230                         struct sensor_t const** list)
 231 {
 232         *list = sensor_desc;
 233         return sensor_count;
 234 }
 235