1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/device.h>
20#include <linux/platform_device.h>
21#include <linux/module.h>
22#include <linux/interrupt.h>
23#include <linux/irq.h>
24#include <linux/slab.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
34
35#define DRIVER_NAME "HID-SENSOR-200076"
36
37enum gyro_3d_channel {
38 CHANNEL_SCAN_INDEX_X,
39 CHANNEL_SCAN_INDEX_Y,
40 CHANNEL_SCAN_INDEX_Z,
41 GYRO_3D_CHANNEL_MAX,
42};
43
44struct gyro_3d_state {
45 struct hid_sensor_hub_callbacks callbacks;
46 struct hid_sensor_common common_attributes;
47 struct hid_sensor_hub_attribute_info gyro[GYRO_3D_CHANNEL_MAX];
48 u32 gyro_val[GYRO_3D_CHANNEL_MAX];
49};
50
51static const u32 gyro_3d_addresses[GYRO_3D_CHANNEL_MAX] = {
52 HID_USAGE_SENSOR_ANGL_VELOCITY_X_AXIS,
53 HID_USAGE_SENSOR_ANGL_VELOCITY_Y_AXIS,
54 HID_USAGE_SENSOR_ANGL_VELOCITY_Z_AXIS
55};
56
57
58static const struct iio_chan_spec gyro_3d_channels[] = {
59 {
60 .type = IIO_ANGL_VEL,
61 .modified = 1,
62 .channel2 = IIO_MOD_X,
63 .info_mask = IIO_CHAN_INFO_OFFSET_SHARED_BIT |
64 IIO_CHAN_INFO_SCALE_SHARED_BIT |
65 IIO_CHAN_INFO_SAMP_FREQ_SHARED_BIT |
66 IIO_CHAN_INFO_HYSTERESIS_SHARED_BIT,
67 .scan_index = CHANNEL_SCAN_INDEX_X,
68 }, {
69 .type = IIO_ANGL_VEL,
70 .modified = 1,
71 .channel2 = IIO_MOD_Y,
72 .info_mask = IIO_CHAN_INFO_OFFSET_SHARED_BIT |
73 IIO_CHAN_INFO_SCALE_SHARED_BIT |
74 IIO_CHAN_INFO_SAMP_FREQ_SHARED_BIT |
75 IIO_CHAN_INFO_HYSTERESIS_SHARED_BIT,
76 .scan_index = CHANNEL_SCAN_INDEX_Y,
77 }, {
78 .type = IIO_ANGL_VEL,
79 .modified = 1,
80 .channel2 = IIO_MOD_Z,
81 .info_mask = IIO_CHAN_INFO_OFFSET_SHARED_BIT |
82 IIO_CHAN_INFO_SCALE_SHARED_BIT |
83 IIO_CHAN_INFO_SAMP_FREQ_SHARED_BIT |
84 IIO_CHAN_INFO_HYSTERESIS_SHARED_BIT,
85 .scan_index = CHANNEL_SCAN_INDEX_Z,
86 }
87};
88
89
90static void gyro_3d_adjust_channel_bit_mask(struct iio_chan_spec *channels,
91 int channel, int size)
92{
93 channels[channel].scan_type.sign = 's';
94
95 channels[channel].scan_type.realbits = size * 8;
96
97 channels[channel].scan_type.storagebits = sizeof(u32) * 8;
98}
99
100
101static int gyro_3d_read_raw(struct iio_dev *indio_dev,
102 struct iio_chan_spec const *chan,
103 int *val, int *val2,
104 long mask)
105{
106 struct gyro_3d_state *gyro_state = iio_priv(indio_dev);
107 int report_id = -1;
108 u32 address;
109 int ret;
110 int ret_type;
111
112 *val = 0;
113 *val2 = 0;
114 switch (mask) {
115 case 0:
116 report_id = gyro_state->gyro[chan->scan_index].report_id;
117 address = gyro_3d_addresses[chan->scan_index];
118 if (report_id >= 0)
119 *val = sensor_hub_input_attr_get_raw_value(
120 gyro_state->common_attributes.hsdev,
121 HID_USAGE_SENSOR_GYRO_3D, address,
122 report_id);
123 else {
124 *val = 0;
125 return -EINVAL;
126 }
127 ret_type = IIO_VAL_INT;
128 break;
129 case IIO_CHAN_INFO_SCALE:
130 *val = gyro_state->gyro[CHANNEL_SCAN_INDEX_X].units;
131 ret_type = IIO_VAL_INT;
132 break;
133 case IIO_CHAN_INFO_OFFSET:
134 *val = hid_sensor_convert_exponent(
135 gyro_state->gyro[CHANNEL_SCAN_INDEX_X].unit_expo);
136 ret_type = IIO_VAL_INT;
137 break;
138 case IIO_CHAN_INFO_SAMP_FREQ:
139 ret = hid_sensor_read_samp_freq_value(
140 &gyro_state->common_attributes, val, val2);
141 ret_type = IIO_VAL_INT_PLUS_MICRO;
142 break;
143 case IIO_CHAN_INFO_HYSTERESIS:
144 ret = hid_sensor_read_raw_hyst_value(
145 &gyro_state->common_attributes, val, val2);
146 ret_type = IIO_VAL_INT_PLUS_MICRO;
147 break;
148 default:
149 ret_type = -EINVAL;
150 break;
151 }
152
153 return ret_type;
154}
155
156
157static int gyro_3d_write_raw(struct iio_dev *indio_dev,
158 struct iio_chan_spec const *chan,
159 int val,
160 int val2,
161 long mask)
162{
163 struct gyro_3d_state *gyro_state = iio_priv(indio_dev);
164 int ret = 0;
165
166 switch (mask) {
167 case IIO_CHAN_INFO_SAMP_FREQ:
168 ret = hid_sensor_write_samp_freq_value(
169 &gyro_state->common_attributes, val, val2);
170 break;
171 case IIO_CHAN_INFO_HYSTERESIS:
172 ret = hid_sensor_write_raw_hyst_value(
173 &gyro_state->common_attributes, val, val2);
174 break;
175 default:
176 ret = -EINVAL;
177 }
178
179 return ret;
180}
181
182static int gyro_3d_write_raw_get_fmt(struct iio_dev *indio_dev,
183 struct iio_chan_spec const *chan,
184 long mask)
185{
186 return IIO_VAL_INT_PLUS_MICRO;
187}
188
189static const struct iio_info gyro_3d_info = {
190 .driver_module = THIS_MODULE,
191 .read_raw = &gyro_3d_read_raw,
192 .write_raw = &gyro_3d_write_raw,
193 .write_raw_get_fmt = &gyro_3d_write_raw_get_fmt,
194};
195
196
197static void hid_sensor_push_data(struct iio_dev *indio_dev, u8 *data, int len)
198{
199 dev_dbg(&indio_dev->dev, "hid_sensor_push_data\n");
200 iio_push_to_buffers(indio_dev, (u8 *)data);
201}
202
203
204static int gyro_3d_proc_event(struct hid_sensor_hub_device *hsdev,
205 unsigned usage_id,
206 void *priv)
207{
208 struct iio_dev *indio_dev = platform_get_drvdata(priv);
209 struct gyro_3d_state *gyro_state = iio_priv(indio_dev);
210
211 dev_dbg(&indio_dev->dev, "gyro_3d_proc_event [%d]\n",
212 gyro_state->common_attributes.data_ready);
213 if (gyro_state->common_attributes.data_ready)
214 hid_sensor_push_data(indio_dev,
215 (u8 *)gyro_state->gyro_val,
216 sizeof(gyro_state->gyro_val));
217
218 return 0;
219}
220
221
222static int gyro_3d_capture_sample(struct hid_sensor_hub_device *hsdev,
223 unsigned usage_id,
224 size_t raw_len, char *raw_data,
225 void *priv)
226{
227 struct iio_dev *indio_dev = platform_get_drvdata(priv);
228 struct gyro_3d_state *gyro_state = iio_priv(indio_dev);
229 int offset;
230 int ret = -EINVAL;
231
232 switch (usage_id) {
233 case HID_USAGE_SENSOR_ANGL_VELOCITY_X_AXIS:
234 case HID_USAGE_SENSOR_ANGL_VELOCITY_Y_AXIS:
235 case HID_USAGE_SENSOR_ANGL_VELOCITY_Z_AXIS:
236 offset = usage_id - HID_USAGE_SENSOR_ANGL_VELOCITY_X_AXIS;
237 gyro_state->gyro_val[CHANNEL_SCAN_INDEX_X + offset] =
238 *(u32 *)raw_data;
239 ret = 0;
240 break;
241 default:
242 break;
243 }
244
245 return ret;
246}
247
248
249static int gyro_3d_parse_report(struct platform_device *pdev,
250 struct hid_sensor_hub_device *hsdev,
251 struct iio_chan_spec *channels,
252 unsigned usage_id,
253 struct gyro_3d_state *st)
254{
255 int ret;
256 int i;
257
258 for (i = 0; i <= CHANNEL_SCAN_INDEX_Z; ++i) {
259 ret = sensor_hub_input_get_attribute_info(hsdev,
260 HID_INPUT_REPORT,
261 usage_id,
262 HID_USAGE_SENSOR_ANGL_VELOCITY_X_AXIS + i,
263 &st->gyro[CHANNEL_SCAN_INDEX_X + i]);
264 if (ret < 0)
265 break;
266 gyro_3d_adjust_channel_bit_mask(channels,
267 CHANNEL_SCAN_INDEX_X + i,
268 st->gyro[CHANNEL_SCAN_INDEX_X + i].size);
269 }
270 dev_dbg(&pdev->dev, "gyro_3d %x:%x, %x:%x, %x:%x\n",
271 st->gyro[0].index,
272 st->gyro[0].report_id,
273 st->gyro[1].index, st->gyro[1].report_id,
274 st->gyro[2].index, st->gyro[2].report_id);
275
276 return ret;
277}
278
279
280static int hid_gyro_3d_probe(struct platform_device *pdev)
281{
282 int ret = 0;
283 static const char *name = "gyro_3d";
284 struct iio_dev *indio_dev;
285 struct gyro_3d_state *gyro_state;
286 struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
287 struct iio_chan_spec *channels;
288
289 indio_dev = iio_device_alloc(sizeof(struct gyro_3d_state));
290 if (indio_dev == NULL) {
291 ret = -ENOMEM;
292 goto error_ret;
293 }
294 platform_set_drvdata(pdev, indio_dev);
295
296 gyro_state = iio_priv(indio_dev);
297 gyro_state->common_attributes.hsdev = hsdev;
298 gyro_state->common_attributes.pdev = pdev;
299
300 ret = hid_sensor_parse_common_attributes(hsdev,
301 HID_USAGE_SENSOR_GYRO_3D,
302 &gyro_state->common_attributes);
303 if (ret) {
304 dev_err(&pdev->dev, "failed to setup common attributes\n");
305 goto error_free_dev;
306 }
307
308 channels = kmemdup(gyro_3d_channels, sizeof(gyro_3d_channels),
309 GFP_KERNEL);
310 if (!channels) {
311 ret = -ENOMEM;
312 dev_err(&pdev->dev, "failed to duplicate channels\n");
313 goto error_free_dev;
314 }
315
316 ret = gyro_3d_parse_report(pdev, hsdev, channels,
317 HID_USAGE_SENSOR_GYRO_3D, gyro_state);
318 if (ret) {
319 dev_err(&pdev->dev, "failed to setup attributes\n");
320 goto error_free_dev_mem;
321 }
322
323 indio_dev->channels = channels;
324 indio_dev->num_channels = ARRAY_SIZE(gyro_3d_channels);
325 indio_dev->dev.parent = &pdev->dev;
326 indio_dev->info = &gyro_3d_info;
327 indio_dev->name = name;
328 indio_dev->modes = INDIO_DIRECT_MODE;
329
330 ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
331 NULL, NULL);
332 if (ret) {
333 dev_err(&pdev->dev, "failed to initialize trigger buffer\n");
334 goto error_free_dev_mem;
335 }
336 gyro_state->common_attributes.data_ready = false;
337 ret = hid_sensor_setup_trigger(indio_dev, name,
338 &gyro_state->common_attributes);
339 if (ret < 0) {
340 dev_err(&pdev->dev, "trigger setup failed\n");
341 goto error_unreg_buffer_funcs;
342 }
343
344 ret = iio_device_register(indio_dev);
345 if (ret) {
346 dev_err(&pdev->dev, "device register failed\n");
347 goto error_remove_trigger;
348 }
349
350 gyro_state->callbacks.send_event = gyro_3d_proc_event;
351 gyro_state->callbacks.capture_sample = gyro_3d_capture_sample;
352 gyro_state->callbacks.pdev = pdev;
353 ret = sensor_hub_register_callback(hsdev, HID_USAGE_SENSOR_GYRO_3D,
354 &gyro_state->callbacks);
355 if (ret < 0) {
356 dev_err(&pdev->dev, "callback reg failed\n");
357 goto error_iio_unreg;
358 }
359
360 return ret;
361
362error_iio_unreg:
363 iio_device_unregister(indio_dev);
364error_remove_trigger:
365 hid_sensor_remove_trigger(indio_dev);
366error_unreg_buffer_funcs:
367 iio_triggered_buffer_cleanup(indio_dev);
368error_free_dev_mem:
369 kfree(indio_dev->channels);
370error_free_dev:
371 iio_device_free(indio_dev);
372error_ret:
373 return ret;
374}
375
376
377static int hid_gyro_3d_remove(struct platform_device *pdev)
378{
379 struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
380 struct iio_dev *indio_dev = platform_get_drvdata(pdev);
381
382 sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_GYRO_3D);
383 iio_device_unregister(indio_dev);
384 hid_sensor_remove_trigger(indio_dev);
385 iio_triggered_buffer_cleanup(indio_dev);
386 kfree(indio_dev->channels);
387 iio_device_free(indio_dev);
388
389 return 0;
390}
391
392static struct platform_driver hid_gyro_3d_platform_driver = {
393 .driver = {
394 .name = DRIVER_NAME,
395 .owner = THIS_MODULE,
396 },
397 .probe = hid_gyro_3d_probe,
398 .remove = hid_gyro_3d_remove,
399};
400module_platform_driver(hid_gyro_3d_platform_driver);
401
402MODULE_DESCRIPTION("HID Sensor Gyroscope 3D");
403MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
404MODULE_LICENSE("GPL");
405
