Release 4.14 drivers/misc/apds990x.c

/*
 * 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>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#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 */

static const u8 ir_currents[]	= {100, 50, 25, 12}; 
/* IRled currents in mA */

/* 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
61
100.00%
1
100.00%
Total
61
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
61
100.00%
1
100.00%
Total
61
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
57
100.00%
1
100.00%
Total
57
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
57
100.00%
1
100.00%
Total
57
100.00%
1
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
45
100.00%
1
100.00%
Total
45
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
222
100.00%
1
100.00%
Total
222
100.00%
1
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
65
100.00%
1
100.00%
Total
65
100.00%
1
100.00%

/* 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
110
100.00%
1
100.00%
Total
110
100.00%
1
100.00%

/* 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
69
100.00%
1
100.00%
Total
69
100.00%
1
100.00%

/* 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%

/* 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
32
100.00%
1
100.00%
Total
32
100.00%
1
100.00%

/* 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
212
100.00%
1
100.00%
Total
212
100.00%
1
100.00%

/* 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
138
100.00%
1
100.00%
Total
138
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
82
100.00%
1
100.00%
Total
82
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
298
100.00%
1
100.00%
Total
298
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
148
100.00%
1
100.00%
Total
148
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
136
100.00%
1
100.00%
Total
136
100.00%
1
100.00%

#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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
66
100.00%
1
100.00%
Total
66
100.00%
1
100.00%

#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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
37
100.00%
1
100.00%
Total
37
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
144
100.00%
1
100.00%
Total
144
100.00%
1
100.00%

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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%

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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%

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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
58
84.06%
1
50.00%
Jingoo Han
11
15.94%
1
50.00%
Total
69
100.00%
2
100.00%

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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
74
100.00%
1
100.00%
Total
74
100.00%
1
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%



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));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
116
100.00%
1
100.00%
Total
116
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
89
91.75%
1
50.00%
Jingoo Han
8
8.25%
1
50.00%
Total
97
100.00%
2
100.00%

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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
81
100.00%
1
100.00%
Total
81
100.00%
1
100.00%

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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%

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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
117
91.41%
1
50.00%
Jingoo Han
11
8.59%
1
50.00%
Total
128
100.00%
2
100.00%

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]);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
47
100.00%
1
100.00%
Total
47
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
49
76.56%
1
50.00%
Andy Shevchenko
15
23.44%
1
50.00%
Total
64
100.00%
2
100.00%

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]);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
38
100.00%
1
100.00%
Total
38
100.00%
1
100.00%

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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%



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;

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
82
88.17%
1
50.00%
Jingoo Han
11
11.83%
1
50.00%
Total
93
100.00%
2
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
61
100.00%
1
100.00%
Total
61
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
61
100.00%
1
100.00%
Total
61
100.00%
1
100.00%

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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
103
90.35%
1
50.00%
Jingoo Han
11
9.65%
1
50.00%
Total
114
100.00%
2
100.00%

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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
37
100.00%
1
100.00%
Total
37
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
111
90.98%
1
50.00%
Jingoo Han
11
9.02%
1
50.00%
Total
122
100.00%
2
100.00%

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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
46
100.00%
1
100.00%
Total
46
100.00%
1
100.00%

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,
				const struct i2c_device_id *id)
{
	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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
742
100.00%
1
100.00%
Total
742
100.00%
1
100.00%



static int 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);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
117
100.00%
1
100.00%
Total
117
100.00%
1
100.00%

#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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
38
97.44%
1
50.00%
Geliang Tang
1
2.56%
1
50.00%
Total
39
100.00%
2
100.00%



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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
39
97.50%
1
50.00%
Geliang Tang
1
2.50%
1
50.00%
Total
40
100.00%
2
100.00%

#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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
38
97.44%
1
50.00%
Geliang Tang
1
2.56%
1
50.00%
Total
39
100.00%
2
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
38
97.44%
1
50.00%
Geliang Tang
1
2.56%
1
50.00%
Total
39
100.00%
2
100.00%

#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	  = 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");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Samu Onkalo
5637
98.38%
1
10.00%
Jingoo Han
64
1.12%
2
20.00%
Andy Shevchenko
16
0.28%
1
10.00%
Geliang Tang
4
0.07%
1
10.00%
Geert Uytterhoeven
3
0.05%
1
10.00%
Rafael J. Wysocki
3
0.05%
1
10.00%
Axel Lin
1
0.02%
1
10.00%
Arvind Yadav
1
0.02%
1
10.00%
Wolfram Sang
1
0.02%
1
10.00%
Total
5730
100.00%
10
100.00%
Directory: drivers/misc

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.