// SPDX-License-Identifier: GPL-2.0-only /* * This file is part of the APDS990x sensor driver. * Chip is combined proximity and ambient light sensor. * * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). * * Contact: Samu Onkalo <samu.p.onkalo@nokia.com> */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/i2c.h> #include <linux/interrupt.h> #include <linux/mutex.h> #include <linux/regulator/consumer.h> #include <linux/pm_runtime.h> #include <linux/delay.h> #include <linux/wait.h> #include <linux/slab.h> #include <linux/platform_data/apds990x.h> /* Register map */ #define APDS990X_ENABLE 0x00 /* Enable of states and interrupts */ #define APDS990X_ATIME 0x01 /* ALS ADC time */ #define APDS990X_PTIME 0x02 /* Proximity ADC time */ #define APDS990X_WTIME 0x03 /* Wait time */ #define APDS990X_AILTL 0x04 /* ALS interrupt low threshold low byte */ #define APDS990X_AILTH 0x05 /* ALS interrupt low threshold hi byte */ #define APDS990X_AIHTL 0x06 /* ALS interrupt hi threshold low byte */ #define APDS990X_AIHTH 0x07 /* ALS interrupt hi threshold hi byte */ #define APDS990X_PILTL 0x08 /* Proximity interrupt low threshold low byte */ #define APDS990X_PILTH 0x09 /* Proximity interrupt low threshold hi byte */ #define APDS990X_PIHTL 0x0a /* Proximity interrupt hi threshold low byte */ #define APDS990X_PIHTH 0x0b /* Proximity interrupt hi threshold hi byte */ #define APDS990X_PERS 0x0c /* Interrupt persistence filters */ #define APDS990X_CONFIG 0x0d /* Configuration */ #define APDS990X_PPCOUNT 0x0e /* Proximity pulse count */ #define APDS990X_CONTROL 0x0f /* Gain control register */ #define APDS990X_REV 0x11 /* Revision Number */ #define APDS990X_ID 0x12 /* Device ID */ #define APDS990X_STATUS 0x13 /* Device status */ #define APDS990X_CDATAL 0x14 /* Clear ADC low data register */ #define APDS990X_CDATAH 0x15 /* Clear ADC high data register */ #define APDS990X_IRDATAL 0x16 /* IR ADC low data register */ #define APDS990X_IRDATAH 0x17 /* IR ADC high data register */ #define APDS990X_PDATAL 0x18 /* Proximity ADC low data register */ #define APDS990X_PDATAH 0x19 /* Proximity ADC high data register */ /* Control */ #define APDS990X_MAX_AGAIN 3 /* Enable register */ #define APDS990X_EN_PIEN (0x1 << 5) #define APDS990X_EN_AIEN (0x1 << 4) #define APDS990X_EN_WEN (0x1 << 3) #define APDS990X_EN_PEN (0x1 << 2) #define APDS990X_EN_AEN (0x1 << 1) #define APDS990X_EN_PON (0x1 << 0) #define APDS990X_EN_DISABLE_ALL 0 /* Status register */ #define APDS990X_ST_PINT (0x1 << 5) #define APDS990X_ST_AINT (0x1 << 4) /* I2C access types */ #define APDS990x_CMD_TYPE_MASK (0x03 << 5) #define APDS990x_CMD_TYPE_RB (0x00 << 5) /* Repeated byte */ #define APDS990x_CMD_TYPE_INC (0x01 << 5) /* Auto increment */ #define APDS990x_CMD_TYPE_SPE (0x03 << 5) /* Special function */ #define APDS990x_ADDR_SHIFT 0 #define APDS990x_CMD 0x80 /* Interrupt ack commands */ #define APDS990X_INT_ACK_ALS 0x6 #define APDS990X_INT_ACK_PS 0x5 #define APDS990X_INT_ACK_BOTH 0x7 /* ptime */ #define APDS990X_PTIME_DEFAULT 0xff /* Recommended conversion time 2.7ms*/ /* wtime */ #define APDS990X_WTIME_DEFAULT 0xee /* ~50ms wait time */ #define APDS990X_TIME_TO_ADC 1024 /* One timetick as ADC count value */ /* Persistence */ #define APDS990X_APERS_SHIFT 0 #define APDS990X_PPERS_SHIFT 4 /* Supported ID:s */ #define APDS990X_ID_0 0x0 #define APDS990X_ID_4 0x4 #define APDS990X_ID_29 0x29 /* pgain and pdiode settings */ #define APDS_PGAIN_1X 0x0 #define APDS_PDIODE_IR 0x2 #define APDS990X_LUX_OUTPUT_SCALE 10 /* Reverse chip factors for threshold calculation */ struct reverse_factors { u32 afactor; int cf1; int irf1; int cf2; int irf2; }; struct apds990x_chip { struct apds990x_platform_data *pdata; struct i2c_client *client; struct mutex mutex; /* avoid parallel access */ struct regulator_bulk_data regs[2]; wait_queue_head_t wait; int prox_en; bool prox_continuous_mode; bool lux_wait_fresh_res; /* Chip parameters */ struct apds990x_chip_factors cf; struct reverse_factors rcf; u16 atime; /* als integration time */ u16 arate; /* als reporting rate */ u16 a_max_result; /* Max possible ADC value with current atime */ u8 again_meas; /* Gain used in last measurement */ u8 again_next; /* Next calculated gain */ u8 pgain; u8 pdiode; u8 pdrive; u8 lux_persistence; u8 prox_persistence; u32 lux_raw; u32 lux; u16 lux_clear; u16 lux_ir; u16 lux_calib; u32 lux_thres_hi; u32 lux_thres_lo; u32 prox_thres; u16 prox_data; u16 prox_calib; char chipname[10]; u8 revision; }; #define APDS_CALIB_SCALER 8192 #define APDS_LUX_NEUTRAL_CALIB_VALUE (1 * APDS_CALIB_SCALER) #define APDS_PROX_NEUTRAL_CALIB_VALUE (1 * APDS_CALIB_SCALER) #define APDS_PROX_DEF_THRES 600 #define APDS_PROX_HYSTERESIS 50 #define APDS_LUX_DEF_THRES_HI 101 #define APDS_LUX_DEF_THRES_LO 100 #define APDS_DEFAULT_PROX_PERS 1 #define APDS_TIMEOUT 2000 #define APDS_STARTUP_DELAY 25000 /* us */ #define APDS_RANGE 65535 #define APDS_PROX_RANGE 1023 #define APDS_LUX_GAIN_LO_LIMIT 100 #define APDS_LUX_GAIN_LO_LIMIT_STRICT 25 #define TIMESTEP 87 /* 2.7ms is about 87 / 32 */ #define TIME_STEP_SCALER 32 #define APDS_LUX_AVERAGING_TIME 50 /* tolerates 50/60Hz ripple */ #define APDS_LUX_DEFAULT_RATE 200 static const u8 again[] = {1, 8, 16, 120}; /* ALS gain steps */ /* Following two tables must match i.e 10Hz rate means 1 as persistence value */ static const u16 arates_hz[] = {10, 5, 2, 1}; static const u8 apersis[] = {1, 2, 4, 5}; /* Regulators */ static const char reg_vcc[] = "Vdd"; static const char reg_vled[] = "Vled"; static int apds990x_read_byte(struct apds990x_chip *chip, u8 reg, u8 *data) { struct i2c_client *client = chip->client; s32 ret; reg &= ~APDS990x_CMD_TYPE_MASK; reg |= APDS990x_CMD | APDS990x_CMD_TYPE_RB; ret = i2c_smbus_read_byte_data(client, reg); *data = ret; return (int)ret; } static int apds990x_read_word(struct apds990x_chip *chip, u8 reg, u16 *data) { struct i2c_client *client = chip->client; s32 ret; reg &= ~APDS990x_CMD_TYPE_MASK; reg |= APDS990x_CMD | APDS990x_CMD_TYPE_INC; ret = i2c_smbus_read_word_data(client, reg); *data = ret; return (int)ret; } static int apds990x_write_byte(struct apds990x_chip *chip, u8 reg, u8 data) { struct i2c_client *client = chip->client; s32 ret; reg &= ~APDS990x_CMD_TYPE_MASK; reg |= APDS990x_CMD | APDS990x_CMD_TYPE_RB; ret = i2c_smbus_write_byte_data(client, reg, data); return (int)ret; } static int apds990x_write_word(struct apds990x_chip *chip, u8 reg, u16 data) { struct i2c_client *client = chip->client; s32 ret; reg &= ~APDS990x_CMD_TYPE_MASK; reg |= APDS990x_CMD | APDS990x_CMD_TYPE_INC; ret = i2c_smbus_write_word_data(client, reg, data); return (int)ret; } static int apds990x_mode_on(struct apds990x_chip *chip) { /* ALS is mandatory, proximity optional */ u8 reg = APDS990X_EN_AIEN | APDS990X_EN_PON | APDS990X_EN_AEN | APDS990X_EN_WEN; if (chip->prox_en) reg |= APDS990X_EN_PIEN | APDS990X_EN_PEN; return apds990x_write_byte(chip, APDS990X_ENABLE, reg); } static u16 apds990x_lux_to_threshold(struct apds990x_chip *chip, u32 lux) { u32 thres; u32 cpl; u32 ir; if (lux == 0) return 0; else if (lux == APDS_RANGE) return APDS_RANGE; /* * Reported LUX value is a combination of the IR and CLEAR channel * values. However, interrupt threshold is only for clear channel. * This function approximates needed HW threshold value for a given * LUX value in the current lightning type. * IR level compared to visible light varies heavily depending on the * source of the light * * Calculate threshold value for the next measurement period. * Math: threshold = lux * cpl where * cpl = atime * again / (glass_attenuation * device_factor) * (count-per-lux) * * First remove calibration. Division by four is to avoid overflow */ lux = lux * (APDS_CALIB_SCALER / 4) / (chip->lux_calib / 4); /* Multiplication by 64 is to increase accuracy */ cpl = ((u32)chip->atime * (u32)again[chip->again_next] * APDS_PARAM_SCALE * 64) / (chip->cf.ga * chip->cf.df); thres = lux * cpl / 64; /* * Convert IR light from the latest result to match with * new gain step. This helps to adapt with the current * source of light. */ ir = (u32)chip->lux_ir * (u32)again[chip->again_next] / (u32)again[chip->again_meas]; /* * Compensate count with IR light impact * IAC1 > IAC2 (see apds990x_get_lux for formulas) */ if (chip->lux_clear * APDS_PARAM_SCALE >= chip->rcf.afactor * chip->lux_ir) thres = (chip->rcf.cf1 * thres + chip->rcf.irf1 * ir) / APDS_PARAM_SCALE; else thres = (chip->rcf.cf2 * thres + chip->rcf.irf2 * ir) / APDS_PARAM_SCALE; if (thres >= chip->a_max_result) thres = chip->a_max_result - 1; return thres; } static inline int apds990x_set_atime(struct apds990x_chip *chip, u32 time_ms) { u8 reg_value; chip->atime = time_ms; /* Formula is specified in the data sheet */ reg_value = 256 - ((time_ms * TIME_STEP_SCALER) / TIMESTEP); /* Calculate max ADC value for given integration time */ chip->a_max_result = (u16)(256 - reg_value) * APDS990X_TIME_TO_ADC; return apds990x_write_byte(chip, APDS990X_ATIME, reg_value); } /* Called always with mutex locked */ static int apds990x_refresh_pthres(struct apds990x_chip *chip, int data) { int ret, lo, hi; /* If the chip is not in use, don't try to access it */ if (pm_runtime_suspended(&chip->client->dev)) return 0; if (data < chip->prox_thres) { lo = 0; hi = chip->prox_thres; } else { lo = chip->prox_thres - APDS_PROX_HYSTERESIS; if (chip->prox_continuous_mode) hi = chip->prox_thres; else hi = APDS_RANGE; } ret = apds990x_write_word(chip, APDS990X_PILTL, lo); ret |= apds990x_write_word(chip, APDS990X_PIHTL, hi); return ret; } /* Called always with mutex locked */ static int apds990x_refresh_athres(struct apds990x_chip *chip) { int ret; /* If the chip is not in use, don't try to access it */ if (pm_runtime_suspended(&chip->client->dev)) return 0; ret = apds990x_write_word(chip, APDS990X_AILTL, apds990x_lux_to_threshold(chip, chip->lux_thres_lo)); ret |= apds990x_write_word(chip, APDS990X_AIHTL, apds990x_lux_to_threshold(chip, chip->lux_thres_hi)); return ret; } /* Called always with mutex locked */ static void apds990x_force_a_refresh(struct apds990x_chip *chip) { /* This will force ALS interrupt after the next measurement. */ apds990x_write_word(chip, APDS990X_AILTL, APDS_LUX_DEF_THRES_LO); apds990x_write_word(chip, APDS990X_AIHTL, APDS_LUX_DEF_THRES_HI); } /* Called always with mutex locked */ static void apds990x_force_p_refresh(struct apds990x_chip *chip) { /* This will force proximity interrupt after the next measurement. */ apds990x_write_word(chip, APDS990X_PILTL, APDS_PROX_DEF_THRES - 1); apds990x_write_word(chip, APDS990X_PIHTL, APDS_PROX_DEF_THRES); } /* Called always with mutex locked */ static int apds990x_calc_again(struct apds990x_chip *chip) { int curr_again = chip->again_meas; int next_again = chip->again_meas; int ret = 0; /* Calculate suitable als gain */ if (chip->lux_clear == chip->a_max_result) next_again -= 2; /* ALS saturated. Decrease gain by 2 steps */ else if (chip->lux_clear > chip->a_max_result / 2) next_again--; else if (chip->lux_clear < APDS_LUX_GAIN_LO_LIMIT_STRICT) next_again += 2; /* Too dark. Increase gain by 2 steps */ else if (chip->lux_clear < APDS_LUX_GAIN_LO_LIMIT) next_again++; /* Limit gain to available range */ if (next_again < 0) next_again = 0; else if (next_again > APDS990X_MAX_AGAIN) next_again = APDS990X_MAX_AGAIN; /* Let's check can we trust the measured result */ if (chip->lux_clear == chip->a_max_result) /* Result can be totally garbage due to saturation */ ret = -ERANGE; else if (next_again != curr_again && chip->lux_clear < APDS_LUX_GAIN_LO_LIMIT_STRICT) /* * Gain is changed and measurement result is very small. * Result can be totally garbage due to underflow */ ret = -ERANGE; chip->again_next = next_again; apds990x_write_byte(chip, APDS990X_CONTROL, (chip->pdrive << 6) | (chip->pdiode << 4) | (chip->pgain << 2) | (chip->again_next << 0)); /* * Error means bad result -> re-measurement is needed. The forced * refresh uses fastest possible persistence setting to get result * as soon as possible. */ if (ret < 0) apds990x_force_a_refresh(chip); else apds990x_refresh_athres(chip); return ret; } /* Called always with mutex locked */ static int apds990x_get_lux(struct apds990x_chip *chip, int clear, int ir) { int iac, iac1, iac2; /* IR adjusted counts */ u32 lpc; /* Lux per count */ /* Formulas: * iac1 = CF1 * CLEAR_CH - IRF1 * IR_CH * iac2 = CF2 * CLEAR_CH - IRF2 * IR_CH */ iac1 = (chip->cf.cf1 * clear - chip->cf.irf1 * ir) / APDS_PARAM_SCALE; iac2 = (chip->cf.cf2 * clear - chip->cf.irf2 * ir) / APDS_PARAM_SCALE; iac = max(iac1, iac2); iac = max(iac, 0); lpc = APDS990X_LUX_OUTPUT_SCALE * (chip->cf.df * chip->cf.ga) / (u32)(again[chip->again_meas] * (u32)chip->atime); return (iac * lpc) / APDS_PARAM_SCALE; } static int apds990x_ack_int(struct apds990x_chip *chip, u8 mode) { struct i2c_client *client = chip->client; s32 ret; u8 reg = APDS990x_CMD | APDS990x_CMD_TYPE_SPE; switch (mode & (APDS990X_ST_AINT | APDS990X_ST_PINT)) { case APDS990X_ST_AINT: reg |= APDS990X_INT_ACK_ALS; break; case APDS990X_ST_PINT: reg |= APDS990X_INT_ACK_PS; break; default: reg |= APDS990X_INT_ACK_BOTH; break; } ret = i2c_smbus_read_byte_data(client, reg); return (int)ret; } static irqreturn_t apds990x_irq(int irq, void *data) { struct apds990x_chip *chip = data; u8 status; apds990x_read_byte(chip, APDS990X_STATUS, &status); apds990x_ack_int(chip, status); mutex_lock(&chip->mutex); if (!pm_runtime_suspended(&chip->client->dev)) { if (status & APDS990X_ST_AINT) { apds990x_read_word(chip, APDS990X_CDATAL, &chip->lux_clear); apds990x_read_word(chip, APDS990X_IRDATAL, &chip->lux_ir); /* Store used gain for calculations */ chip->again_meas = chip->again_next; chip->lux_raw = apds990x_get_lux(chip, chip->lux_clear, chip->lux_ir); if (apds990x_calc_again(chip) == 0) { /* Result is valid */ chip->lux = chip->lux_raw; chip->lux_wait_fresh_res = false; wake_up(&chip->wait); sysfs_notify(&chip->client->dev.kobj, NULL, "lux0_input"); } } if ((status & APDS990X_ST_PINT) && chip->prox_en) { u16 clr_ch; apds990x_read_word(chip, APDS990X_CDATAL, &clr_ch); /* * If ALS channel is saturated at min gain, * proximity gives false posivite values. * Just ignore them. */ if (chip->again_meas == 0 && clr_ch == chip->a_max_result) chip->prox_data = 0; else apds990x_read_word(chip, APDS990X_PDATAL, &chip->prox_data); apds990x_refresh_pthres(chip, chip->prox_data); if (chip->prox_data < chip->prox_thres) chip->prox_data = 0; else if (!chip->prox_continuous_mode) chip->prox_data = APDS_PROX_RANGE; sysfs_notify(&chip->client->dev.kobj, NULL, "prox0_raw"); } } mutex_unlock(&chip->mutex); return IRQ_HANDLED; } static int apds990x_configure(struct apds990x_chip *chip) { /* It is recommended to use disabled mode during these operations */ apds990x_write_byte(chip, APDS990X_ENABLE, APDS990X_EN_DISABLE_ALL); /* conversion and wait times for different state machince states */ apds990x_write_byte(chip, APDS990X_PTIME, APDS990X_PTIME_DEFAULT); apds990x_write_byte(chip, APDS990X_WTIME, APDS990X_WTIME_DEFAULT); apds990x_set_atime(chip, APDS_LUX_AVERAGING_TIME); apds990x_write_byte(chip, APDS990X_CONFIG, 0); /* Persistence levels */ apds990x_write_byte(chip, APDS990X_PERS, (chip->lux_persistence << APDS990X_APERS_SHIFT) | (chip->prox_persistence << APDS990X_PPERS_SHIFT)); apds990x_write_byte(chip, APDS990X_PPCOUNT, chip->pdata->ppcount); /* Start with relatively small gain */ chip->again_meas = 1; chip->again_next = 1; apds990x_write_byte(chip, APDS990X_CONTROL, (chip->pdrive << 6) | (chip->pdiode << 4) | (chip->pgain << 2) | (chip->again_next << 0)); return 0; } static int apds990x_detect(struct apds990x_chip *chip) { struct i2c_client *client = chip->client; int ret; u8 id; ret = apds990x_read_byte(chip, APDS990X_ID, &id); if (ret < 0) { dev_err(&client->dev, "ID read failed\n"); return ret; } ret = apds990x_read_byte(chip, APDS990X_REV, &chip->revision); if (ret < 0) { dev_err(&client->dev, "REV read failed\n"); return ret; } switch (id) { case APDS990X_ID_0: case APDS990X_ID_4: case APDS990X_ID_29: snprintf(chip->chipname, sizeof(chip->chipname), "APDS-990x"); break; default: ret = -ENODEV; break; } return ret; } #ifdef CONFIG_PM static int apds990x_chip_on(struct apds990x_chip *chip) { int err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs); if (err < 0) return err; usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY); /* Refresh all configs in case of regulators were off */ chip->prox_data = 0; apds990x_configure(chip); apds990x_mode_on(chip); return 0; } #endif static int apds990x_chip_off(struct apds990x_chip *chip) { apds990x_write_byte(chip, APDS990X_ENABLE, APDS990X_EN_DISABLE_ALL); regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); return 0; } static ssize_t apds990x_lux_show(struct device *dev, struct device_attribute *attr, char *buf) { struct apds990x_chip *chip = dev_get_drvdata(dev); ssize_t ret; u32 result; long timeout; if (pm_runtime_suspended(dev)) return -EIO; timeout = wait_event_interruptible_timeout(chip->wait, !chip->lux_wait_fresh_res, msecs_to_jiffies(APDS_TIMEOUT)); if (!timeout) return -EIO; mutex_lock(&chip->mutex); result = (chip->lux * chip->lux_calib) / APDS_CALIB_SCALER; if (result > (APDS_RANGE * APDS990X_LUX_OUTPUT_SCALE)) result = APDS_RANGE * APDS990X_LUX_OUTPUT_SCALE; ret = sprintf(buf, "%d.%d\n", result / APDS990X_LUX_OUTPUT_SCALE, result % APDS990X_LUX_OUTPUT_SCALE); mutex_unlock(&chip->mutex); return ret; } static DEVICE_ATTR(lux0_input, S_IRUGO, apds990x_lux_show, NULL); static ssize_t apds990x_lux_range_show(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "%u\n", APDS_RANGE); } static DEVICE_ATTR(lux0_sensor_range, S_IRUGO, apds990x_lux_range_show, NULL); static ssize_t apds990x_lux_calib_format_show(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "%u\n", APDS_CALIB_SCALER); } static DEVICE_ATTR(lux0_calibscale_default, S_IRUGO, apds990x_lux_calib_format_show, NULL); static ssize_t apds990x_lux_calib_show(struct device *dev, struct device_attribute *attr, char *buf) { struct apds990x_chip *chip = dev_get_drvdata(dev); return sprintf(buf, "%u\n", chip->lux_calib); } static ssize_t apds990x_lux_calib_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct apds990x_chip *chip = dev_get_drvdata(dev); unsigned long value; int ret; ret = kstrtoul(buf, 0, &value); if (ret) return ret; chip->lux_calib = value; return len; } static DEVICE_ATTR(lux0_calibscale, S_IRUGO | S_IWUSR, apds990x_lux_calib_show, apds990x_lux_calib_store); static ssize_t apds990x_rate_avail(struct device *dev, struct device_attribute *attr, char *buf) { int i; int pos = 0; for (i = 0; i < ARRAY_SIZE(arates_hz); i++) pos += sprintf(buf + pos, "%d ", arates_hz[i]); sprintf(buf + pos - 1, "\n"); return pos; } static ssize_t apds990x_rate_show(struct device *dev, struct device_attribute *attr, char *buf) { struct apds990x_chip *chip = dev_get_drvdata(dev); return sprintf(buf, "%d\n", chip->arate); } static int apds990x_set_arate(struct apds990x_chip *chip, int rate) { int i; for (i = 0; i < ARRAY_SIZE(arates_hz); i++) if (rate >= arates_hz[i]) break; if (i == ARRAY_SIZE(arates_hz)) return -EINVAL; /* Pick up corresponding persistence value */ chip->lux_persistence = apersis[i]; chip->arate = arates_hz[i]; /* If the chip is not in use, don't try to access it */ if (pm_runtime_suspended(&chip->client->dev)) return 0; /* Persistence levels */ return apds990x_write_byte(chip, APDS990X_PERS, (chip->lux_persistence << APDS990X_APERS_SHIFT) | (chip->prox_persistence << APDS990X_PPERS_SHIFT)); } static ssize_t apds990x_rate_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct apds990x_chip *chip = dev_get_drvdata(dev); unsigned long value; int ret; ret = kstrtoul(buf, 0, &value); if (ret) return ret; mutex_lock(&chip->mutex); ret = apds990x_set_arate(chip, value); mutex_unlock(&chip->mutex); if (ret < 0) return ret; return len; } static DEVICE_ATTR(lux0_rate_avail, S_IRUGO, apds990x_rate_avail, NULL); static DEVICE_ATTR(lux0_rate, S_IRUGO | S_IWUSR, apds990x_rate_show, apds990x_rate_store); static ssize_t apds990x_prox_show(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret; struct apds990x_chip *chip = dev_get_drvdata(dev); if (pm_runtime_suspended(dev) || !chip->prox_en) return -EIO; mutex_lock(&chip->mutex); ret = sprintf(buf, "%d\n", chip->prox_data); mutex_unlock(&chip->mutex); return ret; } static DEVICE_ATTR(prox0_raw, S_IRUGO, apds990x_prox_show, NULL); static ssize_t apds990x_prox_range_show(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "%u\n", APDS_PROX_RANGE); } static DEVICE_ATTR(prox0_sensor_range, S_IRUGO, apds990x_prox_range_show, NULL); static ssize_t apds990x_prox_enable_show(struct device *dev, struct device_attribute *attr, char *buf) { struct apds990x_chip *chip = dev_get_drvdata(dev); return sprintf(buf, "%d\n", chip->prox_en); } static ssize_t apds990x_prox_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct apds990x_chip *chip = dev_get_drvdata(dev); unsigned long value; int ret; ret = kstrtoul(buf, 0, &value); if (ret) return ret; mutex_lock(&chip->mutex); if (!chip->prox_en) chip->prox_data = 0; if (value) chip->prox_en++; else if (chip->prox_en > 0) chip->prox_en--; if (!pm_runtime_suspended(dev)) apds990x_mode_on(chip); mutex_unlock(&chip->mutex); return len; } static DEVICE_ATTR(prox0_raw_en, S_IRUGO | S_IWUSR, apds990x_prox_enable_show, apds990x_prox_enable_store); static const char *reporting_modes[] = {"trigger", "periodic"}; static ssize_t apds990x_prox_reporting_mode_show(struct device *dev, struct device_attribute *attr, char *buf) { struct apds990x_chip *chip = dev_get_drvdata(dev); return sprintf(buf, "%s\n", reporting_modes[!!chip->prox_continuous_mode]); } static ssize_t apds990x_prox_reporting_mode_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct apds990x_chip *chip = dev_get_drvdata(dev); int ret; ret = sysfs_match_string(reporting_modes, buf); if (ret < 0) return ret; chip->prox_continuous_mode = ret; return len; } static DEVICE_ATTR(prox0_reporting_mode, S_IRUGO | S_IWUSR, apds990x_prox_reporting_mode_show, apds990x_prox_reporting_mode_store); static ssize_t apds990x_prox_reporting_avail_show(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "%s %s\n", reporting_modes[0], reporting_modes[1]); } static DEVICE_ATTR(prox0_reporting_mode_avail, S_IRUGO | S_IWUSR, apds990x_prox_reporting_avail_show, NULL); static ssize_t apds990x_lux_thresh_above_show(struct device *dev, struct device_attribute *attr, char *buf) { struct apds990x_chip *chip = dev_get_drvdata(dev); return sprintf(buf, "%d\n", chip->lux_thres_hi); } static ssize_t apds990x_lux_thresh_below_show(struct device *dev, struct device_attribute *attr, char *buf) { struct apds990x_chip *chip = dev_get_drvdata(dev); return sprintf(buf, "%d\n", chip->lux_thres_lo); } static ssize_t apds990x_set_lux_thresh(struct apds990x_chip *chip, u32 *target, const char *buf) { unsigned long thresh; int ret; ret = kstrtoul(buf, 0, &thresh); if (ret) return ret; if (thresh > APDS_RANGE) return -EINVAL; mutex_lock(&chip->mutex); *target = thresh; /* * Don't update values in HW if we are still waiting for * first interrupt to come after device handle open call. */ if (!chip->lux_wait_fresh_res) apds990x_refresh_athres(chip); mutex_unlock(&chip->mutex); return ret; } static ssize_t apds990x_lux_thresh_above_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct apds990x_chip *chip = dev_get_drvdata(dev); int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_hi, buf); if (ret < 0) return ret; return len; } static ssize_t apds990x_lux_thresh_below_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct apds990x_chip *chip = dev_get_drvdata(dev); int ret = apds990x_set_lux_thresh(chip, &chip->lux_thres_lo, buf); if (ret < 0) return ret; return len; } static DEVICE_ATTR(lux0_thresh_above_value, S_IRUGO | S_IWUSR, apds990x_lux_thresh_above_show, apds990x_lux_thresh_above_store); static DEVICE_ATTR(lux0_thresh_below_value, S_IRUGO | S_IWUSR, apds990x_lux_thresh_below_show, apds990x_lux_thresh_below_store); static ssize_t apds990x_prox_threshold_show(struct device *dev, struct device_attribute *attr, char *buf) { struct apds990x_chip *chip = dev_get_drvdata(dev); return sprintf(buf, "%d\n", chip->prox_thres); } static ssize_t apds990x_prox_threshold_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct apds990x_chip *chip = dev_get_drvdata(dev); unsigned long value; int ret; ret = kstrtoul(buf, 0, &value); if (ret) return ret; if ((value > APDS_RANGE) || (value == 0) || (value < APDS_PROX_HYSTERESIS)) return -EINVAL; mutex_lock(&chip->mutex); chip->prox_thres = value; apds990x_force_p_refresh(chip); mutex_unlock(&chip->mutex); return len; } static DEVICE_ATTR(prox0_thresh_above_value, S_IRUGO | S_IWUSR, apds990x_prox_threshold_show, apds990x_prox_threshold_store); static ssize_t apds990x_power_state_show(struct device *dev, struct device_attribute *attr, char *buf) { return sprintf(buf, "%d\n", !pm_runtime_suspended(dev)); return 0; } static ssize_t apds990x_power_state_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t len) { struct apds990x_chip *chip = dev_get_drvdata(dev); unsigned long value; int ret; ret = kstrtoul(buf, 0, &value); if (ret) return ret; if (value) { pm_runtime_get_sync(dev); mutex_lock(&chip->mutex); chip->lux_wait_fresh_res = true; apds990x_force_a_refresh(chip); apds990x_force_p_refresh(chip); mutex_unlock(&chip->mutex); } else { if (!pm_runtime_suspended(dev)) pm_runtime_put(dev); } return len; } static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR, apds990x_power_state_show, apds990x_power_state_store); static ssize_t apds990x_chip_id_show(struct device *dev, struct device_attribute *attr, char *buf) { struct apds990x_chip *chip = dev_get_drvdata(dev); return sprintf(buf, "%s %d\n", chip->chipname, chip->revision); } static DEVICE_ATTR(chip_id, S_IRUGO, apds990x_chip_id_show, NULL); static struct attribute *sysfs_attrs_ctrl[] = { &dev_attr_lux0_calibscale.attr, &dev_attr_lux0_calibscale_default.attr, &dev_attr_lux0_input.attr, &dev_attr_lux0_sensor_range.attr, &dev_attr_lux0_rate.attr, &dev_attr_lux0_rate_avail.attr, &dev_attr_lux0_thresh_above_value.attr, &dev_attr_lux0_thresh_below_value.attr, &dev_attr_prox0_raw_en.attr, &dev_attr_prox0_raw.attr, &dev_attr_prox0_sensor_range.attr, &dev_attr_prox0_thresh_above_value.attr, &dev_attr_prox0_reporting_mode.attr, &dev_attr_prox0_reporting_mode_avail.attr, &dev_attr_chip_id.attr, &dev_attr_power_state.attr, NULL }; static const struct attribute_group apds990x_attribute_group[] = { {.attrs = sysfs_attrs_ctrl }, }; static int apds990x_probe(struct i2c_client *client) { struct apds990x_chip *chip; int err; chip = kzalloc(sizeof *chip, GFP_KERNEL); if (!chip) return -ENOMEM; i2c_set_clientdata(client, chip); chip->client = client; init_waitqueue_head(&chip->wait); mutex_init(&chip->mutex); chip->pdata = client->dev.platform_data; if (chip->pdata == NULL) { dev_err(&client->dev, "platform data is mandatory\n"); err = -EINVAL; goto fail1; } if (chip->pdata->cf.ga == 0) { /* set uncovered sensor default parameters */ chip->cf.ga = 1966; /* 0.48 * APDS_PARAM_SCALE */ chip->cf.cf1 = 4096; /* 1.00 * APDS_PARAM_SCALE */ chip->cf.irf1 = 9134; /* 2.23 * APDS_PARAM_SCALE */ chip->cf.cf2 = 2867; /* 0.70 * APDS_PARAM_SCALE */ chip->cf.irf2 = 5816; /* 1.42 * APDS_PARAM_SCALE */ chip->cf.df = 52; } else { chip->cf = chip->pdata->cf; } /* precalculate inverse chip factors for threshold control */ chip->rcf.afactor = (chip->cf.irf1 - chip->cf.irf2) * APDS_PARAM_SCALE / (chip->cf.cf1 - chip->cf.cf2); chip->rcf.cf1 = APDS_PARAM_SCALE * APDS_PARAM_SCALE / chip->cf.cf1; chip->rcf.irf1 = chip->cf.irf1 * APDS_PARAM_SCALE / chip->cf.cf1; chip->rcf.cf2 = APDS_PARAM_SCALE * APDS_PARAM_SCALE / chip->cf.cf2; chip->rcf.irf2 = chip->cf.irf2 * APDS_PARAM_SCALE / chip->cf.cf2; /* Set something to start with */ chip->lux_thres_hi = APDS_LUX_DEF_THRES_HI; chip->lux_thres_lo = APDS_LUX_DEF_THRES_LO; chip->lux_calib = APDS_LUX_NEUTRAL_CALIB_VALUE; chip->prox_thres = APDS_PROX_DEF_THRES; chip->pdrive = chip->pdata->pdrive; chip->pdiode = APDS_PDIODE_IR; chip->pgain = APDS_PGAIN_1X; chip->prox_calib = APDS_PROX_NEUTRAL_CALIB_VALUE; chip->prox_persistence = APDS_DEFAULT_PROX_PERS; chip->prox_continuous_mode = false; chip->regs[0].supply = reg_vcc; chip->regs[1].supply = reg_vled; err = regulator_bulk_get(&client->dev, ARRAY_SIZE(chip->regs), chip->regs); if (err < 0) { dev_err(&client->dev, "Cannot get regulators\n"); goto fail1; } err = regulator_bulk_enable(ARRAY_SIZE(chip->regs), chip->regs); if (err < 0) { dev_err(&client->dev, "Cannot enable regulators\n"); goto fail2; } usleep_range(APDS_STARTUP_DELAY, 2 * APDS_STARTUP_DELAY); err = apds990x_detect(chip); if (err < 0) { dev_err(&client->dev, "APDS990X not found\n"); goto fail3; } pm_runtime_set_active(&client->dev); apds990x_configure(chip); apds990x_set_arate(chip, APDS_LUX_DEFAULT_RATE); apds990x_mode_on(chip); pm_runtime_enable(&client->dev); if (chip->pdata->setup_resources) { err = chip->pdata->setup_resources(); if (err) { err = -EINVAL; goto fail3; } } err = sysfs_create_group(&chip->client->dev.kobj, apds990x_attribute_group); if (err < 0) { dev_err(&chip->client->dev, "Sysfs registration failed\n"); goto fail4; } err = request_threaded_irq(client->irq, NULL, apds990x_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_LOW | IRQF_ONESHOT, "apds990x", chip); if (err) { dev_err(&client->dev, "could not get IRQ %d\n", client->irq); goto fail5; } return err; fail5: sysfs_remove_group(&chip->client->dev.kobj, &apds990x_attribute_group[0]); fail4: if (chip->pdata && chip->pdata->release_resources) chip->pdata->release_resources(); fail3: regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); fail2: regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); fail1: kfree(chip); return err; } static void apds990x_remove(struct i2c_client *client) { struct apds990x_chip *chip = i2c_get_clientdata(client); free_irq(client->irq, chip); sysfs_remove_group(&chip->client->dev.kobj, apds990x_attribute_group); if (chip->pdata && chip->pdata->release_resources) chip->pdata->release_resources(); if (!pm_runtime_suspended(&client->dev)) apds990x_chip_off(chip); pm_runtime_disable(&client->dev); pm_runtime_set_suspended(&client->dev); regulator_bulk_free(ARRAY_SIZE(chip->regs), chip->regs); kfree(chip); } #ifdef CONFIG_PM_SLEEP static int apds990x_suspend(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct apds990x_chip *chip = i2c_get_clientdata(client); apds990x_chip_off(chip); return 0; } static int apds990x_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct apds990x_chip *chip = i2c_get_clientdata(client); /* * If we were enabled at suspend time, it is expected * everything works nice and smoothly. Chip_on is enough */ apds990x_chip_on(chip); return 0; } #endif #ifdef CONFIG_PM static int apds990x_runtime_suspend(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct apds990x_chip *chip = i2c_get_clientdata(client); apds990x_chip_off(chip); return 0; } static int apds990x_runtime_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct apds990x_chip *chip = i2c_get_clientdata(client); apds990x_chip_on(chip); return 0; } #endif static const struct i2c_device_id apds990x_id[] = { {"apds990x", 0 }, {} }; MODULE_DEVICE_TABLE(i2c, apds990x_id); static const struct dev_pm_ops apds990x_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(apds990x_suspend, apds990x_resume) SET_RUNTIME_PM_OPS(apds990x_runtime_suspend, apds990x_runtime_resume, NULL) }; static struct i2c_driver apds990x_driver = { .driver = { .name = "apds990x", .pm = &apds990x_pm_ops, }, .probe_new = apds990x_probe, .remove = apds990x_remove, .id_table = apds990x_id, }; module_i2c_driver(apds990x_driver); MODULE_DESCRIPTION("APDS990X combined ALS and proximity sensor"); MODULE_AUTHOR("Samu Onkalo, Nokia Corporation"); MODULE_LICENSE("GPL v2");