Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/iio/light/cm32181.c

  1 /*
  2  * Copyright (C) 2013 Capella Microsystems Inc.
  3  * Author: Kevin Tsai <ktsai@capellamicro.com>
  4  *
  5  * This program is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2, as published
  7  * by the Free Software Foundation.
  8  */
  9 
 10 #include <linux/delay.h>
 11 #include <linux/err.h>
 12 #include <linux/i2c.h>
 13 #include <linux/mutex.h>
 14 #include <linux/module.h>
 15 #include <linux/interrupt.h>
 16 #include <linux/regulator/consumer.h>
 17 #include <linux/iio/iio.h>
 18 #include <linux/iio/sysfs.h>
 19 #include <linux/iio/events.h>
 20 #include <linux/init.h>
 21 
 22 /* Registers Address */
 23 #define CM32181_REG_ADDR_CMD            0x00
 24 #define CM32181_REG_ADDR_ALS            0x04
 25 #define CM32181_REG_ADDR_STATUS         0x06
 26 #define CM32181_REG_ADDR_ID             0x07
 27 
 28 /* Number of Configurable Registers */
 29 #define CM32181_CONF_REG_NUM            0x01
 30 
 31 /* CMD register */
 32 #define CM32181_CMD_ALS_ENABLE          0x00
 33 #define CM32181_CMD_ALS_DISABLE         0x01
 34 #define CM32181_CMD_ALS_INT_EN          0x02
 35 
 36 #define CM32181_CMD_ALS_IT_SHIFT        6
 37 #define CM32181_CMD_ALS_IT_MASK         (0x0F << CM32181_CMD_ALS_IT_SHIFT)
 38 #define CM32181_CMD_ALS_IT_DEFAULT      (0x00 << CM32181_CMD_ALS_IT_SHIFT)
 39 
 40 #define CM32181_CMD_ALS_SM_SHIFT        11
 41 #define CM32181_CMD_ALS_SM_MASK         (0x03 << CM32181_CMD_ALS_SM_SHIFT)
 42 #define CM32181_CMD_ALS_SM_DEFAULT      (0x01 << CM32181_CMD_ALS_SM_SHIFT)
 43 
 44 #define CM32181_MLUX_PER_BIT            5       /* ALS_SM=01 IT=800ms */
 45 #define CM32181_MLUX_PER_BIT_BASE_IT    800000  /* Based on IT=800ms */
 46 #define CM32181_CALIBSCALE_DEFAULT      1000
 47 #define CM32181_CALIBSCALE_RESOLUTION   1000
 48 #define MLUX_PER_LUX                    1000
 49 
 50 static const u8 cm32181_reg[CM32181_CONF_REG_NUM] = {
 51         CM32181_REG_ADDR_CMD,
 52 };
 53 
 54 static const int als_it_bits[] = {12, 8, 0, 1, 2, 3};
 55 static const int als_it_value[] = {25000, 50000, 100000, 200000, 400000,
 56         800000};
 57 
 58 struct cm32181_chip {
 59         struct i2c_client *client;
 60         struct mutex lock;
 61         u16 conf_regs[CM32181_CONF_REG_NUM];
 62         int calibscale;
 63 };
 64 
 65 /**
 66  * cm32181_reg_init() - Initialize CM32181 registers
 67  * @cm32181:    pointer of struct cm32181.
 68  *
 69  * Initialize CM32181 ambient light sensor register to default values.
 70  *
 71  * Return: 0 for success; otherwise for error code.
 72  */
 73 static int cm32181_reg_init(struct cm32181_chip *cm32181)
 74 {
 75         struct i2c_client *client = cm32181->client;
 76         int i;
 77         s32 ret;
 78 
 79         ret = i2c_smbus_read_word_data(client, CM32181_REG_ADDR_ID);
 80         if (ret < 0)
 81                 return ret;
 82 
 83         /* check device ID */
 84         if ((ret & 0xFF) != 0x81)
 85                 return -ENODEV;
 86 
 87         /* Default Values */
 88         cm32181->conf_regs[CM32181_REG_ADDR_CMD] = CM32181_CMD_ALS_ENABLE |
 89                         CM32181_CMD_ALS_IT_DEFAULT | CM32181_CMD_ALS_SM_DEFAULT;
 90         cm32181->calibscale = CM32181_CALIBSCALE_DEFAULT;
 91 
 92         /* Initialize registers*/
 93         for (i = 0; i < CM32181_CONF_REG_NUM; i++) {
 94                 ret = i2c_smbus_write_word_data(client, cm32181_reg[i],
 95                         cm32181->conf_regs[i]);
 96                 if (ret < 0)
 97                         return ret;
 98         }
 99 
100         return 0;
101 }
102 
103 /**
104  *  cm32181_read_als_it() - Get sensor integration time (ms)
105  *  @cm32181:   pointer of struct cm32181
106  *  @val2:      pointer of int to load the als_it value.
107  *
108  *  Report the current integartion time by millisecond.
109  *
110  *  Return: IIO_VAL_INT_PLUS_MICRO for success, otherwise -EINVAL.
111  */
112 static int cm32181_read_als_it(struct cm32181_chip *cm32181, int *val2)
113 {
114         u16 als_it;
115         int i;
116 
117         als_it = cm32181->conf_regs[CM32181_REG_ADDR_CMD];
118         als_it &= CM32181_CMD_ALS_IT_MASK;
119         als_it >>= CM32181_CMD_ALS_IT_SHIFT;
120         for (i = 0; i < ARRAY_SIZE(als_it_bits); i++) {
121                 if (als_it == als_it_bits[i]) {
122                         *val2 = als_it_value[i];
123                         return IIO_VAL_INT_PLUS_MICRO;
124                 }
125         }
126 
127         return -EINVAL;
128 }
129 
130 /**
131  * cm32181_write_als_it() - Write sensor integration time
132  * @cm32181:    pointer of struct cm32181.
133  * @val:        integration time by millisecond.
134  *
135  * Convert integration time (ms) to sensor value.
136  *
137  * Return: i2c_smbus_write_word_data command return value.
138  */
139 static int cm32181_write_als_it(struct cm32181_chip *cm32181, int val)
140 {
141         struct i2c_client *client = cm32181->client;
142         u16 als_it;
143         int ret, i, n;
144 
145         n = ARRAY_SIZE(als_it_value);
146         for (i = 0; i < n; i++)
147                 if (val <= als_it_value[i])
148                         break;
149         if (i >= n)
150                 i = n - 1;
151 
152         als_it = als_it_bits[i];
153         als_it <<= CM32181_CMD_ALS_IT_SHIFT;
154 
155         mutex_lock(&cm32181->lock);
156         cm32181->conf_regs[CM32181_REG_ADDR_CMD] &=
157                 ~CM32181_CMD_ALS_IT_MASK;
158         cm32181->conf_regs[CM32181_REG_ADDR_CMD] |=
159                 als_it;
160         ret = i2c_smbus_write_word_data(client, CM32181_REG_ADDR_CMD,
161                         cm32181->conf_regs[CM32181_REG_ADDR_CMD]);
162         mutex_unlock(&cm32181->lock);
163 
164         return ret;
165 }
166 
167 /**
168  * cm32181_get_lux() - report current lux value
169  * @cm32181:    pointer of struct cm32181.
170  *
171  * Convert sensor raw data to lux.  It depends on integration
172  * time and claibscale variable.
173  *
174  * Return: Positive value is lux, otherwise is error code.
175  */
176 static int cm32181_get_lux(struct cm32181_chip *cm32181)
177 {
178         struct i2c_client *client = cm32181->client;
179         int ret;
180         int als_it;
181         unsigned long lux;
182 
183         ret = cm32181_read_als_it(cm32181, &als_it);
184         if (ret < 0)
185                 return -EINVAL;
186 
187         lux = CM32181_MLUX_PER_BIT;
188         lux *= CM32181_MLUX_PER_BIT_BASE_IT;
189         lux /= als_it;
190 
191         ret = i2c_smbus_read_word_data(client, CM32181_REG_ADDR_ALS);
192         if (ret < 0)
193                 return ret;
194 
195         lux *= ret;
196         lux *= cm32181->calibscale;
197         lux /= CM32181_CALIBSCALE_RESOLUTION;
198         lux /= MLUX_PER_LUX;
199 
200         if (lux > 0xFFFF)
201                 lux = 0xFFFF;
202 
203         return lux;
204 }
205 
206 static int cm32181_read_raw(struct iio_dev *indio_dev,
207                             struct iio_chan_spec const *chan,
208                             int *val, int *val2, long mask)
209 {
210         struct cm32181_chip *cm32181 = iio_priv(indio_dev);
211         int ret;
212 
213         switch (mask) {
214         case IIO_CHAN_INFO_PROCESSED:
215                 ret = cm32181_get_lux(cm32181);
216                 if (ret < 0)
217                         return ret;
218                 *val = ret;
219                 return IIO_VAL_INT;
220         case IIO_CHAN_INFO_CALIBSCALE:
221                 *val = cm32181->calibscale;
222                 return IIO_VAL_INT;
223         case IIO_CHAN_INFO_INT_TIME:
224                 ret = cm32181_read_als_it(cm32181, val2);
225                 return ret;
226         }
227 
228         return -EINVAL;
229 }
230 
231 static int cm32181_write_raw(struct iio_dev *indio_dev,
232                              struct iio_chan_spec const *chan,
233                              int val, int val2, long mask)
234 {
235         struct cm32181_chip *cm32181 = iio_priv(indio_dev);
236         int ret;
237 
238         switch (mask) {
239         case IIO_CHAN_INFO_CALIBSCALE:
240                 cm32181->calibscale = val;
241                 return val;
242         case IIO_CHAN_INFO_INT_TIME:
243                 ret = cm32181_write_als_it(cm32181, val2);
244                 return ret;
245         }
246 
247         return -EINVAL;
248 }
249 
250 /**
251  * cm32181_get_it_available() - Get available ALS IT value
252  * @dev:        pointer of struct device.
253  * @attr:       pointer of struct device_attribute.
254  * @buf:        pointer of return string buffer.
255  *
256  * Display the available integration time values by millisecond.
257  *
258  * Return: string length.
259  */
260 static ssize_t cm32181_get_it_available(struct device *dev,
261                         struct device_attribute *attr, char *buf)
262 {
263         int i, n, len;
264 
265         n = ARRAY_SIZE(als_it_value);
266         for (i = 0, len = 0; i < n; i++)
267                 len += sprintf(buf + len, "0.%06u ", als_it_value[i]);
268         return len + sprintf(buf + len, "\n");
269 }
270 
271 static const struct iio_chan_spec cm32181_channels[] = {
272         {
273                 .type = IIO_LIGHT,
274                 .info_mask_separate =
275                         BIT(IIO_CHAN_INFO_PROCESSED) |
276                         BIT(IIO_CHAN_INFO_CALIBSCALE) |
277                         BIT(IIO_CHAN_INFO_INT_TIME),
278         }
279 };
280 
281 static IIO_DEVICE_ATTR(in_illuminance_integration_time_available,
282                         S_IRUGO, cm32181_get_it_available, NULL, 0);
283 
284 static struct attribute *cm32181_attributes[] = {
285         &iio_dev_attr_in_illuminance_integration_time_available.dev_attr.attr,
286         NULL,
287 };
288 
289 static const struct attribute_group cm32181_attribute_group = {
290         .attrs = cm32181_attributes
291 };
292 
293 static const struct iio_info cm32181_info = {
294         .driver_module          = THIS_MODULE,
295         .read_raw               = &cm32181_read_raw,
296         .write_raw              = &cm32181_write_raw,
297         .attrs                  = &cm32181_attribute_group,
298 };
299 
300 static int cm32181_probe(struct i2c_client *client,
301                         const struct i2c_device_id *id)
302 {
303         struct cm32181_chip *cm32181;
304         struct iio_dev *indio_dev;
305         int ret;
306 
307         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*cm32181));
308         if (!indio_dev) {
309                 dev_err(&client->dev, "devm_iio_device_alloc failed\n");
310                 return -ENOMEM;
311         }
312 
313         cm32181 = iio_priv(indio_dev);
314         i2c_set_clientdata(client, indio_dev);
315         cm32181->client = client;
316 
317         mutex_init(&cm32181->lock);
318         indio_dev->dev.parent = &client->dev;
319         indio_dev->channels = cm32181_channels;
320         indio_dev->num_channels = ARRAY_SIZE(cm32181_channels);
321         indio_dev->info = &cm32181_info;
322         indio_dev->name = id->name;
323         indio_dev->modes = INDIO_DIRECT_MODE;
324 
325         ret = cm32181_reg_init(cm32181);
326         if (ret) {
327                 dev_err(&client->dev,
328                         "%s: register init failed\n",
329                         __func__);
330                 return ret;
331         }
332 
333         ret = iio_device_register(indio_dev);
334         if (ret) {
335                 dev_err(&client->dev,
336                         "%s: regist device failed\n",
337                         __func__);
338                 return ret;
339         }
340 
341         return 0;
342 }
343 
344 static int cm32181_remove(struct i2c_client *client)
345 {
346         struct iio_dev *indio_dev = i2c_get_clientdata(client);
347 
348         iio_device_unregister(indio_dev);
349         return 0;
350 }
351 
352 static const struct i2c_device_id cm32181_id[] = {
353         { "cm32181", 0 },
354         { }
355 };
356 
357 MODULE_DEVICE_TABLE(i2c, cm32181_id);
358 
359 static const struct of_device_id cm32181_of_match[] = {
360         { .compatible = "capella,cm32181" },
361         { }
362 };
363 
364 static struct i2c_driver cm32181_driver = {
365         .driver = {
366                 .name   = "cm32181",
367                 .of_match_table = of_match_ptr(cm32181_of_match),
368                 .owner  = THIS_MODULE,
369         },
370         .id_table       = cm32181_id,
371         .probe          = cm32181_probe,
372         .remove         = cm32181_remove,
373 };
374 
375 module_i2c_driver(cm32181_driver);
376 
377 MODULE_AUTHOR("Kevin Tsai <ktsai@capellamicro.com>");
378 MODULE_DESCRIPTION("CM32181 ambient light sensor driver");
379 MODULE_LICENSE("GPL");
380 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us