Modifying the sensor HAL to support upstream patches

Bug: 180032493
Test: Test sensors in KitchenSink
Change-Id: I3d0c669e8deb5490b225b6bcef7864913cc09b56

4 files changed, 55 insertions, 55 deletions

diff --git a/hal/sensors/2.0/Sensor.cpp b/hal/sensors/2.0/Sensor.cpp
index a5338ad..1d2ea80 100644
--- a/hal/sensors/2.0/Sensor.cpp
+++ b/hal/sensors/2.0/Sensor.cpp
@@ -456,10 +456,9 @@ HWSensorBase::HWSensorBase(int32_t sensorHandle, ISensorsEventCallback* callback
     std::string buffer_path;
     mSensorInfo.flags |= SensorFlagBits::CONTINUOUS_MODE;
     mSensorInfo.name = data.name;
-    mSensorInfo.resolution = data.resolution;
+    mSensorInfo.resolution = data.resolution * data.scale;
     mSensorInfo.maxRange = data.max_range * data.scale;
-    mSensorInfo.power =
-            (data.power_microwatts / 1000.f) / SENSOR_VOLTAGE_DEFAULT;  // converting uW to mA
+    mSensorInfo.power = 0;
     mIioData = data;
     setOrientation(config);
     status_t ret = setAdditionalInfoFrames(config);
diff --git a/hal/sensors/2.0/iio_utils.cpp b/hal/sensors/2.0/iio_utils.cpp
index a2075f8..84360b2 100644
--- a/hal/sensors/2.0/iio_utils.cpp
+++ b/hal/sensors/2.0/iio_utils.cpp
@@ -34,10 +34,8 @@ static const char* IIO_SFA_FILENAME = "sampling_frequency_available";
 static const char* IIO_SCALE_FILENAME = "_scale";
 static const char* IIO_SAMPLING_FREQUENCY = "_sampling_frequency";
 static const char* IIO_BUFFER_ENABLE = "buffer/enable";
-static const char* IIO_POWER_FILENAME = "sensor_power";
-static const char* IIO_MAX_RANGE_FILENAME = "sensor_max_range";
-static const char* IIO_RESOLUTION_FILENAME = "sensor_resolution";
 static const char* IIO_NAME_FILENAME = "name";
+static const char* IIO_RANGE_AVAIL_FILENAME = "raw_available";
 
 namespace android {
 namespace hardware {
@@ -128,18 +126,10 @@ static int sysfs_read_uint8(const std::string& file, uint8_t* val) {
     return sysfs_read_val(file, "%hhu\n", val);
 }
 
-static int sysfs_read_uint(const std::string& file, unsigned int* val) {
-    return sysfs_read_val(file, "%u\n", val);
-}
-
 static int sysfs_read_float(const std::string& file, float* val) {
     return sysfs_read_val(file, "%f\n", val);
 }
 
-static int sysfs_read_int64(const std::string& file, int64_t* val) {
-    return sysfs_read_val(file, "%lld\n", val);
-}
-
 static int sysfs_read_str(const std::string& file, std::string* str) {
     std::ifstream infile(file);
     if (!infile.is_open()) return -EINVAL;
@@ -172,30 +162,58 @@ static int get_sampling_frequency_available(const std::string& device_dir,
     int ret = 0;
     char* rest;
     std::string line;
+    DirPtr dp(nullptr, closedir);
+    const struct dirent* ent;
 
-    const std::string filename = device_dir + "/" + IIO_SFA_FILENAME;
-
-    ret = sysfs_read_str(filename, &line);
-    if (ret < 0) return ret;
-    char* pch = strtok_r(const_cast<char*>(line.c_str()), " ,", &rest);
-    while (pch != nullptr) {
-        sfa->push_back(atof(pch));
-        pch = strtok_r(nullptr, " ,", &rest);
+    ret = sysfs_opendir(device_dir, &dp);
+    if (ret) return ret;
+    while (ent = readdir(dp.get()), ent != nullptr) {
+        if (str_has_suffix(ent->d_name, IIO_SFA_FILENAME)) {
+            std::string filename = device_dir;
+            filename += "/";
+            filename += ent->d_name;
+            ret = sysfs_read_str(filename, &line);
+            if (ret < 0) return ret;
+            char* pch = strtok_r(const_cast<char*>(line.c_str()), " ,", &rest);
+            while (pch != nullptr) {
+                sfa->push_back(atof(pch));
+                pch = strtok_r(nullptr, " ,", &rest);
+            }
+        }
     }
 
     return ret < 0 ? ret : 0;
 }
 
-static int get_sensor_power(const std::string& device_dir, unsigned int* power) {
-    const std::string filename = device_dir + "/" + IIO_POWER_FILENAME;
+static int get_sensor_range(const std::string& device_dir, float* resolution, int64_t* max_range) {
+    int ret = 0;
+    char* rest;
+    std::string line;
+    DirPtr dp(nullptr, closedir);
+    const struct dirent* ent;
 
-    return sysfs_read_uint(filename, power);
-}
+    ret = sysfs_opendir(device_dir, &dp);
+    if (ret) return ret;
+    while (ent = readdir(dp.get()), ent != nullptr) {
+        if (str_has_suffix(ent->d_name, IIO_RANGE_AVAIL_FILENAME)) {
+            std::string filename = device_dir;
+            filename += "/";
+            filename += ent->d_name;
 
-static int get_sensor_max_range(const std::string& device_dir, int64_t* max_range) {
-    const std::string filename = device_dir + "/" + IIO_MAX_RANGE_FILENAME;
+            ret = sysfs_read_str(filename, &line);
+            if (ret < 0) return ret;
+            char* pch = strtok_r(const_cast<char*>(line.c_str()), " ", &rest);
+            std::vector<std::string> range_avail;
+            while (pch != nullptr) {
+                range_avail.push_back(pch);
+                pch = strtok_r(nullptr, " ", &rest);
+            }
+            *resolution = atof(range_avail[1].c_str());
+            *max_range = atoll(range_avail[2].c_str());
+        }
+    }
 
-    return sysfs_read_int64(filename, max_range);
+    return ret < 0 ? ret : 0;
 }
 
 static int get_sensor_name(const std::string& device_dir, std::string* name) {
@@ -242,12 +260,6 @@ static int get_sensor_scale(const std::string& device_dir, float* scale) {
     return err;
 }
 
-static int get_sensor_resolution(const std::string& device_dir, float* resolution) {
-    const std::string filename = device_dir + "/" + IIO_RESOLUTION_FILENAME;
-
-    return sysfs_read_float(filename, resolution);
-}
-
 int load_iio_devices(std::string iio_dir, std::vector<iio_device_data>* iio_data,
                      DeviceFilterFunction filter) {
     DirPtr dp(nullptr, closedir);
@@ -291,19 +303,10 @@ int load_iio_devices(std::string iio_dir, std::vector<iio_device_data>* iio_data
             ALOGE("get_sensor_scale for %s returned error %d", path_device.c_str(), err);
             continue;
         }
-        err = get_sensor_power(iio_dev_data.sysfspath, &iio_dev_data.power_microwatts);
-        if (err) {
-            ALOGE("get_sensor_power for %s returned error %d", path_device.c_str(), err);
-            continue;
-        }
-        err = get_sensor_max_range(iio_dev_data.sysfspath, &iio_dev_data.max_range);
-        if (err) {
-            ALOGE("get_sensor_max_range for %s returned error %d", path_device.c_str(), err);
-            continue;
-        }
-        err = get_sensor_resolution(iio_dev_data.sysfspath, &iio_dev_data.resolution);
+        err = get_sensor_range(iio_dev_data.sysfspath, &iio_dev_data.resolution,
+                               &iio_dev_data.max_range);
         if (err) {
-            ALOGE("get_sensor_resolution for %s returned error %d", path_device.c_str(), err);
+            ALOGE("get_sensor_range for %s returned error %d", path_device.c_str(), err);
             continue;
         }
 
diff --git a/hal/sensors/2.0/iio_utils.h b/hal/sensors/2.0/iio_utils.h
index 9de6a7b..a84d369 100644
--- a/hal/sensors/2.0/iio_utils.h
+++ b/hal/sensors/2.0/iio_utils.h
@@ -63,7 +63,6 @@ struct iio_device_data {
     std::vector<iio_info_channel> channelInfo;
     std::vector<double> sampling_freq_avl;
     uint8_t iio_dev_num;
-    unsigned int power_microwatts;
     int64_t max_range;
 };
 
diff --git a/hal/sensors/2.0/tests/IioUtilsTest.cpp b/hal/sensors/2.0/tests/IioUtilsTest.cpp
index f3e53a2..034a6b8 100644
--- a/hal/sensors/2.0/tests/IioUtilsTest.cpp
+++ b/hal/sensors/2.0/tests/IioUtilsTest.cpp
@@ -97,10 +97,11 @@ static bool writeAccelDevice(const std::string& td_path, const iio_device_data&
     if (!writeFile(concatPaths(dev_path, "in_accel_x_scale"), dev.scale)) return false;
     if (!writeFile(concatPaths(dev_path, "in_accel_y_scale"), dev.scale)) return false;
     if (!writeFile(concatPaths(dev_path, "in_accel_z_scale"), dev.scale)) return false;
-    if (!writeFile(concatPaths(dev_path, "sensor_power"), dev.power_microwatts)) return false;
-    if (!writeFile(concatPaths(dev_path, "sensor_max_range"), dev.max_range)) return false;
-    if (!writeFile(concatPaths(dev_path, "sensor_resolution"), dev.resolution)) return false;
-    if (!writeFile(concatPaths(dev_path, "sampling_frequency_available"), dev.sampling_freq_avl))
+    if (!writeFile(concatPaths(dev_path, "in_accel_raw_available"),
+                   "[-78381056.000000000 2392.000000000 78378664.000000000]"))
+        return false;
+    if (!writeFile(concatPaths(dev_path, "in_accel_sampling_frequency_available"),
+                   dev.sampling_freq_avl))
         return false;
 
     return true;
@@ -113,10 +114,9 @@ static iio_device_data createDefaultAccelerometerDevice(int id) {
     dev.iio_dev_num = id;
     dev.name = "scmi.iio.accel";
     dev.sampling_freq_avl = {12.500000, 26.000364, 52.002080, 104.004160, 208.003993};
-    dev.resolution = 0.002392000f;
+    dev.resolution = 2392;
     dev.scale = 0.000001000f;
     dev.max_range = 78378664;
-    dev.power_microwatts = 0;
 
     return dev;
 }
@@ -141,7 +141,6 @@ TEST(IioUtilsTest, LoadValidSensor) {
 
     EXPECT_NEAR(dev_model.resolution, accel.resolution, 0.0002);
     EXPECT_NEAR(dev_model.scale, accel.scale, 0.0002);
-    EXPECT_EQ(dev_model.power_microwatts, accel.power_microwatts);
     EXPECT_EQ(dev_model.max_range, accel.max_range);
 
     EXPECT_EQ(dev_model.sampling_freq_avl.size(), accel.sampling_freq_avl.size());