Loading drivers/Makefile +1 −0 Original line number Diff line number Diff line Loading @@ -169,6 +169,7 @@ obj-$(CONFIG_ESOC) += esoc/ obj-$(CONFIG_BIF) += bif/ obj-$(CONFIG_SENSORS) += sensors/ obj-$(CONFIG_SENSORS_SSC) += sensors/ # <t-base drivers Loading drivers/sensors/Kconfig +6 −0 Original line number Diff line number Diff line config SENSORS bool "Sensors Class Support" help This option enables the sensor sysfs class in /sys/class/sensors. You'll need this to do anything useful with sensors. If unsure, say N. config SENSORS_SSC bool "Enable Sensors Driver Support for SSC" help Loading drivers/sensors/Makefile +1 −0 Original line number Diff line number Diff line obj-$(CONFIG_SENSORS) += sensors_class.o obj-$(CONFIG_SENSORS_SSC) += sensors_ssc.o drivers/sensors/sensors_class.c 0 → 100644 +575 −0 Original line number Diff line number Diff line /* Copyright (c) 2013-2014, 2017 The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and * only version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. */ #include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/list.h> #include <linux/spinlock.h> #include <linux/device.h> #include <linux/err.h> #include <linux/ctype.h> #include <linux/rwsem.h> #include <linux/sensors.h> #include <linux/string.h> #define APPLY_MASK 0x00000001 #define CMD_W_L_MASK 0x00 #define CMD_W_H_MASK 0x10 #define CMD_W_H_L 0x10 #define CMD_MASK 0xF #define DATA_MASK 0xFFFF0000 #define DATA_AXIS_SHIFT 17 #define DATA_APPLY_SHIFT 16 /* * CMD_GET_PARAMS(BIT, PARA, DATA) combine high 16 bit and low 16 bit * as one params */ #define CMD_GET_PARAMS(BIT, PARA, DATA) \ ((BIT) ? \ ((DATA) & DATA_MASK) \ : ((PARA) \ | (((DATA) & DATA_MASK) >> 16))) /* * CMD_DO_CAL sensor do calibrate command, when do sensor calibrate must use * this. * AXIS_X,AXIS_Y,AXIS_Z write axis params to driver like accelerometer * magnetometer,gyroscope etc. * CMD_W_THRESHOLD_H,CMD_W_THRESHOLD_L,CMD_W_BIAS write theshold and bias * params to proximity driver. * CMD_W_FACTOR,CMD_W_OFFSET write factor and offset params to light * sensor driver. * CMD_COMPLETE when one sensor receive calibrate parameters complete, it * must use this command to end receive the parameters and send the * parameters to sensor. */ enum { CMD_DO_CAL = 0x0, CMD_W_OFFSET_X, CMD_W_OFFSET_Y, CMD_W_OFFSET_Z, CMD_W_THRESHOLD_H, CMD_W_THRESHOLD_L, CMD_W_BIAS, CMD_W_OFFSET, CMD_W_FACTOR, CMD_W_RANGE, CMD_COMPLETE, CMD_COUNT }; int cal_map[] = { 0, offsetof(struct cal_result_t, offset_x), offsetof(struct cal_result_t, offset_y), offsetof(struct cal_result_t, offset_z), offsetof(struct cal_result_t, threshold_h), offsetof(struct cal_result_t, threshold_l), offsetof(struct cal_result_t, bias), offsetof(struct cal_result_t, offset[0]), offsetof(struct cal_result_t, offset[1]), offsetof(struct cal_result_t, offset[2]), offsetof(struct cal_result_t, factor), offsetof(struct cal_result_t, range), }; static struct class *sensors_class; DECLARE_RWSEM(sensors_list_lock); LIST_HEAD(sensors_list); static ssize_t sensors_name_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->name); } static ssize_t sensors_vendor_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->vendor); } static ssize_t sensors_version_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->version); } static ssize_t sensors_handle_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->handle); } static ssize_t sensors_type_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->type); } static ssize_t sensors_max_delay_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->max_delay); } static ssize_t sensors_flags_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->flags); } static ssize_t sensors_max_range_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->max_range); } static ssize_t sensors_resolution_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->resolution); } static ssize_t sensors_power_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->sensor_power); } static ssize_t sensors_min_delay_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->min_delay); } static ssize_t sensors_fifo_event_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->fifo_reserved_event_count); } static ssize_t sensors_fifo_max_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->fifo_max_event_count); } static ssize_t sensors_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); ssize_t ret = -EINVAL; unsigned long data = 0; ret = kstrtoul(buf, 10, &data); if (ret) return ret; if (data > 1) { dev_err(dev, "Invalid value of input, input=%ld\n", data); return -EINVAL; } if (sensors_cdev->sensors_enable == NULL) { dev_err(dev, "Invalid sensor class enable handle\n"); return -EINVAL; } ret = sensors_cdev->sensors_enable(sensors_cdev, data); if (ret) return ret; sensors_cdev->enabled = data; return size; } static ssize_t sensors_enable_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%u\n", sensors_cdev->enabled); } static ssize_t sensors_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); ssize_t ret = -EINVAL; unsigned long data = 0; ret = kstrtoul(buf, 10, &data); if (ret) return ret; /* The data unit is millisecond, the min_delay unit is microseconds. */ if ((data * 1000) < sensors_cdev->min_delay) { dev_err(dev, "Invalid value of delay, delay=%ld\n", data); return -EINVAL; } if (sensors_cdev->sensors_poll_delay == NULL) { dev_err(dev, "Invalid sensor class delay handle\n"); return -EINVAL; } ret = sensors_cdev->sensors_poll_delay(sensors_cdev, data); if (ret) return ret; sensors_cdev->delay_msec = data; return size; } static ssize_t sensors_delay_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%u\n", sensors_cdev->delay_msec); } static ssize_t sensors_test_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); int ret; if (sensors_cdev->sensors_self_test == NULL) { dev_err(dev, "Invalid sensor class self test handle\n"); return -EINVAL; } ret = sensors_cdev->sensors_self_test(sensors_cdev); if (ret) dev_warn(dev, "self test failed.(%d)\n", ret); return snprintf(buf, PAGE_SIZE, "%s\n", ret ? "fail" : "pass"); } static ssize_t sensors_max_latency_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); unsigned long latency; int ret = -EINVAL; ret = kstrtoul(buf, 10, &latency); if (ret) return ret; if (latency > sensors_cdev->max_delay) { dev_err(dev, "max_latency(%lu) is greater than max_delay(%u)\n", latency, sensors_cdev->max_delay); return -EINVAL; } if (sensors_cdev->sensors_set_latency == NULL) { dev_err(dev, "Invalid sensor calss set latency handle\n"); return -EINVAL; } /* Disable batching for this sensor */ if ((latency < sensors_cdev->delay_msec) && (latency != 0)) { dev_err(dev, "max_latency is less than delay_msec\n"); return -EINVAL; } ret = sensors_cdev->sensors_set_latency(sensors_cdev, latency); if (ret) return ret; sensors_cdev->max_latency = latency; return size; } static ssize_t sensors_max_latency_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%u\n", sensors_cdev->max_latency); } static ssize_t sensors_flush_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); ssize_t ret = -EINVAL; unsigned long data = 0; ret = kstrtoul(buf, 10, &data); if (ret) return ret; if (data != 1) { dev_err(dev, "Flush: Invalid value of input, input=%ld\n", data); return -EINVAL; } if (sensors_cdev->sensors_flush == NULL) { dev_err(dev, "Invalid sensor class flush handle\n"); return -EINVAL; } ret = sensors_cdev->sensors_flush(sensors_cdev); if (ret) return ret; return size; } static ssize_t sensors_flush_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "Flush handler %s\n", (sensors_cdev->sensors_flush == NULL) ? "not exist" : "exist"); } static ssize_t sensors_enable_wakeup_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); ssize_t ret; unsigned long enable; if (sensors_cdev->sensors_enable_wakeup == NULL) { dev_err(dev, "Invalid sensor class enable_wakeup handle\n"); return -EINVAL; } ret = kstrtoul(buf, 10, &enable); if (ret) return ret; enable = enable ? 1 : 0; ret = sensors_cdev->sensors_enable_wakeup(sensors_cdev, enable); if (ret) return ret; sensors_cdev->wakeup = enable; return size; } static ssize_t sensors_enable_wakeup_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->wakeup); } static ssize_t sensors_calibrate_show(struct device *dev, struct device_attribute *atte, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); if (sensors_cdev->params == NULL) { dev_err(dev, "Invalid sensor params\n"); return -EINVAL; } return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->params); } static ssize_t sensors_calibrate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); ssize_t ret = -EINVAL; long data; int axis, apply_now; int cmd, bit_h; ret = kstrtol(buf, 0, &data); if (ret) return ret; dev_dbg(dev, "data = %lx\n", data); cmd = data & CMD_MASK; if (cmd == CMD_DO_CAL) { if (sensors_cdev->sensors_calibrate == NULL) { dev_err(dev, "Invalid calibrate handle\n"); return -EINVAL; } /* parse the data to get the axis and apply_now value*/ apply_now = (int)(data >> DATA_APPLY_SHIFT) & APPLY_MASK; axis = (int)data >> DATA_AXIS_SHIFT; dev_dbg(dev, "apply_now = %d, axis = %d\n", apply_now, axis); ret = sensors_cdev->sensors_calibrate(sensors_cdev, axis, apply_now); if (ret) return ret; } else { if (sensors_cdev->sensors_write_cal_params == NULL) { dev_err(dev, "Invalid write_cal_params handle\n"); return -EINVAL; } bit_h = (data & CMD_W_H_L) >> 4; if (cmd > CMD_DO_CAL && cmd < CMD_COMPLETE) { char *p = (char *)(&sensors_cdev->cal_result) + cal_map[cmd]; *(int *)p = CMD_GET_PARAMS(bit_h, *(int *)p, data); } else if (cmd == CMD_COMPLETE) { ret = sensors_cdev->sensors_write_cal_params (sensors_cdev, &sensors_cdev->cal_result); } else { dev_err(dev, "Invalid command\n"); return -EINVAL; } } return size; } static DEVICE_ATTR(name, 0444, sensors_name_show, NULL); static DEVICE_ATTR(vendor, 0444, sensors_vendor_show, NULL); static DEVICE_ATTR(version, 0444, sensors_version_show, NULL); static DEVICE_ATTR(handle, 0444, sensors_handle_show, NULL); static DEVICE_ATTR(type, 0444, sensors_type_show, NULL); static DEVICE_ATTR(max_range, 0444, sensors_max_range_show, NULL); static DEVICE_ATTR(resolution, 0444, sensors_resolution_show, NULL); static DEVICE_ATTR(sensor_power, 0444, sensors_power_show, NULL); static DEVICE_ATTR(min_delay, 0444, sensors_min_delay_show, NULL); static DEVICE_ATTR(fifo_reserved_event_count, 0444, sensors_fifo_event_show, NULL); static DEVICE_ATTR(fifo_max_event_count, 0444, sensors_fifo_max_show, NULL); static DEVICE_ATTR(max_delay, 0444, sensors_max_delay_show, NULL); static DEVICE_ATTR(flags, 0444, sensors_flags_show, NULL); static DEVICE_ATTR(enable, 0664, sensors_enable_show, sensors_enable_store); static DEVICE_ATTR(enable_wakeup, 0664, sensors_enable_wakeup_show, sensors_enable_wakeup_store); static DEVICE_ATTR(poll_delay, 0664, sensors_delay_show, sensors_delay_store); static DEVICE_ATTR(self_test, 0440, sensors_test_show, NULL); static DEVICE_ATTR(max_latency, 0660, sensors_max_latency_show, sensors_max_latency_store); static DEVICE_ATTR(flush, 0660, sensors_flush_show, sensors_flush_store); static DEVICE_ATTR(calibrate, 0664, sensors_calibrate_show, sensors_calibrate_store); static struct attribute *sensors_class_attrs[] = { &dev_attr_name.attr, &dev_attr_vendor.attr, &dev_attr_version.attr, &dev_attr_handle.attr, &dev_attr_type.attr, &dev_attr_max_range.attr, &dev_attr_resolution.attr, &dev_attr_sensor_power.attr, &dev_attr_min_delay.attr, &dev_attr_fifo_reserved_event_count.attr, &dev_attr_fifo_max_event_count.attr, &dev_attr_max_delay.attr, &dev_attr_flags.attr, &dev_attr_enable.attr, &dev_attr_enable_wakeup.attr, &dev_attr_poll_delay.attr, &dev_attr_self_test.attr, &dev_attr_max_latency.attr, &dev_attr_flush.attr, &dev_attr_calibrate.attr, NULL, }; ATTRIBUTE_GROUPS(sensors_class); /** * sensors_classdev_register - register a new object of sensors_classdev class. * @parent: The device to register. * @sensors_cdev: the sensors_classdev structure for this device. */ int sensors_classdev_register(struct device *parent, struct sensors_classdev *sensors_cdev) { sensors_cdev->dev = device_create(sensors_class, parent, 0, sensors_cdev, "%s", sensors_cdev->name); if (IS_ERR(sensors_cdev->dev)) return PTR_ERR(sensors_cdev->dev); down_write(&sensors_list_lock); list_add_tail(&sensors_cdev->node, &sensors_list); up_write(&sensors_list_lock); pr_debug("Registered sensors device: %s\n", sensors_cdev->name); return 0; } EXPORT_SYMBOL(sensors_classdev_register); /** * sensors_classdev_unregister - unregister a object of sensors class. * @sensors_cdev: the sensor device to unregister * Unregister a previously registered via sensors_classdev_register object. */ void sensors_classdev_unregister(struct sensors_classdev *sensors_cdev) { device_unregister(sensors_cdev->dev); down_write(&sensors_list_lock); list_del(&sensors_cdev->node); up_write(&sensors_list_lock); } EXPORT_SYMBOL(sensors_classdev_unregister); static int __init sensors_init(void) { sensors_class = class_create(THIS_MODULE, "sensors"); if (IS_ERR(sensors_class)) return PTR_ERR(sensors_class); sensors_class->dev_groups = sensors_class_groups; return 0; } static void __exit sensors_exit(void) { class_destroy(sensors_class); } subsys_initcall(sensors_init); module_exit(sensors_exit); include/linux/sensors.h 0 → 100644 +168 −0 Original line number Diff line number Diff line /* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and * only version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. */ #ifndef __LINUX_SENSORS_H_INCLUDED #define __LINUX_SENSORS_H_INCLUDED #include <linux/list.h> #include <linux/spinlock.h> #include <linux/rwsem.h> #define SENSORS_ACCELERATION_HANDLE 0 #define SENSORS_MAGNETIC_FIELD_HANDLE 1 #define SENSORS_ORIENTATION_HANDLE 2 #define SENSORS_LIGHT_HANDLE 3 #define SENSORS_PROXIMITY_HANDLE 4 #define SENSORS_GYROSCOPE_HANDLE 5 #define SENSORS_PRESSURE_HANDLE 6 #define SENSOR_TYPE_ACCELEROMETER 1 #define SENSOR_TYPE_GEOMAGNETIC_FIELD 2 #define SENSOR_TYPE_MAGNETIC_FIELD SENSOR_TYPE_GEOMAGNETIC_FIELD #define SENSOR_TYPE_ORIENTATION 3 #define SENSOR_TYPE_GYROSCOPE 4 #define SENSOR_TYPE_LIGHT 5 #define SENSOR_TYPE_PRESSURE 6 #define SENSOR_TYPE_TEMPERATURE 7 #define SENSOR_TYPE_PROXIMITY 8 #define SENSOR_TYPE_GRAVITY 9 #define SENSOR_TYPE_LINEAR_ACCELERATION 10 #define SENSOR_TYPE_ROTATION_VECTOR 11 #define SENSOR_TYPE_RELATIVE_HUMIDITY 12 #define SENSOR_TYPE_AMBIENT_TEMPERATURE 13 #define SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED 14 #define SENSOR_TYPE_GAME_ROTATION_VECTOR 15 #define SENSOR_TYPE_GYROSCOPE_UNCALIBRATED 16 #define SENSOR_TYPE_SIGNIFICANT_MOTION 17 #define SENSOR_TYPE_STEP_DETECTOR 18 #define SENSOR_TYPE_STEP_COUNTER 19 #define SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR 20 enum LIS3DH_AXIS { AXIS_X = 0, AXIS_Y, AXIS_Z, AXIS_XYZ, }; enum LIS3DH_THRES { AXIS_THRESHOLD_H = 0, AXIS_THRESHOLD_L, AXIS_BIAS, }; #define AXIS_FACTOR 0 #define AXIS_OFFSET 1 struct cal_result_t { union { struct { int offset_x; /*axis offset of x axis*/ int offset_y; /*axis offset of x axis*/ int offset_z; /*axis offset of x axis*/ }; struct { int threshold_h; /*proximity threshold_h*/ int threshold_l; /*proximity threshold_l*/ int bias; /*proximity measure data noise*/ }; int offset[3]; }; int factor; /*light sensor factor for real ligt strength*/ int range; struct cal_result_t *node; }; /** * struct sensors_classdev - hold the sensor general parameters and APIs * @dev: The device to register. * @node: The list for the all the sensor drivers. * @name: Name of this sensor. * @vendor: The vendor of the hardware part. * @handle: The handle that identifies this sensors. * @type: The sensor type. * @max_range: The maximum range of this sensor's value in SI units. * @resolution: The smallest difference between two values reported by * this sensor. * @sensor_power: The rough estimate of this sensor's power consumption * in mA. * @min_delay: This value depends on the trigger mode: * continuous: minimum period allowed in microseconds * on-change : 0 * one-shot :-1 * special : 0, unless otherwise noted * @fifo_reserved_event_count: The number of events reserved for this sensor * in the batch mode FIFO. * @fifo_max_event_count: The maximum number of events of this sensor * that could be batched. * @max_delay: The slowest rate the sensor supports in millisecond. * @flags: Should be '1' if the sensor is a wake up sensor. * set it to '0' otherwise. * @enabled: Store the sensor driver enable status. * @delay_msec: Store the sensor driver delay value. The data unit is * millisecond. * @wakeup: Indicate if the wake up interrupt has been enabled. * @max_latency: Max report latency in millisecond * @sensors_enable: The handle for enable and disable sensor. * @sensors_poll_delay: The handle for set the sensor polling delay time. * @sensors_set_latency:Set the max report latency of the sensor. * @sensors_flush: Flush sensor events in FIFO and report it to user space. * @params The sensor calibrate string format params up to userspace. * @cal_result The sensor calibrate parameters, cal_result is a struct for sensor. */ struct sensors_classdev { struct device *dev; struct list_head node; const char *name; const char *vendor; int version; int handle; int type; const char *max_range; const char *resolution; const char *sensor_power; int min_delay; int fifo_reserved_event_count; int fifo_max_event_count; int32_t max_delay; uint32_t flags; unsigned int enabled; unsigned int delay_msec; unsigned int wakeup; unsigned int max_latency; char *params; struct cal_result_t cal_result; /* enable and disable the sensor handle*/ int (*sensors_enable)(struct sensors_classdev *sensors_cdev, unsigned int enabled); int (*sensors_poll_delay)(struct sensors_classdev *sensors_cdev, unsigned int delay_msec); int (*sensors_self_test)(struct sensors_classdev *sensors_cdev); int (*sensors_set_latency)(struct sensors_classdev *sensor_cdev, unsigned int max_latency); int (*sensors_enable_wakeup)(struct sensors_classdev *sensor_cdev, unsigned int enable); int (*sensors_flush)(struct sensors_classdev *sensors_cdev); int (*sensors_calibrate)(struct sensors_classdev *sensor_cdev, int axis, int apply_now); int (*sensors_write_cal_params)(struct sensors_classdev *sensor_cdev, struct cal_result_t *cal_result); }; extern int sensors_classdev_register(struct device *parent, struct sensors_classdev *sensors_cdev); extern void sensors_classdev_unregister(struct sensors_classdev *sensors_cdev); #endif /* __LINUX_SENSORS_H_INCLUDED */ Loading
drivers/Makefile +1 −0 Original line number Diff line number Diff line Loading @@ -169,6 +169,7 @@ obj-$(CONFIG_ESOC) += esoc/ obj-$(CONFIG_BIF) += bif/ obj-$(CONFIG_SENSORS) += sensors/ obj-$(CONFIG_SENSORS_SSC) += sensors/ # <t-base drivers Loading
drivers/sensors/Kconfig +6 −0 Original line number Diff line number Diff line config SENSORS bool "Sensors Class Support" help This option enables the sensor sysfs class in /sys/class/sensors. You'll need this to do anything useful with sensors. If unsure, say N. config SENSORS_SSC bool "Enable Sensors Driver Support for SSC" help Loading
drivers/sensors/Makefile +1 −0 Original line number Diff line number Diff line obj-$(CONFIG_SENSORS) += sensors_class.o obj-$(CONFIG_SENSORS_SSC) += sensors_ssc.o
drivers/sensors/sensors_class.c 0 → 100644 +575 −0 Original line number Diff line number Diff line /* Copyright (c) 2013-2014, 2017 The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and * only version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. */ #include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/list.h> #include <linux/spinlock.h> #include <linux/device.h> #include <linux/err.h> #include <linux/ctype.h> #include <linux/rwsem.h> #include <linux/sensors.h> #include <linux/string.h> #define APPLY_MASK 0x00000001 #define CMD_W_L_MASK 0x00 #define CMD_W_H_MASK 0x10 #define CMD_W_H_L 0x10 #define CMD_MASK 0xF #define DATA_MASK 0xFFFF0000 #define DATA_AXIS_SHIFT 17 #define DATA_APPLY_SHIFT 16 /* * CMD_GET_PARAMS(BIT, PARA, DATA) combine high 16 bit and low 16 bit * as one params */ #define CMD_GET_PARAMS(BIT, PARA, DATA) \ ((BIT) ? \ ((DATA) & DATA_MASK) \ : ((PARA) \ | (((DATA) & DATA_MASK) >> 16))) /* * CMD_DO_CAL sensor do calibrate command, when do sensor calibrate must use * this. * AXIS_X,AXIS_Y,AXIS_Z write axis params to driver like accelerometer * magnetometer,gyroscope etc. * CMD_W_THRESHOLD_H,CMD_W_THRESHOLD_L,CMD_W_BIAS write theshold and bias * params to proximity driver. * CMD_W_FACTOR,CMD_W_OFFSET write factor and offset params to light * sensor driver. * CMD_COMPLETE when one sensor receive calibrate parameters complete, it * must use this command to end receive the parameters and send the * parameters to sensor. */ enum { CMD_DO_CAL = 0x0, CMD_W_OFFSET_X, CMD_W_OFFSET_Y, CMD_W_OFFSET_Z, CMD_W_THRESHOLD_H, CMD_W_THRESHOLD_L, CMD_W_BIAS, CMD_W_OFFSET, CMD_W_FACTOR, CMD_W_RANGE, CMD_COMPLETE, CMD_COUNT }; int cal_map[] = { 0, offsetof(struct cal_result_t, offset_x), offsetof(struct cal_result_t, offset_y), offsetof(struct cal_result_t, offset_z), offsetof(struct cal_result_t, threshold_h), offsetof(struct cal_result_t, threshold_l), offsetof(struct cal_result_t, bias), offsetof(struct cal_result_t, offset[0]), offsetof(struct cal_result_t, offset[1]), offsetof(struct cal_result_t, offset[2]), offsetof(struct cal_result_t, factor), offsetof(struct cal_result_t, range), }; static struct class *sensors_class; DECLARE_RWSEM(sensors_list_lock); LIST_HEAD(sensors_list); static ssize_t sensors_name_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->name); } static ssize_t sensors_vendor_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->vendor); } static ssize_t sensors_version_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->version); } static ssize_t sensors_handle_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->handle); } static ssize_t sensors_type_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->type); } static ssize_t sensors_max_delay_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->max_delay); } static ssize_t sensors_flags_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->flags); } static ssize_t sensors_max_range_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->max_range); } static ssize_t sensors_resolution_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->resolution); } static ssize_t sensors_power_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->sensor_power); } static ssize_t sensors_min_delay_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->min_delay); } static ssize_t sensors_fifo_event_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->fifo_reserved_event_count); } static ssize_t sensors_fifo_max_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->fifo_max_event_count); } static ssize_t sensors_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); ssize_t ret = -EINVAL; unsigned long data = 0; ret = kstrtoul(buf, 10, &data); if (ret) return ret; if (data > 1) { dev_err(dev, "Invalid value of input, input=%ld\n", data); return -EINVAL; } if (sensors_cdev->sensors_enable == NULL) { dev_err(dev, "Invalid sensor class enable handle\n"); return -EINVAL; } ret = sensors_cdev->sensors_enable(sensors_cdev, data); if (ret) return ret; sensors_cdev->enabled = data; return size; } static ssize_t sensors_enable_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%u\n", sensors_cdev->enabled); } static ssize_t sensors_delay_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); ssize_t ret = -EINVAL; unsigned long data = 0; ret = kstrtoul(buf, 10, &data); if (ret) return ret; /* The data unit is millisecond, the min_delay unit is microseconds. */ if ((data * 1000) < sensors_cdev->min_delay) { dev_err(dev, "Invalid value of delay, delay=%ld\n", data); return -EINVAL; } if (sensors_cdev->sensors_poll_delay == NULL) { dev_err(dev, "Invalid sensor class delay handle\n"); return -EINVAL; } ret = sensors_cdev->sensors_poll_delay(sensors_cdev, data); if (ret) return ret; sensors_cdev->delay_msec = data; return size; } static ssize_t sensors_delay_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%u\n", sensors_cdev->delay_msec); } static ssize_t sensors_test_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); int ret; if (sensors_cdev->sensors_self_test == NULL) { dev_err(dev, "Invalid sensor class self test handle\n"); return -EINVAL; } ret = sensors_cdev->sensors_self_test(sensors_cdev); if (ret) dev_warn(dev, "self test failed.(%d)\n", ret); return snprintf(buf, PAGE_SIZE, "%s\n", ret ? "fail" : "pass"); } static ssize_t sensors_max_latency_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); unsigned long latency; int ret = -EINVAL; ret = kstrtoul(buf, 10, &latency); if (ret) return ret; if (latency > sensors_cdev->max_delay) { dev_err(dev, "max_latency(%lu) is greater than max_delay(%u)\n", latency, sensors_cdev->max_delay); return -EINVAL; } if (sensors_cdev->sensors_set_latency == NULL) { dev_err(dev, "Invalid sensor calss set latency handle\n"); return -EINVAL; } /* Disable batching for this sensor */ if ((latency < sensors_cdev->delay_msec) && (latency != 0)) { dev_err(dev, "max_latency is less than delay_msec\n"); return -EINVAL; } ret = sensors_cdev->sensors_set_latency(sensors_cdev, latency); if (ret) return ret; sensors_cdev->max_latency = latency; return size; } static ssize_t sensors_max_latency_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%u\n", sensors_cdev->max_latency); } static ssize_t sensors_flush_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); ssize_t ret = -EINVAL; unsigned long data = 0; ret = kstrtoul(buf, 10, &data); if (ret) return ret; if (data != 1) { dev_err(dev, "Flush: Invalid value of input, input=%ld\n", data); return -EINVAL; } if (sensors_cdev->sensors_flush == NULL) { dev_err(dev, "Invalid sensor class flush handle\n"); return -EINVAL; } ret = sensors_cdev->sensors_flush(sensors_cdev); if (ret) return ret; return size; } static ssize_t sensors_flush_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "Flush handler %s\n", (sensors_cdev->sensors_flush == NULL) ? "not exist" : "exist"); } static ssize_t sensors_enable_wakeup_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); ssize_t ret; unsigned long enable; if (sensors_cdev->sensors_enable_wakeup == NULL) { dev_err(dev, "Invalid sensor class enable_wakeup handle\n"); return -EINVAL; } ret = kstrtoul(buf, 10, &enable); if (ret) return ret; enable = enable ? 1 : 0; ret = sensors_cdev->sensors_enable_wakeup(sensors_cdev, enable); if (ret) return ret; sensors_cdev->wakeup = enable; return size; } static ssize_t sensors_enable_wakeup_show(struct device *dev, struct device_attribute *attr, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); return snprintf(buf, PAGE_SIZE, "%d\n", sensors_cdev->wakeup); } static ssize_t sensors_calibrate_show(struct device *dev, struct device_attribute *atte, char *buf) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); if (sensors_cdev->params == NULL) { dev_err(dev, "Invalid sensor params\n"); return -EINVAL; } return snprintf(buf, PAGE_SIZE, "%s\n", sensors_cdev->params); } static ssize_t sensors_calibrate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { struct sensors_classdev *sensors_cdev = dev_get_drvdata(dev); ssize_t ret = -EINVAL; long data; int axis, apply_now; int cmd, bit_h; ret = kstrtol(buf, 0, &data); if (ret) return ret; dev_dbg(dev, "data = %lx\n", data); cmd = data & CMD_MASK; if (cmd == CMD_DO_CAL) { if (sensors_cdev->sensors_calibrate == NULL) { dev_err(dev, "Invalid calibrate handle\n"); return -EINVAL; } /* parse the data to get the axis and apply_now value*/ apply_now = (int)(data >> DATA_APPLY_SHIFT) & APPLY_MASK; axis = (int)data >> DATA_AXIS_SHIFT; dev_dbg(dev, "apply_now = %d, axis = %d\n", apply_now, axis); ret = sensors_cdev->sensors_calibrate(sensors_cdev, axis, apply_now); if (ret) return ret; } else { if (sensors_cdev->sensors_write_cal_params == NULL) { dev_err(dev, "Invalid write_cal_params handle\n"); return -EINVAL; } bit_h = (data & CMD_W_H_L) >> 4; if (cmd > CMD_DO_CAL && cmd < CMD_COMPLETE) { char *p = (char *)(&sensors_cdev->cal_result) + cal_map[cmd]; *(int *)p = CMD_GET_PARAMS(bit_h, *(int *)p, data); } else if (cmd == CMD_COMPLETE) { ret = sensors_cdev->sensors_write_cal_params (sensors_cdev, &sensors_cdev->cal_result); } else { dev_err(dev, "Invalid command\n"); return -EINVAL; } } return size; } static DEVICE_ATTR(name, 0444, sensors_name_show, NULL); static DEVICE_ATTR(vendor, 0444, sensors_vendor_show, NULL); static DEVICE_ATTR(version, 0444, sensors_version_show, NULL); static DEVICE_ATTR(handle, 0444, sensors_handle_show, NULL); static DEVICE_ATTR(type, 0444, sensors_type_show, NULL); static DEVICE_ATTR(max_range, 0444, sensors_max_range_show, NULL); static DEVICE_ATTR(resolution, 0444, sensors_resolution_show, NULL); static DEVICE_ATTR(sensor_power, 0444, sensors_power_show, NULL); static DEVICE_ATTR(min_delay, 0444, sensors_min_delay_show, NULL); static DEVICE_ATTR(fifo_reserved_event_count, 0444, sensors_fifo_event_show, NULL); static DEVICE_ATTR(fifo_max_event_count, 0444, sensors_fifo_max_show, NULL); static DEVICE_ATTR(max_delay, 0444, sensors_max_delay_show, NULL); static DEVICE_ATTR(flags, 0444, sensors_flags_show, NULL); static DEVICE_ATTR(enable, 0664, sensors_enable_show, sensors_enable_store); static DEVICE_ATTR(enable_wakeup, 0664, sensors_enable_wakeup_show, sensors_enable_wakeup_store); static DEVICE_ATTR(poll_delay, 0664, sensors_delay_show, sensors_delay_store); static DEVICE_ATTR(self_test, 0440, sensors_test_show, NULL); static DEVICE_ATTR(max_latency, 0660, sensors_max_latency_show, sensors_max_latency_store); static DEVICE_ATTR(flush, 0660, sensors_flush_show, sensors_flush_store); static DEVICE_ATTR(calibrate, 0664, sensors_calibrate_show, sensors_calibrate_store); static struct attribute *sensors_class_attrs[] = { &dev_attr_name.attr, &dev_attr_vendor.attr, &dev_attr_version.attr, &dev_attr_handle.attr, &dev_attr_type.attr, &dev_attr_max_range.attr, &dev_attr_resolution.attr, &dev_attr_sensor_power.attr, &dev_attr_min_delay.attr, &dev_attr_fifo_reserved_event_count.attr, &dev_attr_fifo_max_event_count.attr, &dev_attr_max_delay.attr, &dev_attr_flags.attr, &dev_attr_enable.attr, &dev_attr_enable_wakeup.attr, &dev_attr_poll_delay.attr, &dev_attr_self_test.attr, &dev_attr_max_latency.attr, &dev_attr_flush.attr, &dev_attr_calibrate.attr, NULL, }; ATTRIBUTE_GROUPS(sensors_class); /** * sensors_classdev_register - register a new object of sensors_classdev class. * @parent: The device to register. * @sensors_cdev: the sensors_classdev structure for this device. */ int sensors_classdev_register(struct device *parent, struct sensors_classdev *sensors_cdev) { sensors_cdev->dev = device_create(sensors_class, parent, 0, sensors_cdev, "%s", sensors_cdev->name); if (IS_ERR(sensors_cdev->dev)) return PTR_ERR(sensors_cdev->dev); down_write(&sensors_list_lock); list_add_tail(&sensors_cdev->node, &sensors_list); up_write(&sensors_list_lock); pr_debug("Registered sensors device: %s\n", sensors_cdev->name); return 0; } EXPORT_SYMBOL(sensors_classdev_register); /** * sensors_classdev_unregister - unregister a object of sensors class. * @sensors_cdev: the sensor device to unregister * Unregister a previously registered via sensors_classdev_register object. */ void sensors_classdev_unregister(struct sensors_classdev *sensors_cdev) { device_unregister(sensors_cdev->dev); down_write(&sensors_list_lock); list_del(&sensors_cdev->node); up_write(&sensors_list_lock); } EXPORT_SYMBOL(sensors_classdev_unregister); static int __init sensors_init(void) { sensors_class = class_create(THIS_MODULE, "sensors"); if (IS_ERR(sensors_class)) return PTR_ERR(sensors_class); sensors_class->dev_groups = sensors_class_groups; return 0; } static void __exit sensors_exit(void) { class_destroy(sensors_class); } subsys_initcall(sensors_init); module_exit(sensors_exit);
include/linux/sensors.h 0 → 100644 +168 −0 Original line number Diff line number Diff line /* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and * only version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. */ #ifndef __LINUX_SENSORS_H_INCLUDED #define __LINUX_SENSORS_H_INCLUDED #include <linux/list.h> #include <linux/spinlock.h> #include <linux/rwsem.h> #define SENSORS_ACCELERATION_HANDLE 0 #define SENSORS_MAGNETIC_FIELD_HANDLE 1 #define SENSORS_ORIENTATION_HANDLE 2 #define SENSORS_LIGHT_HANDLE 3 #define SENSORS_PROXIMITY_HANDLE 4 #define SENSORS_GYROSCOPE_HANDLE 5 #define SENSORS_PRESSURE_HANDLE 6 #define SENSOR_TYPE_ACCELEROMETER 1 #define SENSOR_TYPE_GEOMAGNETIC_FIELD 2 #define SENSOR_TYPE_MAGNETIC_FIELD SENSOR_TYPE_GEOMAGNETIC_FIELD #define SENSOR_TYPE_ORIENTATION 3 #define SENSOR_TYPE_GYROSCOPE 4 #define SENSOR_TYPE_LIGHT 5 #define SENSOR_TYPE_PRESSURE 6 #define SENSOR_TYPE_TEMPERATURE 7 #define SENSOR_TYPE_PROXIMITY 8 #define SENSOR_TYPE_GRAVITY 9 #define SENSOR_TYPE_LINEAR_ACCELERATION 10 #define SENSOR_TYPE_ROTATION_VECTOR 11 #define SENSOR_TYPE_RELATIVE_HUMIDITY 12 #define SENSOR_TYPE_AMBIENT_TEMPERATURE 13 #define SENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED 14 #define SENSOR_TYPE_GAME_ROTATION_VECTOR 15 #define SENSOR_TYPE_GYROSCOPE_UNCALIBRATED 16 #define SENSOR_TYPE_SIGNIFICANT_MOTION 17 #define SENSOR_TYPE_STEP_DETECTOR 18 #define SENSOR_TYPE_STEP_COUNTER 19 #define SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR 20 enum LIS3DH_AXIS { AXIS_X = 0, AXIS_Y, AXIS_Z, AXIS_XYZ, }; enum LIS3DH_THRES { AXIS_THRESHOLD_H = 0, AXIS_THRESHOLD_L, AXIS_BIAS, }; #define AXIS_FACTOR 0 #define AXIS_OFFSET 1 struct cal_result_t { union { struct { int offset_x; /*axis offset of x axis*/ int offset_y; /*axis offset of x axis*/ int offset_z; /*axis offset of x axis*/ }; struct { int threshold_h; /*proximity threshold_h*/ int threshold_l; /*proximity threshold_l*/ int bias; /*proximity measure data noise*/ }; int offset[3]; }; int factor; /*light sensor factor for real ligt strength*/ int range; struct cal_result_t *node; }; /** * struct sensors_classdev - hold the sensor general parameters and APIs * @dev: The device to register. * @node: The list for the all the sensor drivers. * @name: Name of this sensor. * @vendor: The vendor of the hardware part. * @handle: The handle that identifies this sensors. * @type: The sensor type. * @max_range: The maximum range of this sensor's value in SI units. * @resolution: The smallest difference between two values reported by * this sensor. * @sensor_power: The rough estimate of this sensor's power consumption * in mA. * @min_delay: This value depends on the trigger mode: * continuous: minimum period allowed in microseconds * on-change : 0 * one-shot :-1 * special : 0, unless otherwise noted * @fifo_reserved_event_count: The number of events reserved for this sensor * in the batch mode FIFO. * @fifo_max_event_count: The maximum number of events of this sensor * that could be batched. * @max_delay: The slowest rate the sensor supports in millisecond. * @flags: Should be '1' if the sensor is a wake up sensor. * set it to '0' otherwise. * @enabled: Store the sensor driver enable status. * @delay_msec: Store the sensor driver delay value. The data unit is * millisecond. * @wakeup: Indicate if the wake up interrupt has been enabled. * @max_latency: Max report latency in millisecond * @sensors_enable: The handle for enable and disable sensor. * @sensors_poll_delay: The handle for set the sensor polling delay time. * @sensors_set_latency:Set the max report latency of the sensor. * @sensors_flush: Flush sensor events in FIFO and report it to user space. * @params The sensor calibrate string format params up to userspace. * @cal_result The sensor calibrate parameters, cal_result is a struct for sensor. */ struct sensors_classdev { struct device *dev; struct list_head node; const char *name; const char *vendor; int version; int handle; int type; const char *max_range; const char *resolution; const char *sensor_power; int min_delay; int fifo_reserved_event_count; int fifo_max_event_count; int32_t max_delay; uint32_t flags; unsigned int enabled; unsigned int delay_msec; unsigned int wakeup; unsigned int max_latency; char *params; struct cal_result_t cal_result; /* enable and disable the sensor handle*/ int (*sensors_enable)(struct sensors_classdev *sensors_cdev, unsigned int enabled); int (*sensors_poll_delay)(struct sensors_classdev *sensors_cdev, unsigned int delay_msec); int (*sensors_self_test)(struct sensors_classdev *sensors_cdev); int (*sensors_set_latency)(struct sensors_classdev *sensor_cdev, unsigned int max_latency); int (*sensors_enable_wakeup)(struct sensors_classdev *sensor_cdev, unsigned int enable); int (*sensors_flush)(struct sensors_classdev *sensors_cdev); int (*sensors_calibrate)(struct sensors_classdev *sensor_cdev, int axis, int apply_now); int (*sensors_write_cal_params)(struct sensors_classdev *sensor_cdev, struct cal_result_t *cal_result); }; extern int sensors_classdev_register(struct device *parent, struct sensors_classdev *sensors_cdev); extern void sensors_classdev_unregister(struct sensors_classdev *sensors_cdev); #endif /* __LINUX_SENSORS_H_INCLUDED */
