Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/iio/light/hid-sensor-als.c

  1 /*
  2  * HID Sensors Driver
  3  * Copyright (c) 2012, Intel Corporation.
  4  *
  5  * This program is free software; you can redistribute it and/or modify it
  6  * under the terms and conditions of the GNU General Public License,
  7  * version 2, as published by the Free Software Foundation.
  8  *
  9  * This program is distributed in the hope it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 12  * more details.
 13  *
 14  * You should have received a copy of the GNU General Public License along with
 15  * this program; if not, write to the Free Software Foundation, Inc.,
 16  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 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 #define CHANNEL_SCAN_INDEX_ILLUM 0
 34 
 35 struct als_state {
 36         struct hid_sensor_hub_callbacks callbacks;
 37         struct hid_sensor_common common_attributes;
 38         struct hid_sensor_hub_attribute_info als_illum;
 39         u32 illum;
 40 };
 41 
 42 /* Channel definitions */
 43 static const struct iio_chan_spec als_channels[] = {
 44         {
 45                 .type = IIO_INTENSITY,
 46                 .modified = 1,
 47                 .channel2 = IIO_MOD_LIGHT_BOTH,
 48                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
 49                 BIT(IIO_CHAN_INFO_SCALE) |
 50                 BIT(IIO_CHAN_INFO_SAMP_FREQ) |
 51                 BIT(IIO_CHAN_INFO_HYSTERESIS),
 52                 .scan_index = CHANNEL_SCAN_INDEX_ILLUM,
 53         }
 54 };
 55 
 56 /* Adjust channel real bits based on report descriptor */
 57 static void als_adjust_channel_bit_mask(struct iio_chan_spec *channels,
 58                                         int channel, int size)
 59 {
 60         channels[channel].scan_type.sign = 's';
 61         /* Real storage bits will change based on the report desc. */
 62         channels[channel].scan_type.realbits = size * 8;
 63         /* Maximum size of a sample to capture is u32 */
 64         channels[channel].scan_type.storagebits = sizeof(u32) * 8;
 65 }
 66 
 67 /* Channel read_raw handler */
 68 static int als_read_raw(struct iio_dev *indio_dev,
 69                               struct iio_chan_spec const *chan,
 70                               int *val, int *val2,
 71                               long mask)
 72 {
 73         struct als_state *als_state = iio_priv(indio_dev);
 74         int report_id = -1;
 75         u32 address;
 76         int ret;
 77         int ret_type;
 78 
 79         *val = 0;
 80         *val2 = 0;
 81         switch (mask) {
 82         case 0:
 83                 switch (chan->scan_index) {
 84                 case  CHANNEL_SCAN_INDEX_ILLUM:
 85                         report_id = als_state->als_illum.report_id;
 86                         address =
 87                         HID_USAGE_SENSOR_LIGHT_ILLUM;
 88                         break;
 89                 default:
 90                         report_id = -1;
 91                         break;
 92                 }
 93                 if (report_id >= 0)
 94                         *val = sensor_hub_input_attr_get_raw_value(
 95                                 als_state->common_attributes.hsdev,
 96                                 HID_USAGE_SENSOR_ALS, address,
 97                                 report_id);
 98                 else {
 99                         *val = 0;
100                         return -EINVAL;
101                 }
102                 ret_type = IIO_VAL_INT;
103                 break;
104         case IIO_CHAN_INFO_SCALE:
105                 *val = als_state->als_illum.units;
106                 ret_type = IIO_VAL_INT;
107                 break;
108         case IIO_CHAN_INFO_OFFSET:
109                 *val = hid_sensor_convert_exponent(
110                                 als_state->als_illum.unit_expo);
111                 ret_type = IIO_VAL_INT;
112                 break;
113         case IIO_CHAN_INFO_SAMP_FREQ:
114                 ret = hid_sensor_read_samp_freq_value(
115                                 &als_state->common_attributes, val, val2);
116                 ret_type = IIO_VAL_INT_PLUS_MICRO;
117                 break;
118         case IIO_CHAN_INFO_HYSTERESIS:
119                 ret = hid_sensor_read_raw_hyst_value(
120                                 &als_state->common_attributes, val, val2);
121                 ret_type = IIO_VAL_INT_PLUS_MICRO;
122                 break;
123         default:
124                 ret_type = -EINVAL;
125                 break;
126         }
127 
128         return ret_type;
129 }
130 
131 /* Channel write_raw handler */
132 static int als_write_raw(struct iio_dev *indio_dev,
133                                struct iio_chan_spec const *chan,
134                                int val,
135                                int val2,
136                                long mask)
137 {
138         struct als_state *als_state = iio_priv(indio_dev);
139         int ret = 0;
140 
141         switch (mask) {
142         case IIO_CHAN_INFO_SAMP_FREQ:
143                 ret = hid_sensor_write_samp_freq_value(
144                                 &als_state->common_attributes, val, val2);
145                 break;
146         case IIO_CHAN_INFO_HYSTERESIS:
147                 ret = hid_sensor_write_raw_hyst_value(
148                                 &als_state->common_attributes, val, val2);
149                 break;
150         default:
151                 ret = -EINVAL;
152         }
153 
154         return ret;
155 }
156 
157 static const struct iio_info als_info = {
158         .driver_module = THIS_MODULE,
159         .read_raw = &als_read_raw,
160         .write_raw = &als_write_raw,
161 };
162 
163 /* Function to push data to buffer */
164 static void hid_sensor_push_data(struct iio_dev *indio_dev, const void *data,
165                                         int len)
166 {
167         dev_dbg(&indio_dev->dev, "hid_sensor_push_data\n");
168         iio_push_to_buffers(indio_dev, data);
169 }
170 
171 /* Callback handler to send event after all samples are received and captured */
172 static int als_proc_event(struct hid_sensor_hub_device *hsdev,
173                                 unsigned usage_id,
174                                 void *priv)
175 {
176         struct iio_dev *indio_dev = platform_get_drvdata(priv);
177         struct als_state *als_state = iio_priv(indio_dev);
178 
179         dev_dbg(&indio_dev->dev, "als_proc_event [%d]\n",
180                                 als_state->common_attributes.data_ready);
181         if (als_state->common_attributes.data_ready)
182                 hid_sensor_push_data(indio_dev,
183                                 &als_state->illum,
184                                 sizeof(als_state->illum));
185 
186         return 0;
187 }
188 
189 /* Capture samples in local storage */
190 static int als_capture_sample(struct hid_sensor_hub_device *hsdev,
191                                 unsigned usage_id,
192                                 size_t raw_len, char *raw_data,
193                                 void *priv)
194 {
195         struct iio_dev *indio_dev = platform_get_drvdata(priv);
196         struct als_state *als_state = iio_priv(indio_dev);
197         int ret = -EINVAL;
198 
199         switch (usage_id) {
200         case HID_USAGE_SENSOR_LIGHT_ILLUM:
201                 als_state->illum = *(u32 *)raw_data;
202                 ret = 0;
203                 break;
204         default:
205                 break;
206         }
207 
208         return ret;
209 }
210 
211 /* Parse report which is specific to an usage id*/
212 static int als_parse_report(struct platform_device *pdev,
213                                 struct hid_sensor_hub_device *hsdev,
214                                 struct iio_chan_spec *channels,
215                                 unsigned usage_id,
216                                 struct als_state *st)
217 {
218         int ret;
219 
220         ret = sensor_hub_input_get_attribute_info(hsdev, HID_INPUT_REPORT,
221                         usage_id,
222                         HID_USAGE_SENSOR_LIGHT_ILLUM,
223                         &st->als_illum);
224         if (ret < 0)
225                 return ret;
226         als_adjust_channel_bit_mask(channels, CHANNEL_SCAN_INDEX_ILLUM,
227                                         st->als_illum.size);
228 
229         dev_dbg(&pdev->dev, "als %x:%x\n", st->als_illum.index,
230                         st->als_illum.report_id);
231 
232         /* Set Sensitivity field ids, when there is no individual modifier */
233         if (st->common_attributes.sensitivity.index < 0) {
234                 sensor_hub_input_get_attribute_info(hsdev,
235                         HID_FEATURE_REPORT, usage_id,
236                         HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
237                         HID_USAGE_SENSOR_DATA_LIGHT,
238                         &st->common_attributes.sensitivity);
239                 dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
240                         st->common_attributes.sensitivity.index,
241                         st->common_attributes.sensitivity.report_id);
242         }
243         return ret;
244 }
245 
246 /* Function to initialize the processing for usage id */
247 static 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 = devm_iio_device_alloc(&pdev->dev, sizeof(struct als_state));
257         if (!indio_dev)
258                 return -ENOMEM;
259         platform_set_drvdata(pdev, indio_dev);
260 
261         als_state = iio_priv(indio_dev);
262         als_state->common_attributes.hsdev = hsdev;
263         als_state->common_attributes.pdev = pdev;
264 
265         ret = hid_sensor_parse_common_attributes(hsdev, HID_USAGE_SENSOR_ALS,
266                                         &als_state->common_attributes);
267         if (ret) {
268                 dev_err(&pdev->dev, "failed to setup common attributes\n");
269                 return ret;
270         }
271 
272         channels = kmemdup(als_channels, sizeof(als_channels), GFP_KERNEL);
273         if (!channels) {
274                 dev_err(&pdev->dev, "failed to duplicate channels\n");
275                 return -ENOMEM;
276         }
277 
278         ret = als_parse_report(pdev, hsdev, channels,
279                                 HID_USAGE_SENSOR_ALS, als_state);
280         if (ret) {
281                 dev_err(&pdev->dev, "failed to setup attributes\n");
282                 goto error_free_dev_mem;
283         }
284 
285         indio_dev->channels = channels;
286         indio_dev->num_channels =
287                                 ARRAY_SIZE(als_channels);
288         indio_dev->dev.parent = &pdev->dev;
289         indio_dev->info = &als_info;
290         indio_dev->name = name;
291         indio_dev->modes = INDIO_DIRECT_MODE;
292 
293         ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
294                 NULL, NULL);
295         if (ret) {
296                 dev_err(&pdev->dev, "failed to initialize trigger buffer\n");
297                 goto error_free_dev_mem;
298         }
299         als_state->common_attributes.data_ready = false;
300         ret = hid_sensor_setup_trigger(indio_dev, name,
301                                 &als_state->common_attributes);
302         if (ret < 0) {
303                 dev_err(&pdev->dev, "trigger setup failed\n");
304                 goto error_unreg_buffer_funcs;
305         }
306 
307         ret = iio_device_register(indio_dev);
308         if (ret) {
309                 dev_err(&pdev->dev, "device register failed\n");
310                 goto error_remove_trigger;
311         }
312 
313         als_state->callbacks.send_event = als_proc_event;
314         als_state->callbacks.capture_sample = als_capture_sample;
315         als_state->callbacks.pdev = pdev;
316         ret = sensor_hub_register_callback(hsdev, HID_USAGE_SENSOR_ALS,
317                                         &als_state->callbacks);
318         if (ret < 0) {
319                 dev_err(&pdev->dev, "callback reg failed\n");
320                 goto error_iio_unreg;
321         }
322 
323         return ret;
324 
325 error_iio_unreg:
326         iio_device_unregister(indio_dev);
327 error_remove_trigger:
328         hid_sensor_remove_trigger(&als_state->common_attributes);
329 error_unreg_buffer_funcs:
330         iio_triggered_buffer_cleanup(indio_dev);
331 error_free_dev_mem:
332         kfree(indio_dev->channels);
333         return ret;
334 }
335 
336 /* Function to deinitialize the processing for usage id */
337 static int hid_als_remove(struct platform_device *pdev)
338 {
339         struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
340         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
341         struct als_state *als_state = iio_priv(indio_dev);
342 
343         sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_ALS);
344         iio_device_unregister(indio_dev);
345         hid_sensor_remove_trigger(&als_state->common_attributes);
346         iio_triggered_buffer_cleanup(indio_dev);
347         kfree(indio_dev->channels);
348 
349         return 0;
350 }
351 
352 static struct platform_device_id hid_als_ids[] = {
353         {
354                 /* Format: HID-SENSOR-usage_id_in_hex_lowercase */
355                 .name = "HID-SENSOR-200041",
356         },
357         { /* sentinel */ }
358 };
359 MODULE_DEVICE_TABLE(platform, hid_als_ids);
360 
361 static struct platform_driver hid_als_platform_driver = {
362         .id_table = hid_als_ids,
363         .driver = {
364                 .name   = KBUILD_MODNAME,
365                 .owner  = THIS_MODULE,
366         },
367         .probe          = hid_als_probe,
368         .remove         = hid_als_remove,
369 };
370 module_platform_driver(hid_als_platform_driver);
371 
372 MODULE_DESCRIPTION("HID Sensor ALS");
373 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
374 MODULE_LICENSE("GPL");
375 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us