2 * A iio driver for the light sensor ISL 29018.
4 * IIO driver for monitoring ambient light intensity in luxi, proximity
5 * sensing and infrared sensing.
7 * Copyright (c) 2010, NVIDIA Corporation.
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.
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
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.
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>
32 #define CONVERSION_TIME_MS 100
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
42 #define ISL29018_REG_ADD_COMMANDII 0x01
43 #define COMMANDII_RESOLUTION_SHIFT 2
44 #define COMMANDII_RESOLUTION_MASK (0x3 << COMMANDII_RESOLUTION_SHIFT)
46 #define COMMANDII_RANGE_SHIFT 0
47 #define COMMANDII_RANGE_MASK (0x3 << COMMANDII_RANGE_SHIFT)
49 #define COMMANDII_SCHEME_SHIFT 7
50 #define COMMANDII_SCHEME_MASK (0x1 << COMMANDII_SCHEME_SHIFT)
52 #define ISL29018_REG_ADD_DATA_LSB 0x02
53 #define ISL29018_REG_ADD_DATA_MSB 0x03
54 #define ISL29018_MAX_REGS ISL29018_REG_ADD_DATA_MSB
56 struct isl29018_chip {
57 struct iio_dev *indio_dev;
58 struct i2c_client *client;
63 u8 reg_cache[ISL29018_MAX_REGS];
66 static int isl29018_write_data(struct i2c_client *client, u8 reg,
67 u8 val, u8 mask, u8 shift)
71 struct isl29018_chip *chip = i2c_get_clientdata(client);
73 regval = chip->reg_cache[reg];
75 regval |= val << shift;
77 ret = i2c_smbus_write_byte_data(client, reg, regval);
79 dev_err(&client->dev, "Write to device fails status %x\n", ret);
82 chip->reg_cache[reg] = regval;
87 static int isl29018_set_range(struct i2c_client *client, unsigned long range,
88 unsigned int *new_range)
90 static const unsigned long supp_ranges[] = {1000, 4000, 16000, 64000};
93 for (i = 0; i < ARRAY_SIZE(supp_ranges); ++i) {
94 if (range <= supp_ranges[i]) {
95 *new_range = (unsigned int)supp_ranges[i];
100 if (i >= ARRAY_SIZE(supp_ranges))
103 return isl29018_write_data(client, ISL29018_REG_ADD_COMMANDII,
104 i, COMMANDII_RANGE_MASK, COMMANDII_RANGE_SHIFT);
107 static int isl29018_set_resolution(struct i2c_client *client,
108 unsigned long adcbit, unsigned int *conf_adc_bit)
110 static const unsigned long supp_adcbit[] = {16, 12, 8, 4};
113 for (i = 0; i < ARRAY_SIZE(supp_adcbit); ++i) {
114 if (adcbit >= supp_adcbit[i]) {
115 *conf_adc_bit = (unsigned int)supp_adcbit[i];
120 if (i >= ARRAY_SIZE(supp_adcbit))
123 return isl29018_write_data(client, ISL29018_REG_ADD_COMMANDII,
124 i, COMMANDII_RESOLUTION_MASK,
125 COMMANDII_RESOLUTION_SHIFT);
128 static int isl29018_read_sensor_input(struct i2c_client *client, int mode)
135 status = isl29018_write_data(client, ISL29018_REG_ADD_COMMAND1,
136 mode, COMMMAND1_OPMODE_MASK, COMMMAND1_OPMODE_SHIFT);
138 dev_err(&client->dev, "Error in setting operating mode\n");
141 msleep(CONVERSION_TIME_MS);
142 lsb = i2c_smbus_read_byte_data(client, ISL29018_REG_ADD_DATA_LSB);
144 dev_err(&client->dev, "Error in reading LSB DATA\n");
148 msb = i2c_smbus_read_byte_data(client, ISL29018_REG_ADD_DATA_MSB);
150 dev_err(&client->dev, "Error in reading MSB DATA\n");
153 dev_vdbg(&client->dev, "MSB 0x%x and LSB 0x%x\n", msb, lsb);
155 return (msb << 8) | lsb;
158 static int isl29018_read_lux(struct i2c_client *client, int *lux)
161 struct isl29018_chip *chip = i2c_get_clientdata(client);
163 lux_data = isl29018_read_sensor_input(client,
164 COMMMAND1_OPMODE_ALS_ONCE);
169 *lux = (lux_data * chip->range) >> chip->adc_bit;
174 static int isl29018_read_ir(struct i2c_client *client, int *ir)
178 ir_data = isl29018_read_sensor_input(client, COMMMAND1_OPMODE_IR_ONCE);
188 static int isl29018_read_proximity_ir(struct i2c_client *client, int scheme,
195 /* Do proximity sensing with required scheme */
196 status = isl29018_write_data(client, ISL29018_REG_ADD_COMMANDII,
197 scheme, COMMANDII_SCHEME_MASK, COMMANDII_SCHEME_SHIFT);
199 dev_err(&client->dev, "Error in setting operating mode\n");
203 prox_data = isl29018_read_sensor_input(client,
204 COMMMAND1_OPMODE_PROX_ONCE);
209 *near_ir = prox_data;
213 ir_data = isl29018_read_sensor_input(client,
214 COMMMAND1_OPMODE_IR_ONCE);
219 if (prox_data >= ir_data)
220 *near_ir = prox_data - ir_data;
227 static ssize_t get_sensor_data(struct device *dev, char *buf, int mode)
229 struct iio_dev *indio_dev = dev_get_drvdata(dev);
230 struct isl29018_chip *chip = indio_dev->dev_data;
231 struct i2c_client *client = chip->client;
235 mutex_lock(&chip->lock);
237 case COMMMAND1_OPMODE_PROX_ONCE:
238 status = isl29018_read_proximity_ir(client,
239 chip->prox_scheme, &value);
242 case COMMMAND1_OPMODE_ALS_ONCE:
243 status = isl29018_read_lux(client, &value);
246 case COMMMAND1_OPMODE_IR_ONCE:
247 status = isl29018_read_ir(client, &value);
251 dev_err(&client->dev, "Mode %d is not supported\n", mode);
252 mutex_unlock(&chip->lock);
256 dev_err(&client->dev, "Error in Reading data");
257 mutex_unlock(&chip->lock);
261 mutex_unlock(&chip->lock);
263 return sprintf(buf, "%d\n", value);
266 /* Sysfs interface */
268 static ssize_t show_range(struct device *dev,
269 struct device_attribute *attr, char *buf)
271 struct iio_dev *indio_dev = dev_get_drvdata(dev);
272 struct isl29018_chip *chip = indio_dev->dev_data;
274 return sprintf(buf, "%u\n", chip->range);
277 static ssize_t store_range(struct device *dev,
278 struct device_attribute *attr, const char *buf, size_t count)
280 struct iio_dev *indio_dev = dev_get_drvdata(dev);
281 struct isl29018_chip *chip = indio_dev->dev_data;
282 struct i2c_client *client = chip->client;
285 unsigned int new_range;
287 if (strict_strtoul(buf, 10, &lval))
290 if (!(lval == 1000UL || lval == 4000UL ||
291 lval == 16000UL || lval == 64000UL)) {
292 dev_err(dev, "The range is not supported\n");
296 mutex_lock(&chip->lock);
297 status = isl29018_set_range(client, lval, &new_range);
299 mutex_unlock(&chip->lock);
300 dev_err(dev, "Error in setting max range\n");
303 chip->range = new_range;
304 mutex_unlock(&chip->lock);
310 static ssize_t show_resolution(struct device *dev,
311 struct device_attribute *attr, char *buf)
313 struct iio_dev *indio_dev = dev_get_drvdata(dev);
314 struct isl29018_chip *chip = indio_dev->dev_data;
316 return sprintf(buf, "%u\n", chip->adc_bit);
319 static ssize_t store_resolution(struct device *dev,
320 struct device_attribute *attr, const char *buf, size_t count)
322 struct iio_dev *indio_dev = dev_get_drvdata(dev);
323 struct isl29018_chip *chip = indio_dev->dev_data;
324 struct i2c_client *client = chip->client;
327 unsigned int new_adc_bit;
329 if (strict_strtoul(buf, 10, &lval))
331 if (!(lval == 4 || lval == 8 || lval == 12 || lval == 16)) {
332 dev_err(dev, "The resolution is not supported\n");
336 mutex_lock(&chip->lock);
337 status = isl29018_set_resolution(client, lval, &new_adc_bit);
339 mutex_unlock(&chip->lock);
340 dev_err(dev, "Error in setting resolution\n");
343 chip->adc_bit = new_adc_bit;
344 mutex_unlock(&chip->lock);
349 /* proximity scheme */
350 static ssize_t show_prox_infrared_supression(struct device *dev,
351 struct device_attribute *attr, char *buf)
353 struct iio_dev *indio_dev = dev_get_drvdata(dev);
354 struct isl29018_chip *chip = indio_dev->dev_data;
356 /* return the "proximity scheme" i.e. if the chip does on chip
357 infrared supression (1 means perform on chip supression) */
358 return sprintf(buf, "%d\n", chip->prox_scheme);
361 static ssize_t store_prox_infrared_supression(struct device *dev,
362 struct device_attribute *attr, const char *buf, size_t count)
364 struct iio_dev *indio_dev = dev_get_drvdata(dev);
365 struct isl29018_chip *chip = indio_dev->dev_data;
368 if (strict_strtoul(buf, 10, &lval))
370 if (!(lval == 0UL || lval == 1UL)) {
371 dev_err(dev, "The mode is not supported\n");
375 /* get the "proximity scheme" i.e. if the chip does on chip
376 infrared supression (1 means perform on chip supression) */
377 mutex_lock(&chip->lock);
378 chip->prox_scheme = (int)lval;
379 mutex_unlock(&chip->lock);
385 static ssize_t show_lux(struct device *dev,
386 struct device_attribute *devattr, char *buf)
388 return get_sensor_data(dev, buf, COMMMAND1_OPMODE_ALS_ONCE);
392 static ssize_t show_ir(struct device *dev,
393 struct device_attribute *devattr, char *buf)
395 return get_sensor_data(dev, buf, COMMMAND1_OPMODE_IR_ONCE);
398 /* Read nearest ir */
399 static ssize_t show_proxim_ir(struct device *dev,
400 struct device_attribute *devattr, char *buf)
402 return get_sensor_data(dev, buf, COMMMAND1_OPMODE_PROX_ONCE);
406 static ssize_t show_name(struct device *dev,
407 struct device_attribute *attr, char *buf)
409 struct iio_dev *indio_dev = dev_get_drvdata(dev);
410 struct isl29018_chip *chip = indio_dev->dev_data;
412 return sprintf(buf, "%s\n", chip->client->name);
415 static IIO_DEVICE_ATTR(range, S_IRUGO | S_IWUSR, show_range, store_range, 0);
416 static IIO_CONST_ATTR(range_available, "1000 4000 16000 64000");
417 static IIO_CONST_ATTR(adc_resolution_available, "4 8 12 16");
418 static IIO_DEVICE_ATTR(adc_resolution, S_IRUGO | S_IWUSR,
419 show_resolution, store_resolution, 0);
420 static IIO_DEVICE_ATTR(proximity_on_chip_ambient_infrared_supression,
422 show_prox_infrared_supression,
423 store_prox_infrared_supression, 0);
424 static IIO_DEVICE_ATTR(illuminance0_input, S_IRUGO, show_lux, NULL, 0);
425 static IIO_DEVICE_ATTR(intensity_infrared_raw, S_IRUGO, show_ir, NULL, 0);
426 static IIO_DEVICE_ATTR(proximity_raw, S_IRUGO, show_proxim_ir, NULL, 0);
427 static IIO_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
429 #define ISL29018_DEV_ATTR(name) (&iio_dev_attr_##name.dev_attr.attr)
430 #define ISL29018_CONST_ATTR(name) (&iio_const_attr_##name.dev_attr.attr)
431 static struct attribute *isl29018_attributes[] = {
432 ISL29018_DEV_ATTR(name),
433 ISL29018_DEV_ATTR(range),
434 ISL29018_CONST_ATTR(range_available),
435 ISL29018_DEV_ATTR(adc_resolution),
436 ISL29018_CONST_ATTR(adc_resolution_available),
437 ISL29018_DEV_ATTR(proximity_on_chip_ambient_infrared_supression),
438 ISL29018_DEV_ATTR(illuminance0_input),
439 ISL29018_DEV_ATTR(intensity_infrared_raw),
440 ISL29018_DEV_ATTR(proximity_raw),
444 static const struct attribute_group isl29108_group = {
445 .attrs = isl29018_attributes,
448 static int isl29018_chip_init(struct i2c_client *client)
450 struct isl29018_chip *chip = i2c_get_clientdata(client);
453 unsigned int new_range;
455 memset(chip->reg_cache, 0, sizeof(chip->reg_cache));
458 status = isl29018_set_range(client, chip->range, &new_range);
460 dev_err(&client->dev, "Init of isl29018 fails\n");
464 status = isl29018_set_resolution(client, chip->adc_bit,
470 static int __devinit isl29018_probe(struct i2c_client *client,
471 const struct i2c_device_id *id)
473 struct isl29018_chip *chip;
476 chip = kzalloc(sizeof(struct isl29018_chip), GFP_KERNEL);
478 dev_err(&client->dev, "Memory allocation fails\n");
483 i2c_set_clientdata(client, chip);
484 chip->client = client;
486 mutex_init(&chip->lock);
491 err = isl29018_chip_init(client);
495 chip->indio_dev = iio_allocate_device();
496 if (!chip->indio_dev) {
497 dev_err(&client->dev, "iio allocation fails\n");
500 chip->indio_dev->attrs = &isl29108_group;
501 chip->indio_dev->dev.parent = &client->dev;
502 chip->indio_dev->dev_data = (void *)(chip);
503 chip->indio_dev->driver_module = THIS_MODULE;
504 chip->indio_dev->modes = INDIO_DIRECT_MODE;
505 err = iio_device_register(chip->indio_dev);
507 dev_err(&client->dev, "iio registration fails\n");
513 iio_free_device(chip->indio_dev);
520 static int __devexit isl29018_remove(struct i2c_client *client)
522 struct isl29018_chip *chip = i2c_get_clientdata(client);
524 dev_dbg(&client->dev, "%s()\n", __func__);
525 iio_device_unregister(chip->indio_dev);
531 static const struct i2c_device_id isl29018_id[] = {
536 MODULE_DEVICE_TABLE(i2c, isl29018_id);
538 static struct i2c_driver isl29018_driver = {
539 .class = I2C_CLASS_HWMON,
542 .owner = THIS_MODULE,
544 .probe = isl29018_probe,
545 .remove = __devexit_p(isl29018_remove),
546 .id_table = isl29018_id,
549 static int __init isl29018_init(void)
551 return i2c_add_driver(&isl29018_driver);
554 static void __exit isl29018_exit(void)
556 i2c_del_driver(&isl29018_driver);
559 module_init(isl29018_init);
560 module_exit(isl29018_exit);
562 MODULE_DESCRIPTION("ISL29018 Ambient Light Sensor driver");
563 MODULE_LICENSE("GPL");