drivers/staging/iio/light/tsl2x7x_core.c

   1 /*
   2  * Device driver for monitoring ambient light intensity in (lux)
   3  * and proximity detection (prox) within the TAOS TSL2X7X family of devices.
   4  *
   5  * Copyright (c) 2012, TAOS Corporation.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA        02110-1301, USA.
  20  */
  21
  22 #include <linux/kernel.h>
  23 #include <linux/i2c.h>
  24 #include <linux/errno.h>
  25 #include <linux/delay.h>
  26 #include <linux/mutex.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/slab.h>
  29 #include <linux/module.h>
  30 #include <linux/iio/events.h>
  31 #include <linux/iio/iio.h>
  32 #include <linux/iio/sysfs.h>
  33 #include "tsl2x7x.h"
  34
  35 /* Cal defs*/
  36 #define PROX_STAT_CAL        0
  37 #define PROX_STAT_SAMP       1
  38 #define MAX_SAMPLES_CAL      200
  39
  40 /* TSL2X7X Device ID */
  41 #define TRITON_ID    0x00
  42 #define SWORDFISH_ID 0x30
  43 #define HALIBUT_ID   0x20
  44
  45 /* Lux calculation constants */
  46 #define TSL2X7X_LUX_CALC_OVER_FLOW     65535
  47
  48 /* TAOS Register definitions - note:
  49  * depending on device, some of these register are not used and the
  50  * register address is benign.
  51  */
  52 /* 2X7X register offsets */
  53 #define TSL2X7X_MAX_CONFIG_REG         16
  54
  55 /* Device Registers and Masks */
  56 #define TSL2X7X_CNTRL                  0x00
  57 #define TSL2X7X_ALS_TIME               0X01
  58 #define TSL2X7X_PRX_TIME               0x02
  59 #define TSL2X7X_WAIT_TIME              0x03
  60 #define TSL2X7X_ALS_MINTHRESHLO        0X04
  61 #define TSL2X7X_ALS_MINTHRESHHI        0X05
  62 #define TSL2X7X_ALS_MAXTHRESHLO        0X06
  63 #define TSL2X7X_ALS_MAXTHRESHHI        0X07
  64 #define TSL2X7X_PRX_MINTHRESHLO        0X08
  65 #define TSL2X7X_PRX_MINTHRESHHI        0X09
  66 #define TSL2X7X_PRX_MAXTHRESHLO        0X0A
  67 #define TSL2X7X_PRX_MAXTHRESHHI        0X0B
  68 #define TSL2X7X_PERSISTENCE            0x0C
  69 #define TSL2X7X_PRX_CONFIG             0x0D
  70 #define TSL2X7X_PRX_COUNT              0x0E
  71 #define TSL2X7X_GAIN                   0x0F
  72 #define TSL2X7X_NOTUSED                0x10
  73 #define TSL2X7X_REVID                  0x11
  74 #define TSL2X7X_CHIPID                 0x12
  75 #define TSL2X7X_STATUS                 0x13
  76 #define TSL2X7X_ALS_CHAN0LO            0x14
  77 #define TSL2X7X_ALS_CHAN0HI            0x15
  78 #define TSL2X7X_ALS_CHAN1LO            0x16
  79 #define TSL2X7X_ALS_CHAN1HI            0x17
  80 #define TSL2X7X_PRX_LO                 0x18
  81 #define TSL2X7X_PRX_HI                 0x19
  82
  83 /* tsl2X7X cmd reg masks */
  84 #define TSL2X7X_CMD_REG                0x80
  85 #define TSL2X7X_CMD_SPL_FN             0x60
  86
  87 #define TSL2X7X_CMD_PROX_INT_CLR       0X05
  88 #define TSL2X7X_CMD_ALS_INT_CLR        0x06
  89 #define TSL2X7X_CMD_PROXALS_INT_CLR    0X07
  90
  91 /* tsl2X7X cntrl reg masks */
  92 #define TSL2X7X_CNTL_ADC_ENBL          0x02
  93 #define TSL2X7X_CNTL_PWR_ON            0x01
  94
  95 /* tsl2X7X status reg masks */
  96 #define TSL2X7X_STA_ADC_VALID          0x01
  97 #define TSL2X7X_STA_PRX_VALID          0x02
  98 #define TSL2X7X_STA_ADC_PRX_VALID      (TSL2X7X_STA_ADC_VALID |\
  99                                         TSL2X7X_STA_PRX_VALID)
 100 #define TSL2X7X_STA_ALS_INTR           0x10
 101 #define TSL2X7X_STA_PRX_INTR           0x20
 102
 103 /* tsl2X7X cntrl reg masks */
 104 #define TSL2X7X_CNTL_REG_CLEAR         0x00
 105 #define TSL2X7X_CNTL_PROX_INT_ENBL     0X20
 106 #define TSL2X7X_CNTL_ALS_INT_ENBL      0X10
 107 #define TSL2X7X_CNTL_WAIT_TMR_ENBL     0X08
 108 #define TSL2X7X_CNTL_PROX_DET_ENBL     0X04
 109 #define TSL2X7X_CNTL_PWRON             0x01
 110 #define TSL2X7X_CNTL_ALSPON_ENBL       0x03
 111 #define TSL2X7X_CNTL_INTALSPON_ENBL    0x13
 112 #define TSL2X7X_CNTL_PROXPON_ENBL      0x0F
 113 #define TSL2X7X_CNTL_INTPROXPON_ENBL   0x2F
 114
 115 /*Prox diode to use */
 116 #define TSL2X7X_DIODE0                 0x10
 117 #define TSL2X7X_DIODE1                 0x20
 118 #define TSL2X7X_DIODE_BOTH             0x30
 119
 120 /* LED Power */
 121 #define TSL2X7X_mA100                  0x00
 122 #define TSL2X7X_mA50                   0x40
 123 #define TSL2X7X_mA25                   0x80
 124 #define TSL2X7X_mA13                   0xD0
 125 #define TSL2X7X_MAX_TIMER_CNT          (0xFF)
 126
 127 /*Common device IIO EventMask */
 128 #define TSL2X7X_EVENT_MASK \
 129                 (IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) | \
 130                 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING)),
 131
 132 #define TSL2X7X_MIN_ITIME 3
 133
 134 /* TAOS txx2x7x Device family members */
 135 enum {
 136         tsl2571,
 137         tsl2671,
 138         tmd2671,
 139         tsl2771,
 140         tmd2771,
 141         tsl2572,
 142         tsl2672,
 143         tmd2672,
 144         tsl2772,
 145         tmd2772
 146 };
 147
 148 enum {
 149         TSL2X7X_CHIP_UNKNOWN = 0,
 150         TSL2X7X_CHIP_WORKING = 1,
 151         TSL2X7X_CHIP_SUSPENDED = 2
 152 };
 153
 154 struct tsl2x7x_parse_result {
 155         int integer;
 156         int fract;
 157 };
 158
 159 /* Per-device data */
 160 struct tsl2x7x_als_info {
 161         u16 als_ch0;
 162         u16 als_ch1;
 163         u16 lux;
 164 };
 165
 166 struct tsl2x7x_prox_stat {
 167         int min;
 168         int max;
 169         int mean;
 170         unsigned long stddev;
 171 };
 172
 173 struct tsl2x7x_chip_info {
 174         int chan_table_elements;
 175         struct iio_chan_spec            channel[4];
 176         const struct iio_info           *info;
 177 };
 178
 179 struct tsl2X7X_chip {
 180         kernel_ulong_t id;
 181         struct mutex prox_mutex;
 182         struct mutex als_mutex;
 183         struct i2c_client *client;
 184         u16 prox_data;
 185         struct tsl2x7x_als_info als_cur_info;
 186         struct tsl2x7x_settings tsl2x7x_settings;
 187         struct tsl2X7X_platform_data *pdata;
 188         int als_time_scale;
 189         int als_saturation;
 190         int tsl2x7x_chip_status;
 191         u8 tsl2x7x_config[TSL2X7X_MAX_CONFIG_REG];
 192         const struct tsl2x7x_chip_info  *chip_info;
 193         const struct iio_info *info;
 194         s64 event_timestamp;
 195         /* This structure is intentionally large to accommodate
 196          * updates via sysfs. */
 197         /* Sized to 9 = max 8 segments + 1 termination segment */
 198         struct tsl2x7x_lux tsl2x7x_device_lux[TSL2X7X_MAX_LUX_TABLE_SIZE];
 199 };
 200
 201 /* Different devices require different coefficents */
 202 static const struct tsl2x7x_lux tsl2x71_lux_table[] = {
 203         { 14461,   611,   1211 },
 204         { 18540,   352,    623 },
 205         {     0,     0,      0 },
 206 };
 207
 208 static const struct tsl2x7x_lux tmd2x71_lux_table[] = {
 209         { 11635,   115,    256 },
 210         { 15536,    87,    179 },
 211         {     0,     0,      0 },
 212 };
 213
 214 static const struct tsl2x7x_lux tsl2x72_lux_table[] = {
 215         { 14013,   466,   917 },
 216         { 18222,   310,   552 },
 217         {     0,     0,     0 },
 218 };
 219
 220 static const struct tsl2x7x_lux tmd2x72_lux_table[] = {
 221         { 13218,   130,   262 },
 222         { 17592,   92,    169 },
 223         {     0,     0,     0 },
 224 };
 225
 226 static const struct tsl2x7x_lux *tsl2x7x_default_lux_table_group[] = {
 227         [tsl2571] =     tsl2x71_lux_table,
 228         [tsl2671] =     tsl2x71_lux_table,
 229         [tmd2671] =     tmd2x71_lux_table,
 230         [tsl2771] =     tsl2x71_lux_table,
 231         [tmd2771] =     tmd2x71_lux_table,
 232         [tsl2572] =     tsl2x72_lux_table,
 233         [tsl2672] =     tsl2x72_lux_table,
 234         [tmd2672] =     tmd2x72_lux_table,
 235         [tsl2772] =     tsl2x72_lux_table,
 236         [tmd2772] =     tmd2x72_lux_table,
 237 };
 238
 239 static const struct tsl2x7x_settings tsl2x7x_default_settings = {
 240         .als_time = 219, /* 101 ms */
 241         .als_gain = 0,
 242         .prx_time = 254, /* 5.4 ms */
 243         .prox_gain = 1,
 244         .wait_time = 245,
 245         .prox_config = 0,
 246         .als_gain_trim = 1000,
 247         .als_cal_target = 150,
 248         .als_thresh_low = 200,
 249         .als_thresh_high = 256,
 250         .persistence = 255,
 251         .interrupts_en = 0,
 252         .prox_thres_low  = 0,
 253         .prox_thres_high = 512,
 254         .prox_max_samples_cal = 30,
 255         .prox_pulse_count = 8
 256 };
 257
 258 static const s16 tsl2X7X_als_gainadj[] = {
 259         1,
 260         8,
 261         16,
 262         120
 263 };
 264
 265 static const s16 tsl2X7X_prx_gainadj[] = {
 266         1,
 267         2,
 268         4,
 269         8
 270 };
 271
 272 /* Channel variations */
 273 enum {
 274         ALS,
 275         PRX,
 276         ALSPRX,
 277         PRX2,
 278         ALSPRX2,
 279 };
 280
 281 static const u8 device_channel_config[] = {
 282         ALS,
 283         PRX,
 284         PRX,
 285         ALSPRX,
 286         ALSPRX,
 287         ALS,
 288         PRX2,
 289         PRX2,
 290         ALSPRX2,
 291         ALSPRX2
 292 };
 293
 294 /**
 295  * tsl2x7x_i2c_read() - Read a byte from a register.
 296  * @client:     i2c client
 297  * @reg:        device register to read from
 298  * @*val:       pointer to location to store register contents.
 299  *
 300  */
 301 static int
 302 tsl2x7x_i2c_read(struct i2c_client *client, u8 reg, u8 *val)
 303 {
 304         int ret = 0;
 305
 306         /* select register to write */
 307         ret = i2c_smbus_write_byte(client, (TSL2X7X_CMD_REG | reg));
 308         if (ret < 0) {
 309                 dev_err(&client->dev, "%s: failed to write register %x\n"
 310                                 , __func__, reg);
 311                 return ret;
 312         }
 313
 314         /* read the data */
 315         ret = i2c_smbus_read_byte(client);
 316         if (ret >= 0)
 317                 *val = (u8)ret;
 318         else
 319                 dev_err(&client->dev, "%s: failed to read register %x\n"
 320                                                 , __func__, reg);
 321
 322         return ret;
 323 }
 324
 325 /**
 326  * tsl2x7x_get_lux() - Reads and calculates current lux value.
 327  * @indio_dev:  pointer to IIO device
 328  *
 329  * The raw ch0 and ch1 values of the ambient light sensed in the last
 330  * integration cycle are read from the device.
 331  * Time scale factor array values are adjusted based on the integration time.
 332  * The raw values are multiplied by a scale factor, and device gain is obtained
 333  * using gain index. Limit checks are done next, then the ratio of a multiple
 334  * of ch1 value, to the ch0 value, is calculated. Array tsl2x7x_device_lux[]
 335  * is then scanned to find the first ratio value that is just above the ratio
 336  * we just calculated. The ch0 and ch1 multiplier constants in the array are
 337  * then used along with the time scale factor array values, to calculate the
 338  * lux.
 339  */
 340 static int tsl2x7x_get_lux(struct iio_dev *indio_dev)
 341 {
 342         u16 ch0, ch1; /* separated ch0/ch1 data from device */
 343         u32 lux; /* raw lux calculated from device data */
 344         u64 lux64;
 345         u32 ratio;
 346         u8 buf[4];
 347         struct tsl2x7x_lux *p;
 348         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
 349         int i, ret;
 350         u32 ch0lux = 0;
 351         u32 ch1lux = 0;
 352
 353         if (mutex_trylock(&chip->als_mutex) == 0)
 354                 return chip->als_cur_info.lux; /* busy, so return LAST VALUE */
 355
 356         if (chip->tsl2x7x_chip_status != TSL2X7X_CHIP_WORKING) {
 357                 /* device is not enabled */
 358                 dev_err(&chip->client->dev, "%s: device is not enabled\n",
 359                                 __func__);
 360                 ret = -EBUSY ;
 361                 goto out_unlock;
 362         }
 363
 364         ret = tsl2x7x_i2c_read(chip->client,
 365                 (TSL2X7X_CMD_REG | TSL2X7X_STATUS), &buf[0]);
 366         if (ret < 0) {
 367                 dev_err(&chip->client->dev,
 368                         "%s: Failed to read STATUS Reg\n", __func__);
 369                 goto out_unlock;
 370         }
 371         /* is data new & valid */
 372         if (!(buf[0] & TSL2X7X_STA_ADC_VALID)) {
 373                 dev_err(&chip->client->dev,
 374                         "%s: data not valid yet\n", __func__);
 375                 ret = chip->als_cur_info.lux; /* return LAST VALUE */
 376                 goto out_unlock;
 377         }
 378
 379         for (i = 0; i < 4; i++) {
 380                 ret = tsl2x7x_i2c_read(chip->client,
 381                         (TSL2X7X_CMD_REG | (TSL2X7X_ALS_CHAN0LO + i)),
 382                         &buf[i]);
 383                 if (ret < 0) {
 384                         dev_err(&chip->client->dev,
 385                                 "%s: failed to read. err=%x\n", __func__, ret);
 386                         goto out_unlock;
 387                 }
 388         }
 389
 390         /* clear any existing interrupt status */
 391         ret = i2c_smbus_write_byte(chip->client,
 392                 (TSL2X7X_CMD_REG |
 393                                 TSL2X7X_CMD_SPL_FN |
 394                                 TSL2X7X_CMD_ALS_INT_CLR));
 395         if (ret < 0) {
 396                 dev_err(&chip->client->dev,
 397                 "%s: i2c_write_command failed - err = %d\n",
 398                         __func__, ret);
 399                 goto out_unlock; /* have no data, so return failure */
 400         }
 401
 402         /* extract ALS/lux data */
 403         ch0 = le16_to_cpup((const __le16 *)&buf[0]);
 404         ch1 = le16_to_cpup((const __le16 *)&buf[2]);
 405
 406         chip->als_cur_info.als_ch0 = ch0;
 407         chip->als_cur_info.als_ch1 = ch1;
 408
 409         if ((ch0 >= chip->als_saturation) || (ch1 >= chip->als_saturation)) {
 410                 lux = TSL2X7X_LUX_CALC_OVER_FLOW;
 411                 goto return_max;
 412         }
 413
 414         if (ch0 == 0) {
 415                 /* have no data, so return LAST VALUE */
 416                 ret = chip->als_cur_info.lux;
 417                 goto out_unlock;
 418         }
 419         /* calculate ratio */
 420         ratio = (ch1 << 15) / ch0;
 421         /* convert to unscaled lux using the pointer to the table */
 422         p = (struct tsl2x7x_lux *) chip->tsl2x7x_device_lux;
 423         while (p->ratio != 0 && p->ratio < ratio)
 424                 p++;
 425
 426         if (p->ratio == 0) {
 427                 lux = 0;
 428         } else {
 429                 ch0lux = DIV_ROUND_UP((ch0 * p->ch0),
 430                         tsl2X7X_als_gainadj[chip->tsl2x7x_settings.als_gain]);
 431                 ch1lux = DIV_ROUND_UP((ch1 * p->ch1),
 432                         tsl2X7X_als_gainadj[chip->tsl2x7x_settings.als_gain]);
 433                 lux = ch0lux - ch1lux;
 434         }
 435
 436         /* note: lux is 31 bit max at this point */
 437         if (ch1lux > ch0lux) {
 438                 dev_dbg(&chip->client->dev, "ch1lux > ch0lux-return last value\n");
 439                 ret = chip->als_cur_info.lux;
 440                 goto out_unlock;
 441         }
 442
 443         /* adjust for active time scale */
 444         if (chip->als_time_scale == 0)
 445                 lux = 0;
 446         else
 447                 lux = (lux + (chip->als_time_scale >> 1)) /
 448                         chip->als_time_scale;
 449
 450         /* adjust for active gain scale
 451          * The tsl2x7x_device_lux tables have a factor of 256 built-in.
 452          * User-specified gain provides a multiplier.
 453          * Apply user-specified gain before shifting right to retain precision.
 454          * Use 64 bits to avoid overflow on multiplication.
 455          * Then go back to 32 bits before division to avoid using div_u64().
 456          */
 457
 458         lux64 = lux;
 459         lux64 = lux64 * chip->tsl2x7x_settings.als_gain_trim;
 460         lux64 >>= 8;
 461         lux = lux64;
 462         lux = (lux + 500) / 1000;
 463
 464         if (lux > TSL2X7X_LUX_CALC_OVER_FLOW) /* check for overflow */
 465                 lux = TSL2X7X_LUX_CALC_OVER_FLOW;
 466
 467         /* Update the structure with the latest lux. */
 468 return_max:
 469         chip->als_cur_info.lux = lux;
 470         ret = lux;
 471
 472 out_unlock:
 473         mutex_unlock(&chip->als_mutex);
 474
 475         return ret;
 476 }
 477
 478 /**
 479  * tsl2x7x_get_prox() - Reads proximity data registers and updates
 480  *                      chip->prox_data.
 481  *
 482  * @indio_dev:  pointer to IIO device
 483  */
 484 static int tsl2x7x_get_prox(struct iio_dev *indio_dev)
 485 {
 486         int i;
 487         int ret;
 488         u8 status;
 489         u8 chdata[2];
 490         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
 491
 492         if (mutex_trylock(&chip->prox_mutex) == 0) {
 493                 dev_err(&chip->client->dev,
 494                         "%s: Can't get prox mutex\n", __func__);
 495                 return -EBUSY;
 496         }
 497
 498         ret = tsl2x7x_i2c_read(chip->client,
 499                 (TSL2X7X_CMD_REG | TSL2X7X_STATUS), &status);
 500         if (ret < 0) {
 501                 dev_err(&chip->client->dev,
 502                 "%s: i2c err=%d\n", __func__, ret);
 503                 goto prox_poll_err;
 504         }
 505
 506         switch (chip->id) {
 507         case tsl2571:
 508         case tsl2671:
 509         case tmd2671:
 510         case tsl2771:
 511         case tmd2771:
 512                 if (!(status & TSL2X7X_STA_ADC_VALID))
 513                         goto prox_poll_err;
 514         break;
 515         case tsl2572:
 516         case tsl2672:
 517         case tmd2672:
 518         case tsl2772:
 519         case tmd2772:
 520                 if (!(status & TSL2X7X_STA_PRX_VALID))
 521                         goto prox_poll_err;
 522         break;
 523         }
 524
 525         for (i = 0; i < 2; i++) {
 526                 ret = tsl2x7x_i2c_read(chip->client,
 527                         (TSL2X7X_CMD_REG |
 528                                         (TSL2X7X_PRX_LO + i)), &chdata[i]);
 529                 if (ret < 0)
 530                         goto prox_poll_err;
 531         }
 532
 533         chip->prox_data =
 534                         le16_to_cpup((const __le16 *)&chdata[0]);
 535
 536 prox_poll_err:
 537
 538         mutex_unlock(&chip->prox_mutex);
 539
 540         return chip->prox_data;
 541 }
 542
 543 /**
 544  * tsl2x7x_defaults() - Populates the device nominal operating parameters
 545  *                      with those provided by a 'platform' data struct or
 546  *                      with prefined defaults.
 547  *
 548  * @chip:               pointer to device structure.
 549  */
 550 static void tsl2x7x_defaults(struct tsl2X7X_chip *chip)
 551 {
 552         /* If Operational settings defined elsewhere.. */
 553         if (chip->pdata && chip->pdata->platform_default_settings != 0)
 554                 memcpy(&(chip->tsl2x7x_settings),
 555                         chip->pdata->platform_default_settings,
 556                         sizeof(tsl2x7x_default_settings));
 557         else
 558                 memcpy(&(chip->tsl2x7x_settings),
 559                         &tsl2x7x_default_settings,
 560                         sizeof(tsl2x7x_default_settings));
 561
 562         /* Load up the proper lux table. */
 563         if (chip->pdata && chip->pdata->platform_lux_table[0].ratio != 0)
 564                 memcpy(chip->tsl2x7x_device_lux,
 565                         chip->pdata->platform_lux_table,
 566                         sizeof(chip->pdata->platform_lux_table));
 567         else
 568                 memcpy(chip->tsl2x7x_device_lux,
 569                 (struct tsl2x7x_lux *)tsl2x7x_default_lux_table_group[chip->id],
 570                                 MAX_DEFAULT_TABLE_BYTES);
 571 }
 572
 573 /**
 574  * tsl2x7x_als_calibrate() -    Obtain single reading and calculate
 575  *                              the als_gain_trim.
 576  *
 577  * @indio_dev:  pointer to IIO device
 578  */
 579 static int tsl2x7x_als_calibrate(struct iio_dev *indio_dev)
 580 {
 581         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
 582         u8 reg_val;
 583         int gain_trim_val;
 584         int ret;
 585         int lux_val;
 586
 587         ret = i2c_smbus_write_byte(chip->client,
 588                         (TSL2X7X_CMD_REG | TSL2X7X_CNTRL));
 589         if (ret < 0) {
 590                 dev_err(&chip->client->dev,
 591                 "%s: failed to write CNTRL register, ret=%d\n",
 592                 __func__, ret);
 593                 return ret;
 594         }
 595
 596         reg_val = i2c_smbus_read_byte(chip->client);
 597         if ((reg_val & (TSL2X7X_CNTL_ADC_ENBL | TSL2X7X_CNTL_PWR_ON))
 598                 != (TSL2X7X_CNTL_ADC_ENBL | TSL2X7X_CNTL_PWR_ON)) {
 599                 dev_err(&chip->client->dev,
 600                         "%s: failed: ADC not enabled\n", __func__);
 601                 return -1;
 602         }
 603
 604         ret = i2c_smbus_write_byte(chip->client,
 605                         (TSL2X7X_CMD_REG | TSL2X7X_CNTRL));
 606         if (ret < 0) {
 607                 dev_err(&chip->client->dev,
 608                         "%s: failed to write ctrl reg: ret=%d\n",
 609                         __func__, ret);
 610                 return ret;
 611         }
 612
 613         reg_val = i2c_smbus_read_byte(chip->client);
 614         if ((reg_val & TSL2X7X_STA_ADC_VALID) != TSL2X7X_STA_ADC_VALID) {
 615                 dev_err(&chip->client->dev,
 616                         "%s: failed: STATUS - ADC not valid.\n", __func__);
 617                 return -ENODATA;
 618         }
 619
 620         lux_val = tsl2x7x_get_lux(indio_dev);
 621         if (lux_val < 0) {
 622                 dev_err(&chip->client->dev,
 623                 "%s: failed to get lux\n", __func__);
 624                 return lux_val;
 625         }
 626
 627         gain_trim_val =  (((chip->tsl2x7x_settings.als_cal_target)
 628                         * chip->tsl2x7x_settings.als_gain_trim) / lux_val);
 629         if ((gain_trim_val < 250) || (gain_trim_val > 4000))
 630                 return -ERANGE;
 631
 632         chip->tsl2x7x_settings.als_gain_trim = gain_trim_val;
 633         dev_info(&chip->client->dev,
 634                 "%s als_calibrate completed\n", chip->client->name);
 635
 636         return (int) gain_trim_val;
 637 }
 638
 639 static int tsl2x7x_chip_on(struct iio_dev *indio_dev)
 640 {
 641         int i;
 642         int ret = 0;
 643         u8 *dev_reg;
 644         u8 utmp;
 645         int als_count;
 646         int als_time;
 647         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
 648         u8 reg_val = 0;
 649
 650         if (chip->pdata && chip->pdata->power_on)
 651                 chip->pdata->power_on(indio_dev);
 652
 653         /* Non calculated parameters */
 654         chip->tsl2x7x_config[TSL2X7X_PRX_TIME] =
 655                         chip->tsl2x7x_settings.prx_time;
 656         chip->tsl2x7x_config[TSL2X7X_WAIT_TIME] =
 657                         chip->tsl2x7x_settings.wait_time;
 658         chip->tsl2x7x_config[TSL2X7X_PRX_CONFIG] =
 659                         chip->tsl2x7x_settings.prox_config;
 660
 661         chip->tsl2x7x_config[TSL2X7X_ALS_MINTHRESHLO] =
 662                 (chip->tsl2x7x_settings.als_thresh_low) & 0xFF;
 663         chip->tsl2x7x_config[TSL2X7X_ALS_MINTHRESHHI] =
 664                 (chip->tsl2x7x_settings.als_thresh_low >> 8) & 0xFF;
 665         chip->tsl2x7x_config[TSL2X7X_ALS_MAXTHRESHLO] =
 666                 (chip->tsl2x7x_settings.als_thresh_high) & 0xFF;
 667         chip->tsl2x7x_config[TSL2X7X_ALS_MAXTHRESHHI] =
 668                 (chip->tsl2x7x_settings.als_thresh_high >> 8) & 0xFF;
 669         chip->tsl2x7x_config[TSL2X7X_PERSISTENCE] =
 670                 chip->tsl2x7x_settings.persistence;
 671
 672         chip->tsl2x7x_config[TSL2X7X_PRX_COUNT] =
 673                         chip->tsl2x7x_settings.prox_pulse_count;
 674         chip->tsl2x7x_config[TSL2X7X_PRX_MINTHRESHLO] =
 675         chip->tsl2x7x_settings.prox_thres_low;
 676         chip->tsl2x7x_config[TSL2X7X_PRX_MAXTHRESHLO] =
 677                         chip->tsl2x7x_settings.prox_thres_high;
 678
 679         /* and make sure we're not already on */
 680         if (chip->tsl2x7x_chip_status == TSL2X7X_CHIP_WORKING) {
 681                 /* if forcing a register update - turn off, then on */
 682                 dev_info(&chip->client->dev, "device is already enabled\n");
 683                 return -EINVAL;
 684         }
 685
 686         /* determine als integration register */
 687         als_count = (chip->tsl2x7x_settings.als_time * 100 + 135) / 270;
 688         if (als_count == 0)
 689                 als_count = 1; /* ensure at least one cycle */
 690
 691         /* convert back to time (encompasses overrides) */
 692         als_time = (als_count * 27 + 5) / 10;
 693         chip->tsl2x7x_config[TSL2X7X_ALS_TIME] = 256 - als_count;
 694
 695         /* Set the gain based on tsl2x7x_settings struct */
 696         chip->tsl2x7x_config[TSL2X7X_GAIN] =
 697                 (chip->tsl2x7x_settings.als_gain |
 698                         (TSL2X7X_mA100 | TSL2X7X_DIODE1)
 699                         | ((chip->tsl2x7x_settings.prox_gain) << 2));
 700
 701         /* set chip struct re scaling and saturation */
 702         chip->als_saturation = als_count * 922; /* 90% of full scale */
 703         chip->als_time_scale = (als_time + 25) / 50;
 704
 705         /* TSL2X7X Specific power-on / adc enable sequence
 706          * Power on the device 1st. */
 707         utmp = TSL2X7X_CNTL_PWR_ON;
 708         ret = i2c_smbus_write_byte_data(chip->client,
 709                 TSL2X7X_CMD_REG | TSL2X7X_CNTRL, utmp);
 710         if (ret < 0) {
 711                 dev_err(&chip->client->dev,
 712                         "%s: failed on CNTRL reg.\n", __func__);
 713                 return ret;
 714         }
 715
 716         /* Use the following shadow copy for our delay before enabling ADC.
 717          * Write all the registers. */
 718         for (i = 0, dev_reg = chip->tsl2x7x_config;
 719                         i < TSL2X7X_MAX_CONFIG_REG; i++) {
 720                 ret = i2c_smbus_write_byte_data(chip->client,
 721                                 TSL2X7X_CMD_REG + i, *dev_reg++);
 722                 if (ret < 0) {
 723                         dev_err(&chip->client->dev,
 724                         "%s: failed on write to reg %d.\n", __func__, i);
 725                         return ret;
 726                 }
 727         }
 728
 729         mdelay(3);      /* Power-on settling time */
 730
 731         /* NOW enable the ADC
 732          * initialize the desired mode of operation */
 733         utmp = TSL2X7X_CNTL_PWR_ON |
 734                         TSL2X7X_CNTL_ADC_ENBL |
 735                         TSL2X7X_CNTL_PROX_DET_ENBL;
 736         ret = i2c_smbus_write_byte_data(chip->client,
 737                         TSL2X7X_CMD_REG | TSL2X7X_CNTRL, utmp);
 738         if (ret < 0) {
 739                 dev_err(&chip->client->dev,
 740                         "%s: failed on 2nd CTRL reg.\n", __func__);
 741                 return ret;
 742         }
 743
 744         chip->tsl2x7x_chip_status = TSL2X7X_CHIP_WORKING;
 745
 746         if (chip->tsl2x7x_settings.interrupts_en != 0) {
 747                 dev_info(&chip->client->dev, "Setting Up Interrupt(s)\n");
 748
 749                 reg_val = TSL2X7X_CNTL_PWR_ON | TSL2X7X_CNTL_ADC_ENBL;
 750                 if ((chip->tsl2x7x_settings.interrupts_en == 0x20) ||
 751                         (chip->tsl2x7x_settings.interrupts_en == 0x30))
 752                         reg_val |= TSL2X7X_CNTL_PROX_DET_ENBL;
 753
 754                 reg_val |= chip->tsl2x7x_settings.interrupts_en;
 755                 ret = i2c_smbus_write_byte_data(chip->client,
 756                         (TSL2X7X_CMD_REG | TSL2X7X_CNTRL), reg_val);
 757                 if (ret < 0)
 758                         dev_err(&chip->client->dev,
 759                                 "%s: failed in tsl2x7x_IOCTL_INT_SET.\n",
 760                                 __func__);
 761
 762                 /* Clear out any initial interrupts  */
 763                 ret = i2c_smbus_write_byte(chip->client,
 764                         TSL2X7X_CMD_REG | TSL2X7X_CMD_SPL_FN |
 765                         TSL2X7X_CMD_PROXALS_INT_CLR);
 766                 if (ret < 0) {
 767                         dev_err(&chip->client->dev,
 768                                 "%s: Failed to clear Int status\n",
 769                                 __func__);
 770                 return ret;
 771                 }
 772         }
 773
 774         return ret;
 775 }
 776
 777 static int tsl2x7x_chip_off(struct iio_dev *indio_dev)
 778 {
 779         int ret;
 780         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
 781
 782         /* turn device off */
 783         chip->tsl2x7x_chip_status = TSL2X7X_CHIP_SUSPENDED;
 784
 785         ret = i2c_smbus_write_byte_data(chip->client,
 786                 TSL2X7X_CMD_REG | TSL2X7X_CNTRL, 0x00);
 787
 788         if (chip->pdata && chip->pdata->power_off)
 789                 chip->pdata->power_off(chip->client);
 790
 791         return ret;
 792 }
 793
 794 /**
 795  * tsl2x7x_invoke_change
 796  * @indio_dev:  pointer to IIO device
 797  *
 798  * Obtain and lock both ALS and PROX resources,
 799  * determine and save device state (On/Off),
 800  * cycle device to implement updated parameter,
 801  * put device back into proper state, and unlock
 802  * resource.
 803  */
 804 static
 805 int tsl2x7x_invoke_change(struct iio_dev *indio_dev)
 806 {
 807         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
 808         int device_status = chip->tsl2x7x_chip_status;
 809
 810         mutex_lock(&chip->als_mutex);
 811         mutex_lock(&chip->prox_mutex);
 812
 813         if (device_status == TSL2X7X_CHIP_WORKING)
 814                 tsl2x7x_chip_off(indio_dev);
 815
 816         tsl2x7x_chip_on(indio_dev);
 817
 818         if (device_status != TSL2X7X_CHIP_WORKING)
 819                 tsl2x7x_chip_off(indio_dev);
 820
 821         mutex_unlock(&chip->prox_mutex);
 822         mutex_unlock(&chip->als_mutex);
 823
 824         return 0;
 825 }
 826
 827 static
 828 void tsl2x7x_prox_calculate(int *data, int length,
 829                 struct tsl2x7x_prox_stat *statP)
 830 {
 831         int i;
 832         int sample_sum;
 833         int tmp;
 834
 835         if (length == 0)
 836                 length = 1;
 837
 838         sample_sum = 0;
 839         statP->min = INT_MAX;
 840         statP->max = INT_MIN;
 841         for (i = 0; i < length; i++) {
 842                 sample_sum += data[i];
 843                 statP->min = min(statP->min, data[i]);
 844                 statP->max = max(statP->max, data[i]);
 845         }
 846
 847         statP->mean = sample_sum / length;
 848         sample_sum = 0;
 849         for (i = 0; i < length; i++) {
 850                 tmp = data[i] - statP->mean;
 851                 sample_sum += tmp * tmp;
 852         }
 853         statP->stddev = int_sqrt((long)sample_sum)/length;
 854 }
 855
 856 /**
 857  * tsl2x7x_prox_cal() - Calculates std. and sets thresholds.
 858  * @indio_dev:  pointer to IIO device
 859  *
 860  * Calculates a standard deviation based on the samples,
 861  * and sets the threshold accordingly.
 862  */
 863 static void tsl2x7x_prox_cal(struct iio_dev *indio_dev)
 864 {
 865         int prox_history[MAX_SAMPLES_CAL + 1];
 866         int i;
 867         struct tsl2x7x_prox_stat prox_stat_data[2];
 868         struct tsl2x7x_prox_stat *calP;
 869         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
 870         u8 tmp_irq_settings;
 871         u8 current_state = chip->tsl2x7x_chip_status;
 872
 873         if (chip->tsl2x7x_settings.prox_max_samples_cal > MAX_SAMPLES_CAL) {
 874                 dev_err(&chip->client->dev,
 875                         "%s: max prox samples cal is too big: %d\n",
 876                         __func__, chip->tsl2x7x_settings.prox_max_samples_cal);
 877                 chip->tsl2x7x_settings.prox_max_samples_cal = MAX_SAMPLES_CAL;
 878         }
 879
 880         /* have to stop to change settings */
 881         tsl2x7x_chip_off(indio_dev);
 882
 883         /* Enable proximity detection save just in case prox not wanted yet*/
 884         tmp_irq_settings = chip->tsl2x7x_settings.interrupts_en;
 885         chip->tsl2x7x_settings.interrupts_en |= TSL2X7X_CNTL_PROX_INT_ENBL;
 886
 887         /*turn on device if not already on*/
 888         tsl2x7x_chip_on(indio_dev);
 889
 890         /*gather the samples*/
 891         for (i = 0; i < chip->tsl2x7x_settings.prox_max_samples_cal; i++) {
 892                 mdelay(15);
 893                 tsl2x7x_get_prox(indio_dev);
 894                 prox_history[i] = chip->prox_data;
 895                 dev_info(&chip->client->dev, "2 i=%d prox data= %d\n",
 896                         i, chip->prox_data);
 897         }
 898
 899         tsl2x7x_chip_off(indio_dev);
 900         calP = &prox_stat_data[PROX_STAT_CAL];
 901         tsl2x7x_prox_calculate(prox_history,
 902                 chip->tsl2x7x_settings.prox_max_samples_cal, calP);
 903         chip->tsl2x7x_settings.prox_thres_high = (calP->max << 1) - calP->mean;
 904
 905         dev_info(&chip->client->dev, " cal min=%d mean=%d max=%d\n",
 906                 calP->min, calP->mean, calP->max);
 907         dev_info(&chip->client->dev,
 908                 "%s proximity threshold set to %d\n",
 909                 chip->client->name, chip->tsl2x7x_settings.prox_thres_high);
 910
 911         /* back to the way they were */
 912         chip->tsl2x7x_settings.interrupts_en = tmp_irq_settings;
 913         if (current_state == TSL2X7X_CHIP_WORKING)
 914                 tsl2x7x_chip_on(indio_dev);
 915 }
 916
 917 static ssize_t tsl2x7x_power_state_show(struct device *dev,
 918         struct device_attribute *attr, char *buf)
 919 {
 920         struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
 921
 922         return snprintf(buf, PAGE_SIZE, "%d\n", chip->tsl2x7x_chip_status);
 923 }
 924
 925 static ssize_t tsl2x7x_power_state_store(struct device *dev,
 926         struct device_attribute *attr, const char *buf, size_t len)
 927 {
 928         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 929         bool value;
 930
 931         if (strtobool(buf, &value))
 932                 return -EINVAL;
 933
 934         if (value)
 935                 tsl2x7x_chip_on(indio_dev);
 936         else
 937                 tsl2x7x_chip_off(indio_dev);
 938
 939         return len;
 940 }
 941
 942 static ssize_t tsl2x7x_gain_available_show(struct device *dev,
 943         struct device_attribute *attr, char *buf)
 944 {
 945         struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
 946
 947         switch (chip->id) {
 948         case tsl2571:
 949         case tsl2671:
 950         case tmd2671:
 951         case tsl2771:
 952         case tmd2771:
 953                 return snprintf(buf, PAGE_SIZE, "%s\n", "1 8 16 128");
 954         break;
 955         }
 956
 957         return snprintf(buf, PAGE_SIZE, "%s\n", "1 8 16 120");
 958 }
 959
 960 static ssize_t tsl2x7x_prox_gain_available_show(struct device *dev,
 961         struct device_attribute *attr, char *buf)
 962 {
 963                 return snprintf(buf, PAGE_SIZE, "%s\n", "1 2 4 8");
 964 }
 965
 966 static ssize_t tsl2x7x_als_time_show(struct device *dev,
 967         struct device_attribute *attr, char *buf)
 968 {
 969         struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
 970         int y, z;
 971
 972         y = (TSL2X7X_MAX_TIMER_CNT - (u8)chip->tsl2x7x_settings.als_time) + 1;
 973         z = y * TSL2X7X_MIN_ITIME;
 974         y /= 1000;
 975         z %= 1000;
 976
 977         return snprintf(buf, PAGE_SIZE, "%d.%03d\n", y, z);
 978 }
 979
 980 static ssize_t tsl2x7x_als_time_store(struct device *dev,
 981         struct device_attribute *attr, const char *buf, size_t len)
 982 {
 983         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 984         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
 985         struct tsl2x7x_parse_result result;
 986         int ret;
 987
 988         ret = iio_str_to_fixpoint(buf, 100, &result.integer, &result.fract);
 989         if (ret)
 990                 return ret;
 991
 992         result.fract /= 3;
 993         chip->tsl2x7x_settings.als_time =
 994                         (TSL2X7X_MAX_TIMER_CNT - (u8)result.fract);
 995
 996         dev_info(&chip->client->dev, "%s: als time = %d",
 997                 __func__, chip->tsl2x7x_settings.als_time);
 998
 999         tsl2x7x_invoke_change(indio_dev);
1000
1001         return IIO_VAL_INT_PLUS_MICRO;
1002 }
1003
1004 static IIO_CONST_ATTR(in_illuminance0_integration_time_available,
1005                 ".00272 - .696");
1006
1007 static ssize_t tsl2x7x_als_cal_target_show(struct device *dev,
1008         struct device_attribute *attr, char *buf)
1009 {
1010         struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
1011
1012         return snprintf(buf, PAGE_SIZE, "%d\n",
1013                         chip->tsl2x7x_settings.als_cal_target);
1014 }
1015
1016 static ssize_t tsl2x7x_als_cal_target_store(struct device *dev,
1017         struct device_attribute *attr, const char *buf, size_t len)
1018 {
1019         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1020         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1021         unsigned long value;
1022
1023         if (kstrtoul(buf, 0, &value))
1024                 return -EINVAL;
1025
1026         if (value)
1027                 chip->tsl2x7x_settings.als_cal_target = value;
1028
1029         tsl2x7x_invoke_change(indio_dev);
1030
1031         return len;
1032 }
1033
1034 /* persistence settings */
1035 static ssize_t tsl2x7x_als_persistence_show(struct device *dev,
1036         struct device_attribute *attr, char *buf)
1037 {
1038         struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
1039         int y, z, filter_delay;
1040
1041         /* Determine integration time */
1042         y = (TSL2X7X_MAX_TIMER_CNT - (u8)chip->tsl2x7x_settings.als_time) + 1;
1043         z = y * TSL2X7X_MIN_ITIME;
1044         filter_delay = z * (chip->tsl2x7x_settings.persistence & 0x0F);
1045         y = (filter_delay / 1000);
1046         z = (filter_delay % 1000);
1047
1048         return snprintf(buf, PAGE_SIZE, "%d.%03d\n", y, z);
1049 }
1050
1051 static ssize_t tsl2x7x_als_persistence_store(struct device *dev,
1052         struct device_attribute *attr, const char *buf, size_t len)
1053 {
1054         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1055         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1056         struct tsl2x7x_parse_result result;
1057         int y, z, filter_delay;
1058         int ret;
1059
1060         ret = iio_str_to_fixpoint(buf, 100, &result.integer, &result.fract);
1061         if (ret)
1062                 return ret;
1063
1064         y = (TSL2X7X_MAX_TIMER_CNT - (u8)chip->tsl2x7x_settings.als_time) + 1;
1065         z = y * TSL2X7X_MIN_ITIME;
1066
1067         filter_delay =
1068                 DIV_ROUND_UP(((result.integer * 1000) + result.fract), z);
1069
1070         chip->tsl2x7x_settings.persistence &= 0xF0;
1071         chip->tsl2x7x_settings.persistence |= (filter_delay & 0x0F);
1072
1073         dev_info(&chip->client->dev, "%s: als persistence = %d",
1074                 __func__, filter_delay);
1075
1076         tsl2x7x_invoke_change(indio_dev);
1077
1078         return IIO_VAL_INT_PLUS_MICRO;
1079 }
1080
1081 static ssize_t tsl2x7x_prox_persistence_show(struct device *dev,
1082         struct device_attribute *attr, char *buf)
1083 {
1084         struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
1085         int y, z, filter_delay;
1086
1087         /* Determine integration time */
1088         y = (TSL2X7X_MAX_TIMER_CNT - (u8)chip->tsl2x7x_settings.prx_time) + 1;
1089         z = y * TSL2X7X_MIN_ITIME;
1090         filter_delay = z * ((chip->tsl2x7x_settings.persistence & 0xF0) >> 4);
1091         y = (filter_delay / 1000);
1092         z = (filter_delay % 1000);
1093
1094         return snprintf(buf, PAGE_SIZE, "%d.%03d\n", y, z);
1095 }
1096
1097 static ssize_t tsl2x7x_prox_persistence_store(struct device *dev,
1098         struct device_attribute *attr, const char *buf, size_t len)
1099 {
1100         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1101         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1102         struct tsl2x7x_parse_result result;
1103         int y, z, filter_delay;
1104         int ret;
1105
1106         ret = iio_str_to_fixpoint(buf, 100, &result.integer, &result.fract);
1107         if (ret)
1108                 return ret;
1109
1110         y = (TSL2X7X_MAX_TIMER_CNT - (u8)chip->tsl2x7x_settings.prx_time) + 1;
1111         z = y * TSL2X7X_MIN_ITIME;
1112
1113         filter_delay =
1114                 DIV_ROUND_UP(((result.integer * 1000) + result.fract), z);
1115
1116         chip->tsl2x7x_settings.persistence &= 0x0F;
1117         chip->tsl2x7x_settings.persistence |= ((filter_delay << 4) & 0xF0);
1118
1119         dev_info(&chip->client->dev, "%s: prox persistence = %d",
1120                 __func__, filter_delay);
1121
1122         tsl2x7x_invoke_change(indio_dev);
1123
1124         return IIO_VAL_INT_PLUS_MICRO;
1125 }
1126
1127 static ssize_t tsl2x7x_do_calibrate(struct device *dev,
1128         struct device_attribute *attr, const char *buf, size_t len)
1129 {
1130         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1131         bool value;
1132
1133         if (strtobool(buf, &value))
1134                 return -EINVAL;
1135
1136         if (value)
1137                 tsl2x7x_als_calibrate(indio_dev);
1138
1139         tsl2x7x_invoke_change(indio_dev);
1140
1141         return len;
1142 }
1143
1144 static ssize_t tsl2x7x_luxtable_show(struct device *dev,
1145         struct device_attribute *attr, char *buf)
1146 {
1147         struct tsl2X7X_chip *chip = iio_priv(dev_to_iio_dev(dev));
1148         int i = 0;
1149         int offset = 0;
1150
1151         while (i < (TSL2X7X_MAX_LUX_TABLE_SIZE * 3)) {
1152                 offset += snprintf(buf + offset, PAGE_SIZE, "%d,%d,%d,",
1153                         chip->tsl2x7x_device_lux[i].ratio,
1154                         chip->tsl2x7x_device_lux[i].ch0,
1155                         chip->tsl2x7x_device_lux[i].ch1);
1156                 if (chip->tsl2x7x_device_lux[i].ratio == 0) {
1157                         /* We just printed the first "0" entry.
1158                          * Now get rid of the extra "," and break. */
1159                         offset--;
1160                         break;
1161                 }
1162                 i++;
1163         }
1164
1165         offset += snprintf(buf + offset, PAGE_SIZE, "\n");
1166         return offset;
1167 }
1168
1169 static ssize_t tsl2x7x_luxtable_store(struct device *dev,
1170         struct device_attribute *attr, const char *buf, size_t len)
1171 {
1172         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1173         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1174         int value[ARRAY_SIZE(chip->tsl2x7x_device_lux)*3 + 1];
1175         int n;
1176
1177         get_options(buf, ARRAY_SIZE(value), value);
1178
1179         /* We now have an array of ints starting at value[1], and
1180          * enumerated by value[0].
1181          * We expect each group of three ints is one table entry,
1182          * and the last table entry is all 0.
1183          */
1184         n = value[0];
1185         if ((n % 3) || n < 6 ||
1186                         n > ((ARRAY_SIZE(chip->tsl2x7x_device_lux) - 1) * 3)) {
1187                 dev_info(dev, "LUX TABLE INPUT ERROR 1 Value[0]=%d\n", n);
1188                 return -EINVAL;
1189         }
1190
1191         if ((value[(n - 2)] | value[(n - 1)] | value[n]) != 0) {
1192                 dev_info(dev, "LUX TABLE INPUT ERROR 2 Value[0]=%d\n", n);
1193                 return -EINVAL;
1194         }
1195
1196         if (chip->tsl2x7x_chip_status == TSL2X7X_CHIP_WORKING)
1197                 tsl2x7x_chip_off(indio_dev);
1198
1199         /* Zero out the table */
1200         memset(chip->tsl2x7x_device_lux, 0, sizeof(chip->tsl2x7x_device_lux));
1201         memcpy(chip->tsl2x7x_device_lux, &value[1], (value[0] * 4));
1202
1203         tsl2x7x_invoke_change(indio_dev);
1204
1205         return len;
1206 }
1207
1208 static ssize_t tsl2x7x_do_prox_calibrate(struct device *dev,
1209         struct device_attribute *attr, const char *buf, size_t len)
1210 {
1211         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1212         bool value;
1213
1214         if (strtobool(buf, &value))
1215                 return -EINVAL;
1216
1217         if (value)
1218                 tsl2x7x_prox_cal(indio_dev);
1219
1220         tsl2x7x_invoke_change(indio_dev);
1221
1222         return len;
1223 }
1224
1225 static int tsl2x7x_read_interrupt_config(struct iio_dev *indio_dev,
1226                                          u64 event_code)
1227 {
1228         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1229         int ret;
1230
1231         if (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code) == IIO_INTENSITY)
1232                 ret = !!(chip->tsl2x7x_settings.interrupts_en & 0x10);
1233         else
1234                 ret = !!(chip->tsl2x7x_settings.interrupts_en & 0x20);
1235
1236         return ret;
1237 }
1238
1239 static int tsl2x7x_write_interrupt_config(struct iio_dev *indio_dev,
1240                                           u64 event_code,
1241                                           int val)
1242 {
1243         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1244
1245         if (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code) == IIO_INTENSITY) {
1246                 if (val)
1247                         chip->tsl2x7x_settings.interrupts_en |= 0x10;
1248                 else
1249                         chip->tsl2x7x_settings.interrupts_en &= 0x20;
1250         } else {
1251                 if (val)
1252                         chip->tsl2x7x_settings.interrupts_en |= 0x20;
1253                 else
1254                         chip->tsl2x7x_settings.interrupts_en &= 0x10;
1255         }
1256
1257         tsl2x7x_invoke_change(indio_dev);
1258
1259         return 0;
1260 }
1261
1262 static int tsl2x7x_write_thresh(struct iio_dev *indio_dev,
1263                                   u64 event_code,
1264                                   int val)
1265 {
1266         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1267
1268         if (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code) == IIO_INTENSITY) {
1269                 switch (IIO_EVENT_CODE_EXTRACT_DIR(event_code)) {
1270                 case IIO_EV_DIR_RISING:
1271                         chip->tsl2x7x_settings.als_thresh_high = val;
1272                         break;
1273                 case IIO_EV_DIR_FALLING:
1274                         chip->tsl2x7x_settings.als_thresh_low = val;
1275                         break;
1276                 default:
1277                         return -EINVAL;
1278                 }
1279         } else {
1280                 switch (IIO_EVENT_CODE_EXTRACT_DIR(event_code)) {
1281                 case IIO_EV_DIR_RISING:
1282                         chip->tsl2x7x_settings.prox_thres_high = val;
1283                         break;
1284                 case IIO_EV_DIR_FALLING:
1285                         chip->tsl2x7x_settings.prox_thres_low = val;
1286                         break;
1287                 default:
1288                         return -EINVAL;
1289                 }
1290         }
1291
1292         tsl2x7x_invoke_change(indio_dev);
1293
1294         return 0;
1295 }
1296
1297 static int tsl2x7x_read_thresh(struct iio_dev *indio_dev,
1298                                u64 event_code,
1299                                int *val)
1300 {
1301         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1302
1303         if (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code) == IIO_INTENSITY) {
1304                 switch (IIO_EVENT_CODE_EXTRACT_DIR(event_code)) {
1305                 case IIO_EV_DIR_RISING:
1306                         *val = chip->tsl2x7x_settings.als_thresh_high;
1307                         break;
1308                 case IIO_EV_DIR_FALLING:
1309                         *val = chip->tsl2x7x_settings.als_thresh_low;
1310                         break;
1311                 default:
1312                         return -EINVAL;
1313                 }
1314         } else {
1315                 switch (IIO_EVENT_CODE_EXTRACT_DIR(event_code)) {
1316                 case IIO_EV_DIR_RISING:
1317                         *val = chip->tsl2x7x_settings.prox_thres_high;
1318                         break;
1319                 case IIO_EV_DIR_FALLING:
1320                         *val = chip->tsl2x7x_settings.prox_thres_low;
1321                         break;
1322                 default:
1323                         return -EINVAL;
1324                 }
1325         }
1326
1327         return 0;
1328 }
1329
1330 static int tsl2x7x_read_raw(struct iio_dev *indio_dev,
1331                             struct iio_chan_spec const *chan,
1332                             int *val,
1333                             int *val2,
1334                             long mask)
1335 {
1336         int ret = -EINVAL;
1337         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1338
1339         switch (mask) {
1340         case IIO_CHAN_INFO_PROCESSED:
1341                 switch (chan->type) {
1342                 case IIO_LIGHT:
1343                         tsl2x7x_get_lux(indio_dev);
1344                         *val = chip->als_cur_info.lux;
1345                         ret = IIO_VAL_INT;
1346                         break;
1347                 default:
1348                         return -EINVAL;
1349                         break;
1350                 }
1351                 break;
1352         case IIO_CHAN_INFO_RAW:
1353                 switch (chan->type) {
1354                 case IIO_INTENSITY:
1355                         tsl2x7x_get_lux(indio_dev);
1356                         if (chan->channel == 0)
1357                                 *val = chip->als_cur_info.als_ch0;
1358                         else
1359                                 *val = chip->als_cur_info.als_ch1;
1360                         ret = IIO_VAL_INT;
1361                         break;
1362                 case IIO_PROXIMITY:
1363                         tsl2x7x_get_prox(indio_dev);
1364                         *val = chip->prox_data;
1365                         ret = IIO_VAL_INT;
1366                         break;
1367                 default:
1368                         return -EINVAL;
1369                         break;
1370                 }
1371                 break;
1372         case IIO_CHAN_INFO_CALIBSCALE:
1373                 if (chan->type == IIO_LIGHT)
1374                         *val =
1375                         tsl2X7X_als_gainadj[chip->tsl2x7x_settings.als_gain];
1376                 else
1377                         *val =
1378                         tsl2X7X_prx_gainadj[chip->tsl2x7x_settings.prox_gain];
1379                 ret = IIO_VAL_INT;
1380                 break;
1381         case IIO_CHAN_INFO_CALIBBIAS:
1382                 *val = chip->tsl2x7x_settings.als_gain_trim;
1383                 ret = IIO_VAL_INT;
1384                 break;
1385
1386         default:
1387                 ret = -EINVAL;
1388         }
1389
1390         return ret;
1391 }
1392
1393 static int tsl2x7x_write_raw(struct iio_dev *indio_dev,
1394                                struct iio_chan_spec const *chan,
1395                                int val,
1396                                int val2,
1397                                long mask)
1398 {
1399         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1400
1401         switch (mask) {
1402         case IIO_CHAN_INFO_CALIBSCALE:
1403                 if (chan->type == IIO_INTENSITY) {
1404                         switch (val) {
1405                         case 1:
1406                                 chip->tsl2x7x_settings.als_gain = 0;
1407                                 break;
1408                         case 8:
1409                                 chip->tsl2x7x_settings.als_gain = 1;
1410                                 break;
1411                         case 16:
1412                                 chip->tsl2x7x_settings.als_gain = 2;
1413                                 break;
1414                         case 120:
1415                                 switch (chip->id) {
1416                                 case tsl2572:
1417                                 case tsl2672:
1418                                 case tmd2672:
1419                                 case tsl2772:
1420                                 case tmd2772:
1421                                         return -EINVAL;
1422                                 break;
1423                                 }
1424                                 chip->tsl2x7x_settings.als_gain = 3;
1425                                 break;
1426                         case 128:
1427                                 switch (chip->id) {
1428                                 case tsl2571:
1429                                 case tsl2671:
1430                                 case tmd2671:
1431                                 case tsl2771:
1432                                 case tmd2771:
1433                                         return -EINVAL;
1434                                 break;
1435                                 }
1436                                 chip->tsl2x7x_settings.als_gain = 3;
1437                                 break;
1438                         default:
1439                                 return -EINVAL;
1440                         }
1441                 } else {
1442                         switch (val) {
1443                         case 1:
1444                                 chip->tsl2x7x_settings.prox_gain = 0;
1445                                 break;
1446                         case 2:
1447                                 chip->tsl2x7x_settings.prox_gain = 1;
1448                                 break;
1449                         case 4:
1450                                 chip->tsl2x7x_settings.prox_gain = 2;
1451                                 break;
1452                         case 8:
1453                                 chip->tsl2x7x_settings.prox_gain = 3;
1454                                 break;
1455                         default:
1456                                 return -EINVAL;
1457                         }
1458                 }
1459                 break;
1460         case IIO_CHAN_INFO_CALIBBIAS:
1461                 chip->tsl2x7x_settings.als_gain_trim = val;
1462                 break;
1463
1464         default:
1465                 return -EINVAL;
1466         }
1467
1468         tsl2x7x_invoke_change(indio_dev);
1469
1470         return 0;
1471 }
1472
1473 static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR,
1474                 tsl2x7x_power_state_show, tsl2x7x_power_state_store);
1475
1476 static DEVICE_ATTR(in_proximity0_calibscale_available, S_IRUGO,
1477                 tsl2x7x_prox_gain_available_show, NULL);
1478
1479 static DEVICE_ATTR(in_illuminance0_calibscale_available, S_IRUGO,
1480                 tsl2x7x_gain_available_show, NULL);
1481
1482 static DEVICE_ATTR(in_illuminance0_integration_time, S_IRUGO | S_IWUSR,
1483                 tsl2x7x_als_time_show, tsl2x7x_als_time_store);
1484
1485 static DEVICE_ATTR(in_illuminance0_target_input, S_IRUGO | S_IWUSR,
1486                 tsl2x7x_als_cal_target_show, tsl2x7x_als_cal_target_store);
1487
1488 static DEVICE_ATTR(in_illuminance0_calibrate, S_IWUSR, NULL,
1489                 tsl2x7x_do_calibrate);
1490
1491 static DEVICE_ATTR(in_proximity0_calibrate, S_IWUSR, NULL,
1492                 tsl2x7x_do_prox_calibrate);
1493
1494 static DEVICE_ATTR(in_illuminance0_lux_table, S_IRUGO | S_IWUSR,
1495                 tsl2x7x_luxtable_show, tsl2x7x_luxtable_store);
1496
1497 static DEVICE_ATTR(in_intensity0_thresh_period, S_IRUGO | S_IWUSR,
1498                 tsl2x7x_als_persistence_show, tsl2x7x_als_persistence_store);
1499
1500 static DEVICE_ATTR(in_proximity0_thresh_period, S_IRUGO | S_IWUSR,
1501                 tsl2x7x_prox_persistence_show, tsl2x7x_prox_persistence_store);
1502
1503 /* Use the default register values to identify the Taos device */
1504 static int tsl2x7x_device_id(unsigned char *id, int target)
1505 {
1506         switch (target) {
1507         case tsl2571:
1508         case tsl2671:
1509         case tsl2771:
1510                 return ((*id & 0xf0) == TRITON_ID);
1511         break;
1512         case tmd2671:
1513         case tmd2771:
1514                 return ((*id & 0xf0) == HALIBUT_ID);
1515         break;
1516         case tsl2572:
1517         case tsl2672:
1518         case tmd2672:
1519         case tsl2772:
1520         case tmd2772:
1521                 return ((*id & 0xf0) == SWORDFISH_ID);
1522         break;
1523         }
1524
1525         return -EINVAL;
1526 }
1527
1528 static irqreturn_t tsl2x7x_event_handler(int irq, void *private)
1529 {
1530         struct iio_dev *indio_dev = private;
1531         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1532         s64 timestamp = iio_get_time_ns();
1533         int ret;
1534         u8 value;
1535
1536         value = i2c_smbus_read_byte_data(chip->client,
1537                 TSL2X7X_CMD_REG | TSL2X7X_STATUS);
1538
1539         /* What type of interrupt do we need to process */
1540         if (value & TSL2X7X_STA_PRX_INTR) {
1541                 tsl2x7x_get_prox(indio_dev); /* freshen data for ABI */
1542                 iio_push_event(indio_dev,
1543                                IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY,
1544                                                     0,
1545                                                     IIO_EV_TYPE_THRESH,
1546                                                     IIO_EV_DIR_EITHER),
1547                                                     timestamp);
1548         }
1549
1550         if (value & TSL2X7X_STA_ALS_INTR) {
1551                 tsl2x7x_get_lux(indio_dev); /* freshen data for ABI */
1552                 iio_push_event(indio_dev,
1553                        IIO_UNMOD_EVENT_CODE(IIO_LIGHT,
1554                                             0,
1555                                             IIO_EV_TYPE_THRESH,
1556                                             IIO_EV_DIR_EITHER),
1557                                             timestamp);
1558         }
1559         /* Clear interrupt now that we have handled it. */
1560         ret = i2c_smbus_write_byte(chip->client,
1561                 TSL2X7X_CMD_REG | TSL2X7X_CMD_SPL_FN |
1562                 TSL2X7X_CMD_PROXALS_INT_CLR);
1563         if (ret < 0)
1564                 dev_err(&chip->client->dev,
1565                         "%s: Failed to clear irq from event handler. err = %d\n",
1566                         __func__, ret);
1567
1568         return IRQ_HANDLED;
1569 }
1570
1571 static struct attribute *tsl2x7x_ALS_device_attrs[] = {
1572         &dev_attr_power_state.attr,
1573         &dev_attr_in_illuminance0_calibscale_available.attr,
1574         &dev_attr_in_illuminance0_integration_time.attr,
1575         &iio_const_attr_in_illuminance0_integration_time_available\
1576         .dev_attr.attr,
1577         &dev_attr_in_illuminance0_target_input.attr,
1578         &dev_attr_in_illuminance0_calibrate.attr,
1579         &dev_attr_in_illuminance0_lux_table.attr,
1580         NULL
1581 };
1582
1583 static struct attribute *tsl2x7x_PRX_device_attrs[] = {
1584         &dev_attr_power_state.attr,
1585         &dev_attr_in_proximity0_calibrate.attr,
1586         NULL
1587 };
1588
1589 static struct attribute *tsl2x7x_ALSPRX_device_attrs[] = {
1590         &dev_attr_power_state.attr,
1591         &dev_attr_in_illuminance0_calibscale_available.attr,
1592         &dev_attr_in_illuminance0_integration_time.attr,
1593         &iio_const_attr_in_illuminance0_integration_time_available\
1594         .dev_attr.attr,
1595         &dev_attr_in_illuminance0_target_input.attr,
1596         &dev_attr_in_illuminance0_calibrate.attr,
1597         &dev_attr_in_illuminance0_lux_table.attr,
1598         &dev_attr_in_proximity0_calibrate.attr,
1599         NULL
1600 };
1601
1602 static struct attribute *tsl2x7x_PRX2_device_attrs[] = {
1603         &dev_attr_power_state.attr,
1604         &dev_attr_in_proximity0_calibrate.attr,
1605         &dev_attr_in_proximity0_calibscale_available.attr,
1606         NULL
1607 };
1608
1609 static struct attribute *tsl2x7x_ALSPRX2_device_attrs[] = {
1610         &dev_attr_power_state.attr,
1611         &dev_attr_in_illuminance0_calibscale_available.attr,
1612         &dev_attr_in_illuminance0_integration_time.attr,
1613         &iio_const_attr_in_illuminance0_integration_time_available\
1614         .dev_attr.attr,
1615         &dev_attr_in_illuminance0_target_input.attr,
1616         &dev_attr_in_illuminance0_calibrate.attr,
1617         &dev_attr_in_illuminance0_lux_table.attr,
1618         &dev_attr_in_proximity0_calibrate.attr,
1619         &dev_attr_in_proximity0_calibscale_available.attr,
1620         NULL
1621 };
1622
1623 static struct attribute *tsl2X7X_ALS_event_attrs[] = {
1624         &dev_attr_in_intensity0_thresh_period.attr,
1625         NULL,
1626 };
1627 static struct attribute *tsl2X7X_PRX_event_attrs[] = {
1628         &dev_attr_in_proximity0_thresh_period.attr,
1629         NULL,
1630 };
1631
1632 static struct attribute *tsl2X7X_ALSPRX_event_attrs[] = {
1633         &dev_attr_in_intensity0_thresh_period.attr,
1634         &dev_attr_in_proximity0_thresh_period.attr,
1635         NULL,
1636 };
1637
1638 static const struct attribute_group tsl2X7X_device_attr_group_tbl[] = {
1639         [ALS] = {
1640                 .attrs = tsl2x7x_ALS_device_attrs,
1641         },
1642         [PRX] = {
1643                 .attrs = tsl2x7x_PRX_device_attrs,
1644         },
1645         [ALSPRX] = {
1646                 .attrs = tsl2x7x_ALSPRX_device_attrs,
1647         },
1648         [PRX2] = {
1649                 .attrs = tsl2x7x_PRX2_device_attrs,
1650         },
1651         [ALSPRX2] = {
1652                 .attrs = tsl2x7x_ALSPRX2_device_attrs,
1653         },
1654 };
1655
1656 static struct attribute_group tsl2X7X_event_attr_group_tbl[] = {
1657         [ALS] = {
1658                 .attrs = tsl2X7X_ALS_event_attrs,
1659                 .name = "events",
1660         },
1661         [PRX] = {
1662                 .attrs = tsl2X7X_PRX_event_attrs,
1663                 .name = "events",
1664         },
1665         [ALSPRX] = {
1666                 .attrs = tsl2X7X_ALSPRX_event_attrs,
1667                 .name = "events",
1668         },
1669 };
1670
1671 static const struct iio_info tsl2X7X_device_info[] = {
1672         [ALS] = {
1673                 .attrs = &tsl2X7X_device_attr_group_tbl[ALS],
1674                 .event_attrs = &tsl2X7X_event_attr_group_tbl[ALS],
1675                 .driver_module = THIS_MODULE,
1676                 .read_raw = &tsl2x7x_read_raw,
1677                 .write_raw = &tsl2x7x_write_raw,
1678                 .read_event_value = &tsl2x7x_read_thresh,
1679                 .write_event_value = &tsl2x7x_write_thresh,
1680                 .read_event_config = &tsl2x7x_read_interrupt_config,
1681                 .write_event_config = &tsl2x7x_write_interrupt_config,
1682         },
1683         [PRX] = {
1684                 .attrs = &tsl2X7X_device_attr_group_tbl[PRX],
1685                 .event_attrs = &tsl2X7X_event_attr_group_tbl[PRX],
1686                 .driver_module = THIS_MODULE,
1687                 .read_raw = &tsl2x7x_read_raw,
1688                 .write_raw = &tsl2x7x_write_raw,
1689                 .read_event_value = &tsl2x7x_read_thresh,
1690                 .write_event_value = &tsl2x7x_write_thresh,
1691                 .read_event_config = &tsl2x7x_read_interrupt_config,
1692                 .write_event_config = &tsl2x7x_write_interrupt_config,
1693         },
1694         [ALSPRX] = {
1695                 .attrs = &tsl2X7X_device_attr_group_tbl[ALSPRX],
1696                 .event_attrs = &tsl2X7X_event_attr_group_tbl[ALSPRX],
1697                 .driver_module = THIS_MODULE,
1698                 .read_raw = &tsl2x7x_read_raw,
1699                 .write_raw = &tsl2x7x_write_raw,
1700                 .read_event_value = &tsl2x7x_read_thresh,
1701                 .write_event_value = &tsl2x7x_write_thresh,
1702                 .read_event_config = &tsl2x7x_read_interrupt_config,
1703                 .write_event_config = &tsl2x7x_write_interrupt_config,
1704         },
1705         [PRX2] = {
1706                 .attrs = &tsl2X7X_device_attr_group_tbl[PRX2],
1707                 .event_attrs = &tsl2X7X_event_attr_group_tbl[PRX],
1708                 .driver_module = THIS_MODULE,
1709                 .read_raw = &tsl2x7x_read_raw,
1710                 .write_raw = &tsl2x7x_write_raw,
1711                 .read_event_value = &tsl2x7x_read_thresh,
1712                 .write_event_value = &tsl2x7x_write_thresh,
1713                 .read_event_config = &tsl2x7x_read_interrupt_config,
1714                 .write_event_config = &tsl2x7x_write_interrupt_config,
1715         },
1716         [ALSPRX2] = {
1717                 .attrs = &tsl2X7X_device_attr_group_tbl[ALSPRX2],
1718                 .event_attrs = &tsl2X7X_event_attr_group_tbl[ALSPRX],
1719                 .driver_module = THIS_MODULE,
1720                 .read_raw = &tsl2x7x_read_raw,
1721                 .write_raw = &tsl2x7x_write_raw,
1722                 .read_event_value = &tsl2x7x_read_thresh,
1723                 .write_event_value = &tsl2x7x_write_thresh,
1724                 .read_event_config = &tsl2x7x_read_interrupt_config,
1725                 .write_event_config = &tsl2x7x_write_interrupt_config,
1726         },
1727 };
1728
1729 static const struct tsl2x7x_chip_info tsl2x7x_chip_info_tbl[] = {
1730         [ALS] = {
1731                 .channel = {
1732                         {
1733                         .type = IIO_LIGHT,
1734                         .indexed = 1,
1735                         .channel = 0,
1736                         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1737                         }, {
1738                         .type = IIO_INTENSITY,
1739                         .indexed = 1,
1740                         .channel = 0,
1741                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1742                                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1743                                 BIT(IIO_CHAN_INFO_CALIBBIAS),
1744                         .event_mask = TSL2X7X_EVENT_MASK
1745                         }, {
1746                         .type = IIO_INTENSITY,
1747                         .indexed = 1,
1748                         .channel = 1,
1749                         },
1750                 },
1751         .chan_table_elements = 3,
1752         .info = &tsl2X7X_device_info[ALS],
1753         },
1754         [PRX] = {
1755                 .channel = {
1756                         {
1757                         .type = IIO_PROXIMITY,
1758                         .indexed = 1,
1759                         .channel = 0,
1760                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1761                         .event_mask = TSL2X7X_EVENT_MASK
1762                         },
1763                 },
1764         .chan_table_elements = 1,
1765         .info = &tsl2X7X_device_info[PRX],
1766         },
1767         [ALSPRX] = {
1768                 .channel = {
1769                         {
1770                         .type = IIO_LIGHT,
1771                         .indexed = 1,
1772                         .channel = 0,
1773                         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED)
1774                         }, {
1775                         .type = IIO_INTENSITY,
1776                         .indexed = 1,
1777                         .channel = 0,
1778                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1779                                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1780                                 BIT(IIO_CHAN_INFO_CALIBBIAS),
1781                         .event_mask = TSL2X7X_EVENT_MASK
1782                         }, {
1783                         .type = IIO_INTENSITY,
1784                         .indexed = 1,
1785                         .channel = 1,
1786                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1787                         }, {
1788                         .type = IIO_PROXIMITY,
1789                         .indexed = 1,
1790                         .channel = 0,
1791                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1792                         .event_mask = TSL2X7X_EVENT_MASK
1793                         },
1794                 },
1795         .chan_table_elements = 4,
1796         .info = &tsl2X7X_device_info[ALSPRX],
1797         },
1798         [PRX2] = {
1799                 .channel = {
1800                         {
1801                         .type = IIO_PROXIMITY,
1802                         .indexed = 1,
1803                         .channel = 0,
1804                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1805                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1806                         .event_mask = TSL2X7X_EVENT_MASK
1807                         },
1808                 },
1809         .chan_table_elements = 1,
1810         .info = &tsl2X7X_device_info[PRX2],
1811         },
1812         [ALSPRX2] = {
1813                 .channel = {
1814                         {
1815                         .type = IIO_LIGHT,
1816                         .indexed = 1,
1817                         .channel = 0,
1818                         .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
1819                         }, {
1820                         .type = IIO_INTENSITY,
1821                         .indexed = 1,
1822                         .channel = 0,
1823                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1824                                 BIT(IIO_CHAN_INFO_CALIBSCALE) |
1825                                 BIT(IIO_CHAN_INFO_CALIBBIAS),
1826                         .event_mask = TSL2X7X_EVENT_MASK
1827                         }, {
1828                         .type = IIO_INTENSITY,
1829                         .indexed = 1,
1830                         .channel = 1,
1831                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1832                         }, {
1833                         .type = IIO_PROXIMITY,
1834                         .indexed = 1,
1835                         .channel = 0,
1836                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1837                                 BIT(IIO_CHAN_INFO_CALIBSCALE),
1838                         .event_mask = TSL2X7X_EVENT_MASK
1839                         },
1840                 },
1841         .chan_table_elements = 4,
1842         .info = &tsl2X7X_device_info[ALSPRX2],
1843         },
1844 };
1845
1846 static int tsl2x7x_probe(struct i2c_client *clientp,
1847         const struct i2c_device_id *id)
1848 {
1849         int ret;
1850         unsigned char device_id;
1851         struct iio_dev *indio_dev;
1852         struct tsl2X7X_chip *chip;
1853
1854         indio_dev = iio_device_alloc(sizeof(*chip));
1855         if (!indio_dev)
1856                 return -ENOMEM;
1857
1858         chip = iio_priv(indio_dev);
1859         chip->client = clientp;
1860         i2c_set_clientdata(clientp, indio_dev);
1861
1862         ret = tsl2x7x_i2c_read(chip->client,
1863                 TSL2X7X_CHIPID, &device_id);
1864         if (ret < 0)
1865                 goto fail1;
1866
1867         if ((!tsl2x7x_device_id(&device_id, id->driver_data)) ||
1868                 (tsl2x7x_device_id(&device_id, id->driver_data) == -EINVAL)) {
1869                 dev_info(&chip->client->dev,
1870                                 "%s: i2c device found does not match expected id\n",
1871                                 __func__);
1872                 ret = -EINVAL;
1873                 goto fail1;
1874         }
1875
1876         ret = i2c_smbus_write_byte(clientp, (TSL2X7X_CMD_REG | TSL2X7X_CNTRL));
1877         if (ret < 0) {
1878                 dev_err(&clientp->dev, "%s: write to cmd reg failed. err = %d\n",
1879                                 __func__, ret);
1880                 goto fail1;
1881         }
1882
1883         /* ALS and PROX functions can be invoked via user space poll
1884          * or H/W interrupt. If busy return last sample. */
1885         mutex_init(&chip->als_mutex);
1886         mutex_init(&chip->prox_mutex);
1887
1888         chip->tsl2x7x_chip_status = TSL2X7X_CHIP_UNKNOWN;
1889         chip->pdata = clientp->dev.platform_data;
1890         chip->id = id->driver_data;
1891         chip->chip_info =
1892                 &tsl2x7x_chip_info_tbl[device_channel_config[id->driver_data]];
1893
1894         indio_dev->info = chip->chip_info->info;
1895         indio_dev->dev.parent = &clientp->dev;
1896         indio_dev->modes = INDIO_DIRECT_MODE;
1897         indio_dev->name = chip->client->name;
1898         indio_dev->channels = chip->chip_info->channel;
1899         indio_dev->num_channels = chip->chip_info->chan_table_elements;
1900
1901         if (clientp->irq) {
1902                 ret = request_threaded_irq(clientp->irq,
1903                                            NULL,
1904                                            &tsl2x7x_event_handler,
1905                                            IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1906                                            "TSL2X7X_event",
1907                                            indio_dev);
1908                 if (ret) {
1909                         dev_err(&clientp->dev,
1910                                 "%s: irq request failed", __func__);
1911                         goto fail1;
1912                 }
1913         }
1914
1915         /* Load up the defaults */
1916         tsl2x7x_defaults(chip);
1917         /* Make sure the chip is on */
1918         tsl2x7x_chip_on(indio_dev);
1919
1920         ret = iio_device_register(indio_dev);
1921         if (ret) {
1922                 dev_err(&clientp->dev,
1923                         "%s: iio registration failed\n", __func__);
1924                 goto fail2;
1925         }
1926
1927         dev_info(&clientp->dev, "%s Light sensor found.\n", id->name);
1928
1929         return 0;
1930
1931 fail2:
1932         if (clientp->irq)
1933                 free_irq(clientp->irq, indio_dev);
1934 fail1:
1935         iio_device_free(indio_dev);
1936
1937         return ret;
1938 }
1939
1940 static int tsl2x7x_suspend(struct device *dev)
1941 {
1942         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1943         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1944         int ret = 0;
1945
1946         if (chip->tsl2x7x_chip_status == TSL2X7X_CHIP_WORKING) {
1947                 ret = tsl2x7x_chip_off(indio_dev);
1948                 chip->tsl2x7x_chip_status = TSL2X7X_CHIP_SUSPENDED;
1949         }
1950
1951         if (chip->pdata && chip->pdata->platform_power) {
1952                 pm_message_t pmm = {PM_EVENT_SUSPEND};
1953                 chip->pdata->platform_power(dev, pmm);
1954         }
1955
1956         return ret;
1957 }
1958
1959 static int tsl2x7x_resume(struct device *dev)
1960 {
1961         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1962         struct tsl2X7X_chip *chip = iio_priv(indio_dev);
1963         int ret = 0;
1964
1965         if (chip->pdata && chip->pdata->platform_power) {
1966                 pm_message_t pmm = {PM_EVENT_RESUME};
1967                 chip->pdata->platform_power(dev, pmm);
1968         }
1969
1970         if (chip->tsl2x7x_chip_status == TSL2X7X_CHIP_SUSPENDED)
1971                 ret = tsl2x7x_chip_on(indio_dev);
1972
1973         return ret;
1974 }
1975
1976 static int tsl2x7x_remove(struct i2c_client *client)
1977 {
1978         struct iio_dev *indio_dev = i2c_get_clientdata(client);
1979
1980         tsl2x7x_chip_off(indio_dev);
1981
1982         iio_device_unregister(indio_dev);
1983         if (client->irq)
1984                 free_irq(client->irq, indio_dev);
1985
1986         iio_device_free(indio_dev);
1987
1988         return 0;
1989 }
1990
1991 static struct i2c_device_id tsl2x7x_idtable[] = {
1992         { "tsl2571", tsl2571 },
1993         { "tsl2671", tsl2671 },
1994         { "tmd2671", tmd2671 },
1995         { "tsl2771", tsl2771 },
1996         { "tmd2771", tmd2771 },
1997         { "tsl2572", tsl2572 },
1998         { "tsl2672", tsl2672 },
1999         { "tmd2672", tmd2672 },
2000         { "tsl2772", tsl2772 },
2001         { "tmd2772", tmd2772 },
2002         {}
2003 };
2004
2005 MODULE_DEVICE_TABLE(i2c, tsl2x7x_idtable);
2006
2007 static const struct dev_pm_ops tsl2x7x_pm_ops = {
2008         .suspend = tsl2x7x_suspend,
2009         .resume  = tsl2x7x_resume,
2010 };
2011
2012 /* Driver definition */
2013 static struct i2c_driver tsl2x7x_driver = {
2014         .driver = {
2015                 .name = "tsl2x7x",
2016                 .pm = &tsl2x7x_pm_ops,
2017         },
2018         .id_table = tsl2x7x_idtable,
2019         .probe = tsl2x7x_probe,
2020         .remove = tsl2x7x_remove,
2021 };
2022
2023 module_i2c_driver(tsl2x7x_driver);
2024
2025 MODULE_AUTHOR("J. August Brenner<jbrenner@taosinc.com>");
2026 MODULE_DESCRIPTION("TAOS tsl2x7x ambient and proximity light sensor driver");
2027 MODULE_LICENSE("GPL");