| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * ROHM BH1745 digital colour sensor driver | |
| * | |
| * Copyright (C) Mudit Sharma <muditsharma.info@gmail.com> | |
| * | |
| * 7-bit I2C slave addresses: | |
| * 0x38 (ADDR pin low) | |
| * 0x39 (ADDR pin high) | |
| */ | |
| #include <linux/i2c.h> | |
| #include <linux/mutex.h> | |
| #include <linux/util_macros.h> | |
| #include <linux/iio/events.h> | |
| #include <linux/regmap.h> | |
| #include <linux/bits.h> | |
| #include <linux/bitfield.h> | |
| #include <linux/iio/iio.h> | |
| #include <linux/iio/sysfs.h> | |
| #include <linux/iio/trigger.h> | |
| #include <linux/iio/trigger_consumer.h> | |
| #include <linux/iio/triggered_buffer.h> | |
| #include <linux/iio/iio-gts-helper.h> | |
| /* BH1745 configuration registers */ | |
| /* System control */ | |
| #define BH1745_SYS_CTRL 0x40 | |
| #define BH1745_SYS_CTRL_SW_RESET BIT(7) | |
| #define BH1745_SYS_CTRL_INTR_RESET BIT(6) | |
| #define BH1745_SYS_CTRL_PART_ID_MASK GENMASK(5, 0) | |
| #define BH1745_PART_ID 0x0B | |
| /* Mode control 1 */ | |
| #define BH1745_MODE_CTRL1 0x41 | |
| #define BH1745_CTRL1_MEASUREMENT_TIME_MASK GENMASK(2, 0) | |
| /* Mode control 2 */ | |
| #define BH1745_MODE_CTRL2 0x42 | |
| #define BH1745_CTRL2_RGBC_EN BIT(4) | |
| #define BH1745_CTRL2_ADC_GAIN_MASK GENMASK(1, 0) | |
| /* Interrupt */ | |
| #define BH1745_INTR 0x60 | |
| #define BH1745_INTR_STATUS BIT(7) | |
| #define BH1745_INTR_SOURCE_MASK GENMASK(3, 2) | |
| #define BH1745_INTR_ENABLE BIT(0) | |
| #define BH1745_PERSISTENCE 0x61 | |
| /* Threshold high */ | |
| #define BH1745_TH_LSB 0x62 | |
| #define BH1745_TH_MSB 0x63 | |
| /* Threshold low */ | |
| #define BH1745_TL_LSB 0x64 | |
| #define BH1745_TL_MSB 0x65 | |
| /* BH1745 data output regs */ | |
| #define BH1745_RED_LSB 0x50 | |
| #define BH1745_RED_MSB 0x51 | |
| #define BH1745_GREEN_LSB 0x52 | |
| #define BH1745_GREEN_MSB 0x53 | |
| #define BH1745_BLUE_LSB 0x54 | |
| #define BH1745_BLUE_MSB 0x55 | |
| #define BH1745_CLEAR_LSB 0x56 | |
| #define BH1745_CLEAR_MSB 0x57 | |
| #define BH1745_MANU_ID_REG 0x92 | |
| /* From 16x max HW gain and 32x max integration time */ | |
| #define BH1745_MAX_GAIN 512 | |
| enum bh1745_int_source { | |
| BH1745_INTR_SOURCE_RED, | |
| BH1745_INTR_SOURCE_GREEN, | |
| BH1745_INTR_SOURCE_BLUE, | |
| BH1745_INTR_SOURCE_CLEAR, | |
| }; | |
| enum bh1745_gain { | |
| BH1745_ADC_GAIN_1X, | |
| BH1745_ADC_GAIN_2X, | |
| BH1745_ADC_GAIN_16X, | |
| }; | |
| enum bh1745_measurement_time { | |
| BH1745_MEASUREMENT_TIME_160MS, | |
| BH1745_MEASUREMENT_TIME_320MS, | |
| BH1745_MEASUREMENT_TIME_640MS, | |
| BH1745_MEASUREMENT_TIME_1280MS, | |
| BH1745_MEASUREMENT_TIME_2560MS, | |
| BH1745_MEASUREMENT_TIME_5120MS, | |
| }; | |
| enum bh1745_presistence_value { | |
| BH1745_PRESISTENCE_UPDATE_TOGGLE, | |
| BH1745_PRESISTENCE_UPDATE_EACH_MEASUREMENT, | |
| BH1745_PRESISTENCE_UPDATE_FOUR_MEASUREMENT, | |
| BH1745_PRESISTENCE_UPDATE_EIGHT_MEASUREMENT, | |
| }; | |
| static const struct iio_gain_sel_pair bh1745_gain[] = { | |
| GAIN_SCALE_GAIN(1, BH1745_ADC_GAIN_1X), | |
| GAIN_SCALE_GAIN(2, BH1745_ADC_GAIN_2X), | |
| GAIN_SCALE_GAIN(16, BH1745_ADC_GAIN_16X), | |
| }; | |
| static const struct iio_itime_sel_mul bh1745_itimes[] = { | |
| GAIN_SCALE_ITIME_US(5120000, BH1745_MEASUREMENT_TIME_5120MS, 32), | |
| GAIN_SCALE_ITIME_US(2560000, BH1745_MEASUREMENT_TIME_2560MS, 16), | |
| GAIN_SCALE_ITIME_US(1280000, BH1745_MEASUREMENT_TIME_1280MS, 8), | |
| GAIN_SCALE_ITIME_US(640000, BH1745_MEASUREMENT_TIME_640MS, 4), | |
| GAIN_SCALE_ITIME_US(320000, BH1745_MEASUREMENT_TIME_320MS, 2), | |
| GAIN_SCALE_ITIME_US(160000, BH1745_MEASUREMENT_TIME_160MS, 1), | |
| }; | |
| struct bh1745_data { | |
| /* | |
| * Lock to prevent device setting update or read before | |
| * related calculations are completed | |
| */ | |
| struct mutex lock; | |
| struct regmap *regmap; | |
| struct device *dev; | |
| struct iio_trigger *trig; | |
| struct iio_gts gts; | |
| }; | |
| static const struct regmap_range bh1745_volatile_ranges[] = { | |
| regmap_reg_range(BH1745_MODE_CTRL2, BH1745_MODE_CTRL2), /* VALID */ | |
| regmap_reg_range(BH1745_RED_LSB, BH1745_CLEAR_MSB), /* Data */ | |
| regmap_reg_range(BH1745_INTR, BH1745_INTR), /* Interrupt */ | |
| }; | |
| static const struct regmap_access_table bh1745_volatile_regs = { | |
| .yes_ranges = bh1745_volatile_ranges, | |
| .n_yes_ranges = ARRAY_SIZE(bh1745_volatile_ranges), | |
| }; | |
| static const struct regmap_range bh1745_readable_ranges[] = { | |
| regmap_reg_range(BH1745_SYS_CTRL, BH1745_MODE_CTRL2), | |
| regmap_reg_range(BH1745_RED_LSB, BH1745_CLEAR_MSB), | |
| regmap_reg_range(BH1745_INTR, BH1745_INTR), | |
| regmap_reg_range(BH1745_PERSISTENCE, BH1745_TL_MSB), | |
| regmap_reg_range(BH1745_MANU_ID_REG, BH1745_MANU_ID_REG), | |
| }; | |
| static const struct regmap_access_table bh1745_readable_regs = { | |
| .yes_ranges = bh1745_readable_ranges, | |
| .n_yes_ranges = ARRAY_SIZE(bh1745_readable_ranges), | |
| }; | |
| static const struct regmap_range bh1745_writable_ranges[] = { | |
| regmap_reg_range(BH1745_SYS_CTRL, BH1745_MODE_CTRL2), | |
| regmap_reg_range(BH1745_INTR, BH1745_INTR), | |
| regmap_reg_range(BH1745_PERSISTENCE, BH1745_TL_MSB), | |
| }; | |
| static const struct regmap_access_table bh1745_writable_regs = { | |
| .yes_ranges = bh1745_writable_ranges, | |
| .n_yes_ranges = ARRAY_SIZE(bh1745_writable_ranges), | |
| }; | |
| static const struct regmap_config bh1745_regmap = { | |
| .reg_bits = 8, | |
| .val_bits = 8, | |
| .max_register = BH1745_MANU_ID_REG, | |
| .cache_type = REGCACHE_RBTREE, | |
| .volatile_table = &bh1745_volatile_regs, | |
| .wr_table = &bh1745_writable_regs, | |
| .rd_table = &bh1745_readable_regs, | |
| }; | |
| static const struct iio_event_spec bh1745_event_spec[] = { | |
| { | |
| .type = IIO_EV_TYPE_THRESH, | |
| .dir = IIO_EV_DIR_RISING, | |
| .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE), | |
| }, | |
| { | |
| .type = IIO_EV_TYPE_THRESH, | |
| .dir = IIO_EV_DIR_FALLING, | |
| .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE), | |
| }, | |
| { | |
| .type = IIO_EV_TYPE_THRESH, | |
| .dir = IIO_EV_DIR_EITHER, | |
| .mask_shared_by_type = BIT(IIO_EV_INFO_PERIOD), | |
| .mask_separate = BIT(IIO_EV_INFO_ENABLE), | |
| }, | |
| }; | |
| #define BH1745_CHANNEL(_colour, _si, _addr) \ | |
| { \ | |
| .type = IIO_INTENSITY, .modified = 1, \ | |
| .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ | |
| .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE) | \ | |
| BIT(IIO_CHAN_INFO_INT_TIME), \ | |
| .info_mask_shared_by_all_available = \ | |
| BIT(IIO_CHAN_INFO_SCALE) | \ | |
| BIT(IIO_CHAN_INFO_INT_TIME), \ | |
| .event_spec = bh1745_event_spec, \ | |
| .num_event_specs = ARRAY_SIZE(bh1745_event_spec), \ | |
| .channel2 = IIO_MOD_LIGHT_##_colour, .address = _addr, \ | |
| .scan_index = _si, \ | |
| .scan_type = { \ | |
| .sign = 'u', \ | |
| .realbits = 16, \ | |
| .storagebits = 16, \ | |
| .endianness = IIO_CPU, \ | |
| }, \ | |
| } | |
| static const struct iio_chan_spec bh1745_channels[] = { | |
| BH1745_CHANNEL(RED, 0, BH1745_RED_LSB), | |
| BH1745_CHANNEL(GREEN, 1, BH1745_GREEN_LSB), | |
| BH1745_CHANNEL(BLUE, 2, BH1745_BLUE_LSB), | |
| BH1745_CHANNEL(CLEAR, 3, BH1745_CLEAR_LSB), | |
| IIO_CHAN_SOFT_TIMESTAMP(4), | |
| }; | |
| static int bh1745_reset(struct bh1745_data *data) | |
| { | |
| return regmap_set_bits(data->regmap, BH1745_SYS_CTRL, | |
| BH1745_SYS_CTRL_SW_RESET | | |
| BH1745_SYS_CTRL_INTR_RESET); | |
| } | |
| static int bh1745_power_on(struct bh1745_data *data) | |
| { | |
| return regmap_set_bits(data->regmap, BH1745_MODE_CTRL2, | |
| BH1745_CTRL2_RGBC_EN); | |
| } | |
| static void bh1745_power_off(void *data_ptr) | |
| { | |
| struct bh1745_data *data = data_ptr; | |
| struct device *dev = data->dev; | |
| int ret; | |
| ret = regmap_clear_bits(data->regmap, BH1745_MODE_CTRL2, | |
| BH1745_CTRL2_RGBC_EN); | |
| if (ret) | |
| dev_err(dev, "Failed to turn off device\n"); | |
| } | |
| static int bh1745_get_scale(struct bh1745_data *data, int *val, int *val2) | |
| { | |
| int ret; | |
| int value; | |
| int gain_sel, int_time_sel; | |
| int gain; | |
| const struct iio_itime_sel_mul *int_time; | |
| ret = regmap_read(data->regmap, BH1745_MODE_CTRL2, &value); | |
| if (ret) | |
| return ret; | |
| gain_sel = FIELD_GET(BH1745_CTRL2_ADC_GAIN_MASK, value); | |
| gain = iio_gts_find_gain_by_sel(&data->gts, gain_sel); | |
| ret = regmap_read(data->regmap, BH1745_MODE_CTRL1, &value); | |
| if (ret) | |
| return ret; | |
| int_time_sel = FIELD_GET(BH1745_CTRL1_MEASUREMENT_TIME_MASK, value); | |
| int_time = iio_gts_find_itime_by_sel(&data->gts, int_time_sel); | |
| return iio_gts_get_scale(&data->gts, gain, int_time->time_us, val, | |
| val2); | |
| } | |
| static int bh1745_set_scale(struct bh1745_data *data, int val) | |
| { | |
| struct device *dev = data->dev; | |
| int ret; | |
| int value; | |
| int hw_gain_sel, current_int_time_sel, new_int_time_sel; | |
| ret = regmap_read(data->regmap, BH1745_MODE_CTRL1, &value); | |
| if (ret) | |
| return ret; | |
| current_int_time_sel = FIELD_GET(BH1745_CTRL1_MEASUREMENT_TIME_MASK, | |
| value); | |
| ret = iio_gts_find_gain_sel_for_scale_using_time(&data->gts, | |
| current_int_time_sel, | |
| val, 0, &hw_gain_sel); | |
| if (ret) { | |
| for (int i = 0; i < data->gts.num_itime; i++) { | |
| new_int_time_sel = data->gts.itime_table[i].sel; | |
| if (new_int_time_sel == current_int_time_sel) | |
| continue; | |
| ret = iio_gts_find_gain_sel_for_scale_using_time(&data->gts, | |
| new_int_time_sel, | |
| val, 0, | |
| &hw_gain_sel); | |
| if (!ret) | |
| break; | |
| } | |
| if (ret) { | |
| dev_dbg(dev, "Unsupported scale value requested: %d\n", | |
| val); | |
| return -EINVAL; | |
| } | |
| ret = regmap_write_bits(data->regmap, BH1745_MODE_CTRL1, | |
| BH1745_CTRL1_MEASUREMENT_TIME_MASK, | |
| new_int_time_sel); | |
| if (ret) | |
| return ret; | |
| } | |
| return regmap_write_bits(data->regmap, BH1745_MODE_CTRL2, | |
| BH1745_CTRL2_ADC_GAIN_MASK, hw_gain_sel); | |
| } | |
| static int bh1745_get_int_time(struct bh1745_data *data, int *val) | |
| { | |
| int ret; | |
| int value; | |
| int int_time, int_time_sel; | |
| ret = regmap_read(data->regmap, BH1745_MODE_CTRL1, &value); | |
| if (ret) | |
| return ret; | |
| int_time_sel = FIELD_GET(BH1745_CTRL1_MEASUREMENT_TIME_MASK, value); | |
| int_time = iio_gts_find_int_time_by_sel(&data->gts, int_time_sel); | |
| if (int_time < 0) | |
| return int_time; | |
| *val = int_time; | |
| return 0; | |
| } | |
| static int bh1745_set_int_time(struct bh1745_data *data, int val, int val2) | |
| { | |
| struct device *dev = data->dev; | |
| int ret; | |
| int value; | |
| int current_int_time, current_hwgain_sel, current_hwgain; | |
| int new_hwgain, new_hwgain_sel, new_int_time_sel; | |
| int req_int_time = (1000000 * val) + val2; | |
| if (!iio_gts_valid_time(&data->gts, req_int_time)) { | |
| dev_dbg(dev, "Unsupported integration time requested: %d\n", | |
| req_int_time); | |
| return -EINVAL; | |
| } | |
| ret = bh1745_get_int_time(data, ¤t_int_time); | |
| if (ret) | |
| return ret; | |
| if (current_int_time == req_int_time) | |
| return 0; | |
| ret = regmap_read(data->regmap, BH1745_MODE_CTRL2, &value); | |
| if (ret) | |
| return ret; | |
| current_hwgain_sel = FIELD_GET(BH1745_CTRL2_ADC_GAIN_MASK, value); | |
| current_hwgain = iio_gts_find_gain_by_sel(&data->gts, | |
| current_hwgain_sel); | |
| ret = iio_gts_find_new_gain_by_old_gain_time(&data->gts, current_hwgain, | |
| current_int_time, | |
| req_int_time, | |
| &new_hwgain); | |
| if (new_hwgain < 0) { | |
| dev_dbg(dev, "No corresponding gain for requested integration time\n"); | |
| return ret; | |
| } | |
| if (ret) { | |
| bool in_range; | |
| new_hwgain = iio_find_closest_gain_low(&data->gts, new_hwgain, | |
| &in_range); | |
| if (new_hwgain < 0) { | |
| new_hwgain = iio_gts_get_min_gain(&data->gts); | |
| if (new_hwgain < 0) | |
| return ret; | |
| } | |
| if (!in_range) | |
| dev_dbg(dev, "Optimal gain out of range\n"); | |
| dev_dbg(dev, "Scale changed, new hw_gain %d\n", new_hwgain); | |
| } | |
| new_hwgain_sel = iio_gts_find_sel_by_gain(&data->gts, new_hwgain); | |
| if (new_hwgain_sel < 0) | |
| return new_hwgain_sel; | |
| ret = regmap_write_bits(data->regmap, BH1745_MODE_CTRL2, | |
| BH1745_CTRL2_ADC_GAIN_MASK, | |
| new_hwgain_sel); | |
| if (ret) | |
| return ret; | |
| new_int_time_sel = iio_gts_find_sel_by_int_time(&data->gts, | |
| req_int_time); | |
| if (new_int_time_sel < 0) | |
| return new_int_time_sel; | |
| return regmap_write_bits(data->regmap, BH1745_MODE_CTRL1, | |
| BH1745_CTRL1_MEASUREMENT_TIME_MASK, | |
| new_int_time_sel); | |
| } | |
| static int bh1745_read_raw(struct iio_dev *indio_dev, | |
| struct iio_chan_spec const *chan, | |
| int *val, int *val2, long mask) | |
| { | |
| struct bh1745_data *data = iio_priv(indio_dev); | |
| int ret; | |
| int value; | |
| switch (mask) { | |
| case IIO_CHAN_INFO_RAW: | |
| if (!iio_device_claim_direct(indio_dev)) | |
| return -EBUSY; | |
| ret = regmap_bulk_read(data->regmap, chan->address, &value, 2); | |
| iio_device_release_direct(indio_dev); | |
| if (ret) | |
| return ret; | |
| *val = value; | |
| return IIO_VAL_INT; | |
| case IIO_CHAN_INFO_SCALE: { | |
| guard(mutex)(&data->lock); | |
| ret = bh1745_get_scale(data, val, val2); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT; | |
| } | |
| case IIO_CHAN_INFO_INT_TIME: { | |
| guard(mutex)(&data->lock); | |
| *val = 0; | |
| ret = bh1745_get_int_time(data, val2); | |
| if (ret) | |
| return 0; | |
| return IIO_VAL_INT_PLUS_MICRO; | |
| } | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int bh1745_write_raw(struct iio_dev *indio_dev, | |
| struct iio_chan_spec const *chan, | |
| int val, int val2, long mask) | |
| { | |
| struct bh1745_data *data = iio_priv(indio_dev); | |
| guard(mutex)(&data->lock); | |
| switch (mask) { | |
| case IIO_CHAN_INFO_SCALE: | |
| return bh1745_set_scale(data, val); | |
| case IIO_CHAN_INFO_INT_TIME: | |
| return bh1745_set_int_time(data, val, val2); | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int bh1745_write_raw_get_fmt(struct iio_dev *indio_dev, | |
| struct iio_chan_spec const *chan, | |
| long mask) | |
| { | |
| switch (mask) { | |
| case IIO_CHAN_INFO_SCALE: | |
| return IIO_VAL_INT; | |
| case IIO_CHAN_INFO_INT_TIME: | |
| return IIO_VAL_INT_PLUS_MICRO; | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int bh1745_read_thresh(struct iio_dev *indio_dev, | |
| 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 bh1745_data *data = iio_priv(indio_dev); | |
| int ret; | |
| switch (info) { | |
| case IIO_EV_INFO_VALUE: | |
| switch (dir) { | |
| case IIO_EV_DIR_RISING: | |
| ret = regmap_bulk_read(data->regmap, BH1745_TH_LSB, | |
| val, 2); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT; | |
| case IIO_EV_DIR_FALLING: | |
| ret = regmap_bulk_read(data->regmap, BH1745_TL_LSB, | |
| val, 2); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT; | |
| default: | |
| return -EINVAL; | |
| } | |
| case IIO_EV_INFO_PERIOD: | |
| ret = regmap_read(data->regmap, BH1745_PERSISTENCE, val); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT; | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int bh1745_write_thresh(struct iio_dev *indio_dev, | |
| 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 bh1745_data *data = iio_priv(indio_dev); | |
| int ret; | |
| switch (info) { | |
| case IIO_EV_INFO_VALUE: | |
| if (val < 0x0 || val > 0xFFFF) | |
| return -EINVAL; | |
| switch (dir) { | |
| case IIO_EV_DIR_RISING: | |
| ret = regmap_bulk_write(data->regmap, BH1745_TH_LSB, | |
| &val, 2); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT; | |
| case IIO_EV_DIR_FALLING: | |
| ret = regmap_bulk_write(data->regmap, BH1745_TL_LSB, | |
| &val, 2); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT; | |
| default: | |
| return -EINVAL; | |
| } | |
| case IIO_EV_INFO_PERIOD: | |
| if (val < BH1745_PRESISTENCE_UPDATE_TOGGLE || | |
| val > BH1745_PRESISTENCE_UPDATE_EIGHT_MEASUREMENT) | |
| return -EINVAL; | |
| ret = regmap_write(data->regmap, BH1745_PERSISTENCE, val); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT; | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int bh1745_read_event_config(struct iio_dev *indio_dev, | |
| const struct iio_chan_spec *chan, | |
| enum iio_event_type type, | |
| enum iio_event_direction dir) | |
| { | |
| struct bh1745_data *data = iio_priv(indio_dev); | |
| int ret; | |
| int value; | |
| int int_src; | |
| ret = regmap_read(data->regmap, BH1745_INTR, &value); | |
| if (ret) | |
| return ret; | |
| if (!FIELD_GET(BH1745_INTR_ENABLE, value)) | |
| return 0; | |
| int_src = FIELD_GET(BH1745_INTR_SOURCE_MASK, value); | |
| switch (chan->channel2) { | |
| case IIO_MOD_LIGHT_RED: | |
| if (int_src == BH1745_INTR_SOURCE_RED) | |
| return 1; | |
| return 0; | |
| case IIO_MOD_LIGHT_GREEN: | |
| if (int_src == BH1745_INTR_SOURCE_GREEN) | |
| return 1; | |
| return 0; | |
| case IIO_MOD_LIGHT_BLUE: | |
| if (int_src == BH1745_INTR_SOURCE_BLUE) | |
| return 1; | |
| return 0; | |
| case IIO_MOD_LIGHT_CLEAR: | |
| if (int_src == BH1745_INTR_SOURCE_CLEAR) | |
| return 1; | |
| return 0; | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int bh1745_write_event_config(struct iio_dev *indio_dev, | |
| const struct iio_chan_spec *chan, | |
| enum iio_event_type type, | |
| enum iio_event_direction dir, bool state) | |
| { | |
| struct bh1745_data *data = iio_priv(indio_dev); | |
| int value; | |
| if (!state) | |
| return regmap_clear_bits(data->regmap, | |
| BH1745_INTR, BH1745_INTR_ENABLE); | |
| /* Latch is always enabled when enabling interrupt */ | |
| value = BH1745_INTR_ENABLE; | |
| switch (chan->channel2) { | |
| case IIO_MOD_LIGHT_RED: | |
| return regmap_write(data->regmap, BH1745_INTR, | |
| value | FIELD_PREP(BH1745_INTR_SOURCE_MASK, | |
| BH1745_INTR_SOURCE_RED)); | |
| case IIO_MOD_LIGHT_GREEN: | |
| return regmap_write(data->regmap, BH1745_INTR, | |
| value | FIELD_PREP(BH1745_INTR_SOURCE_MASK, | |
| BH1745_INTR_SOURCE_GREEN)); | |
| case IIO_MOD_LIGHT_BLUE: | |
| return regmap_write(data->regmap, BH1745_INTR, | |
| value | FIELD_PREP(BH1745_INTR_SOURCE_MASK, | |
| BH1745_INTR_SOURCE_BLUE)); | |
| case IIO_MOD_LIGHT_CLEAR: | |
| return regmap_write(data->regmap, BH1745_INTR, | |
| value | FIELD_PREP(BH1745_INTR_SOURCE_MASK, | |
| BH1745_INTR_SOURCE_CLEAR)); | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int bh1745_read_avail(struct iio_dev *indio_dev, | |
| struct iio_chan_spec const *chan, const int **vals, | |
| int *type, int *length, long mask) | |
| { | |
| struct bh1745_data *data = iio_priv(indio_dev); | |
| switch (mask) { | |
| case IIO_CHAN_INFO_INT_TIME: | |
| return iio_gts_avail_times(&data->gts, vals, type, length); | |
| case IIO_CHAN_INFO_SCALE: | |
| return iio_gts_all_avail_scales(&data->gts, vals, type, length); | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static const struct iio_info bh1745_info = { | |
| .read_raw = bh1745_read_raw, | |
| .write_raw = bh1745_write_raw, | |
| .write_raw_get_fmt = bh1745_write_raw_get_fmt, | |
| .read_event_value = bh1745_read_thresh, | |
| .write_event_value = bh1745_write_thresh, | |
| .read_event_config = bh1745_read_event_config, | |
| .write_event_config = bh1745_write_event_config, | |
| .read_avail = bh1745_read_avail, | |
| }; | |
| static irqreturn_t bh1745_interrupt_handler(int interrupt, void *p) | |
| { | |
| struct iio_dev *indio_dev = p; | |
| struct bh1745_data *data = iio_priv(indio_dev); | |
| int ret; | |
| int value; | |
| int int_src; | |
| ret = regmap_read(data->regmap, BH1745_INTR, &value); | |
| if (ret) | |
| return IRQ_NONE; | |
| int_src = FIELD_GET(BH1745_INTR_SOURCE_MASK, value); | |
| if (value & BH1745_INTR_STATUS) { | |
| iio_push_event(indio_dev, | |
| IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, int_src, | |
| IIO_EV_TYPE_THRESH, | |
| IIO_EV_DIR_EITHER), | |
| iio_get_time_ns(indio_dev)); | |
| return IRQ_HANDLED; | |
| } | |
| return IRQ_NONE; | |
| } | |
| static irqreturn_t bh1745_trigger_handler(int interrupt, void *p) | |
| { | |
| struct iio_poll_func *pf = p; | |
| struct iio_dev *indio_dev = pf->indio_dev; | |
| struct bh1745_data *data = iio_priv(indio_dev); | |
| struct { | |
| u16 chans[4]; | |
| aligned_s64 timestamp; | |
| } scan = { }; | |
| u16 value; | |
| int ret; | |
| int i; | |
| int j = 0; | |
| iio_for_each_active_channel(indio_dev, i) { | |
| ret = regmap_bulk_read(data->regmap, BH1745_RED_LSB + 2 * i, | |
| &value, 2); | |
| if (ret) | |
| goto err; | |
| scan.chans[j++] = value; | |
| } | |
| iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan), | |
| iio_get_time_ns(indio_dev)); | |
| err: | |
| iio_trigger_notify_done(indio_dev->trig); | |
| return IRQ_HANDLED; | |
| } | |
| static int bh1745_setup_triggered_buffer(struct iio_dev *indio_dev, | |
| struct device *parent, | |
| int irq) | |
| { | |
| struct bh1745_data *data = iio_priv(indio_dev); | |
| struct device *dev = data->dev; | |
| int ret; | |
| ret = devm_iio_triggered_buffer_setup(parent, indio_dev, NULL, | |
| bh1745_trigger_handler, NULL); | |
| if (ret) | |
| return dev_err_probe(dev, ret, | |
| "Triggered buffer setup failed\n"); | |
| if (irq) { | |
| ret = devm_request_threaded_irq(dev, irq, NULL, | |
| bh1745_interrupt_handler, | |
| IRQF_ONESHOT, | |
| "bh1745_interrupt", indio_dev); | |
| if (ret) | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| static int bh1745_init(struct bh1745_data *data) | |
| { | |
| int ret; | |
| struct device *dev = data->dev; | |
| mutex_init(&data->lock); | |
| ret = devm_iio_init_iio_gts(dev, BH1745_MAX_GAIN, 0, bh1745_gain, | |
| ARRAY_SIZE(bh1745_gain), bh1745_itimes, | |
| ARRAY_SIZE(bh1745_itimes), &data->gts); | |
| if (ret) | |
| return ret; | |
| ret = bh1745_reset(data); | |
| if (ret) | |
| return dev_err_probe(dev, ret, "Failed to reset sensor\n"); | |
| ret = bh1745_power_on(data); | |
| if (ret) | |
| return dev_err_probe(dev, ret, "Failed to turn on sensor\n"); | |
| ret = devm_add_action_or_reset(dev, bh1745_power_off, data); | |
| if (ret) | |
| return ret; | |
| return 0; | |
| } | |
| static int bh1745_probe(struct i2c_client *client) | |
| { | |
| int ret; | |
| int value; | |
| int part_id; | |
| struct bh1745_data *data; | |
| struct iio_dev *indio_dev; | |
| struct device *dev = &client->dev; | |
| indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); | |
| if (!indio_dev) | |
| return -ENOMEM; | |
| indio_dev->info = &bh1745_info; | |
| indio_dev->name = "bh1745"; | |
| indio_dev->channels = bh1745_channels; | |
| indio_dev->modes = INDIO_DIRECT_MODE; | |
| indio_dev->num_channels = ARRAY_SIZE(bh1745_channels); | |
| data = iio_priv(indio_dev); | |
| data->dev = &client->dev; | |
| data->regmap = devm_regmap_init_i2c(client, &bh1745_regmap); | |
| if (IS_ERR(data->regmap)) | |
| return dev_err_probe(dev, PTR_ERR(data->regmap), | |
| "Failed to initialize Regmap\n"); | |
| ret = regmap_read(data->regmap, BH1745_SYS_CTRL, &value); | |
| if (ret) | |
| return ret; | |
| part_id = FIELD_GET(BH1745_SYS_CTRL_PART_ID_MASK, value); | |
| if (part_id != BH1745_PART_ID) | |
| dev_warn(dev, "Unknown part ID 0x%x\n", part_id); | |
| ret = devm_regulator_get_enable(dev, "vdd"); | |
| if (ret) | |
| return dev_err_probe(dev, ret, | |
| "Failed to get and enable regulator\n"); | |
| ret = bh1745_init(data); | |
| if (ret) | |
| return ret; | |
| ret = bh1745_setup_triggered_buffer(indio_dev, indio_dev->dev.parent, | |
| client->irq); | |
| if (ret) | |
| return ret; | |
| ret = devm_iio_device_register(dev, indio_dev); | |
| if (ret) | |
| return dev_err_probe(dev, ret, "Failed to register device\n"); | |
| return 0; | |
| } | |
| static const struct i2c_device_id bh1745_idtable[] = { | |
| { .name = "bh1745" }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(i2c, bh1745_idtable); | |
| static const struct of_device_id bh1745_of_match[] = { | |
| { .compatible = "rohm,bh1745" }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(of, bh1745_of_match); | |
| static struct i2c_driver bh1745_driver = { | |
| .driver = { | |
| .name = "bh1745", | |
| .of_match_table = bh1745_of_match, | |
| }, | |
| .probe = bh1745_probe, | |
| .id_table = bh1745_idtable, | |
| }; | |
| module_i2c_driver(bh1745_driver); | |
| MODULE_LICENSE("GPL"); | |
| MODULE_AUTHOR("Mudit Sharma <muditsharma.info@gmail.com>"); | |
| MODULE_DESCRIPTION("BH1745 colour sensor driver"); | |
| MODULE_IMPORT_NS("IIO_GTS_HELPER"); |