drivers/iio/light/apds9300.c

   1 /*
   2  * apds9300.c - IIO driver for Avago APDS9300 ambient light sensor
   3  *
   4  * Copyright 2013 Oleksandr Kravchenko <o.v.kravchenko@globallogic.com>
   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
  11 #include <linux/module.h>
  12 #include <linux/slab.h>
  13 #include <linux/pm.h>
  14 #include <linux/i2c.h>
  15 #include <linux/err.h>
  16 #include <linux/mutex.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/iio/iio.h>
  19 #include <linux/iio/sysfs.h>
  20 #include <linux/iio/events.h>
  21
  22 #define APDS9300_DRV_NAME "apds9300"
  23 #define APDS9300_IRQ_NAME "apds9300_event"
  24
  25 /* Command register bits */
  26 #define APDS9300_CMD    BIT(7) /* Select command register. Must write as 1 */
  27 #define APDS9300_WORD   BIT(5) /* I2C write/read: if 1 word, if 0 byte */
  28 #define APDS9300_CLEAR  BIT(6) /* Interrupt clear. Clears pending interrupt */
  29
  30 /* Register set */
  31 #define APDS9300_CONTROL        0x00 /* Control of basic functions */
  32 #define APDS9300_THRESHLOWLOW   0x02 /* Low byte of low interrupt threshold */
  33 #define APDS9300_THRESHHIGHLOW  0x04 /* Low byte of high interrupt threshold */
  34 #define APDS9300_INTERRUPT      0x06 /* Interrupt control */
  35 #define APDS9300_DATA0LOW       0x0c /* Low byte of ADC channel 0 */
  36 #define APDS9300_DATA1LOW       0x0e /* Low byte of ADC channel 1 */
  37
  38 /* Power on/off value for APDS9300_CONTROL register */
  39 #define APDS9300_POWER_ON       0x03
  40 #define APDS9300_POWER_OFF      0x00
  41
  42 /* Interrupts */
  43 #define APDS9300_INTR_ENABLE    0x10
  44 /* Interrupt Persist Function: Any value outside of threshold range */
  45 #define APDS9300_THRESH_INTR    0x01
  46
  47 #define APDS9300_THRESH_MAX     0xffff /* Max threshold value */
  48
  49 struct apds9300_data {
  50         struct i2c_client *client;
  51         struct mutex mutex;
  52         int power_state;
  53         int thresh_low;
  54         int thresh_hi;
  55         int intr_en;
  56 };
  57
  58 /* Lux calculation */
  59
  60 /* Calculated values 1000 * (CH1/CH0)^1.4 for CH1/CH0 from 0 to 0.52 */
  61 static const u16 apds9300_lux_ratio[] = {
  62         0, 2, 4, 7, 11, 15, 19, 24, 29, 34, 40, 45, 51, 57, 64, 70, 77, 84, 91,
  63         98, 105, 112, 120, 128, 136, 144, 152, 160, 168, 177, 185, 194, 203,
  64         212, 221, 230, 239, 249, 258, 268, 277, 287, 297, 307, 317, 327, 337,
  65         347, 358, 368, 379, 390, 400,
  66 };
  67
  68 static unsigned long apds9300_calculate_lux(u16 ch0, u16 ch1)
  69 {
  70         unsigned long lux, tmp;
  71
  72         /* avoid division by zero */
  73         if (ch0 == 0)
  74                 return 0;
  75
  76         tmp = DIV_ROUND_UP(ch1 * 100, ch0);
  77         if (tmp <= 52) {
  78                 lux = 3150 * ch0 - (unsigned long)DIV_ROUND_UP_ULL(ch0
  79                                 * apds9300_lux_ratio[tmp] * 5930ull, 1000);
  80         } else if (tmp <= 65) {
  81                 lux = 2290 * ch0 - 2910 * ch1;
  82         } else if (tmp <= 80) {
  83                 lux = 1570 * ch0 - 1800 * ch1;
  84         } else if (tmp <= 130) {
  85                 lux = 338 * ch0 - 260 * ch1;
  86         } else {
  87                 lux = 0;
  88         }
  89
  90         return lux / 100000;
  91 }
  92
  93 static int apds9300_get_adc_val(struct apds9300_data *data, int adc_number)
  94 {
  95         int ret;
  96         u8 flags = APDS9300_CMD | APDS9300_WORD;
  97
  98         if (!data->power_state)
  99                 return -EBUSY;
 100
 101         /* Select ADC0 or ADC1 data register */
 102         flags |= adc_number ? APDS9300_DATA1LOW : APDS9300_DATA0LOW;
 103
 104         ret = i2c_smbus_read_word_data(data->client, flags);
 105         if (ret < 0)
 106                 dev_err(&data->client->dev,
 107                         "failed to read ADC%d value\n", adc_number);
 108
 109         return ret;
 110 }
 111
 112 static int apds9300_set_thresh_low(struct apds9300_data *data, int value)
 113 {
 114         int ret;
 115
 116         if (!data->power_state)
 117                 return -EBUSY;
 118
 119         if (value > APDS9300_THRESH_MAX)
 120                 return -EINVAL;
 121
 122         ret = i2c_smbus_write_word_data(data->client, APDS9300_THRESHLOWLOW
 123                         | APDS9300_CMD | APDS9300_WORD, value);
 124         if (ret) {
 125                 dev_err(&data->client->dev, "failed to set thresh_low\n");
 126                 return ret;
 127         }
 128         data->thresh_low = value;
 129
 130         return 0;
 131 }
 132
 133 static int apds9300_set_thresh_hi(struct apds9300_data *data, int value)
 134 {
 135         int ret;
 136
 137         if (!data->power_state)
 138                 return -EBUSY;
 139
 140         if (value > APDS9300_THRESH_MAX)
 141                 return -EINVAL;
 142
 143         ret = i2c_smbus_write_word_data(data->client, APDS9300_THRESHHIGHLOW
 144                         | APDS9300_CMD | APDS9300_WORD, value);
 145         if (ret) {
 146                 dev_err(&data->client->dev, "failed to set thresh_hi\n");
 147                 return ret;
 148         }
 149         data->thresh_hi = value;
 150
 151         return 0;
 152 }
 153
 154 static int apds9300_set_intr_state(struct apds9300_data *data, int state)
 155 {
 156         int ret;
 157         u8 cmd;
 158
 159         if (!data->power_state)
 160                 return -EBUSY;
 161
 162         cmd = state ? APDS9300_INTR_ENABLE | APDS9300_THRESH_INTR : 0x00;
 163         ret = i2c_smbus_write_byte_data(data->client,
 164                         APDS9300_INTERRUPT | APDS9300_CMD, cmd);
 165         if (ret) {
 166                 dev_err(&data->client->dev,
 167                         "failed to set interrupt state %d\n", state);
 168                 return ret;
 169         }
 170         data->intr_en = state;
 171
 172         return 0;
 173 }
 174
 175 static int apds9300_set_power_state(struct apds9300_data *data, int state)
 176 {
 177         int ret;
 178         u8 cmd;
 179
 180         cmd = state ? APDS9300_POWER_ON : APDS9300_POWER_OFF;
 181         ret = i2c_smbus_write_byte_data(data->client,
 182                         APDS9300_CONTROL | APDS9300_CMD, cmd);
 183         if (ret) {
 184                 dev_err(&data->client->dev,
 185                         "failed to set power state %d\n", state);
 186                 return ret;
 187         }
 188         data->power_state = state;
 189
 190         return 0;
 191 }
 192
 193 static void apds9300_clear_intr(struct apds9300_data *data)
 194 {
 195         int ret;
 196
 197         ret = i2c_smbus_write_byte(data->client, APDS9300_CLEAR | APDS9300_CMD);
 198         if (ret < 0)
 199                 dev_err(&data->client->dev, "failed to clear interrupt\n");
 200 }
 201
 202 static int apds9300_chip_init(struct apds9300_data *data)
 203 {
 204         int ret;
 205
 206         /* Need to set power off to ensure that the chip is off */
 207         ret = apds9300_set_power_state(data, 0);
 208         if (ret < 0)
 209                 goto err;
 210         /*
 211          * Probe the chip. To do so we try to power up the device and then to
 212          * read back the 0x03 code
 213          */
 214         ret = apds9300_set_power_state(data, 1);
 215         if (ret < 0)
 216                 goto err;
 217         ret = i2c_smbus_read_byte_data(data->client,
 218                         APDS9300_CONTROL | APDS9300_CMD);
 219         if (ret != APDS9300_POWER_ON) {
 220                 ret = -ENODEV;
 221                 goto err;
 222         }
 223         /*
 224          * Disable interrupt to ensure thai it is doesn't enable
 225          * i.e. after device soft reset
 226          */
 227         ret = apds9300_set_intr_state(data, 0);
 228         if (ret < 0)
 229                 goto err;
 230
 231         return 0;
 232
 233 err:
 234         dev_err(&data->client->dev, "failed to init the chip\n");
 235         return ret;
 236 }
 237
 238 static int apds9300_read_raw(struct iio_dev *indio_dev,
 239                 struct iio_chan_spec const *chan, int *val, int *val2,
 240                 long mask)
 241 {
 242         int ch0, ch1, ret = -EINVAL;
 243         struct apds9300_data *data = iio_priv(indio_dev);
 244
 245         mutex_lock(&data->mutex);
 246         switch (chan->type) {
 247         case IIO_LIGHT:
 248                 ch0 = apds9300_get_adc_val(data, 0);
 249                 if (ch0 < 0) {
 250                         ret = ch0;
 251                         break;
 252                 }
 253                 ch1 = apds9300_get_adc_val(data, 1);
 254                 if (ch1 < 0) {
 255                         ret = ch1;
 256                         break;
 257                 }
 258                 *val = apds9300_calculate_lux(ch0, ch1);
 259                 ret = IIO_VAL_INT;
 260                 break;
 261         case IIO_INTENSITY:
 262                 ret = apds9300_get_adc_val(data, chan->channel);
 263                 if (ret < 0)
 264                         break;
 265                 *val = ret;
 266                 ret = IIO_VAL_INT;
 267                 break;
 268         default:
 269                 break;
 270         }
 271         mutex_unlock(&data->mutex);
 272
 273         return ret;
 274 }
 275
 276 static int apds9300_read_thresh(struct iio_dev *indio_dev, u64 event_code,
 277                 int *val)
 278 {
 279         struct apds9300_data *data = iio_priv(indio_dev);
 280
 281         switch (IIO_EVENT_CODE_EXTRACT_DIR(event_code)) {
 282         case IIO_EV_DIR_RISING:
 283                 *val = data->thresh_hi;
 284                 break;
 285         case IIO_EV_DIR_FALLING:
 286                 *val = data->thresh_low;
 287                 break;
 288         default:
 289                 return -EINVAL;
 290         }
 291
 292         return 0;
 293 }
 294
 295 static int apds9300_write_thresh(struct iio_dev *indio_dev, u64 event_code,
 296                 int val)
 297 {
 298         struct apds9300_data *data = iio_priv(indio_dev);
 299         int ret;
 300
 301         mutex_lock(&data->mutex);
 302         if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_RISING)
 303                 ret = apds9300_set_thresh_hi(data, val);
 304         else
 305                 ret = apds9300_set_thresh_low(data, val);
 306         mutex_unlock(&data->mutex);
 307
 308         return ret;
 309 }
 310
 311 static int apds9300_read_interrupt_config(struct iio_dev *indio_dev,
 312                 u64 event_code)
 313 {
 314         struct apds9300_data *data = iio_priv(indio_dev);
 315
 316         return data->intr_en;
 317 }
 318
 319 static int apds9300_write_interrupt_config(struct iio_dev *indio_dev,
 320                 u64 event_code, int state)
 321 {
 322         struct apds9300_data *data = iio_priv(indio_dev);
 323         int ret;
 324
 325         mutex_lock(&data->mutex);
 326         ret = apds9300_set_intr_state(data, state);
 327         mutex_unlock(&data->mutex);
 328
 329         return ret;
 330 }
 331
 332 static const struct iio_info apds9300_info_no_irq = {
 333         .driver_module  = THIS_MODULE,
 334         .read_raw       = apds9300_read_raw,
 335 };
 336
 337 static const struct iio_info apds9300_info = {
 338         .driver_module          = THIS_MODULE,
 339         .read_raw               = apds9300_read_raw,
 340         .read_event_value       = apds9300_read_thresh,
 341         .write_event_value      = apds9300_write_thresh,
 342         .read_event_config      = apds9300_read_interrupt_config,
 343         .write_event_config     = apds9300_write_interrupt_config,
 344 };
 345
 346 static const struct iio_chan_spec apds9300_channels[] = {
 347         {
 348                 .type = IIO_LIGHT,
 349                 .channel = 0,
 350                 .indexed = true,
 351                 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
 352         }, {
 353                 .type = IIO_INTENSITY,
 354                 .channel = 0,
 355                 .channel2 = IIO_MOD_LIGHT_BOTH,
 356                 .indexed = true,
 357                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 358                 .event_mask = (IIO_EV_BIT(IIO_EV_TYPE_THRESH,
 359                                           IIO_EV_DIR_RISING) |
 360                                IIO_EV_BIT(IIO_EV_TYPE_THRESH,
 361                                           IIO_EV_DIR_FALLING)),
 362         }, {
 363                 .type = IIO_INTENSITY,
 364                 .channel = 1,
 365                 .channel2 = IIO_MOD_LIGHT_IR,
 366                 .indexed = true,
 367                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 368         },
 369 };
 370
 371 static irqreturn_t apds9300_interrupt_handler(int irq, void *private)
 372 {
 373         struct iio_dev *dev_info = private;
 374         struct apds9300_data *data = iio_priv(dev_info);
 375
 376         iio_push_event(dev_info,
 377                        IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0,
 378                                             IIO_EV_TYPE_THRESH,
 379                                             IIO_EV_DIR_EITHER),
 380                        iio_get_time_ns());
 381
 382         apds9300_clear_intr(data);
 383
 384         return IRQ_HANDLED;
 385 }
 386
 387 static int apds9300_probe(struct i2c_client *client,
 388                 const struct i2c_device_id *id)
 389 {
 390         struct apds9300_data *data;
 391         struct iio_dev *indio_dev;
 392         int ret;
 393
 394         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 395         if (!indio_dev)
 396                 return -ENOMEM;
 397
 398         data = iio_priv(indio_dev);
 399         i2c_set_clientdata(client, indio_dev);
 400         data->client = client;
 401
 402         ret = apds9300_chip_init(data);
 403         if (ret < 0)
 404                 goto err;
 405
 406         mutex_init(&data->mutex);
 407
 408         indio_dev->dev.parent = &client->dev;
 409         indio_dev->channels = apds9300_channels;
 410         indio_dev->num_channels = ARRAY_SIZE(apds9300_channels);
 411         indio_dev->name = APDS9300_DRV_NAME;
 412         indio_dev->modes = INDIO_DIRECT_MODE;
 413
 414         if (client->irq)
 415                 indio_dev->info = &apds9300_info;
 416         else
 417                 indio_dev->info = &apds9300_info_no_irq;
 418
 419         if (client->irq) {
 420                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 421                                 NULL, apds9300_interrupt_handler,
 422                                 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 423                                 APDS9300_IRQ_NAME, indio_dev);
 424                 if (ret) {
 425                         dev_err(&client->dev, "irq request error %d\n", -ret);
 426                         goto err;
 427                 }
 428         }
 429
 430         ret = iio_device_register(indio_dev);
 431         if (ret < 0)
 432                 goto err;
 433
 434         return 0;
 435
 436 err:
 437         /* Ensure that power off in case of error */
 438         apds9300_set_power_state(data, 0);
 439         return ret;
 440 }
 441
 442 static int apds9300_remove(struct i2c_client *client)
 443 {
 444         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 445         struct apds9300_data *data = iio_priv(indio_dev);
 446
 447         iio_device_unregister(indio_dev);
 448
 449         /* Ensure that power off and interrupts are disabled */
 450         apds9300_set_intr_state(data, 0);
 451         apds9300_set_power_state(data, 0);
 452
 453         return 0;
 454 }
 455
 456 #ifdef CONFIG_PM_SLEEP
 457 static int apds9300_suspend(struct device *dev)
 458 {
 459         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 460         struct apds9300_data *data = iio_priv(indio_dev);
 461         int ret;
 462
 463         mutex_lock(&data->mutex);
 464         ret = apds9300_set_power_state(data, 0);
 465         mutex_unlock(&data->mutex);
 466
 467         return ret;
 468 }
 469
 470 static int apds9300_resume(struct device *dev)
 471 {
 472         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 473         struct apds9300_data *data = iio_priv(indio_dev);
 474         int ret;
 475
 476         mutex_lock(&data->mutex);
 477         ret = apds9300_set_power_state(data, 1);
 478         mutex_unlock(&data->mutex);
 479
 480         return ret;
 481 }
 482
 483 static SIMPLE_DEV_PM_OPS(apds9300_pm_ops, apds9300_suspend, apds9300_resume);
 484 #define APDS9300_PM_OPS (&apds9300_pm_ops)
 485 #else
 486 #define APDS9300_PM_OPS NULL
 487 #endif
 488
 489 static struct i2c_device_id apds9300_id[] = {
 490         { APDS9300_DRV_NAME, 0 },
 491         { }
 492 };
 493
 494 MODULE_DEVICE_TABLE(i2c, apds9300_id);
 495
 496 static struct i2c_driver apds9300_driver = {
 497         .driver = {
 498                 .name   = APDS9300_DRV_NAME,
 499                 .owner  = THIS_MODULE,
 500                 .pm     = APDS9300_PM_OPS,
 501         },
 502         .probe          = apds9300_probe,
 503         .remove         = apds9300_remove,
 504         .id_table       = apds9300_id,
 505 };
 506
 507 module_i2c_driver(apds9300_driver);
 508
 509 MODULE_AUTHOR("Kravchenko Oleksandr <o.v.kravchenko@globallogic.com>");
 510 MODULE_AUTHOR("GlobalLogic inc.");
 511 MODULE_DESCRIPTION("APDS9300 ambient light photo sensor driver");
 512 MODULE_LICENSE("GPL");