| // SPDX-License-Identifier: GPL-2.0-or-later | |
| /* | |
| * APDS-9306/APDS-9306-065 Ambient Light Sensor | |
| * I2C Address: 0x52 | |
| * Datasheet: https://docs.broadcom.com/doc/AV02-4755EN | |
| * | |
| * Copyright (C) 2024 Subhajit Ghosh <subhajit.ghosh@tweaklogic.com> | |
| */ | |
| #include <linux/bits.h> | |
| #include <linux/cleanup.h> | |
| #include <linux/delay.h> | |
| #include <linux/err.h> | |
| #include <linux/i2c.h> | |
| #include <linux/interrupt.h> | |
| #include <linux/minmax.h> | |
| #include <linux/module.h> | |
| #include <linux/mutex.h> | |
| #include <linux/pm.h> | |
| #include <linux/pm_runtime.h> | |
| #include <linux/regmap.h> | |
| #include <linux/regulator/consumer.h> | |
| #include <linux/types.h> | |
| #include <linux/units.h> | |
| #include <linux/iio/iio.h> | |
| #include <linux/iio/iio-gts-helper.h> | |
| #include <linux/iio/events.h> | |
| #include <linux/iio/sysfs.h> | |
| #include <linux/unaligned.h> | |
| #define APDS9306_MAIN_CTRL_REG 0x00 | |
| #define APDS9306_ALS_MEAS_RATE_REG 0x04 | |
| #define APDS9306_ALS_GAIN_REG 0x05 | |
| #define APDS9306_PART_ID_REG 0x06 | |
| #define APDS9306_MAIN_STATUS_REG 0x07 | |
| #define APDS9306_CLEAR_DATA_0_REG 0x0A | |
| #define APDS9306_CLEAR_DATA_1_REG 0x0B | |
| #define APDS9306_CLEAR_DATA_2_REG 0x0C | |
| #define APDS9306_ALS_DATA_0_REG 0x0D | |
| #define APDS9306_ALS_DATA_1_REG 0x0E | |
| #define APDS9306_ALS_DATA_2_REG 0x0F | |
| #define APDS9306_INT_CFG_REG 0x19 | |
| #define APDS9306_INT_PERSISTENCE_REG 0x1A | |
| #define APDS9306_ALS_THRES_UP_0_REG 0x21 | |
| #define APDS9306_ALS_THRES_UP_1_REG 0x22 | |
| #define APDS9306_ALS_THRES_UP_2_REG 0x23 | |
| #define APDS9306_ALS_THRES_LOW_0_REG 0x24 | |
| #define APDS9306_ALS_THRES_LOW_1_REG 0x25 | |
| #define APDS9306_ALS_THRES_LOW_2_REG 0x26 | |
| #define APDS9306_ALS_THRES_VAR_REG 0x27 | |
| #define APDS9306_ALS_INT_STAT_MASK BIT(4) | |
| #define APDS9306_ALS_DATA_STAT_MASK BIT(3) | |
| #define APDS9306_ALS_THRES_VAL_MAX (BIT(20) - 1) | |
| #define APDS9306_ALS_THRES_VAR_NUM_VALS 8 | |
| #define APDS9306_ALS_PERSIST_NUM_VALS 16 | |
| #define APDS9306_ALS_READ_DATA_DELAY_US (20 * USEC_PER_MSEC) | |
| #define APDS9306_NUM_REPEAT_RATES 7 | |
| #define APDS9306_INT_SRC_CLEAR 0 | |
| #define APDS9306_INT_SRC_ALS 1 | |
| #define APDS9306_SAMP_FREQ_10HZ 2 | |
| /** | |
| * struct part_id_gts_multiplier - Part no. and corresponding gts multiplier | |
| * | |
| * GTS (Gain Time Scale) are helper functions for Light sensors which along | |
| * with hardware gains also has gains associated with Integration times. | |
| * | |
| * There are two variants of the device with slightly different characteristics, | |
| * they have same ADC count for different Lux levels as mentioned in the | |
| * datasheet. This multiplier array is used to store the derived Lux per count | |
| * value for the two variants to be used by the GTS helper functions. | |
| * | |
| * @part_id: Part ID of the device | |
| * @max_scale_int: Multiplier for iio_init_iio_gts() | |
| * @max_scale_nano: Multiplier for iio_init_iio_gts() | |
| */ | |
| struct part_id_gts_multiplier { | |
| int part_id; | |
| int max_scale_int; | |
| int max_scale_nano; | |
| }; | |
| /* | |
| * As per the datasheet, at HW Gain = 3x, Integration time 100mS (32x), | |
| * typical 2000 ADC counts are observed for 49.8 uW per sq cm (340.134 lux) | |
| * for apds9306 and 43 uW per sq cm (293.69 lux) for apds9306-065. | |
| * Assuming lux per count is linear across all integration time ranges. | |
| * | |
| * Lux = (raw + offset) * scale; offset can be any value by userspace. | |
| * HG = Hardware Gain; ITG = Gain by changing integration time. | |
| * Scale table by IIO GTS Helpers = (1 / HG) * (1 / ITG) * Multiplier. | |
| * | |
| * The Lux values provided in the datasheet are at ITG=32x and HG=3x, | |
| * at typical 2000 count for both variants of the device. | |
| * | |
| * Lux per ADC count at 3x and 32x for apds9306 = 340.134 / 2000 | |
| * Lux per ADC count at 3x and 32x for apds9306-065 = 293.69 / 2000 | |
| * | |
| * The Multiplier for the scale table provided to userspace: | |
| * IIO GTS scale Multiplier for apds9306 = (340.134 / 2000) * 32 * 3 = 16.326432 | |
| * and for apds9306-065 = (293.69 / 2000) * 32 * 3 = 14.09712 | |
| */ | |
| static const struct part_id_gts_multiplier apds9306_gts_mul[] = { | |
| { | |
| .part_id = 0xB1, | |
| .max_scale_int = 16, | |
| .max_scale_nano = 326432000, | |
| }, { | |
| .part_id = 0xB3, | |
| .max_scale_int = 14, | |
| .max_scale_nano = 97120000, | |
| }, | |
| }; | |
| static const int apds9306_repeat_rate_freq[APDS9306_NUM_REPEAT_RATES][2] = { | |
| { 40, 0 }, | |
| { 20, 0 }, | |
| { 10, 0 }, | |
| { 5, 0 }, | |
| { 2, 0 }, | |
| { 1, 0 }, | |
| { 0, 500000 }, | |
| }; | |
| static const int apds9306_repeat_rate_period[APDS9306_NUM_REPEAT_RATES] = { | |
| 25000, 50000, 100000, 200000, 500000, 1000000, 2000000, | |
| }; | |
| /** | |
| * struct apds9306_regfields - apds9306 regmap fields definitions | |
| * | |
| * @sw_reset: Software reset regfield | |
| * @en: Enable regfield | |
| * @intg_time: Resolution regfield | |
| * @repeat_rate: Measurement Rate regfield | |
| * @gain: Hardware gain regfield | |
| * @int_src: Interrupt channel regfield | |
| * @int_thresh_var_en: Interrupt variance threshold regfield | |
| * @int_en: Interrupt enable regfield | |
| * @int_persist_val: Interrupt persistence regfield | |
| * @int_thresh_var_val: Interrupt threshold variance value regfield | |
| */ | |
| struct apds9306_regfields { | |
| struct regmap_field *sw_reset; | |
| struct regmap_field *en; | |
| struct regmap_field *intg_time; | |
| struct regmap_field *repeat_rate; | |
| struct regmap_field *gain; | |
| struct regmap_field *int_src; | |
| struct regmap_field *int_thresh_var_en; | |
| struct regmap_field *int_en; | |
| struct regmap_field *int_persist_val; | |
| struct regmap_field *int_thresh_var_val; | |
| }; | |
| /** | |
| * struct apds9306_data - apds9306 private data and registers definitions | |
| * | |
| * @dev: Pointer to the device structure | |
| * @gts: IIO Gain Time Scale structure | |
| * @mutex: Lock for protecting adc reads, device settings changes where | |
| * some calculations are required before or after setting or | |
| * getting the raw settings values from regmap writes or reads | |
| * respectively. | |
| * @regmap: Regmap structure pointer | |
| * @rf: Regmap register fields structure | |
| * @read_data_available: Flag set by IRQ handler for ADC data available | |
| */ | |
| struct apds9306_data { | |
| struct device *dev; | |
| struct iio_gts gts; | |
| struct mutex mutex; | |
| struct regmap *regmap; | |
| struct apds9306_regfields rf; | |
| int read_data_available; | |
| }; | |
| /* | |
| * Available scales with gain 1x - 18x, timings 3.125, 25, 50, 100, 200, 400 ms | |
| * Time impacts to gain: 1x, 8x, 16x, 32x, 64x, 128x | |
| */ | |
| #define APDS9306_GSEL_1X 0x00 | |
| #define APDS9306_GSEL_3X 0x01 | |
| #define APDS9306_GSEL_6X 0x02 | |
| #define APDS9306_GSEL_9X 0x03 | |
| #define APDS9306_GSEL_18X 0x04 | |
| static const struct iio_gain_sel_pair apds9306_gains[] = { | |
| GAIN_SCALE_GAIN(1, APDS9306_GSEL_1X), | |
| GAIN_SCALE_GAIN(3, APDS9306_GSEL_3X), | |
| GAIN_SCALE_GAIN(6, APDS9306_GSEL_6X), | |
| GAIN_SCALE_GAIN(9, APDS9306_GSEL_9X), | |
| GAIN_SCALE_GAIN(18, APDS9306_GSEL_18X), | |
| }; | |
| #define APDS9306_MEAS_MODE_400MS 0x00 | |
| #define APDS9306_MEAS_MODE_200MS 0x01 | |
| #define APDS9306_MEAS_MODE_100MS 0x02 | |
| #define APDS9306_MEAS_MODE_50MS 0x03 | |
| #define APDS9306_MEAS_MODE_25MS 0x04 | |
| #define APDS9306_MEAS_MODE_3125US 0x05 | |
| static const struct iio_itime_sel_mul apds9306_itimes[] = { | |
| GAIN_SCALE_ITIME_US(400000, APDS9306_MEAS_MODE_400MS, BIT(7)), | |
| GAIN_SCALE_ITIME_US(200000, APDS9306_MEAS_MODE_200MS, BIT(6)), | |
| GAIN_SCALE_ITIME_US(100000, APDS9306_MEAS_MODE_100MS, BIT(5)), | |
| GAIN_SCALE_ITIME_US(50000, APDS9306_MEAS_MODE_50MS, BIT(4)), | |
| GAIN_SCALE_ITIME_US(25000, APDS9306_MEAS_MODE_25MS, BIT(3)), | |
| GAIN_SCALE_ITIME_US(3125, APDS9306_MEAS_MODE_3125US, BIT(0)), | |
| }; | |
| static const struct iio_event_spec apds9306_event_spec[] = { | |
| { | |
| .type = IIO_EV_TYPE_THRESH, | |
| .dir = IIO_EV_DIR_RISING, | |
| .mask_shared_by_all = BIT(IIO_EV_INFO_VALUE), | |
| }, { | |
| .type = IIO_EV_TYPE_THRESH, | |
| .dir = IIO_EV_DIR_FALLING, | |
| .mask_shared_by_all = BIT(IIO_EV_INFO_VALUE), | |
| }, { | |
| .type = IIO_EV_TYPE_THRESH, | |
| .dir = IIO_EV_DIR_EITHER, | |
| .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD), | |
| .mask_separate = BIT(IIO_EV_INFO_ENABLE), | |
| }, { | |
| .type = IIO_EV_TYPE_THRESH_ADAPTIVE, | |
| .mask_shared_by_all = BIT(IIO_EV_INFO_VALUE) | | |
| BIT(IIO_EV_INFO_ENABLE), | |
| }, | |
| }; | |
| static const struct iio_chan_spec apds9306_channels_with_events[] = { | |
| { | |
| .type = IIO_LIGHT, | |
| .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) | | |
| BIT(IIO_CHAN_INFO_SAMP_FREQ), | |
| .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) | | |
| BIT(IIO_CHAN_INFO_SAMP_FREQ), | |
| .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | | |
| BIT(IIO_CHAN_INFO_SCALE), | |
| .info_mask_separate_available = BIT(IIO_CHAN_INFO_SCALE), | |
| .event_spec = apds9306_event_spec, | |
| .num_event_specs = ARRAY_SIZE(apds9306_event_spec), | |
| }, { | |
| .type = IIO_INTENSITY, | |
| .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) | | |
| BIT(IIO_CHAN_INFO_SAMP_FREQ), | |
| .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) | | |
| BIT(IIO_CHAN_INFO_SAMP_FREQ), | |
| .channel2 = IIO_MOD_LIGHT_CLEAR, | |
| .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), | |
| .modified = 1, | |
| .event_spec = apds9306_event_spec, | |
| .num_event_specs = ARRAY_SIZE(apds9306_event_spec), | |
| }, | |
| }; | |
| static const struct iio_chan_spec apds9306_channels_without_events[] = { | |
| { | |
| .type = IIO_LIGHT, | |
| .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) | | |
| BIT(IIO_CHAN_INFO_SAMP_FREQ), | |
| .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) | | |
| BIT(IIO_CHAN_INFO_SAMP_FREQ), | |
| .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | | |
| BIT(IIO_CHAN_INFO_SCALE), | |
| .info_mask_separate_available = BIT(IIO_CHAN_INFO_SCALE), | |
| }, { | |
| .type = IIO_INTENSITY, | |
| .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) | | |
| BIT(IIO_CHAN_INFO_SAMP_FREQ), | |
| .info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) | | |
| BIT(IIO_CHAN_INFO_SAMP_FREQ), | |
| .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), | |
| .modified = 1, | |
| .channel2 = IIO_MOD_LIGHT_CLEAR, | |
| }, | |
| }; | |
| /* INT_PERSISTENCE available */ | |
| static IIO_CONST_ATTR(thresh_either_period_available, "[0 1 15]"); | |
| /* ALS_THRESH_VAR available */ | |
| static IIO_CONST_ATTR(thresh_adaptive_either_values_available, "[0 1 7]"); | |
| static struct attribute *apds9306_event_attributes[] = { | |
| &iio_const_attr_thresh_either_period_available.dev_attr.attr, | |
| &iio_const_attr_thresh_adaptive_either_values_available.dev_attr.attr, | |
| NULL | |
| }; | |
| static const struct attribute_group apds9306_event_attr_group = { | |
| .attrs = apds9306_event_attributes, | |
| }; | |
| static const struct regmap_range apds9306_readable_ranges[] = { | |
| regmap_reg_range(APDS9306_MAIN_CTRL_REG, APDS9306_ALS_THRES_VAR_REG) | |
| }; | |
| static const struct regmap_range apds9306_writable_ranges[] = { | |
| regmap_reg_range(APDS9306_MAIN_CTRL_REG, APDS9306_ALS_GAIN_REG), | |
| regmap_reg_range(APDS9306_INT_CFG_REG, APDS9306_ALS_THRES_VAR_REG) | |
| }; | |
| static const struct regmap_range apds9306_volatile_ranges[] = { | |
| regmap_reg_range(APDS9306_MAIN_STATUS_REG, APDS9306_MAIN_STATUS_REG), | |
| regmap_reg_range(APDS9306_CLEAR_DATA_0_REG, APDS9306_ALS_DATA_2_REG) | |
| }; | |
| static const struct regmap_range apds9306_precious_ranges[] = { | |
| regmap_reg_range(APDS9306_MAIN_STATUS_REG, APDS9306_MAIN_STATUS_REG) | |
| }; | |
| static const struct regmap_access_table apds9306_readable_table = { | |
| .yes_ranges = apds9306_readable_ranges, | |
| .n_yes_ranges = ARRAY_SIZE(apds9306_readable_ranges) | |
| }; | |
| static const struct regmap_access_table apds9306_writable_table = { | |
| .yes_ranges = apds9306_writable_ranges, | |
| .n_yes_ranges = ARRAY_SIZE(apds9306_writable_ranges) | |
| }; | |
| static const struct regmap_access_table apds9306_volatile_table = { | |
| .yes_ranges = apds9306_volatile_ranges, | |
| .n_yes_ranges = ARRAY_SIZE(apds9306_volatile_ranges) | |
| }; | |
| static const struct regmap_access_table apds9306_precious_table = { | |
| .yes_ranges = apds9306_precious_ranges, | |
| .n_yes_ranges = ARRAY_SIZE(apds9306_precious_ranges) | |
| }; | |
| static const struct regmap_config apds9306_regmap = { | |
| .name = "apds9306_regmap", | |
| .reg_bits = 8, | |
| .val_bits = 8, | |
| .rd_table = &apds9306_readable_table, | |
| .wr_table = &apds9306_writable_table, | |
| .volatile_table = &apds9306_volatile_table, | |
| .precious_table = &apds9306_precious_table, | |
| .max_register = APDS9306_ALS_THRES_VAR_REG, | |
| .cache_type = REGCACHE_MAPLE, | |
| }; | |
| static const struct reg_field apds9306_rf_sw_reset = | |
| REG_FIELD(APDS9306_MAIN_CTRL_REG, 4, 4); | |
| static const struct reg_field apds9306_rf_en = | |
| REG_FIELD(APDS9306_MAIN_CTRL_REG, 1, 1); | |
| static const struct reg_field apds9306_rf_intg_time = | |
| REG_FIELD(APDS9306_ALS_MEAS_RATE_REG, 4, 6); | |
| static const struct reg_field apds9306_rf_repeat_rate = | |
| REG_FIELD(APDS9306_ALS_MEAS_RATE_REG, 0, 2); | |
| static const struct reg_field apds9306_rf_gain = | |
| REG_FIELD(APDS9306_ALS_GAIN_REG, 0, 2); | |
| static const struct reg_field apds9306_rf_int_src = | |
| REG_FIELD(APDS9306_INT_CFG_REG, 4, 5); | |
| static const struct reg_field apds9306_rf_int_thresh_var_en = | |
| REG_FIELD(APDS9306_INT_CFG_REG, 3, 3); | |
| static const struct reg_field apds9306_rf_int_en = | |
| REG_FIELD(APDS9306_INT_CFG_REG, 2, 2); | |
| static const struct reg_field apds9306_rf_int_persist_val = | |
| REG_FIELD(APDS9306_INT_PERSISTENCE_REG, 4, 7); | |
| static const struct reg_field apds9306_rf_int_thresh_var_val = | |
| REG_FIELD(APDS9306_ALS_THRES_VAR_REG, 0, 2); | |
| static int apds9306_regfield_init(struct apds9306_data *data) | |
| { | |
| struct device *dev = data->dev; | |
| struct regmap *regmap = data->regmap; | |
| struct regmap_field *tmp; | |
| struct apds9306_regfields *rf = &data->rf; | |
| tmp = devm_regmap_field_alloc(dev, regmap, apds9306_rf_sw_reset); | |
| if (IS_ERR(tmp)) | |
| return PTR_ERR(tmp); | |
| rf->sw_reset = tmp; | |
| tmp = devm_regmap_field_alloc(dev, regmap, apds9306_rf_en); | |
| if (IS_ERR(tmp)) | |
| return PTR_ERR(tmp); | |
| rf->en = tmp; | |
| tmp = devm_regmap_field_alloc(dev, regmap, apds9306_rf_intg_time); | |
| if (IS_ERR(tmp)) | |
| return PTR_ERR(tmp); | |
| rf->intg_time = tmp; | |
| tmp = devm_regmap_field_alloc(dev, regmap, apds9306_rf_repeat_rate); | |
| if (IS_ERR(tmp)) | |
| return PTR_ERR(tmp); | |
| rf->repeat_rate = tmp; | |
| tmp = devm_regmap_field_alloc(dev, regmap, apds9306_rf_gain); | |
| if (IS_ERR(tmp)) | |
| return PTR_ERR(tmp); | |
| rf->gain = tmp; | |
| tmp = devm_regmap_field_alloc(dev, regmap, apds9306_rf_int_src); | |
| if (IS_ERR(tmp)) | |
| return PTR_ERR(tmp); | |
| rf->int_src = tmp; | |
| tmp = devm_regmap_field_alloc(dev, regmap, apds9306_rf_int_thresh_var_en); | |
| if (IS_ERR(tmp)) | |
| return PTR_ERR(tmp); | |
| rf->int_thresh_var_en = tmp; | |
| tmp = devm_regmap_field_alloc(dev, regmap, apds9306_rf_int_en); | |
| if (IS_ERR(tmp)) | |
| return PTR_ERR(tmp); | |
| rf->int_en = tmp; | |
| tmp = devm_regmap_field_alloc(dev, regmap, apds9306_rf_int_persist_val); | |
| if (IS_ERR(tmp)) | |
| return PTR_ERR(tmp); | |
| rf->int_persist_val = tmp; | |
| tmp = devm_regmap_field_alloc(dev, regmap, apds9306_rf_int_thresh_var_val); | |
| if (IS_ERR(tmp)) | |
| return PTR_ERR(tmp); | |
| rf->int_thresh_var_val = tmp; | |
| return 0; | |
| } | |
| static int apds9306_power_state(struct apds9306_data *data, bool state) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| int ret; | |
| /* Reset not included as it causes ugly I2C bus error */ | |
| if (state) { | |
| ret = regmap_field_write(rf->en, 1); | |
| if (ret) | |
| return ret; | |
| /* 5ms wake up time */ | |
| fsleep(5000); | |
| return 0; | |
| } | |
| return regmap_field_write(rf->en, 0); | |
| } | |
| static int apds9306_read_data(struct apds9306_data *data, int *val, int reg) | |
| { | |
| struct device *dev = data->dev; | |
| struct iio_dev *indio_dev = dev_to_iio_dev(dev); | |
| struct apds9306_regfields *rf = &data->rf; | |
| u64 ev_code; | |
| int ret, delay, intg_time, intg_time_idx, repeat_rate_idx, int_src; | |
| int status = 0; | |
| u8 buff[3]; | |
| PM_RUNTIME_ACQUIRE_AUTOSUSPEND(data->dev, pm); | |
| if (PM_RUNTIME_ACQUIRE_ERR(&pm)) | |
| return PM_RUNTIME_ACQUIRE_ERR(&pm); | |
| ret = regmap_field_read(rf->intg_time, &intg_time_idx); | |
| if (ret) | |
| return ret; | |
| ret = regmap_field_read(rf->repeat_rate, &repeat_rate_idx); | |
| if (ret) | |
| return ret; | |
| ret = regmap_field_read(rf->int_src, &int_src); | |
| if (ret) | |
| return ret; | |
| intg_time = iio_gts_find_int_time_by_sel(&data->gts, intg_time_idx); | |
| if (intg_time < 0) | |
| return intg_time; | |
| /* Whichever is greater - integration time period or sampling period. */ | |
| delay = max(intg_time, apds9306_repeat_rate_period[repeat_rate_idx]); | |
| /* | |
| * Clear stale data flag that might have been set by the interrupt | |
| * handler if it got data available flag set in the status reg. | |
| */ | |
| data->read_data_available = 0; | |
| /* | |
| * If this function runs parallel with the interrupt handler, either | |
| * this reads and clears the status registers or the interrupt handler | |
| * does. The interrupt handler sets a flag for read data available | |
| * in our private structure which we read here. | |
| */ | |
| ret = regmap_read_poll_timeout(data->regmap, APDS9306_MAIN_STATUS_REG, | |
| status, data->read_data_available || | |
| (status & (APDS9306_ALS_DATA_STAT_MASK | | |
| APDS9306_ALS_INT_STAT_MASK)), | |
| APDS9306_ALS_READ_DATA_DELAY_US, delay * 2); | |
| if (ret) | |
| return ret; | |
| /* If we reach here before the interrupt handler we push an event */ | |
| if ((status & APDS9306_ALS_INT_STAT_MASK)) { | |
| if (int_src == APDS9306_INT_SRC_ALS) | |
| ev_code = IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0, | |
| IIO_EV_TYPE_THRESH, | |
| IIO_EV_DIR_EITHER); | |
| else | |
| ev_code = IIO_MOD_EVENT_CODE(IIO_INTENSITY, 0, | |
| IIO_MOD_LIGHT_CLEAR, | |
| IIO_EV_TYPE_THRESH, | |
| IIO_EV_DIR_EITHER); | |
| iio_push_event(indio_dev, ev_code, iio_get_time_ns(indio_dev)); | |
| } | |
| ret = regmap_bulk_read(data->regmap, reg, buff, sizeof(buff)); | |
| if (ret) { | |
| dev_err_ratelimited(dev, "read data failed\n"); | |
| return ret; | |
| } | |
| *val = get_unaligned_le24(&buff); | |
| return 0; | |
| } | |
| static int apds9306_intg_time_get(struct apds9306_data *data, int *val2) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| int ret, intg_time_idx; | |
| ret = regmap_field_read(rf->intg_time, &intg_time_idx); | |
| if (ret) | |
| return ret; | |
| ret = iio_gts_find_int_time_by_sel(&data->gts, intg_time_idx); | |
| if (ret < 0) | |
| return ret; | |
| *val2 = ret; | |
| return 0; | |
| } | |
| static int apds9306_intg_time_set(struct apds9306_data *data, int val2) | |
| { | |
| struct device *dev = data->dev; | |
| struct apds9306_regfields *rf = &data->rf; | |
| int ret, intg_old, gain_old, gain_new, gain_new_closest, intg_time_idx; | |
| int gain_idx; | |
| bool ok; | |
| if (!iio_gts_valid_time(&data->gts, val2)) { | |
| dev_err_ratelimited(dev, "Unsupported integration time %u\n", val2); | |
| return -EINVAL; | |
| } | |
| ret = regmap_field_read(rf->intg_time, &intg_time_idx); | |
| if (ret) | |
| return ret; | |
| ret = regmap_field_read(rf->gain, &gain_idx); | |
| if (ret) | |
| return ret; | |
| intg_old = iio_gts_find_int_time_by_sel(&data->gts, intg_time_idx); | |
| if (intg_old < 0) | |
| return intg_old; | |
| if (intg_old == val2) | |
| return 0; | |
| gain_old = iio_gts_find_gain_by_sel(&data->gts, gain_idx); | |
| if (gain_old < 0) | |
| return gain_old; | |
| iio_gts_find_new_gain_by_old_gain_time(&data->gts, gain_old, intg_old, | |
| val2, &gain_new); | |
| if (gain_new < 0) { | |
| dev_err_ratelimited(dev, "Unsupported gain with time\n"); | |
| return gain_new; | |
| } | |
| gain_new_closest = iio_find_closest_gain_low(&data->gts, gain_new, &ok); | |
| if (gain_new_closest < 0) { | |
| gain_new_closest = iio_gts_get_min_gain(&data->gts); | |
| if (gain_new_closest < 0) | |
| return gain_new_closest; | |
| } | |
| if (!ok) | |
| dev_dbg(dev, "Unable to find optimum gain, setting minimum"); | |
| ret = iio_gts_find_sel_by_int_time(&data->gts, val2); | |
| if (ret < 0) | |
| return ret; | |
| ret = regmap_field_write(rf->intg_time, ret); | |
| if (ret) | |
| return ret; | |
| ret = iio_gts_find_sel_by_gain(&data->gts, gain_new_closest); | |
| if (ret < 0) | |
| return ret; | |
| return regmap_field_write(rf->gain, ret); | |
| } | |
| static int apds9306_sampling_freq_get(struct apds9306_data *data, int *val, | |
| int *val2) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| int ret, repeat_rate_idx; | |
| ret = regmap_field_read(rf->repeat_rate, &repeat_rate_idx); | |
| if (ret) | |
| return ret; | |
| if (repeat_rate_idx >= ARRAY_SIZE(apds9306_repeat_rate_freq)) | |
| return -EINVAL; | |
| *val = apds9306_repeat_rate_freq[repeat_rate_idx][0]; | |
| *val2 = apds9306_repeat_rate_freq[repeat_rate_idx][1]; | |
| return 0; | |
| } | |
| static int apds9306_sampling_freq_set(struct apds9306_data *data, int val, | |
| int val2) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| int i; | |
| for (i = 0; i < ARRAY_SIZE(apds9306_repeat_rate_freq); i++) { | |
| if (apds9306_repeat_rate_freq[i][0] == val && | |
| apds9306_repeat_rate_freq[i][1] == val2) | |
| return regmap_field_write(rf->repeat_rate, i); | |
| } | |
| return -EINVAL; | |
| } | |
| static int apds9306_scale_get(struct apds9306_data *data, int *val, int *val2) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| int gain, intg, ret, intg_time_idx, gain_idx; | |
| ret = regmap_field_read(rf->gain, &gain_idx); | |
| if (ret) | |
| return ret; | |
| ret = regmap_field_read(rf->intg_time, &intg_time_idx); | |
| if (ret) | |
| return ret; | |
| gain = iio_gts_find_gain_by_sel(&data->gts, gain_idx); | |
| if (gain < 0) | |
| return gain; | |
| intg = iio_gts_find_int_time_by_sel(&data->gts, intg_time_idx); | |
| if (intg < 0) | |
| return intg; | |
| return iio_gts_get_scale(&data->gts, gain, intg, val, val2); | |
| } | |
| static int apds9306_scale_set(struct apds9306_data *data, int val, int val2) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| int i, ret, time_sel, gain_sel, intg_time_idx; | |
| ret = regmap_field_read(rf->intg_time, &intg_time_idx); | |
| if (ret) | |
| return ret; | |
| ret = iio_gts_find_gain_sel_for_scale_using_time(&data->gts, | |
| intg_time_idx, val, val2, &gain_sel); | |
| if (ret) { | |
| for (i = 0; i < data->gts.num_itime; i++) { | |
| time_sel = data->gts.itime_table[i].sel; | |
| if (time_sel == intg_time_idx) | |
| continue; | |
| ret = iio_gts_find_gain_sel_for_scale_using_time(&data->gts, | |
| time_sel, val, val2, &gain_sel); | |
| if (!ret) | |
| break; | |
| } | |
| if (ret) | |
| return -EINVAL; | |
| ret = regmap_field_write(rf->intg_time, time_sel); | |
| if (ret) | |
| return ret; | |
| } | |
| return regmap_field_write(rf->gain, gain_sel); | |
| } | |
| static int apds9306_event_period_get(struct apds9306_data *data, int *val) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| int period, ret; | |
| ret = regmap_field_read(rf->int_persist_val, &period); | |
| if (ret) | |
| return ret; | |
| if (!in_range(period, 0, APDS9306_ALS_PERSIST_NUM_VALS)) | |
| return -EINVAL; | |
| *val = period; | |
| return ret; | |
| } | |
| static int apds9306_event_period_set(struct apds9306_data *data, int val) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| if (!in_range(val, 0, APDS9306_ALS_PERSIST_NUM_VALS)) | |
| return -EINVAL; | |
| return regmap_field_write(rf->int_persist_val, val); | |
| } | |
| static int apds9306_get_thresh_reg(int dir) | |
| { | |
| if (dir == IIO_EV_DIR_RISING) | |
| return APDS9306_ALS_THRES_UP_0_REG; | |
| else if (dir == IIO_EV_DIR_FALLING) | |
| return APDS9306_ALS_THRES_LOW_0_REG; | |
| else | |
| return -EINVAL; | |
| } | |
| static int apds9306_event_thresh_get(struct apds9306_data *data, int dir, | |
| int *val) | |
| { | |
| int reg, ret; | |
| u8 buff[3]; | |
| reg = apds9306_get_thresh_reg(dir); | |
| if (reg < 0) | |
| return reg; | |
| ret = regmap_bulk_read(data->regmap, reg, buff, sizeof(buff)); | |
| if (ret) | |
| return ret; | |
| *val = get_unaligned_le24(&buff); | |
| return 0; | |
| } | |
| static int apds9306_event_thresh_set(struct apds9306_data *data, int dir, | |
| int val) | |
| { | |
| int reg; | |
| u8 buff[3]; | |
| reg = apds9306_get_thresh_reg(dir); | |
| if (reg < 0) | |
| return reg; | |
| if (!in_range(val, 0, APDS9306_ALS_THRES_VAL_MAX)) | |
| return -EINVAL; | |
| put_unaligned_le24(val, buff); | |
| return regmap_bulk_write(data->regmap, reg, buff, sizeof(buff)); | |
| } | |
| static int apds9306_event_thresh_adaptive_get(struct apds9306_data *data, int *val) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| int thr_adpt, ret; | |
| ret = regmap_field_read(rf->int_thresh_var_val, &thr_adpt); | |
| if (ret) | |
| return ret; | |
| if (!in_range(thr_adpt, 0, APDS9306_ALS_THRES_VAR_NUM_VALS)) | |
| return -EINVAL; | |
| *val = thr_adpt; | |
| return ret; | |
| } | |
| static int apds9306_event_thresh_adaptive_set(struct apds9306_data *data, int val) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| if (!in_range(val, 0, APDS9306_ALS_THRES_VAR_NUM_VALS)) | |
| return -EINVAL; | |
| return regmap_field_write(rf->int_thresh_var_val, val); | |
| } | |
| static int apds9306_read_raw(struct iio_dev *indio_dev, | |
| struct iio_chan_spec const *chan, int *val, | |
| int *val2, long mask) | |
| { | |
| struct apds9306_data *data = iio_priv(indio_dev); | |
| int ret, reg; | |
| switch (mask) { | |
| case IIO_CHAN_INFO_RAW: | |
| if (chan->channel2 == IIO_MOD_LIGHT_CLEAR) | |
| reg = APDS9306_CLEAR_DATA_0_REG; | |
| else | |
| reg = APDS9306_ALS_DATA_0_REG; | |
| /* | |
| * Changing device parameters during adc operation, resets | |
| * the ADC which has to avoided. | |
| */ | |
| if (!iio_device_claim_direct(indio_dev)) | |
| return -EBUSY; | |
| ret = apds9306_read_data(data, val, reg); | |
| iio_device_release_direct(indio_dev); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT; | |
| case IIO_CHAN_INFO_INT_TIME: | |
| ret = apds9306_intg_time_get(data, val2); | |
| if (ret) | |
| return ret; | |
| *val = 0; | |
| return IIO_VAL_INT_PLUS_MICRO; | |
| case IIO_CHAN_INFO_SAMP_FREQ: | |
| ret = apds9306_sampling_freq_get(data, val, val2); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT_PLUS_MICRO; | |
| case IIO_CHAN_INFO_SCALE: | |
| ret = apds9306_scale_get(data, val, val2); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT_PLUS_NANO; | |
| default: | |
| return -EINVAL; | |
| } | |
| }; | |
| static int apds9306_read_avail(struct iio_dev *indio_dev, | |
| struct iio_chan_spec const *chan, | |
| const int **vals, int *type, int *length, | |
| long mask) | |
| { | |
| struct apds9306_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); | |
| case IIO_CHAN_INFO_SAMP_FREQ: | |
| *length = ARRAY_SIZE(apds9306_repeat_rate_freq) * 2; | |
| *vals = (const int *)apds9306_repeat_rate_freq; | |
| *type = IIO_VAL_INT_PLUS_MICRO; | |
| return IIO_AVAIL_LIST; | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int apds9306_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_PLUS_NANO; | |
| case IIO_CHAN_INFO_INT_TIME: | |
| return IIO_VAL_INT_PLUS_MICRO; | |
| case IIO_CHAN_INFO_SAMP_FREQ: | |
| return IIO_VAL_INT_PLUS_MICRO; | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int apds9306_write_raw(struct iio_dev *indio_dev, | |
| struct iio_chan_spec const *chan, int val, | |
| int val2, long mask) | |
| { | |
| struct apds9306_data *data = iio_priv(indio_dev); | |
| guard(mutex)(&data->mutex); | |
| switch (mask) { | |
| case IIO_CHAN_INFO_INT_TIME: | |
| if (val) | |
| return -EINVAL; | |
| return apds9306_intg_time_set(data, val2); | |
| case IIO_CHAN_INFO_SCALE: | |
| return apds9306_scale_set(data, val, val2); | |
| case IIO_CHAN_INFO_SAMP_FREQ: | |
| return apds9306_sampling_freq_set(data, val, val2); | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static irqreturn_t apds9306_irq_handler(int irq, void *priv) | |
| { | |
| struct iio_dev *indio_dev = priv; | |
| struct apds9306_data *data = iio_priv(indio_dev); | |
| struct apds9306_regfields *rf = &data->rf; | |
| u64 ev_code; | |
| int ret, status, int_src; | |
| /* | |
| * The interrupt line is released and the interrupt flag is | |
| * cleared as a result of reading the status register. All the | |
| * status flags are cleared as a result of this read. | |
| */ | |
| ret = regmap_read(data->regmap, APDS9306_MAIN_STATUS_REG, &status); | |
| if (ret < 0) { | |
| dev_err_ratelimited(data->dev, "status reg read failed\n"); | |
| return IRQ_HANDLED; | |
| } | |
| ret = regmap_field_read(rf->int_src, &int_src); | |
| if (ret) | |
| return ret; | |
| if ((status & APDS9306_ALS_INT_STAT_MASK)) { | |
| if (int_src == APDS9306_INT_SRC_ALS) | |
| ev_code = IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0, | |
| IIO_EV_TYPE_THRESH, | |
| IIO_EV_DIR_EITHER); | |
| else | |
| ev_code = IIO_MOD_EVENT_CODE(IIO_INTENSITY, 0, | |
| IIO_MOD_LIGHT_CLEAR, | |
| IIO_EV_TYPE_THRESH, | |
| IIO_EV_DIR_EITHER); | |
| iio_push_event(indio_dev, ev_code, iio_get_time_ns(indio_dev)); | |
| } | |
| /* | |
| * If a one-shot read through sysfs is underway at the same time | |
| * as this interrupt handler is executing and a read data available | |
| * flag was set, this flag is set to inform read_poll_timeout() | |
| * to exit. | |
| */ | |
| if ((status & APDS9306_ALS_DATA_STAT_MASK)) | |
| data->read_data_available = 1; | |
| return IRQ_HANDLED; | |
| } | |
| static int apds9306_read_event(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 apds9306_data *data = iio_priv(indio_dev); | |
| int ret; | |
| switch (type) { | |
| case IIO_EV_TYPE_THRESH: | |
| if (dir == IIO_EV_DIR_EITHER && info == IIO_EV_INFO_PERIOD) | |
| ret = apds9306_event_period_get(data, val); | |
| else | |
| ret = apds9306_event_thresh_get(data, dir, val); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT; | |
| case IIO_EV_TYPE_THRESH_ADAPTIVE: | |
| ret = apds9306_event_thresh_adaptive_get(data, val); | |
| if (ret) | |
| return ret; | |
| return IIO_VAL_INT; | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int apds9306_write_event(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 apds9306_data *data = iio_priv(indio_dev); | |
| switch (type) { | |
| case IIO_EV_TYPE_THRESH: | |
| if (dir == IIO_EV_DIR_EITHER && info == IIO_EV_INFO_PERIOD) | |
| return apds9306_event_period_set(data, val); | |
| return apds9306_event_thresh_set(data, dir, val); | |
| case IIO_EV_TYPE_THRESH_ADAPTIVE: | |
| return apds9306_event_thresh_adaptive_set(data, val); | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int apds9306_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 apds9306_data *data = iio_priv(indio_dev); | |
| struct apds9306_regfields *rf = &data->rf; | |
| int int_en, int_src, ret; | |
| switch (type) { | |
| case IIO_EV_TYPE_THRESH: { | |
| guard(mutex)(&data->mutex); | |
| ret = regmap_field_read(rf->int_src, &int_src); | |
| if (ret) | |
| return ret; | |
| ret = regmap_field_read(rf->int_en, &int_en); | |
| if (ret) | |
| return ret; | |
| if (chan->type == IIO_LIGHT) | |
| return int_en && (int_src == APDS9306_INT_SRC_ALS); | |
| if (chan->type == IIO_INTENSITY) | |
| return int_en && (int_src == APDS9306_INT_SRC_CLEAR); | |
| return -EINVAL; | |
| } | |
| case IIO_EV_TYPE_THRESH_ADAPTIVE: | |
| ret = regmap_field_read(rf->int_thresh_var_en, &int_en); | |
| if (ret) | |
| return ret; | |
| return int_en; | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int apds9306_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 apds9306_data *data = iio_priv(indio_dev); | |
| struct apds9306_regfields *rf = &data->rf; | |
| int ret, enabled; | |
| switch (type) { | |
| case IIO_EV_TYPE_THRESH: { | |
| guard(mutex)(&data->mutex); | |
| ret = regmap_field_read(rf->int_en, &enabled); | |
| if (ret) | |
| return ret; | |
| /* | |
| * If interrupt is enabled, the channel is set before enabling | |
| * the interrupt. In case of disable, no need to switch | |
| * channels. In case of different channel is selected while | |
| * interrupt in on, just change the channel. | |
| */ | |
| if (state) { | |
| if (chan->type == IIO_LIGHT) | |
| ret = regmap_field_write(rf->int_src, 1); | |
| else if (chan->type == IIO_INTENSITY) | |
| ret = regmap_field_write(rf->int_src, 0); | |
| else | |
| return -EINVAL; | |
| if (ret) | |
| return ret; | |
| if (enabled) | |
| return 0; | |
| ret = regmap_field_write(rf->int_en, 1); | |
| if (ret) | |
| return ret; | |
| return pm_runtime_resume_and_get(data->dev); | |
| } else { | |
| if (!enabled) | |
| return 0; | |
| ret = regmap_field_write(rf->int_en, 0); | |
| if (ret) | |
| return ret; | |
| pm_runtime_put_autosuspend(data->dev); | |
| return 0; | |
| } | |
| } | |
| case IIO_EV_TYPE_THRESH_ADAPTIVE: | |
| return regmap_field_write(rf->int_thresh_var_en, state); | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static const struct iio_info apds9306_info_no_events = { | |
| .read_avail = apds9306_read_avail, | |
| .read_raw = apds9306_read_raw, | |
| .write_raw = apds9306_write_raw, | |
| .write_raw_get_fmt = apds9306_write_raw_get_fmt, | |
| }; | |
| static const struct iio_info apds9306_info = { | |
| .read_avail = apds9306_read_avail, | |
| .read_raw = apds9306_read_raw, | |
| .write_raw = apds9306_write_raw, | |
| .write_raw_get_fmt = apds9306_write_raw_get_fmt, | |
| .read_event_value = apds9306_read_event, | |
| .write_event_value = apds9306_write_event, | |
| .read_event_config = apds9306_read_event_config, | |
| .write_event_config = apds9306_write_event_config, | |
| .event_attrs = &apds9306_event_attr_group, | |
| }; | |
| static int apds9306_init_iio_gts(struct apds9306_data *data) | |
| { | |
| int i, ret, part_id; | |
| ret = regmap_read(data->regmap, APDS9306_PART_ID_REG, &part_id); | |
| if (ret) | |
| return ret; | |
| for (i = 0; i < ARRAY_SIZE(apds9306_gts_mul); i++) | |
| if (part_id == apds9306_gts_mul[i].part_id) | |
| break; | |
| if (i == ARRAY_SIZE(apds9306_gts_mul)) | |
| return -ENOENT; | |
| return devm_iio_init_iio_gts(data->dev, | |
| apds9306_gts_mul[i].max_scale_int, | |
| apds9306_gts_mul[i].max_scale_nano, | |
| apds9306_gains, ARRAY_SIZE(apds9306_gains), | |
| apds9306_itimes, ARRAY_SIZE(apds9306_itimes), | |
| &data->gts); | |
| } | |
| static void apds9306_powerdown(void *ptr) | |
| { | |
| struct apds9306_data *data = ptr; | |
| struct apds9306_regfields *rf = &data->rf; | |
| int ret; | |
| ret = regmap_field_write(rf->int_thresh_var_en, 0); | |
| if (ret) | |
| return; | |
| ret = regmap_field_write(rf->int_en, 0); | |
| if (ret) | |
| return; | |
| apds9306_power_state(data, false); | |
| } | |
| static int apds9306_device_init(struct apds9306_data *data) | |
| { | |
| struct apds9306_regfields *rf = &data->rf; | |
| int ret; | |
| ret = apds9306_init_iio_gts(data); | |
| if (ret) | |
| return ret; | |
| ret = regmap_field_write(rf->intg_time, APDS9306_MEAS_MODE_100MS); | |
| if (ret) | |
| return ret; | |
| ret = regmap_field_write(rf->repeat_rate, APDS9306_SAMP_FREQ_10HZ); | |
| if (ret) | |
| return ret; | |
| ret = regmap_field_write(rf->gain, APDS9306_GSEL_3X); | |
| if (ret) | |
| return ret; | |
| ret = regmap_field_write(rf->int_src, APDS9306_INT_SRC_ALS); | |
| if (ret) | |
| return ret; | |
| ret = regmap_field_write(rf->int_en, 0); | |
| if (ret) | |
| return ret; | |
| return regmap_field_write(rf->int_thresh_var_en, 0); | |
| } | |
| static int apds9306_pm_init(struct apds9306_data *data) | |
| { | |
| struct device *dev = data->dev; | |
| int ret; | |
| ret = apds9306_power_state(data, true); | |
| if (ret) | |
| return ret; | |
| ret = pm_runtime_set_active(dev); | |
| if (ret) | |
| return ret; | |
| ret = devm_pm_runtime_enable(dev); | |
| if (ret) | |
| return ret; | |
| pm_runtime_set_autosuspend_delay(dev, 5000); | |
| pm_runtime_use_autosuspend(dev); | |
| pm_runtime_get(dev); | |
| return 0; | |
| } | |
| static int apds9306_probe(struct i2c_client *client) | |
| { | |
| struct device *dev = &client->dev; | |
| struct apds9306_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); | |
| mutex_init(&data->mutex); | |
| data->regmap = devm_regmap_init_i2c(client, &apds9306_regmap); | |
| if (IS_ERR(data->regmap)) | |
| return dev_err_probe(dev, PTR_ERR(data->regmap), | |
| "regmap initialization failed\n"); | |
| data->dev = dev; | |
| i2c_set_clientdata(client, indio_dev); | |
| ret = apds9306_regfield_init(data); | |
| if (ret) | |
| return dev_err_probe(dev, ret, "regfield initialization failed\n"); | |
| ret = devm_regulator_get_enable(dev, "vdd"); | |
| if (ret) | |
| return dev_err_probe(dev, ret, "Failed to enable regulator\n"); | |
| indio_dev->name = "apds9306"; | |
| indio_dev->modes = INDIO_DIRECT_MODE; | |
| if (client->irq) { | |
| indio_dev->info = &apds9306_info; | |
| indio_dev->channels = apds9306_channels_with_events; | |
| indio_dev->num_channels = ARRAY_SIZE(apds9306_channels_with_events); | |
| ret = devm_request_threaded_irq(dev, client->irq, NULL, | |
| apds9306_irq_handler, IRQF_ONESHOT, | |
| "apds9306_event", indio_dev); | |
| if (ret) | |
| return ret; | |
| } else { | |
| indio_dev->info = &apds9306_info_no_events; | |
| indio_dev->channels = apds9306_channels_without_events; | |
| indio_dev->num_channels = | |
| ARRAY_SIZE(apds9306_channels_without_events); | |
| } | |
| ret = apds9306_pm_init(data); | |
| if (ret) | |
| return dev_err_probe(dev, ret, "failed pm init\n"); | |
| ret = apds9306_device_init(data); | |
| if (ret) | |
| return dev_err_probe(dev, ret, "failed to init device\n"); | |
| ret = devm_add_action_or_reset(dev, apds9306_powerdown, data); | |
| if (ret) | |
| return ret; | |
| ret = devm_iio_device_register(dev, indio_dev); | |
| if (ret) | |
| return dev_err_probe(dev, ret, "failed iio device registration\n"); | |
| pm_runtime_put_autosuspend(dev); | |
| return 0; | |
| } | |
| static int apds9306_runtime_suspend(struct device *dev) | |
| { | |
| struct apds9306_data *data = iio_priv(dev_get_drvdata(dev)); | |
| return apds9306_power_state(data, false); | |
| } | |
| static int apds9306_runtime_resume(struct device *dev) | |
| { | |
| struct apds9306_data *data = iio_priv(dev_get_drvdata(dev)); | |
| return apds9306_power_state(data, true); | |
| } | |
| static DEFINE_RUNTIME_DEV_PM_OPS(apds9306_pm_ops, | |
| apds9306_runtime_suspend, | |
| apds9306_runtime_resume, | |
| NULL); | |
| static const struct of_device_id apds9306_of_match[] = { | |
| { .compatible = "avago,apds9306" }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(of, apds9306_of_match); | |
| static struct i2c_driver apds9306_driver = { | |
| .driver = { | |
| .name = "apds9306", | |
| .pm = pm_ptr(&apds9306_pm_ops), | |
| .of_match_table = apds9306_of_match, | |
| }, | |
| .probe = apds9306_probe, | |
| }; | |
| module_i2c_driver(apds9306_driver); | |
| MODULE_AUTHOR("Subhajit Ghosh <subhajit.ghosh@tweaklogic.com>"); | |
| MODULE_DESCRIPTION("APDS9306 Ambient Light Sensor driver"); | |
| MODULE_LICENSE("GPL"); | |
| MODULE_IMPORT_NS("IIO_GTS_HELPER"); |