1/* SPDX-License-Identifier: GPL-2.0-only */ 2/* 3 * HID Sensors Driver 4 * Copyright (c) 2012, Intel Corporation. 5 */ 6#ifndef _HID_SENSORS_HUB_H 7#define _HID_SENSORS_HUB_H 8 9#include <linux/hid.h> 10#include <linux/hid-sensor-ids.h> 11#include <linux/iio/iio.h> 12#include <linux/iio/trigger.h> 13 14/** 15 * struct hid_sensor_hub_attribute_info - Attribute info 16 * @usage_id: Parent usage id of a physical device. 17 * @attrib_id: Attribute id for this attribute. 18 * @report_id: Report id in which this information resides. 19 * @index: Field index in the report. 20 * @units: Measurment unit for this attribute. 21 * @unit_expo: Exponent used in the data. 22 * @size: Size in bytes for data size. 23 * @logical_minimum: Logical minimum value for this attribute. 24 * @logical_maximum: Logical maximum value for this attribute. 25 */ 26struct hid_sensor_hub_attribute_info { 27 u32 usage_id; 28 u32 attrib_id; 29 s32 report_id; 30 s32 index; 31 s32 units; 32 s32 unit_expo; 33 s32 size; 34 s32 logical_minimum; 35 s32 logical_maximum; 36}; 37 38/** 39 * struct sensor_hub_pending - Synchronous read pending information 40 * @status: Pending status true/false. 41 * @ready: Completion synchronization data. 42 * @usage_id: Usage id for physical device, E.g. Gyro usage id. 43 * @attr_usage_id: Usage Id of a field, E.g. X-AXIS for a gyro. 44 * @raw_size: Response size for a read request. 45 * @raw_data: Place holder for received response. 46 */ 47struct sensor_hub_pending { 48 bool status; 49 struct completion ready; 50 u32 usage_id; 51 u32 attr_usage_id; 52 int raw_size; 53 u8 *raw_data; 54}; 55 56/** 57 * struct hid_sensor_hub_device - Stores the hub instance data 58 * @hdev: Stores the hid instance. 59 * @vendor_id: Vendor id of hub device. 60 * @product_id: Product id of hub device. 61 * @usage: Usage id for this hub device instance. 62 * @start_collection_index: Starting index for a phy type collection 63 * @end_collection_index: Last index for a phy type collection 64 * @mutex_ptr: synchronizing mutex pointer. 65 * @pending: Holds information of pending sync read request. 66 */ 67struct hid_sensor_hub_device { 68 struct hid_device *hdev; 69 u32 vendor_id; 70 u32 product_id; 71 u32 usage; 72 int start_collection_index; 73 int end_collection_index; 74 struct mutex *mutex_ptr; 75 struct sensor_hub_pending pending; 76}; 77 78/** 79 * struct hid_sensor_hub_callbacks - Client callback functions 80 * @pdev: Platform device instance of the client driver. 81 * @suspend: Suspend callback. 82 * @resume: Resume callback. 83 * @capture_sample: Callback to get a sample. 84 * @send_event: Send notification to indicate all samples are 85 * captured, process and send event 86 */ 87struct hid_sensor_hub_callbacks { 88 struct platform_device *pdev; 89 int (*suspend)(struct hid_sensor_hub_device *hsdev, void *priv); 90 int (*resume)(struct hid_sensor_hub_device *hsdev, void *priv); 91 int (*capture_sample)(struct hid_sensor_hub_device *hsdev, 92 u32 usage_id, size_t raw_len, char *raw_data, 93 void *priv); 94 int (*send_event)(struct hid_sensor_hub_device *hsdev, u32 usage_id, 95 void *priv); 96}; 97 98/** 99* sensor_hub_device_open() - Open hub device 100* @hsdev: Hub device instance. 101* 102* Used to open hid device for sensor hub. 103*/ 104int sensor_hub_device_open(struct hid_sensor_hub_device *hsdev); 105 106/** 107* sensor_hub_device_clode() - Close hub device 108* @hsdev: Hub device instance. 109* 110* Used to clode hid device for sensor hub. 111*/ 112void sensor_hub_device_close(struct hid_sensor_hub_device *hsdev); 113 114/* Registration functions */ 115 116/** 117* sensor_hub_register_callback() - Register client callbacks 118* @hsdev: Hub device instance. 119* @usage_id: Usage id of the client (E.g. 0x200076 for Gyro). 120* @usage_callback: Callback function storage 121* 122* Used to register callbacks by client processing drivers. Sensor 123* hub core driver will call these callbacks to offload processing 124* of data streams and notifications. 125*/ 126int sensor_hub_register_callback(struct hid_sensor_hub_device *hsdev, 127 u32 usage_id, 128 struct hid_sensor_hub_callbacks *usage_callback); 129 130/** 131* sensor_hub_remove_callback() - Remove client callbacks 132* @hsdev: Hub device instance. 133* @usage_id: Usage id of the client (E.g. 0x200076 for Gyro). 134* 135* If there is a callback registred, this call will remove that 136* callbacks, so that it will stop data and event notifications. 137*/ 138int sensor_hub_remove_callback(struct hid_sensor_hub_device *hsdev, 139 u32 usage_id); 140 141 142/* Hid sensor hub core interfaces */ 143 144/** 145* sensor_hub_input_get_attribute_info() - Get an attribute information 146* @hsdev: Hub device instance. 147* @type: Type of this attribute, input/output/feature 148* @usage_id: Attribute usage id of parent physical device as per spec 149* @attr_usage_id: Attribute usage id as per spec 150* @info: return information about attribute after parsing report 151* 152* Parses report and returns the attribute information such as report id, 153* field index, units and exponent etc. 154*/ 155int sensor_hub_input_get_attribute_info(struct hid_sensor_hub_device *hsdev, 156 u8 type, 157 u32 usage_id, u32 attr_usage_id, 158 struct hid_sensor_hub_attribute_info *info); 159 160/** 161* sensor_hub_input_attr_get_raw_value() - Synchronous read request 162* @hsdev: Hub device instance. 163* @usage_id: Attribute usage id of parent physical device as per spec 164* @attr_usage_id: Attribute usage id as per spec 165* @report_id: Report id to look for 166* @flag: Synchronous or asynchronous read 167* @is_signed: If true then fields < 32 bits will be sign-extended 168* 169* Issues a synchronous or asynchronous read request for an input attribute. 170* Return: data up to 32 bits. 171*/ 172 173enum sensor_hub_read_flags { 174 SENSOR_HUB_SYNC, 175 SENSOR_HUB_ASYNC, 176}; 177 178int sensor_hub_input_attr_get_raw_value(struct hid_sensor_hub_device *hsdev, 179 u32 usage_id, 180 u32 attr_usage_id, u32 report_id, 181 enum sensor_hub_read_flags flag, 182 bool is_signed 183); 184 185/** 186* sensor_hub_set_feature() - Feature set request 187* @hsdev: Hub device instance. 188* @report_id: Report id to look for 189* @field_index: Field index inside a report 190* @buffer_size: size of the buffer 191* @buffer: buffer to use in the feature set 192* 193* Used to set a field in feature report. For example this can set polling 194* interval, sensitivity, activate/deactivate state. 195*/ 196int sensor_hub_set_feature(struct hid_sensor_hub_device *hsdev, u32 report_id, 197 u32 field_index, int buffer_size, void *buffer); 198 199/** 200* sensor_hub_get_feature() - Feature get request 201* @hsdev: Hub device instance. 202* @report_id: Report id to look for 203* @field_index: Field index inside a report 204* @buffer_size: size of the buffer 205* @buffer: buffer to copy output 206* 207* Used to get a field in feature report. For example this can get polling 208* interval, sensitivity, activate/deactivate state. 209* Return: On success, it returns the number of bytes copied to buffer. 210* On failure, it returns value < 0. 211*/ 212int sensor_hub_get_feature(struct hid_sensor_hub_device *hsdev, u32 report_id, 213 u32 field_index, int buffer_size, void *buffer); 214 215/* hid-sensor-attributes */ 216 217/* Common hid sensor iio structure */ 218struct hid_sensor_common { 219 struct hid_sensor_hub_device *hsdev; 220 struct platform_device *pdev; 221 unsigned usage_id; 222 atomic_t data_ready; 223 atomic_t user_requested_state; 224 atomic_t runtime_pm_enable; 225 int poll_interval; 226 int raw_hystersis; 227 int latency_ms; 228 struct iio_trigger *trigger; 229 int timestamp_ns_scale; 230 struct hid_sensor_hub_attribute_info poll; 231 struct hid_sensor_hub_attribute_info report_state; 232 struct hid_sensor_hub_attribute_info power_state; 233 struct hid_sensor_hub_attribute_info sensitivity; 234 struct hid_sensor_hub_attribute_info sensitivity_rel; 235 struct hid_sensor_hub_attribute_info report_latency; 236 struct work_struct work; 237}; 238 239/* Convert from hid unit expo to regular exponent */ 240static inline int hid_sensor_convert_exponent(int unit_expo) 241{ 242 if (unit_expo < 0x08) 243 return unit_expo; 244 else if (unit_expo <= 0x0f) 245 return -(0x0f-unit_expo+1); 246 else 247 return 0; 248} 249 250int hid_sensor_parse_common_attributes(struct hid_sensor_hub_device *hsdev, 251 u32 usage_id, 252 struct hid_sensor_common *st, 253 const u32 *sensitivity_addresses, 254 u32 sensitivity_addresses_len); 255int hid_sensor_write_raw_hyst_value(struct hid_sensor_common *st, 256 int val1, int val2); 257int hid_sensor_write_raw_hyst_rel_value(struct hid_sensor_common *st, int val1, 258 int val2); 259int hid_sensor_read_raw_hyst_value(struct hid_sensor_common *st, 260 int *val1, int *val2); 261int hid_sensor_read_raw_hyst_rel_value(struct hid_sensor_common *st, 262 int *val1, int *val2); 263int hid_sensor_write_samp_freq_value(struct hid_sensor_common *st, 264 int val1, int val2); 265int hid_sensor_read_samp_freq_value(struct hid_sensor_common *st, 266 int *val1, int *val2); 267 268int hid_sensor_get_usage_index(struct hid_sensor_hub_device *hsdev, 269 u32 report_id, int field_index, u32 usage_id); 270 271int hid_sensor_format_scale(u32 usage_id, 272 struct hid_sensor_hub_attribute_info *attr_info, 273 int *val0, int *val1); 274 275s32 hid_sensor_read_poll_value(struct hid_sensor_common *st); 276 277int64_t hid_sensor_convert_timestamp(struct hid_sensor_common *st, 278 int64_t raw_value); 279bool hid_sensor_batch_mode_supported(struct hid_sensor_common *st); 280int hid_sensor_set_report_latency(struct hid_sensor_common *st, int latency); 281int hid_sensor_get_report_latency(struct hid_sensor_common *st); 282 283#endif 284