1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/device.h>
19#include <linux/platform_device.h>
20#include <linux/module.h>
21#include <linux/interrupt.h>
22#include <linux/irq.h>
23#include <linux/slab.h>
24#include <linux/delay.h>
25#include <linux/hid-sensor-hub.h>
26#include <linux/iio/iio.h>
27#include <linux/iio/sysfs.h>
28#include <linux/iio/buffer.h>
29#include <linux/iio/trigger_consumer.h>
30#include <linux/iio/triggered_buffer.h>
31#include "../common/hid-sensors/hid-sensor-trigger.h"
32
33#define CHANNEL_SCAN_INDEX_PRESSURE 0
34
35struct press_state {
36 struct hid_sensor_hub_callbacks callbacks;
37 struct hid_sensor_common common_attributes;
38 struct hid_sensor_hub_attribute_info press_attr;
39 u32 press_data;
40 int scale_pre_decml;
41 int scale_post_decml;
42 int scale_precision;
43 int value_offset;
44};
45
46
47static const struct iio_chan_spec press_channels[] = {
48 {
49 .type = IIO_PRESSURE,
50 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
51 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
52 BIT(IIO_CHAN_INFO_SCALE) |
53 BIT(IIO_CHAN_INFO_SAMP_FREQ) |
54 BIT(IIO_CHAN_INFO_HYSTERESIS),
55 .scan_index = CHANNEL_SCAN_INDEX_PRESSURE,
56 }
57};
58
59
60static void press_adjust_channel_bit_mask(struct iio_chan_spec *channels,
61 int channel, int size)
62{
63 channels[channel].scan_type.sign = 's';
64
65 channels[channel].scan_type.realbits = size * 8;
66
67 channels[channel].scan_type.storagebits = sizeof(u32) * 8;
68}
69
70
71static int press_read_raw(struct iio_dev *indio_dev,
72 struct iio_chan_spec const *chan,
73 int *val, int *val2,
74 long mask)
75{
76 struct press_state *press_state = iio_priv(indio_dev);
77 int report_id = -1;
78 u32 address;
79 int ret_type;
80 s32 min;
81
82 *val = 0;
83 *val2 = 0;
84 switch (mask) {
85 case IIO_CHAN_INFO_RAW:
86 switch (chan->scan_index) {
87 case CHANNEL_SCAN_INDEX_PRESSURE:
88 report_id = press_state->press_attr.report_id;
89 min = press_state->press_attr.logical_minimum;
90 address = HID_USAGE_SENSOR_ATMOSPHERIC_PRESSURE;
91 break;
92 default:
93 report_id = -1;
94 break;
95 }
96 if (report_id >= 0) {
97 hid_sensor_power_state(&press_state->common_attributes,
98 true);
99 *val = sensor_hub_input_attr_get_raw_value(
100 press_state->common_attributes.hsdev,
101 HID_USAGE_SENSOR_PRESSURE, address,
102 report_id,
103 SENSOR_HUB_SYNC,
104 min < 0);
105 hid_sensor_power_state(&press_state->common_attributes,
106 false);
107 } else {
108 *val = 0;
109 return -EINVAL;
110 }
111 ret_type = IIO_VAL_INT;
112 break;
113 case IIO_CHAN_INFO_SCALE:
114 *val = press_state->scale_pre_decml;
115 *val2 = press_state->scale_post_decml;
116 ret_type = press_state->scale_precision;
117 break;
118 case IIO_CHAN_INFO_OFFSET:
119 *val = press_state->value_offset;
120 ret_type = IIO_VAL_INT;
121 break;
122 case IIO_CHAN_INFO_SAMP_FREQ:
123 ret_type = hid_sensor_read_samp_freq_value(
124 &press_state->common_attributes, val, val2);
125 break;
126 case IIO_CHAN_INFO_HYSTERESIS:
127 ret_type = hid_sensor_read_raw_hyst_value(
128 &press_state->common_attributes, val, val2);
129 break;
130 default:
131 ret_type = -EINVAL;
132 break;
133 }
134
135 return ret_type;
136}
137
138
139static int press_write_raw(struct iio_dev *indio_dev,
140 struct iio_chan_spec const *chan,
141 int val,
142 int val2,
143 long mask)
144{
145 struct press_state *press_state = iio_priv(indio_dev);
146 int ret = 0;
147
148 switch (mask) {
149 case IIO_CHAN_INFO_SAMP_FREQ:
150 ret = hid_sensor_write_samp_freq_value(
151 &press_state->common_attributes, val, val2);
152 break;
153 case IIO_CHAN_INFO_HYSTERESIS:
154 ret = hid_sensor_write_raw_hyst_value(
155 &press_state->common_attributes, val, val2);
156 break;
157 default:
158 ret = -EINVAL;
159 }
160
161 return ret;
162}
163
164static const struct iio_info press_info = {
165 .read_raw = &press_read_raw,
166 .write_raw = &press_write_raw,
167};
168
169
170static void hid_sensor_push_data(struct iio_dev *indio_dev, const void *data,
171 int len)
172{
173 dev_dbg(&indio_dev->dev, "hid_sensor_push_data\n");
174 iio_push_to_buffers(indio_dev, data);
175}
176
177
178static int press_proc_event(struct hid_sensor_hub_device *hsdev,
179 unsigned usage_id,
180 void *priv)
181{
182 struct iio_dev *indio_dev = platform_get_drvdata(priv);
183 struct press_state *press_state = iio_priv(indio_dev);
184
185 dev_dbg(&indio_dev->dev, "press_proc_event\n");
186 if (atomic_read(&press_state->common_attributes.data_ready))
187 hid_sensor_push_data(indio_dev,
188 &press_state->press_data,
189 sizeof(press_state->press_data));
190
191 return 0;
192}
193
194
195static int press_capture_sample(struct hid_sensor_hub_device *hsdev,
196 unsigned usage_id,
197 size_t raw_len, char *raw_data,
198 void *priv)
199{
200 struct iio_dev *indio_dev = platform_get_drvdata(priv);
201 struct press_state *press_state = iio_priv(indio_dev);
202 int ret = -EINVAL;
203
204 switch (usage_id) {
205 case HID_USAGE_SENSOR_ATMOSPHERIC_PRESSURE:
206 press_state->press_data = *(u32 *)raw_data;
207 ret = 0;
208 break;
209 default:
210 break;
211 }
212
213 return ret;
214}
215
216
217static int press_parse_report(struct platform_device *pdev,
218 struct hid_sensor_hub_device *hsdev,
219 struct iio_chan_spec *channels,
220 unsigned usage_id,
221 struct press_state *st)
222{
223 int ret;
224
225 ret = sensor_hub_input_get_attribute_info(hsdev, HID_INPUT_REPORT,
226 usage_id,
227 HID_USAGE_SENSOR_ATMOSPHERIC_PRESSURE,
228 &st->press_attr);
229 if (ret < 0)
230 return ret;
231 press_adjust_channel_bit_mask(channels, CHANNEL_SCAN_INDEX_PRESSURE,
232 st->press_attr.size);
233
234 dev_dbg(&pdev->dev, "press %x:%x\n", st->press_attr.index,
235 st->press_attr.report_id);
236
237 st->scale_precision = hid_sensor_format_scale(
238 HID_USAGE_SENSOR_PRESSURE,
239 &st->press_attr,
240 &st->scale_pre_decml, &st->scale_post_decml);
241
242
243 if (st->common_attributes.sensitivity.index < 0) {
244 sensor_hub_input_get_attribute_info(hsdev,
245 HID_FEATURE_REPORT, usage_id,
246 HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
247 HID_USAGE_SENSOR_DATA_ATMOSPHERIC_PRESSURE,
248 &st->common_attributes.sensitivity);
249 dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
250 st->common_attributes.sensitivity.index,
251 st->common_attributes.sensitivity.report_id);
252 }
253 return ret;
254}
255
256
257static int hid_press_probe(struct platform_device *pdev)
258{
259 int ret = 0;
260 static const char *name = "press";
261 struct iio_dev *indio_dev;
262 struct press_state *press_state;
263 struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
264
265 indio_dev = devm_iio_device_alloc(&pdev->dev,
266 sizeof(struct press_state));
267 if (!indio_dev)
268 return -ENOMEM;
269 platform_set_drvdata(pdev, indio_dev);
270
271 press_state = iio_priv(indio_dev);
272 press_state->common_attributes.hsdev = hsdev;
273 press_state->common_attributes.pdev = pdev;
274
275 ret = hid_sensor_parse_common_attributes(hsdev,
276 HID_USAGE_SENSOR_PRESSURE,
277 &press_state->common_attributes);
278 if (ret) {
279 dev_err(&pdev->dev, "failed to setup common attributes\n");
280 return ret;
281 }
282
283 indio_dev->channels = kmemdup(press_channels, sizeof(press_channels),
284 GFP_KERNEL);
285 if (!indio_dev->channels) {
286 dev_err(&pdev->dev, "failed to duplicate channels\n");
287 return -ENOMEM;
288 }
289
290 ret = press_parse_report(pdev, hsdev,
291 (struct iio_chan_spec *)indio_dev->channels,
292 HID_USAGE_SENSOR_PRESSURE, press_state);
293 if (ret) {
294 dev_err(&pdev->dev, "failed to setup attributes\n");
295 goto error_free_dev_mem;
296 }
297
298 indio_dev->num_channels =
299 ARRAY_SIZE(press_channels);
300 indio_dev->dev.parent = &pdev->dev;
301 indio_dev->info = &press_info;
302 indio_dev->name = name;
303 indio_dev->modes = INDIO_DIRECT_MODE;
304
305 ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
306 NULL, NULL);
307 if (ret) {
308 dev_err(&pdev->dev, "failed to initialize trigger buffer\n");
309 goto error_free_dev_mem;
310 }
311 atomic_set(&press_state->common_attributes.data_ready, 0);
312 ret = hid_sensor_setup_trigger(indio_dev, name,
313 &press_state->common_attributes);
314 if (ret) {
315 dev_err(&pdev->dev, "trigger setup failed\n");
316 goto error_unreg_buffer_funcs;
317 }
318
319 ret = iio_device_register(indio_dev);
320 if (ret) {
321 dev_err(&pdev->dev, "device register failed\n");
322 goto error_remove_trigger;
323 }
324
325 press_state->callbacks.send_event = press_proc_event;
326 press_state->callbacks.capture_sample = press_capture_sample;
327 press_state->callbacks.pdev = pdev;
328 ret = sensor_hub_register_callback(hsdev, HID_USAGE_SENSOR_PRESSURE,
329 &press_state->callbacks);
330 if (ret < 0) {
331 dev_err(&pdev->dev, "callback reg failed\n");
332 goto error_iio_unreg;
333 }
334
335 return ret;
336
337error_iio_unreg:
338 iio_device_unregister(indio_dev);
339error_remove_trigger:
340 hid_sensor_remove_trigger(&press_state->common_attributes);
341error_unreg_buffer_funcs:
342 iio_triggered_buffer_cleanup(indio_dev);
343error_free_dev_mem:
344 kfree(indio_dev->channels);
345 return ret;
346}
347
348
349static int hid_press_remove(struct platform_device *pdev)
350{
351 struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
352 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
353 struct press_state *press_state = iio_priv(indio_dev);
354
355 sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_PRESSURE);
356 iio_device_unregister(indio_dev);
357 hid_sensor_remove_trigger(&press_state->common_attributes);
358 iio_triggered_buffer_cleanup(indio_dev);
359 kfree(indio_dev->channels);
360
361 return 0;
362}
363
364static const struct platform_device_id hid_press_ids[] = {
365 {
366
367 .name = "HID-SENSOR-200031",
368 },
369 { }
370};
371MODULE_DEVICE_TABLE(platform, hid_press_ids);
372
373static struct platform_driver hid_press_platform_driver = {
374 .id_table = hid_press_ids,
375 .driver = {
376 .name = KBUILD_MODNAME,
377 .pm = &hid_sensor_pm_ops,
378 },
379 .probe = hid_press_probe,
380 .remove = hid_press_remove,
381};
382module_platform_driver(hid_press_platform_driver);
383
384MODULE_DESCRIPTION("HID Sensor Pressure");
385MODULE_AUTHOR("Archana Patni <archana.patni@intel.com>");
386MODULE_LICENSE("GPL");
387
