linux/drivers/iio/light/hid-sensor-prox.c
<<
>>
Prefs
   1/*
   2 * HID Sensors Driver
   3 * Copyright (c) 2014, 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.
  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_PRESENCE 0
  34
  35struct prox_state {
  36        struct hid_sensor_hub_callbacks callbacks;
  37        struct hid_sensor_common common_attributes;
  38        struct hid_sensor_hub_attribute_info prox_attr;
  39        u32 human_presence;
  40};
  41
  42/* Channel definitions */
  43static const struct iio_chan_spec prox_channels[] = {
  44        {
  45                .type = IIO_PROXIMITY,
  46                .modified = 1,
  47                .channel2 = IIO_NO_MOD,
  48                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
  49                .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_OFFSET) |
  50                BIT(IIO_CHAN_INFO_SCALE) |
  51                BIT(IIO_CHAN_INFO_SAMP_FREQ) |
  52                BIT(IIO_CHAN_INFO_HYSTERESIS),
  53                .scan_index = CHANNEL_SCAN_INDEX_PRESENCE,
  54        }
  55};
  56
  57/* Adjust channel real bits based on report descriptor */
  58static void prox_adjust_channel_bit_mask(struct iio_chan_spec *channels,
  59                                        int channel, int size)
  60{
  61        channels[channel].scan_type.sign = 's';
  62        /* Real storage bits will change based on the report desc. */
  63        channels[channel].scan_type.realbits = size * 8;
  64        /* Maximum size of a sample to capture is u32 */
  65        channels[channel].scan_type.storagebits = sizeof(u32) * 8;
  66}
  67
  68/* Channel read_raw handler */
  69static int prox_read_raw(struct iio_dev *indio_dev,
  70                              struct iio_chan_spec const *chan,
  71                              int *val, int *val2,
  72                              long mask)
  73{
  74        struct prox_state *prox_state = iio_priv(indio_dev);
  75        int report_id = -1;
  76        u32 address;
  77        int ret_type;
  78        s32 poll_value;
  79
  80        *val = 0;
  81        *val2 = 0;
  82        switch (mask) {
  83        case IIO_CHAN_INFO_RAW:
  84                switch (chan->scan_index) {
  85                case  CHANNEL_SCAN_INDEX_PRESENCE:
  86                        report_id = prox_state->prox_attr.report_id;
  87                        address =
  88                        HID_USAGE_SENSOR_HUMAN_PRESENCE;
  89                        break;
  90                default:
  91                        report_id = -1;
  92                        break;
  93                }
  94                if (report_id >= 0) {
  95                        poll_value = hid_sensor_read_poll_value(
  96                                        &prox_state->common_attributes);
  97                        if (poll_value < 0)
  98                                return -EINVAL;
  99
 100                        hid_sensor_power_state(&prox_state->common_attributes,
 101                                                true);
 102
 103                        msleep_interruptible(poll_value * 2);
 104
 105                        *val = sensor_hub_input_attr_get_raw_value(
 106                                prox_state->common_attributes.hsdev,
 107                                HID_USAGE_SENSOR_PROX, address,
 108                                report_id);
 109                        hid_sensor_power_state(&prox_state->common_attributes,
 110                                                false);
 111                } else {
 112                        *val = 0;
 113                        return -EINVAL;
 114                }
 115                ret_type = IIO_VAL_INT;
 116                break;
 117        case IIO_CHAN_INFO_SCALE:
 118                *val = prox_state->prox_attr.units;
 119                ret_type = IIO_VAL_INT;
 120                break;
 121        case IIO_CHAN_INFO_OFFSET:
 122                *val = hid_sensor_convert_exponent(
 123                                prox_state->prox_attr.unit_expo);
 124                ret_type = IIO_VAL_INT;
 125                break;
 126        case IIO_CHAN_INFO_SAMP_FREQ:
 127                ret_type = hid_sensor_read_samp_freq_value(
 128                                &prox_state->common_attributes, val, val2);
 129                break;
 130        case IIO_CHAN_INFO_HYSTERESIS:
 131                ret_type = hid_sensor_read_raw_hyst_value(
 132                                &prox_state->common_attributes, val, val2);
 133                break;
 134        default:
 135                ret_type = -EINVAL;
 136                break;
 137        }
 138
 139        return ret_type;
 140}
 141
 142/* Channel write_raw handler */
 143static int prox_write_raw(struct iio_dev *indio_dev,
 144                               struct iio_chan_spec const *chan,
 145                               int val,
 146                               int val2,
 147                               long mask)
 148{
 149        struct prox_state *prox_state = iio_priv(indio_dev);
 150        int ret = 0;
 151
 152        switch (mask) {
 153        case IIO_CHAN_INFO_SAMP_FREQ:
 154                ret = hid_sensor_write_samp_freq_value(
 155                                &prox_state->common_attributes, val, val2);
 156                break;
 157        case IIO_CHAN_INFO_HYSTERESIS:
 158                ret = hid_sensor_write_raw_hyst_value(
 159                                &prox_state->common_attributes, val, val2);
 160                break;
 161        default:
 162                ret = -EINVAL;
 163        }
 164
 165        return ret;
 166}
 167
 168static const struct iio_info prox_info = {
 169        .driver_module = THIS_MODULE,
 170        .read_raw = &prox_read_raw,
 171        .write_raw = &prox_write_raw,
 172};
 173
 174/* Function to push data to buffer */
 175static void hid_sensor_push_data(struct iio_dev *indio_dev, const void *data,
 176                                        int len)
 177{
 178        dev_dbg(&indio_dev->dev, "hid_sensor_push_data\n");
 179        iio_push_to_buffers(indio_dev, data);
 180}
 181
 182/* Callback handler to send event after all samples are received and captured */
 183static int prox_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 prox_state *prox_state = iio_priv(indio_dev);
 189
 190        dev_dbg(&indio_dev->dev, "prox_proc_event\n");
 191        if (atomic_read(&prox_state->common_attributes.data_ready))
 192                hid_sensor_push_data(indio_dev,
 193                                &prox_state->human_presence,
 194                                sizeof(prox_state->human_presence));
 195
 196        return 0;
 197}
 198
 199/* Capture samples in local storage */
 200static int prox_capture_sample(struct hid_sensor_hub_device *hsdev,
 201                                unsigned usage_id,
 202                                size_t raw_len, char *raw_data,
 203                                void *priv)
 204{
 205        struct iio_dev *indio_dev = platform_get_drvdata(priv);
 206        struct prox_state *prox_state = iio_priv(indio_dev);
 207        int ret = -EINVAL;
 208
 209        switch (usage_id) {
 210        case HID_USAGE_SENSOR_HUMAN_PRESENCE:
 211                prox_state->human_presence = *(u32 *)raw_data;
 212                ret = 0;
 213                break;
 214        default:
 215                break;
 216        }
 217
 218        return ret;
 219}
 220
 221/* Parse report which is specific to an usage id*/
 222static int prox_parse_report(struct platform_device *pdev,
 223                                struct hid_sensor_hub_device *hsdev,
 224                                struct iio_chan_spec *channels,
 225                                unsigned usage_id,
 226                                struct prox_state *st)
 227{
 228        int ret;
 229
 230        ret = sensor_hub_input_get_attribute_info(hsdev, HID_INPUT_REPORT,
 231                        usage_id,
 232                        HID_USAGE_SENSOR_HUMAN_PRESENCE,
 233                        &st->prox_attr);
 234        if (ret < 0)
 235                return ret;
 236        prox_adjust_channel_bit_mask(channels, CHANNEL_SCAN_INDEX_PRESENCE,
 237                                        st->prox_attr.size);
 238
 239        dev_dbg(&pdev->dev, "prox %x:%x\n", st->prox_attr.index,
 240                        st->prox_attr.report_id);
 241
 242        /* Set Sensitivity field ids, when there is no individual modifier */
 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_PRESENCE,
 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/* Function to initialize the processing for usage id */
 257static int hid_prox_probe(struct platform_device *pdev)
 258{
 259        int ret = 0;
 260        static const char *name = "prox";
 261        struct iio_dev *indio_dev;
 262        struct prox_state *prox_state;
 263        struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
 264        struct iio_chan_spec *channels;
 265
 266        indio_dev = devm_iio_device_alloc(&pdev->dev,
 267                                sizeof(struct prox_state));
 268        if (!indio_dev)
 269                return -ENOMEM;
 270        platform_set_drvdata(pdev, indio_dev);
 271
 272        prox_state = iio_priv(indio_dev);
 273        prox_state->common_attributes.hsdev = hsdev;
 274        prox_state->common_attributes.pdev = pdev;
 275
 276        ret = hid_sensor_parse_common_attributes(hsdev, HID_USAGE_SENSOR_PROX,
 277                                        &prox_state->common_attributes);
 278        if (ret) {
 279                dev_err(&pdev->dev, "failed to setup common attributes\n");
 280                return ret;
 281        }
 282
 283        channels = kmemdup(prox_channels, sizeof(prox_channels), GFP_KERNEL);
 284        if (!channels) {
 285                dev_err(&pdev->dev, "failed to duplicate channels\n");
 286                return -ENOMEM;
 287        }
 288
 289        ret = prox_parse_report(pdev, hsdev, channels,
 290                                HID_USAGE_SENSOR_PROX, prox_state);
 291        if (ret) {
 292                dev_err(&pdev->dev, "failed to setup attributes\n");
 293                goto error_free_dev_mem;
 294        }
 295
 296        indio_dev->channels = channels;
 297        indio_dev->num_channels =
 298                                ARRAY_SIZE(prox_channels);
 299        indio_dev->dev.parent = &pdev->dev;
 300        indio_dev->info = &prox_info;
 301        indio_dev->name = name;
 302        indio_dev->modes = INDIO_DIRECT_MODE;
 303
 304        ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
 305                NULL, NULL);
 306        if (ret) {
 307                dev_err(&pdev->dev, "failed to initialize trigger buffer\n");
 308                goto error_free_dev_mem;
 309        }
 310        atomic_set(&prox_state->common_attributes.data_ready, 0);
 311        ret = hid_sensor_setup_trigger(indio_dev, name,
 312                                &prox_state->common_attributes);
 313        if (ret) {
 314                dev_err(&pdev->dev, "trigger setup failed\n");
 315                goto error_unreg_buffer_funcs;
 316        }
 317
 318        ret = iio_device_register(indio_dev);
 319        if (ret) {
 320                dev_err(&pdev->dev, "device register failed\n");
 321                goto error_remove_trigger;
 322        }
 323
 324        prox_state->callbacks.send_event = prox_proc_event;
 325        prox_state->callbacks.capture_sample = prox_capture_sample;
 326        prox_state->callbacks.pdev = pdev;
 327        ret = sensor_hub_register_callback(hsdev, HID_USAGE_SENSOR_PROX,
 328                                        &prox_state->callbacks);
 329        if (ret < 0) {
 330                dev_err(&pdev->dev, "callback reg failed\n");
 331                goto error_iio_unreg;
 332        }
 333
 334        return ret;
 335
 336error_iio_unreg:
 337        iio_device_unregister(indio_dev);
 338error_remove_trigger:
 339        hid_sensor_remove_trigger(&prox_state->common_attributes);
 340error_unreg_buffer_funcs:
 341        iio_triggered_buffer_cleanup(indio_dev);
 342error_free_dev_mem:
 343        kfree(indio_dev->channels);
 344        return ret;
 345}
 346
 347/* Function to deinitialize the processing for usage id */
 348static int hid_prox_remove(struct platform_device *pdev)
 349{
 350        struct hid_sensor_hub_device *hsdev = pdev->dev.platform_data;
 351        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 352        struct prox_state *prox_state = iio_priv(indio_dev);
 353
 354        sensor_hub_remove_callback(hsdev, HID_USAGE_SENSOR_PROX);
 355        iio_device_unregister(indio_dev);
 356        hid_sensor_remove_trigger(&prox_state->common_attributes);
 357        iio_triggered_buffer_cleanup(indio_dev);
 358        kfree(indio_dev->channels);
 359
 360        return 0;
 361}
 362
 363static struct platform_device_id hid_prox_ids[] = {
 364        {
 365                /* Format: HID-SENSOR-usage_id_in_hex_lowercase */
 366                .name = "HID-SENSOR-200011",
 367        },
 368        { /* sentinel */ }
 369};
 370MODULE_DEVICE_TABLE(platform, hid_prox_ids);
 371
 372static struct platform_driver hid_prox_platform_driver = {
 373        .id_table = hid_prox_ids,
 374        .driver = {
 375                .name   = KBUILD_MODNAME,
 376        },
 377        .probe          = hid_prox_probe,
 378        .remove         = hid_prox_remove,
 379};
 380module_platform_driver(hid_prox_platform_driver);
 381
 382MODULE_DESCRIPTION("HID Sensor Proximity");
 383MODULE_AUTHOR("Archana Patni <archana.patni@intel.com>");
 384MODULE_LICENSE("GPL");
 385
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.