drivers/iio/light/tcs3472.c

   1 /*
   2  * tcs3472.c - Support for TAOS TCS3472 color light-to-digital converter
   3  *
   4  * Copyright (c) 2013 Peter Meerwald <pmeerw@pmeerw.net>
   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  * Color light sensor with 16-bit channels for red, green, blue, clear);
  11  * 7-bit I2C slave address 0x39 (TCS34721, TCS34723) or 0x29 (TCS34725,
  12  * TCS34727)
  13  *
  14  * Datasheet: http://ams.com/eng/content/download/319364/1117183/file/TCS3472_Datasheet_EN_v2.pdf
  15  *
  16  * TODO: wait time
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/i2c.h>
  21 #include <linux/delay.h>
  22 #include <linux/pm.h>
  23
  24 #include <linux/iio/iio.h>
  25 #include <linux/iio/sysfs.h>
  26 #include <linux/iio/events.h>
  27 #include <linux/iio/trigger_consumer.h>
  28 #include <linux/iio/buffer.h>
  29 #include <linux/iio/triggered_buffer.h>
  30
  31 #define TCS3472_DRV_NAME "tcs3472"
  32
  33 #define TCS3472_COMMAND BIT(7)
  34 #define TCS3472_AUTO_INCR BIT(5)
  35 #define TCS3472_SPECIAL_FUNC (BIT(5) | BIT(6))
  36
  37 #define TCS3472_INTR_CLEAR (TCS3472_COMMAND | TCS3472_SPECIAL_FUNC | 0x06)
  38
  39 #define TCS3472_ENABLE (TCS3472_COMMAND | 0x00)
  40 #define TCS3472_ATIME (TCS3472_COMMAND | 0x01)
  41 #define TCS3472_WTIME (TCS3472_COMMAND | 0x03)
  42 #define TCS3472_AILT (TCS3472_COMMAND | TCS3472_AUTO_INCR | 0x04)
  43 #define TCS3472_AIHT (TCS3472_COMMAND | TCS3472_AUTO_INCR | 0x06)
  44 #define TCS3472_PERS (TCS3472_COMMAND | 0x0c)
  45 #define TCS3472_CONFIG (TCS3472_COMMAND | 0x0d)
  46 #define TCS3472_CONTROL (TCS3472_COMMAND | 0x0f)
  47 #define TCS3472_ID (TCS3472_COMMAND | 0x12)
  48 #define TCS3472_STATUS (TCS3472_COMMAND | 0x13)
  49 #define TCS3472_CDATA (TCS3472_COMMAND | TCS3472_AUTO_INCR | 0x14)
  50 #define TCS3472_RDATA (TCS3472_COMMAND | TCS3472_AUTO_INCR | 0x16)
  51 #define TCS3472_GDATA (TCS3472_COMMAND | TCS3472_AUTO_INCR | 0x18)
  52 #define TCS3472_BDATA (TCS3472_COMMAND | TCS3472_AUTO_INCR | 0x1a)
  53
  54 #define TCS3472_STATUS_AINT BIT(4)
  55 #define TCS3472_STATUS_AVALID BIT(0)
  56 #define TCS3472_ENABLE_AIEN BIT(4)
  57 #define TCS3472_ENABLE_AEN BIT(1)
  58 #define TCS3472_ENABLE_PON BIT(0)
  59 #define TCS3472_CONTROL_AGAIN_MASK (BIT(0) | BIT(1))
  60
  61 struct tcs3472_data {
  62         struct i2c_client *client;
  63         struct mutex lock;
  64         u16 low_thresh;
  65         u16 high_thresh;
  66         u8 enable;
  67         u8 control;
  68         u8 atime;
  69         u8 apers;
  70         /* Ensure timestamp is naturally aligned */
  71         struct {
  72                 u16 chans[4];
  73                 s64 timestamp __aligned(8);
  74         } scan;
  75 };
  76
  77 static const struct iio_event_spec tcs3472_events[] = {
  78         {
  79                 .type = IIO_EV_TYPE_THRESH,
  80                 .dir = IIO_EV_DIR_RISING,
  81                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
  82         }, {
  83                 .type = IIO_EV_TYPE_THRESH,
  84                 .dir = IIO_EV_DIR_FALLING,
  85                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
  86         }, {
  87                 .type = IIO_EV_TYPE_THRESH,
  88                 .dir = IIO_EV_DIR_EITHER,
  89                 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
  90                                  BIT(IIO_EV_INFO_PERIOD),
  91         },
  92 };
  93
  94 #define TCS3472_CHANNEL(_color, _si, _addr) { \
  95         .type = IIO_INTENSITY, \
  96         .modified = 1, \
  97         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
  98         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_CALIBSCALE) | \
  99                 BIT(IIO_CHAN_INFO_INT_TIME), \
 100         .channel2 = IIO_MOD_LIGHT_##_color, \
 101         .address = _addr, \
 102         .scan_index = _si, \
 103         .scan_type = { \
 104                 .sign = 'u', \
 105                 .realbits = 16, \
 106                 .storagebits = 16, \
 107                 .endianness = IIO_CPU, \
 108         }, \
 109         .event_spec = _si ? NULL : tcs3472_events, \
 110         .num_event_specs = _si ? 0 : ARRAY_SIZE(tcs3472_events), \
 111 }
 112
 113 static const int tcs3472_agains[] = { 1, 4, 16, 60 };
 114
 115 static const struct iio_chan_spec tcs3472_channels[] = {
 116         TCS3472_CHANNEL(CLEAR, 0, TCS3472_CDATA),
 117         TCS3472_CHANNEL(RED, 1, TCS3472_RDATA),
 118         TCS3472_CHANNEL(GREEN, 2, TCS3472_GDATA),
 119         TCS3472_CHANNEL(BLUE, 3, TCS3472_BDATA),
 120         IIO_CHAN_SOFT_TIMESTAMP(4),
 121 };
 122
 123 static int tcs3472_req_data(struct tcs3472_data *data)
 124 {
 125         int tries = 50;
 126         int ret;
 127
 128         while (tries--) {
 129                 ret = i2c_smbus_read_byte_data(data->client, TCS3472_STATUS);
 130                 if (ret < 0)
 131                         return ret;
 132                 if (ret & TCS3472_STATUS_AVALID)
 133                         break;
 134                 msleep(20);
 135         }
 136
 137         if (tries < 0) {
 138                 dev_err(&data->client->dev, "data not ready\n");
 139                 return -EIO;
 140         }
 141
 142         return 0;
 143 }
 144
 145 static int tcs3472_read_raw(struct iio_dev *indio_dev,
 146                            struct iio_chan_spec const *chan,
 147                            int *val, int *val2, long mask)
 148 {
 149         struct tcs3472_data *data = iio_priv(indio_dev);
 150         int ret;
 151
 152         switch (mask) {
 153         case IIO_CHAN_INFO_RAW:
 154                 ret = iio_device_claim_direct_mode(indio_dev);
 155                 if (ret)
 156                         return ret;
 157                 ret = tcs3472_req_data(data);
 158                 if (ret < 0) {
 159                         iio_device_release_direct_mode(indio_dev);
 160                         return ret;
 161                 }
 162                 ret = i2c_smbus_read_word_data(data->client, chan->address);
 163                 iio_device_release_direct_mode(indio_dev);
 164                 if (ret < 0)
 165                         return ret;
 166                 *val = ret;
 167                 return IIO_VAL_INT;
 168         case IIO_CHAN_INFO_CALIBSCALE:
 169                 *val = tcs3472_agains[data->control &
 170                         TCS3472_CONTROL_AGAIN_MASK];
 171                 return IIO_VAL_INT;
 172         case IIO_CHAN_INFO_INT_TIME:
 173                 *val = 0;
 174                 *val2 = (256 - data->atime) * 2400;
 175                 return IIO_VAL_INT_PLUS_MICRO;
 176         }
 177         return -EINVAL;
 178 }
 179
 180 static int tcs3472_write_raw(struct iio_dev *indio_dev,
 181                                struct iio_chan_spec const *chan,
 182                                int val, int val2, long mask)
 183 {
 184         struct tcs3472_data *data = iio_priv(indio_dev);
 185         int i;
 186
 187         switch (mask) {
 188         case IIO_CHAN_INFO_CALIBSCALE:
 189                 if (val2 != 0)
 190                         return -EINVAL;
 191                 for (i = 0; i < ARRAY_SIZE(tcs3472_agains); i++) {
 192                         if (val == tcs3472_agains[i]) {
 193                                 data->control &= ~TCS3472_CONTROL_AGAIN_MASK;
 194                                 data->control |= i;
 195                                 return i2c_smbus_write_byte_data(
 196                                         data->client, TCS3472_CONTROL,
 197                                         data->control);
 198                         }
 199                 }
 200                 return -EINVAL;
 201         case IIO_CHAN_INFO_INT_TIME:
 202                 if (val != 0)
 203                         return -EINVAL;
 204                 for (i = 0; i < 256; i++) {
 205                         if (val2 == (256 - i) * 2400) {
 206                                 data->atime = i;
 207                                 return i2c_smbus_write_byte_data(
 208                                         data->client, TCS3472_ATIME,
 209                                         data->atime);
 210                         }
 211
 212                 }
 213                 return -EINVAL;
 214         }
 215         return -EINVAL;
 216 }
 217
 218 /*
 219  * Translation from APERS field value to the number of consecutive out-of-range
 220  * clear channel values before an interrupt is generated
 221  */
 222 static const int tcs3472_intr_pers[] = {
 223         0, 1, 2, 3, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60
 224 };
 225
 226 static int tcs3472_read_event(struct iio_dev *indio_dev,
 227         const struct iio_chan_spec *chan, enum iio_event_type type,
 228         enum iio_event_direction dir, enum iio_event_info info, int *val,
 229         int *val2)
 230 {
 231         struct tcs3472_data *data = iio_priv(indio_dev);
 232         int ret;
 233         unsigned int period;
 234
 235         mutex_lock(&data->lock);
 236
 237         switch (info) {
 238         case IIO_EV_INFO_VALUE:
 239                 *val = (dir == IIO_EV_DIR_RISING) ?
 240                         data->high_thresh : data->low_thresh;
 241                 ret = IIO_VAL_INT;
 242                 break;
 243         case IIO_EV_INFO_PERIOD:
 244                 period = (256 - data->atime) * 2400 *
 245                         tcs3472_intr_pers[data->apers];
 246                 *val = period / USEC_PER_SEC;
 247                 *val2 = period % USEC_PER_SEC;
 248                 ret = IIO_VAL_INT_PLUS_MICRO;
 249                 break;
 250         default:
 251                 ret = -EINVAL;
 252                 break;
 253         }
 254
 255         mutex_unlock(&data->lock);
 256
 257         return ret;
 258 }
 259
 260 static int tcs3472_write_event(struct iio_dev *indio_dev,
 261         const struct iio_chan_spec *chan, enum iio_event_type type,
 262         enum iio_event_direction dir, enum iio_event_info info, int val,
 263         int val2)
 264 {
 265         struct tcs3472_data *data = iio_priv(indio_dev);
 266         int ret;
 267         u8 command;
 268         int period;
 269         int i;
 270
 271         mutex_lock(&data->lock);
 272         switch (info) {
 273         case IIO_EV_INFO_VALUE:
 274                 switch (dir) {
 275                 case IIO_EV_DIR_RISING:
 276                         command = TCS3472_AIHT;
 277                         break;
 278                 case IIO_EV_DIR_FALLING:
 279                         command = TCS3472_AILT;
 280                         break;
 281                 default:
 282                         ret = -EINVAL;
 283                         goto error;
 284                 }
 285                 ret = i2c_smbus_write_word_data(data->client, command, val);
 286                 if (ret)
 287                         goto error;
 288
 289                 if (dir == IIO_EV_DIR_RISING)
 290                         data->high_thresh = val;
 291                 else
 292                         data->low_thresh = val;
 293                 break;
 294         case IIO_EV_INFO_PERIOD:
 295                 period = val * USEC_PER_SEC + val2;
 296                 for (i = 1; i < ARRAY_SIZE(tcs3472_intr_pers) - 1; i++) {
 297                         if (period <= (256 - data->atime) * 2400 *
 298                                         tcs3472_intr_pers[i])
 299                                 break;
 300                 }
 301                 ret = i2c_smbus_write_byte_data(data->client, TCS3472_PERS, i);
 302                 if (ret)
 303                         goto error;
 304
 305                 data->apers = i;
 306                 break;
 307         default:
 308                 ret = -EINVAL;
 309                 break;
 310         }
 311 error:
 312         mutex_unlock(&data->lock);
 313
 314         return ret;
 315 }
 316
 317 static int tcs3472_read_event_config(struct iio_dev *indio_dev,
 318         const struct iio_chan_spec *chan, enum iio_event_type type,
 319         enum iio_event_direction dir)
 320 {
 321         struct tcs3472_data *data = iio_priv(indio_dev);
 322         int ret;
 323
 324         mutex_lock(&data->lock);
 325         ret = !!(data->enable & TCS3472_ENABLE_AIEN);
 326         mutex_unlock(&data->lock);
 327
 328         return ret;
 329 }
 330
 331 static int tcs3472_write_event_config(struct iio_dev *indio_dev,
 332         const struct iio_chan_spec *chan, enum iio_event_type type,
 333         enum iio_event_direction dir, int state)
 334 {
 335         struct tcs3472_data *data = iio_priv(indio_dev);
 336         int ret = 0;
 337         u8 enable_old;
 338
 339         mutex_lock(&data->lock);
 340
 341         enable_old = data->enable;
 342
 343         if (state)
 344                 data->enable |= TCS3472_ENABLE_AIEN;
 345         else
 346                 data->enable &= ~TCS3472_ENABLE_AIEN;
 347
 348         if (enable_old != data->enable) {
 349                 ret = i2c_smbus_write_byte_data(data->client, TCS3472_ENABLE,
 350                                                 data->enable);
 351                 if (ret)
 352                         data->enable = enable_old;
 353         }
 354         mutex_unlock(&data->lock);
 355
 356         return ret;
 357 }
 358
 359 static irqreturn_t tcs3472_event_handler(int irq, void *priv)
 360 {
 361         struct iio_dev *indio_dev = priv;
 362         struct tcs3472_data *data = iio_priv(indio_dev);
 363         int ret;
 364
 365         ret = i2c_smbus_read_byte_data(data->client, TCS3472_STATUS);
 366         if (ret >= 0 && (ret & TCS3472_STATUS_AINT)) {
 367                 iio_push_event(indio_dev, IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0,
 368                                                 IIO_EV_TYPE_THRESH,
 369                                                 IIO_EV_DIR_EITHER),
 370                                 iio_get_time_ns(indio_dev));
 371
 372                 i2c_smbus_read_byte_data(data->client, TCS3472_INTR_CLEAR);
 373         }
 374
 375         return IRQ_HANDLED;
 376 }
 377
 378 static irqreturn_t tcs3472_trigger_handler(int irq, void *p)
 379 {
 380         struct iio_poll_func *pf = p;
 381         struct iio_dev *indio_dev = pf->indio_dev;
 382         struct tcs3472_data *data = iio_priv(indio_dev);
 383         int i, j = 0;
 384
 385         int ret = tcs3472_req_data(data);
 386         if (ret < 0)
 387                 goto done;
 388
 389         for_each_set_bit(i, indio_dev->active_scan_mask,
 390                 indio_dev->masklength) {
 391                 ret = i2c_smbus_read_word_data(data->client,
 392                         TCS3472_CDATA + 2*i);
 393                 if (ret < 0)
 394                         goto done;
 395
 396                 data->scan.chans[j++] = ret;
 397         }
 398
 399         iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
 400                 iio_get_time_ns(indio_dev));
 401
 402 done:
 403         iio_trigger_notify_done(indio_dev->trig);
 404
 405         return IRQ_HANDLED;
 406 }
 407
 408 static ssize_t tcs3472_show_int_time_available(struct device *dev,
 409                                         struct device_attribute *attr,
 410                                         char *buf)
 411 {
 412         size_t len = 0;
 413         int i;
 414
 415         for (i = 1; i <= 256; i++)
 416                 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06d ",
 417                         2400 * i);
 418
 419         /* replace trailing space by newline */
 420         buf[len - 1] = '\n';
 421
 422         return len;
 423 }
 424
 425 static IIO_CONST_ATTR(calibscale_available, "1 4 16 60");
 426 static IIO_DEV_ATTR_INT_TIME_AVAIL(tcs3472_show_int_time_available);
 427
 428 static struct attribute *tcs3472_attributes[] = {
 429         &iio_const_attr_calibscale_available.dev_attr.attr,
 430         &iio_dev_attr_integration_time_available.dev_attr.attr,
 431         NULL
 432 };
 433
 434 static const struct attribute_group tcs3472_attribute_group = {
 435         .attrs = tcs3472_attributes,
 436 };
 437
 438 static const struct iio_info tcs3472_info = {
 439         .read_raw = tcs3472_read_raw,
 440         .write_raw = tcs3472_write_raw,
 441         .read_event_value = tcs3472_read_event,
 442         .write_event_value = tcs3472_write_event,
 443         .read_event_config = tcs3472_read_event_config,
 444         .write_event_config = tcs3472_write_event_config,
 445         .attrs = &tcs3472_attribute_group,
 446 };
 447
 448 static int tcs3472_probe(struct i2c_client *client,
 449                            const struct i2c_device_id *id)
 450 {
 451         struct tcs3472_data *data;
 452         struct iio_dev *indio_dev;
 453         int ret;
 454
 455         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 456         if (indio_dev == NULL)
 457                 return -ENOMEM;
 458
 459         data = iio_priv(indio_dev);
 460         i2c_set_clientdata(client, indio_dev);
 461         data->client = client;
 462         mutex_init(&data->lock);
 463
 464         indio_dev->dev.parent = &client->dev;
 465         indio_dev->info = &tcs3472_info;
 466         indio_dev->name = TCS3472_DRV_NAME;
 467         indio_dev->channels = tcs3472_channels;
 468         indio_dev->num_channels = ARRAY_SIZE(tcs3472_channels);
 469         indio_dev->modes = INDIO_DIRECT_MODE;
 470
 471         ret = i2c_smbus_read_byte_data(data->client, TCS3472_ID);
 472         if (ret < 0)
 473                 return ret;
 474
 475         if (ret == 0x44)
 476                 dev_info(&client->dev, "TCS34721/34725 found\n");
 477         else if (ret == 0x4d)
 478                 dev_info(&client->dev, "TCS34723/34727 found\n");
 479         else
 480                 return -ENODEV;
 481
 482         ret = i2c_smbus_read_byte_data(data->client, TCS3472_CONTROL);
 483         if (ret < 0)
 484                 return ret;
 485         data->control = ret;
 486
 487         ret = i2c_smbus_read_byte_data(data->client, TCS3472_ATIME);
 488         if (ret < 0)
 489                 return ret;
 490         data->atime = ret;
 491
 492         ret = i2c_smbus_read_word_data(data->client, TCS3472_AILT);
 493         if (ret < 0)
 494                 return ret;
 495         data->low_thresh = ret;
 496
 497         ret = i2c_smbus_read_word_data(data->client, TCS3472_AIHT);
 498         if (ret < 0)
 499                 return ret;
 500         data->high_thresh = ret;
 501
 502         data->apers = 1;
 503         ret = i2c_smbus_write_byte_data(data->client, TCS3472_PERS,
 504                                         data->apers);
 505         if (ret < 0)
 506                 return ret;
 507
 508         ret = i2c_smbus_read_byte_data(data->client, TCS3472_ENABLE);
 509         if (ret < 0)
 510                 return ret;
 511
 512         /* enable device */
 513         data->enable = ret | TCS3472_ENABLE_PON | TCS3472_ENABLE_AEN;
 514         data->enable &= ~TCS3472_ENABLE_AIEN;
 515         ret = i2c_smbus_write_byte_data(data->client, TCS3472_ENABLE,
 516                 data->enable);
 517         if (ret < 0)
 518                 return ret;
 519
 520         ret = iio_triggered_buffer_setup(indio_dev, NULL,
 521                 tcs3472_trigger_handler, NULL);
 522         if (ret < 0)
 523                 return ret;
 524
 525         if (client->irq) {
 526                 ret = request_threaded_irq(client->irq, NULL,
 527                                            tcs3472_event_handler,
 528                                            IRQF_TRIGGER_FALLING | IRQF_SHARED |
 529                                            IRQF_ONESHOT,
 530                                            client->name, indio_dev);
 531                 if (ret)
 532                         goto buffer_cleanup;
 533         }
 534
 535         ret = iio_device_register(indio_dev);
 536         if (ret < 0)
 537                 goto free_irq;
 538
 539         return 0;
 540
 541 free_irq:
 542         if (client->irq)
 543                 free_irq(client->irq, indio_dev);
 544 buffer_cleanup:
 545         iio_triggered_buffer_cleanup(indio_dev);
 546         return ret;
 547 }
 548
 549 static int tcs3472_powerdown(struct tcs3472_data *data)
 550 {
 551         int ret;
 552         u8 enable_mask = TCS3472_ENABLE_AEN | TCS3472_ENABLE_PON;
 553
 554         mutex_lock(&data->lock);
 555
 556         ret = i2c_smbus_write_byte_data(data->client, TCS3472_ENABLE,
 557                 data->enable & ~enable_mask);
 558         if (!ret)
 559                 data->enable &= ~enable_mask;
 560
 561         mutex_unlock(&data->lock);
 562
 563         return ret;
 564 }
 565
 566 static int tcs3472_remove(struct i2c_client *client)
 567 {
 568         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 569
 570         iio_device_unregister(indio_dev);
 571         if (client->irq)
 572                 free_irq(client->irq, indio_dev);
 573         iio_triggered_buffer_cleanup(indio_dev);
 574         tcs3472_powerdown(iio_priv(indio_dev));
 575
 576         return 0;
 577 }
 578
 579 #ifdef CONFIG_PM_SLEEP
 580 static int tcs3472_suspend(struct device *dev)
 581 {
 582         struct tcs3472_data *data = iio_priv(i2c_get_clientdata(
 583                 to_i2c_client(dev)));
 584         return tcs3472_powerdown(data);
 585 }
 586
 587 static int tcs3472_resume(struct device *dev)
 588 {
 589         struct tcs3472_data *data = iio_priv(i2c_get_clientdata(
 590                 to_i2c_client(dev)));
 591         int ret;
 592         u8 enable_mask = TCS3472_ENABLE_AEN | TCS3472_ENABLE_PON;
 593
 594         mutex_lock(&data->lock);
 595
 596         ret = i2c_smbus_write_byte_data(data->client, TCS3472_ENABLE,
 597                 data->enable | enable_mask);
 598         if (!ret)
 599                 data->enable |= enable_mask;
 600
 601         mutex_unlock(&data->lock);
 602
 603         return ret;
 604 }
 605 #endif
 606
 607 static SIMPLE_DEV_PM_OPS(tcs3472_pm_ops, tcs3472_suspend, tcs3472_resume);
 608
 609 static const struct i2c_device_id tcs3472_id[] = {
 610         { "tcs3472", 0 },
 611         { }
 612 };
 613 MODULE_DEVICE_TABLE(i2c, tcs3472_id);
 614
 615 static struct i2c_driver tcs3472_driver = {
 616         .driver = {
 617                 .name   = TCS3472_DRV_NAME,
 618                 .pm     = &tcs3472_pm_ops,
 619         },
 620         .probe          = tcs3472_probe,
 621         .remove         = tcs3472_remove,
 622         .id_table       = tcs3472_id,
 623 };
 624 module_i2c_driver(tcs3472_driver);
 625
 626 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
 627 MODULE_DESCRIPTION("TCS3472 color light sensors driver");
 628 MODULE_LICENSE("GPL");