sensor: a global sensor mutex for message transfer

Change-Id: I49f9506634aeb2d87cc24b931c186a8d24e25161
Signed-off-by: Jinhyung Choi <jinhyung2.choi@samsung.com>

diff --git a/drivers/maru/sensors/maru_accel.c b/drivers/maru/sensors/maru_accel.c
index 3bba6bb..34db914 100644 (file)
--- a/drivers/maru/sensors/maru_accel.c
+++ b/drivers/maru/sensors/maru_accel.c
@@ -27,16 +27,13 @@
  *
  */
 
-#include <linux/kernel.h>
 #include <linux/slab.h>
-#include <linux/limits.h>
 
 #include "maru_virtio_sensor.h"
 
 struct maru_accel_data {
        struct input_dev *input_data;
        struct delayed_work work;
-       struct mutex data_mutex;
 
        struct virtio_sensor* vs;
 
@@ -73,17 +70,15 @@ static void maru_accel_input_work_func(struct work_struct *work) {
 
        LOG(1, "maru_accel_input_work_func starts");
 
-       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       enable = atomic_read(&data->enable);
        poll_time = atomic_read(&data->poll_delay);
 
-       mutex_lock(&data->data_mutex);
-       enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
 
        if (enable) {
-               mutex_lock(&data->data_mutex);
+               mutex_lock(&data->vs->vqlock);
                ret = get_sensor_data(sensor_type_accel, sensor_data);
-               mutex_unlock(&data->data_mutex);
+               mutex_unlock(&data->vs->vqlock);
                if (!ret) {
                        sscanf(sensor_data, "%d,%d,%d", &accel_x, &accel_y, &accel_z);
                        LOG(1, "accel_set act %d, %d, %d", accel_x, accel_y, accel_z);
@@ -111,9 +106,7 @@ static void maru_accel_input_work_func(struct work_struct *work) {
                }
        }
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        LOG(1, "enable: %d, poll_time: %d", enable, poll_time);
        if (enable) {
@@ -140,7 +133,19 @@ static ssize_t maru_vendor_show(struct device *dev, struct device_attribute *att
 
 static ssize_t maru_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_accel_enable, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_accel_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_accel_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -152,7 +157,9 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
        if (value != 0 && value != 1)
                return count;
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_accel_enable, buf);
+       mutex_unlock(&data->vs->vqlock);
 
        if (value) {
                if (atomic_read(&data->enable) != 1) {
@@ -172,7 +179,19 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
 
 static ssize_t maru_poll_delay_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_accel_delay, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_accel_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_accel_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -181,7 +200,12 @@ static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute
        struct maru_accel_data *data = input_get_drvdata(input_data);
        int value = simple_strtoul(buf, NULL, 10);
 
+       if (value < __MIN_DELAY_SENSOR)
+               return count;
+
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_accel_delay, buf);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->poll_delay, value);
 
        return strnlen(buf, __MAX_BUF_SENSOR);
@@ -209,12 +233,28 @@ static ssize_t accel_name_show(struct device *dev, struct device_attribute *attr
 
 static ssize_t xyz_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_accel, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_accel_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_accel, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t xyz_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_accel_data *data = input_get_drvdata(input_data);
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_accel, buf);
+       mutex_unlock(&data->vs->vqlock);
        return strnlen(buf, __MAX_BUF_SENSOR);
 }
 
@@ -285,7 +325,9 @@ static int set_initial_value(struct maru_accel_data *data)
        memset(sensor_data, 0, sizeof(sensor_data));
        sensor_data[0] = '0';
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_accel_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->enable, 0);
 
        return ret;
@@ -349,8 +391,6 @@ int maru_accel_init(struct virtio_sensor *vs) {
        vs->accel_handle = data;
        data->vs = vs;
 
-       mutex_init(&data->data_mutex);
-
        INIT_DELAYED_WORK(&data->work, maru_accel_input_work_func);
 
        // create name & vendor

diff --git a/drivers/maru/sensors/maru_geo.c b/drivers/maru/sensors/maru_geo.c
index 3d5ac70..5f230b8 100644 (file)
--- a/drivers/maru/sensors/maru_geo.c
+++ b/drivers/maru/sensors/maru_geo.c
@@ -35,7 +35,6 @@
 struct maru_geo_data {
        struct input_dev *input_data;
        struct delayed_work work;
-       struct mutex data_mutex;
 
        struct virtio_sensor* vs;
 
@@ -67,17 +66,15 @@ static void maru_geo_input_work_func(struct work_struct *work) {
 
        LOG(1, "maru_geo_input_work_func starts");
 
-       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       enable = atomic_read(&data->enable);
        poll_time = atomic_read(&data->poll_delay);
 
-       mutex_lock(&data->data_mutex);
-       enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
 
        if (enable) {
-               mutex_lock(&data->data_mutex);
+               mutex_lock(&data->vs->vqlock);
                ret = get_sensor_data(sensor_type_mag, sensor_data);
-               mutex_unlock(&data->data_mutex);
+               mutex_unlock(&data->vs->vqlock);
                if (!ret) {
                        sscanf(sensor_data, "%d %d %d", &geo_x, &geo_y, &geo_z);
                        LOG(1, "geo_set act %d, %d, %d", geo_x, geo_y, geo_z);
@@ -106,9 +103,7 @@ static void maru_geo_input_work_func(struct work_struct *work) {
                }
        }
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        LOG(1, "enable: %d, poll_time: %d", enable, poll_time);
        if (enable) {
@@ -135,7 +130,19 @@ static ssize_t maru_vendor_show(struct device *dev, struct device_attribute *att
 
 static ssize_t maru_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_geo_enable, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_geo_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_geo_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -147,13 +154,14 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
        if (value != 0 && value != 1)
                return count;
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_geo_enable, buf);
+       mutex_unlock(&data->vs->vqlock);
 
        if (value) {
                if (atomic_read(&data->enable) != 1) {
                        atomic_set(&data->enable, 1);
                        schedule_delayed_work(&data->work, 0);
-
                }
        } else {
                if (atomic_read(&data->enable) != 0) {
@@ -167,7 +175,19 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
 
 static ssize_t maru_poll_delay_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_geo_delay, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_geo_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_geo_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -176,7 +196,12 @@ static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute
        struct maru_geo_data *data = input_get_drvdata(input_data);
        int value = simple_strtoul(buf, NULL, 10);
 
+       if (value < __MIN_DELAY_SENSOR)
+               return count;
+
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_geo_delay, buf);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->poll_delay, value);
 
        return strnlen(buf, __MAX_BUF_SENSOR);
@@ -204,23 +229,55 @@ static ssize_t geo_name_show(struct device *dev, struct device_attribute *attr,
 
 static ssize_t raw_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_tilt, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_geo_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_tilt, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t raw_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_geo_data *data = input_get_drvdata(input_data);
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_tilt, buf);
+       mutex_unlock(&data->vs->vqlock);
        return strnlen(buf, __MAX_BUF_SENSOR);
 }
 
 static ssize_t tesla_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_mag, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_geo_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_mag, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t tesla_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_geo_data *data = input_get_drvdata(input_data);
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_mag, buf);
+       mutex_unlock(&data->vs->vqlock);
        return strnlen(buf, __MAX_BUF_SENSOR);
 }
 
@@ -276,7 +333,9 @@ static int set_initial_value(struct maru_geo_data *data)
 
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_geo_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial delay time");
                return ret;
@@ -292,7 +351,9 @@ static int set_initial_value(struct maru_geo_data *data)
 
        memset(sensor_data, 0, sizeof(sensor_data));
        sensor_data[0] = '0';
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_geo_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->enable, 0);
 
        return ret;
@@ -357,8 +418,6 @@ int maru_geo_init(struct virtio_sensor *vs) {
        vs->geo_handle = data;
        data->vs = vs;
 
-       mutex_init(&data->data_mutex);
-
        INIT_DELAYED_WORK(&data->work, maru_geo_input_work_func);
 
        // create name & vendor

diff --git a/drivers/maru/sensors/maru_gyro.c b/drivers/maru/sensors/maru_gyro.c
index d43258b..083d85f 100644 (file)
--- a/drivers/maru/sensors/maru_gyro.c
+++ b/drivers/maru/sensors/maru_gyro.c
@@ -35,7 +35,6 @@
 struct maru_gyro_data {
        struct input_dev *input_data;
        struct delayed_work work;
-       struct mutex data_mutex;
 
        struct virtio_sensor* vs;
 
@@ -65,17 +64,15 @@ static void maru_gyro_input_work_func(struct work_struct *work) {
 
        LOG(1, "maru_gyro_input_work_func starts");
 
-       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       enable = atomic_read(&data->enable);
        poll_time = atomic_read(&data->poll_delay);
 
-       mutex_lock(&data->data_mutex);
-       enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
 
        if (enable) {
-               mutex_lock(&data->data_mutex);
+               mutex_lock(&data->vs->vqlock);
                ret = get_sensor_data(sensor_type_gyro, sensor_data);
-               mutex_unlock(&data->data_mutex);
+               mutex_unlock(&data->vs->vqlock);
                if (!ret) {
                        sscanf(sensor_data, "%d,%d,%d", &gyro_x, &gyro_y, &gyro_z);
                        LOG(1, "gyro_set act %d, %d, %d", gyro_x, gyro_y, gyro_z);
@@ -102,9 +99,7 @@ static void maru_gyro_input_work_func(struct work_struct *work) {
                }
        }
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        LOG(1, "enable: %d, poll_time: %d", enable, poll_time);
        if (enable) {
@@ -116,7 +111,6 @@ static void maru_gyro_input_work_func(struct work_struct *work) {
        }
 
        LOG(1, "maru_gyro_input_work_func ends");
-
 }
 
 static ssize_t maru_name_show(struct device *dev, struct device_attribute *attr, char *buf)
@@ -131,7 +125,19 @@ static ssize_t maru_vendor_show(struct device *dev, struct device_attribute *att
 
 static ssize_t maru_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_gyro_enable, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_gyro_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_gyro_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -143,7 +149,9 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
        if (value != 0 && value != 1)
                return count;
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_gyro_enable, buf);
+       mutex_unlock(&data->vs->vqlock);
 
        if (value) {
                if (atomic_read(&data->enable) != 1) {
@@ -163,7 +171,19 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
 
 static ssize_t maru_poll_delay_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_gyro_delay, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_gyro_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_gyro_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -172,7 +192,12 @@ static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute
        struct maru_gyro_data *data = input_get_drvdata(input_data);
        int value = simple_strtoul(buf, NULL, 10);
 
+       if (value < __MIN_DELAY_SENSOR)
+               return count;
+
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_gyro_delay, buf);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->poll_delay, value);
 
        return strnlen(buf, __MAX_BUF_SENSOR);
@@ -200,34 +225,82 @@ static ssize_t gyro_name_show(struct device *dev, struct device_attribute *attr,
 
 static ssize_t gyro_x_raw_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_gyro_x, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_gyro_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_gyro_x, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t gyro_x_raw_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_gyro_data *data = input_get_drvdata(input_data);
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_gyro_x, buf);
+       mutex_unlock(&data->vs->vqlock);
        return strnlen(buf, __MAX_BUF_SENSOR);
 }
 
 static ssize_t gyro_y_raw_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_gyro_y, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_gyro_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_gyro_y, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t gyro_y_raw_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_gyro_data *data = input_get_drvdata(input_data);
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_gyro_y, buf);
+       mutex_unlock(&data->vs->vqlock);
        return strnlen(buf, __MAX_BUF_SENSOR);
 }
 
 static ssize_t gyro_z_raw_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_gyro_z, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_gyro_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_gyro_z, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t gyro_z_raw_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_gyro_data *data = input_get_drvdata(input_data);
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_gyro_z, buf);
+       mutex_unlock(&data->vs->vqlock);
        return strnlen(buf, __MAX_BUF_SENSOR);
 }
 
@@ -285,7 +358,9 @@ static int set_initial_value(struct maru_gyro_data *data)
 
        memset(sensor_data, 0, sizeof(sensor_data));
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_gyro_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial delay time");
                return ret;
@@ -302,7 +377,9 @@ static int set_initial_value(struct maru_gyro_data *data)
        memset(sensor_data, 0, sizeof(sensor_data));
        sensor_data[0] = '0';
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_gyro_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->enable, 0);
 
        return ret;
@@ -366,8 +443,6 @@ int maru_gyro_init(struct virtio_sensor *vs) {
        vs->gyro_handle = data;
        data->vs = vs;
 
-       mutex_init(&data->data_mutex);
-
        INIT_DELAYED_WORK(&data->work, maru_gyro_input_work_func);
 
        // create name & vendor

diff --git a/drivers/maru/sensors/maru_hrm.c b/drivers/maru/sensors/maru_hrm.c
index 431b4c0..2a79ac4 100644 (file)
--- a/drivers/maru/sensors/maru_hrm.c
+++ b/drivers/maru/sensors/maru_hrm.c
@@ -35,7 +35,6 @@
 struct maru_hrm_data {
        struct input_dev *input_data;
        struct delayed_work work;
-       struct mutex data_mutex;
 
        struct virtio_sensor* vs;
 
@@ -60,14 +59,12 @@ static void maru_hrm_input_work_func(struct work_struct *work) {
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
        poll_time = atomic_read(&data->poll_delay);
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        if (enable) {
-               mutex_lock(&data->data_mutex);
+               mutex_lock(&data->vs->vqlock);
                ret = get_sensor_data(sensor_type_hrm, sensor_data);
-               mutex_unlock(&data->data_mutex);
+               mutex_unlock(&data->vs->vqlock);
                if (!ret) {
                        sscanf(sensor_data, "%d, %d", &hrm, &rri);
                        LOG(1, "hrm_set %d %d", hrm, rri);
@@ -79,9 +76,7 @@ static void maru_hrm_input_work_func(struct work_struct *work) {
                }
        }
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        LOG(1, "enable: %d, poll_time: %d", enable, poll_time);
        if (enable) {
@@ -108,7 +103,19 @@ static ssize_t maru_vendor_show(struct device *dev, struct device_attribute *att
 
 static ssize_t maru_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_hrm_enable, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_hrm_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_hrm_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -120,7 +127,9 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
        if (value != 0 && value != 1)
                return count;
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_hrm_enable, buf);
+       mutex_unlock(&data->vs->vqlock);
 
        if (value) {
                if (atomic_read(&data->enable) != 1) {
@@ -140,7 +149,19 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
 
 static ssize_t maru_poll_delay_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_hrm_delay, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_hrm_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_hrm_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -149,7 +170,12 @@ static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute
        struct maru_hrm_data *data = input_get_drvdata(input_data);
        int value = simple_strtoul(buf, NULL, 10);
 
+       if (value < __MIN_DELAY_SENSOR)
+               return count;
+
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_hrm_delay, buf);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->poll_delay, value);
 
        return strnlen(buf, __MAX_BUF_SENSOR);
@@ -206,7 +232,9 @@ static int set_initial_value(struct maru_hrm_data *data)
 
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_hrm_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial delay time");
                return ret;
@@ -214,7 +242,9 @@ static int set_initial_value(struct maru_hrm_data *data)
 
        delay = sensor_atoi(sensor_data);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_hrm_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial enable");
                return ret;
@@ -294,8 +324,6 @@ int maru_hrm_init(struct virtio_sensor *vs) {
        vs->hrm_handle = data;
        data->vs = vs;
 
-       mutex_init(&data->data_mutex);
-
        INIT_DELAYED_WORK(&data->work, maru_hrm_input_work_func);
 
        // create name & vendor

diff --git a/drivers/maru/sensors/maru_light.c b/drivers/maru/sensors/maru_light.c
index ecb6f98..4abd7b5 100644 (file)
--- a/drivers/maru/sensors/maru_light.c
+++ b/drivers/maru/sensors/maru_light.c
@@ -35,7 +35,6 @@
 struct maru_light_data {
        struct input_dev *input_data;
        struct delayed_work work;
-       struct mutex data_mutex;
 
        struct virtio_sensor* vs;
 
@@ -64,14 +63,12 @@ static void maru_light_input_work_func(struct work_struct *work) {
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
        poll_time = atomic_read(&data->poll_delay);
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        if (enable) {
-               mutex_lock(&data->data_mutex);
+               mutex_lock(&data->vs->vqlock);
                ret = get_sensor_data(sensor_type_light, sensor_data);
-               mutex_unlock(&data->data_mutex);
+               mutex_unlock(&data->vs->vqlock);
                if (!ret) {
                        sscanf(sensor_data, "%d", &light);
                        LOG(1, "light_set %d", light);
@@ -85,9 +82,7 @@ static void maru_light_input_work_func(struct work_struct *work) {
                }
        }
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        LOG(1, "enable: %d, poll_time: %d", enable, poll_time);
        if (enable) {
@@ -114,7 +109,19 @@ static ssize_t maru_vendor_show(struct device *dev, struct device_attribute *att
 
 static ssize_t maru_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_light_enable, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_light_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_light_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -126,7 +133,9 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
        if (value != 0 && value != 1)
                return count;
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_light_enable, buf);
+       mutex_unlock(&data->vs->vqlock);
 
        if (value) {
                if (atomic_read(&data->enable) != 1) {
@@ -146,7 +155,19 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
 
 static ssize_t maru_poll_delay_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_light_delay, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_light_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_light_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -155,7 +176,12 @@ static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute
        struct maru_light_data *data = input_get_drvdata(input_data);
        int value = simple_strtoul(buf, NULL, 10);
 
+       if (value < __MIN_DELAY_SENSOR)
+               return count;
+
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_light_delay, buf);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->poll_delay, value);
 
        return strnlen(buf, __MAX_BUF_SENSOR);
@@ -183,23 +209,55 @@ static ssize_t light_name_show(struct device *dev, struct device_attribute *attr
 
 static ssize_t adc_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_light_adc, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_light_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_light_adc, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t adc_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_light_data *data = input_get_drvdata(input_data);
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_light_adc, buf);
+       mutex_unlock(&data->vs->vqlock);
        return strnlen(buf, __MAX_BUF_SENSOR);
 }
 
 static ssize_t level_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_light_level, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_light_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_light_level, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t level_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_light_data *data = input_get_drvdata(input_data);
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_light_level, buf);
+       mutex_unlock(&data->vs->vqlock);
        return strnlen(buf, __MAX_BUF_SENSOR);
 }
 
@@ -256,7 +314,9 @@ static int set_initial_value(struct maru_light_data *data)
 
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_light_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial delay time");
                return ret;
@@ -264,7 +324,9 @@ static int set_initial_value(struct maru_light_data *data)
 
        delay = sensor_atoi(sensor_data);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_light_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial enable");
                return ret;
@@ -346,8 +408,6 @@ int maru_light_init(struct virtio_sensor *vs) {
        vs->light_handle = data;
        data->vs = vs;
 
-       mutex_init(&data->data_mutex);
-
        INIT_DELAYED_WORK(&data->work, maru_light_input_work_func);
 
        // create name & vendor

diff --git a/drivers/maru/sensors/maru_pressure.c b/drivers/maru/sensors/maru_pressure.c
index 1b84f57..18a450e 100644 (file)
--- a/drivers/maru/sensors/maru_pressure.c
+++ b/drivers/maru/sensors/maru_pressure.c
@@ -35,7 +35,6 @@
 struct maru_pressure_data {
        struct input_dev *input_data;
        struct delayed_work work;
-       struct mutex data_mutex;
 
        struct virtio_sensor* vs;
 
@@ -77,14 +76,12 @@ static void maru_pressure_input_work_func(struct work_struct *work) {
        memset(sensor_data, 0, sizeof(sensor_data));
        poll_time = atomic_read(&data->poll_delay);
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        if (enable) {
-               mutex_lock(&data->data_mutex);
+               mutex_lock(&data->vs->vqlock);
                ret = get_sensor_data(sensor_type_pressure, sensor_data);
-               mutex_unlock(&data->data_mutex);
+               mutex_unlock(&data->vs->vqlock);
                if (!ret) {
                        sscanf(sensor_data, "%d, %d", &pressure, &temperature);
                        LOG(1, "pressure_set %d, %d", pressure, temperature);
@@ -104,9 +101,7 @@ static void maru_pressure_input_work_func(struct work_struct *work) {
                }
        }
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        LOG(1, "enable: %d, poll_time: %d", enable, poll_time);
        if (enable) {
@@ -133,7 +128,19 @@ static ssize_t maru_vendor_show(struct device *dev, struct device_attribute *att
 
 static ssize_t maru_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_pressure_enable, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_pressure_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_pressure_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -145,7 +152,9 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
        if (value != 0 && value != 1)
                return count;
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_pressure_enable, buf);
+       mutex_unlock(&data->vs->vqlock);
 
        if (value) {
                if (atomic_read(&data->enable) != 1) {
@@ -165,7 +174,19 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
 
 static ssize_t maru_poll_delay_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_pressure_delay, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_pressure_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_pressure_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -174,7 +195,12 @@ static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute
        struct maru_pressure_data *data = input_get_drvdata(input_data);
        int value = simple_strtoul(buf, NULL, 10);
 
+       if (value < __MIN_DELAY_SENSOR)
+               return count;
+
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_pressure_delay, buf);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->poll_delay, value);
 
        return strnlen(buf, __MAX_BUF_SENSOR);
@@ -231,7 +257,9 @@ static int set_initial_value(struct maru_pressure_data *data)
 
        memset(sensor_data, 0, sizeof(sensor_data));
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_pressure_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial delay time");
                return ret;
@@ -239,7 +267,9 @@ static int set_initial_value(struct maru_pressure_data *data)
 
        delay = sensor_atoi(sensor_data);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_pressure_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial enable");
                return ret;
@@ -319,8 +349,6 @@ int maru_pressure_init(struct virtio_sensor *vs) {
        vs->pressure_handle = data;
        data->vs = vs;
 
-       mutex_init(&data->data_mutex);
-
        INIT_DELAYED_WORK(&data->work, maru_pressure_input_work_func);
 
        // create name & vendor

diff --git a/drivers/maru/sensors/maru_proxi.c b/drivers/maru/sensors/maru_proxi.c
index 1c9d13d..aa14f82 100644 (file)
--- a/drivers/maru/sensors/maru_proxi.c
+++ b/drivers/maru/sensors/maru_proxi.c
@@ -35,7 +35,6 @@
 struct maru_proxi_data {
        struct input_dev *input_data;
        struct delayed_work work;
-       struct mutex data_mutex;
 
        struct virtio_sensor* vs;
 
@@ -64,14 +63,12 @@ static void maru_proxi_input_work_func(struct work_struct *work) {
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
        poll_time = atomic_read(&data->poll_delay);
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        if (enable) {
-               mutex_lock(&data->data_mutex);
+               mutex_lock(&data->vs->vqlock);
                ret = get_sensor_data(sensor_type_proxi, sensor_data);
-               mutex_unlock(&data->data_mutex);
+               mutex_unlock(&data->vs->vqlock);
                if (!ret) {
                        sscanf(sensor_data, "%d", &proxi);
                        if (!proxi)
@@ -86,9 +83,7 @@ static void maru_proxi_input_work_func(struct work_struct *work) {
                }
        }
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        LOG(1, "enable: %d, poll_time: %d", enable, poll_time);
        if (enable) {
@@ -115,7 +110,19 @@ static ssize_t maru_vendor_show(struct device *dev, struct device_attribute *att
 
 static ssize_t maru_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_proxi_enable, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_proxi_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_proxi_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -127,7 +134,9 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
        if (value != 0 && value != 1)
                return count;
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_proxi_enable, buf);
+       mutex_unlock(&data->vs->vqlock);
 
        if (value) {
                if (atomic_read(&data->enable) != 1) {
@@ -147,7 +156,19 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
 
 static ssize_t maru_poll_delay_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_proxi_delay, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_proxi_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_proxi_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -156,7 +177,12 @@ static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute
        struct maru_proxi_data *data = input_get_drvdata(input_data);
        int value = simple_strtoul(buf, NULL, 10);
 
+       if (value < __MIN_DELAY_SENSOR)
+               return count;
+
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_proxi_delay, buf);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->poll_delay, value);
 
        return strnlen(buf, __MAX_BUF_SENSOR);
@@ -184,23 +210,55 @@ static ssize_t proxi_name_show(struct device *dev, struct device_attribute *attr
 
 static ssize_t enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_proxi_enable, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_proxi_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_proxi_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_proxi_data *data = input_get_drvdata(input_data);
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_proxi_enable, buf);
+       mutex_unlock(&data->vs->vqlock);
        return strnlen(buf, __MAX_BUF_SENSOR);
 }
 
 static ssize_t vo_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_proxi, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_proxi_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_proxi, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t vo_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
 {
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_proxi_data *data = input_get_drvdata(input_data);
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_proxi, buf);
+       mutex_unlock(&data->vs->vqlock);
        return strnlen(buf, __MAX_BUF_SENSOR);
 }
 
@@ -257,7 +315,9 @@ static int set_initial_value(struct maru_proxi_data *data)
 
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_proxi_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial delay time");
                return ret;
@@ -265,7 +325,9 @@ static int set_initial_value(struct maru_proxi_data *data)
 
        delay = sensor_atoi(sensor_data);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_proxi_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial enable");
                return ret;
@@ -343,8 +405,6 @@ int maru_proxi_init(struct virtio_sensor *vs) {
        vs->proxi_handle = data;
        data->vs = vs;
 
-       mutex_init(&data->data_mutex);
-
        INIT_DELAYED_WORK(&data->work, maru_proxi_input_work_func);
 
        // create name & vendor

diff --git a/drivers/maru/sensors/maru_rotation_vector.c b/drivers/maru/sensors/maru_rotation_vector.c
index 7757c6c..ef03aa0 100644 (file)
--- a/drivers/maru/sensors/maru_rotation_vector.c
+++ b/drivers/maru/sensors/maru_rotation_vector.c
@@ -35,7 +35,6 @@
 struct maru_rotation_vector_data {
        struct input_dev *input_data;
        struct delayed_work work;
-       struct mutex data_mutex;
 
        struct virtio_sensor* vs;
 
@@ -60,14 +59,12 @@ static void maru_rotation_vector_input_work_func(struct work_struct *work) {
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
        poll_time = atomic_read(&data->poll_delay);
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        if (enable) {
-               mutex_lock(&data->data_mutex);
+               mutex_lock(&data->vs->vqlock);
                ret = get_sensor_data(sensor_type_rotation_vector, sensor_data);
-               mutex_unlock(&data->data_mutex);
+               mutex_unlock(&data->vs->vqlock);
                if (!ret) {
                        sscanf(sensor_data, "%d,%d,%d,%d,%d", &quad_a, &quad_b, &quad_c, &quad_d, &accuracy);
                        LOG(1, "rotation_vector_set %d,%d,%d,%d,%d", quad_a, quad_b, quad_c, quad_d, accuracy);
@@ -81,9 +78,7 @@ static void maru_rotation_vector_input_work_func(struct work_struct *work) {
                }
        }
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        LOG(1, "enable: %d, poll_time: %d", enable, poll_time);
        if (enable) {
@@ -110,7 +105,19 @@ static ssize_t maru_vendor_show(struct device *dev, struct device_attribute *att
 
 static ssize_t maru_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_rotation_vector_enable, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_rotation_vector_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_rotation_vector_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -122,7 +129,9 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
        if (value != 0 && value != 1)
                return count;
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_rotation_vector_enable, buf);
+       mutex_unlock(&data->vs->vqlock);
 
        if (value) {
                if (atomic_read(&data->enable) != 1) {
@@ -142,7 +151,19 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
 
 static ssize_t maru_poll_delay_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_rotation_vector_delay, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_rotation_vector_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_rotation_vector_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -151,7 +172,12 @@ static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute
        struct maru_rotation_vector_data *data = input_get_drvdata(input_data);
        int value = simple_strtoul(buf, NULL, 10);
 
+       if (value < __MIN_DELAY_SENSOR)
+               return count;
+
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_rotation_vector_delay, buf);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->poll_delay, value);
 
        return strnlen(buf, __MAX_BUF_SENSOR);
@@ -207,7 +233,9 @@ static int set_initial_value(struct maru_rotation_vector_data *data)
 
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_rotation_vector_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial delay time");
                return ret;
@@ -223,7 +251,9 @@ static int set_initial_value(struct maru_rotation_vector_data *data)
 
        memset(sensor_data, 0, sizeof(sensor_data));
        sensor_data[0] = '0';
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_rotation_vector_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->enable, 0);
 
        return ret;
@@ -289,8 +319,6 @@ int maru_rotation_vector_init(struct virtio_sensor *vs) {
        vs->rotation_vector_handle = data;
        data->vs = vs;
 
-       mutex_init(&data->data_mutex);
-
        INIT_DELAYED_WORK(&data->work, maru_rotation_vector_input_work_func);
 
        // create name & vendor

diff --git a/drivers/maru/sensors/maru_uv.c b/drivers/maru/sensors/maru_uv.c
index 2c6037d..bf45384 100644 (file)
--- a/drivers/maru/sensors/maru_uv.c
+++ b/drivers/maru/sensors/maru_uv.c
@@ -35,7 +35,6 @@
 struct maru_uv_data {
        struct input_dev *input_data;
        struct delayed_work work;
-       struct mutex data_mutex;
 
        struct virtio_sensor* vs;
 
@@ -60,14 +59,12 @@ static void maru_uv_input_work_func(struct work_struct *work) {
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
        poll_time = atomic_read(&data->poll_delay);
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        if (enable) {
-               mutex_lock(&data->data_mutex);
+               mutex_lock(&data->vs->vqlock);
                ret = get_sensor_data(sensor_type_uv, sensor_data);
-               mutex_unlock(&data->data_mutex);
+               mutex_unlock(&data->vs->vqlock);
                if (!ret) {
                        sscanf(sensor_data, "%d", &uv);
                        LOG(1, "uv_set %d", uv);
@@ -77,9 +74,7 @@ static void maru_uv_input_work_func(struct work_struct *work) {
                }
        }
 
-       mutex_lock(&data->data_mutex);
        enable = atomic_read(&data->enable);
-       mutex_unlock(&data->data_mutex);
 
        LOG(1, "enable: %d, poll_time: %d", enable, poll_time);
        if (enable) {
@@ -106,7 +101,19 @@ static ssize_t maru_vendor_show(struct device *dev, struct device_attribute *att
 
 static ssize_t maru_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_uv_enable, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_uv_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_uv_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -118,7 +125,9 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
        if (value != 0 && value != 1)
                return count;
 
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_uv_enable, buf);
+       mutex_unlock(&data->vs->vqlock);
 
        if (value) {
                if (atomic_read(&data->enable) != 1) {
@@ -138,7 +147,19 @@ static ssize_t maru_enable_store(struct device *dev, struct device_attribute *at
 
 static ssize_t maru_poll_delay_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       return get_data_for_show(sensor_type_uv_delay, buf);
+       char sensor_data[__MAX_BUF_SENSOR];
+       int ret;
+       struct input_dev *input_data = to_input_dev(dev);
+       struct maru_uv_data *data = input_get_drvdata(input_data);
+
+       memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&data->vs->vqlock);
+       ret = get_sensor_data(sensor_type_uv_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
+       if (ret)
+               return sprintf(buf, "%d", -1);
+
+       return sprintf(buf, "%s", sensor_data);
 }
 
 static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
@@ -147,7 +168,12 @@ static ssize_t maru_poll_delay_store(struct device *dev, struct device_attribute
        struct maru_uv_data *data = input_get_drvdata(input_data);
        int value = simple_strtoul(buf, NULL, 10);
 
+       if (value < __MIN_DELAY_SENSOR)
+               return count;
+
+       mutex_lock(&data->vs->vqlock);
        set_sensor_data(sensor_type_uv_delay, buf);
+       mutex_unlock(&data->vs->vqlock);
        atomic_set(&data->poll_delay, value);
 
        return strnlen(buf, __MAX_BUF_SENSOR);
@@ -204,7 +230,9 @@ static int set_initial_value(struct maru_uv_data *data)
 
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_uv_delay, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial delay time");
                return ret;
@@ -212,7 +240,9 @@ static int set_initial_value(struct maru_uv_data *data)
 
        delay = sensor_atoi(sensor_data);
 
+       mutex_lock(&data->vs->vqlock);
        ret = get_sensor_data(sensor_type_uv_enable, sensor_data);
+       mutex_unlock(&data->vs->vqlock);
        if (ret) {
                ERR("failed to get initial enable");
                return ret;
@@ -290,8 +320,6 @@ int maru_uv_init(struct virtio_sensor *vs) {
        vs->uv_handle = data;
        data->vs = vs;
 
-       mutex_init(&data->data_mutex);
-
        INIT_DELAYED_WORK(&data->work, maru_uv_input_work_func);
 
        // create name & vendor

diff --git a/drivers/maru/sensors/maru_virtio_sensor.c b/drivers/maru/sensors/maru_virtio_sensor.c
index d47bf58..0f1fd3a 100644 (file)
--- a/drivers/maru/sensors/maru_virtio_sensor.c
+++ b/drivers/maru/sensors/maru_virtio_sensor.c
@@ -159,9 +159,9 @@ static void sensor_vq_done(struct virtqueue *rvq) {
                return;
        }
 
-       LOG(1, "msg buf: %s, req: %d, type: %d", msg->buf, msg->req, msg->type);
-
        mutex_lock(&vs->lock);
+       LOG(1, "msg buf: %s, req: %d, type: %d, vs->flags: %d", msg->buf, msg->req, msg->type, vs->flags);
+
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
        strcpy(sensor_data, msg->buf);
        vs->flags = 1;
@@ -190,12 +190,13 @@ void set_sensor_data(int type, const char* buf)
        vs->msginfo.req = request_set;
        vs->msginfo.type = type;
        strcpy(vs->msginfo.buf, buf);
-       mutex_unlock(&vs->lock);
 
        LOG(1, "set_sensor_data type: %d, req: %d, buf: %s",
                        vs->msginfo.type, vs->msginfo.req, vs->msginfo.buf);
 
-       err = virtqueue_add_outbuf(vs->vq, vs->sg_vq, 1, &vs->msginfo, GFP_ATOMIC);
+       mutex_unlock(&vs->lock);
+
+       err = virtqueue_add_outbuf(vs->vq, vs->sg_vq, 1, &vs->msginfo, GFP_NOWAIT);//GFP_ATOMIC);
        if (err < 0) {
                ERR("failed to add buffer to virtqueue (err = %d)", err);
                return;
@@ -219,14 +220,15 @@ int get_sensor_data(int type, char* data)
 
        vs->msginfo.req = request_get;
        vs->msginfo.type = type;
-       mutex_unlock(&vs->lock);
 
-       LOG(1, "get_sensor_data type: %d, req: %d",
+       LOG(1, "get_sensor_data start type: %d, req: %d",
                        vs->msginfo.type, vs->msginfo.req);
 
        sgs[0] = &vs->sg_vq[0];
        sgs[1] = &vs->sg_vq[1];
-       err = virtqueue_add_sgs(vs->vq, sgs, 1, 1, &vs->msginfo, GFP_ATOMIC);
+       mutex_unlock(&vs->lock);
+
+       err = virtqueue_add_sgs(vs->vq, sgs, 1, 1, &vs->msginfo, GFP_NOWAIT);//GFP_ATOMIC);
        if (err < 0) {
                ERR("failed to add buffer to virtqueue (err = %d)", err);
                return err;
@@ -241,22 +243,10 @@ int get_sensor_data(int type, char* data)
        memcpy(data, sensor_data, strlen(sensor_data));
        mutex_unlock(&vs->lock);
 
+       LOG(1, "get_sensor_data end type: %d, data: %p", type, data);
        return 0;
 }
 
-int get_data_for_show(int type, char* buf)
-{
-       char sensor_data[__MAX_BUF_SENSOR];
-       int ret;
-
-       memset(sensor_data, 0, __MAX_BUF_SENSOR);
-       ret = get_sensor_data(type, sensor_data);
-       if (ret)
-               return sprintf(buf, "%d", -1);
-
-       return sprintf(buf, "%s", sensor_data);
-}
-
 static void device_init(struct virtio_sensor *vs)
 {
        int ret = 0;
@@ -463,9 +453,12 @@ static int sensor_probe(struct virtio_device* dev)
        }
 
        mutex_init(&vs->lock);
+       mutex_init(&vs->vqlock);
 
        memset(sensor_data, 0, __MAX_BUF_SENSOR);
+       mutex_lock(&vs->vqlock);
        ret = get_sensor_data(sensor_type_list, sensor_data);
+       mutex_unlock(&vs->vqlock);
        if (ret) {
                ERR("sensor capability data is null.");
                cleanup(dev);

diff --git a/drivers/maru/sensors/maru_virtio_sensor.h b/drivers/maru/sensors/maru_virtio_sensor.h
index 06533bc..a34c6c0 100644 (file)
--- a/drivers/maru/sensors/maru_virtio_sensor.h
+++ b/drivers/maru/sensors/maru_virtio_sensor.h
@@ -33,6 +33,7 @@
 #include <linux/kernel.h>
 #include <linux/virtio.h>
 #include <linux/input.h>
+#include <linux/limits.h>
 
 #define SUPPORT_LEGACY_SENSOR  1
 
@@ -97,7 +98,10 @@ enum sensor_capabilities {
 };
 
 #define __MAX_BUF_SIZE                 1024
-#define __MAX_BUF_SENSOR               128
+#define __MAX_BUF_SENSOR               32
+
+#define __MIN_DELAY_SENSOR             1000000
+#define __MAX_DELAY_SENSOR             INT_MAX
 
 struct msg_info {
        char buf[__MAX_BUF_SIZE];
@@ -119,6 +123,7 @@ struct virtio_sensor {
 
        int flags;
        struct mutex lock;
+       struct mutex vqlock;
 
        struct class* sensor_class;
 
@@ -157,7 +162,6 @@ struct virtio_sensor {
 
 int sensor_atoi(const char *value);
 
-int get_data_for_show(int type, char* buf);
 int register_sensor_device(struct device *dev, struct virtio_sensor *vs,
                struct device_attribute *attributes[], const char* name);