drivers/iio/light/lm3533-als.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * lm3533-als.c -- LM3533 Ambient Light Sensor driver
   4  *
   5  * Copyright (C) 2011-2012 Texas Instruments
   6  *
   7  * Author: Johan Hovold <jhovold@gmail.com>
   8  */
   9
  10 #include <linux/atomic.h>
  11 #include <linux/fs.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/io.h>
  14 #include <linux/iio/events.h>
  15 #include <linux/iio/iio.h>
  16 #include <linux/module.h>
  17 #include <linux/mutex.h>
  18 #include <linux/mfd/core.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/slab.h>
  21 #include <linux/uaccess.h>
  22
  23 #include <linux/mfd/lm3533.h>
  24
  25
  26 #define LM3533_ALS_RESISTOR_MIN                 1
  27 #define LM3533_ALS_RESISTOR_MAX                 127
  28 #define LM3533_ALS_CHANNEL_CURRENT_MAX          2
  29 #define LM3533_ALS_THRESH_MAX                   3
  30 #define LM3533_ALS_ZONE_MAX                     4
  31
  32 #define LM3533_REG_ALS_RESISTOR_SELECT          0x30
  33 #define LM3533_REG_ALS_CONF                     0x31
  34 #define LM3533_REG_ALS_ZONE_INFO                0x34
  35 #define LM3533_REG_ALS_READ_ADC_RAW             0x37
  36 #define LM3533_REG_ALS_READ_ADC_AVERAGE         0x38
  37 #define LM3533_REG_ALS_BOUNDARY_BASE            0x50
  38 #define LM3533_REG_ALS_TARGET_BASE              0x60
  39
  40 #define LM3533_ALS_ENABLE_MASK                  0x01
  41 #define LM3533_ALS_INPUT_MODE_MASK              0x02
  42 #define LM3533_ALS_INT_ENABLE_MASK              0x01
  43
  44 #define LM3533_ALS_ZONE_SHIFT                   2
  45 #define LM3533_ALS_ZONE_MASK                    0x1c
  46
  47 #define LM3533_ALS_FLAG_INT_ENABLED             1
  48
  49
  50 struct lm3533_als {
  51         struct lm3533 *lm3533;
  52         struct platform_device *pdev;
  53
  54         unsigned long flags;
  55         int irq;
  56
  57         atomic_t zone;
  58         struct mutex thresh_mutex;
  59 };
  60
  61
  62 static int lm3533_als_get_adc(struct iio_dev *indio_dev, bool average,
  63                                                                 int *adc)
  64 {
  65         struct lm3533_als *als = iio_priv(indio_dev);
  66         u8 reg;
  67         u8 val;
  68         int ret;
  69
  70         if (average)
  71                 reg = LM3533_REG_ALS_READ_ADC_AVERAGE;
  72         else
  73                 reg = LM3533_REG_ALS_READ_ADC_RAW;
  74
  75         ret = lm3533_read(als->lm3533, reg, &val);
  76         if (ret) {
  77                 dev_err(&indio_dev->dev, "failed to read adc\n");
  78                 return ret;
  79         }
  80
  81         *adc = val;
  82
  83         return 0;
  84 }
  85
  86 static int _lm3533_als_get_zone(struct iio_dev *indio_dev, u8 *zone)
  87 {
  88         struct lm3533_als *als = iio_priv(indio_dev);
  89         u8 val;
  90         int ret;
  91
  92         ret = lm3533_read(als->lm3533, LM3533_REG_ALS_ZONE_INFO, &val);
  93         if (ret) {
  94                 dev_err(&indio_dev->dev, "failed to read zone\n");
  95                 return ret;
  96         }
  97
  98         val = (val & LM3533_ALS_ZONE_MASK) >> LM3533_ALS_ZONE_SHIFT;
  99         *zone = min_t(u8, val, LM3533_ALS_ZONE_MAX);
 100
 101         return 0;
 102 }
 103
 104 static int lm3533_als_get_zone(struct iio_dev *indio_dev, u8 *zone)
 105 {
 106         struct lm3533_als *als = iio_priv(indio_dev);
 107         int ret;
 108
 109         if (test_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags)) {
 110                 *zone = atomic_read(&als->zone);
 111         } else {
 112                 ret = _lm3533_als_get_zone(indio_dev, zone);
 113                 if (ret)
 114                         return ret;
 115         }
 116
 117         return 0;
 118 }
 119
 120 /*
 121  * channel      output channel 0..2
 122  * zone         zone 0..4
 123  */
 124 static inline u8 lm3533_als_get_target_reg(unsigned channel, unsigned zone)
 125 {
 126         return LM3533_REG_ALS_TARGET_BASE + 5 * channel + zone;
 127 }
 128
 129 static int lm3533_als_get_target(struct iio_dev *indio_dev, unsigned channel,
 130                                                         unsigned zone, u8 *val)
 131 {
 132         struct lm3533_als *als = iio_priv(indio_dev);
 133         u8 reg;
 134         int ret;
 135
 136         if (channel > LM3533_ALS_CHANNEL_CURRENT_MAX)
 137                 return -EINVAL;
 138
 139         if (zone > LM3533_ALS_ZONE_MAX)
 140                 return -EINVAL;
 141
 142         reg = lm3533_als_get_target_reg(channel, zone);
 143         ret = lm3533_read(als->lm3533, reg, val);
 144         if (ret)
 145                 dev_err(&indio_dev->dev, "failed to get target current\n");
 146
 147         return ret;
 148 }
 149
 150 static int lm3533_als_set_target(struct iio_dev *indio_dev, unsigned channel,
 151                                                         unsigned zone, u8 val)
 152 {
 153         struct lm3533_als *als = iio_priv(indio_dev);
 154         u8 reg;
 155         int ret;
 156
 157         if (channel > LM3533_ALS_CHANNEL_CURRENT_MAX)
 158                 return -EINVAL;
 159
 160         if (zone > LM3533_ALS_ZONE_MAX)
 161                 return -EINVAL;
 162
 163         reg = lm3533_als_get_target_reg(channel, zone);
 164         ret = lm3533_write(als->lm3533, reg, val);
 165         if (ret)
 166                 dev_err(&indio_dev->dev, "failed to set target current\n");
 167
 168         return ret;
 169 }
 170
 171 static int lm3533_als_get_current(struct iio_dev *indio_dev, unsigned channel,
 172                                                                 int *val)
 173 {
 174         u8 zone;
 175         u8 target;
 176         int ret;
 177
 178         ret = lm3533_als_get_zone(indio_dev, &zone);
 179         if (ret)
 180                 return ret;
 181
 182         ret = lm3533_als_get_target(indio_dev, channel, zone, &target);
 183         if (ret)
 184                 return ret;
 185
 186         *val = target;
 187
 188         return 0;
 189 }
 190
 191 static int lm3533_als_read_raw(struct iio_dev *indio_dev,
 192                                 struct iio_chan_spec const *chan,
 193                                 int *val, int *val2, long mask)
 194 {
 195         int ret;
 196
 197         switch (mask) {
 198         case IIO_CHAN_INFO_RAW:
 199                 switch (chan->type) {
 200                 case IIO_LIGHT:
 201                         ret = lm3533_als_get_adc(indio_dev, false, val);
 202                         break;
 203                 case IIO_CURRENT:
 204                         ret = lm3533_als_get_current(indio_dev, chan->channel,
 205                                                                         val);
 206                         break;
 207                 default:
 208                         return -EINVAL;
 209                 }
 210                 break;
 211         case IIO_CHAN_INFO_AVERAGE_RAW:
 212                 ret = lm3533_als_get_adc(indio_dev, true, val);
 213                 break;
 214         default:
 215                 return -EINVAL;
 216         }
 217
 218         if (ret)
 219                 return ret;
 220
 221         return IIO_VAL_INT;
 222 }
 223
 224 #define CHANNEL_CURRENT(_channel)                                       \
 225         {                                                               \
 226                 .type           = IIO_CURRENT,                          \
 227                 .channel        = _channel,                             \
 228                 .indexed        = true,                                 \
 229                 .output         = true,                                 \
 230                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
 231         }
 232
 233 static const struct iio_chan_spec lm3533_als_channels[] = {
 234         {
 235                 .type           = IIO_LIGHT,
 236                 .channel        = 0,
 237                 .indexed        = true,
 238                 .info_mask_separate = BIT(IIO_CHAN_INFO_AVERAGE_RAW) |
 239                                    BIT(IIO_CHAN_INFO_RAW),
 240         },
 241         CHANNEL_CURRENT(0),
 242         CHANNEL_CURRENT(1),
 243         CHANNEL_CURRENT(2),
 244 };
 245
 246 static irqreturn_t lm3533_als_isr(int irq, void *dev_id)
 247 {
 248
 249         struct iio_dev *indio_dev = dev_id;
 250         struct lm3533_als *als = iio_priv(indio_dev);
 251         u8 zone;
 252         int ret;
 253
 254         /* Clear interrupt by reading the ALS zone register. */
 255         ret = _lm3533_als_get_zone(indio_dev, &zone);
 256         if (ret)
 257                 goto out;
 258
 259         atomic_set(&als->zone, zone);
 260
 261         iio_push_event(indio_dev,
 262                        IIO_UNMOD_EVENT_CODE(IIO_LIGHT,
 263                                             0,
 264                                             IIO_EV_TYPE_THRESH,
 265                                             IIO_EV_DIR_EITHER),
 266                        iio_get_time_ns(indio_dev));
 267 out:
 268         return IRQ_HANDLED;
 269 }
 270
 271 static int lm3533_als_set_int_mode(struct iio_dev *indio_dev, int enable)
 272 {
 273         struct lm3533_als *als = iio_priv(indio_dev);
 274         u8 mask = LM3533_ALS_INT_ENABLE_MASK;
 275         u8 val;
 276         int ret;
 277
 278         if (enable)
 279                 val = mask;
 280         else
 281                 val = 0;
 282
 283         ret = lm3533_update(als->lm3533, LM3533_REG_ALS_ZONE_INFO, val, mask);
 284         if (ret) {
 285                 dev_err(&indio_dev->dev, "failed to set int mode %d\n",
 286                                                                 enable);
 287                 return ret;
 288         }
 289
 290         return 0;
 291 }
 292
 293 static int lm3533_als_get_int_mode(struct iio_dev *indio_dev, int *enable)
 294 {
 295         struct lm3533_als *als = iio_priv(indio_dev);
 296         u8 mask = LM3533_ALS_INT_ENABLE_MASK;
 297         u8 val;
 298         int ret;
 299
 300         ret = lm3533_read(als->lm3533, LM3533_REG_ALS_ZONE_INFO, &val);
 301         if (ret) {
 302                 dev_err(&indio_dev->dev, "failed to get int mode\n");
 303                 return ret;
 304         }
 305
 306         *enable = !!(val & mask);
 307
 308         return 0;
 309 }
 310
 311 static inline u8 lm3533_als_get_threshold_reg(unsigned nr, bool raising)
 312 {
 313         u8 offset = !raising;
 314
 315         return LM3533_REG_ALS_BOUNDARY_BASE + 2 * nr + offset;
 316 }
 317
 318 static int lm3533_als_get_threshold(struct iio_dev *indio_dev, unsigned nr,
 319                                                         bool raising, u8 *val)
 320 {
 321         struct lm3533_als *als = iio_priv(indio_dev);
 322         u8 reg;
 323         int ret;
 324
 325         if (nr > LM3533_ALS_THRESH_MAX)
 326                 return -EINVAL;
 327
 328         reg = lm3533_als_get_threshold_reg(nr, raising);
 329         ret = lm3533_read(als->lm3533, reg, val);
 330         if (ret)
 331                 dev_err(&indio_dev->dev, "failed to get threshold\n");
 332
 333         return ret;
 334 }
 335
 336 static int lm3533_als_set_threshold(struct iio_dev *indio_dev, unsigned nr,
 337                                                         bool raising, u8 val)
 338 {
 339         struct lm3533_als *als = iio_priv(indio_dev);
 340         u8 val2;
 341         u8 reg, reg2;
 342         int ret;
 343
 344         if (nr > LM3533_ALS_THRESH_MAX)
 345                 return -EINVAL;
 346
 347         reg = lm3533_als_get_threshold_reg(nr, raising);
 348         reg2 = lm3533_als_get_threshold_reg(nr, !raising);
 349
 350         mutex_lock(&als->thresh_mutex);
 351         ret = lm3533_read(als->lm3533, reg2, &val2);
 352         if (ret) {
 353                 dev_err(&indio_dev->dev, "failed to get threshold\n");
 354                 goto out;
 355         }
 356         /*
 357          * This device does not allow negative hysteresis (in fact, it uses
 358          * whichever value is smaller as the lower bound) so we need to make
 359          * sure that thresh_falling <= thresh_raising.
 360          */
 361         if ((raising && (val < val2)) || (!raising && (val > val2))) {
 362                 ret = -EINVAL;
 363                 goto out;
 364         }
 365
 366         ret = lm3533_write(als->lm3533, reg, val);
 367         if (ret) {
 368                 dev_err(&indio_dev->dev, "failed to set threshold\n");
 369                 goto out;
 370         }
 371 out:
 372         mutex_unlock(&als->thresh_mutex);
 373
 374         return ret;
 375 }
 376
 377 static int lm3533_als_get_hysteresis(struct iio_dev *indio_dev, unsigned nr,
 378                                                                 u8 *val)
 379 {
 380         struct lm3533_als *als = iio_priv(indio_dev);
 381         u8 falling;
 382         u8 raising;
 383         int ret;
 384
 385         if (nr > LM3533_ALS_THRESH_MAX)
 386                 return -EINVAL;
 387
 388         mutex_lock(&als->thresh_mutex);
 389         ret = lm3533_als_get_threshold(indio_dev, nr, false, &falling);
 390         if (ret)
 391                 goto out;
 392         ret = lm3533_als_get_threshold(indio_dev, nr, true, &raising);
 393         if (ret)
 394                 goto out;
 395
 396         *val = raising - falling;
 397 out:
 398         mutex_unlock(&als->thresh_mutex);
 399
 400         return ret;
 401 }
 402
 403 static ssize_t show_thresh_either_en(struct device *dev,
 404                                         struct device_attribute *attr,
 405                                         char *buf)
 406 {
 407         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 408         struct lm3533_als *als = iio_priv(indio_dev);
 409         int enable;
 410         int ret;
 411
 412         if (als->irq) {
 413                 ret = lm3533_als_get_int_mode(indio_dev, &enable);
 414                 if (ret)
 415                         return ret;
 416         } else {
 417                 enable = 0;
 418         }
 419
 420         return scnprintf(buf, PAGE_SIZE, "%u\n", enable);
 421 }
 422
 423 static ssize_t store_thresh_either_en(struct device *dev,
 424                                         struct device_attribute *attr,
 425                                         const char *buf, size_t len)
 426 {
 427         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 428         struct lm3533_als *als = iio_priv(indio_dev);
 429         unsigned long enable;
 430         bool int_enabled;
 431         u8 zone;
 432         int ret;
 433
 434         if (!als->irq)
 435                 return -EBUSY;
 436
 437         if (kstrtoul(buf, 0, &enable))
 438                 return -EINVAL;
 439
 440         int_enabled = test_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
 441
 442         if (enable && !int_enabled) {
 443                 ret = lm3533_als_get_zone(indio_dev, &zone);
 444                 if (ret)
 445                         return ret;
 446
 447                 atomic_set(&als->zone, zone);
 448
 449                 set_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
 450         }
 451
 452         ret = lm3533_als_set_int_mode(indio_dev, enable);
 453         if (ret) {
 454                 if (!int_enabled)
 455                         clear_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
 456
 457                 return ret;
 458         }
 459
 460         if (!enable)
 461                 clear_bit(LM3533_ALS_FLAG_INT_ENABLED, &als->flags);
 462
 463         return len;
 464 }
 465
 466 static ssize_t show_zone(struct device *dev,
 467                                 struct device_attribute *attr, char *buf)
 468 {
 469         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 470         u8 zone;
 471         int ret;
 472
 473         ret = lm3533_als_get_zone(indio_dev, &zone);
 474         if (ret)
 475                 return ret;
 476
 477         return scnprintf(buf, PAGE_SIZE, "%u\n", zone);
 478 }
 479
 480 enum lm3533_als_attribute_type {
 481         LM3533_ATTR_TYPE_HYSTERESIS,
 482         LM3533_ATTR_TYPE_TARGET,
 483         LM3533_ATTR_TYPE_THRESH_FALLING,
 484         LM3533_ATTR_TYPE_THRESH_RAISING,
 485 };
 486
 487 struct lm3533_als_attribute {
 488         struct device_attribute dev_attr;
 489         enum lm3533_als_attribute_type type;
 490         u8 val1;
 491         u8 val2;
 492 };
 493
 494 static inline struct lm3533_als_attribute *
 495 to_lm3533_als_attr(struct device_attribute *attr)
 496 {
 497         return container_of(attr, struct lm3533_als_attribute, dev_attr);
 498 }
 499
 500 static ssize_t show_als_attr(struct device *dev,
 501                                         struct device_attribute *attr,
 502                                         char *buf)
 503 {
 504         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 505         struct lm3533_als_attribute *als_attr = to_lm3533_als_attr(attr);
 506         u8 val;
 507         int ret;
 508
 509         switch (als_attr->type) {
 510         case LM3533_ATTR_TYPE_HYSTERESIS:
 511                 ret = lm3533_als_get_hysteresis(indio_dev, als_attr->val1,
 512                                                                         &val);
 513                 break;
 514         case LM3533_ATTR_TYPE_TARGET:
 515                 ret = lm3533_als_get_target(indio_dev, als_attr->val1,
 516                                                         als_attr->val2, &val);
 517                 break;
 518         case LM3533_ATTR_TYPE_THRESH_FALLING:
 519                 ret = lm3533_als_get_threshold(indio_dev, als_attr->val1,
 520                                                                 false, &val);
 521                 break;
 522         case LM3533_ATTR_TYPE_THRESH_RAISING:
 523                 ret = lm3533_als_get_threshold(indio_dev, als_attr->val1,
 524                                                                 true, &val);
 525                 break;
 526         default:
 527                 ret = -ENXIO;
 528         }
 529
 530         if (ret)
 531                 return ret;
 532
 533         return scnprintf(buf, PAGE_SIZE, "%u\n", val);
 534 }
 535
 536 static ssize_t store_als_attr(struct device *dev,
 537                                         struct device_attribute *attr,
 538                                         const char *buf, size_t len)
 539 {
 540         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 541         struct lm3533_als_attribute *als_attr = to_lm3533_als_attr(attr);
 542         u8 val;
 543         int ret;
 544
 545         if (kstrtou8(buf, 0, &val))
 546                 return -EINVAL;
 547
 548         switch (als_attr->type) {
 549         case LM3533_ATTR_TYPE_TARGET:
 550                 ret = lm3533_als_set_target(indio_dev, als_attr->val1,
 551                                                         als_attr->val2, val);
 552                 break;
 553         case LM3533_ATTR_TYPE_THRESH_FALLING:
 554                 ret = lm3533_als_set_threshold(indio_dev, als_attr->val1,
 555                                                                 false, val);
 556                 break;
 557         case LM3533_ATTR_TYPE_THRESH_RAISING:
 558                 ret = lm3533_als_set_threshold(indio_dev, als_attr->val1,
 559                                                                 true, val);
 560                 break;
 561         default:
 562                 ret = -ENXIO;
 563         }
 564
 565         if (ret)
 566                 return ret;
 567
 568         return len;
 569 }
 570
 571 #define ALS_ATTR(_name, _mode, _show, _store, _type, _val1, _val2)      \
 572         { .dev_attr     = __ATTR(_name, _mode, _show, _store),          \
 573           .type         = _type,                                        \
 574           .val1         = _val1,                                        \
 575           .val2         = _val2 }
 576
 577 #define LM3533_ALS_ATTR(_name, _mode, _show, _store, _type, _val1, _val2) \
 578         struct lm3533_als_attribute lm3533_als_attr_##_name =             \
 579                 ALS_ATTR(_name, _mode, _show, _store, _type, _val1, _val2)
 580
 581 #define ALS_TARGET_ATTR_RW(_channel, _zone)                             \
 582         LM3533_ALS_ATTR(out_current##_channel##_current##_zone##_raw,   \
 583                                 S_IRUGO | S_IWUSR,                      \
 584                                 show_als_attr, store_als_attr,          \
 585                                 LM3533_ATTR_TYPE_TARGET, _channel, _zone)
 586 /*
 587  * ALS output current values (ALS mapper targets)
 588  *
 589  * out_current[0-2]_current[0-4]_raw            0-255
 590  */
 591 static ALS_TARGET_ATTR_RW(0, 0);
 592 static ALS_TARGET_ATTR_RW(0, 1);
 593 static ALS_TARGET_ATTR_RW(0, 2);
 594 static ALS_TARGET_ATTR_RW(0, 3);
 595 static ALS_TARGET_ATTR_RW(0, 4);
 596
 597 static ALS_TARGET_ATTR_RW(1, 0);
 598 static ALS_TARGET_ATTR_RW(1, 1);
 599 static ALS_TARGET_ATTR_RW(1, 2);
 600 static ALS_TARGET_ATTR_RW(1, 3);
 601 static ALS_TARGET_ATTR_RW(1, 4);
 602
 603 static ALS_TARGET_ATTR_RW(2, 0);
 604 static ALS_TARGET_ATTR_RW(2, 1);
 605 static ALS_TARGET_ATTR_RW(2, 2);
 606 static ALS_TARGET_ATTR_RW(2, 3);
 607 static ALS_TARGET_ATTR_RW(2, 4);
 608
 609 #define ALS_THRESH_FALLING_ATTR_RW(_nr)                                 \
 610         LM3533_ALS_ATTR(in_illuminance0_thresh##_nr##_falling_value,    \
 611                         S_IRUGO | S_IWUSR,                              \
 612                         show_als_attr, store_als_attr,          \
 613                         LM3533_ATTR_TYPE_THRESH_FALLING, _nr, 0)
 614
 615 #define ALS_THRESH_RAISING_ATTR_RW(_nr)                                 \
 616         LM3533_ALS_ATTR(in_illuminance0_thresh##_nr##_raising_value,    \
 617                         S_IRUGO | S_IWUSR,                              \
 618                         show_als_attr, store_als_attr,                  \
 619                         LM3533_ATTR_TYPE_THRESH_RAISING, _nr, 0)
 620 /*
 621  * ALS Zone thresholds (boundaries)
 622  *
 623  * in_illuminance0_thresh[0-3]_falling_value    0-255
 624  * in_illuminance0_thresh[0-3]_raising_value    0-255
 625  */
 626 static ALS_THRESH_FALLING_ATTR_RW(0);
 627 static ALS_THRESH_FALLING_ATTR_RW(1);
 628 static ALS_THRESH_FALLING_ATTR_RW(2);
 629 static ALS_THRESH_FALLING_ATTR_RW(3);
 630
 631 static ALS_THRESH_RAISING_ATTR_RW(0);
 632 static ALS_THRESH_RAISING_ATTR_RW(1);
 633 static ALS_THRESH_RAISING_ATTR_RW(2);
 634 static ALS_THRESH_RAISING_ATTR_RW(3);
 635
 636 #define ALS_HYSTERESIS_ATTR_RO(_nr)                                     \
 637         LM3533_ALS_ATTR(in_illuminance0_thresh##_nr##_hysteresis,       \
 638                         S_IRUGO, show_als_attr, NULL,                   \
 639                         LM3533_ATTR_TYPE_HYSTERESIS, _nr, 0)
 640 /*
 641  * ALS Zone threshold hysteresis
 642  *
 643  * threshY_hysteresis = threshY_raising - threshY_falling
 644  *
 645  * in_illuminance0_thresh[0-3]_hysteresis       0-255
 646  * in_illuminance0_thresh[0-3]_hysteresis       0-255
 647  */
 648 static ALS_HYSTERESIS_ATTR_RO(0);
 649 static ALS_HYSTERESIS_ATTR_RO(1);
 650 static ALS_HYSTERESIS_ATTR_RO(2);
 651 static ALS_HYSTERESIS_ATTR_RO(3);
 652
 653 #define ILLUMINANCE_ATTR_RO(_name) \
 654         DEVICE_ATTR(in_illuminance0_##_name, S_IRUGO, show_##_name, NULL)
 655 #define ILLUMINANCE_ATTR_RW(_name) \
 656         DEVICE_ATTR(in_illuminance0_##_name, S_IRUGO | S_IWUSR, \
 657                                                 show_##_name, store_##_name)
 658 /*
 659  * ALS Zone threshold-event enable
 660  *
 661  * in_illuminance0_thresh_either_en             0,1
 662  */
 663 static ILLUMINANCE_ATTR_RW(thresh_either_en);
 664
 665 /*
 666  * ALS Current Zone
 667  *
 668  * in_illuminance0_zone         0-4
 669  */
 670 static ILLUMINANCE_ATTR_RO(zone);
 671
 672 static struct attribute *lm3533_als_event_attributes[] = {
 673         &dev_attr_in_illuminance0_thresh_either_en.attr,
 674         &lm3533_als_attr_in_illuminance0_thresh0_falling_value.dev_attr.attr,
 675         &lm3533_als_attr_in_illuminance0_thresh0_hysteresis.dev_attr.attr,
 676         &lm3533_als_attr_in_illuminance0_thresh0_raising_value.dev_attr.attr,
 677         &lm3533_als_attr_in_illuminance0_thresh1_falling_value.dev_attr.attr,
 678         &lm3533_als_attr_in_illuminance0_thresh1_hysteresis.dev_attr.attr,
 679         &lm3533_als_attr_in_illuminance0_thresh1_raising_value.dev_attr.attr,
 680         &lm3533_als_attr_in_illuminance0_thresh2_falling_value.dev_attr.attr,
 681         &lm3533_als_attr_in_illuminance0_thresh2_hysteresis.dev_attr.attr,
 682         &lm3533_als_attr_in_illuminance0_thresh2_raising_value.dev_attr.attr,
 683         &lm3533_als_attr_in_illuminance0_thresh3_falling_value.dev_attr.attr,
 684         &lm3533_als_attr_in_illuminance0_thresh3_hysteresis.dev_attr.attr,
 685         &lm3533_als_attr_in_illuminance0_thresh3_raising_value.dev_attr.attr,
 686         NULL
 687 };
 688
 689 static const struct attribute_group lm3533_als_event_attribute_group = {
 690         .attrs = lm3533_als_event_attributes
 691 };
 692
 693 static struct attribute *lm3533_als_attributes[] = {
 694         &dev_attr_in_illuminance0_zone.attr,
 695         &lm3533_als_attr_out_current0_current0_raw.dev_attr.attr,
 696         &lm3533_als_attr_out_current0_current1_raw.dev_attr.attr,
 697         &lm3533_als_attr_out_current0_current2_raw.dev_attr.attr,
 698         &lm3533_als_attr_out_current0_current3_raw.dev_attr.attr,
 699         &lm3533_als_attr_out_current0_current4_raw.dev_attr.attr,
 700         &lm3533_als_attr_out_current1_current0_raw.dev_attr.attr,
 701         &lm3533_als_attr_out_current1_current1_raw.dev_attr.attr,
 702         &lm3533_als_attr_out_current1_current2_raw.dev_attr.attr,
 703         &lm3533_als_attr_out_current1_current3_raw.dev_attr.attr,
 704         &lm3533_als_attr_out_current1_current4_raw.dev_attr.attr,
 705         &lm3533_als_attr_out_current2_current0_raw.dev_attr.attr,
 706         &lm3533_als_attr_out_current2_current1_raw.dev_attr.attr,
 707         &lm3533_als_attr_out_current2_current2_raw.dev_attr.attr,
 708         &lm3533_als_attr_out_current2_current3_raw.dev_attr.attr,
 709         &lm3533_als_attr_out_current2_current4_raw.dev_attr.attr,
 710         NULL
 711 };
 712
 713 static const struct attribute_group lm3533_als_attribute_group = {
 714         .attrs = lm3533_als_attributes
 715 };
 716
 717 static int lm3533_als_set_input_mode(struct lm3533_als *als, bool pwm_mode)
 718 {
 719         u8 mask = LM3533_ALS_INPUT_MODE_MASK;
 720         u8 val;
 721         int ret;
 722
 723         if (pwm_mode)
 724                 val = mask;     /* pwm input */
 725         else
 726                 val = 0;        /* analog input */
 727
 728         ret = lm3533_update(als->lm3533, LM3533_REG_ALS_CONF, val, mask);
 729         if (ret) {
 730                 dev_err(&als->pdev->dev, "failed to set input mode %d\n",
 731                                                                 pwm_mode);
 732                 return ret;
 733         }
 734
 735         return 0;
 736 }
 737
 738 static int lm3533_als_set_resistor(struct lm3533_als *als, u8 val)
 739 {
 740         int ret;
 741
 742         if (val < LM3533_ALS_RESISTOR_MIN || val > LM3533_ALS_RESISTOR_MAX) {
 743                 dev_err(&als->pdev->dev, "invalid resistor value\n");
 744                 return -EINVAL;
 745         }
 746
 747         ret = lm3533_write(als->lm3533, LM3533_REG_ALS_RESISTOR_SELECT, val);
 748         if (ret) {
 749                 dev_err(&als->pdev->dev, "failed to set resistor\n");
 750                 return ret;
 751         }
 752
 753         return 0;
 754 }
 755
 756 static int lm3533_als_setup(struct lm3533_als *als,
 757                             struct lm3533_als_platform_data *pdata)
 758 {
 759         int ret;
 760
 761         ret = lm3533_als_set_input_mode(als, pdata->pwm_mode);
 762         if (ret)
 763                 return ret;
 764
 765         /* ALS input is always high impedance in PWM-mode. */
 766         if (!pdata->pwm_mode) {
 767                 ret = lm3533_als_set_resistor(als, pdata->r_select);
 768                 if (ret)
 769                         return ret;
 770         }
 771
 772         return 0;
 773 }
 774
 775 static int lm3533_als_setup_irq(struct lm3533_als *als, void *dev)
 776 {
 777         u8 mask = LM3533_ALS_INT_ENABLE_MASK;
 778         int ret;
 779
 780         /* Make sure interrupts are disabled. */
 781         ret = lm3533_update(als->lm3533, LM3533_REG_ALS_ZONE_INFO, 0, mask);
 782         if (ret) {
 783                 dev_err(&als->pdev->dev, "failed to disable interrupts\n");
 784                 return ret;
 785         }
 786
 787         ret = request_threaded_irq(als->irq, NULL, lm3533_als_isr,
 788                                         IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 789                                         dev_name(&als->pdev->dev), dev);
 790         if (ret) {
 791                 dev_err(&als->pdev->dev, "failed to request irq %d\n",
 792                                                                 als->irq);
 793                 return ret;
 794         }
 795
 796         return 0;
 797 }
 798
 799 static int lm3533_als_enable(struct lm3533_als *als)
 800 {
 801         u8 mask = LM3533_ALS_ENABLE_MASK;
 802         int ret;
 803
 804         ret = lm3533_update(als->lm3533, LM3533_REG_ALS_CONF, mask, mask);
 805         if (ret)
 806                 dev_err(&als->pdev->dev, "failed to enable ALS\n");
 807
 808         return ret;
 809 }
 810
 811 static int lm3533_als_disable(struct lm3533_als *als)
 812 {
 813         u8 mask = LM3533_ALS_ENABLE_MASK;
 814         int ret;
 815
 816         ret = lm3533_update(als->lm3533, LM3533_REG_ALS_CONF, 0, mask);
 817         if (ret)
 818                 dev_err(&als->pdev->dev, "failed to disable ALS\n");
 819
 820         return ret;
 821 }
 822
 823 static const struct iio_info lm3533_als_info = {
 824         .attrs          = &lm3533_als_attribute_group,
 825         .event_attrs    = &lm3533_als_event_attribute_group,
 826         .read_raw       = &lm3533_als_read_raw,
 827 };
 828
 829 static int lm3533_als_probe(struct platform_device *pdev)
 830 {
 831         struct lm3533 *lm3533;
 832         struct lm3533_als_platform_data *pdata;
 833         struct lm3533_als *als;
 834         struct iio_dev *indio_dev;
 835         int ret;
 836
 837         lm3533 = dev_get_drvdata(pdev->dev.parent);
 838         if (!lm3533)
 839                 return -EINVAL;
 840
 841         pdata = pdev->dev.platform_data;
 842         if (!pdata) {
 843                 dev_err(&pdev->dev, "no platform data\n");
 844                 return -EINVAL;
 845         }
 846
 847         indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*als));
 848         if (!indio_dev)
 849                 return -ENOMEM;
 850
 851         indio_dev->info = &lm3533_als_info;
 852         indio_dev->channels = lm3533_als_channels;
 853         indio_dev->num_channels = ARRAY_SIZE(lm3533_als_channels);
 854         indio_dev->name = dev_name(&pdev->dev);
 855         iio_device_set_parent(indio_dev, pdev->dev.parent);
 856         indio_dev->modes = INDIO_DIRECT_MODE;
 857
 858         als = iio_priv(indio_dev);
 859         als->lm3533 = lm3533;
 860         als->pdev = pdev;
 861         als->irq = lm3533->irq;
 862         atomic_set(&als->zone, 0);
 863         mutex_init(&als->thresh_mutex);
 864
 865         platform_set_drvdata(pdev, indio_dev);
 866
 867         if (als->irq) {
 868                 ret = lm3533_als_setup_irq(als, indio_dev);
 869                 if (ret)
 870                         return ret;
 871         }
 872
 873         ret = lm3533_als_setup(als, pdata);
 874         if (ret)
 875                 goto err_free_irq;
 876
 877         ret = lm3533_als_enable(als);
 878         if (ret)
 879                 goto err_free_irq;
 880
 881         ret = iio_device_register(indio_dev);
 882         if (ret) {
 883                 dev_err(&pdev->dev, "failed to register ALS\n");
 884                 goto err_disable;
 885         }
 886
 887         return 0;
 888
 889 err_disable:
 890         lm3533_als_disable(als);
 891 err_free_irq:
 892         if (als->irq)
 893                 free_irq(als->irq, indio_dev);
 894
 895         return ret;
 896 }
 897
 898 static int lm3533_als_remove(struct platform_device *pdev)
 899 {
 900         struct iio_dev *indio_dev = platform_get_drvdata(pdev);
 901         struct lm3533_als *als = iio_priv(indio_dev);
 902
 903         lm3533_als_set_int_mode(indio_dev, false);
 904         iio_device_unregister(indio_dev);
 905         lm3533_als_disable(als);
 906         if (als->irq)
 907                 free_irq(als->irq, indio_dev);
 908
 909         return 0;
 910 }
 911
 912 static struct platform_driver lm3533_als_driver = {
 913         .driver = {
 914                 .name   = "lm3533-als",
 915         },
 916         .probe          = lm3533_als_probe,
 917         .remove         = lm3533_als_remove,
 918 };
 919 module_platform_driver(lm3533_als_driver);
 920
 921 MODULE_AUTHOR("Johan Hovold <jhovold@gmail.com>");
 922 MODULE_DESCRIPTION("LM3533 Ambient Light Sensor driver");
 923 MODULE_LICENSE("GPL");
 924 MODULE_ALIAS("platform:lm3533-als");