input: misc: add isl2902[89] driver
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 012128e..e008526 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -722,6 +722,18 @@
Say Y here to enable the CM3629 short distance proximity
sensor with ambient light sensor.
+config INPUT_ISL29028
+ tristate "ISL29028 proximity and light sensor"
+ help
+ Say Y here to enable the ISL29028 Short Distance Proximity
+ Sensor with Ambient Light Sensor.
+
+config INPUT_ISL29029
+ tristate "ISL29029 proximity and light sensor"
+ help
+ Say Y here to enable the ISL29029 Short Distance Proximity
+ Sensor with Ambient Light Sensor.
+
config SENSORS_R3GD20
tristate "ST R3GD20 3-axis gyroscope"
depends on I2C
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index 5791bfa..086de8a 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -69,5 +69,7 @@
obj-$(CONFIG_SENSORS_BMA250) += bma250.o
obj-$(CONFIG_SENSORS_BMA250_BOSCH) += bma250_bosch.o
obj-$(CONFIG_INPUT_CAPELLA_CM3629) += cm3629.o
+obj-$(CONFIG_INPUT_ISL29028) += isl29028.o
+obj-$(CONFIG_INPUT_ISL29029) += isl29029.o
obj-$(CONFIG_SENSORS_R3GD20) += r3gd20.o
obj-y += mpu3050/
diff --git a/drivers/input/misc/isl29028.c b/drivers/input/misc/isl29028.c
new file mode 100644
index 0000000..038d14a
--- /dev/null
+++ b/drivers/input/misc/isl29028.c
@@ -0,0 +1,2240 @@
+/* drivers/i2c/chips/isl29028.c - isl29028 optical sensors driver
+ *
+ * Copyright (C) 2010 HTC, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ *
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <linux/irq.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/miscdevice.h>
+#include <linux/lightsensor.h>
+#include <asm/uaccess.h>
+#include <asm/mach-types.h>
+#include <linux/isl29028.h>
+#include <linux/pl_sensor.h>
+#include <linux/capella_cm3602.h>
+#include <asm/setup.h>
+#include <linux/wakelock.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <mach/board.h>
+
+#define DPS(x...) printk(KERN_DEBUG "[PS][ISL29028] " x)
+#define DLS(x...) printk(KERN_DEBUG "[LS][ISL29028] " x)
+#define IPS(x...) printk(KERN_INFO "[PS][ISL29028] " x)
+#define ILS(x...) printk(KERN_INFO "[LS][ISL29028] " x)
+#define EPS(x...) printk(KERN_ERR "[PS][ISL29028 ERROR] " x)
+#define ELS(x...) printk(KERN_ERR "[LS][ISL29028 ERROR] " x)
+
+#define I2C_RETRY_COUNT 10
+
+/*#define DEBUG_PROXIMITY*/
+#define POLLING_PROXIMITY 1
+#define NO_IGNORE_BOOT_MODE 1
+
+#define INTR_DEFAULT 0x04
+#define CONFIG_DEFAULT 0x62
+
+#define INTR_MASK 0x77
+#define CONFIG_MASK 0x7B
+
+#define NEAR_DELAY_TIME 30000000
+
+#ifdef POLLING_PROXIMITY
+#define POLLING_DELAY 200
+#define TH_ADD 5
+#define BASE_VARIANCE 0
+#define ABNORMAL_LT 0x50
+#endif
+
+extern unsigned int als_kadc;
+struct timespec ts_start;
+struct rtc_time tm_start;
+
+struct timespec ts_end;
+struct rtc_time tm_end;
+
+static void sensor_irq_do_work(struct work_struct *work);
+static DECLARE_WORK(sensor_irq_work, sensor_irq_do_work);
+
+static void report_near_do_work(struct work_struct *w);
+static DECLARE_DELAYED_WORK(report_near_work, report_near_do_work);
+
+#ifdef DEBUG_PROXIMITY
+static void info_do_work(struct work_struct *w);
+static DECLARE_DELAYED_WORK(info_work, info_do_work);
+#endif
+
+#ifdef POLLING_PROXIMITY
+static void polling_do_work(struct work_struct *w);
+static DECLARE_DELAYED_WORK(polling_work, polling_do_work);
+#endif
+
+struct isl29028_info {
+ struct class *isl29028_class;
+ struct device *ls_dev;
+ struct device *ps_dev;
+
+ struct input_dev *ls_input_dev;
+ struct input_dev *ps_input_dev;
+
+ struct i2c_client *i2c_client;
+ struct workqueue_struct *lp_wq;
+
+ int intr_pin;
+
+ int als_enable;
+ int ls_enable_flag;
+
+ int ps_enable;
+ int ps_irq_flag;
+ uint8_t ps_lt;
+ uint8_t ps_ht;
+ uint8_t ps_B_val;
+ uint8_t ps_C_val;
+ uint8_t ps_A_val;
+ uint8_t ps_X_val;
+ int led;
+ uint8_t default_ps_lt;
+ uint8_t default_ps_ht;
+ int ps_pocket_mode;
+
+ uint8_t original_ht;
+ uint8_t original_lt;
+
+ uint16_t *adc_table;
+ uint16_t cali_table[10];
+ int irq;
+
+ int ls_calibrate;
+
+ int (*power)(int, uint8_t); /* power to the chip */
+ int (*calibrate_func)(int, int, int, int, int*, int*);
+
+ uint32_t als_kadc;
+ uint32_t als_gadc;
+ uint16_t golden_adc;
+
+ struct wake_lock ps_wake_lock;
+ int psensor_opened;
+ int lightsensor_opened;
+
+ uint8_t debounce;
+ int mfg_mode;
+
+ uint8_t *mapping_table;
+ uint8_t mapping_size;
+ uint8_t ps_base_index;
+
+ uint8_t enable_polling_ignore;
+};
+
+static struct isl29028_info *lp_info;
+
+/*static uint32_t als_kadc;*/
+static uint32_t ps_threshold;
+
+static int I2C_RxData(char *rxData, int length)
+{
+ uint8_t loop_i;
+ struct i2c_msg msgs[] = {
+ {
+ .addr = lp_info->i2c_client->addr,
+ .flags = 0,
+ .len = 1,
+ .buf = rxData,
+ },
+ {
+ .addr = lp_info->i2c_client->addr,
+ .flags = I2C_M_RD,
+ .len = length,
+ .buf = rxData,
+ },
+ };
+
+ for (loop_i = 0; loop_i < I2C_RETRY_COUNT; loop_i++) {
+ if (i2c_transfer(lp_info->i2c_client->adapter, msgs, 2) > 0)
+ break;
+
+ mdelay(10);
+ }
+
+ if (loop_i >= I2C_RETRY_COUNT) {
+ EPS("%s retry over %d\n",
+ __func__, I2C_RETRY_COUNT);
+ return -EIO;
+ }
+
+ return 0;
+}
+
+static int I2C_TxData(char *txData, int length)
+{
+ uint8_t loop_i;
+ struct i2c_msg msg[] = {
+ {
+ .addr = lp_info->i2c_client->addr,
+ .flags = 0,
+ .len = length,
+ .buf = txData,
+ },
+ };
+
+ for (loop_i = 0; loop_i < I2C_RETRY_COUNT; loop_i++) {
+ if (i2c_transfer(lp_info->i2c_client->adapter, msg, 1) > 0)
+ break;
+
+ mdelay(10);
+ }
+
+ if (loop_i >= I2C_RETRY_COUNT) {
+ EPS("%s retry over %d\n",
+ __func__, I2C_RETRY_COUNT);
+ return -EIO;
+ }
+
+ return 0;
+}
+
+static uint16_t get_ls_adc_value(uint16_t *raw_adc_value)
+{
+ uint16_t value, tmp_value;
+ struct isl29028_info *lpi = lp_info;
+ char buffer[3] = {0};
+ int ret = 0;
+
+ buffer[0] = ISL29028_LS_DATA1;
+ ret = I2C_RxData(buffer, 2);
+ if (ret < 0) {
+ ELS("%s: I2C_RxData fail\n", __func__);
+ return ret;
+ }
+ value = buffer[0];
+ tmp_value = buffer[1];
+
+ /*DLS("%s: value = 0x%03X, tmp_value = 0x%03X\n",
+ __func__, value, tmp_value);*/
+
+ value = value | tmp_value << 8;
+ *raw_adc_value = value;
+
+ if (value > 0xFFF) {
+ printk(KERN_WARNING "%s: get wrong value: 0x%X\n",
+ __func__, value);
+ return -1;
+ } else {
+ if (!lpi->ls_calibrate) {
+ value = value * lpi->als_gadc / lpi->als_kadc;
+ if (value > 0xFFF)
+ value = 0xFFF;
+ }
+ }
+
+ return value & 0x0FFF;
+}
+
+static uint16_t get_ps_adc_value(void)
+{
+ uint16_t value;
+ char buffer[2];
+ int ret = 0;
+
+ buffer[0] = ISL29028_PROX_DATA;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail\n", __func__);
+ return 0;
+ }
+ value = buffer[0];
+
+ return value & 0xff;
+}
+
+static int _isl29028_set_reg_bit(struct i2c_client *client, u8 set,
+ u8 cmd, u8 data)
+{
+ char buffer[2];
+ u8 value;
+ int ret = 0;
+
+ buffer[0] = cmd;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail\n", __func__);
+ return ret;
+ }
+ value = buffer[0];
+ /*DPS("Andy, %s: I2C_RxData[0x%x] = 0x%x\n",
+ __func__, cmd, value);*/
+
+ if (set)
+ value |= data;
+ else
+ value &= ~data;
+
+ buffer[0] = cmd;
+ buffer[1] = value;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0) {
+ EPS("%s: I2C_TxData fail\n", __func__);
+ return -EIO;
+ }
+
+ /* Debug use */
+ /*value = i2c_smbus_read_byte_data(client, cmd);
+ DPS("Andy, %s: After set reg bit[0x%x] = 0x%x\n",
+ __func__, cmd, value);*/
+
+ return ret;
+}
+
+static int set_lsensor_range(uint16_t lt, uint16_t ht)
+{
+ uint16_t value = 0;
+ int ret;
+ char buffer[4];
+
+ value = (lt >> 8) & 0x0f;
+ value |= ht << 4;
+ value &= 0xff;
+
+ buffer[0] = ISL29028_LS_TH1;
+ buffer[1] = lt & 0xFF;
+ buffer[2] = value;
+ buffer[3] = (ht >> 4) & 0xFF;
+ ret = I2C_TxData(buffer, 4);
+ if (ret < 0) {
+ ELS("%s : I2C_TxData fail\n", __func__);
+ return ret;
+ }
+
+/*
+ value = i2c_smbus_read_byte_data(lpi->i2c_client, ISL29028_LS_TH1);
+ DLS("TH1--------->0x%03X\n", value);
+ value = i2c_smbus_read_byte_data(lpi->i2c_client, ISL29028_LS_TH2);
+ DLS("TH2--------->0x%03X\n", value);
+ value = i2c_smbus_read_byte_data(lpi->i2c_client, ISL29028_LS_TH3);
+ DLS("TH3--------->0x%03X\n", value);
+*/
+ return ret;
+}
+
+static int set_psensor_range(u8 lt, u8 ht)
+{
+ int ret;
+ char buffer[3];
+ struct isl29028_info *lpi = lp_info;
+
+ if (!lpi) {
+ EPS("%s: lpi_info is empty\n", __func__);
+ return -EINVAL;
+ }
+
+ /*DPS("%s: PS ps_threshold = 0x%x\n",
+ __func__, ps_threshold);*/
+
+ if (ps_threshold >> 16 == PS_CALIBRATED) {
+ lt = (ps_threshold >> 8) & 0xFF;
+ ht = ps_threshold & 0xFF;
+ }
+
+ IPS("%s: Setting psensor range (0x%X, 0x%X)\n",
+ __func__, lt, ht);
+
+ buffer[0] = ISL29028_PROX_LT;
+ buffer[1] = lt;
+ buffer[2] = ht;
+ ret = I2C_TxData(buffer, 3);
+ if (ret < 0) {
+ EPS("%s : I2C_TxData fail\n", __func__);
+ return ret;
+ }
+
+ return ret;
+}
+
+static void set_psensor_th(u8 lt, u8 ht)
+{
+ struct isl29028_info *lpi = lp_info;
+
+ ps_threshold = (PS_CALIBRATED << 16) | (lt << 8) | ht;
+ /*DPS("set_ps_th: ps_threshold = 0x%08X\n",
+ ps_threshold);*/
+
+ lpi->ps_lt = lt;
+ lpi->ps_ht = ht;
+
+ set_psensor_range(lt, ht);
+}
+
+static void lightsensor_real_disable(struct isl29028_info *lpi)
+{
+ int ret;
+
+ if (lpi->als_enable) {
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 0,
+ ISL29028_CONFIGURE, ISL29028_ALS_EN);
+ if (ret < 0)
+ ELS("%s: disable auto light sensor fail\n",
+ __func__);
+ else
+ lpi->als_enable = 0;
+
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 0,
+ ISL29028_INTERRUPT, ISL29028_INT_ALS_FLAG);
+ if (ret < 0)
+ ELS("%s: clear lsensor intr flag fail\n", __func__);
+ }
+}
+
+static void report_psensor_input_event(struct isl29028_info *lpi,
+ uint16_t ps_adc)
+{
+ int val, ret;
+
+ getnstimeofday(&ts_end);
+ rtc_time_to_tm(ts_end.tv_sec, &tm_end);
+
+ if (lpi->debounce == 1)
+ cancel_delayed_work(&report_near_work);
+
+ if (ps_adc > lpi->ps_ht)
+ val = 0;
+ else if (ps_adc <= lpi->ps_ht)
+ val = 1;
+ else
+ IPS("%s: Proximity adc value not as expected!\n", __func__);
+
+ if ((lpi->enable_polling_ignore == 1) &&
+ (lpi->mfg_mode != NO_IGNORE_BOOT_MODE) && (val == 0)) {
+ if (((int)ts_start.tv_sec == (int)ts_end.tv_sec) &&
+ (!((ts_end.tv_nsec - ts_start.tv_nsec) >
+ NEAR_DELAY_TIME))) {
+ lpi->ps_pocket_mode = 1;
+ IPS("Ignore NEAR event");
+ lightsensor_real_disable(lpi);
+ return;
+ } else if ((((int)ts_end.tv_sec - (int)ts_start.tv_sec) == 1)
+ && (!(((1000000000 - ts_start.tv_nsec) +
+ ts_end.tv_nsec) > NEAR_DELAY_TIME))) {
+ lpi->ps_pocket_mode = 1;
+ IPS("Ignore NEAR event2");
+ lightsensor_real_disable(lpi);
+ return;
+ }
+ }
+
+ IPS("proximity %s\n", val ? "FAR" : "NEAR");
+
+ if (lpi->debounce == 1) {
+ if (val == 0) {
+ queue_delayed_work(lpi->lp_wq, &report_near_work,
+ msecs_to_jiffies(500));
+ return;
+ } else {
+ /* dummy report */
+ input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, -1);
+ input_sync(lpi->ps_input_dev);
+ }
+ }
+
+ /* 0 is close, 1 is far */
+ input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, val);
+ input_sync(lpi->ps_input_dev);
+ blocking_notifier_call_chain(&psensor_notifier_list, val+2, NULL);
+
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 0,
+ ISL29028_INTERRUPT, ISL29028_INT_ALS_FLAG);
+ if (ret < 0)
+ EPS("%s: clear lsensor intr flag fail\n", __func__);
+}
+
+static void report_lsensor_input_event(struct isl29028_info *lpi)
+{
+ uint16_t adc_value, raw_adc_value;
+ int level = 0, i, ret;
+
+ adc_value = get_ls_adc_value(&raw_adc_value);
+
+ for (i = 0; i < 10; i++) {
+ if (adc_value <= (*(lpi->adc_table + i))) {
+ level = i;
+ if (*(lpi->adc_table + i))
+ break;
+ }
+ }
+
+ if (i == 0 && (adc_value >= (*(lpi->cali_table + i)))) {
+ ret = set_lsensor_range((i == 0) ? 0 :
+ *(lpi->cali_table + (i - 1)) + 1,
+ adc_value + 1);
+ if (ret < 0)
+ ELS("%s: set_lsensor_range fail\n", __func__);
+
+ ILS("ALS_ADC = 0x%03X, Level = %d, l_thd equal 0, h_thd(adc_value+1) = 0x%x \n",
+ adc_value, level, adc_value + 1);
+ } else if (i < 10) {
+ ret = set_lsensor_range((i == 0) ? 0 :
+ *(lpi->cali_table + (i - 1)) + 1,
+ *(lpi->cali_table + i));
+ if (ret < 0)
+ ELS("%s: set_lsensor_range fail\n", __func__);
+
+ if (i == 0)
+ ILS("ALS_ADC = 0x%03X, Level = %d, l_thd equal 0, h_thd = 0x%x \n",
+ adc_value, level, *(lpi->cali_table + i));
+ else
+ ILS("ALS_ADC = 0x%03X, Level = %d, l_thd equal = 0x%x, h_thd = 0x%x \n",
+ adc_value, level, *(lpi->cali_table + (i - 1)) + 1, *(lpi->cali_table + i));
+ } else
+ ILS("%s: i = %d\n", __func__, i);
+
+
+ /*DLS("%s: RAW ADC = 0x%03X\n", __func__, raw_adc_value);*/
+ input_report_abs(lpi->ls_input_dev, ABS_MISC, level);
+ input_sync(lpi->ls_input_dev);
+
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 0,
+ ISL29028_INTERRUPT, ISL29028_INT_ALS_FLAG);
+ if (ret < 0)
+ ELS("%s: clear lsensor intr flag fail\n", __func__);
+
+}
+
+static int lightsensor_real_enable(struct isl29028_info *lpi)
+{
+ int ret = -1;
+
+ /*DLS("%s\n", __func__);*/
+
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 1,
+ ISL29028_CONFIGURE, ISL29028_ALS_EN);
+ if (ret < 0)
+ ELS("%s: _isl29028_set_reg_bit error\n", __func__);
+ else {
+ lpi->als_enable = 1;
+ input_report_abs(lpi->ls_input_dev, ABS_MISC, -1);
+ input_sync(lpi->ls_input_dev);
+
+ report_lsensor_input_event(lpi);
+ }
+
+ return ret;
+}
+
+static int is_only_ls_enabled(uint8_t reg_config)
+{
+ int ret = ((reg_config & ISL29028_ALS_EN) &&
+ (!(reg_config & ISL29028_PROX_EN)));
+
+ return ret;
+}
+
+static void __report_psensor_near(struct isl29028_info *lpi, uint16_t ps_adc)
+{
+ int ret;
+
+ irq_set_irq_type(lpi->irq, IRQF_TRIGGER_HIGH);
+
+ if (lpi->als_enable) {
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 0,
+ ISL29028_CONFIGURE, ISL29028_ALS_EN);
+ if (ret < 0)
+ EPS("%s: disable auto light sensor"
+ " fail\n", __func__);
+ else
+ lpi->als_enable = 0;
+ }
+
+ report_psensor_input_event(lpi, ps_adc);
+ lpi->ps_irq_flag = 1;
+}
+
+static void judge_and_enable_lightsensor(struct isl29028_info *lpi)
+{
+ int ret;
+
+ if (lpi->ls_enable_flag && (lpi->ps_irq_flag == 0)) {
+ ret = lightsensor_real_enable(lpi);
+ if (ret < 0)
+ ELS("%s: lightsensor_real_enable: not enabled!\n",
+ __func__);
+ }
+}
+
+static void __report_psensor_far(struct isl29028_info *lpi, uint16_t ps_adc)
+{
+ irq_set_irq_type(lpi->irq, IRQF_TRIGGER_LOW);
+
+ report_psensor_input_event(lpi, ps_adc);
+
+ lpi->ps_irq_flag = 0;
+
+ judge_and_enable_lightsensor(lpi);
+}
+
+static void clear_intr_flags(uint8_t intrrupt, struct isl29028_info *lpi)
+{
+ int ret;
+
+ irq_set_irq_type(lpi->irq, IRQF_TRIGGER_LOW);
+
+ if (intrrupt & ISL29028_INT_ALS_FLAG) {
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 0,
+ ISL29028_INTERRUPT, ISL29028_INT_ALS_FLAG);
+ if (ret < 0)
+ ELS("%s: clear lsensor intr flag fail\n",
+ __func__);
+ }
+ if (intrrupt & ISL29028_INT_PROX_FLAG) {
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 0,
+ ISL29028_INTERRUPT, ISL29028_INT_PROX_FLAG);
+ if (ret < 0)
+ EPS("%s: clear psensor intr flag fail\n",
+ __func__);
+ }
+}
+
+static void check_and_recover(struct isl29028_info *lpi)
+{
+ uint8_t intrrupt, reg_config;
+ uint8_t def_intrrupt, def_reg_config;
+ char buffer[2];
+ int ret = 0;
+ uint8_t orig_enabled;
+
+ buffer[0] = ISL29028_INTERRUPT;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail (ISL29028_INTERRUPT)\n",
+ __func__);
+ return;
+ }
+ intrrupt = buffer[0];
+
+ buffer[0] = ISL29028_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail (ISL29028_CONFIGURE)\n",
+ __func__);
+ return;
+ }
+ reg_config = buffer[0];
+
+ def_intrrupt = (intrrupt & INTR_MASK);
+ def_reg_config = (reg_config & CONFIG_MASK);
+ orig_enabled = ((reg_config & ISL29028_PROX_EN) |
+ (reg_config & ISL29028_ALS_EN));
+
+ if (def_intrrupt != INTR_DEFAULT) {
+ buffer[0] = ISL29028_INTERRUPT;
+ buffer[1] = INTR_DEFAULT;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : Set LPS INTR fail\n", __func__);
+ }
+
+ if (def_reg_config != CONFIG_DEFAULT) {
+ buffer[0] = ISL29028_CONFIGURE;
+ buffer[1] = (CONFIG_DEFAULT | orig_enabled);
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : Set LPS Configuration fail\n",
+ __func__);
+ }
+}
+
+static void sensor_irq_do_work(struct work_struct *work)
+{
+ uint8_t intrrupt, reg_config;
+ struct isl29028_info *lpi = lp_info;
+ char buffer[2];
+ int ret = 0;
+ int value1 = -1;
+ static int count;
+
+ uint16_t ps_adc = 0;
+
+ wake_lock_timeout(&(lpi->ps_wake_lock), 3*HZ);
+
+ value1 = gpio_get_value(lpi->intr_pin);
+ /*DPS("%s: lpi->intr_pin = %d\n", __func__, value1);*/
+
+ buffer[0] = ISL29028_INTERRUPT;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData %d fail (ISL29028_INTERRUPT)\n",
+ __func__, count);
+
+ if (count < 5)
+ count++;
+ else {
+ count = 0;
+ input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, 1);
+ input_sync(lpi->ps_input_dev);
+ blocking_notifier_call_chain(&psensor_notifier_list, 3, NULL);
+ }
+
+ enable_irq(lpi->irq);
+ return;
+ }
+ intrrupt = buffer[0];
+
+ buffer[0] = ISL29028_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData %d fail (ISL29028_CONFIGURE)\n",
+ __func__, count);
+
+ if (count < 5)
+ count++;
+ else {
+ count = 0;
+ input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, 1);
+ input_sync(lpi->ps_input_dev);
+ blocking_notifier_call_chain(&psensor_notifier_list, 3, NULL);
+ }
+
+ enable_irq(lpi->irq);
+ return;
+ }
+ reg_config = buffer[0];
+ IPS("isl_irq: CONFIG = 0x%x, INT_PIN = %d, INT = 0x%x\n",
+ reg_config, value1, intrrupt);
+
+ if (reg_config & ISL29028_PROX_EN) {
+
+ ps_adc = get_ps_adc_value();
+ DPS("isl_irq: ps_adc = 0x%02X, ps_lt = 0x%02X, ps_ht ="
+ " 0x%02X\n", ps_adc, lpi->ps_lt, lpi->ps_ht);
+
+ if (reg_config & ISL29028_ALS_EN) {
+ if (ps_adc > lpi->ps_ht)
+ __report_psensor_near(lpi, ps_adc);
+ else if (intrrupt & ISL29028_INT_ALS_FLAG)
+ report_lsensor_input_event(lpi);
+ else if (ps_adc <= lpi->ps_ht)
+ __report_psensor_far(lpi, ps_adc);
+ else {
+ DPS("%s: Suppose ps and ls enabled or "
+ "LS interrupt, but NO!\n", __func__);
+ clear_intr_flags(intrrupt, lpi);
+ }
+ } else {
+ if (ps_adc < lpi->ps_lt)
+ __report_psensor_far(lpi, ps_adc);
+ else if (ps_adc > lpi->ps_ht)
+ __report_psensor_near(lpi, ps_adc);
+ else {
+ if (value1 == 0)
+ __report_psensor_near(lpi,
+ (lpi->ps_ht + 1));
+ else
+ __report_psensor_far(lpi,
+ (lpi->ps_lt - 1));
+ }
+ }
+ } else if (is_only_ls_enabled(reg_config))
+ report_lsensor_input_event(lpi);
+ else {
+ DPS("%s: ps and ls both disabled!\n", __func__);
+ clear_intr_flags(intrrupt, lpi);
+ }
+
+ check_and_recover(lpi);
+
+ enable_irq(lpi->irq);
+
+ count = 0;
+}
+
+static void report_near_do_work(struct work_struct *w)
+{
+ struct isl29028_info *lpi = lp_info;
+ int ret;
+
+ DPS("%s\n", __func__);
+
+ input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, 0);
+ input_sync(lpi->ps_input_dev);
+
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 0,
+ ISL29028_INTERRUPT, ISL29028_INT_ALS_FLAG);
+ if (ret < 0)
+ EPS("%s: clear lsensor intr flag fail\n", __func__);
+
+ blocking_notifier_call_chain(&psensor_notifier_list, 2, NULL);
+}
+
+/*#ifdef DEBUG_PROXIMITY*/
+static void info_do_work(struct work_struct *w)
+{
+ struct isl29028_info *lpi = lp_info;
+ uint8_t intrrupt, reg_config;
+ int ret, i = 0, level = 0;
+ int value1;
+ uint16_t value, TH1_value, TH2_value, TH3_value;
+ uint16_t PROX_LT, PROX_HT;
+ char buffer[4] = "";
+ uint16_t adc_value, raw_adc_value;
+ uint16_t value_of_test1, value_of_test2;
+
+ buffer[0] = ISL29028_TEST1;
+ ret = I2C_RxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s: I2C_RxData fail (ISL29028_TEST1)\n",
+ __func__);
+ value_of_test1 = buffer[0];
+ value_of_test2 = buffer[1];
+
+ DPS("\n");
+ DPS("%s: TEST1 = 0x%02x, TEST2 = 0x%02x\n",
+ __func__, value_of_test1, value_of_test2);
+
+ value1 = gpio_get_value(lpi->intr_pin);
+ DPS("%s: intr_pin = %d, value of intr_pin = %d\n",
+ __func__, lpi->intr_pin, value1);
+
+ value = get_ps_adc_value();
+
+ DPS("%s: PS_ADC[0x%03X], ENABLE = %d\n",
+ __func__, value, lpi->ps_enable);
+
+ adc_value = get_ls_adc_value(&raw_adc_value);
+
+ for (i = 0; i < 10; i++) {
+ if (adc_value <= (*(lpi->adc_table + i))) {
+ level = i;
+ if (*(lpi->adc_table + i))
+ break;
+ }
+ }
+
+ DLS("%s: LS_ADC = 0x%03X, Level = %d \n", __func__, adc_value, level);
+ DLS("%s: LS_RAW ADC = 0x%03X\n", __func__, raw_adc_value);
+
+ buffer[0] = ISL29028_LS_TH1;
+ ret = I2C_RxData(buffer, 3);
+ if (ret < 0) {
+ ELS("%s: I2C_RxData fail (ISL29028_LS_TH1)\n",
+ __func__);
+ return;
+ }
+ TH1_value = buffer[0];
+ TH2_value = buffer[1];
+ TH3_value = buffer[2];
+
+ DLS("%s: LS_LOW_TH--------->0x%01X%02X\n", __func__,
+ (TH2_value & 0xF), TH1_value);
+ DLS("%s: LS_HIGH_TH--------->0x%02X%01X\n", __func__,
+ TH3_value, ((TH2_value >> 4) & 0xF));
+
+ buffer[0] = ISL29028_PROX_LT;
+ ret = I2C_RxData(buffer, 2);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail (ISL29028_PROX_LT)\n",
+ __func__);
+ return;
+ }
+ PROX_LT = buffer[0];
+ PROX_HT = buffer[1];
+
+ DPS("%s: PROX_LT--------->0x%02X\n", __func__, PROX_LT);
+ DPS("%s: PROX_HT--------->0x%02X\n", __func__, PROX_HT);
+
+ buffer[0] = ISL29028_INTERRUPT;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail (ISL29028_INTERRUPT)\n",
+ __func__);
+ return;
+ }
+ intrrupt = buffer[0];
+
+ buffer[0] = ISL29028_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail (ISL29028_CONFIGURE)\n",
+ __func__);
+ return;
+ }
+ reg_config = buffer[0];
+
+ DPS("%s: reg_config = 0x%x\n", __func__, reg_config);
+ DPS("%s: intrrupt = 0x%x\n", __func__, intrrupt);
+
+ /*queue_delayed_work(lpi->lp_wq, &info_work,
+ msecs_to_jiffies(3000));*/
+}
+/*#endif*/
+
+static uint16_t mid_value(uint16_t value[], uint16_t size)
+{
+ int i = 0, j = 0;
+ uint16_t temp = 0;
+
+ if (size < 3)
+ return 0;
+
+ for (i = 0; i < (size - 2); i++)
+ for (j = (i + 1); j < (size - 1); j++)
+ if (value[i] > value[j]) {
+ temp = value[i];
+ value[i] = value[j];
+ value[j] = temp;
+ }
+ return value[((size - 1) / 2)];
+}
+
+static uint16_t get_stable_ps_adc_value(void)
+{
+ uint16_t value[3] = {0, 0, 0}, mid_val = 0;
+ char buffer[2];
+ int ret = 0;
+
+ buffer[0] = ISL29028_PROX_DATA;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail\n", __func__);
+ return 0;
+ }
+ value[0] = buffer[0];
+
+ buffer[0] = ISL29028_PROX_DATA;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail\n", __func__);
+ return 0;
+ }
+ value[1] = buffer[0];
+
+ buffer[0] = ISL29028_PROX_DATA;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail\n", __func__);
+ return 0;
+ }
+ value[2] = buffer[0];
+
+ /*DPS("Sta_ps: Before sort, value[0, 1, 2] = [0x%x, 0x%x, 0x%x]",
+ value[0], value[1], value[2]);*/
+ mid_val = mid_value(value, 3);
+ /*DPS("Sta_ps: After sort, value[0, 1, 2] = [0x%x, 0x%x, 0x%x]",
+ value[0], value[1], value[2]);*/
+
+ return mid_val & 0xFF;
+}
+
+#ifdef POLLING_PROXIMITY
+static void polling_do_work(struct work_struct *w)
+{
+ struct isl29028_info *lpi = lp_info;
+ uint16_t ps_adc = 0;
+ int i = 0;
+
+ /*DPS("lpi->ps_enable = %d\n", lpi->ps_enable);*/
+ if (lpi->ps_enable == 0)
+ return;
+
+ ps_adc = get_stable_ps_adc_value();
+ /*DPS("polling: ps_adc = 0x%02X, ps_next_base_value = 0x%02X,"
+ " ps_lt = 0x%02X, ps_ht = 0x%02X\n",
+ ps_adc, lpi->mapping_table[lpi->ps_base_index],
+ lpi->ps_lt, lpi->ps_ht);*/
+
+ if (ps_adc == 0) {
+ queue_delayed_work(lpi->lp_wq, &polling_work,
+ msecs_to_jiffies(POLLING_DELAY));
+ return;
+ }
+
+ for (i = lpi->ps_base_index; i >= 1; i--) {
+ if (ps_adc > lpi->mapping_table[i])
+ break;
+ else if ((ps_adc > lpi->mapping_table[(i-1)]) &&
+ (ps_adc <= lpi->mapping_table[i])) {
+ lpi->ps_base_index = (i-1);
+
+ if (i == (lpi->mapping_size - 1))
+ set_psensor_th(0xFE, 0xFF);
+ else
+ set_psensor_th((lpi->mapping_table[i] +
+ TH_ADD), (lpi->mapping_table[i] +
+ TH_ADD + 1));
+ break;
+ }
+ }
+
+ queue_delayed_work(lpi->lp_wq, &polling_work,
+ msecs_to_jiffies(POLLING_DELAY));
+}
+#endif
+
+static irqreturn_t isl29028_irq_handler(int irq, void *data)
+{
+ struct isl29028_info *lpi = data;
+
+ /*int value1;
+ value1 = gpio_get_value(lpi->intr_pin);
+ DPS("\n%s: intr_pin = %d, value of intr_pin = %d\n",
+ __func__, lpi->intr_pin, value1);*/
+ if (lpi->ps_enable == 1)
+ IPS("%s\n", __func__);
+
+ disable_irq_nosync(lpi->irq);
+ queue_work_on(0, lpi->lp_wq, &sensor_irq_work);
+
+ return IRQ_HANDLED;
+}
+
+static int als_power(int enable)
+{
+ struct isl29028_info *lpi = lp_info;
+
+ if (lpi->power)
+ lpi->power(LS_PWR_ON, 1);
+
+ return 0;
+}
+
+static int psensor_enable(struct isl29028_info *lpi)
+{
+ int ret;
+#ifdef POLLING_PROXIMITY
+ uint16_t ps_adc = 0;
+#endif
+
+ IPS("%s\n", __func__);
+ if (lpi->ps_enable) {
+ DPS("%s: already enabled\n", __func__);
+ return 0;
+ }
+
+ blocking_notifier_call_chain(&psensor_notifier_list, 1, NULL);
+
+ /* dummy report */
+ input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, -1);
+ input_sync(lpi->ps_input_dev);
+
+ if (lpi->power)
+ lpi->power(PS_PWR_ON, 1);
+
+ __report_psensor_far(lpi, (lpi->ps_lt - 1));
+
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 1,
+ ISL29028_CONFIGURE, ISL29028_PROX_EN);
+ if (ret < 0) {
+ EPS("%s: enable psensor fail\n", __func__);
+ return ret;
+ }
+
+ getnstimeofday(&ts_start);
+ rtc_time_to_tm(ts_start.tv_sec, &tm_start);
+
+#ifdef DEBUG_PROXIMITY
+ queue_delayed_work(lpi->lp_wq, &info_work,
+ msecs_to_jiffies(3000));
+#endif
+
+ lpi->ps_enable = 1;
+
+ ret = irq_set_irq_wake(lpi->irq, 1);
+ if (ret < 0) {
+ EPS("%s: failed to disable irq %d as a wake interrupt\n",
+ __func__, lpi->irq);
+ return ret;
+ }
+
+#ifdef POLLING_PROXIMITY
+ if ((lpi->enable_polling_ignore == 1) &&
+ (lpi->mfg_mode != NO_IGNORE_BOOT_MODE)) {
+ ps_adc = get_stable_ps_adc_value();
+ if ((lpi->mapping_table != NULL) &&
+ ((ps_adc >= (lpi->ps_lt - 1)) ||
+ (lpi->ps_lt >= ABNORMAL_LT)))
+ queue_delayed_work(lpi->lp_wq, &polling_work,
+ msecs_to_jiffies(POLLING_DELAY));
+ }
+#endif
+ return ret;
+}
+
+static int psensor_disable(struct isl29028_info *lpi)
+{
+ int ret = -EIO;
+
+#ifdef DEBUG_PROXIMITY
+ cancel_delayed_work(&info_work);
+#endif
+
+ lpi->ps_irq_flag = 0;
+ lpi->ps_pocket_mode = 0;
+
+ judge_and_enable_lightsensor(lpi);
+
+ IPS("%s\n", __func__);
+ if (!lpi->ps_enable) {
+ DPS("%s: already disabled\n", __func__);
+ return 0;
+ }
+
+ ret = irq_set_irq_wake(lpi->irq, 0);
+ if (ret < 0) {
+ EPS("%s: failed to disable irq %d as a wake interrupt\n",
+ __func__, lpi->irq);
+ return ret;
+ }
+
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 0,
+ ISL29028_CONFIGURE, ISL29028_PROX_EN);
+ if (ret < 0) {
+ EPS("%s: disable psensor fail\n", __func__);
+ return ret;
+ }
+
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 0,
+ ISL29028_INTERRUPT, ISL29028_INT_PROX_FLAG);
+ if (ret < 0) {
+ EPS("%s: clear proximity INT flag fail\n", __func__);
+ return ret;
+ }
+
+ blocking_notifier_call_chain(&psensor_notifier_list, 0, NULL);
+
+ irq_set_irq_type(lpi->irq, IRQF_TRIGGER_LOW);
+
+ if (lpi->power)
+ lpi->power(PS_PWR_ON, 0);
+
+ lpi->ps_enable = 0;
+
+#ifdef POLLING_PROXIMITY
+ if ((lpi->enable_polling_ignore == 1) &&
+ (lpi->mfg_mode != NO_IGNORE_BOOT_MODE)) {
+ cancel_delayed_work(&polling_work);
+ lpi->ps_base_index = (lpi->mapping_size - 1);
+
+ set_psensor_th(lpi->original_lt, lpi->original_ht);
+ }
+#endif
+ return ret;
+}
+
+static int psensor_open(struct inode *inode, struct file *file)
+{
+ struct isl29028_info *lpi = lp_info;
+
+ DPS("%s\n", __func__);
+
+ if (lpi->psensor_opened)
+ return -EBUSY;
+
+ lpi->psensor_opened = 1;
+
+ return 0;
+}
+
+static int psensor_release(struct inode *inode, struct file *file)
+{
+ struct isl29028_info *lpi = lp_info;
+
+ DPS("%s\n", __func__);
+
+ lpi->psensor_opened = 0;
+
+ return psensor_disable(lpi);
+}
+
+static long psensor_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ int val;
+ struct isl29028_info *lpi = lp_info;
+
+ DPS("%s cmd %d\n", __func__, _IOC_NR(cmd));
+
+ switch (cmd) {
+ case CAPELLA_CM3602_IOCTL_ENABLE:
+ if (get_user(val, (unsigned long __user *)arg))
+ return -EFAULT;
+ if (val)
+ return psensor_enable(lpi);
+ else
+ return psensor_disable(lpi);
+ break;
+ case CAPELLA_CM3602_IOCTL_GET_ENABLED:
+ return put_user(lpi->ps_enable, (unsigned long __user *)arg);
+ break;
+ default:
+ IPS("%s: invalid cmd %d\n", __func__, _IOC_NR(cmd));
+ return -EINVAL;
+ }
+}
+
+static const struct file_operations psensor_fops = {
+ .owner = THIS_MODULE,
+ .open = psensor_open,
+ .release = psensor_release,
+ .unlocked_ioctl = psensor_ioctl
+};
+
+static struct miscdevice psensor_misc = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = "cm3602",
+ .fops = &psensor_fops
+};
+
+static void lightsensor_set_kvalue(struct isl29028_info *lpi)
+{
+ if (!lpi) {
+ ELS("%s: ls_info is empty\n", __func__);
+ return;
+ }
+
+ ILS("%s: ALS calibrated als_kadc=0x%x\n",
+ __func__, als_kadc);
+
+ if (als_kadc >> 16 == ALS_CALIBRATED)
+ lpi->als_kadc = als_kadc & 0xFFFF;
+ else {
+ lpi->als_kadc = 0;
+ ILS("%s: no ALS calibrated\n", __func__);
+ }
+
+ if (lpi->als_kadc && lpi->golden_adc > 0) {
+ lpi->als_kadc = (lpi->als_kadc > 0 && lpi->als_kadc < 0x1000) ?
+ lpi->als_kadc : lpi->golden_adc;
+ lpi->als_gadc = lpi->golden_adc;
+ } else {
+ lpi->als_kadc = 1;
+ lpi->als_gadc = 1;
+ }
+ ILS("%s: als_kadc=0x%x, als_gadc=0x%x\n",
+ __func__, lpi->als_kadc, lpi->als_gadc);
+}
+
+static void psensor_set_kvalue(struct isl29028_info *lpi)
+{
+ int thl_value, thh_value;
+
+ IPS("%s: PS calibrated ps_kparam1 = 0x%x, ps_kparam2 = 0x%x\n",
+ __func__, ps_kparam1, ps_kparam2);
+
+ if (ps_kparam1 >> 16 == PS_CALIBRATED) {
+
+ lpi->ps_B_val = (ps_kparam1 >> 8) & 0xFF;
+ lpi->ps_C_val = ps_kparam1 & 0xFF;
+ lpi->ps_A_val = (ps_kparam2 >> 24) & 0xFF;
+ lpi->ps_X_val = (ps_kparam2 >> 16) & 0xFF;
+ thl_value = (ps_kparam2 >> 8) & 0xFF;
+ thh_value = ps_kparam2 & 0xFF;
+ IPS("%s: PS calibrated ps_B_val = 0x%x, ps_C_val = 0x%x"
+ ", ps_A_val = 0x%x, ps_X_val = 0x%x, ps_lt = 0x%x"
+ ", ps_ht = 0x%x\n",
+ __func__, lpi->ps_B_val, lpi->ps_C_val,
+ lpi->ps_A_val, lpi->ps_X_val, thl_value,
+ thh_value);
+
+ if ((thl_value != 0) && (thh_value != 0) && (thh_value > thl_value)) {
+ lpi->ps_lt = thl_value;
+ lpi->ps_ht = thh_value;
+ IPS("%s: PS calibrated ps_lt = 0x%x"
+ ", ps_ht = 0x%x\n", __func__, lpi->ps_lt, lpi->ps_ht);
+ } else{
+ EPS("%s: PS no calibrated, default ps_lt = 0x%x"
+ ", ps_ht = 0x%x\n", __func__, lpi->ps_lt, lpi->ps_ht);
+ if (lpi->calibrate_func != NULL) {
+ if (lpi->ps_B_val != 0 && lpi->ps_C_val != 0) {
+ lpi->calibrate_func(lpi->ps_B_val, lpi->ps_C_val, lpi->ps_A_val,
+ lpi->ps_X_val, &thl_value, &thh_value);
+ IPS("%s: PS recaculate ps_lt = 0x%x"
+ ", ps_ht = 0x%x\n", __func__, thl_value, thh_value);
+ }
+ }
+ if ((thl_value != 0) && (thh_value != 0) && (thh_value > thl_value)) {
+ lpi->ps_lt = thl_value;
+ lpi->ps_ht = thh_value;
+ }
+ }
+ ps_threshold = (PS_CALIBRATED << 16) |
+ ((lpi->ps_lt << 8) | lpi->ps_ht);
+ set_psensor_range(lpi->ps_lt, lpi->ps_ht);
+ } else
+ DPS("%s: Proximity not calibrated\n", __func__);
+}
+
+static int lightsensor_update_table(struct isl29028_info *lpi)
+{
+ uint16_t data[10];
+ int i;
+ for (i = 0; i < 10; i++) {
+ if (*(lpi->adc_table + i) < 0xFFF) {
+ data[i] = *(lpi->adc_table + i)
+ * lpi->als_kadc / lpi->als_gadc;
+ } else {
+ data[i] = *(lpi->adc_table + i);
+ }
+ ILS("%s: Calibrated adc_table: data[%d] = %x\n",
+ __func__, i, data[i]);
+ }
+ memcpy(lpi->cali_table, data, 20);
+ return 0;
+}
+
+static int lightsensor_enable(struct isl29028_info *lpi)
+{
+ int ret;
+
+ ILS("%s\n", __func__);
+
+ lpi->ls_enable_flag = 1;
+ if (lpi->ps_irq_flag == 1) {
+ ILS("%s: proximity is NEAR\n", __func__);
+ return 0;
+ }
+
+ if (!lpi->als_enable) {
+ ret = _isl29028_set_reg_bit(lpi->i2c_client, 1,
+ ISL29028_CONFIGURE, ISL29028_ALS_EN);
+ if (ret < 0)
+ ELS("%s: set auto light sensor fail\n", __func__);
+ else {
+ lpi->als_enable = 1;
+ /* report an invalid value first to ensure we
+ * trigger an event when adc_level is zero.
+ */
+ input_report_abs(lpi->ls_input_dev, ABS_MISC, -1);
+ input_sync(lpi->ls_input_dev);
+
+ report_lsensor_input_event(lpi);
+ }
+ }
+ return 0;
+}
+
+static int lightsensor_disable(struct isl29028_info *lpi)
+{
+ ILS("%s\n", __func__);
+
+ lpi->ls_enable_flag = 0;
+
+ lightsensor_real_disable(lpi);
+
+ return 0;
+}
+
+static int lightsensor_open(struct inode *inode, struct file *file)
+{
+ struct isl29028_info *lpi = lp_info;
+ int rc = 0;
+
+ DLS("%s\n", __func__);
+ if (lpi->lightsensor_opened) {
+ ILS("%s: already opened\n", __func__);
+ rc = -EBUSY;
+ }
+ lpi->lightsensor_opened = 1;
+ return rc;
+}
+
+static int lightsensor_release(struct inode *inode, struct file *file)
+{
+ struct isl29028_info *lpi = lp_info;
+
+ DLS("%s\n", __func__);
+ lpi->lightsensor_opened = 0;
+ return 0;
+}
+
+static long lightsensor_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ int rc, val;
+ struct isl29028_info *lpi = lp_info;
+
+ DLS("%s cmd %d\n", __func__, _IOC_NR(cmd));
+
+ switch (cmd) {
+ case LIGHTSENSOR_IOCTL_ENABLE:
+ if (get_user(val, (unsigned long __user *)arg)) {
+ rc = -EFAULT;
+ break;
+ }
+ /*DLS("%s value = %d\n", __func__, val);*/
+ rc = val ? lightsensor_enable(lpi) : lightsensor_disable(lpi);
+ break;
+ case LIGHTSENSOR_IOCTL_GET_ENABLED:
+ val = lpi->ls_enable_flag;
+ /*DLS("%s enabled %d\n", __func__, val);*/
+ rc = put_user(val, (unsigned long __user *)arg);
+ break;
+ default:
+ ILS("%s: invalid cmd %d\n", __func__, _IOC_NR(cmd));
+ rc = -EINVAL;
+ }
+
+ return rc;
+}
+
+static const struct file_operations lightsensor_fops = {
+ .owner = THIS_MODULE,
+ .open = lightsensor_open,
+ .release = lightsensor_release,
+ .unlocked_ioctl = lightsensor_ioctl
+};
+
+static struct miscdevice lightsensor_misc = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = "lightsensor",
+ .fops = &lightsensor_fops
+};
+
+static ssize_t ps_adc_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+
+ uint16_t value;
+ int ret;
+ struct isl29028_info *lpi = lp_info;
+
+ int value1;
+
+/*#ifdef DEBUG_PROXIMITY*/
+ info_do_work(NULL);
+ /*cancel_delayed_work(&info_work);*/
+/*#endif*/
+
+ value1 = gpio_get_value(lpi->intr_pin);
+
+ value = get_ps_adc_value();
+
+ ret = sprintf(buf, "ADC[0x%03X], ENABLE = %d, intr_pin = %d,"
+ " ps_pocket_mode = %d\n", value, lpi->ps_enable, value1,
+ lpi->ps_pocket_mode);
+
+ return ret;
+}
+
+static ssize_t ps_enable_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ int ps_en;
+ struct isl29028_info *lpi = lp_info;
+
+ ps_en = -1;
+ sscanf(buf, "%d", &ps_en);
+
+ if (ps_en != 0 && ps_en != 1)
+ return -EINVAL;
+
+ if (ps_en)
+ psensor_enable(lpi);
+ else
+ psensor_disable(lpi);
+
+ return count;
+}
+
+static DEVICE_ATTR(ps_adc, 0664, ps_adc_show, ps_enable_store);
+
+static ssize_t ps_kadc_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ int ret = 0;
+ struct isl29028_info *lpi = lp_info;
+
+ if ((ps_kparam1 >> 16) == PS_CALIBRATED) {
+ ret = sprintf(buf, "P-sensor calibrated, "
+ "(B_value, C_value, A_value, X_value,"
+ " THL, THH) = (0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
+ lpi->ps_B_val, lpi->ps_C_val, lpi->ps_A_val,
+ lpi->ps_X_val, lpi->ps_lt, lpi->ps_ht);
+ } else {
+ ret = sprintf(buf, "P-sensor NOT calibrated, "
+ "(B_value, C_value, A_value, X_value,"
+ " THL, THH) = (0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
+ lpi->ps_B_val, lpi->ps_C_val, lpi->ps_A_val,
+ lpi->ps_X_val, lpi->ps_lt, lpi->ps_ht);
+ }
+
+ return ret;
+}
+
+static ssize_t ps_kadc_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ uint8_t lt, ht;
+ int param1, param2;
+ int ret;
+ struct isl29028_info *lpi = lp_info;
+
+ sscanf(buf, "0x%x 0x%x", ¶m1, ¶m2);
+
+ DPS("%s: store value = 0x%X, 0x%X\n", __func__, param1, param2);
+
+ lt = (param2 >> 8) & 0xFF;
+ ht = param2 & 0xFF;
+
+ ps_threshold = (PS_CALIBRATED << 16) | (param2 & 0xFFFF);
+
+ DPS("%s: lt = 0x%X, ht = 0x%X\n", __func__, lt, ht);
+ DPS("%s: ps_threshold = 0x%X\n", __func__, ps_threshold);
+
+ if (lt < ht) {
+
+ lpi->ps_B_val = (param1 >> 8) & 0xFF;
+ lpi->ps_C_val = param1 & 0xFF;
+ lpi->ps_A_val = (param2 >> 24) & 0xFF;
+ lpi->ps_X_val = (param2 >> 16) & 0xFF;
+ lpi->ps_lt = (param2 >> 8) & 0xFF;
+ lpi->ps_ht = param2 & 0xFF;
+
+ ret = set_psensor_range(lt, ht);
+ if (ret < 0) {
+ EPS("%s : write ISL29028_PS_LT_HT fail\n",
+ __func__);
+ return -1;
+ }
+ lpi->ps_lt = lt;
+ lpi->ps_ht = ht;
+#ifdef POLLING_PROXIMITY
+ lpi->original_lt = lt;
+ lpi->original_ht = ht;
+#endif
+ } else
+ DPS("%s: Setting PS calibration ERROR!\n", __func__);
+
+ return count;
+}
+
+static DEVICE_ATTR(ps_kadc, 0664, ps_kadc_show, ps_kadc_store);
+
+static ssize_t ps_led_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ char buffer[2];
+ uint8_t value;
+ int ret = 0;
+ struct isl29028_info *lpi = lp_info;
+
+ buffer[0] = ISL29028_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail\n", __func__);
+ return ret;
+ }
+ value = buffer[0];
+ DPS("%s: Configure reg = 0x%x\n", __func__, value);
+
+ lpi->led = (value & 0x08) >> 3;
+ DPS("%s: lpi->led = 0x%x\n", __func__, lpi->led);
+
+ ret = sprintf(buf, "Current led setting: %s\n",
+ (lpi->led == 0) ? "100mA" : "200mA");
+
+ return ret;
+}
+
+static ssize_t ps_led_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ int param;
+ int ret;
+ struct isl29028_info *lpi = lp_info;
+
+ sscanf(buf, "%d", ¶m);
+
+ DPS("%s: store value = %d\n", __func__, param);
+
+ if (param == 0 || param == 1) {
+ ret = _isl29028_set_reg_bit(lpi->i2c_client,
+ param, ISL29028_CONFIGURE, ISL29028_PROX_DR);
+ if (ret < 0) {
+ EPS("%s : Set LED fail\n", __func__);
+ return -1;
+ }
+ lpi->led = param;
+ } else
+ DPS("%s: Setting PS LED ERROR, please use 0 or 1!\n", __func__);
+
+ return count;
+}
+
+static DEVICE_ATTR(ps_led, 0664, ps_led_show, ps_led_store);
+
+static ssize_t ps_test_mode_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ char buffer[2] = "";
+ uint8_t test1 = 0, test2 = 0, is_test_mode = 0;
+ int ret = 0;
+
+ buffer[0] = ISL29028_TEST1;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail, Test1\n", __func__);
+ return ret;
+ }
+ test1 = buffer[0];
+
+ buffer[0] = ISL29028_TEST2;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail, Test2\n", __func__);
+ return ret;
+ }
+ test2 = buffer[0];
+
+ if ((test1 == 0) && (test2 == 0))
+ is_test_mode = 0;
+ else
+ is_test_mode = 1;
+
+ ret = sprintf(buf, "Test mode = %d, test1 = 0x%x, test2 = 0x%x\n",
+ is_test_mode, test1, test2);
+
+ return ret;
+}
+
+static ssize_t ps_test_mode_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ char buffer[2] = "";
+ int test1 = 0, test2 = 0;
+ int value = 0;
+ int ret;
+
+ sscanf(buf, "0x%02x 0x%02x", &test1, &test2);
+
+ DPS("%s: store value = %d\n", __func__, value);
+
+ buffer[0] = ISL29028_TEST1;
+ buffer[1] = (test1 & 0xFF);
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29028_TEST1\n",
+ __func__);
+
+ buffer[0] = ISL29028_TEST2;
+ buffer[1] = (test2 & 0xFF);
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29028_TEST2\n",
+ __func__);
+
+ return count;
+}
+
+static DEVICE_ATTR(ps_test_mode, 0664, ps_test_mode_show, ps_test_mode_store);
+
+static ssize_t ls_adc_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ uint16_t value, raw_adc_value;
+ int ret, i, level = -1;
+ struct isl29028_info *lpi = lp_info;
+
+ value = get_ls_adc_value(&raw_adc_value);
+
+ for (i = 0; i < 10; i++) {
+ if (value <= (*(lpi->adc_table + i))) {
+ level = i;
+ if (*(lpi->adc_table + i))
+ break;
+ }
+ }
+
+ ret = sprintf(buf, "ADC[0x%03X] => level %d\n", value, level);
+
+ return ret;
+}
+
+static DEVICE_ATTR(ls_adc, 0664, ls_adc_show, NULL);
+
+static ssize_t ls_enable_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ uint8_t value;
+ int ret;
+ /*struct isl29028_info *lpi = lp_info;*/
+ char buffer[2];
+
+ buffer[0] = ISL29028_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ ELS("%s: I2C_RxData fail\n", __func__);
+ return ret;
+ }
+ value = buffer[0];
+
+ ret = sprintf(buf, "Light sensor Auto Enable = %d\n",
+ (value & 0x04) ? 1 : 0);
+
+ return ret;
+}
+
+static ssize_t ls_enable_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+
+ int ls_auto;
+ int want_enable;
+ int ret;
+ struct isl29028_info *lpi = lp_info;
+
+ ls_auto = -1;
+ sscanf(buf, "%d", &ls_auto);
+
+ if (ls_auto != 0 && ls_auto != 1 && ls_auto != 147)
+ return -EINVAL;
+
+ if (ls_auto) {
+ lpi->ls_calibrate = (ls_auto == 147) ? 1 : 0;
+ want_enable = 1;
+ } else {
+ lpi->ls_calibrate = 0;
+ want_enable = 0;
+ }
+
+ DLS("%s: want_enable = %d!\n", __func__, want_enable);
+
+ ret = _isl29028_set_reg_bit(lpi->i2c_client,
+ ((want_enable) ? 1 : 0),
+ ISL29028_CONFIGURE, ISL29028_ALS_EN);
+ if (ret < 0)
+ ELS("%s: ls enable fail\n", __func__);
+ else
+ lpi->als_enable = (want_enable) ? 1 : 0;
+
+ return count;
+}
+
+static DEVICE_ATTR(ls_auto, 0664,
+ ls_enable_show, ls_enable_store);
+
+static ssize_t ls_kadc_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct isl29028_info *lpi = lp_info;
+ int ret;
+
+ ret = sprintf(buf, "kadc = 0x%x, gadc = 0x%x, kadc while this boot"
+ " = 0x%x\n",
+ lpi->als_kadc, lpi->als_gadc, als_kadc);
+
+ return ret;
+}
+
+static ssize_t ls_kadc_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct isl29028_info *lpi = lp_info;
+ int kadc_temp = 0;
+
+ sscanf(buf, "%d", &kadc_temp);
+ if (kadc_temp <= 0 || lpi->golden_adc <= 0) {
+ ELS("%s: kadc_temp=0x%x, als_gadc=0x%x\n",
+ __func__, kadc_temp, lpi->golden_adc);
+ return -EINVAL;
+ }
+
+ lpi->als_kadc = kadc_temp;
+ lpi->als_gadc = lpi->golden_adc;
+ ILS("%s: als_kadc=0x%x, als_gadc=0x%x\n",
+ __func__, lpi->als_kadc, lpi->als_gadc);
+
+ if (lightsensor_update_table(lpi) < 0)
+ ELS("%s: update ls table fail\n", __func__);
+
+ return count;
+}
+
+static DEVICE_ATTR(ls_kadc, 0664, ls_kadc_show, ls_kadc_store);
+
+static int lightsensor_setup(struct isl29028_info *lpi)
+{
+ int ret;
+
+ lpi->ls_input_dev = input_allocate_device();
+ if (!lpi->ls_input_dev) {
+ ELS("%s: could not allocate ls input device\n", __func__);
+ return -ENOMEM;
+ }
+ lpi->ls_input_dev->name = "lightsensor-level";
+ set_bit(EV_ABS, lpi->ls_input_dev->evbit);
+ input_set_abs_params(lpi->ls_input_dev, ABS_MISC, 0, 9, 0, 0);
+
+ ret = input_register_device(lpi->ls_input_dev);
+ if (ret < 0) {
+ ELS("%s: can not register ls input device\n",
+ __func__);
+ goto err_free_ls_input_device;
+ }
+
+ ret = misc_register(&lightsensor_misc);
+ if (ret < 0) {
+ ELS("%s: can not register ls misc device\n",
+ __func__);
+ goto err_unregister_ls_input_device;
+ }
+
+ return ret;
+
+err_unregister_ls_input_device:
+ input_unregister_device(lpi->ls_input_dev);
+err_free_ls_input_device:
+ input_free_device(lpi->ls_input_dev);
+ return ret;
+}
+
+static int psensor_setup(struct isl29028_info *lpi)
+{
+ int ret;
+
+ lpi->ps_input_dev = input_allocate_device();
+ if (!lpi->ps_input_dev) {
+ EPS("%s: could not allocate ps input device\n", __func__);
+ return -ENOMEM;
+ }
+ lpi->ps_input_dev->name = "proximity";
+ set_bit(EV_ABS, lpi->ps_input_dev->evbit);
+ input_set_abs_params(lpi->ps_input_dev, ABS_DISTANCE, 0, 1, 0, 0);
+
+ ret = input_register_device(lpi->ps_input_dev);
+ if (ret < 0) {
+ EPS("%s: could not register ps input device\n", __func__);
+ goto err_free_ps_input_device;
+ }
+
+ ret = misc_register(&psensor_misc);
+ if (ret < 0) {
+ EPS("%s: could not register ps misc device\n", __func__);
+ goto err_unregister_ps_input_device;
+ }
+
+ return ret;
+
+err_unregister_ps_input_device:
+ input_unregister_device(lpi->ps_input_dev);
+err_free_ps_input_device:
+ input_free_device(lpi->ps_input_dev);
+ return ret;
+}
+
+static int isl29028_power_up_seq(void)
+{
+ int ret = 0;
+ char buffer[2];
+
+ buffer[0] = ISL29028_CONFIGURE;
+ buffer[1] = 0x0;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29028_CONFIGURE\n",
+ __func__);
+
+ buffer[0] = ISL29028_TEST2;
+ buffer[1] = 0x29;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29028_TEST2[1]\n",
+ __func__);
+
+ buffer[0] = ISL29028_TEST1;
+ buffer[1] = 0x0;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29028_TEST1\n",
+ __func__);
+
+ buffer[0] = ISL29028_TEST2;
+ buffer[1] = 0x0;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29028_TEST2[2]\n",
+ __func__);
+
+ msleep(1);
+
+ return ret;
+}
+
+static int isl29028_setup(struct isl29028_info *lpi)
+{
+ int ret = 0;
+ char buffer[2];
+
+ ret = gpio_request(lpi->intr_pin, "gpio_isl29028_intr");
+ if (ret < 0) {
+ EPS("%s: gpio %d request failed (%d)\n",
+ __func__, lpi->intr_pin, ret);
+ return ret;
+ }
+
+ ret = gpio_direction_input(lpi->intr_pin);
+ if (ret < 0) {
+ EPS("%s: failed to set gpio %d as input (%d)\n",
+ __func__, lpi->intr_pin, ret);
+ goto fail_free_intr_pin;
+ }
+
+ ret = request_any_context_irq(lpi->irq,
+ isl29028_irq_handler,
+ IRQF_TRIGGER_LOW,
+ "isl29028",
+ lpi);
+ if (ret < 0) {
+ EPS("%s: request_irq(%d) failed for gpio %d (%d)\n",
+ __func__, lpi->irq,
+ lpi->intr_pin, ret);
+ goto fail_free_intr_pin;
+ }
+
+ ret = isl29028_power_up_seq();
+ if (ret < 0) {
+ EPS("%s: isl29018_power_up_seq() fail!!\n", __func__);
+ goto err_configure;
+ }
+
+ buffer[0] = ISL29028_CONFIGURE;
+ buffer[1] = CONFIG_DEFAULT;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0) {
+ EPS("%s : failed to set LPS Configuration fail\n",
+ __func__);
+ goto err_configure;
+ }
+ lpi->led = 0;
+
+ ret = set_lsensor_range(0x0, 0x0);
+ if (ret < 0) {
+ ELS("%s : write ISL29028_LS_TH123 fail\n",
+ __func__);
+ goto err_set_lsensor_range;
+ }
+
+ lpi->ps_lt = lpi->default_ps_lt;
+ lpi->ps_ht = lpi->default_ps_ht;
+ ret = set_psensor_range(lpi->ps_lt, lpi->ps_ht);
+ if (ret < 0) {
+ EPS("%s : write ISL29028_PS_LT_HT fail\n",
+ __func__);
+ goto err_set_psensor_range;
+ }
+
+ buffer[0] = ISL29028_INTERRUPT;
+ buffer[1] = INTR_DEFAULT;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0) {
+ EPS("%s: set ALS PRST fail\n", __func__);
+ goto err_set_als_prst;
+ }
+
+ return ret;
+
+err_set_als_prst:
+err_set_psensor_range:
+err_set_lsensor_range:
+err_configure:
+ free_irq(lpi->irq, lpi);
+fail_free_intr_pin:
+ gpio_free(lpi->intr_pin);
+ return ret;
+}
+
+static int isl29028_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+ return 0;
+}
+
+static int isl29028_resume(struct i2c_client *client)
+{
+ struct isl29028_info *lpi = lp_info;
+ char buffer[2];
+ uint8_t reg_config = 0;
+ int ret = 0;
+
+ buffer[0] = ISL29028_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0)
+ EPS("%s: I2C_RxData fail (ISL29028_CONFIGURE)\n",
+ __func__);
+ reg_config = buffer[0];
+
+ if (((reg_config & ISL29028_PROX_EN) == 0) &&
+ ((reg_config & ISL29028_ALS_EN) == 0) &&
+ (ret == 0)) {
+ ret = isl29028_power_up_seq();
+ if (ret < 0)
+ EPS("%s: isl29018_power_up_seq() fail!!\n",
+ __func__);
+
+ buffer[0] = ISL29028_CONFIGURE;
+ buffer[1] = CONFIG_DEFAULT;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set "
+ "ISL29028_CONFIGURE2\n", __func__);
+
+ buffer[0] = ISL29028_INTERRUPT;
+ buffer[1] = INTR_DEFAULT;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : Set LPS INTR2 fail\n", __func__);
+
+ ret = set_lsensor_range(0x0, 0x0);
+ if (ret < 0)
+ ELS("%s : write ISL29028_LS_TH123 fail\n",
+ __func__);
+
+ set_psensor_th(lpi->original_lt, lpi->original_ht);
+
+ DPS("isl_resume: Re-initialize isl29028, ret = %d\n", ret);
+ }
+
+ return ret;
+}
+
+static int isl29028_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ int ret = 0;
+ char buffer[2];
+ struct isl29028_info *lpi;
+ struct isl29028_platform_data *pdata;
+
+ IPS("%s\n", __func__);
+
+ lpi = kzalloc(sizeof(struct isl29028_info), GFP_KERNEL);
+ if (!lpi)
+ return -ENOMEM;
+
+ /*DPS("%s: client->irq = %d\n", __func__, client->irq);*/
+
+ lpi->i2c_client = client;
+ pdata = client->dev.platform_data;
+ if (!pdata) {
+ EPS("%s: Assign platform_data error!!\n", __func__);
+ ret = -EBUSY;
+ goto err_platform_data_null;
+ }
+
+ lpi->irq = client->irq;
+
+ lpi->mfg_mode = board_mfg_mode();
+
+ i2c_set_clientdata(client, lpi);
+ lpi->intr_pin = pdata->intr;
+ lpi->adc_table = pdata->levels;
+ lpi->golden_adc = pdata->golden_adc;
+ lpi->power = pdata->power;
+ lpi->default_ps_lt = pdata->lt;
+ lpi->default_ps_ht = pdata->ht;
+ lpi->debounce = pdata->debounce;
+ lpi->ps_pocket_mode = 0;
+ lpi->mapping_table = pdata->mapping_table;
+ lpi->mapping_size = pdata->mapping_size;
+ lpi->ps_base_index = (pdata->mapping_size - 1);
+ lpi->enable_polling_ignore = pdata->enable_polling_ignore;
+ lpi->calibrate_func = pdata->calibrate_func;
+ lp_info = lpi;
+
+ als_power(1);
+
+ buffer[0] = ISL29028_CHIPID;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: Read Chip ID fail\n", __func__);
+ goto err_platform_data_null;
+ }
+
+DPS("%s: Read Chip ID = 0x%x\n", __func__, buffer[0]);
+ if (buffer[0] != 0xA1) {
+ EPS("%s: Error Chip ID or i2c error\n", __func__);
+ goto err_platform_data_null;
+ }
+
+ ret = lightsensor_setup(lpi);
+ if (ret < 0) {
+ ELS("%s: lightsensor_setup error!!\n", __func__);
+ goto err_lightsensor_setup;
+ }
+
+ ret = psensor_setup(lpi);
+ if (ret < 0) {
+ EPS("%s: psensor_setup error!!\n", __func__);
+ goto err_psensor_setup;
+ }
+
+ lightsensor_set_kvalue(lpi);
+
+ ret = lightsensor_update_table(lpi);
+ if (ret < 0) {
+ ELS("%s: update ls table fail\n",
+ __func__);
+ goto err_lightsensor_update_table;
+ }
+
+ lpi->lp_wq = create_singlethread_workqueue("isl29028_wq");
+ if (!lpi->lp_wq) {
+ EPS("%s: can't create workqueue\n", __func__);
+ ret = -ENOMEM;
+ goto err_create_singlethread_workqueue;
+ }
+
+ wake_lock_init(&(lpi->ps_wake_lock), WAKE_LOCK_SUSPEND, "proximity");
+
+ ret = isl29028_setup(lpi);
+ if (ret < 0) {
+ EPS("%s: isl29028_setup error!\n", __func__);
+ goto err_isl29028_setup;
+ }
+
+ psensor_set_kvalue(lpi);
+
+#ifdef POLLING_PROXIMITY
+ lpi->original_lt = lpi->ps_lt;
+ lpi->original_ht = lpi->ps_ht;
+#endif
+
+ lpi->isl29028_class = class_create(THIS_MODULE, "optical_sensors");
+ if (IS_ERR(lpi->isl29028_class)) {
+ ret = PTR_ERR(lpi->isl29028_class);
+ lpi->isl29028_class = NULL;
+ goto err_create_class;
+ }
+
+ lpi->ls_dev = device_create(lpi->isl29028_class,
+ NULL, 0, "%s", "lightsensor");
+ if (unlikely(IS_ERR(lpi->ls_dev))) {
+ ret = PTR_ERR(lpi->ls_dev);
+ lpi->ls_dev = NULL;
+ goto err_create_ls_device;
+ }
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ls_dev, &dev_attr_ls_adc);
+ if (ret)
+ goto err_create_ls_device_file;
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ls_dev, &dev_attr_ls_auto);
+ if (ret)
+ goto err_create_ls_device_file;
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ls_dev, &dev_attr_ls_kadc);
+ if (ret)
+ goto err_create_ls_device_file;
+
+ lpi->ps_dev = device_create(lpi->isl29028_class,
+ NULL, 0, "%s", "proximity");
+ if (unlikely(IS_ERR(lpi->ps_dev))) {
+ ret = PTR_ERR(lpi->ps_dev);
+ lpi->ps_dev = NULL;
+ goto err_create_ls_device_file;
+ }
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ps_dev, &dev_attr_ps_adc);
+ if (ret)
+ goto err_create_ps_device;
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ps_dev, &dev_attr_ps_kadc);
+ if (ret)
+ goto err_create_ps_device;
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ps_dev, &dev_attr_ps_led);
+ if (ret)
+ goto err_create_ps_device;
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ps_dev, &dev_attr_ps_test_mode);
+ if (ret)
+ goto err_create_ps_device;
+
+ IPS("%s: Probe success!\n", __func__);
+ return ret;
+
+err_create_ps_device:
+ device_unregister(lpi->ps_dev);
+err_create_ls_device_file:
+ device_unregister(lpi->ls_dev);
+err_create_ls_device:
+ class_destroy(lpi->isl29028_class);
+err_create_class:
+err_isl29028_setup:
+ wake_lock_destroy(&(lpi->ps_wake_lock));
+ destroy_workqueue(lpi->lp_wq);
+ input_unregister_device(lpi->ls_input_dev);
+ input_free_device(lpi->ls_input_dev);
+ input_unregister_device(lpi->ps_input_dev);
+ input_free_device(lpi->ps_input_dev);
+err_create_singlethread_workqueue:
+err_lightsensor_update_table:
+ misc_deregister(&psensor_misc);
+err_psensor_setup:
+ misc_deregister(&lightsensor_misc);
+err_lightsensor_setup:
+err_platform_data_null:
+ kfree(lpi);
+ return ret;
+}
+
+static const struct i2c_device_id isl29028_i2c_id[] = {
+ {ISL29028_I2C_NAME, 0},
+ {}
+};
+
+static struct i2c_driver isl29028_driver = {
+ .id_table = isl29028_i2c_id,
+ .probe = isl29028_probe,
+ .suspend = isl29028_suspend,
+ .resume = isl29028_resume,
+ .driver = {
+ .name = ISL29028_I2C_NAME,
+ .owner = THIS_MODULE,
+ },
+};
+
+static int __init isl29028_init(void)
+{
+ return i2c_add_driver(&isl29028_driver);
+}
+
+static void __exit isl29028_exit(void)
+{
+ i2c_del_driver(&isl29028_driver);
+}
+
+module_init(isl29028_init);
+module_exit(isl29028_exit);
+
+MODULE_DESCRIPTION("ISL29028 Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/input/misc/isl29029.c b/drivers/input/misc/isl29029.c
new file mode 100644
index 0000000..655552c
--- /dev/null
+++ b/drivers/input/misc/isl29029.c
@@ -0,0 +1,1892 @@
+/* drivers/i2c/chips/isl29029.c - isl29029 optical sensors driver
+ *
+ * Copyright (C) 2010 HTC, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ *
+ */
+
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <linux/irq.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/miscdevice.h>
+#include <linux/lightsensor.h>
+#include <asm/uaccess.h>
+#include <asm/mach-types.h>
+#include <linux/isl29029.h>
+#include <linux/pl_sensor.h>
+#include <linux/capella_cm3602.h>
+#include <asm/setup.h>
+#include <linux/wakelock.h>
+#include <linux/rtc.h>
+#include <linux/slab.h>
+#include <mach/board.h>
+
+#define DPS(x...) printk(KERN_DEBUG "[PS][ISL29029] " x)
+#define DLS(x...) printk(KERN_DEBUG "[LS][ISL29029] " x)
+#define IPS(x...) printk(KERN_INFO "[PS][ISL29029] " x)
+#define ILS(x...) printk(KERN_INFO "[LS][ISL29029] " x)
+#define EPS(x...) printk(KERN_ERR "[PS][ISL29029 ERROR] " x)
+#define ELS(x...) printk(KERN_ERR "[LS][ISL29029 ERROR] " x)
+
+#define I2C_RETRY_COUNT 10
+
+#define INTR_DEFAULT 0x04
+#define CONFIG_DEFAULT 0x52
+
+#define INTR_MASK 0x77
+#define CONFIG_MASK 0x7B
+
+extern unsigned int als_kadc;
+static void sensor_irq_do_work(struct work_struct *work);
+static DECLARE_WORK(sensor_irq_work, sensor_irq_do_work);
+
+struct isl29029_info {
+ struct class *isl29029_class;
+ struct device *ls_dev;
+ struct device *ps_dev;
+
+ struct input_dev *ls_input_dev;
+ struct input_dev *ps_input_dev;
+
+ struct i2c_client *i2c_client;
+ struct workqueue_struct *lp_wq;
+
+ int intr_pin;
+
+ int als_enable;
+ int ls_enable_flag;
+
+ int ps_enable;
+ uint8_t ps_lt;
+ uint8_t ps_ht;
+ uint8_t ps_B_val;
+ uint8_t ps_C_val;
+ uint8_t ps_A_val;
+ uint8_t ps_X_val;
+ int led;
+ uint8_t default_ps_lt;
+ uint8_t default_ps_ht;
+
+ uint16_t *adc_table;
+ uint16_t cali_table[10];
+ int irq;
+
+ int ls_calibrate;
+
+ int (*power)(int, uint8_t); /* power to the chip */
+ int (*calibrate_func)(int, int, int, int, int*, int*);
+ uint32_t als_kadc;
+ uint32_t als_gadc;
+ uint16_t golden_adc;
+
+ struct wake_lock ps_wake_lock;
+ int psensor_opened;
+ int lightsensor_opened;
+ uint8_t default_config_reg;
+};
+
+static struct isl29029_info *lp_info;
+
+/*static uint32_t als_kadc;*/
+static uint32_t ps_threshold;
+
+static int I2C_RxData(char *rxData, int length)
+{
+ uint8_t loop_i;
+ struct i2c_msg msgs[] = {
+ {
+ .addr = lp_info->i2c_client->addr,
+ .flags = 0,
+ .len = 1,
+ .buf = rxData,
+ },
+ {
+ .addr = lp_info->i2c_client->addr,
+ .flags = I2C_M_RD,
+ .len = length,
+ .buf = rxData,
+ },
+ };
+
+ for (loop_i = 0; loop_i < I2C_RETRY_COUNT; loop_i++) {
+ if (i2c_transfer(lp_info->i2c_client->adapter, msgs, 2) > 0)
+ break;
+
+ mdelay(10);
+ }
+
+ if (loop_i >= I2C_RETRY_COUNT) {
+ EPS("%s retry over %d\n",
+ __func__, I2C_RETRY_COUNT);
+ return -EIO;
+ }
+
+ return 0;
+}
+
+static int I2C_TxData(char *txData, int length)
+{
+ uint8_t loop_i;
+ struct i2c_msg msg[] = {
+ {
+ .addr = lp_info->i2c_client->addr,
+ .flags = 0,
+ .len = length,
+ .buf = txData,
+ },
+ };
+
+ for (loop_i = 0; loop_i < I2C_RETRY_COUNT; loop_i++) {
+ if (i2c_transfer(lp_info->i2c_client->adapter, msg, 1) > 0)
+ break;
+
+ mdelay(10);
+ }
+
+ if (loop_i >= I2C_RETRY_COUNT) {
+ EPS("%s retry over %d\n",
+ __func__, I2C_RETRY_COUNT);
+ return -EIO;
+ }
+
+ return 0;
+}
+
+static uint16_t get_ls_adc_value(uint16_t *raw_adc_value)
+{
+ uint16_t value, tmp_value;
+ struct isl29029_info *lpi = lp_info;
+ char buffer[3] = {0};
+ int ret = 0;
+
+ buffer[0] = ISL29029_LS_DATA1;
+ ret = I2C_RxData(buffer, 2);
+ if (ret < 0) {
+ ELS("%s: I2C_RxData fail\n", __func__);
+ return ret;
+ }
+ value = buffer[0];
+ tmp_value = buffer[1];
+
+ /*DLS("%s: value = 0x%03X, tmp_value = 0x%03X\n",
+ __func__, value, tmp_value);*/
+
+ value = value | tmp_value << 8;
+ *raw_adc_value = value;
+
+ if (value > 0xFFF) {
+ printk(KERN_WARNING "%s: get wrong value: 0x%X\n",
+ __func__, value);
+ return -1;
+ } else {
+ if (!lpi->ls_calibrate) {
+ value = value * lpi->als_gadc / lpi->als_kadc;
+ if (value > 0xFFF)
+ value = 0xFFF;
+ }
+ }
+
+ return value & 0x0FFF;
+}
+
+static uint16_t get_ps_adc_value(void)
+{
+ uint16_t value;
+ char buffer[2];
+ int ret = 0;
+
+ buffer[0] = ISL29029_PROX_DATA;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail\n", __func__);
+ return 0;
+ }
+ value = buffer[0];
+
+ return value & 0xFF;
+}
+
+static int _isl29029_set_reg_bit(struct i2c_client *client, u8 set,
+ u8 cmd, u8 data)
+{
+ char buffer[2];
+ u8 value;
+ int ret = 0;
+
+ buffer[0] = cmd;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail\n", __func__);
+ return ret;
+ }
+ value = buffer[0];
+ /*DPS("Andy, %s: I2C_RxData[0x%x] = 0x%x\n",
+ __func__, cmd, value);*/
+
+ if (set)
+ value |= data;
+ else
+ value &= ~data;
+
+ buffer[0] = cmd;
+ buffer[1] = value;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0) {
+ EPS("%s: I2C_TxData fail\n", __func__);
+ return -EIO;
+ }
+
+ /* Debug use */
+ /*value = i2c_smbus_read_byte_data(client, cmd);
+ DPS("Andy, %s: After set reg bit[0x%x] = 0x%x\n",
+ __func__, cmd, value);*/
+
+ return ret;
+}
+
+static int set_lsensor_range(uint16_t lt, uint16_t ht)
+{
+ uint16_t value = 0;
+ int ret;
+ char buffer[4];
+
+ value = (lt >> 8) & 0x0f;
+ value |= ht << 4;
+ value &= 0xff;
+
+ buffer[0] = ISL29029_LS_TH1;
+ buffer[1] = lt & 0xFF;
+ buffer[2] = value;
+ buffer[3] = (ht >> 4) & 0xFF;
+ ret = I2C_TxData(buffer, 4);
+ if (ret < 0) {
+ ELS("%s : I2C_TxData fail\n", __func__);
+ return ret;
+ }
+
+/*
+ value = i2c_smbus_read_byte_data(lpi->i2c_client, ISL29029_LS_TH1);
+ DLS("TH1--------->0x%03X\n", value);
+ value = i2c_smbus_read_byte_data(lpi->i2c_client, ISL29029_LS_TH2);
+ DLS("TH2--------->0x%03X\n", value);
+ value = i2c_smbus_read_byte_data(lpi->i2c_client, ISL29029_LS_TH3);
+ DLS("TH3--------->0x%03X\n", value);
+*/
+ return ret;
+}
+
+static int set_psensor_range(u8 lt, u8 ht)
+{
+ int ret;
+ char buffer[3];
+ struct isl29029_info *lpi = lp_info;
+
+ if (!lpi) {
+ EPS("%s: lpi_info is empty\n", __func__);
+ return -EINVAL;
+ }
+
+ /*DPS("%s: PS ps_threshold = 0x%x\n",
+ __func__, ps_threshold);*/
+
+ if (ps_threshold >> 16 == PS_CALIBRATED) {
+ lt = (ps_threshold >> 8) & 0xFF;
+ ht = ps_threshold & 0xFF;
+ }
+
+ IPS("%s: Setting psensor range (0x%X, 0x%X)\n",
+ __func__, lt, ht);
+
+ buffer[0] = ISL29029_PROX_LT;
+ buffer[1] = lt;
+ buffer[2] = ht;
+ ret = I2C_TxData(buffer, 3);
+ if (ret < 0) {
+ EPS("%s : I2C_TxData fail\n", __func__);
+ return ret;
+ }
+
+ return ret;
+}
+
+static void set_psensor_th(u8 lt, u8 ht)
+{
+ int ret = 0;
+
+ ps_threshold = (PS_CALIBRATED << 16) | (lt << 8) | ht;
+ /*DPS("set_ps_th: ps_threshold = 0x%08X\n",
+ ps_threshold);*/
+
+ ret = set_psensor_range(lt, ht);
+ if (ret < 0)
+ EPS("%s: set_psensor_range fail\n", __func__);
+}
+
+static void lightsensor_real_disable(struct isl29029_info *lpi)
+{
+ int ret;
+
+ if (lpi->als_enable) {
+ ret = _isl29029_set_reg_bit(lpi->i2c_client, 0,
+ ISL29029_CONFIGURE, ISL29029_ALS_EN);
+ if (ret < 0)
+ ELS("%s: disable auto light sensor fail\n",
+ __func__);
+ else
+ lpi->als_enable = 0;
+
+ ret = _isl29029_set_reg_bit(lpi->i2c_client, 0,
+ ISL29029_INTERRUPT, ISL29029_INT_ALS_FLAG);
+ if (ret < 0)
+ ELS("%s: clear lsensor intr flag fail\n", __func__);
+ }
+}
+
+static void report_psensor_input_event(struct isl29029_info *lpi,
+ uint16_t ps_adc)
+{
+ int val, ret;
+
+ if (ps_adc > lpi->ps_ht)
+ val = 0;
+ else if (ps_adc <= lpi->ps_ht)
+ val = 1;
+ else
+ IPS("%s: Proximity adc value not as expected!\n", __func__);
+
+ IPS("proximity %s\n", val ? "FAR" : "NEAR");
+
+ /* 0 is close, 1 is far */
+ input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, val);
+ input_sync(lpi->ps_input_dev);
+
+ blocking_notifier_call_chain(&psensor_notifier_list, val+2, NULL);
+
+ if (val == 1)
+ set_psensor_th(0x0, lpi->ps_ht);
+ else
+ set_psensor_th(lpi->ps_lt, 0xFF);
+
+ ret = _isl29029_set_reg_bit(lpi->i2c_client, 0,
+ ISL29029_INTERRUPT, ISL29029_INT_PROX_FLAG);
+ if (ret < 0)
+ EPS("%s: clear psensor intr flag fail\n", __func__);
+
+ ret = _isl29029_set_reg_bit(lpi->i2c_client, 0,
+ ISL29029_INTERRUPT, ISL29029_INT_ALS_FLAG);
+ if (ret < 0)
+ EPS("%s: clear lsensor intr flag fail\n", __func__);
+}
+
+static void report_lsensor_input_event(struct isl29029_info *lpi)
+{
+ uint16_t adc_value, raw_adc_value;
+ int level = 0, i, ret;
+
+ adc_value = get_ls_adc_value(&raw_adc_value);
+
+ for (i = 0; i < 10; i++) {
+ if (adc_value <= (*(lpi->adc_table + i))) {
+ level = i;
+ if (*(lpi->adc_table + i))
+ break;
+ }
+ }
+
+ if (i == 0 && (adc_value >= (*(lpi->cali_table + i)))) {
+ ret = set_lsensor_range((i == 0) ? 0 :
+ *(lpi->cali_table + (i - 1)) + 1,
+ raw_adc_value + 1);
+ if (ret < 0)
+ ELS("%s: set_lsensor_range fail\n", __func__);
+
+ ILS("ALS_ADC = 0x%03X, Level = %d, l_thd equal 0, h_thd(raw_adc_value+1) = 0x%x \n",
+ adc_value, level, raw_adc_value + 1);
+ } else if (i < 10) {
+ ret = set_lsensor_range((i == 0) ? 0 :
+ *(lpi->cali_table + (i - 1)) + 1,
+ *(lpi->cali_table + i));
+ if (ret < 0)
+ ELS("%s: set_lsensor_range fail\n", __func__);
+
+ if (i == 0)
+ ILS("ALS_ADC = 0x%03X, Level = %d, l_thd equal 0, h_thd = 0x%x \n",
+ adc_value, level, *(lpi->cali_table + i));
+ else
+ ILS("ALS_ADC = 0x%03X, Level = %d, l_thd equal = 0x%x, h_thd = 0x%x \n",
+ adc_value, level, *(lpi->cali_table + (i - 1)) + 1, *(lpi->cali_table + i));
+ } else
+ ILS("%s: i = %d\n", __func__, i);
+
+ /*DLS("%s: RAW ADC = 0x%03X\n", __func__, raw_adc_value);*/
+ input_report_abs(lpi->ls_input_dev, ABS_MISC, level);
+ input_sync(lpi->ls_input_dev);
+
+ ret = _isl29029_set_reg_bit(lpi->i2c_client, 0,
+ ISL29029_INTERRUPT, ISL29029_INT_ALS_FLAG);
+ if (ret < 0)
+ ELS("%s: clear lsensor intr flag fail\n", __func__);
+
+}
+
+static int lightsensor_real_enable(struct isl29029_info *lpi)
+{
+ int ret = -1;
+
+ /*DLS("%s\n", __func__);*/
+
+ ret = _isl29029_set_reg_bit(lpi->i2c_client, 1,
+ ISL29029_CONFIGURE, ISL29029_ALS_EN);
+ if (ret < 0)
+ ELS("%s: _isl29029_set_reg_bit error\n", __func__);
+ else {
+ lpi->als_enable = 1;
+ input_report_abs(lpi->ls_input_dev, ABS_MISC, -1);
+ input_sync(lpi->ls_input_dev);
+
+ report_lsensor_input_event(lpi);
+ }
+
+ return ret;
+}
+
+static void judge_and_enable_lightsensor(struct isl29029_info *lpi)
+{
+ int ret;
+
+ if (lpi->ls_enable_flag) {
+ ret = lightsensor_real_enable(lpi);
+ if (ret < 0)
+ ELS("%s: lightsensor_real_enable: not enabled!\n",
+ __func__);
+ }
+}
+
+static void check_and_recover(struct isl29029_info *lpi)
+{
+ uint8_t intrrupt, reg_config;
+ uint8_t def_intrrupt, def_reg_config;
+ char buffer[2];
+ int ret = 0;
+ uint8_t orig_enabled;
+
+ buffer[0] = ISL29029_INTERRUPT;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail (ISL29029_INTERRUPT)\n",
+ __func__);
+ return;
+ }
+ intrrupt = buffer[0];
+
+ buffer[0] = ISL29029_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail (ISL29029_CONFIGURE)\n",
+ __func__);
+ return;
+ }
+ reg_config = buffer[0];
+
+ def_intrrupt = (intrrupt & INTR_MASK);
+ def_reg_config = (reg_config & CONFIG_MASK);
+ orig_enabled = ((reg_config & ISL29029_PROX_EN) |
+ (reg_config & ISL29029_ALS_EN));
+
+ if (def_intrrupt != INTR_DEFAULT) {
+ buffer[0] = ISL29029_INTERRUPT;
+ buffer[1] = INTR_DEFAULT;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : Set LPS INTR fail\n", __func__);
+ }
+
+ if (def_reg_config != lpi->default_config_reg) {
+ buffer[0] = ISL29029_CONFIGURE;
+ buffer[1] = (lpi->default_config_reg | orig_enabled);
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : Set LPS Configuration fail\n",
+ __func__);
+ }
+}
+
+static void sensor_irq_do_work(struct work_struct *work)
+{
+ uint8_t intrrupt, reg_config;
+ struct isl29029_info *lpi = lp_info;
+ char buffer[2];
+ int ret = 0;
+ int value1 = -1;
+ static int count;
+
+ uint16_t ps_adc = 0;
+
+ wake_lock_timeout(&(lpi->ps_wake_lock), 3*HZ);
+
+ value1 = gpio_get_value(lpi->intr_pin);
+ /*DPS("%s: lpi->intr_pin = %d\n", __func__, value1);*/
+
+ buffer[0] = ISL29029_INTERRUPT;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData %d fail (ISL29029_INTERRUPT)\n",
+ __func__, count);
+
+ if (count < 5)
+ count++;
+ else {
+ count = 0;
+ input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, 1);
+ input_sync(lpi->ps_input_dev);
+ blocking_notifier_call_chain(&psensor_notifier_list, 3, NULL);
+ }
+
+ enable_irq(lpi->irq);
+ return;
+ }
+ intrrupt = buffer[0];
+
+ buffer[0] = ISL29029_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData %d fail (ISL29029_CONFIGURE)\n",
+ __func__, count);
+
+ if (count < 5)
+ count++;
+ else {
+ count = 0;
+ input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, 1);
+ input_sync(lpi->ps_input_dev);
+ blocking_notifier_call_chain(&psensor_notifier_list, 3, NULL);
+ }
+
+ enable_irq(lpi->irq);
+ return;
+ }
+ reg_config = buffer[0];
+ IPS("isl_irq: CONFIG = 0x%x, INT_PIN = %d, INT = 0x%x\n",
+ reg_config, value1, intrrupt);
+
+ if (intrrupt & ISL29029_INT_PROX_FLAG) {
+
+ ps_adc = get_ps_adc_value();
+ DPS("isl_irq: ps_adc = 0x%02X, ps_lt = 0x%02X, ps_ht ="
+ " 0x%02X\n", ps_adc, lpi->ps_lt, lpi->ps_ht);
+
+ report_psensor_input_event(lpi, ps_adc);
+ }
+
+ if (intrrupt & ISL29029_INT_ALS_FLAG)
+ report_lsensor_input_event(lpi);
+
+ check_and_recover(lpi);
+
+ enable_irq(lpi->irq);
+
+ count = 0;
+}
+
+static void info_do_work(struct work_struct *w)
+{
+ struct isl29029_info *lpi = lp_info;
+ uint8_t intrrupt, reg_config;
+ int ret, i = 0, level = 0;
+ int value1;
+ uint16_t value, TH1_value, TH2_value, TH3_value;
+ uint16_t PROX_LT, PROX_HT;
+ char buffer[4] = "";
+ uint16_t adc_value, raw_adc_value;
+ uint16_t value_of_test1, value_of_test2;
+
+ buffer[0] = ISL29029_TEST1;
+ ret = I2C_RxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s: I2C_RxData fail (ISL29029_TEST1)\n",
+ __func__);
+ value_of_test1 = buffer[0];
+ value_of_test2 = buffer[1];
+
+ DPS("\n");
+ DPS("%s: TEST1 = 0x%02x, TEST2 = 0x%02x\n",
+ __func__, value_of_test1, value_of_test2);
+
+ value1 = gpio_get_value(lpi->intr_pin);
+ DPS("%s: intr_pin = %d, value of intr_pin = %d\n",
+ __func__, lpi->intr_pin, value1);
+
+ value = get_ps_adc_value();
+
+ DPS("%s: PS_ADC[0x%03X], ENABLE = %d\n",
+ __func__, value, lpi->ps_enable);
+
+ adc_value = get_ls_adc_value(&raw_adc_value);
+
+ for (i = 0; i < 10; i++) {
+ if (adc_value <= (*(lpi->adc_table + i))) {
+ level = i;
+ if (*(lpi->adc_table + i))
+ break;
+ }
+ }
+
+ DLS("%s: LS_ADC = 0x%03X, Level = %d \n", __func__, adc_value, level);
+ DLS("%s: LS_RAW ADC = 0x%03X\n", __func__, raw_adc_value);
+
+ buffer[0] = ISL29029_LS_TH1;
+ ret = I2C_RxData(buffer, 3);
+ if (ret < 0) {
+ ELS("%s: I2C_RxData fail (ISL29029_LS_TH1)\n",
+ __func__);
+ return;
+ }
+ TH1_value = buffer[0];
+ TH2_value = buffer[1];
+ TH3_value = buffer[2];
+
+ DLS("%s: LS_LOW_TH--------->0x%01X%02X\n", __func__,
+ (TH2_value & 0xF), TH1_value);
+ DLS("%s: LS_HIGH_TH--------->0x%02X%01X\n", __func__,
+ TH3_value, ((TH2_value >> 4) & 0xF));
+
+ buffer[0] = ISL29029_PROX_LT;
+ ret = I2C_RxData(buffer, 2);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail (ISL29029_PROX_LT)\n",
+ __func__);
+ return;
+ }
+ PROX_LT = buffer[0];
+ PROX_HT = buffer[1];
+
+ DPS("%s: PROX_LT--------->0x%02X\n", __func__, PROX_LT);
+ DPS("%s: PROX_HT--------->0x%02X\n", __func__, PROX_HT);
+
+ buffer[0] = ISL29029_INTERRUPT;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail (ISL29029_INTERRUPT)\n",
+ __func__);
+ return;
+ }
+ intrrupt = buffer[0];
+
+ buffer[0] = ISL29029_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail (ISL29029_CONFIGURE)\n",
+ __func__);
+ return;
+ }
+ reg_config = buffer[0];
+
+ DPS("%s: reg_config = 0x%x\n", __func__, reg_config);
+ DPS("%s: intrrupt = 0x%x\n", __func__, intrrupt);
+}
+
+static irqreturn_t isl29029_irq_handler(int irq, void *data)
+{
+ struct isl29029_info *lpi = data;
+
+ /*int value1;
+ value1 = gpio_get_value(lpi->intr_pin);
+ DPS("\n%s: intr_pin = %d, value of intr_pin = %d\n",
+ __func__, lpi->intr_pin, value1);*/
+ if (lpi->ps_enable == 1)
+ IPS("%s\n", __func__);
+
+ disable_irq_nosync(lpi->irq);
+ queue_work_on(0, lpi->lp_wq, &sensor_irq_work);
+
+ return IRQ_HANDLED;
+}
+
+static int als_power(int enable)
+{
+ struct isl29029_info *lpi = lp_info;
+
+ if (lpi->power)
+ lpi->power(LS_PWR_ON, 1);
+
+ return 0;
+}
+
+static int psensor_enable(struct isl29029_info *lpi)
+{
+ int ret;
+ uint16_t ps_adc = 0;
+
+ IPS("%s\n", __func__);
+ if (lpi->ps_enable) {
+ DPS("%s: already enabled\n", __func__);
+ return 0;
+ }
+
+ blocking_notifier_call_chain(&psensor_notifier_list, 1, NULL);
+
+ /* dummy report */
+ input_report_abs(lpi->ps_input_dev, ABS_DISTANCE, -1);
+ input_sync(lpi->ps_input_dev);
+
+ if (lpi->power)
+ lpi->power(PS_PWR_ON, 1);
+
+ ps_adc = get_ps_adc_value();
+ IPS("isl_irq: ps_adc = 0x%02X, ps_lt = 0x%02X, ps_ht = 0x%02X\n",
+ ps_adc, lpi->ps_lt, lpi->ps_ht);
+
+ wake_lock_timeout(&(lpi->ps_wake_lock), 2*HZ);
+ report_psensor_input_event(lpi, ps_adc);
+
+ ret = _isl29029_set_reg_bit(lpi->i2c_client, 1,
+ ISL29029_CONFIGURE, ISL29029_PROX_EN);
+ if (ret < 0) {
+ EPS("%s: enable psensor fail\n", __func__);
+ return ret;
+ }
+
+ lpi->ps_enable = 1;
+
+ ret = irq_set_irq_wake(lpi->irq, 1);
+ if (ret < 0) {
+ EPS("%s: failed to disable irq %d as a wake interrupt\n",
+ __func__, lpi->irq);
+ return ret;
+ }
+
+ return ret;
+}
+
+static int psensor_disable(struct isl29029_info *lpi)
+{
+ int ret = -EIO;
+
+ judge_and_enable_lightsensor(lpi);
+
+ IPS("%s\n", __func__);
+ if (!lpi->ps_enable) {
+ DPS("%s: already disabled\n", __func__);
+ return 0;
+ }
+
+ ret = irq_set_irq_wake(lpi->irq, 0);
+ if (ret < 0) {
+ EPS("%s: failed to disable irq %d as a wake interrupt\n",
+ __func__, lpi->irq);
+ return ret;
+ }
+
+ ret = _isl29029_set_reg_bit(lpi->i2c_client, 0,
+ ISL29029_CONFIGURE, ISL29029_PROX_EN);
+ if (ret < 0) {
+ EPS("%s: disable psensor fail\n", __func__);
+ return ret;
+ }
+
+ blocking_notifier_call_chain(&psensor_notifier_list, 0, NULL);
+
+ ret = _isl29029_set_reg_bit(lpi->i2c_client, 0,
+ ISL29029_INTERRUPT, ISL29029_INT_PROX_FLAG);
+ if (ret < 0) {
+ EPS("%s: clear proximity INT flag fail\n", __func__);
+ return ret;
+ }
+
+ if (lpi->power)
+ lpi->power(PS_PWR_ON, 0);
+
+ lpi->ps_enable = 0;
+
+ return ret;
+}
+
+static int psensor_open(struct inode *inode, struct file *file)
+{
+ struct isl29029_info *lpi = lp_info;
+
+ DPS("%s\n", __func__);
+
+ if (lpi->psensor_opened)
+ return -EBUSY;
+
+ lpi->psensor_opened = 1;
+
+ return 0;
+}
+
+static int psensor_release(struct inode *inode, struct file *file)
+{
+ struct isl29029_info *lpi = lp_info;
+
+ DPS("%s\n", __func__);
+
+ lpi->psensor_opened = 0;
+
+ return psensor_disable(lpi);
+}
+
+static long psensor_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ int val;
+ struct isl29029_info *lpi = lp_info;
+
+ DPS("%s cmd %d\n", __func__, _IOC_NR(cmd));
+
+ switch (cmd) {
+ case CAPELLA_CM3602_IOCTL_ENABLE:
+ if (get_user(val, (unsigned long __user *)arg))
+ return -EFAULT;
+ if (val)
+ return psensor_enable(lpi);
+ else
+ return psensor_disable(lpi);
+ break;
+ case CAPELLA_CM3602_IOCTL_GET_ENABLED:
+ return put_user(lpi->ps_enable, (unsigned long __user *)arg);
+ break;
+ default:
+ IPS("%s: invalid cmd %d\n", __func__, _IOC_NR(cmd));
+ return -EINVAL;
+ }
+}
+
+static const struct file_operations psensor_fops = {
+ .owner = THIS_MODULE,
+ .open = psensor_open,
+ .release = psensor_release,
+ .unlocked_ioctl = psensor_ioctl
+};
+
+static struct miscdevice psensor_misc = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = "cm3602",
+ .fops = &psensor_fops
+};
+
+static void lightsensor_set_kvalue(struct isl29029_info *lpi)
+{
+ if (!lpi) {
+ ELS("%s: ls_info is empty\n", __func__);
+ return;
+ }
+
+ ILS("%s: ALS calibrated als_kadc=0x%x\n",
+ __func__, als_kadc);
+
+ if (als_kadc >> 16 == ALS_CALIBRATED)
+ lpi->als_kadc = als_kadc & 0xFFFF;
+ else {
+ lpi->als_kadc = 0;
+ ILS("%s: no ALS calibrated\n", __func__);
+ }
+
+ if (lpi->als_kadc && lpi->golden_adc > 0) {
+ lpi->als_kadc = (lpi->als_kadc > 0 && lpi->als_kadc < 0x1000) ?
+ lpi->als_kadc : lpi->golden_adc;
+ lpi->als_gadc = lpi->golden_adc;
+ } else {
+ lpi->als_kadc = 1;
+ lpi->als_gadc = 1;
+ }
+ ILS("%s: als_kadc=0x%x, als_gadc=0x%x\n",
+ __func__, lpi->als_kadc, lpi->als_gadc);
+}
+
+static void psensor_set_kvalue(struct isl29029_info *lpi)
+{
+ int thl_value, thh_value;
+
+ IPS("%s: PS calibrated ps_kparam1 = 0x%x, ps_kparam2 = 0x%x\n",
+ __func__, ps_kparam1, ps_kparam2);
+
+ if (ps_kparam1 >> 16 == PS_CALIBRATED) {
+
+ lpi->ps_B_val = (ps_kparam1 >> 8) & 0xFF;
+ lpi->ps_C_val = ps_kparam1 & 0xFF;
+ lpi->ps_A_val = (ps_kparam2 >> 24) & 0xFF;
+ lpi->ps_X_val = (ps_kparam2 >> 16) & 0xFF;
+ thl_value = (ps_kparam2 >> 8) & 0xFF;
+ thh_value = ps_kparam2 & 0xFF;
+ IPS("%s: PS calibrated ps_B_val = 0x%x, ps_C_val = 0x%x"
+ ", ps_A_val = 0x%x, ps_X_val = 0x%x, ps_lt = 0x%x"
+ ", ps_ht = 0x%x\n",
+ __func__, lpi->ps_B_val, lpi->ps_C_val,
+ lpi->ps_A_val, lpi->ps_X_val, thl_value,
+ thh_value);
+
+ if ((thl_value != 0) && (thh_value != 0) && (thh_value > thl_value)) {
+ lpi->ps_lt = thl_value;
+ lpi->ps_ht = thh_value;
+ IPS("%s: PS calibrated ps_lt = 0x%x"
+ ", ps_ht = 0x%x\n", __func__, lpi->ps_lt, lpi->ps_ht);
+ } else{
+ EPS("%s: PS no calibrated, default ps_lt = 0x%x"
+ ", ps_ht = 0x%x\n", __func__, lpi->ps_lt, lpi->ps_ht);
+ if (lpi->calibrate_func != NULL) {
+ if (lpi->ps_B_val != 0 && lpi->ps_C_val != 0) {
+ lpi->calibrate_func(lpi->ps_B_val, lpi->ps_C_val, lpi->ps_A_val,
+ lpi->ps_X_val, &thl_value, &thh_value);
+ IPS("%s: PS recaculate ps_lt = 0x%x"
+ ", ps_ht = 0x%x\n", __func__, thl_value, thh_value);
+ }
+ }
+ if ((thl_value != 0) && (thh_value != 0) && (thh_value > thl_value)) {
+ lpi->ps_lt = thl_value;
+ lpi->ps_ht = thh_value;
+ }
+ }
+ ps_threshold = (PS_CALIBRATED << 16) |
+ ((lpi->ps_lt << 8) | lpi->ps_ht);
+
+ set_psensor_range(lpi->ps_lt, lpi->ps_ht);
+ } else
+ DPS("%s: Proximity not calibrated\n", __func__);
+}
+
+static int lightsensor_update_table(struct isl29029_info *lpi)
+{
+ uint16_t data[10];
+ int i;
+ for (i = 0; i < 10; i++) {
+ if (*(lpi->adc_table + i) < 0xFFF) {
+ data[i] = *(lpi->adc_table + i)
+ * lpi->als_kadc / lpi->als_gadc;
+ } else {
+ data[i] = *(lpi->adc_table + i);
+ }
+ ILS("%s: Calibrated adc_table: data[%d] = %x\n",
+ __func__, i, data[i]);
+ }
+ memcpy(lpi->cali_table, data, 20);
+ return 0;
+}
+
+static int lightsensor_enable(struct isl29029_info *lpi)
+{
+ int ret;
+
+ ILS("%s\n", __func__);
+
+ lpi->ls_enable_flag = 1;
+
+ if (!lpi->als_enable) {
+ ret = _isl29029_set_reg_bit(lpi->i2c_client, 1,
+ ISL29029_CONFIGURE, ISL29029_ALS_EN);
+ if (ret < 0)
+ ELS("%s: set auto light sensor fail\n", __func__);
+ else {
+ lpi->als_enable = 1;
+ /* report an invalid value first to ensure we
+ * trigger an event when adc_level is zero.
+ */
+ input_report_abs(lpi->ls_input_dev, ABS_MISC, -1);
+ input_sync(lpi->ls_input_dev);
+
+ report_lsensor_input_event(lpi);
+ }
+ }
+ return 0;
+}
+
+static int lightsensor_disable(struct isl29029_info *lpi)
+{
+ ILS("%s\n", __func__);
+
+ lpi->ls_enable_flag = 0;
+
+ lightsensor_real_disable(lpi);
+
+ return 0;
+}
+
+static int lightsensor_open(struct inode *inode, struct file *file)
+{
+ struct isl29029_info *lpi = lp_info;
+ int rc = 0;
+
+ DLS("%s\n", __func__);
+ if (lpi->lightsensor_opened) {
+ DLS("%s: already opened\n", __func__);
+ rc = -EBUSY;
+ }
+ lpi->lightsensor_opened = 1;
+ return rc;
+}
+
+static int lightsensor_release(struct inode *inode, struct file *file)
+{
+ struct isl29029_info *lpi = lp_info;
+
+ DLS("%s\n", __func__);
+ lpi->lightsensor_opened = 0;
+ return 0;
+}
+
+static long lightsensor_ioctl(struct file *file, unsigned int cmd,
+ unsigned long arg)
+{
+ int rc, val;
+ struct isl29029_info *lpi = lp_info;
+
+ DLS("%s cmd %d\n", __func__, _IOC_NR(cmd));
+
+ switch (cmd) {
+ case LIGHTSENSOR_IOCTL_ENABLE:
+ if (get_user(val, (unsigned long __user *)arg)) {
+ rc = -EFAULT;
+ break;
+ }
+ /*DLS("%s value = %d\n", __func__, val);*/
+ rc = val ? lightsensor_enable(lpi) : lightsensor_disable(lpi);
+ break;
+ case LIGHTSENSOR_IOCTL_GET_ENABLED:
+ val = lpi->ls_enable_flag;
+ /*DLS("%s enabled %d\n", __func__, val);*/
+ rc = put_user(val, (unsigned long __user *)arg);
+ break;
+ default:
+ ILS("%s: invalid cmd %d\n", __func__, _IOC_NR(cmd));
+ rc = -EINVAL;
+ }
+
+ return rc;
+}
+
+static const struct file_operations lightsensor_fops = {
+ .owner = THIS_MODULE,
+ .open = lightsensor_open,
+ .release = lightsensor_release,
+ .unlocked_ioctl = lightsensor_ioctl
+};
+
+static struct miscdevice lightsensor_misc = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = "lightsensor",
+ .fops = &lightsensor_fops
+};
+
+static ssize_t ps_adc_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+
+ uint16_t value;
+ int ret;
+ struct isl29029_info *lpi = lp_info;
+
+ int value1;
+
+ info_do_work(NULL);
+
+ value1 = gpio_get_value(lpi->intr_pin);
+
+ value = get_ps_adc_value();
+
+ ret = sprintf(buf, "ADC[0x%03X], ENABLE = %d, intr_pin = %d\n"
+ , value, lpi->ps_enable, value1);
+
+ return ret;
+}
+
+static ssize_t ps_enable_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ int ps_en;
+ struct isl29029_info *lpi = lp_info;
+
+ ps_en = -1;
+ sscanf(buf, "%d", &ps_en);
+
+ if (ps_en != 0 && ps_en != 1)
+ return -EINVAL;
+
+ if (ps_en)
+ psensor_enable(lpi);
+ else
+ psensor_disable(lpi);
+
+ return count;
+}
+
+static DEVICE_ATTR(ps_adc, 0664, ps_adc_show, ps_enable_store);
+
+static ssize_t ps_kadc_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ int ret = 0;
+ struct isl29029_info *lpi = lp_info;
+
+ if ((ps_kparam1 >> 16) == PS_CALIBRATED) {
+ ret = sprintf(buf, "P-sensor calibrated, "
+ "(B_value, C_value, A_value, X_value,"
+ " THL, THH) = (0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
+ lpi->ps_B_val, lpi->ps_C_val, lpi->ps_A_val,
+ lpi->ps_X_val, lpi->ps_lt, lpi->ps_ht);
+ } else {
+ ret = sprintf(buf, "P-sensor NOT calibrated, "
+ "(B_value, C_value, A_value, X_value,"
+ " THL, THH) = (0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
+ lpi->ps_B_val, lpi->ps_C_val, lpi->ps_A_val,
+ lpi->ps_X_val, lpi->ps_lt, lpi->ps_ht);
+ }
+
+ return ret;
+}
+
+static ssize_t ps_kadc_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ uint8_t lt, ht;
+ int param1, param2;
+ int ret;
+ struct isl29029_info *lpi = lp_info;
+
+ sscanf(buf, "0x%x 0x%x", ¶m1, ¶m2);
+
+ DPS("%s: store value = 0x%X, 0x%X\n", __func__, param1, param2);
+
+ lt = (param2 >> 8) & 0xFF;
+ ht = param2 & 0xFF;
+
+ ps_threshold = (PS_CALIBRATED << 16) | (param2 & 0xFFFF);
+
+ DPS("%s: lt = 0x%X, ht = 0x%X\n", __func__, lt, ht);
+ DPS("%s: ps_threshold = 0x%X\n", __func__, ps_threshold);
+
+ if (lt < ht) {
+
+ lpi->ps_B_val = (param1 >> 8) & 0xFF;
+ lpi->ps_C_val = param1 & 0xFF;
+ lpi->ps_A_val = (param2 >> 24) & 0xFF;
+ lpi->ps_X_val = (param2 >> 16) & 0xFF;
+ lpi->ps_lt = (param2 >> 8) & 0xFF;
+ lpi->ps_ht = param2 & 0xFF;
+
+ ret = set_psensor_range(lt, ht);
+ if (ret < 0) {
+ EPS("%s : write ISL29029_PS_LT_HT fail\n",
+ __func__);
+ return -1;
+ }
+ lpi->ps_lt = lt;
+ lpi->ps_ht = ht;
+ } else
+ DPS("%s: Setting PS calibration ERROR!\n", __func__);
+
+ return count;
+}
+
+static DEVICE_ATTR(ps_kadc, 0664, ps_kadc_show, ps_kadc_store);
+
+static ssize_t ps_led_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ char buffer[2];
+ uint8_t value;
+ int ret = 0;
+ struct isl29029_info *lpi = lp_info;
+
+ buffer[0] = ISL29029_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail\n", __func__);
+ return ret;
+ }
+ value = buffer[0];
+ DPS("%s: Configure reg = 0x%x\n", __func__, value);
+
+ lpi->led = (value & 0x08) >> 3;
+ DPS("%s: lpi->led = 0x%x\n", __func__, lpi->led);
+
+ ret = sprintf(buf, "Current led setting: %s\n",
+ (lpi->led == 0) ? "100mA" : "200mA");
+
+ return ret;
+}
+
+static ssize_t ps_led_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ int param;
+ int ret;
+ struct isl29029_info *lpi = lp_info;
+
+ sscanf(buf, "%d", ¶m);
+
+ DPS("%s: store value = %d\n", __func__, param);
+
+ if (param == 0 || param == 1) {
+ ret = _isl29029_set_reg_bit(lpi->i2c_client,
+ param, ISL29029_CONFIGURE, ISL29029_PROX_DR);
+ if (ret < 0) {
+ EPS("%s : Set LED fail\n", __func__);
+ return -1;
+ }
+ lpi->led = param;
+ } else
+ DPS("%s: Setting PS LED ERROR, please use 0 or 1!\n", __func__);
+
+ return count;
+}
+
+static DEVICE_ATTR(ps_led, 0664, ps_led_show, ps_led_store);
+
+static ssize_t ps_test_mode_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ char buffer[2] = "";
+ uint8_t test1 = 0, test2 = 0, is_test_mode = 0;
+ int ret = 0;
+
+ buffer[0] = ISL29029_TEST1;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail, Test1\n", __func__);
+ return ret;
+ }
+ test1 = buffer[0];
+
+ buffer[0] = ISL29029_TEST2;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: I2C_RxData fail, Test2\n", __func__);
+ return ret;
+ }
+ test2 = buffer[0];
+
+ if ((test1 == 0) && (test2 == 0))
+ is_test_mode = 0;
+ else
+ is_test_mode = 1;
+
+ ret = sprintf(buf, "Test mode = %d, test1 = 0x%x, test2 = 0x%x\n",
+ is_test_mode, test1, test2);
+
+ return ret;
+}
+
+static ssize_t ps_test_mode_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ char buffer[2] = "";
+ int test1 = 0, test2 = 0;
+ int value = 0;
+ int ret;
+
+ sscanf(buf, "0x%02x 0x%02x", &test1, &test2);
+
+ DPS("%s: store value = %d\n", __func__, value);
+
+ buffer[0] = ISL29029_TEST1;
+ buffer[1] = (test1 & 0xFF);
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29029_TEST1\n",
+ __func__);
+
+ buffer[0] = ISL29029_TEST2;
+ buffer[1] = (test2 & 0xFF);
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29029_TEST2\n",
+ __func__);
+
+ return count;
+}
+
+static DEVICE_ATTR(ps_test_mode, 0664, ps_test_mode_show, ps_test_mode_store);
+
+static ssize_t ls_adc_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ uint16_t value, raw_adc_value;
+ int ret, i, level = -1;
+ struct isl29029_info *lpi = lp_info;
+
+ value = get_ls_adc_value(&raw_adc_value);
+
+ for (i = 0; i < 10; i++) {
+ if (value <= (*(lpi->adc_table + i))) {
+ level = i;
+ if (*(lpi->adc_table + i))
+ break;
+ }
+ }
+
+ ret = sprintf(buf, "ADC[0x%03X] => level %d\n", value, level);
+
+ return ret;
+}
+
+static DEVICE_ATTR(ls_adc, 0664, ls_adc_show, NULL);
+
+static ssize_t ls_enable_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ uint8_t value;
+ int ret;
+ /*struct isl29029_info *lpi = lp_info;*/
+ char buffer[2];
+
+ buffer[0] = ISL29029_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ ELS("%s: I2C_RxData fail\n", __func__);
+ return ret;
+ }
+ value = buffer[0];
+
+ ret = sprintf(buf, "Light sensor Auto Enable = %d\n",
+ (value & 0x04) ? 1 : 0);
+
+ return ret;
+}
+
+static ssize_t ls_enable_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+
+ int ls_auto;
+ int want_enable;
+ int ret;
+ struct isl29029_info *lpi = lp_info;
+
+ ls_auto = -1;
+ sscanf(buf, "%d", &ls_auto);
+
+ if (ls_auto != 0 && ls_auto != 1 && ls_auto != 147)
+ return -EINVAL;
+
+ if (ls_auto) {
+ lpi->ls_calibrate = (ls_auto == 147) ? 1 : 0;
+ want_enable = 1;
+ } else {
+ lpi->ls_calibrate = 0;
+ want_enable = 0;
+ }
+
+ DLS("%s: want_enable = %d!\n", __func__, want_enable);
+
+ ret = _isl29029_set_reg_bit(lpi->i2c_client,
+ ((want_enable) ? 1 : 0),
+ ISL29029_CONFIGURE, ISL29029_ALS_EN);
+ if (ret < 0)
+ ELS("%s: ls enable fail\n", __func__);
+ else
+ lpi->als_enable = (want_enable) ? 1 : 0;
+
+ return count;
+}
+
+static DEVICE_ATTR(ls_auto, 0664,
+ ls_enable_show, ls_enable_store);
+
+static ssize_t ls_kadc_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct isl29029_info *lpi = lp_info;
+ int ret;
+
+ ret = sprintf(buf, "kadc = 0x%x, gadc = 0x%x, kadc while this boot"
+ " = 0x%x\n",
+ lpi->als_kadc, lpi->als_gadc, als_kadc);
+
+ return ret;
+}
+
+static ssize_t ls_kadc_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct isl29029_info *lpi = lp_info;
+ int kadc_temp = 0;
+
+ sscanf(buf, "%d", &kadc_temp);
+ if (kadc_temp <= 0 || lpi->golden_adc <= 0) {
+ ELS("%s: kadc_temp=0x%x, als_gadc=0x%x\n",
+ __func__, kadc_temp, lpi->golden_adc);
+ return -EINVAL;
+ }
+
+ lpi->als_kadc = kadc_temp;
+ lpi->als_gadc = lpi->golden_adc;
+ ILS("%s: als_kadc=0x%x, als_gadc=0x%x\n",
+ __func__, lpi->als_kadc, lpi->als_gadc);
+
+ if (lightsensor_update_table(lpi) < 0)
+ ELS("%s: update ls table fail\n", __func__);
+
+ return count;
+}
+
+static DEVICE_ATTR(ls_kadc, 0664, ls_kadc_show, ls_kadc_store);
+
+static int lightsensor_setup(struct isl29029_info *lpi)
+{
+ int ret;
+
+ lpi->ls_input_dev = input_allocate_device();
+ if (!lpi->ls_input_dev) {
+ ELS("%s: could not allocate ls input device\n", __func__);
+ return -ENOMEM;
+ }
+ lpi->ls_input_dev->name = "lightsensor-level";
+ set_bit(EV_ABS, lpi->ls_input_dev->evbit);
+ input_set_abs_params(lpi->ls_input_dev, ABS_MISC, 0, 9, 0, 0);
+
+ ret = input_register_device(lpi->ls_input_dev);
+ if (ret < 0) {
+ ELS("%s: can not register ls input device\n",
+ __func__);
+ goto err_free_ls_input_device;
+ }
+
+ ret = misc_register(&lightsensor_misc);
+ if (ret < 0) {
+ ELS("%s: can not register ls misc device\n",
+ __func__);
+ goto err_unregister_ls_input_device;
+ }
+
+ return ret;
+
+err_unregister_ls_input_device:
+ input_unregister_device(lpi->ls_input_dev);
+err_free_ls_input_device:
+ input_free_device(lpi->ls_input_dev);
+ return ret;
+}
+
+static int psensor_setup(struct isl29029_info *lpi)
+{
+ int ret;
+
+ lpi->ps_input_dev = input_allocate_device();
+ if (!lpi->ps_input_dev) {
+ EPS("%s: could not allocate ps input device\n", __func__);
+ return -ENOMEM;
+ }
+ lpi->ps_input_dev->name = "proximity";
+ set_bit(EV_ABS, lpi->ps_input_dev->evbit);
+ input_set_abs_params(lpi->ps_input_dev, ABS_DISTANCE, 0, 1, 0, 0);
+
+ ret = input_register_device(lpi->ps_input_dev);
+ if (ret < 0) {
+ EPS("%s: could not register ps input device\n", __func__);
+ goto err_free_ps_input_device;
+ }
+
+ ret = misc_register(&psensor_misc);
+ if (ret < 0) {
+ EPS("%s: could not register ps misc device\n", __func__);
+ goto err_unregister_ps_input_device;
+ }
+
+ return ret;
+
+err_unregister_ps_input_device:
+ input_unregister_device(lpi->ps_input_dev);
+err_free_ps_input_device:
+ input_free_device(lpi->ps_input_dev);
+ return ret;
+}
+
+static int isl29029_power_up_seq(void)
+{
+ int ret = 0;
+ char buffer[2];
+
+ buffer[0] = ISL29029_CONFIGURE;
+ buffer[1] = 0x0;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29029_CONFIGURE\n",
+ __func__);
+
+ buffer[0] = ISL29029_TEST2;
+ buffer[1] = 0x29;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29029_TEST2[1]\n",
+ __func__);
+
+ buffer[0] = ISL29029_TEST1;
+ buffer[1] = 0x0;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29029_TEST1\n",
+ __func__);
+
+ buffer[0] = ISL29029_TEST2;
+ buffer[1] = 0x0;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set ISL29029_TEST2[2]\n",
+ __func__);
+
+ msleep(1);
+
+ return ret;
+}
+
+static int isl29029_setup(struct isl29029_info *lpi)
+{
+ int ret = 0;
+ char buffer[2];
+
+ ret = gpio_request(lpi->intr_pin, "gpio_isl29029_intr");
+ if (ret < 0) {
+ EPS("%s: gpio %d request failed (%d)\n",
+ __func__, lpi->intr_pin, ret);
+ return ret;
+ }
+
+ ret = gpio_direction_input(lpi->intr_pin);
+ if (ret < 0) {
+ EPS("%s: failed to set gpio %d as input (%d)\n",
+ __func__, lpi->intr_pin, ret);
+ goto fail_free_intr_pin;
+ }
+
+ ret = request_any_context_irq(lpi->irq,
+ isl29029_irq_handler,
+ IRQF_TRIGGER_LOW,
+ "isl29029",
+ lpi);
+ if (ret < 0) {
+ EPS("%s: request_irq(%d) failed for gpio %d (%d)\n",
+ __func__, lpi->irq,
+ lpi->intr_pin, ret);
+ goto fail_free_intr_pin;
+ }
+
+ ret = isl29029_power_up_seq();
+ if (ret < 0) {
+ EPS("%s: isl29018_power_up_seq() fail!!\n", __func__);
+ goto err_configure;
+ }
+
+ buffer[0] = ISL29029_CONFIGURE;
+ buffer[1] = lpi->default_config_reg;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0) {
+ EPS("%s : failed to set LPS Configuration fail\n",
+ __func__);
+ goto err_configure;
+ }
+ lpi->led = 0;
+
+ ret = set_lsensor_range(0x0, 0x0);
+ if (ret < 0) {
+ ELS("%s : write ISL29029_LS_TH123 fail\n",
+ __func__);
+ goto err_set_lsensor_range;
+ }
+
+ lpi->ps_lt = lpi->default_ps_lt;
+ lpi->ps_ht = lpi->default_ps_ht;
+ ret = set_psensor_range(lpi->ps_lt, lpi->ps_ht);
+ if (ret < 0) {
+ EPS("%s : write ISL29029_PS_LT_HT fail\n",
+ __func__);
+ goto err_set_psensor_range;
+ }
+
+ buffer[0] = ISL29029_INTERRUPT;
+ buffer[1] = INTR_DEFAULT;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0) {
+ EPS("%s: set ALS PRST fail\n", __func__);
+ goto err_set_als_prst;
+ }
+
+ return ret;
+
+err_set_als_prst:
+err_set_psensor_range:
+err_set_lsensor_range:
+err_configure:
+ free_irq(lpi->irq, lpi);
+fail_free_intr_pin:
+ gpio_free(lpi->intr_pin);
+ return ret;
+}
+
+static int isl29029_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+ return 0;
+}
+
+static int isl29029_resume(struct i2c_client *client)
+{
+ struct isl29029_info *lpi = lp_info;
+ char buffer[2];
+ uint8_t reg_config = 0;
+ int ret = 0;
+
+ buffer[0] = ISL29029_CONFIGURE;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0)
+ EPS("%s: I2C_RxData fail (ISL29029_CONFIGURE)\n",
+ __func__);
+ reg_config = buffer[0];
+
+ if (((reg_config & ISL29029_PROX_EN) == 0) &&
+ ((reg_config & ISL29029_ALS_EN) == 0) &&
+ (ret == 0)) {
+ ret = isl29029_power_up_seq();
+ if (ret < 0)
+ EPS("%s: isl29018_power_up_seq() fail!!\n",
+ __func__);
+
+ buffer[0] = ISL29029_CONFIGURE;
+ buffer[1] = lpi->default_config_reg;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : failed to set "
+ "ISL29029_CONFIGURE2\n", __func__);
+
+ buffer[0] = ISL29029_INTERRUPT;
+ buffer[1] = INTR_DEFAULT;
+ ret = I2C_TxData(buffer, 2);
+ if (ret < 0)
+ EPS("%s : Set LPS INTR2 fail\n", __func__);
+
+ ret = set_lsensor_range(0x0, 0x0);
+ if (ret < 0)
+ ELS("%s : write ISL29029_LS_TH123 fail\n",
+ __func__);
+
+ DPS("isl_resume: Re-initialize isl29029, ret = %d\n", ret);
+ }
+
+ return ret;
+}
+
+static int isl29029_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ int ret = 0;
+ char buffer[2];
+ struct isl29029_info *lpi;
+ struct isl29029_platform_data *pdata;
+
+ IPS("%s\n", __func__);
+
+ lpi = kzalloc(sizeof(struct isl29029_info), GFP_KERNEL);
+ if (!lpi)
+ return -ENOMEM;
+
+ /*DPS("%s: client->irq = %d\n", __func__, client->irq);*/
+
+ lpi->i2c_client = client;
+ pdata = client->dev.platform_data;
+ if (!pdata) {
+ EPS("%s: Assign platform_data error!!\n", __func__);
+ ret = -EBUSY;
+ goto err_platform_data_null;
+ }
+
+ lpi->irq = client->irq;
+
+ i2c_set_clientdata(client, lpi);
+ lpi->intr_pin = pdata->intr;
+ lpi->adc_table = pdata->levels;
+ lpi->golden_adc = pdata->golden_adc;
+ lpi->power = pdata->power;
+ lpi->default_ps_lt = pdata->lt;
+ lpi->default_ps_ht = pdata->ht;
+ lpi->calibrate_func = pdata->calibrate_func;
+ if (pdata->default_config_reg != 0)
+ lpi->default_config_reg = pdata->default_config_reg;
+ else
+ lpi->default_config_reg = CONFIG_DEFAULT;
+ lp_info = lpi;
+
+ /*DLS("Andy: lpi->default_config_reg = 0x%x\n",
+ lpi->default_config_reg);*/
+
+ als_power(1);
+
+ buffer[0] = ISL29029_CHIPID;
+ ret = I2C_RxData(buffer, 1);
+ if (ret < 0) {
+ EPS("%s: Read Chip ID fail\n", __func__);
+ goto err_platform_data_null;
+ }
+
+ if (buffer[0] != 0xA7) {
+ EPS("%s: Error Chip ID or i2c error\n", __func__);
+ goto err_platform_data_null;
+ }
+
+ ret = lightsensor_setup(lpi);
+ if (ret < 0) {
+ ELS("%s: lightsensor_setup error!!\n", __func__);
+ goto err_lightsensor_setup;
+ }
+
+ ret = psensor_setup(lpi);
+ if (ret < 0) {
+ EPS("%s: psensor_setup error!!\n", __func__);
+ goto err_psensor_setup;
+ }
+
+ lightsensor_set_kvalue(lpi);
+
+ ret = lightsensor_update_table(lpi);
+ if (ret < 0) {
+ ELS("%s: update ls table fail\n",
+ __func__);
+ goto err_lightsensor_update_table;
+ }
+
+ lpi->lp_wq = create_singlethread_workqueue("isl29029_wq");
+ if (!lpi->lp_wq) {
+ EPS("%s: can't create workqueue\n", __func__);
+ ret = -ENOMEM;
+ goto err_create_singlethread_workqueue;
+ }
+
+ wake_lock_init(&(lpi->ps_wake_lock), WAKE_LOCK_SUSPEND, "proximity");
+
+ ret = isl29029_setup(lpi);
+ if (ret < 0) {
+ EPS("%s: isl29029_setup error!\n", __func__);
+ goto err_isl29029_setup;
+ }
+
+ psensor_set_kvalue(lpi);
+
+ lpi->isl29029_class = class_create(THIS_MODULE, "optical_sensors");
+ if (IS_ERR(lpi->isl29029_class)) {
+ ret = PTR_ERR(lpi->isl29029_class);
+ lpi->isl29029_class = NULL;
+ goto err_create_class;
+ }
+
+ lpi->ls_dev = device_create(lpi->isl29029_class,
+ NULL, 0, "%s", "lightsensor");
+ if (unlikely(IS_ERR(lpi->ls_dev))) {
+ ret = PTR_ERR(lpi->ls_dev);
+ lpi->ls_dev = NULL;
+ goto err_create_ls_device;
+ }
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ls_dev, &dev_attr_ls_adc);
+ if (ret)
+ goto err_create_ls_device_file;
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ls_dev, &dev_attr_ls_auto);
+ if (ret)
+ goto err_create_ls_device_file;
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ls_dev, &dev_attr_ls_kadc);
+ if (ret)
+ goto err_create_ls_device_file;
+
+ lpi->ps_dev = device_create(lpi->isl29029_class,
+ NULL, 0, "%s", "proximity");
+ if (unlikely(IS_ERR(lpi->ps_dev))) {
+ ret = PTR_ERR(lpi->ps_dev);
+ lpi->ps_dev = NULL;
+ goto err_create_ls_device_file;
+ }
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ps_dev, &dev_attr_ps_adc);
+ if (ret)
+ goto err_create_ps_device;
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ps_dev, &dev_attr_ps_kadc);
+ if (ret)
+ goto err_create_ps_device;
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ps_dev, &dev_attr_ps_led);
+ if (ret)
+ goto err_create_ps_device;
+
+ /* register the attributes */
+ ret = device_create_file(lpi->ps_dev, &dev_attr_ps_test_mode);
+ if (ret)
+ goto err_create_ps_device;
+
+ IPS("%s: Probe success! [CONFIGURE from board]\n", __func__);
+ return ret;
+
+err_create_ps_device:
+ device_unregister(lpi->ps_dev);
+err_create_ls_device_file:
+ device_unregister(lpi->ls_dev);
+err_create_ls_device:
+ class_destroy(lpi->isl29029_class);
+err_create_class:
+err_isl29029_setup:
+ destroy_workqueue(lpi->lp_wq);
+err_create_singlethread_workqueue:
+err_lightsensor_update_table:
+err_psensor_setup:
+err_lightsensor_setup:
+err_platform_data_null:
+ kfree(lpi);
+ return ret;
+}
+
+static const struct i2c_device_id isl29029_i2c_id[] = {
+ {ISL29029_I2C_NAME, 0},
+ {}
+};
+
+static struct i2c_driver isl29029_driver = {
+ .id_table = isl29029_i2c_id,
+ .probe = isl29029_probe,
+ .suspend = isl29029_suspend,
+ .resume = isl29029_resume,
+ .driver = {
+ .name = ISL29029_I2C_NAME,
+ .owner = THIS_MODULE,
+ },
+};
+
+static int __init isl29029_init(void)
+{
+ return i2c_add_driver(&isl29029_driver);
+}
+
+static void __exit isl29029_exit(void)
+{
+ i2c_del_driver(&isl29029_driver);
+}
+
+module_init(isl29029_init);
+module_exit(isl29029_exit);
+
+MODULE_DESCRIPTION("ISL29029 Driver");
+MODULE_LICENSE("GPL");
diff --git a/include/linux/isl29028.h b/include/linux/isl29028.h
new file mode 100644
index 0000000..0420442
--- /dev/null
+++ b/include/linux/isl29028.h
@@ -0,0 +1,62 @@
+/* include/linux/isl29028.h
+ *
+ * Copyright (C) 2010 HTC, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ *
+ */
+
+#ifndef __ISL29028_H
+#define __ISL29028_H
+
+#define ISL29028_I2C_NAME "isl29028"
+
+#define ISL29028_CHIPID 0x00
+#define ISL29028_CONFIGURE 0x01
+#define ISL29028_INTERRUPT 0x02
+#define ISL29028_PROX_LT 0x03
+#define ISL29828_PROX_HT 0x04
+#define ISL29028_LS_TH1 0x05
+#define ISL29028_LS_TH2 0x06
+#define ISL29028_LS_TH3 0x07
+#define ISL29028_PROX_DATA 0x08
+#define ISL29028_LS_DATA1 0x09
+#define ISL29028_LS_DATA2 0x0A
+#define ISL29028_TEST1 0x0E
+#define ISL29028_TEST2 0x0F
+
+#define ISL29028_PROX_EN (1 << 7)
+#define ISL29028_PROX_DR (1 << 3)
+#define ISL29028_ALS_EN (1 << 2)
+#define ISL29028_INT_PROX_FLAG (1 << 7)
+#define ISL29028_INT_ALS_FLAG (1 << 3)
+#define ISL29028_INT_ALS_PRST (2 << 1)
+
+#define ALS_CALIBRATED 0x6DA5
+#define PS_CALIBRATED 0x5053
+
+extern unsigned int ps_kparam1;
+extern unsigned int ps_kparam2;
+
+struct isl29028_platform_data {
+ int intr;
+ uint16_t levels[10];
+ uint16_t golden_adc;
+ int (*power)(int, uint8_t); /* power to the chip */
+ int (*calibrate_func)(int, int, int, int, int*, int*);
+ uint8_t lt;
+ uint8_t ht;
+ uint8_t debounce;
+ uint8_t *mapping_table;
+ uint8_t mapping_size;
+ uint8_t enable_polling_ignore;
+};
+
+#endif
diff --git a/include/linux/isl29029.h b/include/linux/isl29029.h
new file mode 100644
index 0000000..90f1487
--- /dev/null
+++ b/include/linux/isl29029.h
@@ -0,0 +1,63 @@
+/* include/linux/isl29029.h
+ *
+ * Copyright (C) 2010 HTC, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * 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.
+ *
+ */
+
+#ifndef __ISL29029_H
+#define __ISL29029_H
+
+#define ISL29029_I2C_NAME "isl29029"
+
+#define ISL29029_CHIPID 0x00
+#define ISL29029_CONFIGURE 0x01
+#define ISL29029_INTERRUPT 0x02
+#define ISL29029_PROX_LT 0x03
+#define ISL29828_PROX_HT 0x04
+#define ISL29029_LS_TH1 0x05
+#define ISL29029_LS_TH2 0x06
+#define ISL29029_LS_TH3 0x07
+#define ISL29029_PROX_DATA 0x08
+#define ISL29029_LS_DATA1 0x09
+#define ISL29029_LS_DATA2 0x0A
+#define ISL29029_TEST1 0x0E
+#define ISL29029_TEST2 0x0F
+
+#define ISL29029_PROX_EN (1 << 7)
+#define ISL29029_PROX_DR (1 << 3)
+#define ISL29029_ALS_EN (1 << 2)
+#define ISL29029_INT_PROX_FLAG (1 << 7)
+#define ISL29029_INT_ALS_FLAG (1 << 3)
+#define ISL29029_INT_ALS_PRST (2 << 1)
+
+#define ALS_CALIBRATED 0x6DA5
+#define PS_CALIBRATED 0x5053
+
+extern unsigned int ps_kparam1;
+extern unsigned int ps_kparam2;
+
+struct isl29029_platform_data {
+ int intr;
+ uint16_t levels[10];
+ uint16_t golden_adc;
+ int (*power)(int, uint8_t); /* power to the chip */
+ int (*calibrate_func)(int, int, int, int, int*, int*);
+ uint8_t lt;
+ uint8_t ht;
+ uint8_t debounce;
+ uint8_t *mapping_table;
+ uint8_t mapping_size;
+ uint8_t enable_polling_ignore;
+ uint8_t default_config_reg;
+};
+
+#endif