[linux-2.6-block.git] / drivers / iio / light / cm3323.c

/*
 * CM3323 - Capella Color Light Sensor
 *
 * Copyright (c) 2015, Intel Corporation.
 *
 * This file is subject to the terms and conditions of version 2 of
 * the GNU General Public License.  See the file COPYING in the main
 * directory of this archive for more details.
 *
 * IIO driver for CM3323 (7-bit I2C slave address 0x10)
 *
 * TODO: calibscale to correct the lens factor
 */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/mutex.h>

#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>

#define CM3323_DRV_NAME "cm3323"

#define CM3323_CMD_CONF		0x00
#define CM3323_CMD_RED_DATA	0x08
#define CM3323_CMD_GREEN_DATA	0x09
#define CM3323_CMD_BLUE_DATA	0x0A
#define CM3323_CMD_CLEAR_DATA	0x0B

#define CM3323_CONF_SD_BIT	BIT(0) /* sensor disable */
#define CM3323_CONF_AF_BIT	BIT(1) /* auto/manual force mode */
#define CM3323_CONF_IT_MASK	(BIT(4) | BIT(5) | BIT(6))
#define CM3323_CONF_IT_SHIFT	4

#define CM3323_INT_TIME_AVAILABLE "0.04 0.08 0.16 0.32 0.64 1.28"

static const struct {
	int val;
	int val2;
} cm3323_int_time[] = {
	{0, 40000},  /* 40 ms */
	{0, 80000},  /* 80 ms */
	{0, 160000}, /* 160 ms */
	{0, 320000}, /* 320 ms */
	{0, 640000}, /* 640 ms */
	{1, 280000}, /* 1280 ms */
};

struct cm3323_data {
	struct i2c_client *client;
	u16 reg_conf;
	struct mutex mutex;
};

#define CM3323_COLOR_CHANNEL(_color, _addr) { \
	.type = IIO_INTENSITY, \
	.modified = 1, \
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME), \
	.channel2 = IIO_MOD_LIGHT_##_color, \
	.address = _addr, \
}

static const struct iio_chan_spec cm3323_channels[] = {
	CM3323_COLOR_CHANNEL(RED, CM3323_CMD_RED_DATA),
	CM3323_COLOR_CHANNEL(GREEN, CM3323_CMD_GREEN_DATA),
	CM3323_COLOR_CHANNEL(BLUE, CM3323_CMD_BLUE_DATA),
	CM3323_COLOR_CHANNEL(CLEAR, CM3323_CMD_CLEAR_DATA),
};

static IIO_CONST_ATTR_INT_TIME_AVAIL(CM3323_INT_TIME_AVAILABLE);

static struct attribute *cm3323_attributes[] = {
	&iio_const_attr_integration_time_available.dev_attr.attr,
	NULL
};

static const struct attribute_group cm3323_attribute_group = {
	.attrs = cm3323_attributes,
};

static int cm3323_init(struct iio_dev *indio_dev)
{
	int ret;
	struct cm3323_data *data = iio_priv(indio_dev);

	ret = i2c_smbus_read_word_data(data->client, CM3323_CMD_CONF);
	if (ret < 0) {
		dev_err(&data->client->dev, "Error reading reg_conf\n");
		return ret;
	}

	/* enable sensor and set auto force mode */
	ret &= ~(CM3323_CONF_SD_BIT | CM3323_CONF_AF_BIT);

	ret = i2c_smbus_write_word_data(data->client, CM3323_CMD_CONF, ret);
	if (ret < 0) {
		dev_err(&data->client->dev, "Error writing reg_conf\n");
		return ret;
	}

	data->reg_conf = ret;

	return 0;
}

static void cm3323_disable(struct iio_dev *indio_dev)
{
	int ret;
	struct cm3323_data *data = iio_priv(indio_dev);

	ret = i2c_smbus_write_word_data(data->client, CM3323_CMD_CONF,
					CM3323_CONF_SD_BIT);
	if (ret < 0)
		dev_err(&data->client->dev, "Error writing reg_conf\n");
}

static int cm3323_set_it_bits(struct cm3323_data *data, int val, int val2)
{
	int i, ret;
	u16 reg_conf;

	for (i = 0; i < ARRAY_SIZE(cm3323_int_time); i++) {
		if (val == cm3323_int_time[i].val &&
		    val2 == cm3323_int_time[i].val2) {
			reg_conf = data->reg_conf & ~CM3323_CONF_IT_MASK;
			reg_conf |= i << CM3323_CONF_IT_SHIFT;

			ret = i2c_smbus_write_word_data(data->client,
							CM3323_CMD_CONF,
							reg_conf);
			if (ret < 0)
				return ret;

			data->reg_conf = reg_conf;
			return 0;
		}
	}
	return -EINVAL;
}

static int cm3323_get_it_bits(struct cm3323_data *data)
{
	int bits;

	bits = (data->reg_conf & CM3323_CONF_IT_MASK) >>
		CM3323_CONF_IT_SHIFT;

	if (bits >= ARRAY_SIZE(cm3323_int_time))
		return -EINVAL;
	return bits;
}

static int cm3323_read_raw(struct iio_dev *indio_dev,
			   struct iio_chan_spec const *chan, int *val,
			   int *val2, long mask)
{
	int i, ret;
	struct cm3323_data *data = iio_priv(indio_dev);

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		mutex_lock(&data->mutex);
		ret = i2c_smbus_read_word_data(data->client, chan->address);
		if (ret < 0) {
			mutex_unlock(&data->mutex);
			return ret;
		}
		*val = ret;
		mutex_unlock(&data->mutex);

		return IIO_VAL_INT;
	case IIO_CHAN_INFO_INT_TIME:
		mutex_lock(&data->mutex);
		i = cm3323_get_it_bits(data);
		if (i < 0) {
			mutex_unlock(&data->mutex);
			return -EINVAL;
		}

		*val = cm3323_int_time[i].val;
		*val2 = cm3323_int_time[i].val2;
		mutex_unlock(&data->mutex);

		return IIO_VAL_INT_PLUS_MICRO;
	default:
		return -EINVAL;
	}
}

static int cm3323_write_raw(struct iio_dev *indio_dev,
			    struct iio_chan_spec const *chan, int val,
			    int val2, long mask)
{
	struct cm3323_data *data = iio_priv(indio_dev);
	int ret;

	switch (mask) {
	case IIO_CHAN_INFO_INT_TIME:
		mutex_lock(&data->mutex);
		ret = cm3323_set_it_bits(data, val, val2);
		mutex_unlock(&data->mutex);

		return ret;
	default:
		return -EINVAL;
	}
}

static const struct iio_info cm3323_info = {
	.driver_module	= THIS_MODULE,
	.read_raw	= cm3323_read_raw,
	.write_raw	= cm3323_write_raw,
	.attrs		= &cm3323_attribute_group,
};

static int cm3323_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct cm3323_data *data;
	struct iio_dev *indio_dev;
	int ret;

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

	data = iio_priv(indio_dev);
	i2c_set_clientdata(client, indio_dev);
	data->client = client;

	mutex_init(&data->mutex);

	indio_dev->dev.parent = &client->dev;
	indio_dev->info = &cm3323_info;
	indio_dev->name = CM3323_DRV_NAME;
	indio_dev->channels = cm3323_channels;
	indio_dev->num_channels = ARRAY_SIZE(cm3323_channels);
	indio_dev->modes = INDIO_DIRECT_MODE;

	ret = cm3323_init(indio_dev);
	if (ret < 0) {
		dev_err(&client->dev, "cm3323 chip init failed\n");
		return ret;
	}
	ret = iio_device_register(indio_dev);
	if (ret < 0) {
		dev_err(&client->dev, "failed to register iio dev\n");
		goto err_init;
	}
	return 0;
err_init:
	cm3323_disable(indio_dev);
	return ret;
}

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

	iio_device_unregister(indio_dev);
	cm3323_disable(indio_dev);

	return 0;
}

static const struct i2c_device_id cm3323_id[] = {
	{"cm3323", 0},
	{}
};
MODULE_DEVICE_TABLE(i2c, cm3323_id);

static struct i2c_driver cm3323_driver = {
	.driver = {
		.name = CM3323_DRV_NAME,
	},
	.probe		= cm3323_probe,
	.remove		= cm3323_remove,
	.id_table	= cm3323_id,
};

module_i2c_driver(cm3323_driver);

MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
MODULE_DESCRIPTION("Capella CM3323 Color Light Sensor driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
8b054426 DB	1	/*
	2	* CM3323 - Capella Color Light Sensor
	3	*
	4	* Copyright (c) 2015, Intel Corporation.
	5	*
	6	* This file is subject to the terms and conditions of version 2 of
	7	* the GNU General Public License. See the file COPYING in the main
	8	* directory of this archive for more details.
	9	*
	10	* IIO driver for CM3323 (7-bit I2C slave address 0x10)
	11	*
	12	* TODO: calibscale to correct the lens factor
	13	*/
	14	#include <linux/module.h>
	15	#include <linux/init.h>
	16	#include <linux/i2c.h>
	17	#include <linux/mutex.h>
	18
	19	#include <linux/iio/iio.h>
	20	#include <linux/iio/sysfs.h>
	21
	22	#define CM3323_DRV_NAME "cm3323"
	23
	24	#define CM3323_CMD_CONF 0x00
	25	#define CM3323_CMD_RED_DATA 0x08
	26	#define CM3323_CMD_GREEN_DATA 0x09
	27	#define CM3323_CMD_BLUE_DATA 0x0A
	28	#define CM3323_CMD_CLEAR_DATA 0x0B
	29
	30	#define CM3323_CONF_SD_BIT BIT(0) /* sensor disable */
	31	#define CM3323_CONF_AF_BIT BIT(1) /* auto/manual force mode */
	32	#define CM3323_CONF_IT_MASK (BIT(4) \| BIT(5) \| BIT(6))
	33	#define CM3323_CONF_IT_SHIFT 4
	34
	35	#define CM3323_INT_TIME_AVAILABLE "0.04 0.08 0.16 0.32 0.64 1.28"
	36
	37	static const struct {
	38	int val;
	39	int val2;
	40	} cm3323_int_time[] = {
	41	{0, 40000}, /* 40 ms */
	42	{0, 80000}, /* 80 ms */
	43	{0, 160000}, /* 160 ms */
	44	{0, 320000}, /* 320 ms */
	45	{0, 640000}, /* 640 ms */
	46	{1, 280000}, /* 1280 ms */
	47	};
	48
	49	struct cm3323_data {
	50	struct i2c_client *client;
	51	u16 reg_conf;
	52	struct mutex mutex;
	53	};
	54
	55	#define CM3323_COLOR_CHANNEL(_color, _addr) { \
	56	.type = IIO_INTENSITY, \
	57	.modified = 1, \
	58	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
	59	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME), \
	60	.channel2 = IIO_MOD_LIGHT_##_color, \
	61	.address = _addr, \
	62	}
	63
	64	static const struct iio_chan_spec cm3323_channels[] = {
65	CM3323_COLOR_CHANNEL(RED, CM3323_CMD_RED_DATA),
66	CM3323_COLOR_CHANNEL(GREEN, CM3323_CMD_GREEN_DATA),
67	CM3323_COLOR_CHANNEL(BLUE, CM3323_CMD_BLUE_DATA),
68	CM3323_COLOR_CHANNEL(CLEAR, CM3323_CMD_CLEAR_DATA),
69	};
70
71	static IIO_CONST_ATTR_INT_TIME_AVAIL(CM3323_INT_TIME_AVAILABLE);
72
73	static struct attribute *cm3323_attributes[] = {
74	&iio_const_attr_integration_time_available.dev_attr.attr,
75	NULL
76	};
77
78	static const struct attribute_group cm3323_attribute_group = {
79	.attrs = cm3323_attributes,
80	};
81
82	static int cm3323_init(struct iio_dev *indio_dev)
83	{
84	int ret;
85	struct cm3323_data *data = iio_priv(indio_dev);
86
87	ret = i2c_smbus_read_word_data(data->client, CM3323_CMD_CONF);
88	if (ret < 0) {
89	dev_err(&data->client->dev, "Error reading reg_conf\n");
90	return ret;
91	}
92
93	/* enable sensor and set auto force mode */
94	ret &= ~(CM3323_CONF_SD_BIT \| CM3323_CONF_AF_BIT);
95
96	ret = i2c_smbus_write_word_data(data->client, CM3323_CMD_CONF, ret);
97	if (ret < 0) {
98	dev_err(&data->client->dev, "Error writing reg_conf\n");
99	return ret;
100	}
101
102	data->reg_conf = ret;
103
104	return 0;
105	}
106
107	static void cm3323_disable(struct iio_dev *indio_dev)
108	{
109	int ret;
110	struct cm3323_data *data = iio_priv(indio_dev);
111
112	ret = i2c_smbus_write_word_data(data->client, CM3323_CMD_CONF,
113	CM3323_CONF_SD_BIT);
114	if (ret < 0)
115	dev_err(&data->client->dev, "Error writing reg_conf\n");
116	}
117
118	static int cm3323_set_it_bits(struct cm3323_data *data, int val, int val2)
119	{
120	int i, ret;
121	u16 reg_conf;
122
123	for (i = 0; i < ARRAY_SIZE(cm3323_int_time); i++) {
124	if (val == cm3323_int_time[i].val &&
125	val2 == cm3323_int_time[i].val2) {
c288503b	126	reg_conf = data->reg_conf & ~CM3323_CONF_IT_MASK;
8b054426 DB	127	reg_conf \|= i << CM3323_CONF_IT_SHIFT;
	128
	129	ret = i2c_smbus_write_word_data(data->client,
	130	CM3323_CMD_CONF,
	131	reg_conf);
	132	if (ret < 0)
	133	return ret;
	134
	135	data->reg_conf = reg_conf;
	136	return 0;
	137	}
	138	}
	139	return -EINVAL;
	140	}
	141
	142	static int cm3323_get_it_bits(struct cm3323_data *data)
	143	{
	144	int bits;
	145
	146	bits = (data->reg_conf & CM3323_CONF_IT_MASK) >>
	147	CM3323_CONF_IT_SHIFT;
	148
	149	if (bits >= ARRAY_SIZE(cm3323_int_time))
	150	return -EINVAL;
	151	return bits;
	152	}
	153
	154	static int cm3323_read_raw(struct iio_dev *indio_dev,
	155	struct iio_chan_spec const chan, int val,
	156	int *val2, long mask)
	157	{
	158	int i, ret;
	159	struct cm3323_data *data = iio_priv(indio_dev);
	160
	161	switch (mask) {
	162	case IIO_CHAN_INFO_RAW:
	163	mutex_lock(&data->mutex);
	164	ret = i2c_smbus_read_word_data(data->client, chan->address);
	165	if (ret < 0) {
	166	mutex_unlock(&data->mutex);
	167	return ret;
	168	}
	169	*val = ret;
	170	mutex_unlock(&data->mutex);
	171
	172	return IIO_VAL_INT;
	173	case IIO_CHAN_INFO_INT_TIME:
	174	mutex_lock(&data->mutex);
	175	i = cm3323_get_it_bits(data);
	176	if (i < 0) {
	177	mutex_unlock(&data->mutex);
	178	return -EINVAL;
	179	}
	180
	181	*val = cm3323_int_time[i].val;
	182	*val2 = cm3323_int_time[i].val2;
	183	mutex_unlock(&data->mutex);
	184
	185	return IIO_VAL_INT_PLUS_MICRO;
	186	default:
	187	return -EINVAL;
	188	}
	189	}
	190
191	static int cm3323_write_raw(struct iio_dev *indio_dev,
192	struct iio_chan_spec const *chan, int val,
193	int val2, long mask)
194	{
195	struct cm3323_data *data = iio_priv(indio_dev);
196	int ret;
197
198	switch (mask) {
199	case IIO_CHAN_INFO_INT_TIME:
200	mutex_lock(&data->mutex);
201	ret = cm3323_set_it_bits(data, val, val2);
202	mutex_unlock(&data->mutex);
203
204	return ret;
205	default:
206	return -EINVAL;
207	}
208	}
209
210	static const struct iio_info cm3323_info = {
211	.driver_module = THIS_MODULE,
212	.read_raw = cm3323_read_raw,
213	.write_raw = cm3323_write_raw,
214	.attrs = &cm3323_attribute_group,
215	};
216
217	static int cm3323_probe(struct i2c_client *client,
218	const struct i2c_device_id *id)
219	{
220	struct cm3323_data *data;
221	struct iio_dev *indio_dev;
222	int ret;
223
224	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
225	if (!indio_dev)
226	return -ENOMEM;
227
228	data = iio_priv(indio_dev);
229	i2c_set_clientdata(client, indio_dev);
230	data->client = client;
231
232	mutex_init(&data->mutex);
233
234	indio_dev->dev.parent = &client->dev;
235	indio_dev->info = &cm3323_info;
236	indio_dev->name = CM3323_DRV_NAME;
237	indio_dev->channels = cm3323_channels;
238	indio_dev->num_channels = ARRAY_SIZE(cm3323_channels);
239	indio_dev->modes = INDIO_DIRECT_MODE;
240
241	ret = cm3323_init(indio_dev);
242	if (ret < 0) {
243	dev_err(&client->dev, "cm3323 chip init failed\n");
244	return ret;
245	}
246	ret = iio_device_register(indio_dev);
247	if (ret < 0) {
248	dev_err(&client->dev, "failed to register iio dev\n");
249	goto err_init;
250	}
251	return 0;
252	err_init:
253	cm3323_disable(indio_dev);
254	return ret;
255	}
256
257	static int cm3323_remove(struct i2c_client *client)
258	{
259	struct iio_dev *indio_dev = i2c_get_clientdata(client);
260
261	iio_device_unregister(indio_dev);
262	cm3323_disable(indio_dev);
263
264	return 0;
265	}
266
267	static const struct i2c_device_id cm3323_id[] = {
268	{"cm3323", 0},
269	{}
270	};
271	MODULE_DEVICE_TABLE(i2c, cm3323_id);
272
273	static struct i2c_driver cm3323_driver = {
274	.driver = {
275	.name = CM3323_DRV_NAME,
276	},
277	.probe = cm3323_probe,
278	.remove = cm3323_remove,
279	.id_table = cm3323_id,
280	};
281
282	module_i2c_driver(cm3323_driver);
283
284	MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
285	MODULE_DESCRIPTION("Capella CM3323 Color Light Sensor driver");
286	MODULE_LICENSE("GPL v2");