| /** |
| * opt3001.c - Texas Instruments OPT3001 Light Sensor |
| * |
| * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com |
| * |
| * Author: Felipe Balbi <balbi@ti.com> |
| * |
| * This program is free software: you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 of the License |
| * as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| */ |
| |
| #include <linux/bitops.h> |
| #include <linux/delay.h> |
| #include <linux/device.h> |
| #include <linux/i2c.h> |
| #include <linux/interrupt.h> |
| #include <linux/irq.h> |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/mutex.h> |
| #include <linux/slab.h> |
| #include <linux/types.h> |
| |
| #include <linux/iio/events.h> |
| #include <linux/iio/sysfs.h> |
| #include <linux/iio/buffer.h> |
| |
| #include <linux/iio/trigger.h> |
| #include <linux/iio/trigger_consumer.h> |
| #include <linux/iio/triggered_buffer.h> |
| |
| #include "opt3001.h" |
| |
| #define OPT3001_RESULT 0x00 |
| #define OPT3001_CONFIGURATION 0x01 |
| #define OPT3001_LOW_LIMIT 0x02 |
| #define OPT3001_HIGH_LIMIT 0x03 |
| #define OPT3001_MANUFACTURER_ID 0x7e |
| #define OPT3001_DEVICE_ID 0x7f |
| |
| #define OPT3001_CONFIGURATION_RN_MASK (0xf << 12) |
| #define OPT3001_CONFIGURATION_RN_AUTO (0xc << 12) |
| |
| #define OPT3001_CONFIGURATION_CT BIT(11) |
| |
| #define OPT3001_CONFIGURATION_M_MASK (3 << 9) |
| #define OPT3001_CONFIGURATION_M_SHUTDOWN (0 << 9) |
| #define OPT3001_CONFIGURATION_M_SINGLE (1 << 9) |
| #define OPT3001_CONFIGURATION_M_CONTINUOUS (2 << 9) /* also 3 << 9 */ |
| |
| #define OPT3001_CONFIGURATION_OVF BIT(8) |
| #define OPT3001_CONFIGURATION_CRF BIT(7) |
| #define OPT3001_CONFIGURATION_FH BIT(6) |
| #define OPT3001_CONFIGURATION_FL BIT(5) |
| #define OPT3001_CONFIGURATION_L BIT(4) |
| #define OPT3001_CONFIGURATION_POL BIT(3) |
| #define OPT3001_CONFIGURATION_ME BIT(2) |
| |
| #define OPT3001_CONFIGURATION_FC_MASK (3 << 0) |
| |
| #define OPT3001_REG_EXPONENT(n) ((n) >> 12) |
| #define OPT3001_REG_MANTISSA(n) ((n) & 0xfff) |
| |
| #define OPT3001_CONVERSION_XTRA_TIME_DIV_1 5 |
| #define OPT3001_CONVERSION_XTRA_TIME_DIV_2 3 |
| |
| |
| struct ring_buf_data { |
| s32 illuminance_unscaled; |
| s64 timestamp; |
| }; |
| |
| struct opt3001 { |
| struct i2c_client *client; |
| struct device *dev; |
| |
| struct iio_trigger *limit_trig; |
| int irq; |
| |
| struct mutex lock; |
| |
| u32 int_time; |
| u32 mode; |
| |
| u16 high_thresh_mantissa; |
| u16 low_thresh_mantissa; |
| |
| u8 high_thresh_exp; |
| u8 low_thresh_exp; |
| |
| bool trigger_on; |
| |
| struct ring_buf_data data; |
| |
| unsigned int hysteresis:1; |
| }; |
| |
| struct opt3001_scale { |
| int val; |
| int val2; |
| }; |
| |
| static const struct opt3001_scale opt3001_scales[] = { |
| { |
| .val = 40, |
| .val2 = 950000, |
| }, |
| { |
| .val = 81, |
| .val2 = 900000, |
| }, |
| { |
| .val = 163, |
| .val2 = 800000, |
| }, |
| { |
| .val = 327, |
| .val2 = 600000, |
| }, |
| { |
| .val = 655, |
| .val2 = 200000, |
| }, |
| { |
| .val = 1310, |
| .val2 = 400000, |
| }, |
| { |
| .val = 2620, |
| .val2 = 800000, |
| }, |
| { |
| .val = 5241, |
| .val2 = 600000, |
| }, |
| { |
| .val = 10483, |
| .val2 = 200000, |
| }, |
| { |
| .val = 20966, |
| .val2 = 400000, |
| }, |
| { |
| .val = 41932, |
| .val2 = 800000, |
| }, |
| { |
| .val = 83865, |
| .val2 = 600000, |
| }, |
| }; |
| |
| static int opt3001_find_scale(const struct opt3001 *opt, int val, |
| int val2, u8 *exponent) |
| { |
| int i; |
| |
| for (i = 0; i < ARRAY_SIZE(opt3001_scales); i++) { |
| const struct opt3001_scale *scale = &opt3001_scales[i]; |
| |
| if ((val*1000 + val2/1000) <= (scale->val*1000 + scale->val2/1000)) { |
| *exponent = i; |
| return 0; |
| } |
| } |
| |
| return -EINVAL; |
| } |
| |
| static void opt3001_to_iio_ret(struct opt3001 *opt, u8 exponent, |
| u16 mantissa, int *val, int *val2) |
| { |
| int lux; |
| |
| lux = 10 * (mantissa << exponent); |
| *val = lux / 1000; |
| *val2 = (lux - (*val * 1000)) * 1000; |
| } |
| |
| static void opt3001_set_mode(struct opt3001 *opt, u16 *reg, u16 mode) |
| { |
| *reg &= ~OPT3001_CONFIGURATION_M_MASK; |
| *reg |= mode; |
| opt->mode = mode; |
| } |
| |
| static IIO_CONST_ATTR_INT_TIME_AVAIL("0.1 0.8"); |
| |
| static struct attribute *opt3001_attributes[] = { |
| &iio_const_attr_integration_time_available.dev_attr.attr, |
| NULL |
| }; |
| |
| static const struct attribute_group opt3001_attribute_group = { |
| .attrs = opt3001_attributes, |
| }; |
| |
| static const struct iio_event_spec opt3001_event_spec[] = { |
| { |
| .type = IIO_EV_TYPE_THRESH, |
| .dir = IIO_EV_DIR_RISING, |
| .mask_separate = BIT(IIO_EV_INFO_VALUE) | |
| BIT(IIO_EV_INFO_HYSTERESIS) | |
| BIT(IIO_EV_INFO_ENABLE), |
| }, |
| { |
| .type = IIO_EV_TYPE_THRESH, |
| .dir = IIO_EV_DIR_FALLING, |
| .mask_separate = BIT(IIO_EV_INFO_VALUE) | |
| BIT(IIO_EV_INFO_HYSTERESIS) | |
| BIT(IIO_EV_INFO_ENABLE), |
| }, |
| }; |
| |
| static const struct iio_chan_spec opt3001_channels[] = { |
| { |
| .type = IIO_LIGHT, |
| .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) | |
| BIT(IIO_CHAN_INFO_INT_TIME) | |
| BIT(IIO_CHAN_INFO_SCALE), |
| .event_spec = opt3001_event_spec, |
| .num_event_specs = ARRAY_SIZE(opt3001_event_spec), |
| .scan_type = { |
| .sign = 's', |
| .realbits = 32, |
| .storagebits = 32 |
| } |
| }, |
| IIO_CHAN_SOFT_TIMESTAMP(1), |
| }; |
| |
| static int opt3001_get_lux(struct opt3001 *opt, int *val, int *val2) |
| { |
| int ret; |
| u16 mantissa; |
| u16 reg; |
| u8 exponent; |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_CONFIGURATION); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| reg = ret; |
| opt3001_set_mode(opt, ®, OPT3001_CONFIGURATION_M_SINGLE); |
| |
| ret = i2c_smbus_write_word_swapped(opt->client, OPT3001_CONFIGURATION, |
| reg); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to write register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| /* Wait for conversion to complete and give it some extra time. It can take |
| * up to 960ms when integration time is configured to 800ms and 120ms when |
| * integration time is configured to 100ms |
| */ |
| usleep_range(opt->int_time + (opt->int_time / OPT3001_CONVERSION_XTRA_TIME_DIV_1), |
| opt->int_time + (opt->int_time / OPT3001_CONVERSION_XTRA_TIME_DIV_2)); |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_CONFIGURATION); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| reg = ret; |
| if (!(reg & OPT3001_CONFIGURATION_CRF)) |
| return -EPIPE; |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_RESULT); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_RESULT); |
| return ret; |
| } |
| |
| exponent = OPT3001_REG_EXPONENT(ret); |
| mantissa = OPT3001_REG_MANTISSA(ret); |
| |
| opt3001_to_iio_ret(opt, exponent, mantissa, val, val2); |
| |
| return IIO_VAL_INT_PLUS_MICRO; |
| } |
| |
| static int opt3001_get_lux_continuous_mode(struct opt3001 *opt, int *val, int *val2) |
| { |
| int ret; |
| |
| u16 mantissa; |
| u16 reg; |
| u8 exponent; |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_CONFIGURATION); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| reg = ret; |
| |
| if (!(reg & OPT3001_CONFIGURATION_CRF)) { |
| /* Wait for conversion to complete and give it some extra time. It can take |
| * up to 880ms when integration time is configured to 800ms and 110ms when |
| * integration time is configured to 100ms |
| */ |
| usleep_range(opt->int_time + (opt->int_time / OPT3001_CONVERSION_XTRA_TIME_DIV_1), |
| opt->int_time + (opt->int_time / OPT3001_CONVERSION_XTRA_TIME_DIV_2)); |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_CONFIGURATION); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| reg = ret; |
| if (!(reg & OPT3001_CONFIGURATION_CRF)) |
| return -EPIPE; |
| } |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_RESULT); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_RESULT); |
| return ret; |
| } |
| |
| exponent = OPT3001_REG_EXPONENT(ret); |
| mantissa = OPT3001_REG_MANTISSA(ret); |
| |
| opt3001_to_iio_ret(opt, exponent, mantissa, val, val2); |
| |
| return IIO_VAL_INT_PLUS_MICRO; |
| } |
| |
| static int opt3001_get_int_time(struct opt3001 *opt, int *val, int *val2) |
| { |
| *val = 0; |
| *val2 = opt->int_time; |
| |
| return IIO_VAL_INT_PLUS_MICRO; |
| } |
| |
| static int opt3001_set_int_time(struct opt3001 *opt, int time) |
| { |
| int ret; |
| u16 reg; |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_CONFIGURATION); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| reg = ret; |
| |
| switch (time) { |
| case 100000: |
| reg &= ~OPT3001_CONFIGURATION_CT; |
| opt->int_time = 100000; |
| break; |
| case 800000: |
| reg |= OPT3001_CONFIGURATION_CT; |
| opt->int_time = 800000; |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| return i2c_smbus_write_word_swapped(opt->client, OPT3001_CONFIGURATION, |
| reg); |
| } |
| |
| static int opt3001_read_raw(struct iio_dev *iio, |
| struct iio_chan_spec const *chan, int *val, int *val2, |
| long mask) |
| { |
| struct opt3001 *opt = iio_priv(iio); |
| int ret = 0; |
| |
| if (chan->type != IIO_LIGHT) |
| return -EINVAL; |
| |
| mutex_lock(&opt->lock); |
| |
| switch (mask) { |
| case IIO_CHAN_INFO_PROCESSED: |
| if (opt->mode == OPT3001_CONFIGURATION_M_CONTINUOUS) |
| ret = opt3001_get_lux_continuous_mode(opt, val, val2); |
| else |
| ret = opt3001_get_lux(opt, val, val2); |
| break; |
| case IIO_CHAN_INFO_INT_TIME: |
| ret = opt3001_get_int_time(opt, val, val2); |
| break; |
| case IIO_CHAN_INFO_SCALE: |
| /* |
| * Illuminance values have a maximum precision of 0.01. |
| * Values are written into the ring buffer unscaled to avoid |
| * fractional values; userspace needs to scale them by 0.01. |
| */ |
| *val = 0; |
| *val2 = 10000; |
| ret = IIO_VAL_INT_PLUS_MICRO; |
| break; |
| default: |
| ret = -EINVAL; |
| } |
| |
| mutex_unlock(&opt->lock); |
| |
| return ret; |
| } |
| |
| static int opt3001_write_raw(struct iio_dev *iio, |
| struct iio_chan_spec const *chan, int val, int val2, |
| long mask) |
| { |
| struct opt3001 *opt = iio_priv(iio); |
| int ret = 0; |
| |
| if (opt->mode == OPT3001_CONFIGURATION_M_CONTINUOUS) |
| return -EBUSY; |
| |
| if (chan->type != IIO_LIGHT) |
| return -EINVAL; |
| |
| if (mask != IIO_CHAN_INFO_INT_TIME) |
| return -EINVAL; |
| |
| mutex_lock(&opt->lock); |
| ret = opt3001_set_int_time(opt, val2); |
| mutex_unlock(&opt->lock); |
| |
| return ret; |
| } |
| |
| static int opt3001_read_event_value(struct iio_dev *iio, |
| const struct iio_chan_spec *chan, enum iio_event_type type, |
| enum iio_event_direction dir, enum iio_event_info info, |
| int *val, int *val2) |
| { |
| struct opt3001 *opt = iio_priv(iio); |
| int ret = IIO_VAL_INT_PLUS_MICRO; |
| |
| mutex_lock(&opt->lock); |
| |
| switch (dir) { |
| case IIO_EV_DIR_RISING: |
| opt3001_to_iio_ret(opt, opt->high_thresh_exp, |
| opt->high_thresh_mantissa, val, val2); |
| break; |
| case IIO_EV_DIR_FALLING: |
| opt3001_to_iio_ret(opt, opt->low_thresh_exp, |
| opt->low_thresh_mantissa, val, val2); |
| break; |
| default: |
| ret = -EINVAL; |
| } |
| |
| mutex_unlock(&opt->lock); |
| |
| return ret; |
| } |
| |
| static int opt3001_write_event_value(struct iio_dev *iio, |
| const struct iio_chan_spec *chan, enum iio_event_type type, |
| enum iio_event_direction dir, enum iio_event_info info, |
| int val, int val2) |
| { |
| struct opt3001 *opt = iio_priv(iio); |
| int ret = 0; |
| |
| u16 mantissa; |
| u16 value; |
| u16 reg; |
| |
| u8 exponent; |
| |
| mutex_lock(&opt->lock); |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_CONFIGURATION); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_CONFIGURATION); |
| goto err; |
| } |
| |
| if (info == IIO_EV_INFO_HYSTERESIS) |
| opt->hysteresis = true; |
| else |
| opt->hysteresis = false; |
| |
| ret = opt3001_find_scale(opt, val, val2, &exponent); |
| if (ret < 0) { |
| dev_err(opt->dev, "can't find scale for %d.%d\n", val, val2); |
| goto err; |
| } |
| |
| mantissa = (((val * 1000) + (val2 / 1000)) / 10) >> exponent; |
| value = exponent << 12 | mantissa; |
| |
| switch (dir) { |
| case IIO_EV_DIR_RISING: |
| reg = OPT3001_HIGH_LIMIT; |
| opt->high_thresh_mantissa = mantissa; |
| opt->high_thresh_exp = exponent; |
| break; |
| case IIO_EV_DIR_FALLING: |
| reg = OPT3001_LOW_LIMIT; |
| opt->low_thresh_mantissa = mantissa; |
| opt->low_thresh_exp = exponent; |
| break; |
| default: |
| ret = -EINVAL; |
| goto err; |
| } |
| |
| ret = i2c_smbus_write_word_swapped(opt->client, reg, value); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to write register %02x\n", reg); |
| goto err; |
| } |
| |
| err: |
| mutex_unlock(&opt->lock); |
| |
| return ret; |
| } |
| |
| static int opt3001_read_event_config(struct iio_dev *iio, |
| const struct iio_chan_spec *chan, enum iio_event_type type, |
| enum iio_event_direction dir) |
| { |
| struct opt3001 *opt = iio_priv(iio); |
| |
| return opt->mode == OPT3001_CONFIGURATION_M_CONTINUOUS; |
| } |
| |
| static int opt3001_write_event_config(struct iio_dev *iio, |
| const struct iio_chan_spec *chan, enum iio_event_type type, |
| enum iio_event_direction dir, int state) |
| { |
| struct opt3001 *opt = iio_priv(iio); |
| int ret; |
| u16 mode; |
| u16 reg; |
| |
| if (state && opt->mode == OPT3001_CONFIGURATION_M_CONTINUOUS) |
| return 0; |
| |
| if (!state && opt->mode == OPT3001_CONFIGURATION_M_SHUTDOWN) |
| return 0; |
| |
| mode = state ? OPT3001_CONFIGURATION_M_CONTINUOUS |
| : OPT3001_CONFIGURATION_M_SHUTDOWN; |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_CONFIGURATION); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| reg = ret; |
| opt3001_set_mode(opt, ®, mode); |
| |
| if (opt->hysteresis) |
| reg &= ~OPT3001_CONFIGURATION_L; |
| else |
| reg |= OPT3001_CONFIGURATION_L; |
| |
| ret = i2c_smbus_write_word_swapped(opt->client, OPT3001_CONFIGURATION, |
| reg); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to write register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| /* wait for mode change to go through */ |
| usleep_range(opt->int_time + 5000, opt->int_time + 10000); |
| |
| return 0; |
| } |
| |
| static const struct iio_info opt3001_info = { |
| .driver_module = THIS_MODULE, |
| .attrs = &opt3001_attribute_group, |
| .read_raw = opt3001_read_raw, |
| .write_raw = opt3001_write_raw, |
| .read_event_value_new = opt3001_read_event_value, |
| .write_event_value_new = opt3001_write_event_value, |
| .read_event_config_new = opt3001_read_event_config, |
| .write_event_config_new = opt3001_write_event_config, |
| }; |
| |
| static int opt3001_read_id(struct opt3001 *opt) |
| { |
| char manufacturer[2]; |
| u16 device_id; |
| int ret; |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_MANUFACTURER_ID); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_MANUFACTURER_ID); |
| return ret; |
| } |
| |
| manufacturer[0] = ret >> 8; |
| manufacturer[1] = ret & 0xff; |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_DEVICE_ID); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_DEVICE_ID); |
| return ret; |
| } |
| |
| device_id = ret; |
| |
| dev_info(opt->dev, "Found %c%c OPT%04x\n", manufacturer[0], |
| manufacturer[1], device_id); |
| |
| return 0; |
| } |
| |
| static int opt3001_configure(struct opt3001 *opt) |
| { |
| int ret; |
| u16 reg; |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_CONFIGURATION); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| reg = ret; |
| |
| /* Set the default integration time to 100 ms */ |
| opt->int_time = 100000; |
| reg &= ~OPT3001_CONFIGURATION_CT; |
| |
| opt->hysteresis = true; |
| reg &= ~OPT3001_CONFIGURATION_L; |
| reg &= ~OPT3001_CONFIGURATION_RN_MASK; |
| reg |= OPT3001_CONFIGURATION_RN_AUTO; |
| |
| ret = i2c_smbus_write_word_swapped(opt->client, OPT3001_CONFIGURATION, |
| reg); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to write register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_LOW_LIMIT); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_LOW_LIMIT); |
| return ret; |
| } |
| |
| opt->low_thresh_mantissa = OPT3001_REG_MANTISSA(ret); |
| opt->low_thresh_exp = OPT3001_REG_EXPONENT(ret); |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_HIGH_LIMIT); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_HIGH_LIMIT); |
| return ret; |
| } |
| |
| opt->high_thresh_mantissa = OPT3001_REG_MANTISSA(ret); |
| opt->high_thresh_exp = OPT3001_REG_EXPONENT(ret); |
| |
| return 0; |
| } |
| |
| static irqreturn_t opt3001_trig_poll(int irq, void *_iio) |
| { |
| struct iio_dev *iio = _iio; |
| struct opt3001 *opt = iio_priv(iio); |
| |
| if (opt->trigger_on) |
| iio_trigger_poll(opt->limit_trig, 0); |
| |
| if (opt->mode == OPT3001_CONFIGURATION_M_CONTINUOUS) |
| return IRQ_WAKE_THREAD; |
| else |
| return IRQ_HANDLED; |
| } |
| |
| static irqreturn_t opt3001_irq(int irq, void *_iio) |
| { |
| struct iio_dev *iio = _iio; |
| struct opt3001 *opt = iio_priv(iio); |
| int ret; |
| |
| mutex_lock(&opt->lock); |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_CONFIGURATION); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_CONFIGURATION); |
| goto out; |
| } |
| |
| if (ret & OPT3001_CONFIGURATION_FH) |
| iio_push_event(iio, IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0, |
| IIO_EV_TYPE_THRESH, |
| IIO_EV_DIR_RISING), iio_get_time_ns()); |
| |
| if (ret & OPT3001_CONFIGURATION_FL) |
| iio_push_event(iio, IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0, |
| IIO_EV_TYPE_THRESH, |
| IIO_EV_DIR_FALLING), iio_get_time_ns()); |
| |
| out: |
| mutex_unlock(&opt->lock); |
| return IRQ_HANDLED; |
| } |
| |
| irqreturn_t opt3001_trigger_handler(int irq, void *p) |
| { |
| struct iio_poll_func *pf = p; |
| struct iio_dev *iio = pf->indio_dev; |
| struct opt3001 *opt = iio_priv(iio); |
| int ret; |
| u32 reg; |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_RESULT); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_RESULT); |
| goto out; |
| } |
| |
| reg = ret; |
| |
| opt->data.illuminance_unscaled = OPT3001_REG_MANTISSA(reg) << |
| OPT3001_REG_EXPONENT(reg); |
| |
| if (iio->scan_timestamp) |
| opt->data.timestamp = pf->timestamp; |
| |
| iio_push_to_buffers(iio, (unsigned char *)&opt->data); |
| |
| out: |
| iio_trigger_notify_done(iio->trig); |
| |
| return IRQ_HANDLED; |
| } |
| |
| static int opt3001_trigger_set_state(struct iio_trigger *trig, bool state) |
| { |
| struct iio_dev *iio = iio_trigger_get_drvdata(trig); |
| struct opt3001 *opt = iio_priv(iio); |
| |
| opt->trigger_on = state; |
| |
| return 0; |
| } |
| |
| static const struct iio_trigger_ops opt3001_trigger_ops = { |
| .set_trigger_state = opt3001_trigger_set_state, |
| .try_reenable = NULL, |
| .owner = THIS_MODULE, |
| }; |
| |
| static int opt3001_probe(struct i2c_client *client, |
| const struct i2c_device_id *id) |
| { |
| struct device *dev = &client->dev; |
| |
| struct iio_dev *iio; |
| struct opt3001 *opt; |
| int irq = client->irq; |
| int ret = -ENOMEM; |
| |
| iio = iio_device_alloc(sizeof(*opt)); |
| if (!iio) |
| goto err_iio_alloc; |
| |
| opt = iio_priv(iio); |
| opt->client = client; |
| opt->dev = dev; |
| opt->irq = irq; |
| |
| mutex_init(&opt->lock); |
| i2c_set_clientdata(client, iio); |
| |
| ret = opt3001_read_id(opt); |
| if (ret) |
| goto err_read; |
| |
| ret = opt3001_configure(opt); |
| if (ret) |
| goto err_read; |
| |
| iio->name = client->name; |
| iio->channels = opt3001_channels; |
| iio->num_channels = ARRAY_SIZE(opt3001_channels); |
| iio->dev.parent = dev; |
| iio->modes = INDIO_DIRECT_MODE; |
| iio->info = &opt3001_info; |
| |
| opt->limit_trig = iio_trigger_alloc("%s-trigger", iio->name); |
| if (!opt->limit_trig) { |
| ret = -ENOMEM; |
| goto err_read; |
| } |
| |
| opt->limit_trig->dev.parent = &client->dev; |
| opt->limit_trig->ops = &opt3001_trigger_ops; |
| iio_trigger_set_drvdata(opt->limit_trig, iio); |
| ret = iio_trigger_register(opt->limit_trig); |
| if (ret) |
| goto err_trigger_register; |
| |
| ret = opt3001_allocate_ring(iio); |
| if (ret < 0) { |
| dev_err(&client->dev, |
| "Failed: iio triggered buffer setup\n"); |
| goto err_buffer_setup; |
| } |
| |
| ret = iio_device_register(iio); |
| if (ret) { |
| dev_err(dev, "failed to register IIO device\n"); |
| goto err_device_register; |
| } |
| |
| ret = request_threaded_irq(irq, opt3001_trig_poll, opt3001_irq, |
| IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
| | IRQF_ONESHOT, "opt3001", iio); |
| if (ret) { |
| dev_err(dev, "failed to request IRQ #%d\n", irq); |
| goto err_request_irq; |
| } |
| |
| device_init_wakeup(dev, 1); |
| |
| return 0; |
| |
| err_request_irq: |
| iio_device_unregister(iio); |
| |
| err_device_register: |
| opt3001_deallocate_ring(iio); |
| |
| err_buffer_setup: |
| iio_trigger_unregister(opt->limit_trig); |
| |
| err_trigger_register: |
| iio_trigger_free(opt->limit_trig); |
| |
| err_read: |
| iio_device_free(iio); |
| |
| err_iio_alloc: |
| return ret; |
| } |
| |
| static int opt3001_remove(struct i2c_client *client) |
| { |
| struct iio_dev *iio = i2c_get_clientdata(client); |
| struct opt3001 *opt = iio_priv(iio); |
| int ret; |
| u16 reg; |
| |
| free_irq(client->irq, iio); |
| iio_device_unregister(iio); |
| opt3001_deallocate_ring(iio); |
| iio_trigger_unregister(opt->limit_trig); |
| |
| ret = i2c_smbus_read_word_swapped(opt->client, OPT3001_CONFIGURATION); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to read register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| reg = ret; |
| opt3001_set_mode(opt, ®, OPT3001_CONFIGURATION_M_SHUTDOWN); |
| |
| ret = i2c_smbus_write_word_swapped(opt->client, OPT3001_CONFIGURATION, |
| reg); |
| if (ret < 0) { |
| dev_err(opt->dev, "failed to write register %02x\n", |
| OPT3001_CONFIGURATION); |
| return ret; |
| } |
| |
| iio_device_free(iio); |
| |
| return 0; |
| } |
| |
| static int opt3001_suspend(struct device *dev) |
| { |
| struct i2c_client *client = to_i2c_client(dev); |
| struct iio_dev *iio = i2c_get_clientdata(client); |
| struct opt3001 *opt = iio_priv(iio); |
| |
| if (device_may_wakeup(&client->dev)) |
| enable_irq_wake(opt->irq); |
| |
| return 0; |
| } |
| |
| static int opt3001_resume(struct device *dev) |
| { |
| struct i2c_client *client = to_i2c_client(dev); |
| struct iio_dev *iio = i2c_get_clientdata(client); |
| struct opt3001 *opt = iio_priv(iio); |
| |
| if (device_may_wakeup(&client->dev)) |
| disable_irq_wake(opt->irq); |
| |
| return 0; |
| } |
| |
| static SIMPLE_DEV_PM_OPS(opt3001_pm, opt3001_suspend, opt3001_resume); |
| |
| static const struct of_device_id opt3001_of_match[] = { |
| { .compatible = "ti,opt3001" }, |
| { } |
| }; |
| MODULE_DEVICE_TABLE(of, opt3001_of_match); |
| |
| static const struct i2c_device_id opt3001_id[] = { |
| { "opt3001", 0 }, |
| { } /* Terminating Entry */ |
| }; |
| MODULE_DEVICE_TABLE(i2c, opt3001_id); |
| |
| static struct i2c_driver opt3001_driver = { |
| .probe = opt3001_probe, |
| .remove = opt3001_remove, |
| .id_table = opt3001_id, |
| |
| .driver = { |
| .name = "opt3001", |
| .pm = &opt3001_pm, |
| .of_match_table = of_match_ptr(opt3001_of_match), |
| .owner = THIS_MODULE, |
| }, |
| }; |
| |
| module_i2c_driver(opt3001_driver); |
| |
| MODULE_LICENSE("GPL v2"); |
| MODULE_AUTHOR("Felipe Balbi <balbi@ti.com>"); |
| MODULE_DESCRIPTION("Texas Instruments OPT3001 Light Sensor Driver"); |