drivers/misc: driver for bh1770glc / sfh7770 ALS and proximity sensor
authorSamu Onkalo <samu.p.onkalo@nokia.com>
Tue, 26 Oct 2010 21:22:37 +0000 (14:22 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 26 Oct 2010 23:52:14 +0000 (16:52 -0700)
This is a driver for ROHM BH1770GLC and OSRAM SFH7770 combined ALS and
proximity sensor.

Interface is sysfs based.  The driver uses interrupts to provide new data.
 The driver supports pm_runtime and regulator frameworks.

See Documentation/misc-devices/bh1770glc.txt for details

Signed-off-by: Samu Onkalo <samu.p.onkalo@nokia.com>
Acked-by: Jonathan Cameron <jic23@cam.ac.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
drivers/misc/Kconfig
drivers/misc/Makefile
drivers/misc/bh1770glc.c [new file with mode: 0644]
include/linux/i2c/bh1770glc.h [new file with mode: 0644]

index 3d57adfc87033f925484bfcd247e8ae67ff891f2..3b50106abfa583037b954eaec59b65edea4a9fb1 100644 (file)
@@ -315,6 +315,16 @@ config SENSORS_BH1780
          This driver can also be built as a module.  If so, the module
          will be called bh1780gli.
 
+config SENSORS_BH1770
+         tristate "BH1770GLC / SFH7770 combined ALS - Proximity sensor"
+         depends on I2C
+         ---help---
+           Say Y here if you want to build a driver for BH1770GLC (ROHM) or
+          SFH7770 (Osram) combined ambient light and proximity sensor chip.
+
+           To compile this driver as a module, choose M here: the
+           module will be called bh1770glc. If unsure, say N here.
+
 config HMC6352
        tristate "Honeywell HMC6352 compass"
        depends on I2C
index 9f2986b4da2fd7031c071ec3ac0a2ce636ffe4b4..5fed6ab533e2f5f1e663684427506c7c46c2e17b 100644 (file)
@@ -16,6 +16,7 @@ obj-$(CONFIG_TIFM_CORE)               += tifm_core.o
 obj-$(CONFIG_TIFM_7XX1)        += tifm_7xx1.o
 obj-$(CONFIG_PHANTOM)          += phantom.o
 obj-$(CONFIG_SENSORS_BH1780)   += bh1780gli.o
+obj-$(CONFIG_SENSORS_BH1770)   += bh1770glc.o
 obj-$(CONFIG_SGI_IOC4)         += ioc4.o
 obj-$(CONFIG_ENCLOSURE_SERVICES) += enclosure.o
 obj-$(CONFIG_KGDB_TESTS)       += kgdbts.o
diff --git a/drivers/misc/bh1770glc.c b/drivers/misc/bh1770glc.c
new file mode 100644 (file)
index 0000000..cee632e
--- /dev/null
@@ -0,0 +1,1413 @@
+/*
+ * 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;
+       size_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);
+               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,
+};
+
+static int __init bh1770_init(void)
+{
+       return i2c_add_driver(&bh1770_driver);
+}
+
+static void __exit bh1770_exit(void)
+{
+       i2c_del_driver(&bh1770_driver);
+}
+
+MODULE_DESCRIPTION("BH1770GLC / SFH7770 combined ALS and proximity sensor");
+MODULE_AUTHOR("Samu Onkalo, Nokia Corporation");
+MODULE_LICENSE("GPL v2");
+
+module_init(bh1770_init);
+module_exit(bh1770_exit);
diff --git a/include/linux/i2c/bh1770glc.h b/include/linux/i2c/bh1770glc.h
new file mode 100644 (file)
index 0000000..8b5e2df
--- /dev/null
@@ -0,0 +1,53 @@
+/*
+ * 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
+ *
+ */
+
+#ifndef __BH1770_H__
+#define __BH1770_H__
+
+/**
+ * struct bh1770_platform_data - platform data for bh1770glc driver
+ * @led_def_curr: IR led driving current.
+ * @glass_attenuation: Attenuation factor for covering window.
+ * @setup_resources: Call back for interrupt line setup function
+ * @release_resources: Call back for interrupte line release function
+ *
+ * Example of glass attenuation: 16384 * 385 / 100 means attenuation factor
+ * of 3.85. i.e. light_above_sensor = light_above_cover_window / 3.85
+ */
+
+struct bh1770_platform_data {
+#define BH1770_LED_5mA 0
+#define BH1770_LED_10mA        1
+#define BH1770_LED_20mA        2
+#define BH1770_LED_50mA        3
+#define BH1770_LED_100mA 4
+#define BH1770_LED_150mA 5
+#define BH1770_LED_200mA 6
+       __u8 led_def_curr;
+#define BH1770_NEUTRAL_GA 16384 /* 16384 / 16384 = 1 */
+       __u32 glass_attenuation;
+       int (*setup_resources)(void);
+       int (*release_resources)(void);
+};
+#endif