#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>
#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
#define BH1745_MODE_CTRL1 0x41
#define BH1745_CTRL1_MEASUREMENT_TIME_MASK GENMASK(2, 0)
#define BH1745_MODE_CTRL2 0x42
#define BH1745_CTRL2_RGBC_EN BIT(4)
#define BH1745_CTRL2_ADC_GAIN_MASK GENMASK(1, 0)
#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
#define BH1745_TH_LSB 0x62
#define BH1745_TH_MSB 0x63
#define BH1745_TL_LSB 0x64
#define BH1745_TL_MSB 0x65
#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
#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 {
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),
regmap_reg_range(BH1745_RED_LSB, BH1745_CLEAR_MSB),
regmap_reg_range(BH1745_INTR, BH1745_INTR),
};
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);
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 dev_err_probe(dev, ret,
"Request for IRQ failed\n");
}
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[] = {
{ "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");
