iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
bea76a2ab8
linux/drivers/iio/light/apds9960.c
Alexandru Ardelean 17395ce299 iio: make use of devm_iio_kfifo_buffer_setup() helper 
All drivers that already call devm_iio_kfifo_allocate() &
iio_device_attach_buffer() are simple to convert to
iio_device_attach_kfifo_buffer() in a single go.

This change does that; the unwind order is preserved.
What is important, is that the devm_iio_kfifo_buffer_setup() be called
after the indio_dev->modes is assigned, to make sure that
INDIO_BUFFER_SOFTWARE flag is set and not overridden by the assignment to
indio_dev->modes.

Also, the INDIO_BUFFER_SOFTWARE has been removed from the assignments of
'indio_dev->modes' because it is set by devm_iio_kfifo_buffer_setup().

Signed-off-by: Alexandru Ardelean <alexandru.ardelean@analog.com>
Reviewed-by: Gwendal Grignou <gwendal@chromium.org>
Reviewed-by: Matt Ranostay <matt.ranostay@konsulko.com>x
Link: https://lore.kernel.org/r/20210215104043.91251-4-alexandru.ardelean@analog.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
2021-03-11 20:47:01 +00:00

1143 lines
28 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0+
/*
* apds9960.c - Support for Avago APDS9960 gesture/RGB/ALS/proximity sensor
*
* Copyright (C) 2015, 2018
* Author: Matt Ranostay <matt.ranostay@konsulko.com>
*
* TODO: gesture + proximity calib offsets
*/
#include <linux/acpi.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/irq.h>
#include <linux/i2c.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
#include <linux/iio/events.h>
#include <linux/iio/kfifo_buf.h>
#include <linux/iio/sysfs.h>
#define APDS9960_REGMAP_NAME "apds9960_regmap"
#define APDS9960_DRV_NAME "apds9960"
#define APDS9960_REG_RAM_START 0x00
#define APDS9960_REG_RAM_END 0x7f
#define APDS9960_REG_ENABLE 0x80
#define APDS9960_REG_ATIME 0x81
#define APDS9960_REG_WTIME 0x83
#define APDS9960_REG_AILTL 0x84
#define APDS9960_REG_AILTH 0x85
#define APDS9960_REG_AIHTL 0x86
#define APDS9960_REG_AIHTH 0x87
#define APDS9960_REG_PILT 0x89
#define APDS9960_REG_PIHT 0x8b
#define APDS9960_REG_PERS 0x8c
#define APDS9960_REG_CONFIG_1 0x8d
#define APDS9960_REG_PPULSE 0x8e
#define APDS9960_REG_CONTROL 0x8f
#define APDS9960_REG_CONTROL_AGAIN_MASK 0x03
#define APDS9960_REG_CONTROL_PGAIN_MASK 0x0c
#define APDS9960_REG_CONTROL_AGAIN_MASK_SHIFT 0
#define APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT 2
#define APDS9960_REG_CONFIG_2 0x90
#define APDS9960_REG_CONFIG_2_GGAIN_MASK 0x60
#define APDS9960_REG_CONFIG_2_GGAIN_MASK_SHIFT 5
#define APDS9960_REG_ID 0x92
#define APDS9960_REG_STATUS 0x93
#define APDS9960_REG_STATUS_PS_INT BIT(5)
#define APDS9960_REG_STATUS_ALS_INT BIT(4)
#define APDS9960_REG_STATUS_GINT BIT(2)
#define APDS9960_REG_PDATA 0x9c
#define APDS9960_REG_POFFSET_UR 0x9d
#define APDS9960_REG_POFFSET_DL 0x9e
#define APDS9960_REG_CONFIG_3 0x9f
#define APDS9960_REG_GPENTH 0xa0
#define APDS9960_REG_GEXTH 0xa1
#define APDS9960_REG_GCONF_1 0xa2
#define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK 0xc0
#define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT 6
#define APDS9960_REG_GCONF_2 0xa3
#define APDS9960_REG_GOFFSET_U 0xa4
#define APDS9960_REG_GOFFSET_D 0xa5
#define APDS9960_REG_GPULSE 0xa6
#define APDS9960_REG_GOFFSET_L 0xa7
#define APDS9960_REG_GOFFSET_R 0xa9
#define APDS9960_REG_GCONF_3 0xaa
#define APDS9960_REG_GCONF_4 0xab
#define APDS9960_REG_GFLVL 0xae
#define APDS9960_REG_GSTATUS 0xaf
#define APDS9960_REG_IFORCE 0xe4
#define APDS9960_REG_PICLEAR 0xe5
#define APDS9960_REG_CICLEAR 0xe6
#define APDS9960_REG_AICLEAR 0xe7
#define APDS9960_DEFAULT_PERS 0x33
#define APDS9960_DEFAULT_GPENTH 0x50
#define APDS9960_DEFAULT_GEXTH 0x40
#define APDS9960_MAX_PXS_THRES_VAL 255
#define APDS9960_MAX_ALS_THRES_VAL 0xffff
#define APDS9960_MAX_INT_TIME_IN_US 1000000
enum apds9960_als_channel_idx {
IDX_ALS_CLEAR, IDX_ALS_RED, IDX_ALS_GREEN, IDX_ALS_BLUE,
};
#define APDS9960_REG_ALS_BASE 0x94
#define APDS9960_REG_ALS_CHANNEL(_colour) \
(APDS9960_REG_ALS_BASE + (IDX_ALS_##_colour * 2))
enum apds9960_gesture_channel_idx {
IDX_DIR_UP, IDX_DIR_DOWN, IDX_DIR_LEFT, IDX_DIR_RIGHT,
};
#define APDS9960_REG_GFIFO_BASE 0xfc
#define APDS9960_REG_GFIFO_DIR(_dir) \
(APDS9960_REG_GFIFO_BASE + IDX_DIR_##_dir)
struct apds9960_data {
struct i2c_client *client;
struct iio_dev *indio_dev;
struct mutex lock;
/* regmap fields */
struct regmap *regmap;
struct regmap_field *reg_int_als;
struct regmap_field *reg_int_ges;
struct regmap_field *reg_int_pxs;
struct regmap_field *reg_enable_als;
struct regmap_field *reg_enable_ges;
struct regmap_field *reg_enable_pxs;
/* state */
int als_int;
int pxs_int;
int gesture_mode_running;
/* gain values */
int als_gain;
int pxs_gain;
/* integration time value in us */
int als_adc_int_us;
/* gesture buffer */
u8 buffer[4]; /* 4 8-bit channels */
};
static const struct reg_default apds9960_reg_defaults[] = {
/* Default ALS integration time = 2.48ms */
{ APDS9960_REG_ATIME, 0xff },
};
static const struct regmap_range apds9960_volatile_ranges[] = {
regmap_reg_range(APDS9960_REG_STATUS,
APDS9960_REG_PDATA),
regmap_reg_range(APDS9960_REG_GFLVL,
APDS9960_REG_GSTATUS),
regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP),
APDS9960_REG_GFIFO_DIR(RIGHT)),
regmap_reg_range(APDS9960_REG_IFORCE,
APDS9960_REG_AICLEAR),
};
static const struct regmap_access_table apds9960_volatile_table = {
.yes_ranges = apds9960_volatile_ranges,
.n_yes_ranges = ARRAY_SIZE(apds9960_volatile_ranges),
};
static const struct regmap_range apds9960_precious_ranges[] = {
regmap_reg_range(APDS9960_REG_RAM_START, APDS9960_REG_RAM_END),
};
static const struct regmap_access_table apds9960_precious_table = {
.yes_ranges = apds9960_precious_ranges,
.n_yes_ranges = ARRAY_SIZE(apds9960_precious_ranges),
};
static const struct regmap_range apds9960_readable_ranges[] = {
regmap_reg_range(APDS9960_REG_ENABLE,
APDS9960_REG_GSTATUS),
regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP),
APDS9960_REG_GFIFO_DIR(RIGHT)),
};
static const struct regmap_access_table apds9960_readable_table = {
.yes_ranges = apds9960_readable_ranges,
.n_yes_ranges = ARRAY_SIZE(apds9960_readable_ranges),
};
static const struct regmap_range apds9960_writeable_ranges[] = {
regmap_reg_range(APDS9960_REG_ENABLE, APDS9960_REG_CONFIG_2),
regmap_reg_range(APDS9960_REG_POFFSET_UR, APDS9960_REG_GCONF_4),
regmap_reg_range(APDS9960_REG_IFORCE, APDS9960_REG_AICLEAR),
};
static const struct regmap_access_table apds9960_writeable_table = {
.yes_ranges = apds9960_writeable_ranges,
.n_yes_ranges = ARRAY_SIZE(apds9960_writeable_ranges),
};
static const struct regmap_config apds9960_regmap_config = {
.name = APDS9960_REGMAP_NAME,
.reg_bits = 8,
.val_bits = 8,
.use_single_read = true,
.use_single_write = true,
.volatile_table = &apds9960_volatile_table,
.precious_table = &apds9960_precious_table,
.rd_table = &apds9960_readable_table,
.wr_table = &apds9960_writeable_table,
.reg_defaults = apds9960_reg_defaults,
.num_reg_defaults = ARRAY_SIZE(apds9960_reg_defaults),
.max_register = APDS9960_REG_GFIFO_DIR(RIGHT),
.cache_type = REGCACHE_RBTREE,
};
static const struct iio_event_spec apds9960_pxs_event_spec[] = {
{
.type = IIO_EV_TYPE_THRESH,
.dir = IIO_EV_DIR_RISING,
.mask_separate = BIT(IIO_EV_INFO_VALUE) |
BIT(IIO_EV_INFO_ENABLE),
},
{
.type = IIO_EV_TYPE_THRESH,
.dir = IIO_EV_DIR_FALLING,
.mask_separate = BIT(IIO_EV_INFO_VALUE) |
BIT(IIO_EV_INFO_ENABLE),
},
};
static const struct iio_event_spec apds9960_als_event_spec[] = {
{
.type = IIO_EV_TYPE_THRESH,
.dir = IIO_EV_DIR_RISING,
.mask_separate = BIT(IIO_EV_INFO_VALUE) |
BIT(IIO_EV_INFO_ENABLE),
},
{
.type = IIO_EV_TYPE_THRESH,
.dir = IIO_EV_DIR_FALLING,
.mask_separate = BIT(IIO_EV_INFO_VALUE) |
BIT(IIO_EV_INFO_ENABLE),
},
};
#define APDS9960_GESTURE_CHANNEL(_dir, _si) { \
.type = IIO_PROXIMITY, \
.channel = _si + 1, \
.scan_index = _si, \
.indexed = 1, \
.scan_type = { \
.sign = 'u', \
.realbits = 8, \
.storagebits = 8, \
}, \
}
#define APDS9960_INTENSITY_CHANNEL(_colour) { \
.type = IIO_INTENSITY, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
BIT(IIO_CHAN_INFO_INT_TIME), \
.channel2 = IIO_MOD_LIGHT_##_colour, \
.address = APDS9960_REG_ALS_CHANNEL(_colour), \
.modified = 1, \
.scan_index = -1, \
}
static const unsigned long apds9960_scan_masks[] = {0xf, 0};
static const struct iio_chan_spec apds9960_channels[] = {
{
.type = IIO_PROXIMITY,
.address = APDS9960_REG_PDATA,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
.channel = 0,
.indexed = 0,
.scan_index = -1,
.event_spec = apds9960_pxs_event_spec,
.num_event_specs = ARRAY_SIZE(apds9960_pxs_event_spec),
},
/* Gesture Sensor */
APDS9960_GESTURE_CHANNEL(UP, 0),
APDS9960_GESTURE_CHANNEL(DOWN, 1),
APDS9960_GESTURE_CHANNEL(LEFT, 2),
APDS9960_GESTURE_CHANNEL(RIGHT, 3),
/* ALS */
{
.type = IIO_INTENSITY,
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
BIT(IIO_CHAN_INFO_INT_TIME),
.channel2 = IIO_MOD_LIGHT_CLEAR,
.address = APDS9960_REG_ALS_CHANNEL(CLEAR),
.modified = 1,
.scan_index = -1,
.event_spec = apds9960_als_event_spec,
.num_event_specs = ARRAY_SIZE(apds9960_als_event_spec),
},
/* RGB Sensor */
APDS9960_INTENSITY_CHANNEL(RED),
APDS9960_INTENSITY_CHANNEL(GREEN),
APDS9960_INTENSITY_CHANNEL(BLUE),
};
/* integration time in us */
static const int apds9960_int_time[][2] = {
{ 28000, 246},
{100000, 219},
{200000, 182},
{700000, 0}
};
/* gain mapping */
static const int apds9960_pxs_gain_map[] = {1, 2, 4, 8};
static const int apds9960_als_gain_map[] = {1, 4, 16, 64};
static IIO_CONST_ATTR(proximity_scale_available, "1 2 4 8");
static IIO_CONST_ATTR(intensity_scale_available, "1 4 16 64");
static IIO_CONST_ATTR_INT_TIME_AVAIL("0.028 0.1 0.2 0.7");
static struct attribute *apds9960_attributes[] = {
&iio_const_attr_proximity_scale_available.dev_attr.attr,
&iio_const_attr_intensity_scale_available.dev_attr.attr,
&iio_const_attr_integration_time_available.dev_attr.attr,
NULL,
};
static const struct attribute_group apds9960_attribute_group = {
.attrs = apds9960_attributes,
};
static const struct reg_field apds9960_reg_field_int_als =
REG_FIELD(APDS9960_REG_ENABLE, 4, 4);
static const struct reg_field apds9960_reg_field_int_ges =
REG_FIELD(APDS9960_REG_GCONF_4, 1, 1);
static const struct reg_field apds9960_reg_field_int_pxs =
REG_FIELD(APDS9960_REG_ENABLE, 5, 5);
static const struct reg_field apds9960_reg_field_enable_als =
REG_FIELD(APDS9960_REG_ENABLE, 1, 1);
static const struct reg_field apds9960_reg_field_enable_ges =
REG_FIELD(APDS9960_REG_ENABLE, 6, 6);
static const struct reg_field apds9960_reg_field_enable_pxs =
REG_FIELD(APDS9960_REG_ENABLE, 2, 2);
static int apds9960_set_it_time(struct apds9960_data *data, int val2)
{
int ret = -EINVAL;
int idx;
for (idx = 0; idx < ARRAY_SIZE(apds9960_int_time); idx++) {
if (apds9960_int_time[idx][0] == val2) {
mutex_lock(&data->lock);
ret = regmap_write(data->regmap, APDS9960_REG_ATIME,
apds9960_int_time[idx][1]);
if (!ret)
data->als_adc_int_us = val2;
mutex_unlock(&data->lock);
break;
}
}
return ret;
}
static int apds9960_set_pxs_gain(struct apds9960_data *data, int val)
{
int ret = -EINVAL;
int idx;
for (idx = 0; idx < ARRAY_SIZE(apds9960_pxs_gain_map); idx++) {
if (apds9960_pxs_gain_map[idx] == val) {
/* pxs + gesture gains are mirrored */
mutex_lock(&data->lock);
ret = regmap_update_bits(data->regmap,
APDS9960_REG_CONTROL,
APDS9960_REG_CONTROL_PGAIN_MASK,
idx << APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT);
if (ret) {
mutex_unlock(&data->lock);
break;
}
ret = regmap_update_bits(data->regmap,
APDS9960_REG_CONFIG_2,
APDS9960_REG_CONFIG_2_GGAIN_MASK,
idx << APDS9960_REG_CONFIG_2_GGAIN_MASK_SHIFT);
if (!ret)
data->pxs_gain = idx;
mutex_unlock(&data->lock);
break;
}
}
return ret;
}
static int apds9960_set_als_gain(struct apds9960_data *data, int val)
{
int ret = -EINVAL;
int idx;
for (idx = 0; idx < ARRAY_SIZE(apds9960_als_gain_map); idx++) {
if (apds9960_als_gain_map[idx] == val) {
mutex_lock(&data->lock);
ret = regmap_update_bits(data->regmap,
APDS9960_REG_CONTROL,
APDS9960_REG_CONTROL_AGAIN_MASK, idx);
if (!ret)
data->als_gain = idx;
mutex_unlock(&data->lock);
break;
}
}
return ret;
}
#ifdef CONFIG_PM
static int apds9960_set_power_state(struct apds9960_data *data, bool on)
{
struct device *dev = &data->client->dev;
int ret = 0;
mutex_lock(&data->lock);
if (on) {
int suspended;
suspended = pm_runtime_suspended(dev);
ret = pm_runtime_get_sync(dev);
/* Allow one integration cycle before allowing a reading */
if (suspended)
usleep_range(data->als_adc_int_us,
APDS9960_MAX_INT_TIME_IN_US);
} else {
pm_runtime_mark_last_busy(dev);
ret = pm_runtime_put_autosuspend(dev);
}
mutex_unlock(&data->lock);
return ret;
}
#else
static int apds9960_set_power_state(struct apds9960_data *data, bool on)
{
return 0;
}
#endif
static int apds9960_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2, long mask)
{
struct apds9960_data *data = iio_priv(indio_dev);
__le16 buf;
int ret = -EINVAL;
if (data->gesture_mode_running)
return -EBUSY;
switch (mask) {
case IIO_CHAN_INFO_RAW:
apds9960_set_power_state(data, true);
switch (chan->type) {
case IIO_PROXIMITY:
ret = regmap_read(data->regmap, chan->address, val);
if (!ret)
ret = IIO_VAL_INT;
break;
case IIO_INTENSITY:
ret = regmap_bulk_read(data->regmap, chan->address,
&buf, 2);
if (!ret) {
ret = IIO_VAL_INT;
*val = le16_to_cpu(buf);
}
break;
default:
ret = -EINVAL;
}
apds9960_set_power_state(data, false);
break;
case IIO_CHAN_INFO_INT_TIME:
/* RGB + ALS sensors only have integration time */
mutex_lock(&data->lock);
switch (chan->type) {
case IIO_INTENSITY:
*val = 0;
*val2 = data->als_adc_int_us;
ret = IIO_VAL_INT_PLUS_MICRO;
break;
default:
ret = -EINVAL;
}
mutex_unlock(&data->lock);
break;
case IIO_CHAN_INFO_SCALE:
mutex_lock(&data->lock);
switch (chan->type) {
case IIO_PROXIMITY:
*val = apds9960_pxs_gain_map[data->pxs_gain];
ret = IIO_VAL_INT;
break;
case IIO_INTENSITY:
*val = apds9960_als_gain_map[data->als_gain];
ret = IIO_VAL_INT;
break;
default:
ret = -EINVAL;
}
mutex_unlock(&data->lock);
break;
}
return ret;
};
static int apds9960_write_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int val, int val2, long mask)
{
struct apds9960_data *data = iio_priv(indio_dev);
switch (mask) {
case IIO_CHAN_INFO_INT_TIME:
/* RGB + ALS sensors only have int time */
switch (chan->type) {
case IIO_INTENSITY:
if (val != 0)
return -EINVAL;
return apds9960_set_it_time(data, val2);
default:
return -EINVAL;
}
case IIO_CHAN_INFO_SCALE:
if (val2 != 0)
return -EINVAL;
switch (chan->type) {
case IIO_PROXIMITY:
return apds9960_set_pxs_gain(data, val);
case IIO_INTENSITY:
return apds9960_set_als_gain(data, val);
default:
return -EINVAL;
}
default:
return -EINVAL;
}
return 0;
}
static inline int apds9960_get_thres_reg(const struct iio_chan_spec *chan,
enum iio_event_direction dir,
u8 *reg)
{
switch (dir) {
case IIO_EV_DIR_RISING:
switch (chan->type) {
case IIO_PROXIMITY:
*reg = APDS9960_REG_PIHT;
break;
case IIO_INTENSITY:
*reg = APDS9960_REG_AIHTL;
break;
default:
return -EINVAL;
}
break;
case IIO_EV_DIR_FALLING:
switch (chan->type) {
case IIO_PROXIMITY:
*reg = APDS9960_REG_PILT;
break;
case IIO_INTENSITY:
*reg = APDS9960_REG_AILTL;
break;
default:
return -EINVAL;
}
break;
default:
return -EINVAL;
}
return 0;
}
static int apds9960_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)
{
u8 reg;
__le16 buf;
int ret = 0;
struct apds9960_data *data = iio_priv(indio_dev);
if (info != IIO_EV_INFO_VALUE)
return -EINVAL;
ret = apds9960_get_thres_reg(chan, dir, &reg);
if (ret < 0)
return ret;
if (chan->type == IIO_PROXIMITY) {
ret = regmap_read(data->regmap, reg, val);
if (ret < 0)
return ret;
} else if (chan->type == IIO_INTENSITY) {
ret = regmap_bulk_read(data->regmap, reg, &buf, 2);
if (ret < 0)
return ret;
*val = le16_to_cpu(buf);
} else
return -EINVAL;
*val2 = 0;
return IIO_VAL_INT;
}
static int apds9960_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)
{
u8 reg;
__le16 buf;
int ret = 0;
struct apds9960_data *data = iio_priv(indio_dev);
if (info != IIO_EV_INFO_VALUE)
return -EINVAL;
ret = apds9960_get_thres_reg(chan, dir, &reg);
if (ret < 0)
return ret;
if (chan->type == IIO_PROXIMITY) {
if (val < 0 || val > APDS9960_MAX_PXS_THRES_VAL)
return -EINVAL;
ret = regmap_write(data->regmap, reg, val);
if (ret < 0)
return ret;
} else if (chan->type == IIO_INTENSITY) {
if (val < 0 || val > APDS9960_MAX_ALS_THRES_VAL)
return -EINVAL;
buf = cpu_to_le16(val);
ret = regmap_bulk_write(data->regmap, reg, &buf, 2);
if (ret < 0)
return ret;
} else
return -EINVAL;
return 0;
}
static int apds9960_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 apds9960_data *data = iio_priv(indio_dev);
switch (chan->type) {
case IIO_PROXIMITY:
return data->pxs_int;
case IIO_INTENSITY:
return data->als_int;
default:
return -EINVAL;
}
return 0;
}
static int apds9960_write_event_config(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
enum iio_event_type type,
enum iio_event_direction dir,
int state)
{
struct apds9960_data *data = iio_priv(indio_dev);
int ret;
state = !!state;
switch (chan->type) {
case IIO_PROXIMITY:
if (data->pxs_int == state)
return -EINVAL;
ret = regmap_field_write(data->reg_int_pxs, state);
if (ret)
return ret;
data->pxs_int = state;
apds9960_set_power_state(data, state);
break;
case IIO_INTENSITY:
if (data->als_int == state)
return -EINVAL;
ret = regmap_field_write(data->reg_int_als, state);
if (ret)
return ret;
data->als_int = state;
apds9960_set_power_state(data, state);
break;
default:
return -EINVAL;
}
return 0;
}
static const struct iio_info apds9960_info = {
.attrs = &apds9960_attribute_group,
.read_raw = apds9960_read_raw,
.write_raw = apds9960_write_raw,
.read_event_value = apds9960_read_event,
.write_event_value = apds9960_write_event,
.read_event_config = apds9960_read_event_config,
.write_event_config = apds9960_write_event_config,
};
static inline int apds9660_fifo_is_empty(struct apds9960_data *data)
{
int cnt;
int ret;
ret = regmap_read(data->regmap, APDS9960_REG_GFLVL, &cnt);
if (ret)
return ret;
return cnt;
}
static void apds9960_read_gesture_fifo(struct apds9960_data *data)
{
int ret, cnt = 0;
mutex_lock(&data->lock);
data->gesture_mode_running = 1;
while (cnt || (cnt = apds9660_fifo_is_empty(data) > 0)) {
ret = regmap_bulk_read(data->regmap, APDS9960_REG_GFIFO_BASE,
&data->buffer, 4);
if (ret)
goto err_read;
iio_push_to_buffers(data->indio_dev, data->buffer);
cnt--;
}
err_read:
data->gesture_mode_running = 0;
mutex_unlock(&data->lock);
}
static irqreturn_t apds9960_interrupt_handler(int irq, void *private)
{
struct iio_dev *indio_dev = private;
struct apds9960_data *data = iio_priv(indio_dev);
int ret, status;
ret = regmap_read(data->regmap, APDS9960_REG_STATUS, &status);
if (ret < 0) {
dev_err(&data->client->dev, "irq status reg read failed\n");
return IRQ_HANDLED;
}
if ((status & APDS9960_REG_STATUS_ALS_INT) && data->als_int) {
iio_push_event(indio_dev,
IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_EITHER),
iio_get_time_ns(indio_dev));
regmap_write(data->regmap, APDS9960_REG_CICLEAR, 1);
}
if ((status & APDS9960_REG_STATUS_PS_INT) && data->pxs_int) {
iio_push_event(indio_dev,
IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_EITHER),
iio_get_time_ns(indio_dev));
regmap_write(data->regmap, APDS9960_REG_PICLEAR, 1);
}
if (status & APDS9960_REG_STATUS_GINT)
apds9960_read_gesture_fifo(data);
return IRQ_HANDLED;
}
static int apds9960_set_powermode(struct apds9960_data *data, bool state)
{
return regmap_update_bits(data->regmap, APDS9960_REG_ENABLE, 1, state);
}
static int apds9960_buffer_postenable(struct iio_dev *indio_dev)
{
struct apds9960_data *data = iio_priv(indio_dev);
int ret;
ret = regmap_field_write(data->reg_int_ges, 1);
if (ret)
return ret;
ret = regmap_field_write(data->reg_enable_ges, 1);
if (ret)
return ret;
pm_runtime_get_sync(&data->client->dev);
return 0;
}
static int apds9960_buffer_predisable(struct iio_dev *indio_dev)
{
struct apds9960_data *data = iio_priv(indio_dev);
int ret;
ret = regmap_field_write(data->reg_enable_ges, 0);
if (ret)
return ret;
ret = regmap_field_write(data->reg_int_ges, 0);
if (ret)
return ret;
pm_runtime_put_autosuspend(&data->client->dev);
return 0;
}
static const struct iio_buffer_setup_ops apds9960_buffer_setup_ops = {
.postenable = apds9960_buffer_postenable,
.predisable = apds9960_buffer_predisable,
};
static int apds9960_regfield_init(struct apds9960_data *data)
{
struct device *dev = &data->client->dev;
struct regmap *regmap = data->regmap;
data->reg_int_als = devm_regmap_field_alloc(dev, regmap,
apds9960_reg_field_int_als);
if (IS_ERR(data->reg_int_als)) {
dev_err(dev, "INT ALS reg field init failed\n");
return PTR_ERR(data->reg_int_als);
}
data->reg_int_ges = devm_regmap_field_alloc(dev, regmap,
apds9960_reg_field_int_ges);
if (IS_ERR(data->reg_int_ges)) {
dev_err(dev, "INT gesture reg field init failed\n");
return PTR_ERR(data->reg_int_ges);
}
data->reg_int_pxs = devm_regmap_field_alloc(dev, regmap,
apds9960_reg_field_int_pxs);
if (IS_ERR(data->reg_int_pxs)) {
dev_err(dev, "INT pxs reg field init failed\n");
return PTR_ERR(data->reg_int_pxs);
}
data->reg_enable_als = devm_regmap_field_alloc(dev, regmap,
apds9960_reg_field_enable_als);
if (IS_ERR(data->reg_enable_als)) {
dev_err(dev, "Enable ALS reg field init failed\n");
return PTR_ERR(data->reg_enable_als);
}
data->reg_enable_ges = devm_regmap_field_alloc(dev, regmap,
apds9960_reg_field_enable_ges);
if (IS_ERR(data->reg_enable_ges)) {
dev_err(dev, "Enable gesture reg field init failed\n");
return PTR_ERR(data->reg_enable_ges);
}
data->reg_enable_pxs = devm_regmap_field_alloc(dev, regmap,
apds9960_reg_field_enable_pxs);
if (IS_ERR(data->reg_enable_pxs)) {
dev_err(dev, "Enable PXS reg field init failed\n");
return PTR_ERR(data->reg_enable_pxs);
}
return 0;
}
static int apds9960_chip_init(struct apds9960_data *data)
{
int ret;
/* Default IT for ALS of 28 ms */
ret = apds9960_set_it_time(data, 28000);
if (ret)
return ret;
/* Ensure gesture interrupt is OFF */
ret = regmap_field_write(data->reg_int_ges, 0);
if (ret)
return ret;
/* Disable gesture sensor, since polling is useless from user-space */
ret = regmap_field_write(data->reg_enable_ges, 0);
if (ret)
return ret;
/* Ensure proximity interrupt is OFF */
ret = regmap_field_write(data->reg_int_pxs, 0);
if (ret)
return ret;
/* Enable proximity sensor for polling */
ret = regmap_field_write(data->reg_enable_pxs, 1);
if (ret)
return ret;
/* Ensure ALS interrupt is OFF */
ret = regmap_field_write(data->reg_int_als, 0);
if (ret)
return ret;
/* Enable ALS sensor for polling */
ret = regmap_field_write(data->reg_enable_als, 1);
if (ret)
return ret;
/*
* When enabled trigger an interrupt after 3 readings
* outside threshold for ALS + PXS
*/
ret = regmap_write(data->regmap, APDS9960_REG_PERS,
APDS9960_DEFAULT_PERS);
if (ret)
return ret;
/*
* Wait for 4 event outside gesture threshold to prevent interrupt
* flooding.
*/
ret = regmap_update_bits(data->regmap, APDS9960_REG_GCONF_1,
APDS9960_REG_GCONF_1_GFIFO_THRES_MASK,
BIT(0) << APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT);
if (ret)
return ret;
/* Default ENTER and EXIT thresholds for the GESTURE engine. */
ret = regmap_write(data->regmap, APDS9960_REG_GPENTH,
APDS9960_DEFAULT_GPENTH);
if (ret)
return ret;
ret = regmap_write(data->regmap, APDS9960_REG_GEXTH,
APDS9960_DEFAULT_GEXTH);
if (ret)
return ret;
return apds9960_set_powermode(data, 1);
}
static int apds9960_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct apds9960_data *data;
struct iio_dev *indio_dev;
int ret;
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
if (!indio_dev)
return -ENOMEM;
indio_dev->info = &apds9960_info;
indio_dev->name = APDS9960_DRV_NAME;
indio_dev->channels = apds9960_channels;
indio_dev->num_channels = ARRAY_SIZE(apds9960_channels);
indio_dev->available_scan_masks = apds9960_scan_masks;
indio_dev->modes = INDIO_DIRECT_MODE;
ret = devm_iio_kfifo_buffer_setup(&client->dev, indio_dev,
INDIO_BUFFER_SOFTWARE,
&apds9960_buffer_setup_ops);
if (ret)
return ret;
data = iio_priv(indio_dev);
i2c_set_clientdata(client, indio_dev);
data->regmap = devm_regmap_init_i2c(client, &apds9960_regmap_config);
if (IS_ERR(data->regmap)) {
dev_err(&client->dev, "regmap initialization failed.\n");
return PTR_ERR(data->regmap);
}
data->client = client;
data->indio_dev = indio_dev;
mutex_init(&data->lock);
ret = pm_runtime_set_active(&client->dev);
if (ret)
goto error_power_down;
pm_runtime_enable(&client->dev);
pm_runtime_set_autosuspend_delay(&client->dev, 5000);
pm_runtime_use_autosuspend(&client->dev);
apds9960_set_power_state(data, true);
ret = apds9960_regfield_init(data);
if (ret)
goto error_power_down;
ret = apds9960_chip_init(data);
if (ret)
goto error_power_down;
if (client->irq <= 0) {
dev_err(&client->dev, "no valid irq defined\n");
ret = -EINVAL;
goto error_power_down;
}
ret = devm_request_threaded_irq(&client->dev, client->irq,
NULL, apds9960_interrupt_handler,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
"apds9960_event",
indio_dev);
if (ret) {
dev_err(&client->dev, "request irq (%d) failed\n", client->irq);
goto error_power_down;
}
ret = iio_device_register(indio_dev);
if (ret)
goto error_power_down;
apds9960_set_power_state(data, false);
return 0;
error_power_down:
apds9960_set_power_state(data, false);
return ret;
}
static int apds9960_remove(struct i2c_client *client)
{
struct iio_dev *indio_dev = i2c_get_clientdata(client);
struct apds9960_data *data = iio_priv(indio_dev);
iio_device_unregister(indio_dev);
pm_runtime_disable(&client->dev);
pm_runtime_set_suspended(&client->dev);
apds9960_set_powermode(data, 0);
return 0;
}
#ifdef CONFIG_PM
static int apds9960_runtime_suspend(struct device *dev)
{
struct apds9960_data *data =
iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
return apds9960_set_powermode(data, 0);
}
static int apds9960_runtime_resume(struct device *dev)
{
struct apds9960_data *data =
iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
return apds9960_set_powermode(data, 1);
}
#endif
static const struct dev_pm_ops apds9960_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
SET_RUNTIME_PM_OPS(apds9960_runtime_suspend,
apds9960_runtime_resume, NULL)
};
static const struct i2c_device_id apds9960_id[] = {
{ "apds9960", 0 },
{}
};
MODULE_DEVICE_TABLE(i2c, apds9960_id);
static const struct acpi_device_id apds9960_acpi_match[] = {
{ "MSHW0184" },
{ }
};
MODULE_DEVICE_TABLE(acpi, apds9960_acpi_match);
static const struct of_device_id apds9960_of_match[] = {
{ .compatible = "avago,apds9960" },
{ }
};
MODULE_DEVICE_TABLE(of, apds9960_of_match);
static struct i2c_driver apds9960_driver = {
.driver = {
.name = APDS9960_DRV_NAME,
.of_match_table = apds9960_of_match,
.pm = &apds9960_pm_ops,
.acpi_match_table = apds9960_acpi_match,
},
.probe = apds9960_probe,
.remove = apds9960_remove,
.id_table = apds9960_id,
};
module_i2c_driver(apds9960_driver);
MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
MODULE_DESCRIPTION("APDS9960 Gesture/RGB/ALS/Proximity sensor");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink