1284 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * This file is part of the APDS990x sensor driver.4 * Chip is combined proximity and ambient light sensor.5 *6 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).7 *8 * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>9 */10 11#include <linux/kernel.h>12#include <linux/module.h>13#include <linux/i2c.h>14#include <linux/interrupt.h>15#include <linux/mutex.h>16#include <linux/regulator/consumer.h>17#include <linux/pm_runtime.h>18#include <linux/delay.h>19#include <linux/wait.h>20#include <linux/slab.h>21#include <linux/platform_data/apds990x.h>22 23/* Register map */24#define APDS990X_ENABLE 0x00 /* Enable of states and interrupts */25#define APDS990X_ATIME 0x01 /* ALS ADC time */26#define APDS990X_PTIME 0x02 /* Proximity ADC time */27#define APDS990X_WTIME 0x03 /* Wait time */28#define APDS990X_AILTL 0x04 /* ALS interrupt low threshold low byte */29#define APDS990X_AILTH 0x05 /* ALS interrupt low threshold hi byte */30#define APDS990X_AIHTL 0x06 /* ALS interrupt hi threshold low byte */31#define APDS990X_AIHTH 0x07 /* ALS interrupt hi threshold hi byte */32#define APDS990X_PILTL 0x08 /* Proximity interrupt low threshold low byte */33#define APDS990X_PILTH 0x09 /* Proximity interrupt low threshold hi byte */34#define APDS990X_PIHTL 0x0a /* Proximity interrupt hi threshold low byte */35#define APDS990X_PIHTH 0x0b /* Proximity interrupt hi threshold hi byte */36#define APDS990X_PERS 0x0c /* Interrupt persistence filters */37#define APDS990X_CONFIG 0x0d /* Configuration */38#define APDS990X_PPCOUNT 0x0e /* Proximity pulse count */39#define APDS990X_CONTROL 0x0f /* Gain control register */40#define APDS990X_REV 0x11 /* Revision Number */41#define APDS990X_ID 0x12 /* Device ID */42#define APDS990X_STATUS 0x13 /* Device status */43#define APDS990X_CDATAL 0x14 /* Clear ADC low data register */44#define APDS990X_CDATAH 0x15 /* Clear ADC high data register */45#define APDS990X_IRDATAL 0x16 /* IR ADC low data register */46#define APDS990X_IRDATAH 0x17 /* IR ADC high data register */47#define APDS990X_PDATAL 0x18 /* Proximity ADC low data register */48#define APDS990X_PDATAH 0x19 /* Proximity ADC high data register */49 50/* Control */51#define APDS990X_MAX_AGAIN 352 53/* Enable register */54#define APDS990X_EN_PIEN (0x1 << 5)55#define APDS990X_EN_AIEN (0x1 << 4)56#define APDS990X_EN_WEN (0x1 << 3)57#define APDS990X_EN_PEN (0x1 << 2)58#define APDS990X_EN_AEN (0x1 << 1)59#define APDS990X_EN_PON (0x1 << 0)60#define APDS990X_EN_DISABLE_ALL 061 62/* Status register */63#define APDS990X_ST_PINT (0x1 << 5)64#define APDS990X_ST_AINT (0x1 << 4)65 66/* I2C access types */67#define APDS990x_CMD_TYPE_MASK (0x03 << 5)68#define APDS990x_CMD_TYPE_RB (0x00 << 5) /* Repeated byte */69#define APDS990x_CMD_TYPE_INC (0x01 << 5) /* Auto increment */70#define APDS990x_CMD_TYPE_SPE (0x03 << 5) /* Special function */71 72#define APDS990x_ADDR_SHIFT 073#define APDS990x_CMD 0x8074 75/* Interrupt ack commands */76#define APDS990X_INT_ACK_ALS 0x677#define APDS990X_INT_ACK_PS 0x578#define APDS990X_INT_ACK_BOTH 0x779 80/* ptime */81#define APDS990X_PTIME_DEFAULT 0xff /* Recommended conversion time 2.7ms*/82 83/* wtime */84#define APDS990X_WTIME_DEFAULT 0xee /* ~50ms wait time */85 86#define APDS990X_TIME_TO_ADC 1024 /* One timetick as ADC count value */87 88/* Persistence */89#define APDS990X_APERS_SHIFT 090#define APDS990X_PPERS_SHIFT 491 92/* Supported ID:s */93#define APDS990X_ID_0 0x094#define APDS990X_ID_4 0x495#define APDS990X_ID_29 0x2996 97/* pgain and pdiode settings */98#define APDS_PGAIN_1X 0x099#define APDS_PDIODE_IR 0x2100 101#define APDS990X_LUX_OUTPUT_SCALE 10102 103/* Reverse chip factors for threshold calculation */104struct reverse_factors {105 u32 afactor;106 int cf1;107 int irf1;108 int cf2;109 int irf2;110};111 112struct apds990x_chip {113 struct apds990x_platform_data *pdata;114 struct i2c_client *client;115 struct mutex mutex; /* avoid parallel access */116 struct regulator_bulk_data regs[2];117 wait_queue_head_t wait;118 119 int prox_en;120 bool prox_continuous_mode;121 bool lux_wait_fresh_res;122 123 /* Chip parameters */124 struct apds990x_chip_factors cf;125 struct reverse_factors rcf;126 u16 atime; /* als integration time */127 u16 arate; /* als reporting rate */128 u16 a_max_result; /* Max possible ADC value with current atime */129 u8 again_meas; /* Gain used in last measurement */130 u8 again_next; /* Next calculated gain */131 u8 pgain;132 u8 pdiode;133 u8 pdrive;134 u8 lux_persistence;135 u8 prox_persistence;136 137 u32 lux_raw;138 u32 lux;139 u16 lux_clear;140 u16 lux_ir;141 u16 lux_calib;142 u32 lux_thres_hi;143 u32 lux_thres_lo;144 145 u32 prox_thres;146 u16 prox_data;147 u16 prox_calib;148 149 char chipname[10];150 u8 revision;151};152 153#define APDS_CALIB_SCALER 8192154#define APDS_LUX_NEUTRAL_CALIB_VALUE (1 * APDS_CALIB_SCALER)155#define APDS_PROX_NEUTRAL_CALIB_VALUE (1 * APDS_CALIB_SCALER)156 157#define APDS_PROX_DEF_THRES 600158#define APDS_PROX_HYSTERESIS 50159#define APDS_LUX_DEF_THRES_HI 101160#define APDS_LUX_DEF_THRES_LO 100161#define APDS_DEFAULT_PROX_PERS 1162 163#define APDS_TIMEOUT 2000164#define APDS_STARTUP_DELAY 25000 /* us */165#define APDS_RANGE 65535166#define APDS_PROX_RANGE 1023167#define APDS_LUX_GAIN_LO_LIMIT 100168#define APDS_LUX_GAIN_LO_LIMIT_STRICT 25169 170#define TIMESTEP 87 /* 2.7ms is about 87 / 32 */171#define TIME_STEP_SCALER 32172 173#define APDS_LUX_AVERAGING_TIME 50 /* tolerates 50/60Hz ripple */174#define APDS_LUX_DEFAULT_RATE 200175 176static const u8 again[] = {1, 8, 16, 120}; /* ALS gain steps */177 178/* Following two tables must match i.e 10Hz rate means 1 as persistence value */179static const u16 arates_hz[] = {10, 5, 2, 1};180static const u8 apersis[] = {1, 2, 4, 5};181 182/* Regulators */183static const char reg_vcc[] = "Vdd";184static const char reg_vled[] = "Vled";185 186static int apds990x_read_byte(struct apds990x_chip *chip, u8 reg, u8 *data)187{188 struct i2c_client *client = chip->client;189 s32 ret;190 191 reg &= ~APDS990x_CMD_TYPE_MASK;192 reg |= APDS990x_CMD | APDS990x_CMD_TYPE_RB;193 194 ret = i2c_smbus_read_byte_data(client, reg);195 *data = ret;196 return (int)ret;197}198 199static int apds990x_read_word(struct apds990x_chip *chip, u8 reg, u16 *data)200{201 struct i2c_client *client = chip->client;202 s32 ret;203 204 reg &= ~APDS990x_CMD_TYPE_MASK;205 reg |= APDS990x_CMD | APDS990x_CMD_TYPE_INC;206 207 ret = i2c_smbus_read_word_data(client, reg);208 *data = ret;209 return (int)ret;210}211 212static int apds990x_write_byte(struct apds990x_chip *chip, u8 reg, u8 data)213{214 struct i2c_client *client = chip->client;215 s32 ret;216 217 reg &= ~APDS990x_CMD_TYPE_MASK;218 reg |= APDS990x_CMD | APDS990x_CMD_TYPE_RB;219 220 ret = i2c_smbus_write_byte_data(client, reg, data);221 return (int)ret;222}223 224static int apds990x_write_word(struct apds990x_chip *chip, u8 reg, u16 data)225{226 struct i2c_client *client = chip->client;227 s32 ret;228 229 reg &= ~APDS990x_CMD_TYPE_MASK;230 reg |= APDS990x_CMD | APDS990x_CMD_TYPE_INC;231 232 ret = i2c_smbus_write_word_data(client, reg, data);233 return (int)ret;234}235 236static int apds990x_mode_on(struct apds990x_chip *chip)237{238 /* ALS is mandatory, proximity optional */239 u8 reg = APDS990X_EN_AIEN | APDS990X_EN_PON | APDS990X_EN_AEN |240 APDS990X_EN_WEN;241 242 if (chip->prox_en)243 reg |= APDS990X_EN_PIEN | APDS990X_EN_PEN;244 245 return apds990x_write_byte(chip, APDS990X_ENABLE, reg);246}247 248static u16 apds990x_lux_to_threshold(struct apds990x_chip *chip, u32 lux)249{250 u32 thres;251 u32 cpl;252 u32 ir;253 254 if (lux == 0)255 return 0;256 else if (lux == APDS_RANGE)257 return APDS_RANGE;258 259 /*260 * Reported LUX value is a combination of the IR and CLEAR channel261 * values. However, interrupt threshold is only for clear channel.262 * This function approximates needed HW threshold value for a given263 * LUX value in the current lightning type.264 * IR level compared to visible light varies heavily depending on the265 * source of the light266 *267 * Calculate threshold value for the next measurement period.268 * Math: threshold = lux * cpl where269 * cpl = atime * again / (glass_attenuation * device_factor)270 * (count-per-lux)271 *272 * First remove calibration. Division by four is to avoid overflow273 */274 lux = lux * (APDS_CALIB_SCALER / 4) / (chip->lux_calib / 4);275 276 /* Multiplication by 64 is to increase accuracy */277 cpl = ((u32)chip->atime * (u32)again[chip->again_next] *278 APDS_PARAM_SCALE * 64) / (chip->cf.ga * chip->cf.df);279 280 thres = lux * cpl / 64;281 /*282 * Convert IR light from the latest result to match with283 * new gain step. This helps to adapt with the current284 * source of light.285 */286 ir = (u32)chip->lux_ir * (u32)again[chip->again_next] /287 (u32)again[chip->again_meas];288 289 /*290 * Compensate count with IR light impact291 * IAC1 > IAC2 (see apds990x_get_lux for formulas)292 */293 if (chip->lux_clear * APDS_PARAM_SCALE >=294 chip->rcf.afactor * chip->lux_ir)295 thres = (chip->rcf.cf1 * thres + chip->rcf.irf1 * ir) /296 APDS_PARAM_SCALE;297 else298 thres = (chip->rcf.cf2 * thres + chip->rcf.irf2 * ir) /299 APDS_PARAM_SCALE;300 301 if (thres >= chip->a_max_result)302 thres = chip->a_max_result - 1;303 return thres;304}305 306static inline int apds990x_set_atime(struct apds990x_chip *chip, u32 time_ms)307{308 u8 reg_value;309 310 chip->atime = time_ms;311 /* Formula is specified in the data sheet */312 reg_value = 256 - ((time_ms * TIME_STEP_SCALER) / TIMESTEP);313 /* Calculate max ADC value for given integration time */314 chip->a_max_result = (u16)(256 - reg_value) * APDS990X_TIME_TO_ADC;315 return apds990x_write_byte(chip, APDS990X_ATIME, reg_value);316}317 318/* Called always with mutex locked */319static int apds990x_refresh_pthres(struct apds990x_chip *chip, int data)320{321 int ret, lo, hi;322 323 /* If the chip is not in use, don't try to access it */324 if (pm_runtime_suspended(&chip->client->dev))325 return 0;326 327 if (data < chip->prox_thres) {328 lo = 0;329 hi = chip->prox_thres;330 } else {331 lo = chip->prox_thres - APDS_PROX_HYSTERESIS;332 if (chip->prox_continuous_mode)333 hi = chip->prox_thres;334 else335 hi = APDS_RANGE;336 }337 338 ret = apds990x_write_word(chip, APDS990X_PILTL, lo);339 ret |= apds990x_write_word(chip, APDS990X_PIHTL, hi);340 return ret;341}342 343/* Called always with mutex locked */344static int apds990x_refresh_athres(struct apds990x_chip *chip)345{346 int ret;347 /* If the chip is not in use, don't try to access it */348 if (pm_runtime_suspended(&chip->client->dev))349 return 0;350 351 ret = apds990x_write_word(chip, APDS990X_AILTL,352 apds990x_lux_to_threshold(chip, chip->lux_thres_lo));353 ret |= apds990x_write_word(chip, APDS990X_AIHTL,354 apds990x_lux_to_threshold(chip, chip->lux_thres_hi));355 356 return ret;357}358 359/* Called always with mutex locked */360static void apds990x_force_a_refresh(struct apds990x_chip *chip)361{362 /* This will force ALS interrupt after the next measurement. */363 apds990x_write_word(chip, APDS990X_AILTL, APDS_LUX_DEF_THRES_LO);364 apds990x_write_word(chip, APDS990X_AIHTL, APDS_LUX_DEF_THRES_HI);365}366 367/* Called always with mutex locked */368static void apds990x_force_p_refresh(struct apds990x_chip *chip)369{370 /* This will force proximity interrupt after the next measurement. */371 apds990x_write_word(chip, APDS990X_PILTL, APDS_PROX_DEF_THRES - 1);372 apds990x_write_word(chip, APDS990X_PIHTL, APDS_PROX_DEF_THRES);373}374 375/* Called always with mutex locked */376static int apds990x_calc_again(struct apds990x_chip *chip)377{378 int curr_again = chip->again_meas;379 int next_again = chip->again_meas;380 int ret = 0;381 382 /* Calculate suitable als gain */383 if (chip->lux_clear == chip->a_max_result)384 next_again -= 2; /* ALS saturated. Decrease gain by 2 steps */385 else if (chip->lux_clear > chip->a_max_result / 2)386 next_again--;387 else if (chip->lux_clear < APDS_LUX_GAIN_LO_LIMIT_STRICT)388 next_again += 2; /* Too dark. Increase gain by 2 steps */389 else if (chip->lux_clear < APDS_LUX_GAIN_LO_LIMIT)390 next_again++;391 392 /* Limit gain to available range */393 if (next_again < 0)394 next_again = 0;395 else if (next_again > APDS990X_MAX_AGAIN)396 next_again = APDS990X_MAX_AGAIN;397 398 /* Let's check can we trust the measured result */399 if (chip->lux_clear == chip->a_max_result)400 /* Result can be totally garbage due to saturation */401 ret = -ERANGE;402 else if (next_again != curr_again &&403 chip->lux_clear < APDS_LUX_GAIN_LO_LIMIT_STRICT)404 /*405 * Gain is changed and measurement result is very small.406 * Result can be totally garbage due to underflow407 */408 ret = -ERANGE;409 410 chip->again_next = next_again;411 apds990x_write_byte(chip, APDS990X_CONTROL,412 (chip->pdrive << 6) |413 (chip->pdiode << 4) |414 (chip->pgain << 2) |415 (chip->again_next << 0));416 417 /*418 * Error means bad result -> re-measurement is needed. The forced419 * refresh uses fastest possible persistence setting to get result420 * as soon as possible.421 */422 if (ret < 0)423 apds990x_force_a_refresh(chip);424 else425 apds990x_refresh_athres(chip);426 427 return ret;428}429 430/* Called always with mutex locked */431static int apds990x_get_lux(struct apds990x_chip *chip, int clear, int ir)432{433 int iac, iac1, iac2; /* IR adjusted counts */434 u32 lpc; /* Lux per count */435 436 /* Formulas:437 * iac1 = CF1 * CLEAR_CH - IRF1 * IR_CH438 * iac2 = CF2 * CLEAR_CH - IRF2 * IR_CH439 */440 iac1 = (chip->cf.cf1 * clear - chip->cf.irf1 * ir) / APDS_PARAM_SCALE;441 iac2 = (chip->cf.cf2 * clear - chip->cf.irf2 * ir) / APDS_PARAM_SCALE;442 443 iac = max(iac1, iac2);444 iac = max(iac, 0);445 446 lpc = APDS990X_LUX_OUTPUT_SCALE * (chip->cf.df * chip->cf.ga) /447 (u32)(again[chip->again_meas] * (u32)chip->atime);448 449 return (iac * lpc) / APDS_PARAM_SCALE;450}451 452static int apds990x_ack_int(struct apds990x_chip *chip, u8 mode)453{454 struct i2c_client *client = chip->client;455 s32 ret;456 u8 reg = APDS990x_CMD | APDS990x_CMD_TYPE_SPE;457 458 switch (mode & (APDS990X_ST_AINT | APDS990X_ST_PINT)) {459 case APDS990X_ST_AINT:460 reg |= APDS990X_INT_ACK_ALS;461 break;462 case APDS990X_ST_PINT:463 reg |= APDS990X_INT_ACK_PS;464 break;465 default:466 reg |= APDS990X_INT_ACK_BOTH;467 break;468 }469 470 ret = i2c_smbus_read_byte_data(client, reg);471 return (int)ret;472}473 474static irqreturn_t apds990x_irq(int irq, void *data)475{476 struct apds990x_chip *chip = data;477 u8 status;478 479 apds990x_read_byte(chip, APDS990X_STATUS, &status);480 apds990x_ack_int(chip, status);481 482 mutex_lock(&chip->mutex);483 if (!pm_runtime_suspended(&chip->client->dev)) {484 if (status & APDS990X_ST_AINT) {485 apds990x_read_word(chip, APDS990X_CDATAL,486 &chip->lux_clear);487 apds990x_read_word(chip, APDS990X_IRDATAL,488 &chip->lux_ir);489 /* Store used gain for calculations */490 chip->again_meas = chip->again_next;491 492 chip->lux_raw = apds990x_get_lux(chip,493 chip->lux_clear,494 chip->lux_ir);495 496 if (apds990x_calc_again(chip) == 0) {497 /* Result is valid */498 chip->lux = chip->lux_raw;499 chip->lux_wait_fresh_res = false;500 wake_up(&chip->wait);501 sysfs_notify(&chip->client->dev.kobj,502 NULL, "lux0_input");503 }504 }505 506 if ((status & APDS990X_ST_PINT) && chip->prox_en) {507 u16 clr_ch;508 509 apds990x_read_word(chip, APDS990X_CDATAL, &clr_ch);510 /*511 * If ALS channel is saturated at min gain,512 * proximity gives false posivite values.513 * Just ignore them.514 */515 if (chip->again_meas == 0 &&516 clr_ch == chip->a_max_result)517 chip->prox_data = 0;518 else519 apds990x_read_word(chip,520 APDS990X_PDATAL,521 &chip->prox_data);522 523 apds990x_refresh_pthres(chip, chip->prox_data);524 if (chip->prox_data < chip->prox_thres)525 chip->prox_data = 0;526 else if (!chip->prox_continuous_mode)527 chip->prox_data = APDS_PROX_RANGE;528 sysfs_notify(&chip->client->dev.kobj,529 NULL, "prox0_raw");530 }531 }532 mutex_unlock(&chip->mutex);533 return IRQ_HANDLED;534}535 536static int apds990x_configure(struct apds990x_chip *chip)537{538 /* It is recommended to use disabled mode during these operations */539 apds990x_write_byte(chip, APDS990X_ENABLE, APDS990X_EN_DISABLE_ALL);540 541 /* conversion and wait times for different state machince states */542 apds990x_write_byte(chip, APDS990X_PTIME, APDS990X_PTIME_DEFAULT);543 apds990x_write_byte(chip, APDS990X_WTIME, APDS990X_WTIME_DEFAULT);544 apds990x_set_atime(chip, APDS_LUX_AVERAGING_TIME);545 546 apds990x_write_byte(chip, APDS990X_CONFIG, 0);547 548 /* Persistence levels */549 apds990x_write_byte(chip, APDS990X_PERS,550 (chip->lux_persistence << APDS990X_APERS_SHIFT) |551 (chip->prox_persistence << APDS990X_PPERS_SHIFT));552 553 apds990x_write_byte(chip, APDS990X_PPCOUNT, chip->pdata->ppcount);554 555 /* Start with relatively small gain */556 chip->again_meas = 1;557 chip->again_next = 1;558 apds990x_write_byte(chip, APDS990X_CONTROL,559 (chip->pdrive << 6) |560 (chip->pdiode << 4) |561 (chip->pgain << 2) |562 (chip->again_next << 0));563 return 0;564}565 566static int apds990x_detect(struct apds990x_chip *chip)567{568 struct i2c_client *client = chip->client;569 int ret;570 u8 id;571 572 ret = apds990x_read_byte(chip, APDS990X_ID, &id);573 if (ret < 0) {574 dev_err(&client->dev, "ID read failed\n");575 return ret;576 }577 578 ret = apds990x_read_byte(chip, APDS990X_REV, &chip->revision);579 if (ret < 0) {580 dev_err(&client->dev, "REV read failed\n");581 return ret;582 }583 584 switch (id) {585 case APDS990X_ID_0:586 case APDS990X_ID_4:587 case APDS990X_ID_29:588 snprintf(chip->chipname, sizeof(chip->chipname), "APDS-990x");589 break;590 default:591 ret = -ENODEV;592 break;593 }594 return ret;595}596 597#ifdef CONFIG_PM598static int apds990x_chip_on(struct apds990x_chip *chip)599{600 int err = regulator_bulk_enable(ARRAY_SIZE(chip->regs),601 chip->regs);602 if (err < 0)603 return err;604 605 usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY);606 607 /* Refresh all configs in case of regulators were off */608 chip->prox_data = 0;609 apds990x_configure(chip);610 apds990x_mode_on(chip);611 return 0;612}613#endif614 615static int apds990x_chip_off(struct apds990x_chip *chip)616{617 apds990x_write_byte(chip, APDS990X_ENABLE, APDS990X_EN_DISABLE_ALL);618 regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs);619 return 0;620}621 622static ssize_t apds990x_lux_show(struct device *dev,623 struct device_attribute *attr, char *buf)624{625 struct apds990x_chip *chip = dev_get_drvdata(dev);626 ssize_t ret;627 u32 result;628 long time_left;629 630 if (pm_runtime_suspended(dev))631 return -EIO;632 633 time_left = wait_event_interruptible_timeout(chip->wait,634 !chip->lux_wait_fresh_res,635 msecs_to_jiffies(APDS_TIMEOUT));636 if (!time_left)637 return -EIO;638 639 mutex_lock(&chip->mutex);640 result = (chip->lux * chip->lux_calib) / APDS_CALIB_SCALER;641 if (result > (APDS_RANGE * APDS990X_LUX_OUTPUT_SCALE))642 result = APDS_RANGE * APDS990X_LUX_OUTPUT_SCALE;643 644 ret = sprintf(buf, "%d.%d\n",645 result / APDS990X_LUX_OUTPUT_SCALE,646 result % APDS990X_LUX_OUTPUT_SCALE);647 mutex_unlock(&chip->mutex);648 return ret;649}650 651static DEVICE_ATTR(lux0_input, S_IRUGO, apds990x_lux_show, NULL);652 653static ssize_t apds990x_lux_range_show(struct device *dev,654 struct device_attribute *attr, char *buf)655{656 return sprintf(buf, "%u\n", APDS_RANGE);657}658 659static DEVICE_ATTR(lux0_sensor_range, S_IRUGO, apds990x_lux_range_show, NULL);660 661static ssize_t apds990x_lux_calib_format_show(struct device *dev,662 struct device_attribute *attr, char *buf)663{664 return sprintf(buf, "%u\n", APDS_CALIB_SCALER);665}666 667static DEVICE_ATTR(lux0_calibscale_default, S_IRUGO,668 apds990x_lux_calib_format_show, NULL);669 670static ssize_t apds990x_lux_calib_show(struct device *dev,671 struct device_attribute *attr, char *buf)672{673 struct apds990x_chip *chip = dev_get_drvdata(dev);674 675 return sprintf(buf, "%u\n", chip->lux_calib);676}677 678static ssize_t apds990x_lux_calib_store(struct device *dev,679 struct device_attribute *attr,680 const char *buf, size_t len)681{682 struct apds990x_chip *chip = dev_get_drvdata(dev);683 unsigned long value;684 int ret;685 686 ret = kstrtoul(buf, 0, &value);687 if (ret)688 return ret;689 690 chip->lux_calib = value;691 692 return len;693}694 695static DEVICE_ATTR(lux0_calibscale, S_IRUGO | S_IWUSR, apds990x_lux_calib_show,696 apds990x_lux_calib_store);697 698static ssize_t apds990x_rate_avail(struct device *dev,699 struct device_attribute *attr, char *buf)700{701 int i;702 int pos = 0;703 704 for (i = 0; i < ARRAY_SIZE(arates_hz); i++)705 pos += sprintf(buf + pos, "%d ", arates_hz[i]);706 sprintf(buf + pos - 1, "\n");707 return pos;708}709 710static ssize_t apds990x_rate_show(struct device *dev,711 struct device_attribute *attr, char *buf)712{713 struct apds990x_chip *chip = dev_get_drvdata(dev);714 715 return sprintf(buf, "%d\n", chip->arate);716}717 718static int apds990x_set_arate(struct apds990x_chip *chip, int rate)719{720 int i;721 722 for (i = 0; i < ARRAY_SIZE(arates_hz); i++)723 if (rate >= arates_hz[i])724 break;725 726 if (i == ARRAY_SIZE(arates_hz))727 return -EINVAL;728 729 /* Pick up corresponding persistence value */730 chip->lux_persistence = apersis[i];731 chip->arate = arates_hz[i];732 733 /* If the chip is not in use, don't try to access it */734 if (pm_runtime_suspended(&chip->client->dev))735 return 0;736 737 /* Persistence levels */738 return apds990x_write_byte(chip, APDS990X_PERS,739 (chip->lux_persistence << APDS990X_APERS_SHIFT) |740 (chip->prox_persistence << APDS990X_PPERS_SHIFT));741}742 743static ssize_t apds990x_rate_store(struct device *dev,744 struct device_attribute *attr,745 const char *buf, size_t len)746{747 struct apds990x_chip *chip = dev_get_drvdata(dev);748 unsigned long value;749 int ret;750 751 ret = kstrtoul(buf, 0, &value);752 if (ret)753 return ret;754 755 mutex_lock(&chip->mutex);756 ret = apds990x_set_arate(chip, value);757 mutex_unlock(&chip->mutex);758 759 if (ret < 0)760 return ret;761 return len;762}763 764static DEVICE_ATTR(lux0_rate_avail, S_IRUGO, apds990x_rate_avail, NULL);765 766static DEVICE_ATTR(lux0_rate, S_IRUGO | S_IWUSR, apds990x_rate_show,767 apds990x_rate_store);768 769static ssize_t apds990x_prox_show(struct device *dev,770 struct device_attribute *attr, char *buf)771{772 ssize_t ret;773 struct apds990x_chip *chip = dev_get_drvdata(dev);774 775 if (pm_runtime_suspended(dev) || !chip->prox_en)776 return -EIO;777 778 mutex_lock(&chip->mutex);779 ret = sprintf(buf, "%d\n", chip->prox_data);780 mutex_unlock(&chip->mutex);781 return ret;782}783 784static DEVICE_ATTR(prox0_raw, S_IRUGO, apds990x_prox_show, NULL);785 786static ssize_t apds990x_prox_range_show(struct device *dev,787 struct device_attribute *attr, char *buf)788{789 return sprintf(buf, "%u\n", APDS_PROX_RANGE);790}791 792static DEVICE_ATTR(prox0_sensor_range, S_IRUGO, apds990x_prox_range_show, NULL);793 794static ssize_t apds990x_prox_enable_show(struct device *dev,795 struct device_attribute *attr, char *buf)796{797 struct apds990x_chip *chip = dev_get_drvdata(dev);798 799 return sprintf(buf, "%d\n", chip->prox_en);800}801 802static ssize_t apds990x_prox_enable_store(struct device *dev,803 struct device_attribute *attr,804 const char *buf, size_t len)805{806 struct apds990x_chip *chip = dev_get_drvdata(dev);807 unsigned long value;808 int ret;809 810 ret = kstrtoul(buf, 0, &value);811 if (ret)812 return ret;813 814 mutex_lock(&chip->mutex);815 816 if (!chip->prox_en)817 chip->prox_data = 0;818 819 if (value)820 chip->prox_en++;821 else if (chip->prox_en > 0)822 chip->prox_en--;823 824 if (!pm_runtime_suspended(dev))825 apds990x_mode_on(chip);826 mutex_unlock(&chip->mutex);827 return len;828}829 830static DEVICE_ATTR(prox0_raw_en, S_IRUGO | S_IWUSR, apds990x_prox_enable_show,831 apds990x_prox_enable_store);832 833static const char *reporting_modes[] = {"trigger", "periodic"};834 835static ssize_t apds990x_prox_reporting_mode_show(struct device *dev,836 struct device_attribute *attr, char *buf)837{838 struct apds990x_chip *chip = dev_get_drvdata(dev);839 840 return sprintf(buf, "%s\n",841 reporting_modes[!!chip->prox_continuous_mode]);842}843 844static ssize_t apds990x_prox_reporting_mode_store(struct device *dev,845 struct device_attribute *attr,846 const char *buf, size_t len)847{848 struct apds990x_chip *chip = dev_get_drvdata(dev);849 int ret;850 851 ret = sysfs_match_string(reporting_modes, buf);852 if (ret < 0)853 return ret;854 855 chip->prox_continuous_mode = ret;856 return len;857}858 859static DEVICE_ATTR(prox0_reporting_mode, S_IRUGO | S_IWUSR,860 apds990x_prox_reporting_mode_show,861 apds990x_prox_reporting_mode_store);862 863static ssize_t apds990x_prox_reporting_avail_show(struct device *dev,864 struct device_attribute *attr, char *buf)865{866 return sprintf(buf, "%s %s\n", reporting_modes[0], reporting_modes[1]);867}868 869static DEVICE_ATTR(prox0_reporting_mode_avail, S_IRUGO | S_IWUSR,870 apds990x_prox_reporting_avail_show, NULL);871 872 873static ssize_t apds990x_lux_thresh_above_show(struct device *dev,874 struct device_attribute *attr, char *buf)875{876 struct apds990x_chip *chip = dev_get_drvdata(dev);877 878 return sprintf(buf, "%d\n", chip->lux_thres_hi);879}880 881static ssize_t apds990x_lux_thresh_below_show(struct device *dev,882 struct device_attribute *attr, char *buf)883{884 struct apds990x_chip *chip = dev_get_drvdata(dev);885 886 return sprintf(buf, "%d\n", chip->lux_thres_lo);887}888 889static ssize_t apds990x_set_lux_thresh(struct apds990x_chip *chip, u32 *target,890 const char *buf)891{892 unsigned long thresh;893 int ret;894 895 ret = kstrtoul(buf, 0, &thresh);896 if (ret)897 return ret;898 899 if (thresh > APDS_RANGE)900 return -EINVAL;901 902 mutex_lock(&chip->mutex);903 *target = thresh;904 /*905 * Don't update values in HW if we are still waiting for906 * first interrupt to come after device handle open call.907 */908 if (!chip->lux_wait_fresh_res)909 apds990x_refresh_athres(chip);910 mutex_unlock(&chip->mutex);911 return ret;912 913}914 915static ssize_t apds990x_lux_thresh_above_store(struct device *dev,916 struct device_attribute *attr,917 const char *buf, size_t len)918{919 struct apds990x_chip *chip = dev_get_drvdata(dev);920 int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_hi, buf);921 922 if (ret < 0)923 return ret;924 return len;925}926 927static ssize_t apds990x_lux_thresh_below_store(struct device *dev,928 struct device_attribute *attr,929 const char *buf, size_t len)930{931 struct apds990x_chip *chip = dev_get_drvdata(dev);932 int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_lo, buf);933 934 if (ret < 0)935 return ret;936 return len;937}938 939static DEVICE_ATTR(lux0_thresh_above_value, S_IRUGO | S_IWUSR,940 apds990x_lux_thresh_above_show,941 apds990x_lux_thresh_above_store);942 943static DEVICE_ATTR(lux0_thresh_below_value, S_IRUGO | S_IWUSR,944 apds990x_lux_thresh_below_show,945 apds990x_lux_thresh_below_store);946 947static ssize_t apds990x_prox_threshold_show(struct device *dev,948 struct device_attribute *attr, char *buf)949{950 struct apds990x_chip *chip = dev_get_drvdata(dev);951 952 return sprintf(buf, "%d\n", chip->prox_thres);953}954 955static ssize_t apds990x_prox_threshold_store(struct device *dev,956 struct device_attribute *attr,957 const char *buf, size_t len)958{959 struct apds990x_chip *chip = dev_get_drvdata(dev);960 unsigned long value;961 int ret;962 963 ret = kstrtoul(buf, 0, &value);964 if (ret)965 return ret;966 967 if ((value > APDS_RANGE) || (value == 0) ||968 (value < APDS_PROX_HYSTERESIS))969 return -EINVAL;970 971 mutex_lock(&chip->mutex);972 chip->prox_thres = value;973 974 apds990x_force_p_refresh(chip);975 mutex_unlock(&chip->mutex);976 return len;977}978 979static DEVICE_ATTR(prox0_thresh_above_value, S_IRUGO | S_IWUSR,980 apds990x_prox_threshold_show,981 apds990x_prox_threshold_store);982 983static ssize_t apds990x_power_state_show(struct device *dev,984 struct device_attribute *attr, char *buf)985{986 return sprintf(buf, "%d\n", !pm_runtime_suspended(dev));987 return 0;988}989 990static ssize_t apds990x_power_state_store(struct device *dev,991 struct device_attribute *attr,992 const char *buf, size_t len)993{994 struct apds990x_chip *chip = dev_get_drvdata(dev);995 unsigned long value;996 int ret;997 998 ret = kstrtoul(buf, 0, &value);999 if (ret)1000 return ret;1001 1002 if (value) {1003 pm_runtime_get_sync(dev);1004 mutex_lock(&chip->mutex);1005 chip->lux_wait_fresh_res = true;1006 apds990x_force_a_refresh(chip);1007 apds990x_force_p_refresh(chip);1008 mutex_unlock(&chip->mutex);1009 } else {1010 if (!pm_runtime_suspended(dev))1011 pm_runtime_put(dev);1012 }1013 return len;1014}1015 1016static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR,1017 apds990x_power_state_show,1018 apds990x_power_state_store);1019 1020static ssize_t apds990x_chip_id_show(struct device *dev,1021 struct device_attribute *attr, char *buf)1022{1023 struct apds990x_chip *chip = dev_get_drvdata(dev);1024 1025 return sprintf(buf, "%s %d\n", chip->chipname, chip->revision);1026}1027 1028static DEVICE_ATTR(chip_id, S_IRUGO, apds990x_chip_id_show, NULL);1029 1030static struct attribute *sysfs_attrs_ctrl[] = {1031 &dev_attr_lux0_calibscale.attr,1032 &dev_attr_lux0_calibscale_default.attr,1033 &dev_attr_lux0_input.attr,1034 &dev_attr_lux0_sensor_range.attr,1035 &dev_attr_lux0_rate.attr,1036 &dev_attr_lux0_rate_avail.attr,1037 &dev_attr_lux0_thresh_above_value.attr,1038 &dev_attr_lux0_thresh_below_value.attr,1039 &dev_attr_prox0_raw_en.attr,1040 &dev_attr_prox0_raw.attr,1041 &dev_attr_prox0_sensor_range.attr,1042 &dev_attr_prox0_thresh_above_value.attr,1043 &dev_attr_prox0_reporting_mode.attr,1044 &dev_attr_prox0_reporting_mode_avail.attr,1045 &dev_attr_chip_id.attr,1046 &dev_attr_power_state.attr,1047 NULL1048};1049 1050static const struct attribute_group apds990x_attribute_group[] = {1051 {.attrs = sysfs_attrs_ctrl },1052};1053 1054static int apds990x_probe(struct i2c_client *client)1055{1056 struct apds990x_chip *chip;1057 int err;1058 1059 chip = kzalloc(sizeof *chip, GFP_KERNEL);1060 if (!chip)1061 return -ENOMEM;1062 1063 i2c_set_clientdata(client, chip);1064 chip->client = client;1065 1066 init_waitqueue_head(&chip->wait);1067 mutex_init(&chip->mutex);1068 chip->pdata = client->dev.platform_data;1069 1070 if (chip->pdata == NULL) {1071 dev_err(&client->dev, "platform data is mandatory\n");1072 err = -EINVAL;1073 goto fail1;1074 }1075 1076 if (chip->pdata->cf.ga == 0) {1077 /* set uncovered sensor default parameters */1078 chip->cf.ga = 1966; /* 0.48 * APDS_PARAM_SCALE */1079 chip->cf.cf1 = 4096; /* 1.00 * APDS_PARAM_SCALE */1080 chip->cf.irf1 = 9134; /* 2.23 * APDS_PARAM_SCALE */1081 chip->cf.cf2 = 2867; /* 0.70 * APDS_PARAM_SCALE */1082 chip->cf.irf2 = 5816; /* 1.42 * APDS_PARAM_SCALE */1083 chip->cf.df = 52;1084 } else {1085 chip->cf = chip->pdata->cf;1086 }1087 1088 /* precalculate inverse chip factors for threshold control */1089 chip->rcf.afactor =1090 (chip->cf.irf1 - chip->cf.irf2) * APDS_PARAM_SCALE /1091 (chip->cf.cf1 - chip->cf.cf2);1092 chip->rcf.cf1 = APDS_PARAM_SCALE * APDS_PARAM_SCALE /1093 chip->cf.cf1;1094 chip->rcf.irf1 = chip->cf.irf1 * APDS_PARAM_SCALE /1095 chip->cf.cf1;1096 chip->rcf.cf2 = APDS_PARAM_SCALE * APDS_PARAM_SCALE /1097 chip->cf.cf2;1098 chip->rcf.irf2 = chip->cf.irf2 * APDS_PARAM_SCALE /1099 chip->cf.cf2;1100 1101 /* Set something to start with */1102 chip->lux_thres_hi = APDS_LUX_DEF_THRES_HI;1103 chip->lux_thres_lo = APDS_LUX_DEF_THRES_LO;1104 chip->lux_calib = APDS_LUX_NEUTRAL_CALIB_VALUE;1105 1106 chip->prox_thres = APDS_PROX_DEF_THRES;1107 chip->pdrive = chip->pdata->pdrive;1108 chip->pdiode = APDS_PDIODE_IR;1109 chip->pgain = APDS_PGAIN_1X;1110 chip->prox_calib = APDS_PROX_NEUTRAL_CALIB_VALUE;1111 chip->prox_persistence = APDS_DEFAULT_PROX_PERS;1112 chip->prox_continuous_mode = false;1113 1114 chip->regs[0].supply = reg_vcc;1115 chip->regs[1].supply = reg_vled;1116 1117 err = regulator_bulk_get(&client->dev,1118 ARRAY_SIZE(chip->regs), chip->regs);1119 if (err < 0) {1120 dev_err(&client->dev, "Cannot get regulators\n");1121 goto fail1;1122 }1123 1124 err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs);1125 if (err < 0) {1126 dev_err(&client->dev, "Cannot enable regulators\n");1127 goto fail2;1128 }1129 1130 usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY);1131 1132 err = apds990x_detect(chip);1133 if (err < 0) {1134 dev_err(&client->dev, "APDS990X not found\n");1135 goto fail3;1136 }1137 1138 pm_runtime_set_active(&client->dev);1139 1140 apds990x_configure(chip);1141 apds990x_set_arate(chip, APDS_LUX_DEFAULT_RATE);1142 apds990x_mode_on(chip);1143 1144 pm_runtime_enable(&client->dev);1145 1146 if (chip->pdata->setup_resources) {1147 err = chip->pdata->setup_resources();1148 if (err) {1149 err = -EINVAL;1150 goto fail3;1151 }1152 }1153 1154 err = sysfs_create_group(&chip->client->dev.kobj,1155 apds990x_attribute_group);1156 if (err < 0) {1157 dev_err(&chip->client->dev, "Sysfs registration failed\n");1158 goto fail4;1159 }1160 1161 err = request_threaded_irq(client->irq, NULL,1162 apds990x_irq,1163 IRQF_TRIGGER_FALLING | IRQF_TRIGGER_LOW |1164 IRQF_ONESHOT,1165 "apds990x", chip);1166 if (err) {1167 dev_err(&client->dev, "could not get IRQ %d\n",1168 client->irq);1169 goto fail5;1170 }1171 return err;1172fail5:1173 sysfs_remove_group(&chip->client->dev.kobj,1174 &apds990x_attribute_group[0]);1175fail4:1176 if (chip->pdata && chip->pdata->release_resources)1177 chip->pdata->release_resources();1178fail3:1179 regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs);1180fail2:1181 regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs);1182fail1:1183 kfree(chip);1184 return err;1185}1186 1187static void apds990x_remove(struct i2c_client *client)1188{1189 struct apds990x_chip *chip = i2c_get_clientdata(client);1190 1191 free_irq(client->irq, chip);1192 sysfs_remove_group(&chip->client->dev.kobj,1193 apds990x_attribute_group);1194 1195 if (chip->pdata && chip->pdata->release_resources)1196 chip->pdata->release_resources();1197 1198 if (!pm_runtime_suspended(&client->dev))1199 apds990x_chip_off(chip);1200 1201 pm_runtime_disable(&client->dev);1202 pm_runtime_set_suspended(&client->dev);1203 1204 regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs);1205 1206 kfree(chip);1207}1208 1209#ifdef CONFIG_PM_SLEEP1210static int apds990x_suspend(struct device *dev)1211{1212 struct i2c_client *client = to_i2c_client(dev);1213 struct apds990x_chip *chip = i2c_get_clientdata(client);1214 1215 apds990x_chip_off(chip);1216 return 0;1217}1218 1219static int apds990x_resume(struct device *dev)1220{1221 struct i2c_client *client = to_i2c_client(dev);1222 struct apds990x_chip *chip = i2c_get_clientdata(client);1223 1224 /*1225 * If we were enabled at suspend time, it is expected1226 * everything works nice and smoothly. Chip_on is enough1227 */1228 apds990x_chip_on(chip);1229 1230 return 0;1231}1232#endif1233 1234#ifdef CONFIG_PM1235static int apds990x_runtime_suspend(struct device *dev)1236{1237 struct i2c_client *client = to_i2c_client(dev);1238 struct apds990x_chip *chip = i2c_get_clientdata(client);1239 1240 apds990x_chip_off(chip);1241 return 0;1242}1243 1244static int apds990x_runtime_resume(struct device *dev)1245{1246 struct i2c_client *client = to_i2c_client(dev);1247 struct apds990x_chip *chip = i2c_get_clientdata(client);1248 1249 apds990x_chip_on(chip);1250 return 0;1251}1252 1253#endif1254 1255static const struct i2c_device_id apds990x_id[] = {1256 { "apds990x" },1257 {}1258};1259 1260MODULE_DEVICE_TABLE(i2c, apds990x_id);1261 1262static const struct dev_pm_ops apds990x_pm_ops = {1263 SET_SYSTEM_SLEEP_PM_OPS(apds990x_suspend, apds990x_resume)1264 SET_RUNTIME_PM_OPS(apds990x_runtime_suspend,1265 apds990x_runtime_resume,1266 NULL)1267};1268 1269static struct i2c_driver apds990x_driver = {1270 .driver = {1271 .name = "apds990x",1272 .pm = &apds990x_pm_ops,1273 },1274 .probe = apds990x_probe,1275 .remove = apds990x_remove,1276 .id_table = apds990x_id,1277};1278 1279module_i2c_driver(apds990x_driver);1280 1281MODULE_DESCRIPTION("APDS990X combined ALS and proximity sensor");1282MODULE_AUTHOR("Samu Onkalo, Nokia Corporation");1283MODULE_LICENSE("GPL v2");1284