[deliverable/linux.git] / drivers / staging / iio / light / isl29018.c

/*
 * A iio driver for the light sensor ISL 29018.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA	02110-1301, USA.
 */

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include "../iio.h"
#include "../sysfs.h"
#define CONVERSION_TIME_MS		100

#define ISL29018_REG_ADD_COMMAND1	0x00
#define COMMMAND1_OPMODE_SHIFT		5
#define COMMMAND1_OPMODE_MASK		(7 << COMMMAND1_OPMODE_SHIFT)
#define COMMMAND1_OPMODE_POWER_DOWN	0
#define COMMMAND1_OPMODE_ALS_ONCE	1
#define COMMMAND1_OPMODE_IR_ONCE	2
#define COMMMAND1_OPMODE_PROX_ONCE	3

#define ISL29018_REG_ADD_COMMANDII	0x01
#define COMMANDII_RESOLUTION_SHIFT	2
#define COMMANDII_RESOLUTION_MASK	(0x3 << COMMANDII_RESOLUTION_SHIFT)

#define COMMANDII_RANGE_SHIFT		0
#define COMMANDII_RANGE_MASK		(0x3 << COMMANDII_RANGE_SHIFT)

#define COMMANDII_SCHEME_SHIFT		7
#define COMMANDII_SCHEME_MASK		(0x1 << COMMANDII_SCHEME_SHIFT)

#define ISL29018_REG_ADD_DATA_LSB	0x02
#define ISL29018_REG_ADD_DATA_MSB	0x03
#define ISL29018_MAX_REGS		(ISL29018_REG_ADD_DATA_MSB+1)

#define ISL29018_REG_TEST		0x08
#define ISL29018_TEST_SHIFT		0
#define ISL29018_TEST_MASK		(0xFF << ISL29018_TEST_SHIFT)

struct isl29018_chip {
	struct i2c_client	*client;
	struct mutex		lock;
	unsigned int		lux_scale;
	unsigned int		range;
	unsigned int		adc_bit;
	int			prox_scheme;
	u8			reg_cache[ISL29018_MAX_REGS];
};

static int isl29018_write_data(struct i2c_client *client, u8 reg,
			u8 val, u8 mask, u8 shift)
{
	u8 regval = val;
	int ret;
	struct isl29018_chip *chip = iio_priv(i2c_get_clientdata(client));

	/* don't cache or mask REG_TEST */
	if (reg < ISL29018_MAX_REGS) {
		regval = chip->reg_cache[reg];
		regval &= ~mask;
		regval |= val << shift;
	}

	ret = i2c_smbus_write_byte_data(client, reg, regval);
	if (ret) {
		dev_err(&client->dev, "Write to device fails status %x\n", ret);
	} else {
		/* don't update cache on err */
		if (reg < ISL29018_MAX_REGS)
			chip->reg_cache[reg] = regval;
	}

	return ret;
}

static int isl29018_set_range(struct i2c_client *client, unsigned long range,
		unsigned int *new_range)
{
	static const unsigned long supp_ranges[] = {1000, 4000, 16000, 64000};
	int i;

	for (i = 0; i < ARRAY_SIZE(supp_ranges); ++i) {
		if (range <= supp_ranges[i]) {
			*new_range = (unsigned int)supp_ranges[i];
			break;
		}
	}

	if (i >= ARRAY_SIZE(supp_ranges))
		return -EINVAL;

	return isl29018_write_data(client, ISL29018_REG_ADD_COMMANDII,
			i, COMMANDII_RANGE_MASK, COMMANDII_RANGE_SHIFT);
}

static int isl29018_set_resolution(struct i2c_client *client,
			unsigned long adcbit, unsigned int *conf_adc_bit)
{
	static const unsigned long supp_adcbit[] = {16, 12, 8, 4};
	int i;

	for (i = 0; i < ARRAY_SIZE(supp_adcbit); ++i) {
		if (adcbit >= supp_adcbit[i]) {
			*conf_adc_bit = (unsigned int)supp_adcbit[i];
			break;
		}
	}

	if (i >= ARRAY_SIZE(supp_adcbit))
		return -EINVAL;

	return isl29018_write_data(client, ISL29018_REG_ADD_COMMANDII,
			i, COMMANDII_RESOLUTION_MASK,
			COMMANDII_RESOLUTION_SHIFT);
}

static int isl29018_read_sensor_input(struct i2c_client *client, int mode)
{
	int status;
	int lsb;
	int msb;

	/* Set mode */
	status = isl29018_write_data(client, ISL29018_REG_ADD_COMMAND1,
			mode, COMMMAND1_OPMODE_MASK, COMMMAND1_OPMODE_SHIFT);
	if (status) {
		dev_err(&client->dev, "Error in setting operating mode\n");
		return status;
	}
	msleep(CONVERSION_TIME_MS);
	lsb = i2c_smbus_read_byte_data(client, ISL29018_REG_ADD_DATA_LSB);
	if (lsb < 0) {
		dev_err(&client->dev, "Error in reading LSB DATA\n");
		return lsb;
	}

	msb = i2c_smbus_read_byte_data(client, ISL29018_REG_ADD_DATA_MSB);
	if (msb < 0) {
		dev_err(&client->dev, "Error in reading MSB DATA\n");
		return msb;
	}
	dev_vdbg(&client->dev, "MSB 0x%x and LSB 0x%x\n", msb, lsb);

	return (msb << 8) | lsb;
}

static int isl29018_read_lux(struct i2c_client *client, int *lux)
{
	int lux_data;
	struct isl29018_chip *chip = iio_priv(i2c_get_clientdata(client));

	lux_data = isl29018_read_sensor_input(client,
				COMMMAND1_OPMODE_ALS_ONCE);

	if (lux_data < 0)
		return lux_data;

	*lux = (lux_data * chip->range * chip->lux_scale) >> chip->adc_bit;

	return 0;
}

static int isl29018_read_ir(struct i2c_client *client, int *ir)
{
	int ir_data;

	ir_data = isl29018_read_sensor_input(client, COMMMAND1_OPMODE_IR_ONCE);

	if (ir_data < 0)
		return ir_data;

	*ir = ir_data;

	return 0;
}

static int isl29018_read_proximity_ir(struct i2c_client *client, int scheme,
		int *near_ir)
{
	int status;
	int prox_data = -1;
	int ir_data = -1;

	/* Do proximity sensing with required scheme */
	status = isl29018_write_data(client, ISL29018_REG_ADD_COMMANDII,
			scheme, COMMANDII_SCHEME_MASK, COMMANDII_SCHEME_SHIFT);
	if (status) {
		dev_err(&client->dev, "Error in setting operating mode\n");
		return status;
	}

	prox_data = isl29018_read_sensor_input(client,
					COMMMAND1_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(client,
				COMMMAND1_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;
}

/* Sysfs interface */
/* range */
static ssize_t show_range(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct isl29018_chip *chip = iio_priv(indio_dev);

	return sprintf(buf, "%u\n", chip->range);
}

static ssize_t store_range(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct isl29018_chip *chip = iio_priv(indio_dev);
	struct i2c_client *client = chip->client;
	int status;
	unsigned long lval;
	unsigned int new_range;

	if (strict_strtoul(buf, 10, &lval))
		return -EINVAL;

	if (!(lval == 1000UL || lval == 4000UL ||
			lval == 16000UL || lval == 64000UL)) {
		dev_err(dev, "The range is not supported\n");
		return -EINVAL;
	}

	mutex_lock(&chip->lock);
	status = isl29018_set_range(client, lval, &new_range);
	if (status < 0) {
		mutex_unlock(&chip->lock);
		dev_err(dev, "Error in setting max range\n");
		return status;
	}
	chip->range = new_range;
	mutex_unlock(&chip->lock);

	return count;
}

/* resolution */
static ssize_t show_resolution(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct isl29018_chip *chip = iio_priv(indio_dev);

	return sprintf(buf, "%u\n", chip->adc_bit);
}

static ssize_t store_resolution(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct isl29018_chip *chip = iio_priv(indio_dev);
	struct i2c_client *client = chip->client;
	int status;
	unsigned long lval;
	unsigned int new_adc_bit;

	if (strict_strtoul(buf, 10, &lval))
		return -EINVAL;
	if (!(lval == 4 || lval == 8 || lval == 12 || lval == 16)) {
		dev_err(dev, "The resolution is not supported\n");
		return -EINVAL;
	}

	mutex_lock(&chip->lock);
	status = isl29018_set_resolution(client, lval, &new_adc_bit);
	if (status < 0) {
		mutex_unlock(&chip->lock);
		dev_err(dev, "Error in setting resolution\n");
		return status;
	}
	chip->adc_bit = new_adc_bit;
	mutex_unlock(&chip->lock);

	return count;
}

/* proximity scheme */
static ssize_t show_prox_infrared_supression(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct isl29018_chip *chip = iio_priv(indio_dev);

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

static ssize_t store_prox_infrared_supression(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct isl29018_chip *chip = iio_priv(indio_dev);
	unsigned long lval;

	if (strict_strtoul(buf, 10, &lval))
		return -EINVAL;
	if (!(lval == 0UL || lval == 1UL)) {
		dev_err(dev, "The mode is not supported\n");
		return -EINVAL;
	}

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

	return count;
}

/* Channel IO */
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 (mask == IIO_CHAN_INFO_CALIBSCALE && chan->type == IIO_LIGHT) {
		chip->lux_scale = val;
		ret = 0;
	}
	mutex_unlock(&chip->lock);

	return 0;
}

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);
	struct i2c_client *client = chip->client;

	mutex_lock(&chip->lock);
	switch (mask) {
	case IIO_CHAN_INFO_RAW:
	case IIO_CHAN_INFO_PROCESSED:
		switch (chan->type) {
		case IIO_LIGHT:
			ret = isl29018_read_lux(client, val);
			break;
		case IIO_INTENSITY:
			ret = isl29018_read_ir(client, val);
			break;
		case IIO_PROXIMITY:
			ret = isl29018_read_proximity_ir(client,
					chip->prox_scheme, val);
			break;
		default:
			break;
		}
		if (!ret)
			ret = IIO_VAL_INT;
		break;
	case IIO_CHAN_INFO_CALIBSCALE:
		if (chan->type == IIO_LIGHT) {
			*val = chip->lux_scale;
			ret = IIO_VAL_INT;
		}
		break;
	default:
		break;
	}
	mutex_unlock(&chip->lock);
	return ret;
}

static const struct iio_chan_spec isl29018_channels[] = {
	{
		.type = IIO_LIGHT,
		.indexed = 1,
		.channel = 0,
		.info_mask = IIO_CHAN_INFO_PROCESSED_SEPARATE_BIT |
		IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT,
	}, {
		.type = IIO_INTENSITY,
		.modified = 1,
		.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT,
		.channel2 = IIO_MOD_LIGHT_IR,
	}, {
		/* Unindexed in current ABI.  But perhaps it should be. */
		.type = IIO_PROXIMITY,
		.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT,
	}
};

static IIO_DEVICE_ATTR(range, S_IRUGO | S_IWUSR, show_range, store_range, 0);
static IIO_CONST_ATTR(range_available, "1000 4000 16000 64000");
static IIO_CONST_ATTR(adc_resolution_available, "4 8 12 16");
static IIO_DEVICE_ATTR(adc_resolution, S_IRUGO | S_IWUSR,
					show_resolution, store_resolution, 0);
static IIO_DEVICE_ATTR(proximity_on_chip_ambient_infrared_supression,
					S_IRUGO | S_IWUSR,
					show_prox_infrared_supression,
					store_prox_infrared_supression, 0);

#define ISL29018_DEV_ATTR(name) (&iio_dev_attr_##name.dev_attr.attr)
#define ISL29018_CONST_ATTR(name) (&iio_const_attr_##name.dev_attr.attr)
static struct attribute *isl29018_attributes[] = {
	ISL29018_DEV_ATTR(range),
	ISL29018_CONST_ATTR(range_available),
	ISL29018_DEV_ATTR(adc_resolution),
	ISL29018_CONST_ATTR(adc_resolution_available),
	ISL29018_DEV_ATTR(proximity_on_chip_ambient_infrared_supression),
	NULL
};

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

static int isl29018_chip_init(struct i2c_client *client)
{
	struct isl29018_chip *chip = iio_priv(i2c_get_clientdata(client));
	int status;
	int new_adc_bit;
	unsigned int new_range;

	memset(chip->reg_cache, 0, sizeof(chip->reg_cache));

	/* 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 = isl29018_write_data(client, ISL29018_REG_TEST, 0,
				ISL29018_TEST_MASK, ISL29018_TEST_SHIFT);
	if (status < 0) {
		dev_err(&client->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 = isl29018_write_data(client, ISL29018_REG_ADD_COMMAND1, 0,
				0xff, 0);
	if (status < 0) {
		dev_err(&client->dev, "Failed to clear isl29018 CMD1 reg."
					"(%d)\n", status);
		return status;
	}

	msleep(1);	/* per data sheet, page 10 */

	/* set defaults */
	status = isl29018_set_range(client, chip->range, &new_range);
	if (status < 0) {
		dev_err(&client->dev, "Init of isl29018 fails\n");
		return status;
	}

	status = isl29018_set_resolution(client, chip->adc_bit,
						&new_adc_bit);

	return 0;
}

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

static int __devinit isl29018_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	struct isl29018_chip *chip;
	struct iio_dev *indio_dev;
	int err;

	indio_dev = iio_allocate_device(sizeof(*chip));
	if (indio_dev == NULL) {
		dev_err(&client->dev, "iio allocation fails\n");
		err = -ENOMEM;
		goto exit;
	}
	chip = iio_priv(indio_dev);

	i2c_set_clientdata(client, indio_dev);
	chip->client = client;

	mutex_init(&chip->lock);

	chip->lux_scale = 1;
	chip->range = 1000;
	chip->adc_bit = 16;

	err = isl29018_chip_init(client);
	if (err)
		goto exit_iio_free;

	indio_dev->info = &isl29108_info;
	indio_dev->channels = isl29018_channels;
	indio_dev->num_channels = ARRAY_SIZE(isl29018_channels);
	indio_dev->name = id->name;
	indio_dev->dev.parent = &client->dev;
	indio_dev->modes = INDIO_DIRECT_MODE;
	err = iio_device_register(indio_dev);
	if (err) {
		dev_err(&client->dev, "iio registration fails\n");
		goto exit_iio_free;
	}

	return 0;
exit_iio_free:
	iio_free_device(indio_dev);
exit:
	return err;
}

static int __devexit isl29018_remove(struct i2c_client *client)
{
	struct iio_dev *indio_dev = i2c_get_clientdata(client);

	dev_dbg(&client->dev, "%s()\n", __func__);
	iio_device_unregister(indio_dev);
	iio_free_device(indio_dev);

	return 0;
}

static const struct i2c_device_id isl29018_id[] = {
	{"isl29018", 0},
	{}
};

MODULE_DEVICE_TABLE(i2c, isl29018_id);

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

static struct i2c_driver isl29018_driver = {
	.class	= I2C_CLASS_HWMON,
	.driver	 = {
			.name = "isl29018",
			.owner = THIS_MODULE,
			.of_match_table = isl29018_of_match,
		    },
	.probe	 = isl29018_probe,
	.remove	 = __devexit_p(isl29018_remove),
	.id_table = isl29018_id,
};
module_i2c_driver(isl29018_driver);

MODULE_DESCRIPTION("ISL29018 Ambient Light Sensor driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
94042874 RK	1	/*
	2	* A iio driver for the light sensor ISL 29018.
	3	*
	4	* IIO driver for monitoring ambient light intensity in luxi, proximity
	5	* sensing and infrared sensing.
	6	*
	7	* Copyright (c) 2010, NVIDIA Corporation.
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful, but WITHOUT
	15	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	16	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	17	* more details.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	22	*/
	23
	24	#include <linux/module.h>
	25	#include <linux/i2c.h>
	26	#include <linux/err.h>
	27	#include <linux/mutex.h>
	28	#include <linux/delay.h>
	29	#include <linux/slab.h>
	30	#include "../iio.h"
9dd1cb30	31	#include "../sysfs.h"
94042874 RK	32	#define CONVERSION_TIME_MS 100
	33
	34	#define ISL29018_REG_ADD_COMMAND1 0x00
	35	#define COMMMAND1_OPMODE_SHIFT 5
	36	#define COMMMAND1_OPMODE_MASK (7 << COMMMAND1_OPMODE_SHIFT)
	37	#define COMMMAND1_OPMODE_POWER_DOWN 0
	38	#define COMMMAND1_OPMODE_ALS_ONCE 1
	39	#define COMMMAND1_OPMODE_IR_ONCE 2
	40	#define COMMMAND1_OPMODE_PROX_ONCE 3
	41
	42	#define ISL29018_REG_ADD_COMMANDII 0x01
	43	#define COMMANDII_RESOLUTION_SHIFT 2
	44	#define COMMANDII_RESOLUTION_MASK (0x3 << COMMANDII_RESOLUTION_SHIFT)
	45
	46	#define COMMANDII_RANGE_SHIFT 0
	47	#define COMMANDII_RANGE_MASK (0x3 << COMMANDII_RANGE_SHIFT)
	48
	49	#define COMMANDII_SCHEME_SHIFT 7
	50	#define COMMANDII_SCHEME_MASK (0x1 << COMMANDII_SCHEME_SHIFT)
	51
	52	#define ISL29018_REG_ADD_DATA_LSB 0x02
	53	#define ISL29018_REG_ADD_DATA_MSB 0x03
25d7315a	54	#define ISL29018_MAX_REGS (ISL29018_REG_ADD_DATA_MSB+1)
94042874	55
176f9f29 GG	56	#define ISL29018_REG_TEST 0x08
	57	#define ISL29018_TEST_SHIFT 0
	58	#define ISL29018_TEST_MASK (0xFF << ISL29018_TEST_SHIFT)
	59
94042874	60	struct isl29018_chip {
94042874 RK	61	struct i2c_client *client;
94042874 RK	62	struct mutex lock;
6d1ad0f8	63	unsigned int lux_scale;
94042874 RK	64	unsigned int range;
	65	unsigned int adc_bit;
	66	int prox_scheme;
	67	u8 reg_cache[ISL29018_MAX_REGS];
	68	};
	69
	70	static int isl29018_write_data(struct i2c_client *client, u8 reg,
	71	u8 val, u8 mask, u8 shift)
	72	{
25d7315a JC	73	u8 regval = val;
25d7315a JC	74	int ret;
152d52cf	75	struct isl29018_chip *chip = iio_priv(i2c_get_clientdata(client));
94042874	76
25d7315a JC	77	/* don't cache or mask REG_TEST */
	78	if (reg < ISL29018_MAX_REGS) {
	79	regval = chip->reg_cache[reg];
	80	regval &= ~mask;
	81	regval \|= val << shift;
	82	}
94042874 RK	83
	84	ret = i2c_smbus_write_byte_data(client, reg, regval);
	85	if (ret) {
	86	dev_err(&client->dev, "Write to device fails status %x\n", ret);
25d7315a JC	87	} else {
	88	/* don't update cache on err */
	89	if (reg < ISL29018_MAX_REGS)
	90	chip->reg_cache[reg] = regval;
94042874	91	}
94042874	92
25d7315a	93	return ret;
94042874 RK	94	}
	95
	96	static int isl29018_set_range(struct i2c_client *client, unsigned long range,
	97	unsigned int *new_range)
	98	{
	99	static const unsigned long supp_ranges[] = {1000, 4000, 16000, 64000};
	100	int i;
	101
	102	for (i = 0; i < ARRAY_SIZE(supp_ranges); ++i) {
	103	if (range <= supp_ranges[i]) {
	104	*new_range = (unsigned int)supp_ranges[i];
	105	break;
	106	}
	107	}
	108
	109	if (i >= ARRAY_SIZE(supp_ranges))
	110	return -EINVAL;
	111
	112	return isl29018_write_data(client, ISL29018_REG_ADD_COMMANDII,
	113	i, COMMANDII_RANGE_MASK, COMMANDII_RANGE_SHIFT);
	114	}
	115
	116	static int isl29018_set_resolution(struct i2c_client *client,
	117	unsigned long adcbit, unsigned int *conf_adc_bit)
	118	{
	119	static const unsigned long supp_adcbit[] = {16, 12, 8, 4};
	120	int i;
	121
	122	for (i = 0; i < ARRAY_SIZE(supp_adcbit); ++i) {
	123	if (adcbit >= supp_adcbit[i]) {
	124	*conf_adc_bit = (unsigned int)supp_adcbit[i];
	125	break;
	126	}
	127	}
	128
	129	if (i >= ARRAY_SIZE(supp_adcbit))
	130	return -EINVAL;
	131
	132	return isl29018_write_data(client, ISL29018_REG_ADD_COMMANDII,
	133	i, COMMANDII_RESOLUTION_MASK,
	134	COMMANDII_RESOLUTION_SHIFT);
	135	}
	136
	137	static int isl29018_read_sensor_input(struct i2c_client *client, int mode)
	138	{
	139	int status;
	140	int lsb;
	141	int msb;
	142
	143	/* Set mode */
	144	status = isl29018_write_data(client, ISL29018_REG_ADD_COMMAND1,
	145	mode, COMMMAND1_OPMODE_MASK, COMMMAND1_OPMODE_SHIFT);
	146	if (status) {
	147	dev_err(&client->dev, "Error in setting operating mode\n");
	148	return status;
	149	}
	150	msleep(CONVERSION_TIME_MS);
	151	lsb = i2c_smbus_read_byte_data(client, ISL29018_REG_ADD_DATA_LSB);
	152	if (lsb < 0) {
	153	dev_err(&client->dev, "Error in reading LSB DATA\n");
	154	return lsb;
	155	}
	156
	157	msb = i2c_smbus_read_byte_data(client, ISL29018_REG_ADD_DATA_MSB);
158	if (msb < 0) {
159	dev_err(&client->dev, "Error in reading MSB DATA\n");
160	return msb;
161	}
162	dev_vdbg(&client->dev, "MSB 0x%x and LSB 0x%x\n", msb, lsb);
163
164	return (msb << 8) \| lsb;
165	}
166
167	static int isl29018_read_lux(struct i2c_client client, int lux)
168	{
169	int lux_data;
152d52cf	170	struct isl29018_chip *chip = iio_priv(i2c_get_clientdata(client));
94042874 RK	171
	172	lux_data = isl29018_read_sensor_input(client,
	173	COMMMAND1_OPMODE_ALS_ONCE);
	174
	175	if (lux_data < 0)
	176	return lux_data;
	177
6d1ad0f8	178	lux = (lux_data chip->range * chip->lux_scale) >> chip->adc_bit;
94042874 RK	179
	180	return 0;
	181	}
	182
	183	static int isl29018_read_ir(struct i2c_client client, int ir)
	184	{
	185	int ir_data;
	186
	187	ir_data = isl29018_read_sensor_input(client, COMMMAND1_OPMODE_IR_ONCE);
	188
	189	if (ir_data < 0)
	190	return ir_data;
	191
	192	*ir = ir_data;
	193
	194	return 0;
	195	}
	196
	197	static int isl29018_read_proximity_ir(struct i2c_client *client, int scheme,
	198	int *near_ir)
	199	{
	200	int status;
	201	int prox_data = -1;
	202	int ir_data = -1;
	203
	204	/* Do proximity sensing with required scheme */
	205	status = isl29018_write_data(client, ISL29018_REG_ADD_COMMANDII,
	206	scheme, COMMANDII_SCHEME_MASK, COMMANDII_SCHEME_SHIFT);
	207	if (status) {
	208	dev_err(&client->dev, "Error in setting operating mode\n");
	209	return status;
	210	}
	211
	212	prox_data = isl29018_read_sensor_input(client,
	213	COMMMAND1_OPMODE_PROX_ONCE);
	214	if (prox_data < 0)
	215	return prox_data;
	216
	217	if (scheme == 1) {
	218	*near_ir = prox_data;
	219	return 0;
	220	}
	221
	222	ir_data = isl29018_read_sensor_input(client,
	223	COMMMAND1_OPMODE_IR_ONCE);
	224
	225	if (ir_data < 0)
	226	return ir_data;
	227
	228	if (prox_data >= ir_data)
	229	*near_ir = prox_data - ir_data;
	230	else
	231	*near_ir = 0;
	232
	233	return 0;
	234	}
	235
94042874 RK	236	/* Sysfs interface */
	237	/* range */
	238	static ssize_t show_range(struct device *dev,
	239	struct device_attribute attr, char buf)
	240	{
	241	struct iio_dev *indio_dev = dev_get_drvdata(dev);
927afbec	242	struct isl29018_chip *chip = iio_priv(indio_dev);
94042874 RK	243
	244	return sprintf(buf, "%u\n", chip->range);
	245	}
	246
	247	static ssize_t store_range(struct device *dev,
	248	struct device_attribute attr, const char buf, size_t count)
	249	{
	250	struct iio_dev *indio_dev = dev_get_drvdata(dev);
927afbec	251	struct isl29018_chip *chip = iio_priv(indio_dev);
94042874 RK	252	struct i2c_client *client = chip->client;
	253	int status;
	254	unsigned long lval;
	255	unsigned int new_range;
	256
	257	if (strict_strtoul(buf, 10, &lval))
	258	return -EINVAL;
	259
	260	if (!(lval == 1000UL \|\| lval == 4000UL \|\|
	261	lval == 16000UL \|\| lval == 64000UL)) {
	262	dev_err(dev, "The range is not supported\n");
	263	return -EINVAL;
	264	}
	265
	266	mutex_lock(&chip->lock);
	267	status = isl29018_set_range(client, lval, &new_range);
	268	if (status < 0) {
	269	mutex_unlock(&chip->lock);
	270	dev_err(dev, "Error in setting max range\n");
	271	return status;
	272	}
	273	chip->range = new_range;
	274	mutex_unlock(&chip->lock);
	275
	276	return count;
	277	}
	278
	279	/* resolution */
	280	static ssize_t show_resolution(struct device *dev,
	281	struct device_attribute attr, char buf)
	282	{
	283	struct iio_dev *indio_dev = dev_get_drvdata(dev);
927afbec	284	struct isl29018_chip *chip = iio_priv(indio_dev);
94042874 RK	285
	286	return sprintf(buf, "%u\n", chip->adc_bit);
	287	}
	288
	289	static ssize_t store_resolution(struct device *dev,
	290	struct device_attribute attr, const char buf, size_t count)
	291	{
	292	struct iio_dev *indio_dev = dev_get_drvdata(dev);
927afbec	293	struct isl29018_chip *chip = iio_priv(indio_dev);
94042874 RK	294	struct i2c_client *client = chip->client;
	295	int status;
	296	unsigned long lval;
	297	unsigned int new_adc_bit;
	298
	299	if (strict_strtoul(buf, 10, &lval))
	300	return -EINVAL;
	301	if (!(lval == 4 \|\| lval == 8 \|\| lval == 12 \|\| lval == 16)) {
	302	dev_err(dev, "The resolution is not supported\n");
	303	return -EINVAL;
	304	}
	305
	306	mutex_lock(&chip->lock);
	307	status = isl29018_set_resolution(client, lval, &new_adc_bit);
	308	if (status < 0) {
	309	mutex_unlock(&chip->lock);
	310	dev_err(dev, "Error in setting resolution\n");
	311	return status;
	312	}
	313	chip->adc_bit = new_adc_bit;
	314	mutex_unlock(&chip->lock);
	315
	316	return count;
	317	}
	318
	319	/* proximity scheme */
	320	static ssize_t show_prox_infrared_supression(struct device *dev,
	321	struct device_attribute attr, char buf)
	322	{
	323	struct iio_dev *indio_dev = dev_get_drvdata(dev);
927afbec	324	struct isl29018_chip *chip = iio_priv(indio_dev);
94042874 RK	325
	326	/* return the "proximity scheme" i.e. if the chip does on chip
	327	infrared supression (1 means perform on chip supression) */
	328	return sprintf(buf, "%d\n", chip->prox_scheme);
	329	}
	330
	331	static ssize_t store_prox_infrared_supression(struct device *dev,
	332	struct device_attribute attr, const char buf, size_t count)
	333	{
	334	struct iio_dev *indio_dev = dev_get_drvdata(dev);
927afbec	335	struct isl29018_chip *chip = iio_priv(indio_dev);
94042874 RK	336	unsigned long lval;
	337
	338	if (strict_strtoul(buf, 10, &lval))
	339	return -EINVAL;
	340	if (!(lval == 0UL \|\| lval == 1UL)) {
	341	dev_err(dev, "The mode is not supported\n");
	342	return -EINVAL;
	343	}
	344
	345	/* get the "proximity scheme" i.e. if the chip does on chip
	346	infrared supression (1 means perform on chip supression) */
	347	mutex_lock(&chip->lock);
	348	chip->prox_scheme = (int)lval;
	349	mutex_unlock(&chip->lock);
	350
	351	return count;
	352	}
	353
01e57c57 BF	354	/* Channel IO */
	355	static int isl29018_write_raw(struct iio_dev *indio_dev,
	356	struct iio_chan_spec const *chan,
	357	int val,
	358	int val2,
	359	long mask)
94042874	360	{
01e57c57 BF	361	struct isl29018_chip *chip = iio_priv(indio_dev);
01e57c57 BF	362	int ret = -EINVAL;
94042874	363
01e57c57	364	mutex_lock(&chip->lock);
c8a9f805	365	if (mask == IIO_CHAN_INFO_CALIBSCALE && chan->type == IIO_LIGHT) {
01e57c57 BF	366	chip->lux_scale = val;
	367	ret = 0;
	368	}
	369	mutex_unlock(&chip->lock);
	370
	371	return 0;
94042874 RK	372	}
94042874 RK	373
01e57c57 BF	374	static int isl29018_read_raw(struct iio_dev *indio_dev,
	375	struct iio_chan_spec const *chan,
	376	int *val,
	377	int *val2,
	378	long mask)
94042874	379	{
01e57c57 BF	380	int ret = -EINVAL;
	381	struct isl29018_chip *chip = iio_priv(indio_dev);
	382	struct i2c_client *client = chip->client;
	383
	384	mutex_lock(&chip->lock);
	385	switch (mask) {
90354d00 JC	386	case IIO_CHAN_INFO_RAW:
90354d00 JC	387	case IIO_CHAN_INFO_PROCESSED:
01e57c57 BF	388	switch (chan->type) {
	389	case IIO_LIGHT:
	390	ret = isl29018_read_lux(client, val);
	391	break;
	392	case IIO_INTENSITY:
	393	ret = isl29018_read_ir(client, val);
	394	break;
	395	case IIO_PROXIMITY:
	396	ret = isl29018_read_proximity_ir(client,
	397	chip->prox_scheme, val);
	398	break;
	399	default:
	400	break;
	401	}
	402	if (!ret)
	403	ret = IIO_VAL_INT;
	404	break;
c8a9f805	405	case IIO_CHAN_INFO_CALIBSCALE:
01e57c57 BF	406	if (chan->type == IIO_LIGHT) {
	407	*val = chip->lux_scale;
	408	ret = IIO_VAL_INT;
	409	}
	410	break;
	411	default:
	412	break;
	413	}
	414	mutex_unlock(&chip->lock);
	415	return ret;
94042874 RK	416	}
94042874 RK	417
01e57c57 BF	418	static const struct iio_chan_spec isl29018_channels[] = {
	419	{
	420	.type = IIO_LIGHT,
	421	.indexed = 1,
	422	.channel = 0,
90354d00 JC	423	.info_mask = IIO_CHAN_INFO_PROCESSED_SEPARATE_BIT \|
90354d00 JC	424	IIO_CHAN_INFO_CALIBSCALE_SEPARATE_BIT,
01e57c57 BF	425	}, {
	426	.type = IIO_INTENSITY,
	427	.modified = 1,
90354d00	428	.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT,
01e57c57 BF	429	.channel2 = IIO_MOD_LIGHT_IR,
	430	}, {
	431	/* Unindexed in current ABI. But perhaps it should be. */
	432	.type = IIO_PROXIMITY,
90354d00	433	.info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT,
01e57c57 BF	434	}
	435	};
	436
94042874 RK	437	static IIO_DEVICE_ATTR(range, S_IRUGO \| S_IWUSR, show_range, store_range, 0);
	438	static IIO_CONST_ATTR(range_available, "1000 4000 16000 64000");
	439	static IIO_CONST_ATTR(adc_resolution_available, "4 8 12 16");
	440	static IIO_DEVICE_ATTR(adc_resolution, S_IRUGO \| S_IWUSR,
	441	show_resolution, store_resolution, 0);
	442	static IIO_DEVICE_ATTR(proximity_on_chip_ambient_infrared_supression,
	443	S_IRUGO \| S_IWUSR,
	444	show_prox_infrared_supression,
	445	store_prox_infrared_supression, 0);
94042874 RK	446
	447	#define ISL29018_DEV_ATTR(name) (&iio_dev_attr_##name.dev_attr.attr)
	448	#define ISL29018_CONST_ATTR(name) (&iio_const_attr_##name.dev_attr.attr)
	449	static struct attribute *isl29018_attributes[] = {
94042874 RK	450	ISL29018_DEV_ATTR(range),
	451	ISL29018_CONST_ATTR(range_available),
	452	ISL29018_DEV_ATTR(adc_resolution),
	453	ISL29018_CONST_ATTR(adc_resolution_available),
	454	ISL29018_DEV_ATTR(proximity_on_chip_ambient_infrared_supression),
94042874 RK	455	NULL
	456	};
	457
	458	static const struct attribute_group isl29108_group = {
	459	.attrs = isl29018_attributes,
	460	};
	461
	462	static int isl29018_chip_init(struct i2c_client *client)
	463	{
152d52cf	464	struct isl29018_chip *chip = iio_priv(i2c_get_clientdata(client));
94042874 RK	465	int status;
	466	int new_adc_bit;
	467	unsigned int new_range;
	468
	469	memset(chip->reg_cache, 0, sizeof(chip->reg_cache));
	470
176f9f29 GG	471	/* Code added per Intersil Application Note 1534:
	472	* When VDD sinks to approximately 1.8V or below, some of
	473	* the part's registers may change their state. When VDD
	474	* recovers to 2.25V (or greater), the part may thus be in an
	475	* unknown mode of operation. The user can return the part to
	476	* a known mode of operation either by (a) setting VDD = 0V for
	477	* 1 second or more and then powering back up with a slew rate
	478	* of 0.5V/ms or greater, or (b) via I2C disable all ALS/PROX
	479	* conversions, clear the test registers, and then rewrite all
	480	* registers to the desired values.
	481	* ...
	482	* FOR ISL29011, ISL29018, ISL29021, ISL29023
	483	* 1. Write 0x00 to register 0x08 (TEST)
	484	* 2. Write 0x00 to register 0x00 (CMD1)
	485	* 3. Rewrite all registers to the desired values
	486	*
	487	* ISL29018 Data Sheet (FN6619.1, Feb 11, 2010) essentially says
	488	* the same thing EXCEPT the data sheet asks for a 1ms delay after
	489	* writing the CMD1 register.
	490	*/
	491	status = isl29018_write_data(client, ISL29018_REG_TEST, 0,
	492	ISL29018_TEST_MASK, ISL29018_TEST_SHIFT);
	493	if (status < 0) {
	494	dev_err(&client->dev, "Failed to clear isl29018 TEST reg."
	495	"(%d)\n", status);
	496	return status;
	497	}
	498
	499	/* See Intersil AN1534 comments above.
	500	* "Operating Mode" (COMMAND1) register is reprogrammed when
	501	* data is read from the device.
	502	*/
	503	status = isl29018_write_data(client, ISL29018_REG_ADD_COMMAND1, 0,
	504	0xff, 0);
	505	if (status < 0) {
	506	dev_err(&client->dev, "Failed to clear isl29018 CMD1 reg."
	507	"(%d)\n", status);
	508	return status;
	509	}
	510
	511	msleep(1); /* per data sheet, page 10 */
	512
94042874 RK	513	/* set defaults */
	514	status = isl29018_set_range(client, chip->range, &new_range);
	515	if (status < 0) {
	516	dev_err(&client->dev, "Init of isl29018 fails\n");
	517	return status;
	518	}
	519
	520	status = isl29018_set_resolution(client, chip->adc_bit,
	521	&new_adc_bit);
	522
	523	return 0;
	524	}
	525
6fe8135f JC	526	static const struct iio_info isl29108_info = {
	527	.attrs = &isl29108_group,
	528	.driver_module = THIS_MODULE,
01e57c57 BF	529	.read_raw = &isl29018_read_raw,
01e57c57 BF	530	.write_raw = &isl29018_write_raw,
6fe8135f JC	531	};
6fe8135f JC	532
94042874 RK	533	static int __devinit isl29018_probe(struct i2c_client *client,
	534	const struct i2c_device_id *id)
	535	{
	536	struct isl29018_chip *chip;
927afbec	537	struct iio_dev *indio_dev;
94042874 RK	538	int err;
94042874 RK	539
927afbec JC	540	indio_dev = iio_allocate_device(sizeof(*chip));
	541	if (indio_dev == NULL) {
	542	dev_err(&client->dev, "iio allocation fails\n");
94042874 RK	543	err = -ENOMEM;
	544	goto exit;
	545	}
927afbec	546	chip = iio_priv(indio_dev);
94042874	547
927afbec	548	i2c_set_clientdata(client, indio_dev);
94042874 RK	549	chip->client = client;
	550
	551	mutex_init(&chip->lock);
	552
6d1ad0f8	553	chip->lux_scale = 1;
94042874 RK	554	chip->range = 1000;
	555	chip->adc_bit = 16;
	556
	557	err = isl29018_chip_init(client);
	558	if (err)
927afbec	559	goto exit_iio_free;
94042874	560
927afbec	561	indio_dev->info = &isl29108_info;
01e57c57 BF	562	indio_dev->channels = isl29018_channels;
01e57c57 BF	563	indio_dev->num_channels = ARRAY_SIZE(isl29018_channels);
927afbec JC	564	indio_dev->name = id->name;
	565	indio_dev->dev.parent = &client->dev;
	566	indio_dev->modes = INDIO_DIRECT_MODE;
	567	err = iio_device_register(indio_dev);
94042874 RK	568	if (err) {
	569	dev_err(&client->dev, "iio registration fails\n");
	570	goto exit_iio_free;
	571	}
	572
	573	return 0;
	574	exit_iio_free:
927afbec	575	iio_free_device(indio_dev);
94042874 RK	576	exit:
	577	return err;
	578	}
	579
	580	static int __devexit isl29018_remove(struct i2c_client *client)
	581	{
927afbec	582	struct iio_dev *indio_dev = i2c_get_clientdata(client);
94042874 RK	583
94042874 RK	584	dev_dbg(&client->dev, "%s()\n", __func__);
927afbec	585	iio_device_unregister(indio_dev);
d2fffd6c	586	iio_free_device(indio_dev);
94042874 RK	587
	588	return 0;
	589	}
	590
	591	static const struct i2c_device_id isl29018_id[] = {
	592	{"isl29018", 0},
	593	{}
	594	};
	595
	596	MODULE_DEVICE_TABLE(i2c, isl29018_id);
	597
4ee19524	598	static const struct of_device_id isl29018_of_match[] = {
610202dd	599	{ .compatible = "isil,isl29018", },
4ee19524 OJ	600	{ },
	601	};
	602	MODULE_DEVICE_TABLE(of, isl29018_of_match);
	603
94042874 RK	604	static struct i2c_driver isl29018_driver = {
	605	.class = I2C_CLASS_HWMON,
	606	.driver = {
	607	.name = "isl29018",
	608	.owner = THIS_MODULE,
4ee19524	609	.of_match_table = isl29018_of_match,
94042874 RK	610	},
	611	.probe = isl29018_probe,
	612	.remove = __devexit_p(isl29018_remove),
	613	.id_table = isl29018_id,
	614	};
6e5af184	615	module_i2c_driver(isl29018_driver);
94042874 RK	616
	617	MODULE_DESCRIPTION("ISL29018 Ambient Light Sensor driver");
	618	MODULE_LICENSE("GPL");