Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * HID Sensors Driver
0004  * Copyright (c) 2012, Intel Corporation.
0005  */
0006 #include <linux/device.h>
0007 #include <linux/platform_device.h>
0008 #include <linux/module.h>
0009 #include <linux/mod_devicetable.h>
0010 #include <linux/slab.h>
0011 #include <linux/hid-sensor-hub.h>
0012 #include <linux/iio/iio.h>
0013 #include <linux/iio/buffer.h>
0014 #include "../common/hid-sensors/hid-sensor-trigger.h"
0015 
0016 enum {
0017     CHANNEL_SCAN_INDEX_INTENSITY = 0,
0018     CHANNEL_SCAN_INDEX_ILLUM = 1,
0019     CHANNEL_SCAN_INDEX_MAX
0020 };
0021 
0022 #define CHANNEL_SCAN_INDEX_TIMESTAMP CHANNEL_SCAN_INDEX_MAX
0023 
0024 struct als_state {
0025     struct hid_sensor_hub_callbacks callbacks;
0026     struct hid_sensor_common common_attributes;
0027     struct hid_sensor_hub_attribute_info als_illum;
0028     struct {
0029         u32 illum[CHANNEL_SCAN_INDEX_MAX];
0030         u64 timestamp __aligned(8);
0031     } scan;
0032     int scale_pre_decml;
0033     int scale_post_decml;
0034     int scale_precision;
0035     int value_offset;
0036     s64 timestamp;
0037 };
0038 
0039 static const u32 als_sensitivity_addresses[] = {
0040     HID_USAGE_SENSOR_DATA_LIGHT,
0041     HID_USAGE_SENSOR_LIGHT_ILLUM,
0042 };
0043 
0044 /* Channel definitions */
0045 static const struct iio_chan_spec als_channels[] = {
0046     {
0047         .type = IIO_INTENSITY,
0048         .modified = 1,
0049         .channel2 = IIO_MOD_LIGHT_BOTH,
0050         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
0051         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
0052         BIT(IIO_CHAN_INFO_SCALE) |
0053         BIT(IIO_CHAN_INFO_SAMP_FREQ) |
0054         BIT(IIO_CHAN_INFO_HYSTERESIS) |
0055         BIT(IIO_CHAN_INFO_HYSTERESIS_RELATIVE),
0056         .scan_index = CHANNEL_SCAN_INDEX_INTENSITY,
0057     },
0058     {
0059         .type = IIO_LIGHT,
0060         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
0061         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
0062         BIT(IIO_CHAN_INFO_SCALE) |
0063         BIT(IIO_CHAN_INFO_SAMP_FREQ) |
0064         BIT(IIO_CHAN_INFO_HYSTERESIS) |
0065         BIT(IIO_CHAN_INFO_HYSTERESIS_RELATIVE),
0066         .scan_index = CHANNEL_SCAN_INDEX_ILLUM,
0067     },
0068     IIO_CHAN_SOFT_TIMESTAMP(CHANNEL_SCAN_INDEX_TIMESTAMP)
0069 };
0070 
0071 /* Adjust channel real bits based on report descriptor */
0072 static void als_adjust_channel_bit_mask(struct iio_chan_spec *channels,
0073                     int channel, int size)
0074 {
0075     channels[channel].scan_type.sign = 's';
0076     /* Real storage bits will change based on the report desc. */
0077     channels[channel].scan_type.realbits = size * 8;
0078     /* Maximum size of a sample to capture is u32 */
0079     channels[channel].scan_type.storagebits = sizeof(u32) * 8;
0080 }
0081 
0082 /* Channel read_raw handler */
0083 static int als_read_raw(struct iio_dev *indio_dev,
0084                   struct iio_chan_spec const *chan,
0085                   int *val, int *val2,
0086                   long mask)
0087 {
0088     struct als_state *als_state = iio_priv(indio_dev);
0089     int report_id = -1;
0090     u32 address;
0091     int ret_type;
0092     s32 min;
0093 
0094     *val = 0;
0095     *val2 = 0;
0096     switch (mask) {
0097     case IIO_CHAN_INFO_RAW:
0098         switch (chan->scan_index) {
0099         case  CHANNEL_SCAN_INDEX_INTENSITY:
0100         case  CHANNEL_SCAN_INDEX_ILLUM:
0101             report_id = als_state->als_illum.report_id;
0102             min = als_state->als_illum.logical_minimum;
0103             address = HID_USAGE_SENSOR_LIGHT_ILLUM;
0104             break;
0105         default:
0106             report_id = -1;
0107             break;
0108         }
0109         if (report_id >= 0) {
0110             hid_sensor_power_state(&als_state->common_attributes,
0111                         true);
0112             *val = sensor_hub_input_attr_get_raw_value(
0113                     als_state->common_attributes.hsdev,
0114                     HID_USAGE_SENSOR_ALS, address,
0115                     report_id,
0116                     SENSOR_HUB_SYNC,
0117                     min < 0);
0118             hid_sensor_power_state(&als_state->common_attributes,
0119                         false);
0120         } else {
0121             *val = 0;
0122             return -EINVAL;
0123         }
0124         ret_type = IIO_VAL_INT;
0125         break;
0126     case IIO_CHAN_INFO_SCALE:
0127         *val = als_state->scale_pre_decml;
0128         *val2 = als_state->scale_post_decml;
0129         ret_type = als_state->scale_precision;
0130         break;
0131     case IIO_CHAN_INFO_OFFSET:
0132         *val = als_state->value_offset;
0133         ret_type = IIO_VAL_INT;
0134         break;
0135     case IIO_CHAN_INFO_SAMP_FREQ:
0136         ret_type = hid_sensor_read_samp_freq_value(
0137                 &als_state->common_attributes, val, val2);
0138         break;
0139     case IIO_CHAN_INFO_HYSTERESIS:
0140         ret_type = hid_sensor_read_raw_hyst_value(
0141                 &als_state->common_attributes, val, val2);
0142         break;
0143     case IIO_CHAN_INFO_HYSTERESIS_RELATIVE:
0144         ret_type = hid_sensor_read_raw_hyst_rel_value(
0145                 &als_state->common_attributes, val, val2);
0146         break;
0147     default:
0148         ret_type = -EINVAL;
0149         break;
0150     }
0151 
0152     return ret_type;
0153 }
0154 
0155 /* Channel write_raw handler */
0156 static int als_write_raw(struct iio_dev *indio_dev,
0157                    struct iio_chan_spec const *chan,
0158                    int val,
0159                    int val2,
0160                    long mask)
0161 {
0162     struct als_state *als_state = iio_priv(indio_dev);
0163     int ret = 0;
0164 
0165     switch (mask) {
0166     case IIO_CHAN_INFO_SAMP_FREQ:
0167         ret = hid_sensor_write_samp_freq_value(
0168                 &als_state->common_attributes, val, val2);
0169         break;
0170     case IIO_CHAN_INFO_HYSTERESIS:
0171         ret = hid_sensor_write_raw_hyst_value(
0172                 &als_state->common_attributes, val, val2);
0173         break;
0174     case IIO_CHAN_INFO_HYSTERESIS_RELATIVE:
0175         ret = hid_sensor_write_raw_hyst_rel_value(
0176                 &als_state->common_attributes, val, val2);
0177         break;
0178     default:
0179         ret = -EINVAL;
0180     }
0181 
0182     return ret;
0183 }
0184 
0185 static const struct iio_info als_info = {
0186     .read_raw = &als_read_raw,
0187     .write_raw = &als_write_raw,
0188 };
0189 
0190 /* Callback handler to send event after all samples are received and captured */
0191 static int als_proc_event(struct hid_sensor_hub_device *hsdev,
0192                 unsigned usage_id,
0193                 void *priv)
0194 {
0195     struct iio_dev *indio_dev = platform_get_drvdata(priv);
0196     struct als_state *als_state = iio_priv(indio_dev);
0197 
0198     dev_dbg(&indio_dev->dev, "als_proc_event\n");
0199     if (atomic_read(&als_state->common_attributes.data_ready)) {
0200         if (!als_state->timestamp)
0201             als_state->timestamp = iio_get_time_ns(indio_dev);
0202 
0203         iio_push_to_buffers_with_timestamp(indio_dev, &als_state->scan,
0204                            als_state->timestamp);
0205         als_state->timestamp = 0;
0206     }
0207 
0208     return 0;
0209 }
0210 
0211 /* Capture samples in local storage */
0212 static int als_capture_sample(struct hid_sensor_hub_device *hsdev,
0213                 unsigned usage_id,
0214                 size_t raw_len, char *raw_data,
0215                 void *priv)
0216 {
0217     struct iio_dev *indio_dev = platform_get_drvdata(priv);
0218     struct als_state *als_state = iio_priv(indio_dev);
0219     int ret = -EINVAL;
0220     u32 sample_data = *(u32 *)raw_data;
0221 
0222     switch (usage_id) {
0223     case HID_USAGE_SENSOR_LIGHT_ILLUM:
0224         als_state->scan.illum[CHANNEL_SCAN_INDEX_INTENSITY] = sample_data;
0225         als_state->scan.illum[CHANNEL_SCAN_INDEX_ILLUM] = sample_data;
0226         ret = 0;
0227         break;
0228     case HID_USAGE_SENSOR_TIME_TIMESTAMP:
0229         als_state->timestamp = hid_sensor_convert_timestamp(&als_state->common_attributes,
0230                                     *(s64 *)raw_data);
0231         break;
0232     default:
0233         break;
0234     }
0235 
0236     return ret;
0237 }
0238 
0239 /* Parse report which is specific to an usage id*/
0240 static int als_parse_report(struct platform_device *pdev,
0241                 struct hid_sensor_hub_device *hsdev,
0242                 struct iio_chan_spec *channels,
0243                 unsigned usage_id,
0244                 struct als_state *st)
0245 {
0246     int ret;
0247 
0248     ret = sensor_hub_input_get_attribute_info(hsdev, HID_INPUT_REPORT,
0249             usage_id,
0250             HID_USAGE_SENSOR_LIGHT_ILLUM,
0251             &st->als_illum);
0252     if (ret < 0)
0253         return ret;
0254     als_adjust_channel_bit_mask(channels, CHANNEL_SCAN_INDEX_INTENSITY,
0255                     st->als_illum.size);
0256     als_adjust_channel_bit_mask(channels, CHANNEL_SCAN_INDEX_ILLUM,
0257                     st->als_illum.size);
0258 
0259     dev_dbg(&pdev->dev, "als %x:%x\n", st->als_illum.index,
0260             st->als_illum.report_id);
0261 
0262     st->scale_precision = hid_sensor_format_scale(
0263                 HID_USAGE_SENSOR_ALS,
0264                 &st->als_illum,
0265                 &st->scale_pre_decml, &st->scale_post_decml);
0266 
0267     return ret;
0268 }
0269 
0270 /* Function to initialize the processing for usage id */
0271 static int hid_als_probe(struct platform_device *pdev)
0272 {
0273     int ret = 0;
0274     static const char *name = "als";
0275     struct iio_dev *indio_dev;
0276     struct als_state *als_state;
0277     struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
0278 
0279     indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(struct als_state));
0280     if (!indio_dev)
0281         return -ENOMEM;
0282     platform_set_drvdata(pdev, indio_dev);
0283 
0284     als_state = iio_priv(indio_dev);
0285     als_state->common_attributes.hsdev = hsdev;
0286     als_state->common_attributes.pdev = pdev;
0287 
0288     ret = hid_sensor_parse_common_attributes(hsdev, HID_USAGE_SENSOR_ALS,
0289                     &als_state->common_attributes,
0290                     als_sensitivity_addresses,
0291                     ARRAY_SIZE(als_sensitivity_addresses));
0292     if (ret) {
0293         dev_err(&pdev->dev, "failed to setup common attributes\n");
0294         return ret;
0295     }
0296 
0297     indio_dev->channels = devm_kmemdup(&pdev->dev, als_channels,
0298                        sizeof(als_channels), GFP_KERNEL);
0299     if (!indio_dev->channels) {
0300         dev_err(&pdev->dev, "failed to duplicate channels\n");
0301         return -ENOMEM;
0302     }
0303 
0304     ret = als_parse_report(pdev, hsdev,
0305                    (struct iio_chan_spec *)indio_dev->channels,
0306                    HID_USAGE_SENSOR_ALS, als_state);
0307     if (ret) {
0308         dev_err(&pdev->dev, "failed to setup attributes\n");
0309         return ret;
0310     }
0311 
0312     indio_dev->num_channels =
0313                 ARRAY_SIZE(als_channels);
0314     indio_dev->info = &als_info;
0315     indio_dev->name = name;
0316     indio_dev->modes = INDIO_DIRECT_MODE;
0317 
0318     atomic_set(&als_state->common_attributes.data_ready, 0);
0319 
0320     ret = hid_sensor_setup_trigger(indio_dev, name,
0321                 &als_state->common_attributes);
0322     if (ret < 0) {
0323         dev_err(&pdev->dev, "trigger setup failed\n");
0324         return ret;
0325     }
0326 
0327     ret = iio_device_register(indio_dev);
0328     if (ret) {
0329         dev_err(&pdev->dev, "device register failed\n");
0330         goto error_remove_trigger;
0331     }
0332 
0333     als_state->callbacks.send_event = als_proc_event;
0334     als_state->callbacks.capture_sample = als_capture_sample;
0335     als_state->callbacks.pdev = pdev;
0336     ret = sensor_hub_register_callback(hsdev, HID_USAGE_SENSOR_ALS,
0337                     &als_state->callbacks);
0338     if (ret < 0) {
0339         dev_err(&pdev->dev, "callback reg failed\n");
0340         goto error_iio_unreg;
0341     }
0342 
0343     return ret;
0344 
0345 error_iio_unreg:
0346     iio_device_unregister(indio_dev);
0347 error_remove_trigger:
0348     hid_sensor_remove_trigger(indio_dev, &als_state->common_attributes);
0349     return ret;
0350 }
0351 
0352 /* Function to deinitialize the processing for usage id */
0353 static int hid_als_remove(struct platform_device *pdev)
0354 {
0355     struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
0356     struct iio_dev *indio_dev = platform_get_drvdata(pdev);
0357     struct als_state *als_state = iio_priv(indio_dev);
0358 
0359     sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_ALS);
0360     iio_device_unregister(indio_dev);
0361     hid_sensor_remove_trigger(indio_dev, &als_state->common_attributes);
0362 
0363     return 0;
0364 }
0365 
0366 static const struct platform_device_id hid_als_ids[] = {
0367     {
0368         /* Format: HID-SENSOR-usage_id_in_hex_lowercase */
0369         .name = "HID-SENSOR-200041",
0370     },
0371     { /* sentinel */ }
0372 };
0373 MODULE_DEVICE_TABLE(platform, hid_als_ids);
0374 
0375 static struct platform_driver hid_als_platform_driver = {
0376     .id_table = hid_als_ids,
0377     .driver = {
0378         .name   = KBUILD_MODNAME,
0379         .pm = &hid_sensor_pm_ops,
0380     },
0381     .probe      = hid_als_probe,
0382     .remove     = hid_als_remove,
0383 };
0384 module_platform_driver(hid_als_platform_driver);
0385 
0386 MODULE_DESCRIPTION("HID Sensor ALS");
0387 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@intel.com>");
0388 MODULE_LICENSE("GPL");
0389 MODULE_IMPORT_NS(IIO_HID);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!