Release 4.11 drivers/iio/light/isl29018.c

/*
 * A iio driver for the light sensor ISL 29018/29023/29035.
 *
 * IIO driver for monitoring ambient light intensity in luxi, proximity
 * sensing and infrared sensing.
 *
 * Copyright (c) 2010, NVIDIA Corporation.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 */

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/acpi.h>


#define ISL29018_CONV_TIME_MS		100


#define ISL29018_REG_ADD_COMMAND1	0x00

#define ISL29018_CMD1_OPMODE_SHIFT	5

#define ISL29018_CMD1_OPMODE_MASK	(7 << ISL29018_CMD1_OPMODE_SHIFT)

#define ISL29018_CMD1_OPMODE_POWER_DOWN	0

#define ISL29018_CMD1_OPMODE_ALS_ONCE	1

#define ISL29018_CMD1_OPMODE_IR_ONCE	2

#define ISL29018_CMD1_OPMODE_PROX_ONCE	3


#define ISL29018_REG_ADD_COMMAND2	0x01

#define ISL29018_CMD2_RESOLUTION_SHIFT	2

#define ISL29018_CMD2_RESOLUTION_MASK	(0x3 << ISL29018_CMD2_RESOLUTION_SHIFT)


#define ISL29018_CMD2_RANGE_SHIFT	0

#define ISL29018_CMD2_RANGE_MASK	(0x3 << ISL29018_CMD2_RANGE_SHIFT)


#define ISL29018_CMD2_SCHEME_SHIFT	7

#define ISL29018_CMD2_SCHEME_MASK	(0x1 << ISL29018_CMD2_SCHEME_SHIFT)


#define ISL29018_REG_ADD_DATA_LSB	0x02

#define ISL29018_REG_ADD_DATA_MSB	0x03


#define ISL29018_REG_TEST		0x08

#define ISL29018_TEST_SHIFT		0

#define ISL29018_TEST_MASK		(0xFF << ISL29018_TEST_SHIFT)


#define ISL29035_REG_DEVICE_ID		0x0F

#define ISL29035_DEVICE_ID_SHIFT	0x03

#define ISL29035_DEVICE_ID_MASK		(0x7 << ISL29035_DEVICE_ID_SHIFT)

#define ISL29035_DEVICE_ID		0x5

#define ISL29035_BOUT_SHIFT		0x07

#define ISL29035_BOUT_MASK		(0x01 << ISL29035_BOUT_SHIFT)


enum isl29018_int_time {
	
ISL29018_INT_TIME_16,
	
ISL29018_INT_TIME_12,
	
ISL29018_INT_TIME_8,
	
ISL29018_INT_TIME_4,
};


static const unsigned int isl29018_int_utimes[3][4] = {
	{90000, 5630, 351, 21},
	{90000, 5600, 352, 22},
	{105000, 6500, 410, 25},
};


static const struct isl29018_scale {
	
unsigned int scale;
	
unsigned int uscale;
} 
isl29018_scales[4][4] = {
	{ {0, 15258}, {0, 61035}, {0, 244140}, {0, 976562} },
	{ {0, 244140}, {0, 976562}, {3, 906250}, {15, 625000} },
	{ {3, 906250}, {15, 625000}, {62, 500000}, {250, 0} },
	{ {62, 500000}, {250, 0}, {1000, 0}, {4000, 0} }
};


struct isl29018_chip {
	
struct regmap		*regmap;
	
struct mutex		lock;
	
int			type;
	
unsigned int		calibscale;
	
unsigned int		ucalibscale;
	
unsigned int		int_time;
	
struct isl29018_scale	scale;
	
int			prox_scheme;
	
bool			suspended;
};



static int isl29018_set_integration_time(struct isl29018_chip *chip,
					 unsigned int utime)
{
	unsigned int i;
	int ret;
	unsigned int int_time, new_int_time;

	for (i = 0; i < ARRAY_SIZE(isl29018_int_utimes[chip->type]); ++i) {
		if (utime == isl29018_int_utimes[chip->type][i]) {
			new_int_time = i;
			break;
		}
	}

	if (i >= ARRAY_SIZE(isl29018_int_utimes[chip->type]))
		return -EINVAL;

	ret = regmap_update_bits(chip->regmap, ISL29018_REG_ADD_COMMAND2,
				 ISL29018_CMD2_RESOLUTION_MASK,
				 i << ISL29018_CMD2_RESOLUTION_SHIFT);
	if (ret < 0)
		return ret;

	/* Keep the same range when integration time changes */
	int_time = chip->int_time;
	for (i = 0; i < ARRAY_SIZE(isl29018_scales[int_time]); ++i) {
		if (chip->scale.scale == isl29018_scales[int_time][i].scale &&
		    chip->scale.uscale == isl29018_scales[int_time][i].uscale) {
			chip->scale = isl29018_scales[new_int_time][i];
			break;
		}
	}
	chip->int_time = new_int_time;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Roberta Dobrescu
128
63.37%
1
16.67%
Rhyland Klein
59
29.21%
1
16.67%
Laxman Dewangan
8
3.96%
1
16.67%
Peter Meerwald-Stadler
4
1.98%
2
33.33%
Brian Masney
3
1.49%
1
16.67%
Total
202
100.00%
6
100.00%



static int isl29018_set_scale(struct isl29018_chip *chip, int scale, int uscale)
{
	unsigned int i;
	int ret;
	struct isl29018_scale new_scale;

	for (i = 0; i < ARRAY_SIZE(isl29018_scales[chip->int_time]); ++i) {
		if (scale == isl29018_scales[chip->int_time][i].scale &&
		    uscale == isl29018_scales[chip->int_time][i].uscale) {
			new_scale = isl29018_scales[chip->int_time][i];
			break;
		}
	}

	if (i >= ARRAY_SIZE(isl29018_scales[chip->int_time]))
		return -EINVAL;

	ret = regmap_update_bits(chip->regmap, ISL29018_REG_ADD_COMMAND2,
				 ISL29018_CMD2_RANGE_MASK,
				 i << ISL29018_CMD2_RANGE_SHIFT);
	if (ret < 0)
		return ret;

	chip->scale = new_scale;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Roberta Dobrescu
72
48.32%
1
20.00%
Rhyland Klein
63
42.28%
1
20.00%
Laxman Dewangan
8
5.37%
1
20.00%
Brian Masney
3
2.01%
1
20.00%
Peter Meerwald-Stadler
3
2.01%
1
20.00%
Total
149
100.00%
5
100.00%



static int isl29018_read_sensor_input(struct isl29018_chip *chip, int mode)
{
	int status;
	unsigned int lsb;
	unsigned int msb;
	struct device *dev = regmap_get_device(chip->regmap);

	/* Set mode */
	status = regmap_write(chip->regmap, ISL29018_REG_ADD_COMMAND1,
			      mode << ISL29018_CMD1_OPMODE_SHIFT);
	if (status) {
		dev_err(dev,
			"Error in setting operating mode err %d\n", status);
		return status;
	}
	msleep(ISL29018_CONV_TIME_MS);
	status = regmap_read(chip->regmap, ISL29018_REG_ADD_DATA_LSB, &lsb);
	if (status < 0) {
		dev_err(dev,
			"Error in reading LSB DATA with err %d\n", status);
		return status;
	}

	status = regmap_read(chip->regmap, ISL29018_REG_ADD_DATA_MSB, &msb);
	if (status < 0) {
		dev_err(dev,
			"Error in reading MSB DATA with error %d\n", status);
		return status;
	}
	dev_vdbg(dev, "MSB 0x%x and LSB 0x%x\n", msb, lsb);

	return (msb << 8) | lsb;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rhyland Klein
112
68.29%
1
25.00%
Laxman Dewangan
38
23.17%
1
25.00%
Alison Schofield
12
7.32%
1
25.00%
Peter Meerwald-Stadler
2
1.22%
1
25.00%
Total
164
100.00%
4
100.00%



static int isl29018_read_lux(struct isl29018_chip *chip, int *lux)
{
	int lux_data;
	unsigned int data_x_range;

	lux_data = isl29018_read_sensor_input(chip,
					      ISL29018_CMD1_OPMODE_ALS_ONCE);
	if (lux_data < 0)
		return lux_data;

	data_x_range = lux_data * chip->scale.scale +
		       lux_data * chip->scale.uscale / 1000000;
	*lux = data_x_range * chip->calibscale +
	       data_x_range * chip->ucalibscale / 1000000;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rhyland Klein
41
51.25%
1
14.29%
Roberta Dobrescu
19
23.75%
2
28.57%
Bryan Freed
16
20.00%
2
28.57%
Laxman Dewangan
3
3.75%
1
14.29%
Peter Meerwald-Stadler
1
1.25%
1
14.29%
Total
80
100.00%
7
100.00%



static int isl29018_read_ir(struct isl29018_chip *chip, int *ir)
{
	int ir_data;

	ir_data = isl29018_read_sensor_input(chip,
					     ISL29018_CMD1_OPMODE_IR_ONCE);
	if (ir_data < 0)
		return ir_data;

	*ir = ir_data;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rhyland Klein
40
90.91%
1
33.33%
Laxman Dewangan
3
6.82%
1
33.33%
Peter Meerwald-Stadler
1
2.27%
1
33.33%
Total
44
100.00%
3
100.00%



static int isl29018_read_proximity_ir(struct isl29018_chip *chip, int scheme,
				      int *near_ir)
{
	int status;
	int prox_data = -1;
	int ir_data = -1;
	struct device *dev = regmap_get_device(chip->regmap);

	/* Do proximity sensing with required scheme */
	status = regmap_update_bits(chip->regmap, ISL29018_REG_ADD_COMMAND2,
				    ISL29018_CMD2_SCHEME_MASK,
				    scheme << ISL29018_CMD2_SCHEME_SHIFT);
	if (status) {
		dev_err(dev, "Error in setting operating mode\n");
		return status;
	}

	prox_data = isl29018_read_sensor_input(chip,
					       ISL29018_CMD1_OPMODE_PROX_ONCE);
	if (prox_data < 0)
		return prox_data;

	if (scheme == 1) {
		*near_ir = prox_data;
		return 0;
	}

	ir_data = isl29018_read_sensor_input(chip,
					     ISL29018_CMD1_OPMODE_IR_ONCE);
	if (ir_data < 0)
		return ir_data;

	if (prox_data >= ir_data)
		*near_ir = prox_data - ir_data;
	else
		*near_ir = 0;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rhyland Klein
116
75.82%
1
20.00%
Alison Schofield
12
7.84%
1
20.00%
Roberta Dobrescu
10
6.54%
1
20.00%
Laxman Dewangan
10
6.54%
1
20.00%
Peter Meerwald-Stadler
5
3.27%
1
20.00%
Total
153
100.00%
5
100.00%



static ssize_t in_illuminance_scale_available_show
			(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct isl29018_chip *chip = iio_priv(indio_dev);
	unsigned int i;
	int len = 0;

	mutex_lock(&chip->lock);
	for (i = 0; i < ARRAY_SIZE(isl29018_scales[chip->int_time]); ++i)
		len += sprintf(buf + len, "%d.%06d ",
			       isl29018_scales[chip->int_time][i].scale,
			       isl29018_scales[chip->int_time][i].uscale);
	mutex_unlock(&chip->lock);

	buf[len - 1] = '\n';

	return len;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Roberta Dobrescu
113
84.96%
1
25.00%
Brian Masney
20
15.04%
3
75.00%
Total
133
100.00%
4
100.00%



static ssize_t in_illuminance_integration_time_available_show
			(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct isl29018_chip *chip = iio_priv(indio_dev);
	unsigned int i;
	int len = 0;

	for (i = 0; i < ARRAY_SIZE(isl29018_int_utimes[chip->type]); ++i)
		len += sprintf(buf + len, "0.%06d ",
			       isl29018_int_utimes[chip->type][i]);

	buf[len - 1] = '\n';

	return len;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Roberta Dobrescu
94
91.26%
1
25.00%
Rhyland Klein
5
4.85%
1
25.00%
Brian Masney
4
3.88%
2
50.00%
Total
103
100.00%
4
100.00%

/*
 * From ISL29018 Data Sheet (FN6619.4, Oct 8, 2012) regarding the
 * infrared suppression:
 *
 *   Proximity Sensing Scheme: Bit 7. This bit programs the function
 * of the proximity detection. Logic 0 of this bit, Scheme 0, makes
 * full n (4, 8, 12, 16) bits (unsigned) proximity detection. The range
 * of Scheme 0 proximity count is from 0 to 2^n. Logic 1 of this bit,
 * Scheme 1, makes n-1 (3, 7, 11, 15) bits (2's complementary)
 * proximity_less_ambient detection. The range of Scheme 1
 * proximity count is from -2^(n-1) to 2^(n-1) . The sign bit is extended
 * for resolutions less than 16. While Scheme 0 has wider dynamic
 * range, Scheme 1 proximity detection is less affected by the
 * ambient IR noise variation.
 *
 * 0 Sensing IR from LED and ambient
 * 1 Sensing IR from LED with ambient IR rejection
 */


static ssize_t proximity_on_chip_ambient_infrared_suppression_show
			(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct isl29018_chip *chip = iio_priv(indio_dev);

	/*
         * Return the "proximity scheme" i.e. if the chip does on chip
         * infrared suppression (1 means perform on chip suppression)
         */
	return sprintf(buf, "%d\n", chip->prox_scheme);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rhyland Klein
47
88.68%
1
20.00%
Jonathan Cameron
3
5.66%
1
20.00%
Brian Masney
1
1.89%
1
20.00%
Lars-Peter Clausen
1
1.89%
1
20.00%
Peter Meerwald-Stadler
1
1.89%
1
20.00%
Total
53
100.00%
5
100.00%



static ssize_t proximity_on_chip_ambient_infrared_suppression_store
			(struct device *dev, struct device_attribute *attr,
			 const char *buf, size_t count)
{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct isl29018_chip *chip = iio_priv(indio_dev);
	int val;

	if (kstrtoint(buf, 10, &val))
		return -EINVAL;
	if (!(val == 0 || val == 1))
		return -EINVAL;

	/*
         * Get the "proximity scheme" i.e. if the chip does on chip
         * infrared suppression (1 means perform on chip suppression)
         */
	mutex_lock(&chip->lock);
	chip->prox_scheme = val;
	mutex_unlock(&chip->lock);

	return count;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rhyland Klein
76
71.70%
1
14.29%
Bryan Freed
15
14.15%
1
14.29%
Jingoo Han
9
8.49%
1
14.29%
Jonathan Cameron
3
2.83%
1
14.29%
Peter Meerwald-Stadler
1
0.94%
1
14.29%
Lars-Peter Clausen
1
0.94%
1
14.29%
Brian Masney
1
0.94%
1
14.29%
Total
106
100.00%
7
100.00%



static int isl29018_write_raw(struct iio_dev *indio_dev,
			      struct iio_chan_spec const *chan,
			      int val,
			      int val2,
			      long mask)
{
	struct isl29018_chip *chip = iio_priv(indio_dev);
	int ret = -EINVAL;

	mutex_lock(&chip->lock);
	if (chip->suspended) {
		ret = -EBUSY;
		goto write_done;
	}
	switch (mask) {
	case IIO_CHAN_INFO_CALIBSCALE:
		if (chan->type == IIO_LIGHT) {
			chip->calibscale = val;
			chip->ucalibscale = val2;
			ret = 0;
		}
		break;
	case IIO_CHAN_INFO_INT_TIME:
		if (chan->type == IIO_LIGHT && !val)
			ret = isl29018_set_integration_time(chip, val2);
		break;
	case IIO_CHAN_INFO_SCALE:
		if (chan->type == IIO_LIGHT)
			ret = isl29018_set_scale(chip, val, val2);
		break;
	default:
		break;
	}

write_done:
	mutex_unlock(&chip->lock);

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Freed
84
51.22%
2
25.00%
Roberta Dobrescu
58
35.37%
2
25.00%
Brian Masney
20
12.20%
2
25.00%
Wei Yongjun
1
0.61%
1
12.50%
Jonathan Cameron
1
0.61%
1
12.50%
Total
164
100.00%
8
100.00%



static int isl29018_read_raw(struct iio_dev *indio_dev,
			     struct iio_chan_spec const *chan,
			     int *val,
			     int *val2,
			     long mask)
{
	int ret = -EINVAL;
	struct isl29018_chip *chip = iio_priv(indio_dev);

	mutex_lock(&chip->lock);
	if (chip->suspended) {
		ret = -EBUSY;
		goto read_done;
	}
	switch (mask) {
	case IIO_CHAN_INFO_RAW:
	case IIO_CHAN_INFO_PROCESSED:
		switch (chan->type) {
		case IIO_LIGHT:
			ret = isl29018_read_lux(chip, val);
			break;
		case IIO_INTENSITY:
			ret = isl29018_read_ir(chip, val);
			break;
		case IIO_PROXIMITY:
			ret = isl29018_read_proximity_ir(chip,
							 chip->prox_scheme,
							 val);
			break;
		default:
			break;
		}
		if (!ret)
			ret = IIO_VAL_INT;
		break;
	case IIO_CHAN_INFO_INT_TIME:
		if (chan->type == IIO_LIGHT) {
			*val = 0;
			*val2 = isl29018_int_utimes[chip->type][chip->int_time];
			ret = IIO_VAL_INT_PLUS_MICRO;
		}
		break;
	case IIO_CHAN_INFO_SCALE:
		if (chan->type == IIO_LIGHT) {
			*val = chip->scale.scale;
			*val2 = chip->scale.uscale;
			ret = IIO_VAL_INT_PLUS_MICRO;
		}
		break;
	case IIO_CHAN_INFO_CALIBSCALE:
		if (chan->type == IIO_LIGHT) {
			*val = chip->calibscale;
			*val2 = chip->ucalibscale;
			ret = IIO_VAL_INT_PLUS_MICRO;
		}
		break;
	default:
		break;
	}

read_done:
	mutex_unlock(&chip->lock);

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Freed
159
60.23%
3
30.00%
Roberta Dobrescu
76
28.79%
2
20.00%
Rhyland Klein
13
4.92%
1
10.00%
Brian Masney
8
3.03%
1
10.00%
Jonathan Cameron
5
1.89%
2
20.00%
Laxman Dewangan
3
1.14%
1
10.00%
Total
264
100.00%
10
100.00%


#define ISL29018_LIGHT_CHANNEL {                                       \
        .type = IIO_LIGHT,                                              \
        .indexed = 1,                                                   \
        .channel = 0,                                                   \
        .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |            \
        BIT(IIO_CHAN_INFO_CALIBSCALE) |                                 \
        BIT(IIO_CHAN_INFO_SCALE) |                                      \
        BIT(IIO_CHAN_INFO_INT_TIME),                                    \
}


#define ISL29018_IR_CHANNEL {                                               \
        .type = IIO_INTENSITY,                                          \
        .modified = 1,                                                  \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                   \
        .channel2 = IIO_MOD_LIGHT_IR,                                   \
}


#define ISL29018_PROXIMITY_CHANNEL {                                       \
        .type = IIO_PROXIMITY,                                          \
        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                   \
}


static const struct iio_chan_spec isl29018_channels[] = {
	ISL29018_LIGHT_CHANNEL,
	ISL29018_IR_CHANNEL,
	ISL29018_PROXIMITY_CHANNEL,
};


static const struct iio_chan_spec isl29023_channels[] = {
	ISL29018_LIGHT_CHANNEL,
	ISL29018_IR_CHANNEL,
};

static IIO_DEVICE_ATTR_RO(in_illuminance_integration_time_available, 0);
static IIO_DEVICE_ATTR_RO(in_illuminance_scale_available, 0);
static IIO_DEVICE_ATTR_RW(proximity_on_chip_ambient_infrared_suppression, 0);


#define ISL29018_DEV_ATTR(name) (&iio_dev_attr_##name.dev_attr.attr)


static struct attribute *isl29018_attributes[] = {
	ISL29018_DEV_ATTR(in_illuminance_scale_available),
	ISL29018_DEV_ATTR(in_illuminance_integration_time_available),
	ISL29018_DEV_ATTR(proximity_on_chip_ambient_infrared_suppression),
	NULL
};


static struct attribute *isl29023_attributes[] = {
	ISL29018_DEV_ATTR(in_illuminance_scale_available),
	ISL29018_DEV_ATTR(in_illuminance_integration_time_available),
	NULL
};


static const struct attribute_group isl29018_group = {
	.attrs = isl29018_attributes,
};


static const struct attribute_group isl29023_group = {
	.attrs = isl29023_attributes,
};

enum {
	
isl29018,
	
isl29023,
	
isl29035,
};



static int isl29018_chip_init(struct isl29018_chip *chip)
{
	int status;
	struct device *dev = regmap_get_device(chip->regmap);

	if (chip->type == isl29035) {
		unsigned int id;

		status = regmap_read(chip->regmap, ISL29035_REG_DEVICE_ID, &id);
		if (status < 0) {
			dev_err(dev,
				"Error reading ID register with error %d\n",
				status);
			return status;
		}

		id = (id & ISL29035_DEVICE_ID_MASK) >> ISL29035_DEVICE_ID_SHIFT;

		if (id != ISL29035_DEVICE_ID)
			return -ENODEV;

		/* Clear brownout bit */
		status = regmap_update_bits(chip->regmap,
					    ISL29035_REG_DEVICE_ID,
					    ISL29035_BOUT_MASK, 0);
		if (status < 0)
			return status;
	}

	/*
         * Code added per Intersil Application Note 1534:
         *     When VDD sinks to approximately 1.8V or below, some of
         * the part's registers may change their state. When VDD
         * recovers to 2.25V (or greater), the part may thus be in an
         * unknown mode of operation. The user can return the part to
         * a known mode of operation either by (a) setting VDD = 0V for
         * 1 second or more and then powering back up with a slew rate
         * of 0.5V/ms or greater, or (b) via I2C disable all ALS/PROX
         * conversions, clear the test registers, and then rewrite all
         * registers to the desired values.
         * ...
         * For ISL29011, ISL29018, ISL29021, ISL29023
         * 1. Write 0x00 to register 0x08 (TEST)
         * 2. Write 0x00 to register 0x00 (CMD1)
         * 3. Rewrite all registers to the desired values
         *
         * ISL29018 Data Sheet (FN6619.1, Feb 11, 2010) essentially says
         * the same thing EXCEPT the data sheet asks for a 1ms delay after
         * writing the CMD1 register.
         */
	status = regmap_write(chip->regmap, ISL29018_REG_TEST, 0x0);
	if (status < 0) {
		dev_err(dev, "Failed to clear isl29018 TEST reg.(%d)\n",
			status);
		return status;
	}

	/*
         * See Intersil AN1534 comments above.
         * "Operating Mode" (COMMAND1) register is reprogrammed when
         * data is read from the device.
         */
	status = regmap_write(chip->regmap, ISL29018_REG_ADD_COMMAND1, 0);
	if (status < 0) {
		dev_err(dev, "Failed to clear isl29018 CMD1 reg.(%d)\n",
			status);
		return status;
	}

	usleep_range(1000, 2000);	/* per data sheet, page 10 */

	/* Set defaults */
	status = isl29018_set_scale(chip, chip->scale.scale,
				    chip->scale.uscale);
	if (status < 0) {
		dev_err(dev, "Init of isl29018 fails\n");
		return status;
	}

	status = isl29018_set_integration_time(chip,
			isl29018_int_utimes[chip->type][chip->int_time]);
	if (status < 0)
		dev_err(dev, "Init of isl29018 fails\n");

	return status;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Laurentiu Palcu
89
33.21%
1
9.09%
Grant Grundler
59
22.01%
1
9.09%
Roberta Dobrescu
38
14.18%
2
18.18%
Rhyland Klein
35
13.06%
1
9.09%
Brian Masney
18
6.72%
2
18.18%
Alison Schofield
12
4.48%
1
9.09%
Laxman Dewangan
11
4.10%
1
9.09%
Vaishali Thakkar
4
1.49%
1
9.09%
Peter Meerwald-Stadler
2
0.75%
1
9.09%
Total
268
100.00%
11
100.00%


static const struct iio_info isl29018_info = {
	.attrs = &isl29018_group,
	.driver_module = THIS_MODULE,
	.read_raw = isl29018_read_raw,
	.write_raw = isl29018_write_raw,
};


static const struct iio_info isl29023_info = {
	.attrs = &isl29023_group,
	.driver_module = THIS_MODULE,
	.read_raw = isl29018_read_raw,
	.write_raw = isl29018_write_raw,
};



static bool isl29018_is_volatile_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case ISL29018_REG_ADD_DATA_LSB:
	case ISL29018_REG_ADD_DATA_MSB:
	case ISL29018_REG_ADD_COMMAND1:
	case ISL29018_REG_TEST:
	case ISL29035_REG_DEVICE_ID:
		return true;
	default:
		return false;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Laxman Dewangan
39
90.70%
1
33.33%
Laurentiu Palcu
3
6.98%
1
33.33%
Peter Meerwald-Stadler
1
2.33%
1
33.33%
Total
43
100.00%
3
100.00%


static const struct regmap_config isl29018_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.volatile_reg = isl29018_is_volatile_reg,
	.max_register = ISL29018_REG_TEST,
	.num_reg_defaults_raw = ISL29018_REG_TEST + 1,
	.cache_type = REGCACHE_RBTREE,
};


static const struct regmap_config isl29035_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.volatile_reg = isl29018_is_volatile_reg,
	.max_register = ISL29035_REG_DEVICE_ID,
	.num_reg_defaults_raw = ISL29035_REG_DEVICE_ID + 1,
	.cache_type = REGCACHE_RBTREE,
};


struct isl29018_chip_info {
	
const struct iio_chan_spec *channels;
	
int num_channels;
	
const struct iio_info *indio_info;
	
const struct regmap_config *regmap_cfg;
};


static const struct isl29018_chip_info isl29018_chip_info_tbl[] = {
	[isl29018] = {
		.channels = isl29018_channels,
		.num_channels = ARRAY_SIZE(isl29018_channels),
		.indio_info = &isl29018_info,
		.regmap_cfg = &isl29018_regmap_config,
        },
	[isl29023] = {
		.channels = isl29023_channels,
		.num_channels = ARRAY_SIZE(isl29023_channels),
		.indio_info = &isl29023_info,
		.regmap_cfg = &isl29018_regmap_config,
        },
	[isl29035] = {
		.channels = isl29023_channels,
		.num_channels = ARRAY_SIZE(isl29023_channels),
		.indio_info = &isl29023_info,
		.regmap_cfg = &isl29035_regmap_config,
        },
};



static const char *isl29018_match_acpi_device(struct device *dev, int *data)
{
	const struct acpi_device_id *id;

	id = acpi_match_device(dev->driver->acpi_match_table, dev);

	if (!id)
		return NULL;

	*data = (int)id->driver_data;

	return dev_name(dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Laurentiu Palcu
60
100.00%
1
100.00%
Total
60
100.00%
1
100.00%



static int isl29018_probe(struct i2c_client *client,
			  const struct i2c_device_id *id)
{
	struct isl29018_chip *chip;
	struct iio_dev *indio_dev;
	int err;
	const char *name = NULL;
	int dev_id = 0;

	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip));
	if (!indio_dev)
		return -ENOMEM;

	chip = iio_priv(indio_dev);

	i2c_set_clientdata(client, indio_dev);

	if (id) {
		name = id->name;
		dev_id = id->driver_data;
	}

	if (ACPI_HANDLE(&client->dev))
		name = isl29018_match_acpi_device(&client->dev, &dev_id);

	mutex_init(&chip->lock);

	chip->type = dev_id;
	chip->calibscale = 1;
	chip->ucalibscale = 0;
	chip->int_time = ISL29018_INT_TIME_16;
	chip->scale = isl29018_scales[chip->int_time][0];
	chip->suspended = false;

	chip->regmap = devm_regmap_init_i2c(client,
				isl29018_chip_info_tbl[dev_id].regmap_cfg);
	if (IS_ERR(chip->regmap)) {
		err = PTR_ERR(chip->regmap);
		dev_err(&client->dev, "regmap initialization fails: %d\n", err);
		return err;
	}

	err = isl29018_chip_init(chip);
	if (err)
		return err;

	indio_dev->info = isl29018_chip_info_tbl[dev_id].indio_info;
	indio_dev->channels = isl29018_chip_info_tbl[dev_id].channels;
	indio_dev->num_channels = isl29018_chip_info_tbl[dev_id].num_channels;
	indio_dev->name = name;
	indio_dev->dev.parent = &client->dev;
	indio_dev->modes = INDIO_DIRECT_MODE;

	return devm_iio_device_register(&client->dev, indio_dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Rhyland Klein
94
30.72%
1
5.26%
Laurentiu Palcu
79
25.82%
2
10.53%
Laxman Dewangan
40
13.07%
1
5.26%
Jonathan Cameron
24
7.84%
3
15.79%
Bryan Freed
21
6.86%
3
15.79%
Sachin Kamat
20
6.54%
2
10.53%
Roberta Dobrescu
14
4.58%
2
10.53%
Peter Meerwald-Stadler
5
1.63%
2
10.53%
Derek Basehore
5
1.63%
1
5.26%
Alison Schofield
3
0.98%
1
5.26%
Cristina Moraru
1
0.33%
1
5.26%
Total
306
100.00%
19
100.00%

#ifdef CONFIG_PM_SLEEP


static int isl29018_suspend(struct device *dev)
{
	struct isl29018_chip *chip = iio_priv(dev_get_drvdata(dev));

	mutex_lock(&chip->lock);

	/*
         * Since this driver uses only polling commands, we are by default in
         * auto shutdown (ie, power-down) mode.
         * So we do not have much to do here.
         */
	chip->suspended = true;

	mutex_unlock(&chip->lock);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Freed
49
98.00%
1
50.00%
Brian Masney
1
2.00%
1
50.00%
Total
50
100.00%
2
100.00%



static int isl29018_resume(struct device *dev)
{
	struct isl29018_chip *chip = iio_priv(dev_get_drvdata(dev));
	int err;

	mutex_lock(&chip->lock);

	err = isl29018_chip_init(chip);
	if (!err)
		chip->suspended = false;

	mutex_unlock(&chip->lock);

	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Freed
64
100.00%
1
100.00%
Total
64
100.00%
1
100.00%

static SIMPLE_DEV_PM_OPS(isl29018_pm_ops, isl29018_suspend, isl29018_resume);

#define ISL29018_PM_OPS (&isl29018_pm_ops)
#else

#define ISL29018_PM_OPS NULL
#endif


static const struct acpi_device_id isl29018_acpi_match[] = {
	{"ISL29018", isl29018},
	{"ISL29023", isl29023},
	{"ISL29035", isl29035},
	{},
};
MODULE_DEVICE_TABLE(acpi, isl29018_acpi_match);


static const struct i2c_device_id isl29018_id[] = {
	{"isl29018", isl29018},
	{"isl29023", isl29023},
	{"isl29035", isl29035},
	{}
};
MODULE_DEVICE_TABLE(i2c, isl29018_id);


static const struct of_device_id isl29018_of_match[] = {
	{ .compatible = "isil,isl29018", },
	{ .compatible = "isil,isl29023", },
	{ .compatible = "isil,isl29035", },
	{ },
};
MODULE_DEVICE_TABLE(of, isl29018_of_match);


static struct i2c_driver isl29018_driver = {
	.driver	 = {
			.name = "isl29018",
			.acpi_match_table = ACPI_PTR(isl29018_acpi_match),
			.pm = ISL29018_PM_OPS,
			.of_match_table = isl29018_of_match,
                    },
	.probe	 = isl29018_probe,
	.id_table = isl29018_id,
};

module_i2c_driver(isl29018_driver);

MODULE_DESCRIPTION("ISL29018 Ambient Light Sensor driver");
MODULE_LICENSE("GPL");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Rhyland Klein
896
26.51%
1
2.13%
Roberta Dobrescu
847
25.06%
3
6.38%
Laurentiu Palcu
578
17.10%
3
6.38%
Bryan Freed
465
13.76%
4
8.51%
Laxman Dewangan
210
6.21%
2
4.26%
Brian Masney
93
2.75%
10
21.28%
Grant Grundler
71
2.10%
1
2.13%
Jonathan Cameron
59
1.75%
7
14.89%
Peter Meerwald-Stadler
51
1.51%
5
10.64%
Alison Schofield
39
1.15%
1
2.13%
Olof Johansson
27
0.80%
1
2.13%
Sachin Kamat
20
0.59%
2
4.26%
Jingoo Han
9
0.27%
1
2.13%
Derek Basehore
5
0.15%
1
2.13%
Vaishali Thakkar
4
0.12%
1
2.13%
Lars-Peter Clausen
4
0.12%
2
4.26%
Cristina Moraru
1
0.03%
1
2.13%
Wei Yongjun
1
0.03%
1
2.13%
Total
3380
100.00%
47
100.00%
Directory: drivers/iio/light

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.