drivers/iio/light/tsl2772.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Device driver for monitoring ambient light intensity in (lux) and proximity
   4  * detection (prox) within the TAOS TSL2571, TSL2671, TMD2671, TSL2771, TMD2771,
   5  * TSL2572, TSL2672, TMD2672, TSL2772, and TMD2772 devices.
   6  *
   7  * Copyright (c) 2012, TAOS Corporation.
   8  * Copyright (c) 2017-2018 Brian Masney <masneyb@onstation.org>
   9  */
  10
  11 #include <linux/delay.h>
  12 #include <linux/errno.h>
  13 #include <linux/i2c.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/mutex.h>
  18 #include <linux/property.h>
  19 #include <linux/slab.h>
  20
  21 #include <linux/iio/events.h>
  22 #include <linux/iio/iio.h>
  23 #include <linux/iio/sysfs.h>
  24 #include <linux/platform_data/tsl2772.h>
  25 #include <linux/regulator/consumer.h>
  26
  27 /* Cal defs */
  28 #define PROX_STAT_CAL                   0
  29 #define PROX_STAT_SAMP                  1
  30 #define MAX_SAMPLES_CAL                 200
  31
  32 /* TSL2772 Device ID */
  33 #define TRITON_ID                       0x00
  34 #define SWORDFISH_ID                    0x30
  35 #define HALIBUT_ID                      0x20
  36
  37 /* Lux calculation constants */
  38 #define TSL2772_LUX_CALC_OVER_FLOW      65535
  39
  40 /*
  41  * TAOS Register definitions - Note: depending on device, some of these register
  42  * are not used and the register address is benign.
  43  */
  44
  45 /* Register offsets */
  46 #define TSL2772_MAX_CONFIG_REG          16
  47
  48 /* Device Registers and Masks */
  49 #define TSL2772_CNTRL                   0x00
  50 #define TSL2772_ALS_TIME                0X01
  51 #define TSL2772_PRX_TIME                0x02
  52 #define TSL2772_WAIT_TIME               0x03
  53 #define TSL2772_ALS_MINTHRESHLO         0X04
  54 #define TSL2772_ALS_MINTHRESHHI         0X05
  55 #define TSL2772_ALS_MAXTHRESHLO         0X06
  56 #define TSL2772_ALS_MAXTHRESHHI         0X07
  57 #define TSL2772_PRX_MINTHRESHLO         0X08
  58 #define TSL2772_PRX_MINTHRESHHI         0X09
  59 #define TSL2772_PRX_MAXTHRESHLO         0X0A
  60 #define TSL2772_PRX_MAXTHRESHHI         0X0B
  61 #define TSL2772_PERSISTENCE             0x0C
  62 #define TSL2772_ALS_PRX_CONFIG          0x0D
  63 #define TSL2772_PRX_COUNT               0x0E
  64 #define TSL2772_GAIN                    0x0F
  65 #define TSL2772_NOTUSED                 0x10
  66 #define TSL2772_REVID                   0x11
  67 #define TSL2772_CHIPID                  0x12
  68 #define TSL2772_STATUS                  0x13
  69 #define TSL2772_ALS_CHAN0LO             0x14
  70 #define TSL2772_ALS_CHAN0HI             0x15
  71 #define TSL2772_ALS_CHAN1LO             0x16
  72 #define TSL2772_ALS_CHAN1HI             0x17
  73 #define TSL2772_PRX_LO                  0x18
  74 #define TSL2772_PRX_HI                  0x19
  75
  76 /* tsl2772 cmd reg masks */
  77 #define TSL2772_CMD_REG                 0x80
  78 #define TSL2772_CMD_SPL_FN              0x60
  79 #define TSL2772_CMD_REPEAT_PROTO        0x00
  80 #define TSL2772_CMD_AUTOINC_PROTO       0x20
  81
  82 #define TSL2772_CMD_PROX_INT_CLR        0X05
  83 #define TSL2772_CMD_ALS_INT_CLR         0x06
  84 #define TSL2772_CMD_PROXALS_INT_CLR     0X07
  85
  86 /* tsl2772 cntrl reg masks */
  87 #define TSL2772_CNTL_ADC_ENBL           0x02
  88 #define TSL2772_CNTL_PWR_ON             0x01
  89
  90 /* tsl2772 status reg masks */
  91 #define TSL2772_STA_ADC_VALID           0x01
  92 #define TSL2772_STA_PRX_VALID           0x02
  93 #define TSL2772_STA_ADC_PRX_VALID       (TSL2772_STA_ADC_VALID | \
  94                                          TSL2772_STA_PRX_VALID)
  95 #define TSL2772_STA_ALS_INTR            0x10
  96 #define TSL2772_STA_PRX_INTR            0x20
  97
  98 /* tsl2772 cntrl reg masks */
  99 #define TSL2772_CNTL_REG_CLEAR          0x00
 100 #define TSL2772_CNTL_PROX_INT_ENBL      0X20
 101 #define TSL2772_CNTL_ALS_INT_ENBL       0X10
 102 #define TSL2772_CNTL_WAIT_TMR_ENBL      0X08
 103 #define TSL2772_CNTL_PROX_DET_ENBL      0X04
 104 #define TSL2772_CNTL_PWRON              0x01
 105 #define TSL2772_CNTL_ALSPON_ENBL        0x03
 106 #define TSL2772_CNTL_INTALSPON_ENBL     0x13
 107 #define TSL2772_CNTL_PROXPON_ENBL       0x0F
 108 #define TSL2772_CNTL_INTPROXPON_ENBL    0x2F
 109
 110 #define TSL2772_ALS_GAIN_TRIM_MIN       250
 111 #define TSL2772_ALS_GAIN_TRIM_MAX       4000
 112
 113 #define TSL2772_MAX_PROX_LEDS           2
 114
 115 #define TSL2772_BOOT_MIN_SLEEP_TIME     10000
 116 #define TSL2772_BOOT_MAX_SLEEP_TIME     28000
 117
 118 /* Device family members */
 119 enum {
 120         tsl2571,
 121         tsl2671,
 122         tmd2671,
 123         tsl2771,
 124         tmd2771,
 125         tsl2572,
 126         tsl2672,
 127         tmd2672,
 128         tsl2772,
 129         tmd2772,
 130         apds9930,
 131 };
 132
 133 enum {
 134         TSL2772_CHIP_UNKNOWN = 0,
 135         TSL2772_CHIP_WORKING = 1,
 136         TSL2772_CHIP_SUSPENDED = 2
 137 };
 138
 139 enum {
 140         TSL2772_SUPPLY_VDD = 0,
 141         TSL2772_SUPPLY_VDDIO = 1,
 142         TSL2772_NUM_SUPPLIES = 2
 143 };
 144
 145 /* Per-device data */
 146 struct tsl2772_als_info {
 147         u16 als_ch0;
 148         u16 als_ch1;
 149         u16 lux;
 150 };
 151
 152 struct tsl2772_chip_info {
 153         int chan_table_elements;
 154         struct iio_chan_spec channel_with_events[4];
 155         struct iio_chan_spec channel_without_events[4];
 156         const struct iio_info *info;
 157 };
 158
 159 static const int tsl2772_led_currents[][2] = {
 160         { 100000, TSL2772_100_mA },
 161         {  50000, TSL2772_50_mA },
 162         {  25000, TSL2772_25_mA },
 163         {  13000, TSL2772_13_mA },
 164         {      0, 0 }
 165 };
 166
 167 struct tsl2772_chip {
 168         kernel_ulong_t id;
 169         struct mutex prox_mutex;
 170         struct mutex als_mutex;
 171         struct i2c_client *client;
 172         struct regulator_bulk_data supplies[TSL2772_NUM_SUPPLIES];
 173         u16 prox_data;
 174         struct tsl2772_als_info als_cur_info;
 175         struct tsl2772_settings settings;
 176         struct tsl2772_platform_data *pdata;
 177         int als_gain_time_scale;
 178         int als_saturation;
 179         int tsl2772_chip_status;
 180         u8 tsl2772_config[TSL2772_MAX_CONFIG_REG];
 181         const struct tsl2772_chip_info  *chip_info;
 182         const struct iio_info *info;
 183         s64 event_timestamp;
 184         /*
 185          * This structure is intentionally large to accommodate
 186          * updates via sysfs.
 187          * Sized to 9 = max 8 segments + 1 termination segment
 188          */
 189         struct tsl2772_lux tsl2772_device_lux[TSL2772_MAX_LUX_TABLE_SIZE];
 190 };
 191
 192 /*
 193  * Different devices require different coefficents, and these numbers were
 194  * derived from the 'Lux Equation' section of the various device datasheets.
 195  * All of these coefficients assume a Glass Attenuation (GA) factor of 1.
 196  * The coefficients are multiplied by 1000 to avoid floating point operations.
 197  * The two rows in each table correspond to the Lux1 and Lux2 equations from
 198  * the datasheets.
 199  */
 200 static const struct tsl2772_lux tsl2x71_lux_table[TSL2772_DEF_LUX_TABLE_SZ] = {
 201         { 53000, 106000 },
 202         { 31800,  53000 },
 203         { 0,          0 },
 204 };
 205
 206 static const struct tsl2772_lux tmd2x71_lux_table[TSL2772_DEF_LUX_TABLE_SZ] = {
 207         { 24000,  48000 },
 208         { 14400,  24000 },
 209         { 0,          0 },
 210 };
 211
 212 static const struct tsl2772_lux tsl2x72_lux_table[TSL2772_DEF_LUX_TABLE_SZ] = {
 213         { 60000, 112200 },
 214         { 37800,  60000 },
 215         {     0,      0 },
 216 };
 217
 218 static const struct tsl2772_lux tmd2x72_lux_table[TSL2772_DEF_LUX_TABLE_SZ] = {
 219         { 20000,  35000 },
 220         { 12600,  20000 },
 221         {     0,      0 },
 222 };
 223
 224 static const struct tsl2772_lux apds9930_lux_table[TSL2772_DEF_LUX_TABLE_SZ] = {
 225         { 52000,  96824 },
 226         { 38792,  67132 },
 227         {     0,      0 },
 228 };
 229
 230 static const struct tsl2772_lux *tsl2772_default_lux_table_group[] = {
 231         [tsl2571] = tsl2x71_lux_table,
 232         [tsl2671] = tsl2x71_lux_table,
 233         [tmd2671] = tmd2x71_lux_table,
 234         [tsl2771] = tsl2x71_lux_table,
 235         [tmd2771] = tmd2x71_lux_table,
 236         [tsl2572] = tsl2x72_lux_table,
 237         [tsl2672] = tsl2x72_lux_table,
 238         [tmd2672] = tmd2x72_lux_table,
 239         [tsl2772] = tsl2x72_lux_table,
 240         [tmd2772] = tmd2x72_lux_table,
 241         [apds9930] = apds9930_lux_table,
 242 };
 243
 244 static const struct tsl2772_settings tsl2772_default_settings = {
 245         .als_time = 255, /* 2.72 / 2.73 ms */
 246         .als_gain = 0,
 247         .prox_time = 255, /* 2.72 / 2.73 ms */
 248         .prox_gain = 0,
 249         .wait_time = 255,
 250         .als_prox_config = 0,
 251         .als_gain_trim = 1000,
 252         .als_cal_target = 150,
 253         .als_persistence = 1,
 254         .als_interrupt_en = false,
 255         .als_thresh_low = 200,
 256         .als_thresh_high = 256,
 257         .prox_persistence = 1,
 258         .prox_interrupt_en = false,
 259         .prox_thres_low  = 0,
 260         .prox_thres_high = 512,
 261         .prox_max_samples_cal = 30,
 262         .prox_pulse_count = 8,
 263         .prox_diode = TSL2772_DIODE1,
 264         .prox_power = TSL2772_100_mA
 265 };
 266
 267 static const s16 tsl2772_als_gain[] = {
 268         1,
 269         8,
 270         16,
 271         120
 272 };
 273
 274 static const s16 tsl2772_prox_gain[] = {
 275         1,
 276         2,
 277         4,
 278         8
 279 };
 280
 281 static const int tsl2772_int_time_avail[][6] = {
 282         [tsl2571] = { 0, 2720, 0, 2720, 0, 696000 },
 283         [tsl2671] = { 0, 2720, 0, 2720, 0, 696000 },
 284         [tmd2671] = { 0, 2720, 0, 2720, 0, 696000 },
 285         [tsl2771] = { 0, 2720, 0, 2720, 0, 696000 },
 286         [tmd2771] = { 0, 2720, 0, 2720, 0, 696000 },
 287         [tsl2572] = { 0, 2730, 0, 2730, 0, 699000 },
 288         [tsl2672] = { 0, 2730, 0, 2730, 0, 699000 },
 289         [tmd2672] = { 0, 2730, 0, 2730, 0, 699000 },
 290         [tsl2772] = { 0, 2730, 0, 2730, 0, 699000 },
 291         [tmd2772] = { 0, 2730, 0, 2730, 0, 699000 },
 292         [apds9930] = { 0, 2730, 0, 2730, 0, 699000 },
 293 };
 294
 295 static int tsl2772_int_calibscale_avail[] = { 1, 8, 16, 120 };
 296
 297 static int tsl2772_prox_calibscale_avail[] = { 1, 2, 4, 8 };
 298
 299 /* Channel variations */
 300 enum {
 301         ALS,
 302         PRX,
 303         ALSPRX,
 304         PRX2,
 305         ALSPRX2,
 306 };
 307
 308 static const u8 device_channel_config[] = {
 309         [tsl2571] = ALS,
 310         [tsl2671] = PRX,
 311         [tmd2671] = PRX,
 312         [tsl2771] = ALSPRX,
 313         [tmd2771] = ALSPRX,
 314         [tsl2572] = ALS,
 315         [tsl2672] = PRX2,
 316         [tmd2672] = PRX2,
 317         [tsl2772] = ALSPRX2,
 318         [tmd2772] = ALSPRX2,
 319         [apds9930] = ALSPRX2,
 320 };
 321
 322 static int tsl2772_read_status(struct tsl2772_chip *chip)
 323 {
 324         int ret;
 325
 326         ret = i2c_smbus_read_byte_data(chip->client,
 327                                        TSL2772_CMD_REG | TSL2772_STATUS);
 328         if (ret < 0)
 329                 dev_err(&chip->client->dev,
 330                         "%s: failed to read STATUS register: %d\n", __func__,
 331                         ret);
 332
 333         return ret;
 334 }
 335
 336 static int tsl2772_write_control_reg(struct tsl2772_chip *chip, u8 data)
 337 {
 338         int ret;
 339
 340         ret = i2c_smbus_write_byte_data(chip->client,
 341                                         TSL2772_CMD_REG | TSL2772_CNTRL, data);
 342         if (ret < 0) {
 343                 dev_err(&chip->client->dev,
 344                         "%s: failed to write to control register %x: %d\n",
 345                         __func__, data, ret);
 346         }
 347
 348         return ret;
 349 }
 350
 351 static int tsl2772_read_autoinc_regs(struct tsl2772_chip *chip, int lower_reg,
 352                                      int upper_reg)
 353 {
 354         u8 buf[2];
 355         int ret;
 356
 357         ret = i2c_smbus_write_byte(chip->client,
 358                                    TSL2772_CMD_REG | TSL2772_CMD_AUTOINC_PROTO |
 359                                    lower_reg);
 360         if (ret < 0) {
 361                 dev_err(&chip->client->dev,
 362                         "%s: failed to enable auto increment protocol: %d\n",
 363                         __func__, ret);
 364                 return ret;
 365         }
 366
 367         ret = i2c_smbus_read_byte_data(chip->client,
 368                                        TSL2772_CMD_REG | lower_reg);
 369         if (ret < 0) {
 370                 dev_err(&chip->client->dev,
 371                         "%s: failed to read from register %x: %d\n", __func__,
 372                         lower_reg, ret);
 373                 return ret;
 374         }
 375         buf[0] = ret;
 376
 377         ret = i2c_smbus_read_byte_data(chip->client,
 378                                        TSL2772_CMD_REG | upper_reg);
 379         if (ret < 0) {
 380                 dev_err(&chip->client->dev,
 381                         "%s: failed to read from register %x: %d\n", __func__,
 382                         upper_reg, ret);
 383                 return ret;
 384         }
 385         buf[1] = ret;
 386
 387         ret = i2c_smbus_write_byte(chip->client,
 388                                    TSL2772_CMD_REG | TSL2772_CMD_REPEAT_PROTO |
 389                                    lower_reg);
 390         if (ret < 0) {
 391                 dev_err(&chip->client->dev,
 392                         "%s: failed to enable repeated byte protocol: %d\n",
 393                         __func__, ret);
 394                 return ret;
 395         }
 396
 397         return le16_to_cpup((const __le16 *)&buf[0]);
 398 }
 399
 400 /**
 401  * tsl2772_get_lux() - Reads and calculates current lux value.
 402  * @indio_dev:  pointer to IIO device
 403  *
 404  * The raw ch0 and ch1 values of the ambient light sensed in the last
 405  * integration cycle are read from the device. The raw values are multiplied
 406  * by a device-specific scale factor, and divided by the integration time and
 407  * device gain. The code supports multiple lux equations through the lux table
 408  * coefficients. A lux gain trim is applied to each lux equation, and then the
 409  * maximum lux within the interval 0..65535 is selected.
 410  */
 411 static int tsl2772_get_lux(struct iio_dev *indio_dev)
 412 {
 413         struct tsl2772_chip *chip = iio_priv(indio_dev);
 414         struct tsl2772_lux *p;
 415         int max_lux, ret;
 416         bool overflow;
 417
 418         mutex_lock(&chip->als_mutex);
 419
 420         if (chip->tsl2772_chip_status != TSL2772_CHIP_WORKING) {
 421                 dev_err(&chip->client->dev, "%s: device is not enabled\n",
 422                         __func__);
 423                 ret = -EBUSY;
 424                 goto out_unlock;
 425         }
 426
 427         ret = tsl2772_read_status(chip);
 428         if (ret < 0)
 429                 goto out_unlock;
 430
 431         if (!(ret & TSL2772_STA_ADC_VALID)) {
 432                 dev_err(&chip->client->dev,
 433                         "%s: data not valid yet\n", __func__);
 434                 ret = chip->als_cur_info.lux; /* return LAST VALUE */
 435                 goto out_unlock;
 436         }
 437
 438         ret = tsl2772_read_autoinc_regs(chip, TSL2772_ALS_CHAN0LO,
 439                                         TSL2772_ALS_CHAN0HI);
 440         if (ret < 0)
 441                 goto out_unlock;
 442         chip->als_cur_info.als_ch0 = ret;
 443
 444         ret = tsl2772_read_autoinc_regs(chip, TSL2772_ALS_CHAN1LO,
 445                                         TSL2772_ALS_CHAN1HI);
 446         if (ret < 0)
 447                 goto out_unlock;
 448         chip->als_cur_info.als_ch1 = ret;
 449
 450         if (chip->als_cur_info.als_ch0 >= chip->als_saturation) {
 451                 max_lux = TSL2772_LUX_CALC_OVER_FLOW;
 452                 goto update_struct_with_max_lux;
 453         }
 454
 455         if (!chip->als_cur_info.als_ch0) {
 456                 /* have no data, so return LAST VALUE */
 457                 ret = chip->als_cur_info.lux;
 458                 goto out_unlock;
 459         }
 460
 461         max_lux = 0;
 462         overflow = false;
 463         for (p = (struct tsl2772_lux *)chip->tsl2772_device_lux; p->ch0 != 0;
 464              p++) {
 465                 int lux;
 466
 467                 lux = ((chip->als_cur_info.als_ch0 * p->ch0) -
 468                        (chip->als_cur_info.als_ch1 * p->ch1)) /
 469                         chip->als_gain_time_scale;
 470
 471                 /*
 472                  * The als_gain_trim can have a value within the range 250..4000
 473                  * and is a multiplier for the lux. A trim of 1000 makes no
 474                  * changes to the lux, less than 1000 scales it down, and
 475                  * greater than 1000 scales it up.
 476                  */
 477                 lux = (lux * chip->settings.als_gain_trim) / 1000;
 478
 479                 if (lux > TSL2772_LUX_CALC_OVER_FLOW) {
 480                         overflow = true;
 481                         continue;
 482                 }
 483
 484                 max_lux = max(max_lux, lux);
 485         }
 486
 487         if (overflow && max_lux == 0)
 488                 max_lux = TSL2772_LUX_CALC_OVER_FLOW;
 489
 490 update_struct_with_max_lux:
 491         chip->als_cur_info.lux = max_lux;
 492         ret = max_lux;
 493
 494 out_unlock:
 495         mutex_unlock(&chip->als_mutex);
 496
 497         return ret;
 498 }
 499
 500 /**
 501  * tsl2772_get_prox() - Reads proximity data registers and updates
 502  *                      chip->prox_data.
 503  *
 504  * @indio_dev:  pointer to IIO device
 505  */
 506 static int tsl2772_get_prox(struct iio_dev *indio_dev)
 507 {
 508         struct tsl2772_chip *chip = iio_priv(indio_dev);
 509         int ret;
 510
 511         mutex_lock(&chip->prox_mutex);
 512
 513         ret = tsl2772_read_status(chip);
 514         if (ret < 0)
 515                 goto prox_poll_err;
 516
 517         switch (chip->id) {
 518         case tsl2571:
 519         case tsl2671:
 520         case tmd2671:
 521         case tsl2771:
 522         case tmd2771:
 523                 if (!(ret & TSL2772_STA_ADC_VALID)) {
 524                         ret = -EINVAL;
 525                         goto prox_poll_err;
 526                 }
 527                 break;
 528         case tsl2572:
 529         case tsl2672:
 530         case tmd2672:
 531         case tsl2772:
 532         case tmd2772:
 533         case apds9930:
 534                 if (!(ret & TSL2772_STA_PRX_VALID)) {
 535                         ret = -EINVAL;
 536                         goto prox_poll_err;
 537                 }
 538                 break;
 539         }
 540
 541         ret = tsl2772_read_autoinc_regs(chip, TSL2772_PRX_LO, TSL2772_PRX_HI);
 542         if (ret < 0)
 543                 goto prox_poll_err;
 544         chip->prox_data = ret;
 545
 546 prox_poll_err:
 547         mutex_unlock(&chip->prox_mutex);
 548
 549         return ret;
 550 }
 551
 552 static int tsl2772_read_prox_led_current(struct tsl2772_chip *chip)
 553 {
 554         struct device *dev = &chip->client->dev;
 555         int ret, tmp, i;
 556
 557         ret = device_property_read_u32(dev, "led-max-microamp", &tmp);
 558         if (ret < 0)
 559                 return ret;
 560
 561         for (i = 0; tsl2772_led_currents[i][0] != 0; i++) {
 562                 if (tmp == tsl2772_led_currents[i][0]) {
 563                         chip->settings.prox_power = tsl2772_led_currents[i][1];
 564                         return 0;
 565                 }
 566         }
 567
 568         dev_err(dev, "Invalid value %d for led-max-microamp\n", tmp);
 569
 570         return -EINVAL;
 571 }
 572
 573 static int tsl2772_read_prox_diodes(struct tsl2772_chip *chip)
 574 {
 575         struct device *dev = &chip->client->dev;
 576         int i, ret, num_leds, prox_diode_mask;
 577         u32 leds[TSL2772_MAX_PROX_LEDS];
 578
 579         ret = device_property_count_u32(dev, "amstaos,proximity-diodes");
 580         if (ret < 0)
 581                 return ret;
 582
 583         num_leds = ret;
 584         if (num_leds > TSL2772_MAX_PROX_LEDS)
 585                 num_leds = TSL2772_MAX_PROX_LEDS;
 586
 587         ret = device_property_read_u32_array(dev, "amstaos,proximity-diodes", leds, num_leds);
 588         if (ret < 0) {
 589                 dev_err(dev, "Invalid value for amstaos,proximity-diodes: %d.\n", ret);
 590                 return ret;
 591         }
 592
 593         prox_diode_mask = 0;
 594         for (i = 0; i < num_leds; i++) {
 595                 if (leds[i] == 0)
 596                         prox_diode_mask |= TSL2772_DIODE0;
 597                 else if (leds[i] == 1)
 598                         prox_diode_mask |= TSL2772_DIODE1;
 599                 else {
 600                         dev_err(dev, "Invalid value %d in amstaos,proximity-diodes.\n", leds[i]);
 601                         return -EINVAL;
 602                 }
 603         }
 604         chip->settings.prox_diode = prox_diode_mask;
 605
 606         return 0;
 607 }
 608
 609 static void tsl2772_parse_dt(struct tsl2772_chip *chip)
 610 {
 611         tsl2772_read_prox_led_current(chip);
 612         tsl2772_read_prox_diodes(chip);
 613 }
 614
 615 /**
 616  * tsl2772_defaults() - Populates the device nominal operating parameters
 617  *                      with those provided by a 'platform' data struct or
 618  *                      with prefined defaults.
 619  *
 620  * @chip:               pointer to device structure.
 621  */
 622 static void tsl2772_defaults(struct tsl2772_chip *chip)
 623 {
 624         /* If Operational settings defined elsewhere.. */
 625         if (chip->pdata && chip->pdata->platform_default_settings)
 626                 memcpy(&chip->settings, chip->pdata->platform_default_settings,
 627                        sizeof(tsl2772_default_settings));
 628         else
 629                 memcpy(&chip->settings, &tsl2772_default_settings,
 630                        sizeof(tsl2772_default_settings));
 631
 632         /* Load up the proper lux table. */
 633         if (chip->pdata && chip->pdata->platform_lux_table[0].ch0 != 0)
 634                 memcpy(chip->tsl2772_device_lux,
 635                        chip->pdata->platform_lux_table,
 636                        sizeof(chip->pdata->platform_lux_table));
 637         else
 638                 memcpy(chip->tsl2772_device_lux,
 639                        tsl2772_default_lux_table_group[chip->id],
 640                        TSL2772_DEFAULT_TABLE_BYTES);
 641
 642         tsl2772_parse_dt(chip);
 643 }
 644
 645 /**
 646  * tsl2772_als_calibrate() -    Obtain single reading and calculate
 647  *                              the als_gain_trim.
 648  *
 649  * @indio_dev:  pointer to IIO device
 650  */
 651 static int tsl2772_als_calibrate(struct iio_dev *indio_dev)
 652 {
 653         struct tsl2772_chip *chip = iio_priv(indio_dev);
 654         int ret, lux_val;
 655
 656         ret = i2c_smbus_read_byte_data(chip->client,
 657                                        TSL2772_CMD_REG | TSL2772_CNTRL);
 658         if (ret < 0) {
 659                 dev_err(&chip->client->dev,
 660                         "%s: failed to read from the CNTRL register\n",
 661                         __func__);
 662                 return ret;
 663         }
 664
 665         if ((ret & (TSL2772_CNTL_ADC_ENBL | TSL2772_CNTL_PWR_ON))
 666                         != (TSL2772_CNTL_ADC_ENBL | TSL2772_CNTL_PWR_ON)) {
 667                 dev_err(&chip->client->dev,
 668                         "%s: Device is not powered on and/or ADC is not enabled\n",
 669                         __func__);
 670                 return -EINVAL;
 671         } else if ((ret & TSL2772_STA_ADC_VALID) != TSL2772_STA_ADC_VALID) {
 672                 dev_err(&chip->client->dev,
 673                         "%s: The two ADC channels have not completed an integration cycle\n",
 674                         __func__);
 675                 return -ENODATA;
 676         }
 677
 678         lux_val = tsl2772_get_lux(indio_dev);
 679         if (lux_val < 0) {
 680                 dev_err(&chip->client->dev,
 681                         "%s: failed to get lux\n", __func__);
 682                 return lux_val;
 683         }
 684         if (lux_val == 0)
 685                 return -ERANGE;
 686
 687         ret = (chip->settings.als_cal_target * chip->settings.als_gain_trim) /
 688                         lux_val;
 689         if (ret < TSL2772_ALS_GAIN_TRIM_MIN || ret > TSL2772_ALS_GAIN_TRIM_MAX)
 690                 return -ERANGE;
 691
 692         chip->settings.als_gain_trim = ret;
 693
 694         return ret;
 695 }
 696
 697 static void tsl2772_disable_regulators_action(void *_data)
 698 {
 699         struct tsl2772_chip *chip = _data;
 700
 701         regulator_bulk_disable(ARRAY_SIZE(chip->supplies), chip->supplies);
 702 }
 703
 704 static int tsl2772_chip_on(struct iio_dev *indio_dev)
 705 {
 706         struct tsl2772_chip *chip = iio_priv(indio_dev);
 707         int ret, i, als_count, als_time_us;
 708         u8 *dev_reg, reg_val;
 709
 710         /* Non calculated parameters */
 711         chip->tsl2772_config[TSL2772_ALS_TIME] = chip->settings.als_time;
 712         chip->tsl2772_config[TSL2772_PRX_TIME] = chip->settings.prox_time;
 713         chip->tsl2772_config[TSL2772_WAIT_TIME] = chip->settings.wait_time;
 714         chip->tsl2772_config[TSL2772_ALS_PRX_CONFIG] =
 715                 chip->settings.als_prox_config;
 716
 717         chip->tsl2772_config[TSL2772_ALS_MINTHRESHLO] =
 718                 (chip->settings.als_thresh_low) & 0xFF;
 719         chip->tsl2772_config[TSL2772_ALS_MINTHRESHHI] =
 720                 (chip->settings.als_thresh_low >> 8) & 0xFF;
 721         chip->tsl2772_config[TSL2772_ALS_MAXTHRESHLO] =
 722                 (chip->settings.als_thresh_high) & 0xFF;
 723         chip->tsl2772_config[TSL2772_ALS_MAXTHRESHHI] =
 724                 (chip->settings.als_thresh_high >> 8) & 0xFF;
 725         chip->tsl2772_config[TSL2772_PERSISTENCE] =
 726                 (chip->settings.prox_persistence & 0xFF) << 4 |
 727                 (chip->settings.als_persistence & 0xFF);
 728
 729         chip->tsl2772_config[TSL2772_PRX_COUNT] =
 730                         chip->settings.prox_pulse_count;
 731         chip->tsl2772_config[TSL2772_PRX_MINTHRESHLO] =
 732                         (chip->settings.prox_thres_low) & 0xFF;
 733         chip->tsl2772_config[TSL2772_PRX_MINTHRESHHI] =
 734                         (chip->settings.prox_thres_low >> 8) & 0xFF;
 735         chip->tsl2772_config[TSL2772_PRX_MAXTHRESHLO] =
 736                         (chip->settings.prox_thres_high) & 0xFF;
 737         chip->tsl2772_config[TSL2772_PRX_MAXTHRESHHI] =
 738                         (chip->settings.prox_thres_high >> 8) & 0xFF;
 739
 740         /* and make sure we're not already on */
 741         if (chip->tsl2772_chip_status == TSL2772_CHIP_WORKING) {
 742                 /* if forcing a register update - turn off, then on */
 743                 dev_info(&chip->client->dev, "device is already enabled\n");
 744                 return -EINVAL;
 745         }
 746
 747         /* Set the gain based on tsl2772_settings struct */
 748         chip->tsl2772_config[TSL2772_GAIN] =
 749                 (chip->settings.als_gain & 0xFF) |
 750                 ((chip->settings.prox_gain & 0xFF) << 2) |
 751                 (chip->settings.prox_diode << 4) |
 752                 (chip->settings.prox_power << 6);
 753
 754         /* set chip time scaling and saturation */
 755         als_count = 256 - chip->settings.als_time;
 756         als_time_us = als_count * tsl2772_int_time_avail[chip->id][3];
 757         chip->als_saturation = als_count * 768; /* 75% of full scale */
 758         chip->als_gain_time_scale = als_time_us *
 759                 tsl2772_als_gain[chip->settings.als_gain];
 760
 761         /*
 762          * TSL2772 Specific power-on / adc enable sequence
 763          * Power on the device 1st.
 764          */
 765         ret = tsl2772_write_control_reg(chip, TSL2772_CNTL_PWR_ON);
 766         if (ret < 0)
 767                 return ret;
 768
 769         /*
 770          * Use the following shadow copy for our delay before enabling ADC.
 771          * Write all the registers.
 772          */
 773         for (i = 0, dev_reg = chip->tsl2772_config;
 774                         i < TSL2772_MAX_CONFIG_REG; i++) {
 775                 int reg = TSL2772_CMD_REG + i;
 776
 777                 ret = i2c_smbus_write_byte_data(chip->client, reg,
 778                                                 *dev_reg++);
 779                 if (ret < 0) {
 780                         dev_err(&chip->client->dev,
 781                                 "%s: failed to write to register %x: %d\n",
 782                                 __func__, reg, ret);
 783                         return ret;
 784                 }
 785         }
 786
 787         /* Power-on settling time */
 788         usleep_range(3000, 3500);
 789
 790         reg_val = TSL2772_CNTL_PWR_ON | TSL2772_CNTL_ADC_ENBL |
 791                   TSL2772_CNTL_PROX_DET_ENBL;
 792         if (chip->settings.als_interrupt_en)
 793                 reg_val |= TSL2772_CNTL_ALS_INT_ENBL;
 794         if (chip->settings.prox_interrupt_en)
 795                 reg_val |= TSL2772_CNTL_PROX_INT_ENBL;
 796
 797         ret = tsl2772_write_control_reg(chip, reg_val);
 798         if (ret < 0)
 799                 return ret;
 800
 801         ret = i2c_smbus_write_byte(chip->client,
 802                                    TSL2772_CMD_REG | TSL2772_CMD_SPL_FN |
 803                                    TSL2772_CMD_PROXALS_INT_CLR);
 804         if (ret < 0) {
 805                 dev_err(&chip->client->dev,
 806                         "%s: failed to clear interrupt status: %d\n",
 807                         __func__, ret);
 808                 return ret;
 809         }
 810
 811         chip->tsl2772_chip_status = TSL2772_CHIP_WORKING;
 812
 813         return ret;
 814 }
 815
 816 static int tsl2772_chip_off(struct iio_dev *indio_dev)
 817 {
 818         struct tsl2772_chip *chip = iio_priv(indio_dev);
 819
 820         /* turn device off */
 821         chip->tsl2772_chip_status = TSL2772_CHIP_SUSPENDED;
 822         return tsl2772_write_control_reg(chip, 0x00);
 823 }
 824
 825 static void tsl2772_chip_off_action(void *data)
 826 {
 827         struct iio_dev *indio_dev = data;
 828
 829         tsl2772_chip_off(indio_dev);
 830 }
 831
 832 /**
 833  * tsl2772_invoke_change - power cycle the device to implement the user
 834  *                         parameters
 835  * @indio_dev:  pointer to IIO device
 836  *
 837  * Obtain and lock both ALS and PROX resources, determine and save device state
 838  * (On/Off), cycle device to implement updated parameter, put device back into
 839  * proper state, and unlock resource.
 840  */
 841 static int tsl2772_invoke_change(struct iio_dev *indio_dev)
 842 {
 843         struct tsl2772_chip *chip = iio_priv(indio_dev);
 844         int device_status = chip->tsl2772_chip_status;
 845         int ret;
 846
 847         mutex_lock(&chip->als_mutex);
 848         mutex_lock(&chip->prox_mutex);
 849
 850         if (device_status == TSL2772_CHIP_WORKING) {
 851                 ret = tsl2772_chip_off(indio_dev);
 852                 if (ret < 0)
 853                         goto unlock;
 854         }
 855
 856         ret = tsl2772_chip_on(indio_dev);
 857
 858 unlock:
 859         mutex_unlock(&chip->prox_mutex);
 860         mutex_unlock(&chip->als_mutex);
 861
 862         return ret;
 863 }
 864
 865 static int tsl2772_prox_cal(struct iio_dev *indio_dev)
 866 {
 867         struct tsl2772_chip *chip = iio_priv(indio_dev);
 868         int prox_history[MAX_SAMPLES_CAL + 1];
 869         int i, ret, mean, max, sample_sum;
 870
 871         if (chip->settings.prox_max_samples_cal < 1 ||
 872             chip->settings.prox_max_samples_cal > MAX_SAMPLES_CAL)
 873                 return -EINVAL;
 874
 875         for (i = 0; i < chip->settings.prox_max_samples_cal; i++) {
 876                 usleep_range(15000, 17500);
 877                 ret = tsl2772_get_prox(indio_dev);
 878                 if (ret < 0)
 879                         return ret;
 880
 881                 prox_history[i] = chip->prox_data;
 882         }
 883
 884         sample_sum = 0;
 885         max = INT_MIN;
 886         for (i = 0; i < chip->settings.prox_max_samples_cal; i++) {
 887                 sample_sum += prox_history[i];
 888                 max = max(max, prox_history[i]);
 889         }
 890         mean = sample_sum / chip->settings.prox_max_samples_cal;
 891
 892         chip->settings.prox_thres_high = (max << 1) - mean;
 893
 894         return tsl2772_invoke_change(indio_dev);
 895 }
 896
 897 static int tsl2772_read_avail(struct iio_dev *indio_dev,
 898                               struct iio_chan_spec const *chan,
 899                               const int **vals, int *type, int *length,
 900                               long mask)
 901 {
 902         struct tsl2772_chip *chip = iio_priv(indio_dev);
 903
 904         switch (mask) {
 905         case IIO_CHAN_INFO_CALIBSCALE:
 906                 if (chan->type == IIO_INTENSITY) {
 907                         *length = ARRAY_SIZE(tsl2772_int_calibscale_avail);
 908                         *vals = tsl2772_int_calibscale_avail;
 909                 } else {
 910                         *length = ARRAY_SIZE(tsl2772_prox_calibscale_avail);
 911                         *vals = tsl2772_prox_calibscale_avail;
 912                 }
 913                 *type = IIO_VAL_INT;
 914                 return IIO_AVAIL_LIST;
 915         case IIO_CHAN_INFO_INT_TIME:
 916                 *length = ARRAY_SIZE(tsl2772_int_time_avail[chip->id]);
 917                 *vals = tsl2772_int_time_avail[chip->id];
 918                 *type = IIO_VAL_INT_PLUS_MICRO;
 919                 return IIO_AVAIL_RANGE;
 920         }
 921
 922         return -EINVAL;
 923 }
 924
 925 static ssize_t in_illuminance0_target_input_show(struct device *dev,
 926                                                  struct device_attribute *attr,
 927                                                  char *buf)
 928 {
 929         struct tsl2772_chip *chip = iio_priv(dev_to_iio_dev(dev));
 930
 931         return scnprintf(buf, PAGE_SIZE, "%d\n", chip->settings.als_cal_target);
 932 }
 933
 934 static ssize_t in_illuminance0_target_input_store(struct device *dev,
 935                                                   struct device_attribute *attr,
 936                                                   const char *buf, size_t len)
 937 {
 938         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 939         struct tsl2772_chip *chip = iio_priv(indio_dev);
 940         u16 value;
 941         int ret;
 942
 943         if (kstrtou16(buf, 0, &value))
 944                 return -EINVAL;
 945
 946         chip->settings.als_cal_target = value;
 947         ret = tsl2772_invoke_change(indio_dev);
 948         if (ret < 0)
 949                 return ret;
 950
 951         return len;
 952 }
 953
 954 static ssize_t in_illuminance0_calibrate_store(struct device *dev,
 955                                                struct device_attribute *attr,
 956                                                const char *buf, size_t len)
 957 {
 958         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 959         bool value;
 960         int ret;
 961
 962         if (kstrtobool(buf, &value) || !value)
 963                 return -EINVAL;
 964
 965         ret = tsl2772_als_calibrate(indio_dev);
 966         if (ret < 0)
 967                 return ret;
 968
 969         ret = tsl2772_invoke_change(indio_dev);
 970         if (ret < 0)
 971                 return ret;
 972
 973         return len;
 974 }
 975
 976 static ssize_t in_illuminance0_lux_table_show(struct device *dev,
 977                                               struct device_attribute *attr,
 978                                               char *buf)
 979 {
 980         struct tsl2772_chip *chip = iio_priv(dev_to_iio_dev(dev));
 981         int i = 0;
 982         int offset = 0;
 983
 984         while (i < TSL2772_MAX_LUX_TABLE_SIZE) {
 985                 offset += scnprintf(buf + offset, PAGE_SIZE - offset, "%u,%u,",
 986                         chip->tsl2772_device_lux[i].ch0,
 987                         chip->tsl2772_device_lux[i].ch1);
 988                 if (chip->tsl2772_device_lux[i].ch0 == 0) {
 989                         /*
 990                          * We just printed the first "0" entry.
 991                          * Now get rid of the extra "," and break.
 992                          */
 993                         offset--;
 994                         break;
 995                 }
 996                 i++;
 997         }
 998
 999         offset += scnprintf(buf + offset, PAGE_SIZE - offset, "\n");
1000         return offset;
1001 }
1002
1003 static ssize_t in_illuminance0_lux_table_store(struct device *dev,
1004                                                struct device_attribute *attr,
1005                                                const char *buf, size_t len)
1006 {
1007         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1008         struct tsl2772_chip *chip = iio_priv(indio_dev);
1009         int value[ARRAY_SIZE(chip->tsl2772_device_lux) * 2 + 1];
1010         int n, ret;
1011
1012         get_options(buf, ARRAY_SIZE(value), value);
1013
1014         /*
1015          * We now have an array of ints starting at value[1], and
1016          * enumerated by value[0].
1017          * We expect each group of two ints to be one table entry,
1018          * and the last table entry is all 0.
1019          */
1020         n = value[0];
1021         if ((n % 2) || n < 4 ||
1022             n > ((ARRAY_SIZE(chip->tsl2772_device_lux) - 1) * 2))
1023                 return -EINVAL;
1024
1025         if ((value[(n - 1)] | value[n]) != 0)
1026                 return -EINVAL;
1027
1028         if (chip->tsl2772_chip_status == TSL2772_CHIP_WORKING) {
1029                 ret = tsl2772_chip_off(indio_dev);
1030                 if (ret < 0)
1031                         return ret;
1032         }
1033
1034         /* Zero out the table */
1035         memset(chip->tsl2772_device_lux, 0, sizeof(chip->tsl2772_device_lux));
1036         memcpy(chip->tsl2772_device_lux, &value[1], (value[0] * 4));
1037
1038         ret = tsl2772_invoke_change(indio_dev);
1039         if (ret < 0)
1040                 return ret;
1041
1042         return len;
1043 }
1044
1045 static ssize_t in_proximity0_calibrate_store(struct device *dev,
1046                                              struct device_attribute *attr,
1047                                              const char *buf, size_t len)
1048 {
1049         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1050         bool value;
1051         int ret;
1052
1053         if (kstrtobool(buf, &value) || !value)
1054                 return -EINVAL;
1055
1056         ret = tsl2772_prox_cal(indio_dev);
1057         if (ret < 0)
1058                 return ret;
1059
1060         ret = tsl2772_invoke_change(indio_dev);
1061         if (ret < 0)
1062                 return ret;
1063
1064         return len;
1065 }
1066
1067 static int tsl2772_read_interrupt_config(struct iio_dev *indio_dev,
1068                                          const struct iio_chan_spec *chan,
1069                                          enum iio_event_type type,
1070                                          enum iio_event_direction dir)
1071 {
1072         struct tsl2772_chip *chip = iio_priv(indio_dev);
1073
1074         if (chan->type == IIO_INTENSITY)
1075                 return chip->settings.als_interrupt_en;
1076         else
1077                 return chip->settings.prox_interrupt_en;
1078 }
1079
1080 static int tsl2772_write_interrupt_config(struct iio_dev *indio_dev,
1081                                           const struct iio_chan_spec *chan,
1082                                           enum iio_event_type type,
1083                                           enum iio_event_direction dir,
1084                                           int val)
1085 {
1086         struct tsl2772_chip *chip = iio_priv(indio_dev);
1087
1088         if (chan->type == IIO_INTENSITY)
1089                 chip->settings.als_interrupt_en = val ? true : false;
1090         else
1091                 chip->settings.prox_interrupt_en = val ? true : false;
1092
1093         return tsl2772_invoke_change(indio_dev);
1094 }
1095
1096 static int tsl2772_write_event_value(struct iio_dev *indio_dev,
1097                                      const struct iio_chan_spec *chan,
1098                                      enum iio_event_type type,
1099                                      enum iio_event_direction dir,
1100                                      enum iio_event_info info,
1101                                      int val, int val2)
1102 {
1103         struct tsl2772_chip *chip = iio_priv(indio_dev);
1104         int ret = -EINVAL, count, persistence;
1105         u8 time;
1106
1107         switch (info) {
1108         case IIO_EV_INFO_VALUE:
1109                 if (chan->type == IIO_INTENSITY) {
1110                         switch (dir) {
1111                         case IIO_EV_DIR_RISING:
1112                                 chip->settings.als_thresh_high = val;
1113                                 ret = 0;
1114                                 break;
1115                         case IIO_EV_DIR_FALLING:
1116                                 chip->settings.als_thresh_low = val;
1117                                 ret = 0;
1118                                 break;
1119                         default:
1120                                 break;
1121                         }
1122                 } else {
1123                         switch (dir) {
1124                         case IIO_EV_DIR_RISING:
1125                                 chip->settings.prox_thres_high = val;
1126                                 ret = 0;
1127                                 break;
1128                         case IIO_EV_DIR_FALLING:
1129                                 chip->settings.prox_thres_low = val;
1130                                 ret = 0;
1131                                 break;
1132                         default:
1133                                 break;
1134                         }
1135                 }
1136                 break;
1137         case IIO_EV_INFO_PERIOD:
1138                 if (chan->type == IIO_INTENSITY)
1139                         time = chip->settings.als_time;
1140                 else
1141                         time = chip->settings.prox_time;
1142
1143                 count = 256 - time;
1144                 persistence = ((val * 1000000) + val2) /
1145                         (count * tsl2772_int_time_avail[chip->id][3]);
1146
1147                 if (chan->type == IIO_INTENSITY) {
1148                         /* ALS filter values are 1, 2, 3, 5, 10, 15, ..., 60 */
1149                         if (persistence > 3)
1150                                 persistence = (persistence / 5) + 3;
1151
1152                         chip->settings.als_persistence = persistence;
1153                 } else {
1154                         chip->settings.prox_persistence = persistence;
1155                 }
1156
1157                 ret = 0;
1158                 break;
1159         default:
1160                 break;
1161         }
1162
1163         if (ret < 0)
1164                 return ret;
1165
1166         return tsl2772_invoke_change(indio_dev);
1167 }
1168
1169 static int tsl2772_read_event_value(struct iio_dev *indio_dev,
1170                                     const struct iio_chan_spec *chan,
1171                                     enum iio_event_type type,
1172                                     enum iio_event_direction dir,
1173                                     enum iio_event_info info,
1174                                     int *val, int *val2)
1175 {
1176         struct tsl2772_chip *chip = iio_priv(indio_dev);
1177         int filter_delay, persistence;
1178         u8 time;
1179
1180         switch (info) {
1181         case IIO_EV_INFO_VALUE:
1182                 if (chan->type == IIO_INTENSITY) {
1183                         switch (dir) {
1184                         case IIO_EV_DIR_RISING:
1185                                 *val = chip->settings.als_thresh_high;
1186                                 return IIO_VAL_INT;
1187                         case IIO_EV_DIR_FALLING:
1188                                 *val = chip->settings.als_thresh_low;
1189                                 return IIO_VAL_INT;
1190                         default:
1191                                 return -EINVAL;
1192                         }
1193                 } else {
1194                         switch (dir) {
1195                         case IIO_EV_DIR_RISING:
1196                                 *val = chip->settings.prox_thres_high;
1197                                 return IIO_VAL_INT;
1198                         case IIO_EV_DIR_FALLING:
1199                                 *val = chip->settings.prox_thres_low;
1200                                 return IIO_VAL_INT;
1201                         default:
1202                                 return -EINVAL;
1203                         }
1204                 }
1205                 break;
1206         case IIO_EV_INFO_PERIOD:
1207                 if (chan->type == IIO_INTENSITY) {
1208                         time = chip->settings.als_time;
1209                         persistence = chip->settings.als_persistence;
1210
1211                         /* ALS filter values are 1, 2, 3, 5, 10, 15, ..., 60 */
1212                         if (persistence > 3)
1213                                 persistence = (persistence - 3) * 5;
1214                 } else {
1215                         time = chip->settings.prox_time;
1216                         persistence = chip->settings.prox_persistence;
1217                 }
1218
1219                 filter_delay = persistence * (256 - time) *
1220                         tsl2772_int_time_avail[chip->id][3];
1221
1222                 *val = filter_delay / 1000000;
1223                 *val2 = filter_delay % 1000000;
1224                 return IIO_VAL_INT_PLUS_MICRO;
1225         default:
1226                 return -EINVAL;
1227         }
1228 }
1229
1230 static int tsl2772_read_raw(struct iio_dev *indio_dev,
1231                             struct iio_chan_spec const *chan,
1232                             int *val,
1233                             int *val2,
1234                             long mask)
1235 {
1236         struct tsl2772_chip *chip = iio_priv(indio_dev);
1237
1238         switch (mask) {
1239         case IIO_CHAN_INFO_PROCESSED:
1240                 switch (chan->type) {
1241                 case IIO_LIGHT:
1242                         tsl2772_get_lux(indio_dev);
1243                         *val = chip->als_cur_info.lux;
1244                         return IIO_VAL_INT;
1245                 default:
1246                         return -EINVAL;
1247                 }
1248         case IIO_CHAN_INFO_RAW:
1249                 switch (chan->type) {
1250                 case IIO_INTENSITY:
1251                         tsl2772_get_lux(indio_dev);
1252                         if (chan->channel == 0)
1253                                 *val = chip->als_cur_info.als_ch0;
1254                         else
1255                                 *val = chip->als_cur_info.als_ch1;
1256                         return IIO_VAL_INT;
1257                 case IIO_PROXIMITY:
1258                         tsl2772_get_prox(indio_dev);
1259                         *val = chip->prox_data;
1260                         return IIO_VAL_INT;
1261                 default:
1262                         return -EINVAL;
1263                 }
1264                 break;
1265         case IIO_CHAN_INFO_CALIBSCALE:
1266                 if (chan->type == IIO_LIGHT)
1267                         *val = tsl2772_als_gain[chip->settings.als_gain];
1268                 else
1269                         *val = tsl2772_prox_gain[chip->settings.prox_gain];
1270                 return IIO_VAL_INT;
1271         case IIO_CHAN_INFO_CALIBBIAS:
1272                 *val = chip->settings.als_gain_trim;
1273                 return IIO_VAL_INT;
1274         case IIO_CHAN_INFO_INT_TIME:
1275                 *val = 0;
1276                 *val2 = (256 - chip->settings.als_time) *
1277                         tsl2772_int_time_avail[chip->id][3];
1278                 return IIO_VAL_INT_PLUS_MICRO;
1279         default:
1280                 return -EINVAL;
1281         }
1282 }
1283
1284 static int tsl2772_write_raw(struct iio_dev *indio_dev,
1285                              struct iio_chan_spec const *chan,
1286                              int val,
1287                              int val2,
1288                              long mask)
1289 {
1290         struct tsl2772_chip *chip = iio_priv(indio_dev);
1291
1292         switch (mask) {
1293         case IIO_CHAN_INFO_CALIBSCALE:
1294                 if (chan->type == IIO_INTENSITY) {
1295                         switch (val) {
1296                         case 1:
1297                                 chip->settings.als_gain = 0;
1298                                 break;
1299                         case 8:
1300                                 chip->settings.als_gain = 1;
1301                                 break;
1302                         case 16:
1303                                 chip->settings.als_gain = 2;
1304                                 break;
1305                         case 120:
1306                                 chip->settings.als_gain = 3;
1307                                 break;
1308                         default:
1309                                 return -EINVAL;
1310                         }
1311                 } else {
1312                         switch (val) {
1313                         case 1:
1314                                 chip->settings.prox_gain = 0;
1315                                 break;
1316                         case 2:
1317                                 chip->settings.prox_gain = 1;
1318                                 break;
1319                         case 4:
1320                                 chip->settings.prox_gain = 2;
1321                                 break;
1322                         case 8:
1323                                 chip->settings.prox_gain = 3;
1324                                 break;
1325                         default:
1326                                 return -EINVAL;
1327                         }
1328                 }
1329                 break;
1330         case IIO_CHAN_INFO_CALIBBIAS:
1331                 if (val < TSL2772_ALS_GAIN_TRIM_MIN ||
1332                     val > TSL2772_ALS_GAIN_TRIM_MAX)
1333                         return -EINVAL;
1334
1335                 chip->settings.als_gain_trim = val;
1336                 break;
1337         case IIO_CHAN_INFO_INT_TIME:
1338                 if (val != 0 || val2 < tsl2772_int_time_avail[chip->id][1] ||
1339                     val2 > tsl2772_int_time_avail[chip->id][5])
1340                         return -EINVAL;
1341
1342                 chip->settings.als_time = 256 -
1343                         (val2 / tsl2772_int_time_avail[chip->id][3]);
1344                 break;
1345         default:
1346                 return -EINVAL;
1347         }
1348
1349         return tsl2772_invoke_change(indio_dev);
1350 }
1351
1352 static DEVICE_ATTR_RW(in_illuminance0_target_input);
1353
1354 static DEVICE_ATTR_WO(in_illuminance0_calibrate);
1355
1356 static DEVICE_ATTR_WO(in_proximity0_calibrate);
1357
1358 static DEVICE_ATTR_RW(in_illuminance0_lux_table);
1359
1360 /* Use the default register values to identify the Taos device */
1361 static int tsl2772_device_id_verif(int id, int target)
1362 {
1363         switch (target) {
1364         case tsl2571:
1365         case tsl2671:
1366         case tsl2771:
1367                 return (id & 0xf0) == TRITON_ID;
1368         case tmd2671:
1369         case tmd2771:
1370                 return (id & 0xf0) == HALIBUT_ID;
1371         case tsl2572:
1372         case tsl2672:
1373         case tmd2672:
1374         case tsl2772:
1375         case tmd2772:
1376         case apds9930:
1377                 return (id & 0xf0) == SWORDFISH_ID;
1378         }
1379
1380         return -EINVAL;
1381 }
1382
1383 static irqreturn_t tsl2772_event_handler(int irq, void *private)
1384 {
1385         struct iio_dev *indio_dev = private;
1386         struct tsl2772_chip *chip = iio_priv(indio_dev);
1387         s64 timestamp = iio_get_time_ns(indio_dev);
1388         int ret;
1389
1390         ret = tsl2772_read_status(chip);
1391         if (ret < 0)
1392                 return IRQ_HANDLED;
1393
1394         /* What type of interrupt do we need to process */
1395         if (ret & TSL2772_STA_PRX_INTR) {
1396                 iio_push_event(indio_dev,
1397                                IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY,
1398                                                     0,
1399                                                     IIO_EV_TYPE_THRESH,
1400                                                     IIO_EV_DIR_EITHER),
1401                                timestamp);
1402         }
1403
1404         if (ret & TSL2772_STA_ALS_INTR) {
1405                 iio_push_event(indio_dev,
1406                                IIO_UNMOD_EVENT_CODE(IIO_LIGHT,
1407                                                     0,
1408                                                     IIO_EV_TYPE_THRESH,
1409                                                     IIO_EV_DIR_EITHER),
1410                                timestamp);
1411         }
1412
1413         ret = i2c_smbus_write_byte(chip->client,
1414                                    TSL2772_CMD_REG | TSL2772_CMD_SPL_FN |
1415                                    TSL2772_CMD_PROXALS_INT_CLR);
1416         if (ret < 0)
1417                 dev_err(&chip->client->dev,
1418                         "%s: failed to clear interrupt status: %d\n",
1419                         __func__, ret);
1420
1421         return IRQ_HANDLED;
1422 }
1423
1424 static struct attribute *tsl2772_ALS_device_attrs[] = {
1425         &dev_attr_in_illuminance0_target_input.attr,
1426         &dev_attr_in_illuminance0_calibrate.attr,
1427         &dev_attr_in_illuminance0_lux_table.attr,
1428         NULL
1429 };
1430
1431 static struct attribute *tsl2772_PRX_device_attrs[] = {
1432         &dev_attr_in_proximity0_calibrate.attr,
1433         NULL
1434 };
1435
1436 static struct attribute *tsl2772_ALSPRX_device_attrs[] = {
1437         &dev_attr_in_illuminance0_target_input.attr,
1438         &dev_attr_in_illuminance0_calibrate.attr,
1439         &dev_attr_in_illuminance0_lux_table.attr,
1440         NULL
1441 };
1442
1443 static struct attribute *tsl2772_PRX2_device_attrs[] = {
1444         &dev_attr_in_proximity0_calibrate.attr,
1445         NULL
1446 };
1447
1448 static struct attribute *tsl2772_ALSPRX2_device_attrs[] = {
1449         &dev_attr_in_illuminance0_target_input.attr,
1450         &dev_attr_in_illuminance0_calibrate.attr,
1451         &dev_attr_in_illuminance0_lux_table.attr,
1452         &dev_attr_in_proximity0_calibrate.attr,
1453         NULL
1454 };
1455
1456 static const struct attribute_group tsl2772_device_attr_group_tbl[] = {
1457         [ALS] = {
1458                 .attrs = tsl2772_ALS_device_attrs,
1459         },
1460         [PRX] = {
1461                 .attrs = tsl2772_PRX_device_attrs,
1462         },
1463         [ALSPRX] = {
1464                 .attrs = tsl2772_ALSPRX_device_attrs,
1465         },
1466         [PRX2] = {
1467                 .attrs = tsl2772_PRX2_device_attrs,
1468         },
1469         [ALSPRX2] = {
1470                 .attrs = tsl2772_ALSPRX2_device_attrs,
1471         },
1472 };
1473
1474 #define TSL2772_DEVICE_INFO(type)[type] = \
1475         { \
1476                 .attrs = &tsl2772_device_attr_group_tbl[type], \
1477                 .read_raw = &tsl2772_read_raw, \
1478                 .read_avail = &tsl2772_read_avail, \
1479                 .write_raw = &tsl2772_write_raw, \
1480                 .read_event_value = &tsl2772_read_event_value, \
1481                 .write_event_value = &tsl2772_write_event_value, \
1482                 .read_event_config = &tsl2772_read_interrupt_config, \
1483                 .write_event_config = &tsl2772_write_interrupt_config, \
1484         }
1485
1486 static const struct iio_info tsl2772_device_info[] = {
1487         TSL2772_DEVICE_INFO(ALS),
1488         TSL2772_DEVICE_INFO(PRX),
1489         TSL2772_DEVICE_INFO(ALSPRX),
1490         TSL2772_DEVICE_INFO(PRX2),
1491         TSL2772_DEVICE_INFO(ALSPRX2),
1492 };
1493
1494 static const struct iio_event_spec tsl2772_events[] = {
1495         {
1496                 .type = IIO_EV_TYPE_THRESH,
1497                 .dir = IIO_EV_DIR_RISING,
1498                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1499         }, {
1500                 .type = IIO_EV_TYPE_THRESH,
1501                 .dir = IIO_EV_DIR_FALLING,
1502                 .mask_separate = BIT(IIO_EV_INFO_VALUE),
1503         }, {
1504                 .type = IIO_EV_TYPE_THRESH,
1505                 .dir = IIO_EV_DIR_EITHER,
1506                 .mask_separate = BIT(IIO_EV_INFO_PERIOD) |
1507                         BIT(IIO_EV_INFO_ENABLE),
1508         },
1509 };
1510
1511 static const struct tsl2772_chip_info tsl2772_chip_info_tbl[] = {
1512         [ALS] = {
1513                 .channel_with_events = {
1514                         {
1515                         .type = IIO_LIGHT,
1516                         .indexed = 1,
1517                         .channel = 0,
1518                         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1519                         }, {
1520                         .type = IIO_INTENSITY,
1521                         .indexed = 1,
1522                         .channel = 0,
1523                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1524                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1525                                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1526                                 BIT(IIO_CHAN_INFO_CALIBBIAS),
1527                         .info_mask_separate_available =
1528                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1529                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1530                         .event_spec = tsl2772_events,
1531                         .num_event_specs = ARRAY_SIZE(tsl2772_events),
1532                         }, {
1533                         .type = IIO_INTENSITY,
1534                         .indexed = 1,
1535                         .channel = 1,
1536                         },
1537                 },
1538                 .channel_without_events = {
1539                         {
1540                         .type = IIO_LIGHT,
1541                         .indexed = 1,
1542                         .channel = 0,
1543                         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1544                         }, {
1545                         .type = IIO_INTENSITY,
1546                         .indexed = 1,
1547                         .channel = 0,
1548                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1549                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1550                                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1551                                 BIT(IIO_CHAN_INFO_CALIBBIAS),
1552                         .info_mask_separate_available =
1553                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1554                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1555                         }, {
1556                         .type = IIO_INTENSITY,
1557                         .indexed = 1,
1558                         .channel = 1,
1559                         },
1560                 },
1561                 .chan_table_elements = 3,
1562                 .info = &tsl2772_device_info[ALS],
1563         },
1564         [PRX] = {
1565                 .channel_with_events = {
1566                         {
1567                         .type = IIO_PROXIMITY,
1568                         .indexed = 1,
1569                         .channel = 0,
1570                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1571                         .event_spec = tsl2772_events,
1572                         .num_event_specs = ARRAY_SIZE(tsl2772_events),
1573                         },
1574                 },
1575                 .channel_without_events = {
1576                         {
1577                         .type = IIO_PROXIMITY,
1578                         .indexed = 1,
1579                         .channel = 0,
1580                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1581                         },
1582                 },
1583                 .chan_table_elements = 1,
1584                 .info = &tsl2772_device_info[PRX],
1585         },
1586         [ALSPRX] = {
1587                 .channel_with_events = {
1588                         {
1589                         .type = IIO_LIGHT,
1590                         .indexed = 1,
1591                         .channel = 0,
1592                         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1593                         }, {
1594                         .type = IIO_INTENSITY,
1595                         .indexed = 1,
1596                         .channel = 0,
1597                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1598                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1599                                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1600                                 BIT(IIO_CHAN_INFO_CALIBBIAS),
1601                         .info_mask_separate_available =
1602                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1603                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1604                         .event_spec = tsl2772_events,
1605                         .num_event_specs = ARRAY_SIZE(tsl2772_events),
1606                         }, {
1607                         .type = IIO_INTENSITY,
1608                         .indexed = 1,
1609                         .channel = 1,
1610                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1611                         }, {
1612                         .type = IIO_PROXIMITY,
1613                         .indexed = 1,
1614                         .channel = 0,
1615                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1616                         .event_spec = tsl2772_events,
1617                         .num_event_specs = ARRAY_SIZE(tsl2772_events),
1618                         },
1619                 },
1620                 .channel_without_events = {
1621                         {
1622                         .type = IIO_LIGHT,
1623                         .indexed = 1,
1624                         .channel = 0,
1625                         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1626                         }, {
1627                         .type = IIO_INTENSITY,
1628                         .indexed = 1,
1629                         .channel = 0,
1630                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1631                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1632                                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1633                                 BIT(IIO_CHAN_INFO_CALIBBIAS),
1634                         .info_mask_separate_available =
1635                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1636                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1637                         }, {
1638                         .type = IIO_INTENSITY,
1639                         .indexed = 1,
1640                         .channel = 1,
1641                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1642                         }, {
1643                         .type = IIO_PROXIMITY,
1644                         .indexed = 1,
1645                         .channel = 0,
1646                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1647                         },
1648                 },
1649                 .chan_table_elements = 4,
1650                 .info = &tsl2772_device_info[ALSPRX],
1651         },
1652         [PRX2] = {
1653                 .channel_with_events = {
1654                         {
1655                         .type = IIO_PROXIMITY,
1656                         .indexed = 1,
1657                         .channel = 0,
1658                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1659                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1660                         .info_mask_separate_available =
1661                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1662                         .event_spec = tsl2772_events,
1663                         .num_event_specs = ARRAY_SIZE(tsl2772_events),
1664                         },
1665                 },
1666                 .channel_without_events = {
1667                         {
1668                         .type = IIO_PROXIMITY,
1669                         .indexed = 1,
1670                         .channel = 0,
1671                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1672                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1673                         .info_mask_separate_available =
1674                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1675                         },
1676                 },
1677                 .chan_table_elements = 1,
1678                 .info = &tsl2772_device_info[PRX2],
1679         },
1680         [ALSPRX2] = {
1681                 .channel_with_events = {
1682                         {
1683                         .type = IIO_LIGHT,
1684                         .indexed = 1,
1685                         .channel = 0,
1686                         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1687                         }, {
1688                         .type = IIO_INTENSITY,
1689                         .indexed = 1,
1690                         .channel = 0,
1691                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1692                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1693                                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1694                                 BIT(IIO_CHAN_INFO_CALIBBIAS),
1695                         .info_mask_separate_available =
1696                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1697                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1698                         .event_spec = tsl2772_events,
1699                         .num_event_specs = ARRAY_SIZE(tsl2772_events),
1700                         }, {
1701                         .type = IIO_INTENSITY,
1702                         .indexed = 1,
1703                         .channel = 1,
1704                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1705                         }, {
1706                         .type = IIO_PROXIMITY,
1707                         .indexed = 1,
1708                         .channel = 0,
1709                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1710                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1711                         .info_mask_separate_available =
1712                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1713                         .event_spec = tsl2772_events,
1714                         .num_event_specs = ARRAY_SIZE(tsl2772_events),
1715                         },
1716                 },
1717                 .channel_without_events = {
1718                         {
1719                         .type = IIO_LIGHT,
1720                         .indexed = 1,
1721                         .channel = 0,
1722                         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1723                         }, {
1724                         .type = IIO_INTENSITY,
1725                         .indexed = 1,
1726                         .channel = 0,
1727                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1728                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1729                                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1730                                 BIT(IIO_CHAN_INFO_CALIBBIAS),
1731                         .info_mask_separate_available =
1732                                 BIT(IIO_CHAN_INFO_INT_TIME) |
1733                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1734                         }, {
1735                         .type = IIO_INTENSITY,
1736                         .indexed = 1,
1737                         .channel = 1,
1738                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1739                         }, {
1740                         .type = IIO_PROXIMITY,
1741                         .indexed = 1,
1742                         .channel = 0,
1743                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1744                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1745                         .info_mask_separate_available =
1746                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1747                         },
1748                 },
1749                 .chan_table_elements = 4,
1750                 .info = &tsl2772_device_info[ALSPRX2],
1751         },
1752 };
1753
1754 static int tsl2772_probe(struct i2c_client *clientp,
1755                          const struct i2c_device_id *id)
1756 {
1757         struct iio_dev *indio_dev;
1758         struct tsl2772_chip *chip;
1759         int ret;
1760
1761         indio_dev = devm_iio_device_alloc(&clientp->dev, sizeof(*chip));
1762         if (!indio_dev)
1763                 return -ENOMEM;
1764
1765         chip = iio_priv(indio_dev);
1766         chip->client = clientp;
1767         i2c_set_clientdata(clientp, indio_dev);
1768
1769         chip->supplies[TSL2772_SUPPLY_VDD].supply = "vdd";
1770         chip->supplies[TSL2772_SUPPLY_VDDIO].supply = "vddio";
1771
1772         ret = devm_regulator_bulk_get(&clientp->dev,
1773                                       ARRAY_SIZE(chip->supplies),
1774                                       chip->supplies);
1775         if (ret < 0)
1776                 return dev_err_probe(&clientp->dev, ret, "Failed to get regulators\n");
1777
1778         ret = regulator_bulk_enable(ARRAY_SIZE(chip->supplies), chip->supplies);
1779         if (ret < 0) {
1780                 dev_err(&clientp->dev, "Failed to enable regulators: %d\n",
1781                         ret);
1782                 return ret;
1783         }
1784
1785         ret = devm_add_action_or_reset(&clientp->dev,
1786                                         tsl2772_disable_regulators_action,
1787                                         chip);
1788         if (ret < 0) {
1789                 dev_err(&clientp->dev, "Failed to setup regulator cleanup action %d\n",
1790                         ret);
1791                 return ret;
1792         }
1793
1794         usleep_range(TSL2772_BOOT_MIN_SLEEP_TIME, TSL2772_BOOT_MAX_SLEEP_TIME);
1795
1796         ret = i2c_smbus_read_byte_data(chip->client,
1797                                        TSL2772_CMD_REG | TSL2772_CHIPID);
1798         if (ret < 0)
1799                 return ret;
1800
1801         if (tsl2772_device_id_verif(ret, id->driver_data) <= 0) {
1802                 dev_info(&chip->client->dev,
1803                          "%s: i2c device found does not match expected id\n",
1804                                 __func__);
1805                 return -EINVAL;
1806         }
1807
1808         ret = i2c_smbus_write_byte(clientp, TSL2772_CMD_REG | TSL2772_CNTRL);
1809         if (ret < 0) {
1810                 dev_err(&clientp->dev,
1811                         "%s: Failed to write to CMD register: %d\n",
1812                         __func__, ret);
1813                 return ret;
1814         }
1815
1816         mutex_init(&chip->als_mutex);
1817         mutex_init(&chip->prox_mutex);
1818
1819         chip->tsl2772_chip_status = TSL2772_CHIP_UNKNOWN;
1820         chip->pdata = dev_get_platdata(&clientp->dev);
1821         chip->id = id->driver_data;
1822         chip->chip_info =
1823                 &tsl2772_chip_info_tbl[device_channel_config[id->driver_data]];
1824
1825         indio_dev->info = chip->chip_info->info;
1826         indio_dev->modes = INDIO_DIRECT_MODE;
1827         indio_dev->name = chip->client->name;
1828         indio_dev->num_channels = chip->chip_info->chan_table_elements;
1829
1830         if (clientp->irq) {
1831                 indio_dev->channels = chip->chip_info->channel_with_events;
1832
1833                 ret = devm_request_threaded_irq(&clientp->dev, clientp->irq,
1834                                                 NULL,
1835                                                 &tsl2772_event_handler,
1836                                                 IRQF_TRIGGER_FALLING |
1837                                                 IRQF_ONESHOT,
1838                                                 "TSL2772_event",
1839                                                 indio_dev);
1840                 if (ret) {
1841                         dev_err(&clientp->dev,
1842                                 "%s: irq request failed\n", __func__);
1843                         return ret;
1844                 }
1845         } else {
1846                 indio_dev->channels = chip->chip_info->channel_without_events;
1847         }
1848
1849         tsl2772_defaults(chip);
1850         ret = tsl2772_chip_on(indio_dev);
1851         if (ret < 0)
1852                 return ret;
1853
1854         ret = devm_add_action_or_reset(&clientp->dev,
1855                                         tsl2772_chip_off_action,
1856                                         indio_dev);
1857         if (ret < 0)
1858                 return ret;
1859
1860         return devm_iio_device_register(&clientp->dev, indio_dev);
1861 }
1862
1863 static int tsl2772_suspend(struct device *dev)
1864 {
1865         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1866         struct tsl2772_chip *chip = iio_priv(indio_dev);
1867         int ret;
1868
1869         ret = tsl2772_chip_off(indio_dev);
1870         regulator_bulk_disable(ARRAY_SIZE(chip->supplies), chip->supplies);
1871
1872         return ret;
1873 }
1874
1875 static int tsl2772_resume(struct device *dev)
1876 {
1877         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1878         struct tsl2772_chip *chip = iio_priv(indio_dev);
1879         int ret;
1880
1881         ret = regulator_bulk_enable(ARRAY_SIZE(chip->supplies), chip->supplies);
1882         if (ret < 0)
1883                 return ret;
1884
1885         usleep_range(TSL2772_BOOT_MIN_SLEEP_TIME, TSL2772_BOOT_MAX_SLEEP_TIME);
1886
1887         return tsl2772_chip_on(indio_dev);
1888 }
1889
1890 static const struct i2c_device_id tsl2772_idtable[] = {
1891         { "tsl2571", tsl2571 },
1892         { "tsl2671", tsl2671 },
1893         { "tmd2671", tmd2671 },
1894         { "tsl2771", tsl2771 },
1895         { "tmd2771", tmd2771 },
1896         { "tsl2572", tsl2572 },
1897         { "tsl2672", tsl2672 },
1898         { "tmd2672", tmd2672 },
1899         { "tsl2772", tsl2772 },
1900         { "tmd2772", tmd2772 },
1901         { "apds9930", apds9930 },
1902         {}
1903 };
1904
1905 MODULE_DEVICE_TABLE(i2c, tsl2772_idtable);
1906
1907 static const struct of_device_id tsl2772_of_match[] = {
1908         { .compatible = "amstaos,tsl2571" },
1909         { .compatible = "amstaos,tsl2671" },
1910         { .compatible = "amstaos,tmd2671" },
1911         { .compatible = "amstaos,tsl2771" },
1912         { .compatible = "amstaos,tmd2771" },
1913         { .compatible = "amstaos,tsl2572" },
1914         { .compatible = "amstaos,tsl2672" },
1915         { .compatible = "amstaos,tmd2672" },
1916         { .compatible = "amstaos,tsl2772" },
1917         { .compatible = "amstaos,tmd2772" },
1918         { .compatible = "avago,apds9930" },
1919         {}
1920 };
1921 MODULE_DEVICE_TABLE(of, tsl2772_of_match);
1922
1923 static const struct dev_pm_ops tsl2772_pm_ops = {
1924         .suspend = tsl2772_suspend,
1925         .resume  = tsl2772_resume,
1926 };
1927
1928 static struct i2c_driver tsl2772_driver = {
1929         .driver = {
1930                 .name = "tsl2772",
1931                 .of_match_table = tsl2772_of_match,
1932                 .pm = &tsl2772_pm_ops,
1933         },
1934         .id_table = tsl2772_idtable,
1935         .probe = tsl2772_probe,
1936 };
1937
1938 module_i2c_driver(tsl2772_driver);
1939
1940 MODULE_AUTHOR("J. August Brenner <Jon.Brenner@ams.com>");
1941 MODULE_AUTHOR("Brian Masney <masneyb@onstation.org>");
1942 MODULE_DESCRIPTION("TAOS tsl2772 ambient and proximity light sensor driver");
1943 MODULE_LICENSE("GPL");