From: Jinhyung Choi Date: Thu, 12 Mar 2015 02:50:00 +0000 (+0900) Subject: sensor: a global sensor mutex for message transfer X-Git-Tag: submit/tizen/20160422.055611~1^2~86 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=e763f30c3d8db808e99d02eaf4bea48beccb65d9;p=sdk%2Femulator%2Femulator-kernel.git sensor: a global sensor mutex for message transfer Change-Id: I49f9506634aeb2d87cc24b931c186a8d24e25161 Signed-off-by: Jinhyung Choi --- diff --git a/drivers/maru/sensors/maru_accel.c b/drivers/maru/sensors/maru_accel.c index 3bba6bb05a88..34db914e36b0 100644 --- a/drivers/maru/sensors/maru_accel.c +++ b/drivers/maru/sensors/maru_accel.c @@ -27,16 +27,13 @@ * */ -#include #include -#include #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 3d5ac703e217..5f230b86f7bf 100644 --- 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 d43258b676fa..083d85f532fa 100644 --- 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 431b4c0bc93b..2a79ac4cd662 100644 --- 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 ecb6f98266ec..4abd7b56b75a 100644 --- 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 1b84f570d108..18a450e17230 100644 --- 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 1c9d13d33b19..aa14f82361cc 100644 --- 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 7757c6c0de7a..ef03aa04247a 100644 --- 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 2c6037d62bf0..bf453849003f 100644 --- 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 d47bf58bd5ee..0f1fd3a6e951 100644 --- 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 06533bcba68b..a34c6c00cbcd 100644 --- a/drivers/maru/sensors/maru_virtio_sensor.h +++ b/drivers/maru/sensors/maru_virtio_sensor.h @@ -33,6 +33,7 @@ #include #include #include +#include #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);