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,
 277                 const struct iio_chan_spec *chan, enum iio_event_type type,
 278                 enum iio_event_direction dir, enum iio_event_info info,
 279                 int *val, int *val2)
 280 {
 281         struct apds9300_data *data = iio_priv(indio_dev);
 282
 283         switch (dir) {
 284         case IIO_EV_DIR_RISING:
 285                 *val = data->thresh_hi;
 286                 break;
 287         case IIO_EV_DIR_FALLING:
 288                 *val = data->thresh_low;
 289                 break;
 290         default:
 291                 return -EINVAL;
 292         }
 293
 294         return IIO_VAL_INT;
 295 }
 296
 297 static int apds9300_write_thresh(struct iio_dev *indio_dev,
 298                 const struct iio_chan_spec *chan, enum iio_event_type type,
 299                 enum iio_event_direction dir, enum iio_event_info info, int val,
 300                 int val2)
 301 {
 302         struct apds9300_data *data = iio_priv(indio_dev);
 303         int ret;
 304
 305         mutex_lock(&data->mutex);
 306         if (dir == IIO_EV_DIR_RISING)
 307                 ret = apds9300_set_thresh_hi(data, val);
 308         else
 309                 ret = apds9300_set_thresh_low(data, val);
 310         mutex_unlock(&data->mutex);
 311
 312         return ret;
 313 }
 314
 315 static int apds9300_read_interrupt_config(struct iio_dev *indio_dev,
 316                 const struct iio_chan_spec *chan,
 317                 enum iio_event_type type,
 318                 enum iio_event_direction dir)
 319 {
 320         struct apds9300_data *data = iio_priv(indio_dev);
 321
 322         return data->intr_en;
 323 }
 324
 325 static int apds9300_write_interrupt_config(struct iio_dev *indio_dev,
 326                 const struct iio_chan_spec *chan, enum iio_event_type type,
 327                 enum iio_event_direction dir, int state)
 328 {
 329         struct apds9300_data *data = iio_priv(indio_dev);
 330         int ret;
 331
 332         mutex_lock(&data->mutex);
 333         ret = apds9300_set_intr_state(data, state);
 334         mutex_unlock(&data->mutex);
 335
 336         return ret;
 337 }
 338
 339 static const struct iio_info apds9300_info_no_irq = {
 340         .read_raw       = apds9300_read_raw,
 341 };
 342
 343 static const struct iio_info apds9300_info = {
 344         .read_raw               = apds9300_read_raw,
 345         .read_event_value       = apds9300_read_thresh,
 346         .write_event_value      = apds9300_write_thresh,
 347         .read_event_config      = apds9300_read_interrupt_config,
 348         .write_event_config     = apds9300_write_interrupt_config,
 349 };
 350
 351 static const struct iio_event_spec apds9300_event_spec[] = {
 352         {
 353                 .type = IIO_EV_TYPE_THRESH,
 354                 .dir = IIO_EV_DIR_RISING,
 355                 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
 356                         BIT(IIO_EV_INFO_ENABLE),
 357         }, {
 358                 .type = IIO_EV_TYPE_THRESH,
 359                 .dir = IIO_EV_DIR_FALLING,
 360                 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
 361                         BIT(IIO_EV_INFO_ENABLE),
 362         },
 363 };
 364
 365 static const struct iio_chan_spec apds9300_channels[] = {
 366         {
 367                 .type = IIO_LIGHT,
 368                 .channel = 0,
 369                 .indexed = true,
 370                 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
 371         }, {
 372                 .type = IIO_INTENSITY,
 373                 .channel = 0,
 374                 .channel2 = IIO_MOD_LIGHT_BOTH,
 375                 .indexed = true,
 376                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 377                 .event_spec = apds9300_event_spec,
 378                 .num_event_specs = ARRAY_SIZE(apds9300_event_spec),
 379         }, {
 380                 .type = IIO_INTENSITY,
 381                 .channel = 1,
 382                 .channel2 = IIO_MOD_LIGHT_IR,
 383                 .indexed = true,
 384                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
 385         },
 386 };
 387
 388 static irqreturn_t apds9300_interrupt_handler(int irq, void *private)
 389 {
 390         struct iio_dev *dev_info = private;
 391         struct apds9300_data *data = iio_priv(dev_info);
 392
 393         iio_push_event(dev_info,
 394                        IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0,
 395                                             IIO_EV_TYPE_THRESH,
 396                                             IIO_EV_DIR_EITHER),
 397                        iio_get_time_ns(dev_info));
 398
 399         apds9300_clear_intr(data);
 400
 401         return IRQ_HANDLED;
 402 }
 403
 404 static int apds9300_probe(struct i2c_client *client,
 405                 const struct i2c_device_id *id)
 406 {
 407         struct apds9300_data *data;
 408         struct iio_dev *indio_dev;
 409         int ret;
 410
 411         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 412         if (!indio_dev)
 413                 return -ENOMEM;
 414
 415         data = iio_priv(indio_dev);
 416         i2c_set_clientdata(client, indio_dev);
 417         data->client = client;
 418
 419         ret = apds9300_chip_init(data);
 420         if (ret < 0)
 421                 goto err;
 422
 423         mutex_init(&data->mutex);
 424
 425         indio_dev->dev.parent = &client->dev;
 426         indio_dev->channels = apds9300_channels;
 427         indio_dev->num_channels = ARRAY_SIZE(apds9300_channels);
 428         indio_dev->name = APDS9300_DRV_NAME;
 429         indio_dev->modes = INDIO_DIRECT_MODE;
 430
 431         if (client->irq)
 432                 indio_dev->info = &apds9300_info;
 433         else
 434                 indio_dev->info = &apds9300_info_no_irq;
 435
 436         if (client->irq) {
 437                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 438                                 NULL, apds9300_interrupt_handler,
 439                                 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 440                                 APDS9300_IRQ_NAME, indio_dev);
 441                 if (ret) {
 442                         dev_err(&client->dev, "irq request error %d\n", -ret);
 443                         goto err;
 444                 }
 445         }
 446
 447         ret = iio_device_register(indio_dev);
 448         if (ret < 0)
 449                 goto err;
 450
 451         return 0;
 452
 453 err:
 454         /* Ensure that power off in case of error */
 455         apds9300_set_power_state(data, 0);
 456         return ret;
 457 }
 458
 459 static int apds9300_remove(struct i2c_client *client)
 460 {
 461         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 462         struct apds9300_data *data = iio_priv(indio_dev);
 463
 464         iio_device_unregister(indio_dev);
 465
 466         /* Ensure that power off and interrupts are disabled */
 467         apds9300_set_intr_state(data, 0);
 468         apds9300_set_power_state(data, 0);
 469
 470         return 0;
 471 }
 472
 473 #ifdef CONFIG_PM_SLEEP
 474 static int apds9300_suspend(struct device *dev)
 475 {
 476         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 477         struct apds9300_data *data = iio_priv(indio_dev);
 478         int ret;
 479
 480         mutex_lock(&data->mutex);
 481         ret = apds9300_set_power_state(data, 0);
 482         mutex_unlock(&data->mutex);
 483
 484         return ret;
 485 }
 486
 487 static int apds9300_resume(struct device *dev)
 488 {
 489         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 490         struct apds9300_data *data = iio_priv(indio_dev);
 491         int ret;
 492
 493         mutex_lock(&data->mutex);
 494         ret = apds9300_set_power_state(data, 1);
 495         mutex_unlock(&data->mutex);
 496
 497         return ret;
 498 }
 499
 500 static SIMPLE_DEV_PM_OPS(apds9300_pm_ops, apds9300_suspend, apds9300_resume);
 501 #define APDS9300_PM_OPS (&apds9300_pm_ops)
 502 #else
 503 #define APDS9300_PM_OPS NULL
 504 #endif
 505
 506 static const struct i2c_device_id apds9300_id[] = {
 507         { APDS9300_DRV_NAME, 0 },
 508         { }
 509 };
 510
 511 MODULE_DEVICE_TABLE(i2c, apds9300_id);
 512
 513 static struct i2c_driver apds9300_driver = {
 514         .driver = {
 515                 .name   = APDS9300_DRV_NAME,
 516                 .pm     = APDS9300_PM_OPS,
 517         },
 518         .probe          = apds9300_probe,
 519         .remove         = apds9300_remove,
 520         .id_table       = apds9300_id,
 521 };
 522
 523 module_i2c_driver(apds9300_driver);
 524
 525 MODULE_AUTHOR("Kravchenko Oleksandr <o.v.kravchenko@globallogic.com>");
 526 MODULE_AUTHOR("GlobalLogic inc.");
 527 MODULE_DESCRIPTION("APDS9300 ambient light photo sensor driver");
 528 MODULE_LICENSE("GPL");