// SPDX-License-Identifier: GPL-2.0-only /* * Support for AMS AS73211 JENCOLOR(R) Digital XYZ Sensor * * Author: Christian Eggers <ceggers@arri.de> * * Copyright (c) 2020 ARRI Lighting * * Color light sensor with 16-bit channels for x, y, z and temperature); * 7-bit I2C slave address 0x74 .. 0x77. * * Datasheet: https://ams.com/documents/20143/36005/AS73211_DS000556_3-01.pdf */ #include <linux/bitfield.h> #include <linux/completion.h> #include <linux/delay.h> #include <linux/i2c.h> #include <linux/iio/buffer.h> #include <linux/iio/iio.h> #include <linux/iio/sysfs.h> #include <linux/iio/trigger_consumer.h> #include <linux/iio/triggered_buffer.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/pm.h> #define HZ_PER_KHZ 1000 #define AS73211_DRV_NAME "as73211" /* AS73211 configuration registers */ #define AS73211_REG_OSR 0x0 #define AS73211_REG_AGEN 0x2 #define AS73211_REG_CREG1 0x6 #define AS73211_REG_CREG2 0x7 #define AS73211_REG_CREG3 0x8 /* AS73211 output register bank */ #define AS73211_OUT_OSR_STATUS 0 #define AS73211_OUT_TEMP 1 #define AS73211_OUT_MRES1 2 #define AS73211_OUT_MRES2 3 #define AS73211_OUT_MRES3 4 #define AS73211_OSR_SS BIT(7) #define AS73211_OSR_PD BIT(6) #define AS73211_OSR_SW_RES BIT(3) #define AS73211_OSR_DOS_MASK GENMASK(2, 0) #define AS73211_OSR_DOS_CONFIG FIELD_PREP(AS73211_OSR_DOS_MASK, 0x2) #define AS73211_OSR_DOS_MEASURE FIELD_PREP(AS73211_OSR_DOS_MASK, 0x3) #define AS73211_AGEN_DEVID_MASK GENMASK(7, 4) #define AS73211_AGEN_DEVID(x) FIELD_PREP(AS73211_AGEN_DEVID_MASK, (x)) #define AS73211_AGEN_MUT_MASK GENMASK(3, 0) #define AS73211_AGEN_MUT(x) FIELD_PREP(AS73211_AGEN_MUT_MASK, (x)) #define AS73211_CREG1_GAIN_MASK GENMASK(7, 4) #define AS73211_CREG1_GAIN_1 11 #define AS73211_CREG1_TIME_MASK GENMASK(3, 0) #define AS73211_CREG3_CCLK_MASK GENMASK(1, 0) #define AS73211_OSR_STATUS_OUTCONVOF BIT(15) #define AS73211_OSR_STATUS_MRESOF BIT(14) #define AS73211_OSR_STATUS_ADCOF BIT(13) #define AS73211_OSR_STATUS_LDATA BIT(12) #define AS73211_OSR_STATUS_NDATA BIT(11) #define AS73211_OSR_STATUS_NOTREADY BIT(10) #define AS73211_SAMPLE_FREQ_BASE 1024000 #define AS73211_SAMPLE_TIME_NUM 15 #define AS73211_SAMPLE_TIME_MAX_MS BIT(AS73211_SAMPLE_TIME_NUM - 1) /* Available sample frequencies are 1.024MHz multiplied by powers of two. */ static const int as73211_samp_freq_avail[] = { AS73211_SAMPLE_FREQ_BASE * 1, AS73211_SAMPLE_FREQ_BASE * 2, AS73211_SAMPLE_FREQ_BASE * 4, AS73211_SAMPLE_FREQ_BASE * 8, }; static const int as73211_hardwaregain_avail[] = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, }; /** * struct as73211_data - Instance data for one AS73211 * @client: I2C client. * @osr: Cached Operational State Register. * @creg1: Cached Configuration Register 1. * @creg2: Cached Configuration Register 2. * @creg3: Cached Configuration Register 3. * @mutex: Keeps cached registers in sync with the device. * @completion: Completion to wait for interrupt. * @int_time_avail: Available integration times (depend on sampling frequency). */ struct as73211_data { struct i2c_client *client; u8 osr; u8 creg1; u8 creg2; u8 creg3; struct mutex mutex; struct completion completion; int int_time_avail[AS73211_SAMPLE_TIME_NUM * 2]; }; #define AS73211_COLOR_CHANNEL(_color, _si, _addr) { \ .type = IIO_INTENSITY, \ .modified = 1, \ .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), \ .info_mask_shared_by_type = \ BIT(IIO_CHAN_INFO_SAMP_FREQ) | \ BIT(IIO_CHAN_INFO_HARDWAREGAIN) | \ BIT(IIO_CHAN_INFO_INT_TIME), \ .info_mask_shared_by_type_available = \ BIT(IIO_CHAN_INFO_SAMP_FREQ) | \ BIT(IIO_CHAN_INFO_HARDWAREGAIN) | \ BIT(IIO_CHAN_INFO_INT_TIME), \ .channel2 = IIO_MOD_##_color, \ .address = _addr, \ .scan_index = _si, \ .scan_type = { \ .sign = 'u', \ .realbits = 16, \ .storagebits = 16, \ .endianness = IIO_LE, \ }, \ } #define AS73211_OFFSET_TEMP_INT (-66) #define AS73211_OFFSET_TEMP_MICRO 900000 #define AS73211_SCALE_TEMP_INT 0 #define AS73211_SCALE_TEMP_MICRO 50000 #define AS73211_SCALE_X 277071108 /* nW/m^2 */ #define AS73211_SCALE_Y 298384270 /* nW/m^2 */ #define AS73211_SCALE_Z 160241927 /* nW/m^2 */ /* Channel order MUST match devices result register order */ #define AS73211_SCAN_INDEX_TEMP 0 #define AS73211_SCAN_INDEX_X 1 #define AS73211_SCAN_INDEX_Y 2 #define AS73211_SCAN_INDEX_Z 3 #define AS73211_SCAN_INDEX_TS 4 #define AS73211_SCAN_MASK_COLOR ( \ BIT(AS73211_SCAN_INDEX_X) | \ BIT(AS73211_SCAN_INDEX_Y) | \ BIT(AS73211_SCAN_INDEX_Z)) #define AS73211_SCAN_MASK_ALL ( \ BIT(AS73211_SCAN_INDEX_TEMP) | \ AS73211_SCAN_MASK_COLOR) static const struct iio_chan_spec as73211_channels[] = { { .type = IIO_TEMP, .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_SCALE), .address = AS73211_OUT_TEMP, .scan_index = AS73211_SCAN_INDEX_TEMP, .scan_type = { .sign = 'u', .realbits = 16, .storagebits = 16, .endianness = IIO_LE, } }, AS73211_COLOR_CHANNEL(X, AS73211_SCAN_INDEX_X, AS73211_OUT_MRES1), AS73211_COLOR_CHANNEL(Y, AS73211_SCAN_INDEX_Y, AS73211_OUT_MRES2), AS73211_COLOR_CHANNEL(Z, AS73211_SCAN_INDEX_Z, AS73211_OUT_MRES3), IIO_CHAN_SOFT_TIMESTAMP(AS73211_SCAN_INDEX_TS), }; static unsigned int as73211_integration_time_1024cyc(struct as73211_data *data) { /* * Return integration time in units of 1024 clock cycles. Integration time * in CREG1 is in powers of 2 (x 1024 cycles). */ return BIT(FIELD_GET(AS73211_CREG1_TIME_MASK, data->creg1)); } static unsigned int as73211_integration_time_us(struct as73211_data *data, unsigned int integration_time_1024cyc) { /* * f_samp is configured in CREG3 in powers of 2 (x 1.024 MHz) * t_cycl is configured in CREG1 in powers of 2 (x 1024 cycles) * t_int_us = 1 / (f_samp) * t_cycl * US_PER_SEC * = 1 / (2^CREG3_CCLK * 1,024,000) * 2^CREG1_CYCLES * 1,024 * US_PER_SEC * = 2^(-CREG3_CCLK) * 2^CREG1_CYCLES * 1,000 * In order to get rid of negative exponents, we extend the "fraction" * by 2^3 (CREG3_CCLK,max = 3) * t_int_us = 2^(3-CREG3_CCLK) * 2^CREG1_CYCLES * 125 */ return BIT(3 - FIELD_GET(AS73211_CREG3_CCLK_MASK, data->creg3)) * integration_time_1024cyc * 125; } static void as73211_integration_time_calc_avail(struct as73211_data *data) { int i; for (i = 0; i < ARRAY_SIZE(data->int_time_avail) / 2; i++) { unsigned int time_us = as73211_integration_time_us(data, BIT(i)); data->int_time_avail[i * 2 + 0] = time_us / USEC_PER_SEC; data->int_time_avail[i * 2 + 1] = time_us % USEC_PER_SEC; } } static unsigned int as73211_gain(struct as73211_data *data) { /* gain can be calculated from CREG1 as 2^(11 - CREG1_GAIN) */ return BIT(AS73211_CREG1_GAIN_1 - FIELD_GET(AS73211_CREG1_GAIN_MASK, data->creg1)); } /* must be called with as73211_data::mutex held. */ static int as73211_req_data(struct as73211_data *data) { unsigned int time_us = as73211_integration_time_us(data, as73211_integration_time_1024cyc(data)); struct device *dev = &data->client->dev; union i2c_smbus_data smbus_data; u16 osr_status; int ret; if (data->client->irq) reinit_completion(&data->completion); /* * During measurement, there should be no traffic on the i2c bus as the * electrical noise would disturb the measurement process. */ i2c_lock_bus(data->client->adapter, I2C_LOCK_SEGMENT); data->osr &= ~AS73211_OSR_DOS_MASK; data->osr |= AS73211_OSR_DOS_MEASURE | AS73211_OSR_SS; smbus_data.byte = data->osr; ret = __i2c_smbus_xfer(data->client->adapter, data->client->addr, data->client->flags, I2C_SMBUS_WRITE, AS73211_REG_OSR, I2C_SMBUS_BYTE_DATA, &smbus_data); if (ret < 0) { i2c_unlock_bus(data->client->adapter, I2C_LOCK_SEGMENT); return ret; } /* * Reset AS73211_OSR_SS (is self clearing) in order to avoid unintentional * triggering of further measurements later. */ data->osr &= ~AS73211_OSR_SS; /* * Add 33% extra margin for the timeout. fclk,min = fclk,typ - 27%. */ time_us += time_us / 3; if (data->client->irq) { ret = wait_for_completion_timeout(&data->completion, usecs_to_jiffies(time_us)); if (!ret) { dev_err(dev, "timeout waiting for READY IRQ\n"); i2c_unlock_bus(data->client->adapter, I2C_LOCK_SEGMENT); return -ETIMEDOUT; } } else { /* Wait integration time */ usleep_range(time_us, 2 * time_us); } i2c_unlock_bus(data->client->adapter, I2C_LOCK_SEGMENT); ret = i2c_smbus_read_word_data(data->client, AS73211_OUT_OSR_STATUS); if (ret < 0) return ret; osr_status = ret; if (osr_status != (AS73211_OSR_DOS_MEASURE | AS73211_OSR_STATUS_NDATA)) { if (osr_status & AS73211_OSR_SS) { dev_err(dev, "%s() Measurement has not stopped\n", __func__); return -ETIME; } if (osr_status & AS73211_OSR_STATUS_NOTREADY) { dev_err(dev, "%s() Data is not ready\n", __func__); return -ENODATA; } if (!(osr_status & AS73211_OSR_STATUS_NDATA)) { dev_err(dev, "%s() No new data available\n", __func__); return -ENODATA; } if (osr_status & AS73211_OSR_STATUS_LDATA) { dev_err(dev, "%s() Result buffer overrun\n", __func__); return -ENOBUFS; } if (osr_status & AS73211_OSR_STATUS_ADCOF) { dev_err(dev, "%s() ADC overflow\n", __func__); return -EOVERFLOW; } if (osr_status & AS73211_OSR_STATUS_MRESOF) { dev_err(dev, "%s() Measurement result overflow\n", __func__); return -EOVERFLOW; } if (osr_status & AS73211_OSR_STATUS_OUTCONVOF) { dev_err(dev, "%s() Timer overflow\n", __func__); return -EOVERFLOW; } dev_err(dev, "%s() Unexpected status value\n", __func__); return -EIO; } return 0; } static int as73211_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct as73211_data *data = iio_priv(indio_dev); switch (mask) { case IIO_CHAN_INFO_RAW: { int ret; ret = iio_device_claim_direct_mode(indio_dev); if (ret < 0) return ret; ret = as73211_req_data(data); if (ret < 0) { iio_device_release_direct_mode(indio_dev); return ret; } ret = i2c_smbus_read_word_data(data->client, chan->address); iio_device_release_direct_mode(indio_dev); if (ret < 0) return ret; *val = ret; return IIO_VAL_INT; } case IIO_CHAN_INFO_OFFSET: *val = AS73211_OFFSET_TEMP_INT; *val2 = AS73211_OFFSET_TEMP_MICRO; return IIO_VAL_INT_PLUS_MICRO; case IIO_CHAN_INFO_SCALE: switch (chan->type) { case IIO_TEMP: *val = AS73211_SCALE_TEMP_INT; *val2 = AS73211_SCALE_TEMP_MICRO; return IIO_VAL_INT_PLUS_MICRO; case IIO_INTENSITY: { unsigned int scale; switch (chan->channel2) { case IIO_MOD_X: scale = AS73211_SCALE_X; break; case IIO_MOD_Y: scale = AS73211_SCALE_Y; break; case IIO_MOD_Z: scale = AS73211_SCALE_Z; break; default: return -EINVAL; } scale /= as73211_gain(data); scale /= as73211_integration_time_1024cyc(data); *val = scale; return IIO_VAL_INT; default: return -EINVAL; }} case IIO_CHAN_INFO_SAMP_FREQ: /* f_samp is configured in CREG3 in powers of 2 (x 1.024 MHz) */ *val = BIT(FIELD_GET(AS73211_CREG3_CCLK_MASK, data->creg3)) * AS73211_SAMPLE_FREQ_BASE; return IIO_VAL_INT; case IIO_CHAN_INFO_HARDWAREGAIN: *val = as73211_gain(data); return IIO_VAL_INT; case IIO_CHAN_INFO_INT_TIME: { unsigned int time_us; mutex_lock(&data->mutex); time_us = as73211_integration_time_us(data, as73211_integration_time_1024cyc(data)); mutex_unlock(&data->mutex); *val = time_us / USEC_PER_SEC; *val2 = time_us % USEC_PER_SEC; return IIO_VAL_INT_PLUS_MICRO; default: return -EINVAL; }} } static int as73211_read_avail(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, const int **vals, int *type, int *length, long mask) { struct as73211_data *data = iio_priv(indio_dev); switch (mask) { case IIO_CHAN_INFO_SAMP_FREQ: *length = ARRAY_SIZE(as73211_samp_freq_avail); *vals = as73211_samp_freq_avail; *type = IIO_VAL_INT; return IIO_AVAIL_LIST; case IIO_CHAN_INFO_HARDWAREGAIN: *length = ARRAY_SIZE(as73211_hardwaregain_avail); *vals = as73211_hardwaregain_avail; *type = IIO_VAL_INT; return IIO_AVAIL_LIST; case IIO_CHAN_INFO_INT_TIME: *length = ARRAY_SIZE(data->int_time_avail); *vals = data->int_time_avail; *type = IIO_VAL_INT_PLUS_MICRO; return IIO_AVAIL_LIST; default: return -EINVAL; } } static int _as73211_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan __always_unused, int val, int val2, long mask) { struct as73211_data *data = iio_priv(indio_dev); int ret; switch (mask) { case IIO_CHAN_INFO_SAMP_FREQ: { int reg_bits, freq_kHz = val / HZ_PER_KHZ; /* 1024, 2048, ... */ /* val must be 1024 * 2^x */ if (val < 0 || (freq_kHz * HZ_PER_KHZ) != val || !is_power_of_2(freq_kHz) || val2) return -EINVAL; /* f_samp is configured in CREG3 in powers of 2 (x 1.024 MHz (=2^10)) */ reg_bits = ilog2(freq_kHz) - 10; if (!FIELD_FIT(AS73211_CREG3_CCLK_MASK, reg_bits)) return -EINVAL; data->creg3 &= ~AS73211_CREG3_CCLK_MASK; data->creg3 |= FIELD_PREP(AS73211_CREG3_CCLK_MASK, reg_bits); as73211_integration_time_calc_avail(data); ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_CREG3, data->creg3); if (ret < 0) return ret; return 0; } case IIO_CHAN_INFO_HARDWAREGAIN: { unsigned int reg_bits; if (val < 0 || !is_power_of_2(val) || val2) return -EINVAL; /* gain can be calculated from CREG1 as 2^(11 - CREG1_GAIN) */ reg_bits = AS73211_CREG1_GAIN_1 - ilog2(val); if (!FIELD_FIT(AS73211_CREG1_GAIN_MASK, reg_bits)) return -EINVAL; data->creg1 &= ~AS73211_CREG1_GAIN_MASK; data->creg1 |= FIELD_PREP(AS73211_CREG1_GAIN_MASK, reg_bits); ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_CREG1, data->creg1); if (ret < 0) return ret; return 0; } case IIO_CHAN_INFO_INT_TIME: { int val_us = val * USEC_PER_SEC + val2; int time_ms; int reg_bits; /* f_samp is configured in CREG3 in powers of 2 (x 1.024 MHz) */ int f_samp_1_024mhz = BIT(FIELD_GET(AS73211_CREG3_CCLK_MASK, data->creg3)); /* * time_ms = time_us * US_PER_MS * f_samp_1_024mhz / MHZ_PER_HZ * = time_us * f_samp_1_024mhz / 1000 */ time_ms = (val_us * f_samp_1_024mhz) / 1000; /* 1 ms, 2 ms, ... (power of two) */ if (time_ms < 0 || !is_power_of_2(time_ms) || time_ms > AS73211_SAMPLE_TIME_MAX_MS) return -EINVAL; reg_bits = ilog2(time_ms); if (!FIELD_FIT(AS73211_CREG1_TIME_MASK, reg_bits)) return -EINVAL; /* not possible due to previous tests */ data->creg1 &= ~AS73211_CREG1_TIME_MASK; data->creg1 |= FIELD_PREP(AS73211_CREG1_TIME_MASK, reg_bits); ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_CREG1, data->creg1); if (ret < 0) return ret; return 0; default: return -EINVAL; }} } static int as73211_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int val, int val2, long mask) { struct as73211_data *data = iio_priv(indio_dev); int ret; mutex_lock(&data->mutex); ret = iio_device_claim_direct_mode(indio_dev); if (ret < 0) goto error_unlock; /* Need to switch to config mode ... */ if ((data->osr & AS73211_OSR_DOS_MASK) != AS73211_OSR_DOS_CONFIG) { data->osr &= ~AS73211_OSR_DOS_MASK; data->osr |= AS73211_OSR_DOS_CONFIG; ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_OSR, data->osr); if (ret < 0) goto error_release; } ret = _as73211_write_raw(indio_dev, chan, val, val2, mask); error_release: iio_device_release_direct_mode(indio_dev); error_unlock: mutex_unlock(&data->mutex); return ret; } static irqreturn_t as73211_ready_handler(int irq __always_unused, void *priv) { struct as73211_data *data = iio_priv(priv); complete(&data->completion); return IRQ_HANDLED; } static irqreturn_t as73211_trigger_handler(int irq __always_unused, void *p) { struct iio_poll_func *pf = p; struct iio_dev *indio_dev = pf->indio_dev; struct as73211_data *data = iio_priv(indio_dev); struct { __le16 chan[4]; s64 ts __aligned(8); } scan; int data_result, ret; mutex_lock(&data->mutex); data_result = as73211_req_data(data); if (data_result < 0 && data_result != -EOVERFLOW) goto done; /* don't push any data for errors other than EOVERFLOW */ if (*indio_dev->active_scan_mask == AS73211_SCAN_MASK_ALL) { /* Optimization for reading all (color + temperature) channels */ u8 addr = as73211_channels[0].address; struct i2c_msg msgs[] = { { .addr = data->client->addr, .flags = 0, .len = 1, .buf = &addr, }, { .addr = data->client->addr, .flags = I2C_M_RD, .len = sizeof(scan.chan), .buf = (u8 *)&scan.chan, }, }; ret = i2c_transfer(data->client->adapter, msgs, ARRAY_SIZE(msgs)); if (ret < 0) goto done; } else { /* Optimization for reading only color channels */ /* AS73211 starts reading at address 2 */ ret = i2c_master_recv(data->client, (char *)&scan.chan[1], 3 * sizeof(scan.chan[1])); if (ret < 0) goto done; } if (data_result) { /* * Saturate all channels (in case of overflows). Temperature channel * is not affected by overflows. */ scan.chan[1] = cpu_to_le16(U16_MAX); scan.chan[2] = cpu_to_le16(U16_MAX); scan.chan[3] = cpu_to_le16(U16_MAX); } iio_push_to_buffers_with_timestamp(indio_dev, &scan, iio_get_time_ns(indio_dev)); done: mutex_unlock(&data->mutex); iio_trigger_notify_done(indio_dev->trig); return IRQ_HANDLED; } static const struct iio_info as73211_info = { .read_raw = as73211_read_raw, .read_avail = as73211_read_avail, .write_raw = as73211_write_raw, }; static int as73211_power(struct iio_dev *indio_dev, bool state) { struct as73211_data *data = iio_priv(indio_dev); int ret; mutex_lock(&data->mutex); if (state) data->osr &= ~AS73211_OSR_PD; else data->osr |= AS73211_OSR_PD; ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_OSR, data->osr); mutex_unlock(&data->mutex); if (ret < 0) return ret; return 0; } static void as73211_power_disable(void *data) { struct iio_dev *indio_dev = data; as73211_power(indio_dev, false); } static int as73211_probe(struct i2c_client *client) { struct device *dev = &client->dev; struct as73211_data *data; struct iio_dev *indio_dev; int ret; indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; data = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); data->client = client; mutex_init(&data->mutex); init_completion(&data->completion); indio_dev->info = &as73211_info; indio_dev->name = AS73211_DRV_NAME; indio_dev->channels = as73211_channels; indio_dev->num_channels = ARRAY_SIZE(as73211_channels); indio_dev->modes = INDIO_DIRECT_MODE; ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_OSR); if (ret < 0) return ret; data->osr = ret; /* reset device */ data->osr |= AS73211_OSR_SW_RES; ret = i2c_smbus_write_byte_data(data->client, AS73211_REG_OSR, data->osr); if (ret < 0) return ret; ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_OSR); if (ret < 0) return ret; data->osr = ret; /* * Reading AGEN is only possible after reset (AGEN is not available if * device is in measurement mode). */ ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_AGEN); if (ret < 0) return ret; /* At the time of writing this driver, only DEVID 2 and MUT 1 are known. */ if ((ret & AS73211_AGEN_DEVID_MASK) != AS73211_AGEN_DEVID(2) || (ret & AS73211_AGEN_MUT_MASK) != AS73211_AGEN_MUT(1)) return -ENODEV; ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_CREG1); if (ret < 0) return ret; data->creg1 = ret; ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_CREG2); if (ret < 0) return ret; data->creg2 = ret; ret = i2c_smbus_read_byte_data(data->client, AS73211_REG_CREG3); if (ret < 0) return ret; data->creg3 = ret; as73211_integration_time_calc_avail(data); ret = as73211_power(indio_dev, true); if (ret < 0) return ret; ret = devm_add_action_or_reset(dev, as73211_power_disable, indio_dev); if (ret) return ret; ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL, as73211_trigger_handler, NULL); if (ret) return ret; if (client->irq) { ret = devm_request_threaded_irq(&client->dev, client->irq, NULL, as73211_ready_handler, IRQF_ONESHOT, client->name, indio_dev); if (ret) return ret; } return devm_iio_device_register(dev, indio_dev); } static int __maybe_unused as73211_suspend(struct device *dev) { struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); return as73211_power(indio_dev, false); } static int __maybe_unused as73211_resume(struct device *dev) { struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); return as73211_power(indio_dev, true); } static SIMPLE_DEV_PM_OPS(as73211_pm_ops, as73211_suspend, as73211_resume); static const struct of_device_id as73211_of_match[] = { { .compatible = "ams,as73211" }, { } }; MODULE_DEVICE_TABLE(of, as73211_of_match); static const struct i2c_device_id as73211_id[] = { { "as73211", 0 }, { } }; MODULE_DEVICE_TABLE(i2c, as73211_id); static struct i2c_driver as73211_driver = { .driver = { .name = AS73211_DRV_NAME, .of_match_table = as73211_of_match, .pm = &as73211_pm_ops, }, .probe_new = as73211_probe, .id_table = as73211_id, }; module_i2c_driver(as73211_driver); MODULE_AUTHOR("Christian Eggers <ceggers@arri.de>"); MODULE_DESCRIPTION("AS73211 XYZ True Color Sensor driver"); MODULE_LICENSE("GPL");