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