/*
- * sensord
+ * gyro_sensor_hal
*
* Copyright (c) 2014 Samsung Electronics Co., Ltd.
*
* limitations under the License.
*
*/
-
-#include <fstream>
#include <fcntl.h>
#include <sys/stat.h>
-#include <sys/ioctl.h>
#include <dirent.h>
+
#include <linux/input.h>
#include <cconfig.h>
+
#include <gyro_sensor_hal.h>
+#include <sys/ioctl.h>
+#include <fstream>
+#include <cconfig.h>
#include <sys/poll.h>
-#include <iio_common.h>
using std::ifstream;
using config::CConfig;
-#define INITIAL_VALUE -1
-#define INITIAL_TIME 0
#define DPS_TO_MDPS 1000
-#define MIN_RANGE(RES) (-((2 << (RES))/2))
-#define MAX_RANGE(RES) (((2 << (RES))/2)-1)
+#define MIN_RANGE(RES) (-((1 << (RES))/2))
+#define MAX_RANGE(RES) (((1 << (RES))/2)-1)
#define RAW_DATA_TO_DPS_UNIT(X) ((float)(X)/((float)DPS_TO_MDPS))
-#define SEC_MSEC 1000
-#define MSEC_TO_FREQ(VAL) (int)((SEC_MSEC) / (VAL))
-
#define SENSOR_TYPE_GYRO "GYRO"
-#define ELEMENT_NAME "NAME"
+#define ELEMENT_NAME "NAME"
#define ELEMENT_VENDOR "VENDOR"
#define ELEMENT_RAW_DATA_UNIT "RAW_DATA_UNIT"
-#define ELEMENT_RESOLUTION "RESOLUTION"
-#define ATTR_VALUE "value"
+#define ELEMENT_RESOLUTION "RESOLUTION"
+
+#define ATTR_VALUE "value"
-#define ENABLE_VAL 1
-#define DISABLE_VAL 0
-#define DEV_DIR "/dev/"
-#define TRIG_PATH "trigger/current_trigger"
+#define SCALE_AVAILABLE_NODE "in_anglvel_scale_available"
+#define SCAN_EL_DIR "scan_elements/"
+#define TRIG_SUFFIX "-trigger"
+#define GYRO_RINGBUF_LEN 32
+#define SEC_MSEC 1000
+#define MSEC_TO_FREQ(VAL) ((SEC_MSEC) / (VAL))
+#define NSEC_TO_MUSEC(VAL) ((VAL) / 1000)
gyro_sensor_hal::gyro_sensor_hal()
-: m_x(INITIAL_VALUE)
-, m_y(INITIAL_VALUE)
-, m_z(INITIAL_VALUE)
+: m_x(-1)
+, m_y(-1)
+, m_z(-1)
+, m_node_handle(-1)
, m_polling_interval(POLL_1HZ_MS)
-, m_fired_time(INITIAL_TIME)
-, m_sensorhub_supported(false)
+, m_fired_time(0)
{
- if (!check_hw_node())
- {
- ERR("check_hw_node() fail");
+
+ const string sensorhub_interval_node_name = "gyro_poll_delay";
+ CConfig &config = CConfig::get_instance();
+
+ node_path_info_query query;
+ node_path_info info;
+ int input_method = IIO_METHOD;
+
+ if (!get_model_properties(SENSOR_TYPE_GYRO, m_model_id, input_method)) {
+ ERR("Failed to find model_properties");
+ throw ENXIO;
+
+ }
+
+ query.input_method = input_method;
+ query.sensorhub_controlled = m_sensorhub_controlled = is_sensorhub_controlled(sensorhub_interval_node_name);
+ query.sensor_type = SENSOR_TYPE_GYRO;
+ query.input_event_key = "gyro_sensor";
+ query.iio_enable_node_name = "gyro_enable";
+ query.sensorhub_interval_node_name = sensorhub_interval_node_name;
+
+ if (!get_node_path_info(query, info)) {
+ ERR("Failed to get node info");
throw ENXIO;
}
- CConfig &config = CConfig::get_instance();
+ show_node_path_info(info);
+
+ m_data_node = info.data_node_path;
+ m_interval_node = info.interval_node_path;
+ m_gyro_dir = info.base_dir;
+ m_trigger_path = info.trigger_node_path;
+ m_buffer_enable_node_path = info.buffer_enable_node_path;
+ m_buffer_length_node_path = info.buffer_length_node_path;
+ m_available_freq_node_path = info.available_freq_node_path;
+ m_available_scale_node_path = m_gyro_dir + string(SCALE_AVAILABLE_NODE);
- if (!config.get(SENSOR_TYPE_GYRO, m_model_id, ELEMENT_VENDOR, m_vendor))
- {
- ERR("[VENDOR] is empty");
+ if (!config.get(SENSOR_TYPE_GYRO, m_model_id, ELEMENT_VENDOR, m_vendor)) {
+ ERR("[VENDOR] is empty\n");
throw ENXIO;
}
INFO("m_vendor = %s", m_vendor.c_str());
- if (!config.get(SENSOR_TYPE_GYRO, m_model_id, ELEMENT_NAME, m_chip_name))
- {
- ERR("[NAME] is empty");
+ if (!config.get(SENSOR_TYPE_GYRO, m_model_id, ELEMENT_NAME, m_chip_name)) {
+ ERR("[NAME] is empty\n");
throw ENXIO;
}
- INFO("m_chip_name = %s", m_chip_name.c_str());
+ INFO("m_chip_name = %s\n",m_chip_name.c_str());
+
+ if (input_method == IIO_METHOD) {
+ m_trigger_name = m_model_id + TRIG_SUFFIX;
+ if (!verify_iio_trigger(m_trigger_name)) {
+ ERR("Failed verify trigger");
+ throw ENXIO;
+ }
+ string scan_dir = m_gyro_dir + SCAN_EL_DIR;
+ if (!get_generic_channel_names(scan_dir, string("_type"), m_generic_channel_names))
+ ERR ("Failed to find any input channels");
+ else {
+ INFO ("generic channel names:");
+ for (vector <string>::iterator it = m_generic_channel_names.begin();
+ it != m_generic_channel_names.end(); ++it) {
+ INFO ("%s", it->c_str());
+ }
+ }
+ }
long resolution;
- if (!config.get(SENSOR_TYPE_GYRO, m_model_id, ELEMENT_RESOLUTION, resolution))
- {
- ERR("[RESOLUTION] is empty");
+ if (!config.get(SENSOR_TYPE_GYRO, m_model_id, ELEMENT_RESOLUTION, resolution)) {
+ ERR("[RESOLUTION] is empty\n");
throw ENXIO;
}
m_resolution = (int)resolution;
- INFO("m_resolution = %d", m_resolution);
double raw_data_unit;
- if (!config.get(SENSOR_TYPE_GYRO, m_model_id, ELEMENT_RAW_DATA_UNIT, raw_data_unit))
- {
- ERR("[RAW_DATA_UNIT] is empty");
+ if (!config.get(SENSOR_TYPE_GYRO, m_model_id, ELEMENT_RAW_DATA_UNIT, raw_data_unit)) {
+ ERR("[RAW_DATA_UNIT] is empty\n");
throw ENXIO;
}
m_raw_data_unit = (float)(raw_data_unit);
- INFO("m_raw_data_unit = %f", m_raw_data_unit);
- INFO("RAW_DATA_TO_DPS_UNIT(m_raw_data_unit) = [%f]", RAW_DATA_TO_DPS_UNIT(m_raw_data_unit));
- INFO("gyro_sensor_hal is created!");
+ if ((m_node_handle = open(m_data_node.c_str(), O_RDWR)) < 0) {
+ ERR("gyro handle open fail for gyro processor, error:%s\n", strerror(errno));
+ throw ENXIO;
+ }
+
+ if (setup_channels() == true)
+ INFO("IIO channel setup successful");
+ else {
+ ERR("IIO channel setup failed");
+ throw ENXIO;
+ }
+
+ INFO("m_raw_data_unit = %f\n",m_raw_data_unit);
+ INFO("RAW_DATA_TO_DPS_UNIT(m_raw_data_unit) = [%f]",RAW_DATA_TO_DPS_UNIT(m_raw_data_unit));
+ INFO("gyro_sensor is created!\n");
}
gyro_sensor_hal::~gyro_sensor_hal()
enable_resource(false);
if (m_data != NULL)
delete []m_data;
- if (m_fp_buffer > 0)
- close(m_fp_buffer);
- INFO("gyro_sensor_hal is destroyed!");
+ close(m_node_handle);
+ m_node_handle = -1;
+
+ INFO("gyro_sensor is destroyed!\n");
}
string gyro_sensor_hal::get_model_id(void)
return GYROSCOPE_SENSOR;
}
-bool gyro_sensor_hal::enable_resource(bool enable)
-{
- string temp;
- int enable_val;
-
- if(enable)
- enable_val = ENABLE_VAL;
- else
- enable_val = DISABLE_VAL;
-
- temp = m_gyro_dir + string(SCAN_EL_DIR) + string(CHANNEL_NAME_X) + string(ENABLE_SUFFIX);
- update_sysfs_num(temp.c_str(), enable_val);
- temp = m_gyro_dir + string(SCAN_EL_DIR) + string(CHANNEL_NAME_Y) + string(ENABLE_SUFFIX);
- update_sysfs_num(temp.c_str(), enable_val);
- temp = m_gyro_dir + string(SCAN_EL_DIR) + string(CHANNEL_NAME_Z) + string(ENABLE_SUFFIX);
- update_sysfs_num(temp.c_str(), enable_val);
- temp = m_gyro_dir + string(SCAN_EL_DIR) + string(CHANNEL_NAME_TIME) + string(ENABLE_SUFFIX);
- update_sysfs_num(temp.c_str(), enable_val);
- setup_trigger(INPUT_TRIG_NAME, enable);
- setup_buffer(enable_val);
-
- return true;
-}
-
bool gyro_sensor_hal::enable(void)
{
AUTOLOCK(m_mutex);
- enable_resource(true);
+ if (!enable_resource(true))
+ return false;
+
set_interval(m_polling_interval);
- m_fired_time = INITIAL_TIME;
+ m_fired_time = 0;
INFO("Gyro sensor real starting");
return true;
}
{
AUTOLOCK(m_mutex);
- enable_resource(false);
+ if (!enable_resource(false))
+ return false;
+
INFO("Gyro sensor real stopping");
return true;
+
}
bool gyro_sensor_hal::set_interval(unsigned long ms_interval)
{
- int freq, i, approx_freq;
- freq = MSEC_TO_FREQ(ms_interval);
-
- for (i=0; i < m_sample_freq_count; i++)
- {
- if (freq == m_sample_freq[i])
- {
- if (update_sysfs_num(m_freq_resource.c_str(), freq, true) == 0)
- {
+ int freq, i;
+
+ freq = (int)(MSEC_TO_FREQ(ms_interval));
+
+ for (i=0; i < m_sample_freq_count; i++) {
+ if (freq == m_sample_freq[i]) {
+ if (update_sysfs_num(m_interval_node.c_str(), freq, true) == 0) {
INFO("Interval is changed from %lums to %lums]", m_polling_interval, ms_interval);
m_polling_interval = ms_interval;
return true;
}
- else
- {
+ else {
ERR("Failed to set data %lu\n", ms_interval);
return false;
}
}
}
- INFO("The interval not supported: %lu\n", ms_interval);
+ DBG("The interval not supported: %lu\n", ms_interval);
ERR("Failed to set data %lu\n", ms_interval);
return false;
}
ssize_t read_size;
const int TIMEOUT = 1000;
- pfd.fd = m_fp_buffer;
+ pfd.fd = m_node_handle;
pfd.events = POLLIN;
if (wait)
poll(&pfd, 1, TIMEOUT);
else
poll(&pfd, 1, 0);
- read_size = read(m_fp_buffer, m_data, GYRO_RINGBUF_LEN * m_scan_size);
-
- if (read_size <= 0)
- {
- ERR("No gyro data available to read\n");
+ read_size = read(m_node_handle, m_data, GYRO_RINGBUF_LEN * m_scan_size);
+ if (read_size <= 0) {
+ ERR("Gyro:No data available\n");
return false;
}
-
- for (i = 0; i < (read_size / m_scan_size); i++)
- decode_data();
+ else {
+ for (i = 0; i < (read_size / m_scan_size); i++)
+ decode_data();
+ }
return true;
}
int gyro_sensor_hal::get_sensor_data(sensor_data_t &data)
{
- const int chance = 3;
- int retry = 0;
-
- while ((m_fired_time == INITIAL_TIME) && (retry++ < chance))
- {
- INFO("Try usleep for getting a valid BASE DATA value");
- usleep(m_polling_interval * MS_TO_SEC);
- }
-
- if (m_fired_time == INITIAL_TIME)
- {
- ERR("get_sensor_data failed");
- return -1;
- }
+ AUTOLOCK(m_value_mutex);
- data.data_accuracy = SENSOR_ACCURACY_GOOD;
- data.data_unit_idx = SENSOR_UNIT_VENDOR_UNIT;
+ data.accuracy = SENSOR_ACCURACY_GOOD;
data.timestamp = m_fired_time ;
- data.values_num = 3;
+ data.value_count = 3;
data.values[0] = m_x;
data.values[1] = m_y;
data.values[2] = m_z;
bool gyro_sensor_hal::get_properties(sensor_properties_t &properties)
{
- properties.sensor_unit_idx = SENSOR_UNIT_DEGREE_PER_SECOND;
- properties.sensor_min_range = MIN_RANGE(m_resolution) * RAW_DATA_TO_DPS_UNIT(m_raw_data_unit);
- properties.sensor_max_range = MAX_RANGE(m_resolution) * RAW_DATA_TO_DPS_UNIT(m_raw_data_unit);
- snprintf(properties.sensor_name, sizeof(properties.sensor_name), "%s", m_chip_name.c_str());
- snprintf(properties.sensor_vendor, sizeof(properties.sensor_vendor), "%s", m_vendor.c_str());
- properties.sensor_resolution = RAW_DATA_TO_DPS_UNIT(m_raw_data_unit);
+ properties.name = m_chip_name;
+ properties.vendor = m_vendor;
+ properties.min_range = MIN_RANGE(m_resolution)* RAW_DATA_TO_DPS_UNIT(m_raw_data_unit);
+ properties.max_range = MAX_RANGE(m_resolution)* RAW_DATA_TO_DPS_UNIT(m_raw_data_unit);
+ properties.min_interval = 1;
+ properties.resolution = RAW_DATA_TO_DPS_UNIT(m_raw_data_unit);
+ properties.fifo_count = 0;
+ properties.max_batch_count = 0;
return true;
-}
-bool gyro_sensor_hal::is_sensorhub_supported(void)
-{
- return false;
}
-bool gyro_sensor_hal::check_hw_node(void)
+bool gyro_sensor_hal::add_gyro_channels_to_array(void)
{
- string name_node;
- string hw_name;
- string file_name;
- string temp;
- DIR *main_dir = NULL;
- struct dirent *dir_entry = NULL;
- bool find_node = false;
- bool find_trigger = false;
-
- INFO("======================start check_hw_node=============================");
-
- m_sensorhub_supported = is_sensorhub_supported();
- main_dir = opendir(IIO_DIR);
-
- if (!main_dir)
- {
- ERR("Could not open IIO directory\n");
- return false;
- }
-
- m_channels = (struct channel_parameters*) malloc(sizeof(struct channel_parameters) * NO_OF_CHANNELS);
-
- while (!(find_node && find_trigger))
- {
- dir_entry = readdir(main_dir);
- if(dir_entry == NULL)
- break;
-
- if ((strncasecmp(dir_entry->d_name , ".", 1 ) != 0) && (strncasecmp(dir_entry->d_name , "..", 2 ) != 0) && (dir_entry->d_ino != 0))
- {
- file_name = string(IIO_DIR) + string(dir_entry->d_name) + string(NAME_NODE);
- ifstream infile(file_name.c_str());
-
- if (!infile)
- continue;
-
- infile >> hw_name;
-
- if (strncmp(dir_entry->d_name, IIO_DEV_BASE_NAME, IIO_DEV_STR_LEN) == 0)
- {
- if (CConfig::get_instance().is_supported(SENSOR_TYPE_GYRO, hw_name) == true)
- {
- m_gyro_dir = string(IIO_DIR) + string(dir_entry->d_name) + string("/");
- m_buffer_access = string(DEV_DIR) + string(dir_entry->d_name);
- m_name = m_model_id = hw_name;
- find_node = true;
- INFO("m_gyro_dir:%s\n", m_gyro_dir.c_str());
- INFO("m_buffer_access:%s\n", m_buffer_access.c_str());
- INFO("m_name:%s\n", m_name.c_str());
- }
- }
-
- if (strncmp(dir_entry->d_name, IIO_TRIG_BASE_NAME, IIO_TRIG_STR_LEN) == 0)
- {
- if (hw_name == string(INPUT_TRIG_NAME))
- {
- m_gyro_trig_dir = string(IIO_DIR) + string(dir_entry->d_name) + string("/");
- find_trigger = true;
- DBG("m_gyro_trig_dir:%s\n", m_gyro_trig_dir.c_str());
- }
- }
-
- if (find_node && find_trigger)
- break;
- }
- }
-
- closedir(main_dir);
-
- if (find_node && find_trigger)
- {
- if (setup_channels() == true)
- INFO("IIO channel setup successful");
- else
- {
- ERR("IIO channel setup failed");
+ int i = 0;
+ m_channels = (struct channel_parameters*) malloc(sizeof(struct channel_parameters) * m_generic_channel_names.size());
+ for (vector <string>::iterator it = m_generic_channel_names.begin();
+ it != m_generic_channel_names.end(); ++it) {
+ if (add_channel_to_array(m_gyro_dir.c_str(), it->c_str() , &m_channels[i++]) < 0) {
+ ERR("Failed to add channel %s to channel array", it->c_str());
return false;
}
}
- return (find_node && find_trigger);
-}
-
-bool gyro_sensor_hal::add_gyro_channels_to_array(void)
-{
- if (add_channel_to_array(m_gyro_dir.c_str(), CHANNEL_NAME_X, &m_channels[0]) < 0)
- {
- ERR("Failed to add %s to channel array", CHANNEL_NAME_X);
- return false;
- }
- if (add_channel_to_array(m_gyro_dir.c_str(), CHANNEL_NAME_Y, &m_channels[1]) < 0)
- {
- ERR("Failed to add %s to channel array", CHANNEL_NAME_Y);
- return false;
- }
- if (add_channel_to_array(m_gyro_dir.c_str(), CHANNEL_NAME_Z, &m_channels[2]) < 0)
- {
- ERR("Failed to add %s to channel array", CHANNEL_NAME_Z);
- return false;
- }
- if (add_channel_to_array(m_gyro_dir.c_str(), CHANNEL_NAME_TIME, &m_channels[3]) < 0)
- {
- ERR("Failed to add channel time_stamp to channel array");
- return false;
- }
return true;
}
{
int freq, i;
double sf;
- string temp;
enable_resource(true);
- if (!add_gyro_channels_to_array())
+ if (!add_gyro_channels_to_array()) {
+ ERR("Failed to add channels to array!");
return false;
+ }
- sort_channels_by_index(m_channels, NO_OF_CHANNELS);
+ INFO("Sorting channels by index");
+ sort_channels_by_index(m_channels, m_generic_channel_names.size());
+ INFO("Sorting channels by index completed");
- m_scan_size = get_channel_array_size(m_channels, NO_OF_CHANNELS);
- if (m_scan_size == 0)
- {
+ m_scan_size = get_channel_array_size(m_channels, m_generic_channel_names.size());
+ if (m_scan_size == 0) {
ERR("Channel array size is zero");
return false;
}
m_data = new (std::nothrow) char[m_scan_size * GYRO_RINGBUF_LEN];
- if (m_data == NULL)
- {
+ if (m_data == NULL) {
ERR("Couldn't create data buffer\n");
return false;
}
- m_fp_buffer = open(m_buffer_access.c_str(), O_RDONLY | O_NONBLOCK);
- if (m_fp_buffer == -1)
- {
- ERR("Failed to open ring buffer(%s)\n", m_buffer_access.c_str());
- return false;
- }
-
- m_freq_resource = m_gyro_dir + string(GYRO_FREQ);
- temp = m_gyro_dir + string(GYRO_FREQ_AVLBL);
-
FILE *fp = NULL;
- fp = fopen(temp.c_str(), "r");
- if (!fp)
- {
- ERR("Fail to open available frequencies file:%s\n", temp.c_str());
+ fp = fopen(m_available_freq_node_path.c_str(), "r");
+ if (!fp) {
+ ERR("Fail to open available frequencies file:%s\n", m_available_freq_node_path.c_str());
return false;
}
m_sample_freq[i] = 0;
i = 0;
+
while (fscanf(fp, "%d", &freq) > 0)
m_sample_freq[i++] = freq;
+
m_sample_freq_count = i;
- temp = m_gyro_dir + string(GYRO_SCALE_AVLBL);
- fp = fopen(temp.c_str(), "r");
- if (!fp)
- {
- ERR("Fail to open available scale factors file:%s\n", temp.c_str());
+ fp = fopen(m_available_scale_node_path.c_str(), "r");
+ if (!fp) {
+ ERR("Fail to open available scale factors file:%s\n", m_available_scale_node_path.c_str());
return false;
}
m_scale_factor[i] = 0;
i = 0;
+
while (fscanf(fp, "%lf", &sf) > 0)
m_scale_factor[i++] = sf;
+
m_scale_factor_count = i;
return true;
if ((val >> m_channels[3].valid_bits) & 1)
val = (val & m_channels[3].mask) | ~m_channels[3].mask;
- m_fired_time = (unsigned long long int)(val);
- DBG("m_x = %d, m_y = %d, m_z = %d, time = %lluus", m_x, m_y, m_z, m_fired_time);
+ m_fired_time = (unsigned long long int)(NSEC_TO_MUSEC(val));
+ INFO("m_x = %d, m_y = %d, m_z = %d, time = %lluus", m_x, m_y, m_z, m_fired_time);
}
-bool gyro_sensor_hal::setup_trigger(char* trig_name, bool verify)
+bool gyro_sensor_hal::setup_trigger(const char* trig_name, bool verify)
{
- string temp;
- int ret;
+ int ret = 0;
- temp = m_gyro_dir + string(TRIG_PATH);
- update_sysfs_string(temp.c_str(), trig_name, verify);
- if (ret < 0)
- {
- ERR("failed to write to current_trigger\n");
+ ret = update_sysfs_string(m_trigger_path.c_str(), trig_name);
+ if (ret < 0) {
+ ERR("failed to write to current_trigger,%s,%s\n", m_trigger_path.c_str(), trig_name);
return false;
}
INFO("current_trigger setup successfully\n");
bool gyro_sensor_hal::setup_buffer(int enable)
{
- string temp;
int ret;
- temp = m_gyro_dir + string(BUFFER_LEN);
- INFO("Buffer Length Setup: %s", temp.c_str());
- ret = update_sysfs_num(temp.c_str(), GYRO_RINGBUF_LEN, true);
- if (ret < 0)
- {
+ ret = update_sysfs_num(m_buffer_length_node_path.c_str(), GYRO_RINGBUF_LEN, true);
+ if (ret < 0) {
ERR("failed to write to buffer/length\n");
return false;
}
INFO("buffer/length setup successfully\n");
- temp = m_gyro_dir + string(BUFFER_EN);
- INFO("Buffer Enable: %s", temp.c_str());
- ret = update_sysfs_num(temp.c_str(), enable, true);
- if (ret < 0)
- {
+ ret = update_sysfs_num(m_buffer_enable_node_path.c_str(), enable, true);
+ if (ret < 0) {
ERR("failed to write to buffer/enable\n");
return false;
}
+
if (enable)
INFO("buffer enabled\n");
else
INFO("buffer disabled\n");
+ return true;
+}
+
+bool gyro_sensor_hal::enable_resource(bool enable)
+{
+ string temp;
+ if(enable)
+ setup_trigger(m_trigger_name.c_str(), enable);
+ else
+ setup_trigger("NULL", enable);
+ for (vector <string>::iterator it = m_generic_channel_names.begin();
+ it != m_generic_channel_names.end(); ++it) {
+ temp = m_gyro_dir + string(SCAN_EL_DIR) + *it + string("_en");
+ if (update_sysfs_num(temp.c_str(), enable) < 0)
+ return false;
+ }
+ setup_buffer(enable);
return true;
}
{
gyro_sensor_hal *inst;
- try
- {
+ try {
inst = new gyro_sensor_hal();
- }
- catch (int err)
- {
- ERR("Failed to create gyro_sensor_hal class, errno : %d, errstr : %s", err, strerror(err));
+ } catch (int err) {
+ ERR("gyro_sensor class create fail , errno : %d , errstr : %s\n", err, strerror(err));
return NULL;
}
- return (void *)inst;
+ return (void*)inst;
}
extern "C" void destroy(void *inst)
{
- delete (gyro_sensor_hal *)inst;
+ delete (gyro_sensor_hal*)inst;
}
projects / platform / core / system / sensord.git / commitdiff