| /* |
| * This file is part of the ROHM BH1770GLC / OSRAM SFH7770 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/i2c/bh1770glc.h> |
| #include <linux/regulator/consumer.h> |
| #include <linux/pm_runtime.h> |
| #include <linux/workqueue.h> |
| #include <linux/delay.h> |
| #include <linux/wait.h> |
| #include <linux/slab.h> |
| |
| #define BH1770_ALS_CONTROL 0x80 /* ALS operation mode control */ |
| #define BH1770_PS_CONTROL 0x81 /* PS operation mode control */ |
| #define BH1770_I_LED 0x82 /* active LED and LED1, LED2 current */ |
| #define BH1770_I_LED3 0x83 /* LED3 current setting */ |
| #define BH1770_ALS_PS_MEAS 0x84 /* Forced mode trigger */ |
| #define BH1770_PS_MEAS_RATE 0x85 /* PS meas. rate at stand alone mode */ |
| #define BH1770_ALS_MEAS_RATE 0x86 /* ALS meas. rate at stand alone mode */ |
| #define BH1770_PART_ID 0x8a /* Part number and revision ID */ |
| #define BH1770_MANUFACT_ID 0x8b /* Manufacturerer ID */ |
| #define BH1770_ALS_DATA_0 0x8c /* ALS DATA low byte */ |
| #define BH1770_ALS_DATA_1 0x8d /* ALS DATA high byte */ |
| #define BH1770_ALS_PS_STATUS 0x8e /* Measurement data and int status */ |
| #define BH1770_PS_DATA_LED1 0x8f /* PS data from LED1 */ |
| #define BH1770_PS_DATA_LED2 0x90 /* PS data from LED2 */ |
| #define BH1770_PS_DATA_LED3 0x91 /* PS data from LED3 */ |
| #define BH1770_INTERRUPT 0x92 /* Interrupt setting */ |
| #define BH1770_PS_TH_LED1 0x93 /* PS interrupt threshold for LED1 */ |
| #define BH1770_PS_TH_LED2 0x94 /* PS interrupt threshold for LED2 */ |
| #define BH1770_PS_TH_LED3 0x95 /* PS interrupt threshold for LED3 */ |
| #define BH1770_ALS_TH_UP_0 0x96 /* ALS upper threshold low byte */ |
| #define BH1770_ALS_TH_UP_1 0x97 /* ALS upper threshold high byte */ |
| #define BH1770_ALS_TH_LOW_0 0x98 /* ALS lower threshold low byte */ |
| #define BH1770_ALS_TH_LOW_1 0x99 /* ALS lower threshold high byte */ |
| |
| /* MANUFACT_ID */ |
| #define BH1770_MANUFACT_ROHM 0x01 |
| #define BH1770_MANUFACT_OSRAM 0x03 |
| |
| /* PART_ID */ |
| #define BH1770_PART 0x90 |
| #define BH1770_PART_MASK 0xf0 |
| #define BH1770_REV_MASK 0x0f |
| #define BH1770_REV_SHIFT 0 |
| #define BH1770_REV_0 0x00 |
| #define BH1770_REV_1 0x01 |
| |
| /* Operating modes for both */ |
| #define BH1770_STANDBY 0x00 |
| #define BH1770_FORCED 0x02 |
| #define BH1770_STANDALONE 0x03 |
| #define BH1770_SWRESET (0x01 << 2) |
| |
| #define BH1770_PS_TRIG_MEAS (1 << 0) |
| #define BH1770_ALS_TRIG_MEAS (1 << 1) |
| |
| /* Interrupt control */ |
| #define BH1770_INT_OUTPUT_MODE (1 << 3) /* 0 = latched */ |
| #define BH1770_INT_POLARITY (1 << 2) /* 1 = active high */ |
| #define BH1770_INT_ALS_ENA (1 << 1) |
| #define BH1770_INT_PS_ENA (1 << 0) |
| |
| /* Interrupt status */ |
| #define BH1770_INT_LED1_DATA (1 << 0) |
| #define BH1770_INT_LED1_INT (1 << 1) |
| #define BH1770_INT_LED2_DATA (1 << 2) |
| #define BH1770_INT_LED2_INT (1 << 3) |
| #define BH1770_INT_LED3_DATA (1 << 4) |
| #define BH1770_INT_LED3_INT (1 << 5) |
| #define BH1770_INT_LEDS_INT ((1 << 1) | (1 << 3) | (1 << 5)) |
| #define BH1770_INT_ALS_DATA (1 << 6) |
| #define BH1770_INT_ALS_INT (1 << 7) |
| |
| /* Led channels */ |
| #define BH1770_LED1 0x00 |
| |
| #define BH1770_DISABLE 0 |
| #define BH1770_ENABLE 1 |
| #define BH1770_PROX_CHANNELS 1 |
| |
| #define BH1770_LUX_DEFAULT_RATE 1 /* Index to lux rate table */ |
| #define BH1770_PROX_DEFAULT_RATE 1 /* Direct HW value =~ 50Hz */ |
| #define BH1770_PROX_DEF_RATE_THRESH 6 /* Direct HW value =~ 5 Hz */ |
| #define BH1770_STARTUP_DELAY 50 |
| #define BH1770_RESET_TIME 10 |
| #define BH1770_TIMEOUT 2100 /* Timeout in 2.1 seconds */ |
| |
| #define BH1770_LUX_RANGE 65535 |
| #define BH1770_PROX_RANGE 255 |
| #define BH1770_COEF_SCALER 1024 |
| #define BH1770_CALIB_SCALER 8192 |
| #define BH1770_LUX_NEUTRAL_CALIB_VALUE (1 * BH1770_CALIB_SCALER) |
| #define BH1770_LUX_DEF_THRES 1000 |
| #define BH1770_PROX_DEF_THRES 70 |
| #define BH1770_PROX_DEF_ABS_THRES 100 |
| #define BH1770_DEFAULT_PERSISTENCE 10 |
| #define BH1770_PROX_MAX_PERSISTENCE 50 |
| #define BH1770_LUX_GA_SCALE 16384 |
| #define BH1770_LUX_CF_SCALE 2048 /* CF ChipFactor */ |
| #define BH1770_NEUTRAL_CF BH1770_LUX_CF_SCALE |
| #define BH1770_LUX_CORR_SCALE 4096 |
| |
| #define PROX_ABOVE_THRESHOLD 1 |
| #define PROX_BELOW_THRESHOLD 0 |
| |
| #define PROX_IGNORE_LUX_LIMIT 500 |
| |
| struct bh1770_chip { |
| struct bh1770_platform_data *pdata; |
| char chipname[10]; |
| u8 revision; |
| struct i2c_client *client; |
| struct regulator_bulk_data regs[2]; |
| struct mutex mutex; /* avoid parallel access */ |
| wait_queue_head_t wait; |
| |
| bool int_mode_prox; |
| bool int_mode_lux; |
| struct delayed_work prox_work; |
| u32 lux_cf; /* Chip specific factor */ |
| u32 lux_ga; |
| u32 lux_calib; |
| int lux_rate_index; |
| u32 lux_corr; |
| u16 lux_data_raw; |
| u16 lux_threshold_hi; |
| u16 lux_threshold_lo; |
| u16 lux_thres_hi_onchip; |
| u16 lux_thres_lo_onchip; |
| bool lux_wait_result; |
| |
| int prox_enable_count; |
| u16 prox_coef; |
| u16 prox_const; |
| int prox_rate; |
| int prox_rate_threshold; |
| u8 prox_persistence; |
| u8 prox_persistence_counter; |
| u8 prox_data; |
| u8 prox_threshold; |
| u8 prox_threshold_hw; |
| bool prox_force_update; |
| u8 prox_abs_thres; |
| u8 prox_led; |
| }; |
| |
| static const char reg_vcc[] = "Vcc"; |
| static const char reg_vleds[] = "Vleds"; |
| |
| /* |
| * Supported stand alone rates in ms from chip data sheet |
| * {10, 20, 30, 40, 70, 100, 200, 500, 1000, 2000}; |
| */ |
| static const s16 prox_rates_hz[] = {100, 50, 33, 25, 14, 10, 5, 2}; |
| static const s16 prox_rates_ms[] = {10, 20, 30, 40, 70, 100, 200, 500}; |
| |
| /* Supported IR-led currents in mA */ |
| static const u8 prox_curr_ma[] = {5, 10, 20, 50, 100, 150, 200}; |
| |
| /* |
| * Supported stand alone rates in ms from chip data sheet |
| * {100, 200, 500, 1000, 2000}; |
| */ |
| static const s16 lux_rates_hz[] = {10, 5, 2, 1, 0}; |
| |
| /* |
| * interrupt control functions are called while keeping chip->mutex |
| * excluding module probe / remove |
| */ |
| static inline int bh1770_lux_interrupt_control(struct bh1770_chip *chip, |
| int lux) |
| { |
| chip->int_mode_lux = lux; |
| /* Set interrupt modes, interrupt active low, latched */ |
| return i2c_smbus_write_byte_data(chip->client, |
| BH1770_INTERRUPT, |
| (lux << 1) | chip->int_mode_prox); |
| } |
| |
| static inline int bh1770_prox_interrupt_control(struct bh1770_chip *chip, |
| int ps) |
| { |
| chip->int_mode_prox = ps; |
| return i2c_smbus_write_byte_data(chip->client, |
| BH1770_INTERRUPT, |
| (chip->int_mode_lux << 1) | (ps << 0)); |
| } |
| |
| /* chip->mutex is always kept here */ |
| static int bh1770_lux_rate(struct bh1770_chip *chip, int rate_index) |
| { |
| /* sysfs may call this when the chip is powered off */ |
| if (pm_runtime_suspended(&chip->client->dev)) |
| return 0; |
| |
| /* Proper proximity response needs fastest lux rate (100ms) */ |
| if (chip->prox_enable_count) |
| rate_index = 0; |
| |
| return i2c_smbus_write_byte_data(chip->client, |
| BH1770_ALS_MEAS_RATE, |
| rate_index); |
| } |
| |
| static int bh1770_prox_rate(struct bh1770_chip *chip, int mode) |
| { |
| int rate; |
| |
| rate = (mode == PROX_ABOVE_THRESHOLD) ? |
| chip->prox_rate_threshold : chip->prox_rate; |
| |
| return i2c_smbus_write_byte_data(chip->client, |
| BH1770_PS_MEAS_RATE, |
| rate); |
| } |
| |
| /* InfraredLED is controlled by the chip during proximity scanning */ |
| static inline int bh1770_led_cfg(struct bh1770_chip *chip) |
| { |
| /* LED cfg, current for leds 1 and 2 */ |
| return i2c_smbus_write_byte_data(chip->client, |
| BH1770_I_LED, |
| (BH1770_LED1 << 6) | |
| (BH1770_LED_5mA << 3) | |
| chip->prox_led); |
| } |
| |
| /* |
| * Following two functions converts raw ps values from HW to normalized |
| * values. Purpose is to compensate differences between different sensor |
| * versions and variants so that result means about the same between |
| * versions. |
| */ |
| static inline u8 bh1770_psraw_to_adjusted(struct bh1770_chip *chip, u8 psraw) |
| { |
| u16 adjusted; |
| adjusted = (u16)(((u32)(psraw + chip->prox_const) * chip->prox_coef) / |
| BH1770_COEF_SCALER); |
| if (adjusted > BH1770_PROX_RANGE) |
| adjusted = BH1770_PROX_RANGE; |
| return adjusted; |
| } |
| |
| static inline u8 bh1770_psadjusted_to_raw(struct bh1770_chip *chip, u8 ps) |
| { |
| u16 raw; |
| |
| raw = (((u32)ps * BH1770_COEF_SCALER) / chip->prox_coef); |
| if (raw > chip->prox_const) |
| raw = raw - chip->prox_const; |
| else |
| raw = 0; |
| return raw; |
| } |
| |
| /* |
| * Following two functions converts raw lux values from HW to normalized |
| * values. Purpose is to compensate differences between different sensor |
| * versions and variants so that result means about the same between |
| * versions. Chip->mutex is kept when this is called. |
| */ |
| static int bh1770_prox_set_threshold(struct bh1770_chip *chip) |
| { |
| u8 tmp = 0; |
| |
| /* sysfs may call this when the chip is powered off */ |
| if (pm_runtime_suspended(&chip->client->dev)) |
| return 0; |
| |
| tmp = bh1770_psadjusted_to_raw(chip, chip->prox_threshold); |
| chip->prox_threshold_hw = tmp; |
| |
| return i2c_smbus_write_byte_data(chip->client, BH1770_PS_TH_LED1, |
| tmp); |
| } |
| |
| static inline u16 bh1770_lux_raw_to_adjusted(struct bh1770_chip *chip, u16 raw) |
| { |
| u32 lux; |
| lux = ((u32)raw * chip->lux_corr) / BH1770_LUX_CORR_SCALE; |
| return min(lux, (u32)BH1770_LUX_RANGE); |
| } |
| |
| static inline u16 bh1770_lux_adjusted_to_raw(struct bh1770_chip *chip, |
| u16 adjusted) |
| { |
| return (u32)adjusted * BH1770_LUX_CORR_SCALE / chip->lux_corr; |
| } |
| |
| /* chip->mutex is kept when this is called */ |
| static int bh1770_lux_update_thresholds(struct bh1770_chip *chip, |
| u16 threshold_hi, u16 threshold_lo) |
| { |
| u8 data[4]; |
| int ret; |
| |
| /* sysfs may call this when the chip is powered off */ |
| if (pm_runtime_suspended(&chip->client->dev)) |
| return 0; |
| |
| /* |
| * Compensate threshold values with the correction factors if not |
| * set to minimum or maximum. |
| * Min & max values disables interrupts. |
| */ |
| if (threshold_hi != BH1770_LUX_RANGE && threshold_hi != 0) |
| threshold_hi = bh1770_lux_adjusted_to_raw(chip, threshold_hi); |
| |
| if (threshold_lo != BH1770_LUX_RANGE && threshold_lo != 0) |
| threshold_lo = bh1770_lux_adjusted_to_raw(chip, threshold_lo); |
| |
| if (chip->lux_thres_hi_onchip == threshold_hi && |
| chip->lux_thres_lo_onchip == threshold_lo) |
| return 0; |
| |
| chip->lux_thres_hi_onchip = threshold_hi; |
| chip->lux_thres_lo_onchip = threshold_lo; |
| |
| data[0] = threshold_hi; |
| data[1] = threshold_hi >> 8; |
| data[2] = threshold_lo; |
| data[3] = threshold_lo >> 8; |
| |
| ret = i2c_smbus_write_i2c_block_data(chip->client, |
| BH1770_ALS_TH_UP_0, |
| ARRAY_SIZE(data), |
| data); |
| return ret; |
| } |
| |
| static int bh1770_lux_get_result(struct bh1770_chip *chip) |
| { |
| u16 data; |
| int ret; |
| |
| ret = i2c_smbus_read_byte_data(chip->client, BH1770_ALS_DATA_0); |
| if (ret < 0) |
| return ret; |
| |
| data = ret & 0xff; |
| ret = i2c_smbus_read_byte_data(chip->client, BH1770_ALS_DATA_1); |
| if (ret < 0) |
| return ret; |
| |
| chip->lux_data_raw = data | ((ret & 0xff) << 8); |
| |
| return 0; |
| } |
| |
| /* Calculate correction value which contains chip and device specific parts */ |
| static u32 bh1770_get_corr_value(struct bh1770_chip *chip) |
| { |
| u32 tmp; |
| /* Impact of glass attenuation correction */ |
| tmp = (BH1770_LUX_CORR_SCALE * chip->lux_ga) / BH1770_LUX_GA_SCALE; |
| /* Impact of chip factor correction */ |
| tmp = (tmp * chip->lux_cf) / BH1770_LUX_CF_SCALE; |
| /* Impact of Device specific calibration correction */ |
| tmp = (tmp * chip->lux_calib) / BH1770_CALIB_SCALER; |
| return tmp; |
| } |
| |
| static int bh1770_lux_read_result(struct bh1770_chip *chip) |
| { |
| bh1770_lux_get_result(chip); |
| return bh1770_lux_raw_to_adjusted(chip, chip->lux_data_raw); |
| } |
| |
| /* |
| * Chip on / off functions are called while keeping mutex except probe |
| * or remove phase |
| */ |
| static int bh1770_chip_on(struct bh1770_chip *chip) |
| { |
| int ret = regulator_bulk_enable(ARRAY_SIZE(chip->regs), |
| chip->regs); |
| if (ret < 0) |
| return ret; |
| |
| usleep_range(BH1770_STARTUP_DELAY, BH1770_STARTUP_DELAY * 2); |
| |
| /* Reset the chip */ |
| i2c_smbus_write_byte_data(chip->client, BH1770_ALS_CONTROL, |
| BH1770_SWRESET); |
| usleep_range(BH1770_RESET_TIME, BH1770_RESET_TIME * 2); |
| |
| /* |
| * ALS is started always since proximity needs als results |
| * for realibility estimation. |
| * Let's assume dark until the first ALS measurement is ready. |
| */ |
| chip->lux_data_raw = 0; |
| chip->prox_data = 0; |
| ret = i2c_smbus_write_byte_data(chip->client, |
| BH1770_ALS_CONTROL, BH1770_STANDALONE); |
| |
| /* Assume reset defaults */ |
| chip->lux_thres_hi_onchip = BH1770_LUX_RANGE; |
| chip->lux_thres_lo_onchip = 0; |
| |
| return ret; |
| } |
| |
| static void bh1770_chip_off(struct bh1770_chip *chip) |
| { |
| i2c_smbus_write_byte_data(chip->client, |
| BH1770_INTERRUPT, BH1770_DISABLE); |
| i2c_smbus_write_byte_data(chip->client, |
| BH1770_ALS_CONTROL, BH1770_STANDBY); |
| i2c_smbus_write_byte_data(chip->client, |
| BH1770_PS_CONTROL, BH1770_STANDBY); |
| regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); |
| } |
| |
| /* chip->mutex is kept when this is called */ |
| static int bh1770_prox_mode_control(struct bh1770_chip *chip) |
| { |
| if (chip->prox_enable_count) { |
| chip->prox_force_update = true; /* Force immediate update */ |
| |
| bh1770_lux_rate(chip, chip->lux_rate_index); |
| bh1770_prox_set_threshold(chip); |
| bh1770_led_cfg(chip); |
| bh1770_prox_rate(chip, PROX_BELOW_THRESHOLD); |
| bh1770_prox_interrupt_control(chip, BH1770_ENABLE); |
| i2c_smbus_write_byte_data(chip->client, |
| BH1770_PS_CONTROL, BH1770_STANDALONE); |
| } else { |
| chip->prox_data = 0; |
| bh1770_lux_rate(chip, chip->lux_rate_index); |
| bh1770_prox_interrupt_control(chip, BH1770_DISABLE); |
| i2c_smbus_write_byte_data(chip->client, |
| BH1770_PS_CONTROL, BH1770_STANDBY); |
| } |
| return 0; |
| } |
| |
| /* chip->mutex is kept when this is called */ |
| static int bh1770_prox_read_result(struct bh1770_chip *chip) |
| { |
| int ret; |
| bool above; |
| u8 mode; |
| |
| ret = i2c_smbus_read_byte_data(chip->client, BH1770_PS_DATA_LED1); |
| if (ret < 0) |
| goto out; |
| |
| if (ret > chip->prox_threshold_hw) |
| above = true; |
| else |
| above = false; |
| |
| /* |
| * when ALS levels goes above limit, proximity result may be |
| * false proximity. Thus ignore the result. With real proximity |
| * there is a shadow causing low als levels. |
| */ |
| if (chip->lux_data_raw > PROX_IGNORE_LUX_LIMIT) |
| ret = 0; |
| |
| chip->prox_data = bh1770_psraw_to_adjusted(chip, ret); |
| |
| /* Strong proximity level or force mode requires immediate response */ |
| if (chip->prox_data >= chip->prox_abs_thres || |
| chip->prox_force_update) |
| chip->prox_persistence_counter = chip->prox_persistence; |
| |
| chip->prox_force_update = false; |
| |
| /* Persistence filttering to reduce false proximity events */ |
| if (likely(above)) { |
| if (chip->prox_persistence_counter < chip->prox_persistence) { |
| chip->prox_persistence_counter++; |
| ret = -ENODATA; |
| } else { |
| mode = PROX_ABOVE_THRESHOLD; |
| ret = 0; |
| } |
| } else { |
| chip->prox_persistence_counter = 0; |
| mode = PROX_BELOW_THRESHOLD; |
| chip->prox_data = 0; |
| ret = 0; |
| } |
| |
| /* Set proximity detection rate based on above or below value */ |
| if (ret == 0) { |
| bh1770_prox_rate(chip, mode); |
| sysfs_notify(&chip->client->dev.kobj, NULL, "prox0_raw"); |
| } |
| out: |
| return ret; |
| } |
| |
| static int bh1770_detect(struct bh1770_chip *chip) |
| { |
| struct i2c_client *client = chip->client; |
| s32 ret; |
| u8 manu, part; |
| |
| ret = i2c_smbus_read_byte_data(client, BH1770_MANUFACT_ID); |
| if (ret < 0) |
| goto error; |
| manu = (u8)ret; |
| |
| ret = i2c_smbus_read_byte_data(client, BH1770_PART_ID); |
| if (ret < 0) |
| goto error; |
| part = (u8)ret; |
| |
| chip->revision = (part & BH1770_REV_MASK) >> BH1770_REV_SHIFT; |
| chip->prox_coef = BH1770_COEF_SCALER; |
| chip->prox_const = 0; |
| chip->lux_cf = BH1770_NEUTRAL_CF; |
| |
| if ((manu == BH1770_MANUFACT_ROHM) && |
| ((part & BH1770_PART_MASK) == BH1770_PART)) { |
| snprintf(chip->chipname, sizeof(chip->chipname), "BH1770GLC"); |
| return 0; |
| } |
| |
| if ((manu == BH1770_MANUFACT_OSRAM) && |
| ((part & BH1770_PART_MASK) == BH1770_PART)) { |
| snprintf(chip->chipname, sizeof(chip->chipname), "SFH7770"); |
| /* Values selected by comparing different versions */ |
| chip->prox_coef = 819; /* 0.8 * BH1770_COEF_SCALER */ |
| chip->prox_const = 40; |
| return 0; |
| } |
| |
| ret = -ENODEV; |
| error: |
| dev_dbg(&client->dev, "BH1770 or SFH7770 not found\n"); |
| |
| return ret; |
| } |
| |
| /* |
| * This work is re-scheduled at every proximity interrupt. |
| * If this work is running, it means that there hasn't been any |
| * proximity interrupt in time. Situation is handled as no-proximity. |
| * It would be nice to have low-threshold interrupt or interrupt |
| * when measurement and hi-threshold are both 0. But neither of those exists. |
| * This is a workaroud for missing HW feature. |
| */ |
| |
| static void bh1770_prox_work(struct work_struct *work) |
| { |
| struct bh1770_chip *chip = |
| container_of(work, struct bh1770_chip, prox_work.work); |
| |
| mutex_lock(&chip->mutex); |
| bh1770_prox_read_result(chip); |
| mutex_unlock(&chip->mutex); |
| } |
| |
| /* This is threaded irq handler */ |
| static irqreturn_t bh1770_irq(int irq, void *data) |
| { |
| struct bh1770_chip *chip = data; |
| int status; |
| int rate = 0; |
| |
| mutex_lock(&chip->mutex); |
| status = i2c_smbus_read_byte_data(chip->client, BH1770_ALS_PS_STATUS); |
| |
| /* Acknowledge interrupt by reading this register */ |
| i2c_smbus_read_byte_data(chip->client, BH1770_INTERRUPT); |
| |
| /* |
| * Check if there is fresh data available for als. |
| * If this is the very first data, update thresholds after that. |
| */ |
| if (status & BH1770_INT_ALS_DATA) { |
| bh1770_lux_get_result(chip); |
| if (unlikely(chip->lux_wait_result)) { |
| chip->lux_wait_result = false; |
| wake_up(&chip->wait); |
| bh1770_lux_update_thresholds(chip, |
| chip->lux_threshold_hi, |
| chip->lux_threshold_lo); |
| } |
| } |
| |
| /* Disable interrupt logic to guarantee acknowledgement */ |
| i2c_smbus_write_byte_data(chip->client, BH1770_INTERRUPT, |
| (0 << 1) | (0 << 0)); |
| |
| if ((status & BH1770_INT_ALS_INT)) |
| sysfs_notify(&chip->client->dev.kobj, NULL, "lux0_input"); |
| |
| if (chip->int_mode_prox && (status & BH1770_INT_LEDS_INT)) { |
| rate = prox_rates_ms[chip->prox_rate_threshold]; |
| bh1770_prox_read_result(chip); |
| } |
| |
| /* Re-enable interrupt logic */ |
| i2c_smbus_write_byte_data(chip->client, BH1770_INTERRUPT, |
| (chip->int_mode_lux << 1) | |
| (chip->int_mode_prox << 0)); |
| mutex_unlock(&chip->mutex); |
| |
| /* |
| * Can't cancel work while keeping mutex since the work uses the |
| * same mutex. |
| */ |
| if (rate) { |
| /* |
| * Simulate missing no-proximity interrupt 50ms after the |
| * next expected interrupt time. |
| */ |
| cancel_delayed_work_sync(&chip->prox_work); |
| schedule_delayed_work(&chip->prox_work, |
| msecs_to_jiffies(rate + 50)); |
| } |
| return IRQ_HANDLED; |
| } |
| |
| static ssize_t bh1770_power_state_store(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| unsigned long value; |
| ssize_t ret; |
| |
| if (strict_strtoul(buf, 0, &value)) |
| return -EINVAL; |
| |
| mutex_lock(&chip->mutex); |
| if (value) { |
| pm_runtime_get_sync(dev); |
| |
| ret = bh1770_lux_rate(chip, chip->lux_rate_index); |
| if (ret < 0) { |
| pm_runtime_put(dev); |
| goto leave; |
| } |
| |
| ret = bh1770_lux_interrupt_control(chip, BH1770_ENABLE); |
| if (ret < 0) { |
| pm_runtime_put(dev); |
| goto leave; |
| } |
| |
| /* This causes interrupt after the next measurement cycle */ |
| bh1770_lux_update_thresholds(chip, BH1770_LUX_DEF_THRES, |
| BH1770_LUX_DEF_THRES); |
| /* Inform that we are waiting for a result from ALS */ |
| chip->lux_wait_result = true; |
| bh1770_prox_mode_control(chip); |
| } else if (!pm_runtime_suspended(dev)) { |
| pm_runtime_put(dev); |
| } |
| ret = count; |
| leave: |
| mutex_unlock(&chip->mutex); |
| return ret; |
| } |
| |
| static ssize_t bh1770_power_state_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| return sprintf(buf, "%d\n", !pm_runtime_suspended(dev)); |
| } |
| |
| static ssize_t bh1770_lux_result_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| ssize_t ret; |
| long timeout; |
| |
| if (pm_runtime_suspended(dev)) |
| return -EIO; /* Chip is not enabled at all */ |
| |
| timeout = wait_event_interruptible_timeout(chip->wait, |
| !chip->lux_wait_result, |
| msecs_to_jiffies(BH1770_TIMEOUT)); |
| if (!timeout) |
| return -EIO; |
| |
| mutex_lock(&chip->mutex); |
| ret = sprintf(buf, "%d\n", bh1770_lux_read_result(chip)); |
| mutex_unlock(&chip->mutex); |
| |
| return ret; |
| } |
| |
| static ssize_t bh1770_lux_range_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| return sprintf(buf, "%d\n", BH1770_LUX_RANGE); |
| } |
| |
| static ssize_t bh1770_prox_enable_store(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| unsigned long value; |
| |
| if (strict_strtoul(buf, 0, &value)) |
| return -EINVAL; |
| |
| mutex_lock(&chip->mutex); |
| /* Assume no proximity. Sensor will tell real state soon */ |
| if (!chip->prox_enable_count) |
| chip->prox_data = 0; |
| |
| if (value) |
| chip->prox_enable_count++; |
| else if (chip->prox_enable_count > 0) |
| chip->prox_enable_count--; |
| else |
| goto leave; |
| |
| /* Run control only when chip is powered on */ |
| if (!pm_runtime_suspended(dev)) |
| bh1770_prox_mode_control(chip); |
| leave: |
| mutex_unlock(&chip->mutex); |
| return count; |
| } |
| |
| static ssize_t bh1770_prox_enable_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| ssize_t len; |
| |
| mutex_lock(&chip->mutex); |
| len = sprintf(buf, "%d\n", chip->prox_enable_count); |
| mutex_unlock(&chip->mutex); |
| return len; |
| } |
| |
| static ssize_t bh1770_prox_result_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| ssize_t ret; |
| |
| mutex_lock(&chip->mutex); |
| if (chip->prox_enable_count && !pm_runtime_suspended(dev)) |
| ret = sprintf(buf, "%d\n", chip->prox_data); |
| else |
| ret = -EIO; |
| mutex_unlock(&chip->mutex); |
| return ret; |
| } |
| |
| static ssize_t bh1770_prox_range_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| return sprintf(buf, "%d\n", BH1770_PROX_RANGE); |
| } |
| |
| static ssize_t bh1770_get_prox_rate_avail(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| int i; |
| int pos = 0; |
| for (i = 0; i < ARRAY_SIZE(prox_rates_hz); i++) |
| pos += sprintf(buf + pos, "%d ", prox_rates_hz[i]); |
| sprintf(buf + pos - 1, "\n"); |
| return pos; |
| } |
| |
| static ssize_t bh1770_get_prox_rate_above(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| return sprintf(buf, "%d\n", prox_rates_hz[chip->prox_rate_threshold]); |
| } |
| |
| static ssize_t bh1770_get_prox_rate_below(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| return sprintf(buf, "%d\n", prox_rates_hz[chip->prox_rate]); |
| } |
| |
| static int bh1770_prox_rate_validate(int rate) |
| { |
| int i; |
| |
| for (i = 0; i < ARRAY_SIZE(prox_rates_hz) - 1; i++) |
| if (rate >= prox_rates_hz[i]) |
| break; |
| return i; |
| } |
| |
| static ssize_t bh1770_set_prox_rate_above(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| unsigned long value; |
| |
| if (strict_strtoul(buf, 0, &value)) |
| return -EINVAL; |
| |
| mutex_lock(&chip->mutex); |
| chip->prox_rate_threshold = bh1770_prox_rate_validate(value); |
| mutex_unlock(&chip->mutex); |
| return count; |
| } |
| |
| static ssize_t bh1770_set_prox_rate_below(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| unsigned long value; |
| |
| if (strict_strtoul(buf, 0, &value)) |
| return -EINVAL; |
| |
| mutex_lock(&chip->mutex); |
| chip->prox_rate = bh1770_prox_rate_validate(value); |
| mutex_unlock(&chip->mutex); |
| return count; |
| } |
| |
| static ssize_t bh1770_get_prox_thres(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| return sprintf(buf, "%d\n", chip->prox_threshold); |
| } |
| |
| static ssize_t bh1770_set_prox_thres(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| unsigned long value; |
| int ret; |
| |
| if (strict_strtoul(buf, 0, &value)) |
| return -EINVAL; |
| if (value > BH1770_PROX_RANGE) |
| return -EINVAL; |
| |
| mutex_lock(&chip->mutex); |
| chip->prox_threshold = value; |
| ret = bh1770_prox_set_threshold(chip); |
| mutex_unlock(&chip->mutex); |
| if (ret < 0) |
| return ret; |
| return count; |
| } |
| |
| static ssize_t bh1770_prox_persistence_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| |
| return sprintf(buf, "%u\n", chip->prox_persistence); |
| } |
| |
| static ssize_t bh1770_prox_persistence_store(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t len) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| unsigned long value; |
| |
| if (strict_strtoul(buf, 0, &value)) |
| return -EINVAL; |
| |
| if (value > BH1770_PROX_MAX_PERSISTENCE) |
| return -EINVAL; |
| |
| chip->prox_persistence = value; |
| |
| return len; |
| } |
| |
| static ssize_t bh1770_prox_abs_thres_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| return sprintf(buf, "%u\n", chip->prox_abs_thres); |
| } |
| |
| static ssize_t bh1770_prox_abs_thres_store(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t len) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| unsigned long value; |
| |
| if (strict_strtoul(buf, 0, &value)) |
| return -EINVAL; |
| |
| if (value > BH1770_PROX_RANGE) |
| return -EINVAL; |
| |
| chip->prox_abs_thres = value; |
| |
| return len; |
| } |
| |
| static ssize_t bh1770_chip_id_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| return sprintf(buf, "%s rev %d\n", chip->chipname, chip->revision); |
| } |
| |
| static ssize_t bh1770_lux_calib_default_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| return sprintf(buf, "%u\n", BH1770_CALIB_SCALER); |
| } |
| |
| static ssize_t bh1770_lux_calib_show(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| ssize_t len; |
| |
| mutex_lock(&chip->mutex); |
| len = sprintf(buf, "%u\n", chip->lux_calib); |
| mutex_unlock(&chip->mutex); |
| return len; |
| } |
| |
| static ssize_t bh1770_lux_calib_store(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t len) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| unsigned long value; |
| u32 old_calib; |
| u32 new_corr; |
| |
| if (strict_strtoul(buf, 0, &value)) |
| return -EINVAL; |
| |
| mutex_lock(&chip->mutex); |
| old_calib = chip->lux_calib; |
| chip->lux_calib = value; |
| new_corr = bh1770_get_corr_value(chip); |
| if (new_corr == 0) { |
| chip->lux_calib = old_calib; |
| mutex_unlock(&chip->mutex); |
| return -EINVAL; |
| } |
| chip->lux_corr = new_corr; |
| /* Refresh thresholds on HW after changing correction value */ |
| bh1770_lux_update_thresholds(chip, chip->lux_threshold_hi, |
| chip->lux_threshold_lo); |
| |
| mutex_unlock(&chip->mutex); |
| |
| return len; |
| } |
| |
| static ssize_t bh1770_get_lux_rate_avail(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| int i; |
| int pos = 0; |
| for (i = 0; i < ARRAY_SIZE(lux_rates_hz); i++) |
| pos += sprintf(buf + pos, "%d ", lux_rates_hz[i]); |
| sprintf(buf + pos - 1, "\n"); |
| return pos; |
| } |
| |
| static ssize_t bh1770_get_lux_rate(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| return sprintf(buf, "%d\n", lux_rates_hz[chip->lux_rate_index]); |
| } |
| |
| static ssize_t bh1770_set_lux_rate(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| unsigned long rate_hz; |
| int ret, i; |
| |
| if (strict_strtoul(buf, 0, &rate_hz)) |
| return -EINVAL; |
| |
| for (i = 0; i < ARRAY_SIZE(lux_rates_hz) - 1; i++) |
| if (rate_hz >= lux_rates_hz[i]) |
| break; |
| |
| mutex_lock(&chip->mutex); |
| chip->lux_rate_index = i; |
| ret = bh1770_lux_rate(chip, i); |
| mutex_unlock(&chip->mutex); |
| |
| if (ret < 0) |
| return ret; |
| |
| return count; |
| } |
| |
| static ssize_t bh1770_get_lux_thresh_above(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| return sprintf(buf, "%d\n", chip->lux_threshold_hi); |
| } |
| |
| static ssize_t bh1770_get_lux_thresh_below(struct device *dev, |
| struct device_attribute *attr, char *buf) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| return sprintf(buf, "%d\n", chip->lux_threshold_lo); |
| } |
| |
| static ssize_t bh1770_set_lux_thresh(struct bh1770_chip *chip, u16 *target, |
| const char *buf) |
| { |
| int ret = 0; |
| unsigned long thresh; |
| |
| if (strict_strtoul(buf, 0, &thresh)) |
| return -EINVAL; |
| |
| if (thresh > BH1770_LUX_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_result) |
| ret = bh1770_lux_update_thresholds(chip, |
| chip->lux_threshold_hi, |
| chip->lux_threshold_lo); |
| mutex_unlock(&chip->mutex); |
| return ret; |
| |
| } |
| |
| static ssize_t bh1770_set_lux_thresh_above(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t len) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| int ret = bh1770_set_lux_thresh(chip, &chip->lux_threshold_hi, buf); |
| if (ret < 0) |
| return ret; |
| return len; |
| } |
| |
| static ssize_t bh1770_set_lux_thresh_below(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t len) |
| { |
| struct bh1770_chip *chip = dev_get_drvdata(dev); |
| int ret = bh1770_set_lux_thresh(chip, &chip->lux_threshold_lo, buf); |
| if (ret < 0) |
| return ret; |
| return len; |
| } |
| |
| static DEVICE_ATTR(prox0_raw_en, S_IRUGO | S_IWUSR, bh1770_prox_enable_show, |
| bh1770_prox_enable_store); |
| static DEVICE_ATTR(prox0_thresh_above1_value, S_IRUGO | S_IWUSR, |
| bh1770_prox_abs_thres_show, |
| bh1770_prox_abs_thres_store); |
| static DEVICE_ATTR(prox0_thresh_above0_value, S_IRUGO | S_IWUSR, |
| bh1770_get_prox_thres, |
| bh1770_set_prox_thres); |
| static DEVICE_ATTR(prox0_raw, S_IRUGO, bh1770_prox_result_show, NULL); |
| static DEVICE_ATTR(prox0_sensor_range, S_IRUGO, bh1770_prox_range_show, NULL); |
| static DEVICE_ATTR(prox0_thresh_above_count, S_IRUGO | S_IWUSR, |
| bh1770_prox_persistence_show, |
| bh1770_prox_persistence_store); |
| static DEVICE_ATTR(prox0_rate_above, S_IRUGO | S_IWUSR, |
| bh1770_get_prox_rate_above, |
| bh1770_set_prox_rate_above); |
| static DEVICE_ATTR(prox0_rate_below, S_IRUGO | S_IWUSR, |
| bh1770_get_prox_rate_below, |
| bh1770_set_prox_rate_below); |
| static DEVICE_ATTR(prox0_rate_avail, S_IRUGO, bh1770_get_prox_rate_avail, NULL); |
| |
| static DEVICE_ATTR(lux0_calibscale, S_IRUGO | S_IWUSR, bh1770_lux_calib_show, |
| bh1770_lux_calib_store); |
| static DEVICE_ATTR(lux0_calibscale_default, S_IRUGO, |
| bh1770_lux_calib_default_show, |
| NULL); |
| static DEVICE_ATTR(lux0_input, S_IRUGO, bh1770_lux_result_show, NULL); |
| static DEVICE_ATTR(lux0_sensor_range, S_IRUGO, bh1770_lux_range_show, NULL); |
| static DEVICE_ATTR(lux0_rate, S_IRUGO | S_IWUSR, bh1770_get_lux_rate, |
| bh1770_set_lux_rate); |
| static DEVICE_ATTR(lux0_rate_avail, S_IRUGO, bh1770_get_lux_rate_avail, NULL); |
| static DEVICE_ATTR(lux0_thresh_above_value, S_IRUGO | S_IWUSR, |
| bh1770_get_lux_thresh_above, |
| bh1770_set_lux_thresh_above); |
| static DEVICE_ATTR(lux0_thresh_below_value, S_IRUGO | S_IWUSR, |
| bh1770_get_lux_thresh_below, |
| bh1770_set_lux_thresh_below); |
| static DEVICE_ATTR(chip_id, S_IRUGO, bh1770_chip_id_show, NULL); |
| static DEVICE_ATTR(power_state, S_IRUGO | S_IWUSR, bh1770_power_state_show, |
| bh1770_power_state_store); |
| |
| |
| static struct attribute *sysfs_attrs[] = { |
| &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.attr, |
| &dev_attr_prox0_sensor_range.attr, |
| &dev_attr_prox0_raw_en.attr, |
| &dev_attr_prox0_thresh_above_count.attr, |
| &dev_attr_prox0_rate_above.attr, |
| &dev_attr_prox0_rate_below.attr, |
| &dev_attr_prox0_rate_avail.attr, |
| &dev_attr_prox0_thresh_above0_value.attr, |
| &dev_attr_prox0_thresh_above1_value.attr, |
| &dev_attr_chip_id.attr, |
| &dev_attr_power_state.attr, |
| NULL |
| }; |
| |
| static struct attribute_group bh1770_attribute_group = { |
| .attrs = sysfs_attrs |
| }; |
| |
| static int __devinit bh1770_probe(struct i2c_client *client, |
| const struct i2c_device_id *id) |
| { |
| struct bh1770_chip *chip; |
| int err; |
| |
| chip = kzalloc(sizeof *chip, GFP_KERNEL); |
| if (!chip) |
| return -ENOMEM; |
| |
| i2c_set_clientdata(client, chip); |
| chip->client = client; |
| |
| mutex_init(&chip->mutex); |
| init_waitqueue_head(&chip->wait); |
| INIT_DELAYED_WORK(&chip->prox_work, bh1770_prox_work); |
| |
| if (client->dev.platform_data == NULL) { |
| dev_err(&client->dev, "platform data is mandatory\n"); |
| err = -EINVAL; |
| goto fail1; |
| } |
| |
| chip->pdata = client->dev.platform_data; |
| chip->lux_calib = BH1770_LUX_NEUTRAL_CALIB_VALUE; |
| chip->lux_rate_index = BH1770_LUX_DEFAULT_RATE; |
| chip->lux_threshold_lo = BH1770_LUX_DEF_THRES; |
| chip->lux_threshold_hi = BH1770_LUX_DEF_THRES; |
| |
| if (chip->pdata->glass_attenuation == 0) |
| chip->lux_ga = BH1770_NEUTRAL_GA; |
| else |
| chip->lux_ga = chip->pdata->glass_attenuation; |
| |
| chip->prox_threshold = BH1770_PROX_DEF_THRES; |
| chip->prox_led = chip->pdata->led_def_curr; |
| chip->prox_abs_thres = BH1770_PROX_DEF_ABS_THRES; |
| chip->prox_persistence = BH1770_DEFAULT_PERSISTENCE; |
| chip->prox_rate_threshold = BH1770_PROX_DEF_RATE_THRESH; |
| chip->prox_rate = BH1770_PROX_DEFAULT_RATE; |
| chip->prox_data = 0; |
| |
| chip->regs[0].supply = reg_vcc; |
| chip->regs[1].supply = reg_vleds; |
| |
| 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(BH1770_STARTUP_DELAY, BH1770_STARTUP_DELAY * 2); |
| err = bh1770_detect(chip); |
| if (err < 0) |
| goto fail3; |
| |
| /* Start chip */ |
| bh1770_chip_on(chip); |
| pm_runtime_set_active(&client->dev); |
| pm_runtime_enable(&client->dev); |
| |
| chip->lux_corr = bh1770_get_corr_value(chip); |
| if (chip->lux_corr == 0) { |
| dev_err(&client->dev, "Improper correction values\n"); |
| err = -EINVAL; |
| goto fail3; |
| } |
| |
| if (chip->pdata->setup_resources) { |
| err = chip->pdata->setup_resources(); |
| if (err) { |
| err = -EINVAL; |
| goto fail3; |
| } |
| } |
| |
| err = sysfs_create_group(&chip->client->dev.kobj, |
| &bh1770_attribute_group); |
| if (err < 0) { |
| dev_err(&chip->client->dev, "Sysfs registration failed\n"); |
| goto fail4; |
| } |
| |
| /* |
| * Chip needs level triggered interrupt to work. However, |
| * level triggering doesn't work always correctly with power |
| * management. Select both |
| */ |
| err = request_threaded_irq(client->irq, NULL, |
| bh1770_irq, |
| IRQF_TRIGGER_FALLING | IRQF_ONESHOT | |
| IRQF_TRIGGER_LOW, |
| "bh1770", chip); |
| if (err) { |
| dev_err(&client->dev, "could not get IRQ %d\n", |
| client->irq); |
| goto fail5; |
| } |
| regulator_bulk_disable(ARRAY_SIZE(chip->regs), chip->regs); |
| return err; |
| fail5: |
| sysfs_remove_group(&chip->client->dev.kobj, |
| &bh1770_attribute_group); |
| fail4: |
| if (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 int __devexit bh1770_remove(struct i2c_client *client) |
| { |
| struct bh1770_chip *chip = i2c_get_clientdata(client); |
| |
| free_irq(client->irq, chip); |
| |
| sysfs_remove_group(&chip->client->dev.kobj, |
| &bh1770_attribute_group); |
| |
| if (chip->pdata->release_resources) |
| chip->pdata->release_resources(); |
| |
| cancel_delayed_work_sync(&chip->prox_work); |
| |
| if (!pm_runtime_suspended(&client->dev)) |
| bh1770_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; |
| } |
| |
| #ifdef CONFIG_PM |
| static int bh1770_suspend(struct device *dev) |
| { |
| struct i2c_client *client = container_of(dev, struct i2c_client, dev); |
| struct bh1770_chip *chip = i2c_get_clientdata(client); |
| |
| bh1770_chip_off(chip); |
| |
| return 0; |
| } |
| |
| static int bh1770_resume(struct device *dev) |
| { |
| struct i2c_client *client = container_of(dev, struct i2c_client, dev); |
| struct bh1770_chip *chip = i2c_get_clientdata(client); |
| int ret = 0; |
| |
| bh1770_chip_on(chip); |
| |
| if (!pm_runtime_suspended(dev)) { |
| /* |
| * If we were enabled at suspend time, it is expected |
| * everything works nice and smoothly |
| */ |
| ret = bh1770_lux_rate(chip, chip->lux_rate_index); |
| ret |= bh1770_lux_interrupt_control(chip, BH1770_ENABLE); |
| |
| /* This causes interrupt after the next measurement cycle */ |
| bh1770_lux_update_thresholds(chip, BH1770_LUX_DEF_THRES, |
| BH1770_LUX_DEF_THRES); |
| /* Inform that we are waiting for a result from ALS */ |
| chip->lux_wait_result = true; |
| bh1770_prox_mode_control(chip); |
| } |
| return ret; |
| } |
| |
| #else |
| #define bh1770_suspend NULL |
| #define bh1770_shutdown NULL |
| #define bh1770_resume NULL |
| #endif |
| |
| #ifdef CONFIG_PM_RUNTIME |
| static int bh1770_runtime_suspend(struct device *dev) |
| { |
| struct i2c_client *client = container_of(dev, struct i2c_client, dev); |
| struct bh1770_chip *chip = i2c_get_clientdata(client); |
| |
| bh1770_chip_off(chip); |
| |
| return 0; |
| } |
| |
| static int bh1770_runtime_resume(struct device *dev) |
| { |
| struct i2c_client *client = container_of(dev, struct i2c_client, dev); |
| struct bh1770_chip *chip = i2c_get_clientdata(client); |
| |
| bh1770_chip_on(chip); |
| |
| return 0; |
| } |
| #endif |
| |
| static const struct i2c_device_id bh1770_id[] = { |
| {"bh1770glc", 0 }, |
| {"sfh7770", 0 }, |
| {} |
| }; |
| |
| MODULE_DEVICE_TABLE(i2c, bh1770_id); |
| |
| static const struct dev_pm_ops bh1770_pm_ops = { |
| SET_SYSTEM_SLEEP_PM_OPS(bh1770_suspend, bh1770_resume) |
| SET_RUNTIME_PM_OPS(bh1770_runtime_suspend, bh1770_runtime_resume, NULL) |
| }; |
| |
| static struct i2c_driver bh1770_driver = { |
| .driver = { |
| .name = "bh1770glc", |
| .owner = THIS_MODULE, |
| .pm = &bh1770_pm_ops, |
| }, |
| .probe = bh1770_probe, |
| .remove = __devexit_p(bh1770_remove), |
| .id_table = bh1770_id, |
| }; |
| |
| module_i2c_driver(bh1770_driver); |
| |
| MODULE_DESCRIPTION("BH1770GLC / SFH7770 combined ALS and proximity sensor"); |
| MODULE_AUTHOR("Samu Onkalo, Nokia Corporation"); |
| MODULE_LICENSE("GPL v2"); |