drivers/staging/iio/light/tsl2583.c

   1 /*
   2  * Device driver for monitoring ambient light intensity (lux)
   3  * within the TAOS tsl258x family of devices (tsl2580, tsl2581).
   4  *
   5  * Copyright (c) 2011, 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/string.h>
  27 #include <linux/mutex.h>
  28 #include <linux/unistd.h>
  29 #include <linux/slab.h>
  30 #include <linux/module.h>
  31 #include <linux/iio/iio.h>
  32
  33 #define TSL258X_MAX_DEVICE_REGS         32
  34
  35 /* Triton register offsets */
  36 #define TSL258X_REG_MAX         8
  37
  38 /* Device Registers and Masks */
  39 #define TSL258X_CNTRL                   0x00
  40 #define TSL258X_ALS_TIME                0X01
  41 #define TSL258X_INTERRUPT               0x02
  42 #define TSL258X_GAIN                    0x07
  43 #define TSL258X_REVID                   0x11
  44 #define TSL258X_CHIPID                  0x12
  45 #define TSL258X_ALS_CHAN0LO             0x14
  46 #define TSL258X_ALS_CHAN0HI             0x15
  47 #define TSL258X_ALS_CHAN1LO             0x16
  48 #define TSL258X_ALS_CHAN1HI             0x17
  49 #define TSL258X_TMR_LO                  0x18
  50 #define TSL258X_TMR_HI                  0x19
  51
  52 /* tsl2583 cmd reg masks */
  53 #define TSL258X_CMD_REG                 0x80
  54 #define TSL258X_CMD_SPL_FN              0x60
  55 #define TSL258X_CMD_ALS_INT_CLR 0X01
  56
  57 /* tsl2583 cntrl reg masks */
  58 #define TSL258X_CNTL_ADC_ENBL   0x02
  59 #define TSL258X_CNTL_PWR_ON             0x01
  60
  61 /* tsl2583 status reg masks */
  62 #define TSL258X_STA_ADC_VALID   0x01
  63 #define TSL258X_STA_ADC_INTR    0x10
  64
  65 /* Lux calculation constants */
  66 #define TSL258X_LUX_CALC_OVER_FLOW              65535
  67
  68 enum {
  69         TSL258X_CHIP_UNKNOWN = 0,
  70         TSL258X_CHIP_WORKING = 1,
  71         TSL258X_CHIP_SUSPENDED = 2
  72 };
  73
  74 /* Per-device data */
  75 struct taos_als_info {
  76         u16 als_ch0;
  77         u16 als_ch1;
  78         u16 lux;
  79 };
  80
  81 struct taos_settings {
  82         int als_time;
  83         int als_gain;
  84         int als_gain_trim;
  85         int als_cal_target;
  86 };
  87
  88 struct tsl2583_chip {
  89         struct mutex als_mutex;
  90         struct i2c_client *client;
  91         struct taos_als_info als_cur_info;
  92         struct taos_settings taos_settings;
  93         int als_time_scale;
  94         int als_saturation;
  95         int taos_chip_status;
  96         u8 taos_config[8];
  97 };
  98
  99 /*
 100  * Initial values for device - this values can/will be changed by driver.
 101  * and applications as needed.
 102  * These values are dynamic.
 103  */
 104 static const u8 taos_config[8] = {
 105                 0x00, 0xee, 0x00, 0x03, 0x00, 0xFF, 0xFF, 0x00
 106 }; /*   cntrl atime intC  Athl0 Athl1 Athh0 Athh1 gain */
 107
 108 struct taos_lux {
 109         unsigned int ratio;
 110         unsigned int ch0;
 111         unsigned int ch1;
 112 };
 113
 114 /* This structure is intentionally large to accommodate updates via sysfs. */
 115 /* Sized to 11 = max 10 segments + 1 termination segment */
 116 /* Assumption is one and only one type of glass used  */
 117 static struct taos_lux taos_device_lux[11] = {
 118         {  9830,  8520, 15729 },
 119         { 12452, 10807, 23344 },
 120         { 14746,  6383, 11705 },
 121         { 17695,  4063,  6554 },
 122 };
 123
 124 struct gainadj {
 125         s16 ch0;
 126         s16 ch1;
 127 };
 128
 129 /* Index = (0 - 3) Used to validate the gain selection index */
 130 static const struct gainadj gainadj[] = {
 131         { 1, 1 },
 132         { 8, 8 },
 133         { 16, 16 },
 134         { 107, 115 }
 135 };
 136
 137 /*
 138  * Provides initial operational parameter defaults.
 139  * These defaults may be changed through the device's sysfs files.
 140  */
 141 static void taos_defaults(struct tsl2583_chip *chip)
 142 {
 143         /* Operational parameters */
 144         chip->taos_settings.als_time = 100;
 145         /* must be a multiple of 50mS */
 146         chip->taos_settings.als_gain = 0;
 147         /* this is actually an index into the gain table */
 148         /* assume clear glass as default */
 149         chip->taos_settings.als_gain_trim = 1000;
 150         /* default gain trim to account for aperture effects */
 151         chip->taos_settings.als_cal_target = 130;
 152         /* Known external ALS reading used for calibration */
 153 }
 154
 155 /*
 156  * Read a number of bytes starting at register (reg) location.
 157  * Return 0, or i2c_smbus_write_byte ERROR code.
 158  */
 159 static int
 160 taos_i2c_read(struct i2c_client *client, u8 reg, u8 *val, unsigned int len)
 161 {
 162         int i, ret;
 163
 164         for (i = 0; i < len; i++) {
 165                 /* select register to write */
 166                 ret = i2c_smbus_write_byte(client, (TSL258X_CMD_REG | reg));
 167                 if (ret < 0) {
 168                         dev_err(&client->dev,
 169                                 "taos_i2c_read failed to write register %x\n",
 170                                 reg);
 171                         return ret;
 172                 }
 173                 /* read the data */
 174                 *val = i2c_smbus_read_byte(client);
 175                 val++;
 176                 reg++;
 177         }
 178         return 0;
 179 }
 180
 181 /*
 182  * Reads and calculates current lux value.
 183  * The raw ch0 and ch1 values of the ambient light sensed in the last
 184  * integration cycle are read from the device.
 185  * Time scale factor array values are adjusted based on the integration time.
 186  * The raw values are multiplied by a scale factor, and device gain is obtained
 187  * using gain index. Limit checks are done next, then the ratio of a multiple
 188  * of ch1 value, to the ch0 value, is calculated. The array taos_device_lux[]
 189  * declared above is then scanned to find the first ratio value that is just
 190  * above the ratio we just calculated. The ch0 and ch1 multiplier constants in
 191  * the array are then used along with the time scale factor array values, to
 192  * calculate the lux.
 193  */
 194 static int taos_get_lux(struct iio_dev *indio_dev)
 195 {
 196         u16 ch0, ch1; /* separated ch0/ch1 data from device */
 197         u32 lux; /* raw lux calculated from device data */
 198         u64 lux64;
 199         u32 ratio;
 200         u8 buf[5];
 201         struct taos_lux *p;
 202         struct tsl2583_chip *chip = iio_priv(indio_dev);
 203         int i, ret;
 204         u32 ch0lux = 0;
 205         u32 ch1lux = 0;
 206
 207         if (mutex_trylock(&chip->als_mutex) == 0) {
 208                 dev_info(&chip->client->dev, "taos_get_lux device is busy\n");
 209                 return chip->als_cur_info.lux; /* busy, so return LAST VALUE */
 210         }
 211
 212         if (chip->taos_chip_status != TSL258X_CHIP_WORKING) {
 213                 /* device is not enabled */
 214                 dev_err(&chip->client->dev, "taos_get_lux device is not enabled\n");
 215                 ret = -EBUSY;
 216                 goto out_unlock;
 217         }
 218
 219         ret = taos_i2c_read(chip->client, (TSL258X_CMD_REG), &buf[0], 1);
 220         if (ret < 0) {
 221                 dev_err(&chip->client->dev, "taos_get_lux failed to read CMD_REG\n");
 222                 goto out_unlock;
 223         }
 224         /* is data new & valid */
 225         if (!(buf[0] & TSL258X_STA_ADC_INTR)) {
 226                 dev_err(&chip->client->dev, "taos_get_lux data not valid\n");
 227                 ret = chip->als_cur_info.lux; /* return LAST VALUE */
 228                 goto out_unlock;
 229         }
 230
 231         for (i = 0; i < 4; i++) {
 232                 int reg = TSL258X_CMD_REG | (TSL258X_ALS_CHAN0LO + i);
 233                 ret = taos_i2c_read(chip->client, reg, &buf[i], 1);
 234                 if (ret < 0) {
 235                         dev_err(&chip->client->dev,
 236                                 "taos_get_lux failed to read register %x\n",
 237                                 reg);
 238                         goto out_unlock;
 239                 }
 240         }
 241
 242         /* clear status, really interrupt status (interrupts are off), but
 243          * we use the bit anyway - don't forget 0x80 - this is a command*/
 244         ret = i2c_smbus_write_byte(chip->client,
 245                                    (TSL258X_CMD_REG | TSL258X_CMD_SPL_FN |
 246                                     TSL258X_CMD_ALS_INT_CLR));
 247
 248         if (ret < 0) {
 249                 dev_err(&chip->client->dev,
 250                         "taos_i2c_write_command failed in taos_get_lux, err = %d\n",
 251                         ret);
 252                 goto out_unlock; /* have no data, so return failure */
 253         }
 254
 255         /* extract ALS/lux data */
 256         ch0 = le16_to_cpup((const __le16 *)&buf[0]);
 257         ch1 = le16_to_cpup((const __le16 *)&buf[2]);
 258
 259         chip->als_cur_info.als_ch0 = ch0;
 260         chip->als_cur_info.als_ch1 = ch1;
 261
 262         if ((ch0 >= chip->als_saturation) || (ch1 >= chip->als_saturation))
 263                 goto return_max;
 264
 265         if (ch0 == 0) {
 266                 /* have no data, so return LAST VALUE */
 267                 ret = chip->als_cur_info.lux = 0;
 268                 goto out_unlock;
 269         }
 270         /* calculate ratio */
 271         ratio = (ch1 << 15) / ch0;
 272         /* convert to unscaled lux using the pointer to the table */
 273         for (p = (struct taos_lux *) taos_device_lux;
 274              p->ratio != 0 && p->ratio < ratio; p++)
 275                 ;
 276
 277         if (p->ratio == 0) {
 278                 lux = 0;
 279         } else {
 280                 ch0lux = ((ch0 * p->ch0) +
 281                           (gainadj[chip->taos_settings.als_gain].ch0 >> 1))
 282                          / gainadj[chip->taos_settings.als_gain].ch0;
 283                 ch1lux = ((ch1 * p->ch1) +
 284                           (gainadj[chip->taos_settings.als_gain].ch1 >> 1))
 285                          / gainadj[chip->taos_settings.als_gain].ch1;
 286                 lux = ch0lux - ch1lux;
 287         }
 288
 289         /* note: lux is 31 bit max at this point */
 290         if (ch1lux > ch0lux) {
 291                 dev_dbg(&chip->client->dev, "No Data - Return last value\n");
 292                 ret = chip->als_cur_info.lux = 0;
 293                 goto out_unlock;
 294         }
 295
 296         /* adjust for active time scale */
 297         if (chip->als_time_scale == 0)
 298                 lux = 0;
 299         else
 300                 lux = (lux + (chip->als_time_scale >> 1)) /
 301                         chip->als_time_scale;
 302
 303         /* Adjust for active gain scale.
 304          * The taos_device_lux tables above have a factor of 8192 built in,
 305          * so we need to shift right.
 306          * User-specified gain provides a multiplier.
 307          * Apply user-specified gain before shifting right to retain precision.
 308          * Use 64 bits to avoid overflow on multiplication.
 309          * Then go back to 32 bits before division to avoid using div_u64().
 310          */
 311         lux64 = lux;
 312         lux64 = lux64 * chip->taos_settings.als_gain_trim;
 313         lux64 >>= 13;
 314         lux = lux64;
 315         lux = (lux + 500) / 1000;
 316         if (lux > TSL258X_LUX_CALC_OVER_FLOW) { /* check for overflow */
 317 return_max:
 318                 lux = TSL258X_LUX_CALC_OVER_FLOW;
 319         }
 320
 321         /* Update the structure with the latest VALID lux. */
 322         chip->als_cur_info.lux = lux;
 323         ret = lux;
 324
 325 out_unlock:
 326         mutex_unlock(&chip->als_mutex);
 327         return ret;
 328 }
 329
 330 /*
 331  * Obtain single reading and calculate the als_gain_trim (later used
 332  * to derive actual lux).
 333  * Return updated gain_trim value.
 334  */
 335 static int taos_als_calibrate(struct iio_dev *indio_dev)
 336 {
 337         struct tsl2583_chip *chip = iio_priv(indio_dev);
 338         u8 reg_val;
 339         unsigned int gain_trim_val;
 340         int ret;
 341         int lux_val;
 342
 343         ret = i2c_smbus_write_byte(chip->client,
 344                                    (TSL258X_CMD_REG | TSL258X_CNTRL));
 345         if (ret < 0) {
 346                 dev_err(&chip->client->dev,
 347                         "taos_als_calibrate failed to reach the CNTRL register, ret=%d\n",
 348                         ret);
 349                 return ret;
 350         }
 351
 352         reg_val = i2c_smbus_read_byte(chip->client);
 353         if ((reg_val & (TSL258X_CNTL_ADC_ENBL | TSL258X_CNTL_PWR_ON))
 354                         != (TSL258X_CNTL_ADC_ENBL | TSL258X_CNTL_PWR_ON)) {
 355                 dev_err(&chip->client->dev,
 356                         "taos_als_calibrate failed: device not powered on with ADC enabled\n");
 357                 return -1;
 358         }
 359
 360         ret = i2c_smbus_write_byte(chip->client,
 361                                    (TSL258X_CMD_REG | TSL258X_CNTRL));
 362         if (ret < 0) {
 363                 dev_err(&chip->client->dev,
 364                         "taos_als_calibrate failed to reach the STATUS register, ret=%d\n",
 365                         ret);
 366                 return ret;
 367         }
 368         reg_val = i2c_smbus_read_byte(chip->client);
 369
 370         if ((reg_val & TSL258X_STA_ADC_VALID) != TSL258X_STA_ADC_VALID) {
 371                 dev_err(&chip->client->dev,
 372                         "taos_als_calibrate failed: STATUS - ADC not valid.\n");
 373                 return -ENODATA;
 374         }
 375         lux_val = taos_get_lux(indio_dev);
 376         if (lux_val < 0) {
 377                 dev_err(&chip->client->dev, "taos_als_calibrate failed to get lux\n");
 378                 return lux_val;
 379         }
 380         gain_trim_val = (unsigned int) (((chip->taos_settings.als_cal_target)
 381                         * chip->taos_settings.als_gain_trim) / lux_val);
 382
 383         if ((gain_trim_val < 250) || (gain_trim_val > 4000)) {
 384                 dev_err(&chip->client->dev,
 385                         "taos_als_calibrate failed: trim_val of %d is out of range\n",
 386                         gain_trim_val);
 387                 return -ENODATA;
 388         }
 389         chip->taos_settings.als_gain_trim = (int) gain_trim_val;
 390
 391         return (int) gain_trim_val;
 392 }
 393
 394 /*
 395  * Turn the device on.
 396  * Configuration must be set before calling this function.
 397  */
 398 static int taos_chip_on(struct iio_dev *indio_dev)
 399 {
 400         int i;
 401         int ret;
 402         u8 *uP;
 403         u8 utmp;
 404         int als_count;
 405         int als_time;
 406         struct tsl2583_chip *chip = iio_priv(indio_dev);
 407
 408         /* and make sure we're not already on */
 409         if (chip->taos_chip_status == TSL258X_CHIP_WORKING) {
 410                 /* if forcing a register update - turn off, then on */
 411                 dev_info(&chip->client->dev, "device is already enabled\n");
 412                 return -EINVAL;
 413         }
 414
 415         /* determine als integration register */
 416         als_count = (chip->taos_settings.als_time * 100 + 135) / 270;
 417         if (als_count == 0)
 418                 als_count = 1; /* ensure at least one cycle */
 419
 420         /* convert back to time (encompasses overrides) */
 421         als_time = (als_count * 27 + 5) / 10;
 422         chip->taos_config[TSL258X_ALS_TIME] = 256 - als_count;
 423
 424         /* Set the gain based on taos_settings struct */
 425         chip->taos_config[TSL258X_GAIN] = chip->taos_settings.als_gain;
 426
 427         /* set chip struct re scaling and saturation */
 428         chip->als_saturation = als_count * 922; /* 90% of full scale */
 429         chip->als_time_scale = (als_time + 25) / 50;
 430
 431         /* TSL258x Specific power-on / adc enable sequence
 432          * Power on the device 1st. */
 433         utmp = TSL258X_CNTL_PWR_ON;
 434         ret = i2c_smbus_write_byte_data(chip->client,
 435                                         TSL258X_CMD_REG | TSL258X_CNTRL, utmp);
 436         if (ret < 0) {
 437                 dev_err(&chip->client->dev, "taos_chip_on failed on CNTRL reg.\n");
 438                 return ret;
 439         }
 440
 441         /* Use the following shadow copy for our delay before enabling ADC.
 442          * Write all the registers. */
 443         for (i = 0, uP = chip->taos_config; i < TSL258X_REG_MAX; i++) {
 444                 ret = i2c_smbus_write_byte_data(chip->client,
 445                                                 TSL258X_CMD_REG + i,
 446                                                 *uP++);
 447                 if (ret < 0) {
 448                         dev_err(&chip->client->dev,
 449                                 "taos_chip_on failed on reg %d.\n", i);
 450                         return ret;
 451                 }
 452         }
 453
 454         usleep_range(3000, 3500);
 455         /* NOW enable the ADC
 456          * initialize the desired mode of operation */
 457         utmp = TSL258X_CNTL_PWR_ON | TSL258X_CNTL_ADC_ENBL;
 458         ret = i2c_smbus_write_byte_data(chip->client,
 459                                         TSL258X_CMD_REG | TSL258X_CNTRL,
 460                                         utmp);
 461         if (ret < 0) {
 462                 dev_err(&chip->client->dev, "taos_chip_on failed on 2nd CTRL reg.\n");
 463                 return ret;
 464         }
 465         chip->taos_chip_status = TSL258X_CHIP_WORKING;
 466
 467         return ret;
 468 }
 469
 470 static int taos_chip_off(struct iio_dev *indio_dev)
 471 {
 472         struct tsl2583_chip *chip = iio_priv(indio_dev);
 473         int ret;
 474
 475         /* turn device off */
 476         chip->taos_chip_status = TSL258X_CHIP_SUSPENDED;
 477         ret = i2c_smbus_write_byte_data(chip->client,
 478                                         TSL258X_CMD_REG | TSL258X_CNTRL,
 479                                         0x00);
 480         return ret;
 481 }
 482
 483 /* Sysfs Interface Functions */
 484
 485 static ssize_t taos_power_state_show(struct device *dev,
 486         struct device_attribute *attr, char *buf)
 487 {
 488         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 489         struct tsl2583_chip *chip = iio_priv(indio_dev);
 490
 491         return sprintf(buf, "%d\n", chip->taos_chip_status);
 492 }
 493
 494 static ssize_t taos_power_state_store(struct device *dev,
 495         struct device_attribute *attr, const char *buf, size_t len)
 496 {
 497         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 498         int value;
 499
 500         if (kstrtoint(buf, 0, &value))
 501                 return -EINVAL;
 502
 503         if (value == 0)
 504                 taos_chip_off(indio_dev);
 505         else
 506                 taos_chip_on(indio_dev);
 507
 508         return len;
 509 }
 510
 511 static ssize_t taos_gain_show(struct device *dev,
 512         struct device_attribute *attr, char *buf)
 513 {
 514         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 515         struct tsl2583_chip *chip = iio_priv(indio_dev);
 516         char gain[4] = {0};
 517
 518         switch (chip->taos_settings.als_gain) {
 519         case 0:
 520                 strcpy(gain, "001");
 521                 break;
 522         case 1:
 523                 strcpy(gain, "008");
 524                 break;
 525         case 2:
 526                 strcpy(gain, "016");
 527                 break;
 528         case 3:
 529                 strcpy(gain, "111");
 530                 break;
 531         }
 532
 533         return sprintf(buf, "%s\n", gain);
 534 }
 535
 536 static ssize_t taos_gain_store(struct device *dev,
 537         struct device_attribute *attr, const char *buf, size_t len)
 538 {
 539         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 540         struct tsl2583_chip *chip = iio_priv(indio_dev);
 541         int value;
 542
 543         if (kstrtoint(buf, 0, &value))
 544                 return -EINVAL;
 545
 546         switch (value) {
 547         case 1:
 548                 chip->taos_settings.als_gain = 0;
 549                 break;
 550         case 8:
 551                 chip->taos_settings.als_gain = 1;
 552                 break;
 553         case 16:
 554                 chip->taos_settings.als_gain = 2;
 555                 break;
 556         case 111:
 557                 chip->taos_settings.als_gain = 3;
 558                 break;
 559         default:
 560                 dev_err(dev, "Invalid Gain Index (must be 1,8,16,111)\n");
 561                 return -1;
 562         }
 563
 564         return len;
 565 }
 566
 567 static ssize_t taos_gain_available_show(struct device *dev,
 568         struct device_attribute *attr, char *buf)
 569 {
 570         return sprintf(buf, "%s\n", "1 8 16 111");
 571 }
 572
 573 static ssize_t taos_als_time_show(struct device *dev,
 574         struct device_attribute *attr, char *buf)
 575 {
 576         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 577         struct tsl2583_chip *chip = iio_priv(indio_dev);
 578
 579         return sprintf(buf, "%d\n", chip->taos_settings.als_time);
 580 }
 581
 582 static ssize_t taos_als_time_store(struct device *dev,
 583         struct device_attribute *attr, const char *buf, size_t len)
 584 {
 585         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 586         struct tsl2583_chip *chip = iio_priv(indio_dev);
 587         int value;
 588
 589         if (kstrtoint(buf, 0, &value))
 590                 return -EINVAL;
 591
 592         if ((value < 50) || (value > 650))
 593                 return -EINVAL;
 594
 595         if (value % 50)
 596                 return -EINVAL;
 597
 598         chip->taos_settings.als_time = value;
 599
 600         return len;
 601 }
 602
 603 static ssize_t taos_als_time_available_show(struct device *dev,
 604         struct device_attribute *attr, char *buf)
 605 {
 606         return sprintf(buf, "%s\n",
 607                 "50 100 150 200 250 300 350 400 450 500 550 600 650");
 608 }
 609
 610 static ssize_t taos_als_trim_show(struct device *dev,
 611         struct device_attribute *attr, char *buf)
 612 {
 613         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 614         struct tsl2583_chip *chip = iio_priv(indio_dev);
 615
 616         return sprintf(buf, "%d\n", chip->taos_settings.als_gain_trim);
 617 }
 618
 619 static ssize_t taos_als_trim_store(struct device *dev,
 620         struct device_attribute *attr, const char *buf, size_t len)
 621 {
 622         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 623         struct tsl2583_chip *chip = iio_priv(indio_dev);
 624         int value;
 625
 626         if (kstrtoint(buf, 0, &value))
 627                 return -EINVAL;
 628
 629         if (value)
 630                 chip->taos_settings.als_gain_trim = value;
 631
 632         return len;
 633 }
 634
 635 static ssize_t taos_als_cal_target_show(struct device *dev,
 636         struct device_attribute *attr, char *buf)
 637 {
 638         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 639         struct tsl2583_chip *chip = iio_priv(indio_dev);
 640
 641         return sprintf(buf, "%d\n", chip->taos_settings.als_cal_target);
 642 }
 643
 644 static ssize_t taos_als_cal_target_store(struct device *dev,
 645         struct device_attribute *attr, const char *buf, size_t len)
 646 {
 647         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 648         struct tsl2583_chip *chip = iio_priv(indio_dev);
 649         int value;
 650
 651         if (kstrtoint(buf, 0, &value))
 652                 return -EINVAL;
 653
 654         if (value)
 655                 chip->taos_settings.als_cal_target = value;
 656
 657         return len;
 658 }
 659
 660 static ssize_t taos_lux_show(struct device *dev, struct device_attribute *attr,
 661         char *buf)
 662 {
 663         int ret;
 664
 665         ret = taos_get_lux(dev_to_iio_dev(dev));
 666         if (ret < 0)
 667                 return ret;
 668
 669         return sprintf(buf, "%d\n", ret);
 670 }
 671
 672 static ssize_t taos_do_calibrate(struct device *dev,
 673         struct device_attribute *attr, const char *buf, size_t len)
 674 {
 675         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 676         int value;
 677
 678         if (kstrtoint(buf, 0, &value))
 679                 return -EINVAL;
 680
 681         if (value == 1)
 682                 taos_als_calibrate(indio_dev);
 683
 684         return len;
 685 }
 686
 687 static ssize_t taos_luxtable_show(struct device *dev,
 688         struct device_attribute *attr, char *buf)
 689 {
 690         int i;
 691         int offset = 0;
 692
 693         for (i = 0; i < ARRAY_SIZE(taos_device_lux); i++) {
 694                 offset += sprintf(buf + offset, "%d,%d,%d,",
 695                                   taos_device_lux[i].ratio,
 696                                   taos_device_lux[i].ch0,
 697                                   taos_device_lux[i].ch1);
 698                 if (taos_device_lux[i].ratio == 0) {
 699                         /* We just printed the first "0" entry.
 700                          * Now get rid of the extra "," and break. */
 701                         offset--;
 702                         break;
 703                 }
 704         }
 705
 706         offset += sprintf(buf + offset, "\n");
 707         return offset;
 708 }
 709
 710 static ssize_t taos_luxtable_store(struct device *dev,
 711         struct device_attribute *attr, const char *buf, size_t len)
 712 {
 713         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 714         struct tsl2583_chip *chip = iio_priv(indio_dev);
 715         int value[ARRAY_SIZE(taos_device_lux)*3 + 1];
 716         int n;
 717
 718         get_options(buf, ARRAY_SIZE(value), value);
 719
 720         /* We now have an array of ints starting at value[1], and
 721          * enumerated by value[0].
 722          * We expect each group of three ints is one table entry,
 723          * and the last table entry is all 0.
 724          */
 725         n = value[0];
 726         if ((n % 3) || n < 6 || n > ((ARRAY_SIZE(taos_device_lux) - 1) * 3)) {
 727                 dev_info(dev, "LUX TABLE INPUT ERROR 1 Value[0]=%d\n", n);
 728                 return -EINVAL;
 729         }
 730         if ((value[(n - 2)] | value[(n - 1)] | value[n]) != 0) {
 731                 dev_info(dev, "LUX TABLE INPUT ERROR 2 Value[0]=%d\n", n);
 732                 return -EINVAL;
 733         }
 734
 735         if (chip->taos_chip_status == TSL258X_CHIP_WORKING)
 736                 taos_chip_off(indio_dev);
 737
 738         /* Zero out the table */
 739         memset(taos_device_lux, 0, sizeof(taos_device_lux));
 740         memcpy(taos_device_lux, &value[1], (value[0] * 4));
 741
 742         taos_chip_on(indio_dev);
 743
 744         return len;
 745 }
 746
 747 static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR,
 748                 taos_power_state_show, taos_power_state_store);
 749
 750 static DEVICE_ATTR(illuminance0_calibscale, S_IRUGO | S_IWUSR,
 751                 taos_gain_show, taos_gain_store);
 752 static DEVICE_ATTR(illuminance0_calibscale_available, S_IRUGO,
 753                 taos_gain_available_show, NULL);
 754
 755 static DEVICE_ATTR(illuminance0_integration_time, S_IRUGO | S_IWUSR,
 756                 taos_als_time_show, taos_als_time_store);
 757 static DEVICE_ATTR(illuminance0_integration_time_available, S_IRUGO,
 758                 taos_als_time_available_show, NULL);
 759
 760 static DEVICE_ATTR(illuminance0_calibbias, S_IRUGO | S_IWUSR,
 761                 taos_als_trim_show, taos_als_trim_store);
 762
 763 static DEVICE_ATTR(illuminance0_input_target, S_IRUGO | S_IWUSR,
 764                 taos_als_cal_target_show, taos_als_cal_target_store);
 765
 766 static DEVICE_ATTR(illuminance0_input, S_IRUGO, taos_lux_show, NULL);
 767 static DEVICE_ATTR(illuminance0_calibrate, S_IWUSR, NULL, taos_do_calibrate);
 768 static DEVICE_ATTR(illuminance0_lux_table, S_IRUGO | S_IWUSR,
 769                 taos_luxtable_show, taos_luxtable_store);
 770
 771 static struct attribute *sysfs_attrs_ctrl[] = {
 772         &dev_attr_power_state.attr,
 773         &dev_attr_illuminance0_calibscale.attr,                 /* Gain  */
 774         &dev_attr_illuminance0_calibscale_available.attr,
 775         &dev_attr_illuminance0_integration_time.attr,   /* I time*/
 776         &dev_attr_illuminance0_integration_time_available.attr,
 777         &dev_attr_illuminance0_calibbias.attr,                  /* trim  */
 778         &dev_attr_illuminance0_input_target.attr,
 779         &dev_attr_illuminance0_input.attr,
 780         &dev_attr_illuminance0_calibrate.attr,
 781         &dev_attr_illuminance0_lux_table.attr,
 782         NULL
 783 };
 784
 785 static struct attribute_group tsl2583_attribute_group = {
 786         .attrs = sysfs_attrs_ctrl,
 787 };
 788
 789 /* Use the default register values to identify the Taos device */
 790 static int taos_tsl258x_device(unsigned char *bufp)
 791 {
 792         return ((bufp[TSL258X_CHIPID] & 0xf0) == 0x90);
 793 }
 794
 795 static const struct iio_info tsl2583_info = {
 796         .attrs = &tsl2583_attribute_group,
 797         .driver_module = THIS_MODULE,
 798 };
 799
 800 /*
 801  * Client probe function - When a valid device is found, the driver's device
 802  * data structure is updated, and initialization completes successfully.
 803  */
 804 static int taos_probe(struct i2c_client *clientp,
 805                       const struct i2c_device_id *idp)
 806 {
 807         int i, ret;
 808         unsigned char buf[TSL258X_MAX_DEVICE_REGS];
 809         struct tsl2583_chip *chip;
 810         struct iio_dev *indio_dev;
 811
 812         if (!i2c_check_functionality(clientp->adapter,
 813                 I2C_FUNC_SMBUS_BYTE_DATA)) {
 814                 dev_err(&clientp->dev, "taos_probe() - i2c smbus byte data func unsupported\n");
 815                 return -EOPNOTSUPP;
 816         }
 817
 818         indio_dev = devm_iio_device_alloc(&clientp->dev, sizeof(*chip));
 819         if (!indio_dev)
 820                 return -ENOMEM;
 821         chip = iio_priv(indio_dev);
 822         chip->client = clientp;
 823         i2c_set_clientdata(clientp, indio_dev);
 824
 825         mutex_init(&chip->als_mutex);
 826         chip->taos_chip_status = TSL258X_CHIP_UNKNOWN;
 827         memcpy(chip->taos_config, taos_config, sizeof(chip->taos_config));
 828
 829         for (i = 0; i < TSL258X_MAX_DEVICE_REGS; i++) {
 830                 ret = i2c_smbus_write_byte(clientp,
 831                                 (TSL258X_CMD_REG | (TSL258X_CNTRL + i)));
 832                 if (ret < 0) {
 833                         dev_err(&clientp->dev,
 834                                 "i2c_smbus_write_byte to cmd reg failed in taos_probe(), err = %d\n",
 835                                 ret);
 836                         return ret;
 837                 }
 838                 ret = i2c_smbus_read_byte(clientp);
 839                 if (ret < 0) {
 840                         dev_err(&clientp->dev,
 841                                 "i2c_smbus_read_byte from reg failed in taos_probe(), err = %d\n",
 842                                 ret);
 843                         return ret;
 844                 }
 845                 buf[i] = ret;
 846         }
 847
 848         if (!taos_tsl258x_device(buf)) {
 849                 dev_info(&clientp->dev,
 850                         "i2c device found but does not match expected id in taos_probe()\n");
 851                 return -EINVAL;
 852         }
 853
 854         ret = i2c_smbus_write_byte(clientp, (TSL258X_CMD_REG | TSL258X_CNTRL));
 855         if (ret < 0) {
 856                 dev_err(&clientp->dev,
 857                         "i2c_smbus_write_byte() to cmd reg failed in taos_probe(), err = %d\n",
 858                         ret);
 859                 return ret;
 860         }
 861
 862         indio_dev->info = &tsl2583_info;
 863         indio_dev->dev.parent = &clientp->dev;
 864         indio_dev->modes = INDIO_DIRECT_MODE;
 865         indio_dev->name = chip->client->name;
 866         ret = iio_device_register(indio_dev);
 867         if (ret) {
 868                 dev_err(&clientp->dev, "iio registration failed\n");
 869                 return ret;
 870         }
 871
 872         /* Load up the V2 defaults (these are hard coded defaults for now) */
 873         taos_defaults(chip);
 874
 875         /* Make sure the chip is on */
 876         taos_chip_on(indio_dev);
 877
 878         dev_info(&clientp->dev, "Light sensor found.\n");
 879         return 0;
 880 }
 881
 882 #ifdef CONFIG_PM_SLEEP
 883 static int taos_suspend(struct device *dev)
 884 {
 885         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 886         struct tsl2583_chip *chip = iio_priv(indio_dev);
 887         int ret = 0;
 888
 889         mutex_lock(&chip->als_mutex);
 890
 891         if (chip->taos_chip_status == TSL258X_CHIP_WORKING) {
 892                 ret = taos_chip_off(indio_dev);
 893                 chip->taos_chip_status = TSL258X_CHIP_SUSPENDED;
 894         }
 895
 896         mutex_unlock(&chip->als_mutex);
 897         return ret;
 898 }
 899
 900 static int taos_resume(struct device *dev)
 901 {
 902         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 903         struct tsl2583_chip *chip = iio_priv(indio_dev);
 904         int ret = 0;
 905
 906         mutex_lock(&chip->als_mutex);
 907
 908         if (chip->taos_chip_status == TSL258X_CHIP_SUSPENDED)
 909                 ret = taos_chip_on(indio_dev);
 910
 911         mutex_unlock(&chip->als_mutex);
 912         return ret;
 913 }
 914
 915 static SIMPLE_DEV_PM_OPS(taos_pm_ops, taos_suspend, taos_resume);
 916 #define TAOS_PM_OPS (&taos_pm_ops)
 917 #else
 918 #define TAOS_PM_OPS NULL
 919 #endif
 920
 921 static int taos_remove(struct i2c_client *client)
 922 {
 923         iio_device_unregister(i2c_get_clientdata(client));
 924
 925         return 0;
 926 }
 927
 928 static struct i2c_device_id taos_idtable[] = {
 929         { "tsl2580", 0 },
 930         { "tsl2581", 1 },
 931         { "tsl2583", 2 },
 932         {}
 933 };
 934 MODULE_DEVICE_TABLE(i2c, taos_idtable);
 935
 936 /* Driver definition */
 937 static struct i2c_driver taos_driver = {
 938         .driver = {
 939                 .name = "tsl2583",
 940                 .pm = TAOS_PM_OPS,
 941         },
 942         .id_table = taos_idtable,
 943         .probe = taos_probe,
 944         .remove = taos_remove,
 945 };
 946 module_i2c_driver(taos_driver);
 947
 948 MODULE_AUTHOR("J. August Brenner<jbrenner@taosinc.com>");
 949 MODULE_DESCRIPTION("TAOS tsl2583 ambient light sensor driver");
 950 MODULE_LICENSE("GPL");