Gitiles
Code Review Sign In
LeafOS / LeafOS-Devices / android_kernel_samsung_exynos9820 / 47320233b0588873e131d00d1f7103a4b8311a92 / . / drivers / optics / vd6281.c
blob: c576012e16df1a9fc21bd4d4121ae97dc456ead7 [file] [log] [blame]
/*
* Copyright (C) 2018 Samsung Electronics Co., Ltd. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License, 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.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define VENDOR "STM"
#define VD6281_CHIP_NAME "VD6281"
#define VERSION "0"
#define SUB_VERSION "1"
#define VENDOR_VERSION "s"
#define MODULE_NAME_ALS "als_rear"
#define VD6281_SLAVE_I2C_ADDR 0x20
#define VD6281_I2C_RETRY_DELAY 10
#define VD6281_I2C_MAX_RETRIES 5
#if defined(CONFIG_LEDS_S2MPB02)
#define CONFIG_STM_ALS_EOL_MODE
#endif
#include "vd6281.h"
#ifdef CONFIG_STM_ALS_EOL_MODE
#include <linux/leds-s2mpb02.h>
#define DEFAULT_DUTY_50HZ 5000
#define DEFAULT_DUTY_60HZ 4166
#define MAX_TEST_RESULT 256
#define EOL_COUNT 20
#define EOL_SKIP_COUNT 5
#define DEFAULT_IR_SPEC_MIN 0
#define DEFAULT_IR_SPEC_MAX 500000
static u32 gSpec_ir_min = DEFAULT_IR_SPEC_MIN;
static u32 gSpec_ir_max = DEFAULT_IR_SPEC_MAX;
static u32 gSpec_clear_min = DEFAULT_IR_SPEC_MIN;
static u32 gSpec_clear_max = DEFAULT_IR_SPEC_MAX;
#define FREQ100_SPEC_IN(X) ((X == 100)?"PASS":"FAIL")
#define FREQ120_SPEC_IN(X) ((X == 120)?"PASS":"FAIL")
#define IR_SPEC_IN(X) ((X >= gSpec_ir_min && X <= gSpec_ir_max)?"PASS":"FAIL")
#define CLEAR_SPEC_IN(X) ((X >= gSpec_clear_min && X <= gSpec_clear_max)?"PASS":"FAIL")
#endif
#define ALS_CHANNELS (STALS_CHANNEL_1|STALS_CHANNEL_3|STALS_CHANNEL_4|STALS_CHANNEL_5|STALS_CHANNEL_2)
#define FLK_CHANNEL STALS_CHANNEL_6
static int als_debug = 1;
static int als_info;
module_param(als_debug, int, S_IRUGO | S_IWUSR);
module_param(als_info, int, S_IRUGO | S_IWUSR);
static struct vd6281_device_data *vd6281_data;
/* only gcc compiler is supported */
/*Kernel / user code compatibility macro */
#ifndef __KERNEL__
#define POPCOUNT(a) __builtin_popcount(a)
#define div64_u64(a, b) ((a) / (b))
#else
#define POPCOUNT(a) hweight_long(a)
#define assert(c) BUG_ON(c)
#endif
#define UNUSED_P(x) x __attribute__((unused))
#define VERSION_MAJOR 1
#define VERSION_MINOR 0
#define VERSION_REVISION 0
#define VD6281_DEVICE 0x70
#define VD6281_REVISION_CUT_2_0 0xBA
#define VD6281_REVISION_CUT_2_1 0xBB
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
#endif
#define VD6281_DC_CHANNELS_MASK 0x1f
#define VD6281_AC_CHANNELS_MASK 0x20
#define VD6281_DEFAULT_HF_TRIM 0x0e3
#define VD6281_DEFAULT_LF_TRIM 0x07
#define VD6281_DEFAULT_FILTER_CONFIG 0
#define VD6281_DEFAULT_GAIN 0x80
#define VD6281_OTP_V1 0x7
#define VD6281_OTP_V2 0x6
#ifndef MAX
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
#ifndef MIN
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#endif
#define WA_460857 460857
#define WA_462997 462997
#define WA_461428 461428
#define WA_464174 464174
#define WA_478654 478654
static const uint16_t GainRange[] = {
0x42AB, // 66, 67
0x3200, // 50, 00
0x2154, // 33, 33
0x1900, // 25, 00
0x10AB, // 16, 67
0x0A00, // 10, 00
0x0723, // 7, 14
0x0500, // 5, 00
0x0354, // 3, 33
0x0280, // 2, 50
0x01AB, // 1, 67
0x0140, // 1, 25
0x0100, // 1, 00
0x00D4, // 0, 83
0x00B5 // 0, 71
};
static const uint16_t GainRangeThreshold[] = { //14
0x3A56,
0x29AB,
0x1D2B,
0x14D6,
0x0D56,
0x0892,
0x0612,
0x042B,
0x02EB,
0x0216,
0x0176,
0x0121,
0x00EB,
0x00C5
};
//static struct VD6281_device devices[VD6281_CONFIG_DEVICES_MAX];
static const enum STALS_Color_Id_t
channel_2_color_default[VD6281_CHANNEL_NB] = {
STALS_COLOR_CLEAR, STALS_COLOR_CLEAR, STALS_COLOR_CLEAR,
STALS_COLOR_CLEAR, STALS_COLOR_CLEAR, STALS_COLOR_CLEAR
};
static const enum STALS_Color_Id_t
channel_2_color_uv_rgb_ir[VD6281_CHANNEL_NB] = {
STALS_COLOR_RED, STALS_COLOR_GREEN, STALS_COLOR_BLUE,
STALS_COLOR_UV, STALS_COLOR_IR, STALS_COLOR_CLEAR
};
static const enum STALS_Color_Id_t *filter_mapping_array[8] = {
channel_2_color_default, channel_2_color_default,
channel_2_color_uv_rgb_ir, channel_2_color_default,
channel_2_color_default, channel_2_color_uv_rgb_ir,
channel_2_color_default, channel_2_color_default
};
#define CHECK_DEVICE_VALID(d) \
do { \
if (!d) \
return STALS_ERROR_INVALID_DEVICE_ID; \
} while (0)
#define CHECK_NULL_PTR(a) \
do { \
if (!a) \
return STALS_ERROR_INVALID_PARAMS; \
} while (0)
#define CHECK_CHANNEL_VALID(idx) \
do { \
if ((idx) >= VD6281_CHANNEL_NB) \
return STALS_ERROR_INVALID_PARAMS; \
} while (0)
#define CHECH_DEV_ST_INIT(d) \
do { \
if (d->st != DEV_INIT) \
return STALS_ERROR_ALREADY_STARTED; \
} while (0)
#define CHECK_DEV_ST_FLICKER_STARTED(d) \
do { \
if (d->st != DEV_FLICKER_RUN && d->st != DEV_BOTH_RUN) \
return STALS_ERROR_NOT_STARTED; \
} while (0)
#define CHECH_DEV_ST_FLICKER_NOT_STARTED(d) \
do { \
if (d->st == DEV_FLICKER_RUN) \
return STALS_ERROR_ALREADY_STARTED; \
if (d->st == DEV_BOTH_RUN) \
return STALS_ERROR_ALREADY_STARTED; \
} while (0)
#define CHECK_DEV_ST_ALS_STARTED(d) \
do { \
if (d->st != DEV_ALS_RUN && d->st != DEV_BOTH_RUN) \
return STALS_ERROR_NOT_STARTED; \
} while (0)
#define CHECH_DEV_ST_ALS_NOT_STARTED(d) \
do { \
if (d->st == DEV_ALS_RUN) \
return STALS_ERROR_ALREADY_STARTED; \
if (d->st == DEV_BOTH_RUN) \
return STALS_ERROR_ALREADY_STARTED; \
} while (0)
#define CHECK_CHANNEL_MASK_VALID_FOR_ALS(m) \
do { \
/* check there is no invalid channel selected */ \
if ((m) & ~((1 << STALS_ALS_MAX_CHANNELS) - 1)) \
return STALS_ERROR_INVALID_PARAMS; \
} while (0)
#define CHECK_CHANNEL_MASK_VALID(m) \
do { \
/* check there is no invalid channel selected */ \
if ((m) & ~((1 << STALS_ALS_MAX_CHANNELS) - 1)) \
return STALS_ERROR_INVALID_PARAMS; \
/* check there is at least one channel */ \
if (!(m)) \
return STALS_ERROR_INVALID_PARAMS; \
} while (0)
#define CHECK_CHANNEL_NOT_IN_USE(d, c) \
do { \
if (d->als.chan & (c)) \
return STALS_ERROR_INVALID_PARAMS; \
if (d->flk.chan & (c)) \
return STALS_ERROR_INVALID_PARAMS; \
} while (0)
#define US_TO_NS(x) (x * 1E3L)
#define ALS_WORK_DELAY 500
static void vd6281_debug_var(struct vd6281_device_data *data)
{
ALS_dbg("===== %s =====\n", __func__);
ALS_dbg("%s client %p slave_addr 0x%x\n", __func__,
data->client, data->client->addr);
ALS_dbg("%s dev %p\n", __func__, data->dev);
ALS_dbg("%s als_input_dev %p\n", __func__, data->als_input_dev);
ALS_dbg("%s als_pinctrl %p\n", __func__, data->als_pinctrl);
ALS_dbg("%s pins_sleep %p\n", __func__, data->pins_sleep);
ALS_dbg("%s pins_idle %p\n", __func__, data->pins_idle);
ALS_dbg("%s vdd_1p8 %s\n", __func__, data->vdd_1p8);
ALS_dbg("%s i2c_1p8 %s\n", __func__, data->i2c_1p8);
ALS_dbg("%s als_enabled %d\n", __func__, data->enabled);
ALS_dbg("%s als_sampling_rate %d\n", __func__, data->sampling_period_ns);
ALS_dbg("%s regulator_state %d\n", __func__, data->regulator_state);
ALS_dbg("%s als_int %d\n", __func__, data->pin_als_int);
ALS_dbg("%s als_en %d\n", __func__, data->pin_als_en);
ALS_dbg("%s als_irq %d\n", __func__, data->dev_irq);
ALS_dbg("%s irq_state %d\n", __func__, data->irq_state);
ALS_dbg("===== %s =====\n", __func__);
}
static DECLARE_WORK(vd6281_flicker_work, vd6281_flicker_work_cb);
int vd6281_get_adc_data()
{
int adc_data, ret;
ret = iio_read_channel_raw(vd6281_data->chan, &adc_data);
if (ret < 0)
ALS_err("%s : err(%d) returned, skip read\n", __func__, adc_data);
return adc_data;
}
void vd6281_flicker_work_cb(struct work_struct *w)
{
int adc = vd6281_get_adc_data();
vd6281_data->flicker_data[vd6281_data->flicker_cnt - 1] = adc;
if (vd6281_data->flicker_cnt == 199) {
input_report_rel(vd6281_data->als_input_dev, REL_RZ, -1);
input_sync(vd6281_data->als_input_dev);
}
// ALS_dbg("===== %s =====(adc_data : %d) cnt : %d\n", __func__,
// adc, vd6281_data->flicker_cnt - 1);
}
enum hrtimer_restart my_hrtimer_callback(struct hrtimer *timer)
{
int ret;
vd6281_data->flicker_cnt++;
ret = queue_work(vd6281_data->flicker_work, &vd6281_flicker_work);
if (ret == 0)
ALS_err("failed in queue_work\n");
hrtimer_forward(&vd6281_data->timer.timer, hrtimer_cb_get_time(&vd6281_data->timer.timer), ktime_set(0, US_TO_NS(2500)));
return HRTIMER_RESTART;
}
int start_flicker_timer(void)
{
vd6281_data->flicker_cnt = 0;
tasklet_hrtimer_start(&vd6281_data->timer, ktime_set(0, US_TO_NS(2500)), HRTIMER_MODE_REL);
return 0;
}
void stop_flicker_timer(void)
{
tasklet_hrtimer_cancel(&vd6281_data->timer);
ALS_dbg("%s, timer cleanup success\n", __func__);
}
static void vd6281_als_work(struct work_struct *w)
{
STALS_ErrCode_t res;
struct delayed_work *work_queue;
// struct VD6281_device *dev;
struct STALS_Als_t meas;
uint8_t is_valid;
unsigned long timeout;
ALS_dbg("%s\n", __func__);
work_queue = container_of(w, struct delayed_work, work);
// dev = container_of(work_queue, struct vd6281_device_data, rear_als_work);
timeout = wait_for_completion_timeout(&vd6281_data->completion, VD6281_ADC_TIMEOUT);
if (timeout == 0) {
ALS_err("%s wait_for_completion_timeout err err err errr\n", __func__);
}
stop_flicker_timer();
// if (work_pending(&vd6281_data->flicker_work)) {
// ALS_dbg("Gas - cancel_delayed_work\n");
// cancel_work(&vd6281_data->flicker_work);
// }
res = STALS_GetAlsValues(vd6281_data->devices.hdl, ALS_CHANNELS, &meas, &is_valid);
res = STALS_Stop(vd6281_data->devices.hdl, STALS_MODE_ALS_SINGLE_SHOT);
res = STALS_Stop(vd6281_data->devices.hdl, STALS_MODE_FLICKER);
ALS_dbg("%s IR(%d), RED(%d), GREEN(%d), BLUE(%d), CLEAR(%d)\n", __func__,
meas.CountValue[STALS_COLOR_IR-1],
meas.CountValue[STALS_COLOR_RED-1],
meas.CountValue[STALS_COLOR_GREEN-1],
meas.CountValue[STALS_COLOR_BLUE-1],
meas.CountValue[STALS_COLOR_CLEAR-1]);
input_report_rel(vd6281_data->als_input_dev, REL_X, meas.CountValue[STALS_COLOR_IR-1] + 1);
input_report_rel(vd6281_data->als_input_dev, REL_Y, meas.CountValue[STALS_COLOR_RED-1] + 1);
input_report_rel(vd6281_data->als_input_dev, REL_Z, meas.CountValue[STALS_COLOR_GREEN-1] + 1);
input_report_rel(vd6281_data->als_input_dev, REL_RX, meas.CountValue[STALS_COLOR_BLUE-1] + 1);
input_report_rel(vd6281_data->als_input_dev, REL_RY, meas.CountValue[STALS_COLOR_CLEAR-1] + 1);
// input_report_abs(vd6281_data->als_input_dev, ABS_X, meas.time_us + 1);
// input_report_abs(vd6281_data->als_input_dev, ABS_Y, meas.gain + 1);
input_sync(vd6281_data->als_input_dev);
memset(vd6281_data->flicker_data, 0, sizeof(vd6281_data->flicker_data));
res = STALS_Start(vd6281_data->devices.hdl, STALS_MODE_ALS_SINGLE_SHOT, ALS_CHANNELS);
res = STALS_Start(vd6281_data->devices.hdl, STALS_MODE_FLICKER, FLK_CHANNEL);
reinit_completion(&vd6281_data->completion);
start_flicker_timer();
schedule_delayed_work(&vd6281_data->rear_als_work, msecs_to_jiffies(ALS_WORK_DELAY));
}
static int vd6281_write_reg(struct vd6281_device_data *device,
u8 reg_addr, u8 data)
{
int err = -1;
int tries = 0;
int num = 1;
u8 buffer[2] = { reg_addr, data };
struct i2c_msg msgs[] = {
{
.addr = device->client->addr,
.flags = device->client->flags & I2C_M_TEN,
.len = 2,
.buf = buffer,
},
};
if (!device->pm_state || device->regulator_state == 0) {
ALS_err("%s - write error, pm suspend or reg_state %d\n",
__func__, device->regulator_state);
err = -EFAULT;
return err;
}
mutex_lock(&device->suspendlock);
do {
err = i2c_transfer(device->client->adapter, msgs, num);
if (err != num)
msleep_interruptible(VD6281_I2C_RETRY_DELAY);
if (err < 0)
ALS_err("%s - i2c_transfer error = %d\n", __func__, err);
} while ((err != num) && (++tries < VD6281_I2C_MAX_RETRIES));
mutex_unlock(&device->suspendlock);
if (err != num) {
ALS_err("%s -write transfer error:%d\n", __func__, err);
err = -EIO;
device->i2c_err_cnt++;
return err;
}
return 0;
}
static int vd6281_read_reg(struct vd6281_device_data *device,
u8 reg_addr, u8 *buffer, int length)
{
int err = -1;
int tries = 0; /* # of attempts to read the device */
int num = 2;
struct i2c_msg msgs[] = {
{
.addr = device->client->addr,
.flags = device->client->flags & I2C_M_TEN,
.len = 1,
.buf = buffer,
},
{
.addr = device->client->addr,
.flags = (device->client->flags & I2C_M_TEN) | I2C_M_RD,
.len = length,
.buf = buffer,
},
};
if (!device->pm_state || device->regulator_state == 0) {
ALS_err("%s - read error, pm suspend or reg_state %d\n",
__func__, device->regulator_state);
err = -EFAULT;
return err;
}
mutex_lock(&device->suspendlock);
do {
buffer[0] = reg_addr;
err = i2c_transfer(device->client->adapter, msgs, num);
if (err != num)
msleep_interruptible(VD6281_I2C_RETRY_DELAY);
if (err < 0)
ALS_err("%s - i2c_transfer error = %d\n", __func__, err);
} while ((err != num) && (++tries < VD6281_I2C_MAX_RETRIES));
mutex_unlock(&device->suspendlock);
if (err != num) {
ALS_err("%s -read transfer error:%d\n", __func__, err);
err = -EIO;
device->i2c_err_cnt++;
} else
err = 0;
return err;
}
STALS_ErrCode_t STALS_WrByte(void *pClient, uint8_t index, uint8_t data)
{
vd6281_write_reg(vd6281_data, index, data);
return STALS_NO_ERROR;
}
STALS_ErrCode_t STALS_RdByte(void *pClient, uint8_t index, uint8_t *data)
{
uint8_t length = 1;
vd6281_read_reg(vd6281_data, index, data, length);
return STALS_NO_ERROR;
}
STALS_ErrCode_t STALS_RdMultipleBytes(void *pClient, uint8_t index,
uint8_t *data, int nb)
{
STALS_ErrCode_t res;
int i;
for (i = 0; i < nb; i++) {
res = vd6281_read_reg(vd6281_data, index + i, &data[i], 1);
if (res)
return res;
}
return STALS_NO_ERROR;
}
static inline int channelId_2_index(enum STALS_Channel_Id_t ChannelId)
{
return POPCOUNT(ChannelId) == 1 ? __builtin_ctz(ChannelId) :
STALS_ALS_MAX_CHANNELS;
}
static int is_cut_2_0(struct VD6281_device *dev)
{
return (dev->device_id == VD6281_DEVICE) &&
(dev->revision_id == VD6281_REVISION_CUT_2_0);
}
static int is_cut_2_1(struct VD6281_device *dev)
{
return (dev->device_id == VD6281_DEVICE) &&
(dev->revision_id == VD6281_REVISION_CUT_2_1);
}
struct VD6281_device *vd6281_get_device(void **pHandle)
{
#if 0
uint32_t i;
//
// for (i = 0; i < VD6281_CONFIG_DEVICES_MAX; i++) {
/ if (!vd6281_data->devices[i].st)
break;
}
*pHandle = (void *)(uintptr_t)i;
return i == VD6281_CONFIG_DEVICES_MAX ? NULL : &vd6281_data->devices[i];
#endif
*pHandle = (void *)(uintptr_t) 0;
return &vd6281_data->devices;
}
static void setup_device(struct VD6281_device *dev, void *pClient, void *hdl)
{
memset(dev, 0, sizeof(*dev));
dev->client = pClient;
dev->hdl = hdl;
dev->st = DEV_INIT;
dev->is_otp_usage_enable = STALS_CONTROL_ENABLE;
dev->is_output_dark_enable = STALS_CONTROL_DISABLE;
dev->exposure = 80000;
}
static void select_device_wa(struct VD6281_device *dev)
{
dev->wa_codex_460857 = 1;
dev->wa_codex_462997 = 1;
dev->wa_codex_461428 = 1;
dev->wa_codex_464174 = is_cut_2_0(dev);
dev->wa_codex_478654 = 1;
}
static STALS_ErrCode_t otp_read_bank(struct VD6281_device *dev, int bank,
int bit_start, int bit_end, uint32_t *opt)
{
int bit_nb = bit_end - bit_start + 1;
uint32_t bit_mask = (1 << bit_nb) - 1;
*opt = (dev->otp_bits[bank] >> bit_start) & bit_mask;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t otp_read(struct VD6281_device *dev, int bit_start,
int bit_nb, uint32_t *otp, int bit_swap)
{
STALS_ErrCode_t res;
const int bit_end = bit_start + bit_nb - 1;
uint32_t bank0 = 0;
uint32_t bank1 = 0;
uint32_t result;
uint32_t result_swap;
int bank1_shift = 0;
int i;
#ifndef __KERNEL__
assert(bit_nb <= 24);
assert(bit_end < 120);
#endif
if (bit_start < 64) {
res = otp_read_bank(dev, 0, bit_start, MIN(63, bit_end),
&bank0);
if (res)
return res;
bank1_shift = MIN(63, bit_end) - bit_start + 1;
}
if (bit_end >= 64) {
res = otp_read_bank(dev, 1, MAX(0, bit_start - 64),
bit_end - 64, &bank1);
if (res)
return res;
}
result = bank0 | (bank1 << bank1_shift);
if (bit_swap) {
result_swap = 0;
for (i = 0; i < bit_nb; i++) {
if ((result >> i) & 1)
result_swap |= 1 << (bit_nb - 1 - i);
}
}
*otp = bit_swap ? result_swap : result;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t check_supported_device(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
res = STALS_RdByte(dev->client, VD6281_DEVICE_ID, &dev->device_id);
if (res)
return res;
res = STALS_RdByte(dev->client, VD6281_REVISION_ID, &dev->revision_id);
if (res)
return res;
if (is_cut_2_0(dev))
return STALS_NO_ERROR;
if (is_cut_2_1(dev))
return STALS_NO_ERROR;
return STALS_ERROR_INIT;
}
static STALS_ErrCode_t is_data_ready(struct VD6281_device *dev,
uint8_t *is_data_ready)
{
STALS_ErrCode_t res;
uint8_t isr_ctrl_st;
res = STALS_RdByte(dev->client, VD6281_IRQ_CTRL_ST, &isr_ctrl_st);
*is_data_ready = !(isr_ctrl_st & 0x02);
return res;
}
static STALS_ErrCode_t ac_mode_update(struct VD6281_device *dev, uint8_t mask,
uint8_t data)
{
STALS_ErrCode_t res;
uint8_t ac_mode;
res = STALS_RdByte(dev->client, VD6281_AC_MODE, &ac_mode);
if (res)
return res;
ac_mode = (ac_mode & ~mask) | (data & mask);
return STALS_WrByte(dev->client, VD6281_AC_MODE, ac_mode);
}
static STALS_ErrCode_t read_channel(struct VD6281_device *dev, int chan,
uint32_t *measure)
{
STALS_ErrCode_t res;
uint8_t values[3];
res = STALS_RdMultipleBytes(dev->client, VD6281_CHANNELx_MM(chan),
values, 3);
if (res)
return res;
*measure = (values[0] << 16) + (values[1] << 8) + values[2];
return STALS_NO_ERROR;
}
static STALS_ErrCode_t acknowledge_irq(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
res = STALS_WrByte(dev->client, VD6281_IRQ_CTRL_ST, 1);
if (res)
return res;
res = STALS_WrByte(dev->client, VD6281_IRQ_CTRL_ST, 0);
if (res)
return res;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t dev_sw_reset(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
res = STALS_WrByte(dev->client, VD6281_GLOBAL_RESET, 1);
if (res)
return res;
res = STALS_WrByte(dev->client, VD6281_GLOBAL_RESET, 0);
if (res)
return res;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t opt_reset(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
uint8_t status;
int max_loop_nb = 100;
res = STALS_WrByte(dev->client, VD6281_OTP_CTRL1, 0);
if (res)
return res;
do {
res = STALS_RdByte(dev->client, VD6281_OTP_STATUS, &status);
if (res)
return res;
} while ((status & VD6281_OTP_DATA_READY) !=
VD6281_OTP_DATA_READY && --max_loop_nb);
if (!max_loop_nb)
return STALS_ERROR_TIME_OUT;
return STALS_NO_ERROR;
}
static uint8_t byte_bit_reversal(uint8_t d)
{
d = ((d & 0xaa) >> 1) | ((d & 0x55) << 1);
d = ((d & 0xcc) >> 2) | ((d & 0x33) << 2);
d = ((d & 0xf0) >> 4) | ((d & 0x0f) << 4);
return d;
}
static STALS_ErrCode_t opt_read_init(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
uint8_t reg[8];
int i;
dev->otp_bits[0] = 0;
res = STALS_RdMultipleBytes(dev->client, VD6281_OTP_BANK_0, reg, 8);
if (res)
return res;
for (i = 0; i < 7; i++) {
dev->otp_bits[0] |=
(uint64_t) byte_bit_reversal(reg[i]) << (i * 8);
}
reg[7] = byte_bit_reversal(reg[7]) >> 4;
dev->otp_bits[0] |= (uint64_t) reg[7] << 56;
res = STALS_RdMultipleBytes(dev->client, VD6281_OTP_BANK_1, reg, 8);
if (res)
return res;
reg[0] = byte_bit_reversal(reg[0]);
dev->otp_bits[0] |= (uint64_t) (reg[0] & 0x0f) << 60;
dev->otp_bits[1] = reg[0] >> 4;
for (i = 1; i < 7; i++) {
dev->otp_bits[1] |=
(uint64_t) byte_bit_reversal(reg[i]) << (i * 8 - 4);
}
reg[7] = byte_bit_reversal(reg[7]) >> 4;
dev->otp_bits[1] |= (uint64_t) reg[7] << 52;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t otp_read_param_v1_v2(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
uint32_t otp_data;
int i;
res = otp_read(dev, 51, 9, &otp_data, 1);
if (res)
goto error;
dev->otp.hf_trim = otp_data;
res = otp_read(dev, 116, 4, &otp_data, 1);
if (res)
goto error;
dev->otp.lf_trim = otp_data;
res = otp_read(dev, 48, 3, &otp_data, 1);
if (res)
goto error;
dev->otp.filter_config = otp_data;
for (i = 0; i < STALS_ALS_MAX_CHANNELS; i++) {
res = otp_read(dev, i * 8, 8, &otp_data, 1);
if (res)
goto error;
/* 0 is not a valid value */
dev->otp.gains[i] = otp_data ? otp_data : VD6281_DEFAULT_GAIN;
}
return STALS_NO_ERROR;
error:
return res;
}
static STALS_ErrCode_t otp_read_param(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
uint32_t otp_data;
int i;
/* default values in case we don't recognize otp version */
dev->otp.hf_trim = VD6281_DEFAULT_HF_TRIM;
dev->otp.lf_trim = VD6281_DEFAULT_LF_TRIM;
dev->otp.filter_config = VD6281_DEFAULT_FILTER_CONFIG;
for (i = 0; i < STALS_ALS_MAX_CHANNELS; i++)
dev->otp.gains[i] = VD6281_DEFAULT_GAIN;
/* read otp version */
res = otp_read(dev, 113, 3, &otp_data, 1);
if (res)
goto error;
switch (otp_data) {
case VD6281_OTP_V1:
case VD6281_OTP_V2:
res = otp_read_param_v1_v2(dev);
break;
default:
/* default values will be applied */
break;
}
error:
return res;
}
static STALS_ErrCode_t trim_oscillators(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
uint16_t hf_trim = dev->is_otp_usage_enable ? dev->otp.hf_trim :
VD6281_DEFAULT_HF_TRIM;
uint8_t lf_trim = dev->is_otp_usage_enable ? dev->otp.lf_trim :
VD6281_DEFAULT_LF_TRIM;
/* 10.24Mhz */
res = STALS_WrByte(dev->client, VD6281_OSC10M, 1);
if (res)
return res;
res = STALS_WrByte(dev->client, VD6281_OSC10M_TRIM_M,
(hf_trim >> 8) & 0x01);
if (res)
return res;
res = STALS_WrByte(dev->client, VD6281_OSC10M_TRIM_L,
(hf_trim >> 0) & 0xff);
if (res)
return res;
/* 48.7 Khz */
res = STALS_WrByte(dev->client, VD6281_OSC50K_TRIM, lf_trim & 0x0f);
if (res)
return res;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t clamp_enable(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
res = STALS_WrByte(dev->client, VD6281_AC_CLAMP_EN, 1);
if (res)
return res;
res = STALS_WrByte(dev->client, VD6281_DC_CLAMP_EN, 0x1f);
if (res)
return res;
/* set count to be independent of pd nummbers */
res = STALS_WrByte(dev->client, VD6281_SPARE_1, 0x3f);
if (res)
return res;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t dev_configuration(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
const uint8_t pds[] = {0x07, 0x07, 0x07, 0x1f, 0x0f, 0x1f};
int c;
res = opt_reset(dev);
if (res)
return res;
res = opt_read_init(dev);
if (res)
return res;
res = otp_read_param(dev);
if (res)
return res;
res = trim_oscillators(dev);
if (res)
return res;
res = clamp_enable(dev);
if (res)
return res;
for (c = 0; c < STALS_ALS_MAX_CHANNELS; c++) {
res = STALS_WrByte(dev->client, VD6281_SEL_PD_x(c), pds[c]);
if (res)
return res;
}
for (c = 0; c < STALS_ALS_MAX_CHANNELS; c++) {
res = set_channel_gain(dev, c, 0x0100); // default 25x
if (res)
return res;
}
res = set_pedestal_value(dev, 3);
if (res)
return res;
return STALS_NO_ERROR;
}
void vd6281_put_device(struct VD6281_device *dev)
{
dev_sw_reset(dev);
dev->st = DEV_FREE;
}
static struct VD6281_device *get_active_device(void *pHandle)
{
uint32_t handle = (uint32_t)(uintptr_t) pHandle;
if (handle >= VD6281_CONFIG_DEVICES_MAX)
return NULL;
if (vd6281_data->devices.st == DEV_FREE)
return NULL;
return &vd6281_data->devices;
}
static STALS_ErrCode_t get_channel_gain(struct VD6281_device *dev, int c,
uint16_t *pAppliedGain)
{
*pAppliedGain = dev->gains[c];
return STALS_NO_ERROR;
}
STALS_ErrCode_t set_channel_gain(struct VD6281_device *dev, int c,
uint16_t Gain)
{
STALS_ErrCode_t res;
uint8_t vref;
for (vref = ARRAY_SIZE(GainRange) - 1; vref > 0; vref--) {
if (Gain < GainRangeThreshold[vref - 1])
break;
}
res = STALS_WrByte(dev->client, VD6281_CHANNEL_VREF(c), vref + 1);
if (res)
return res;
dev->gains[c] = GainRange[vref];
return STALS_NO_ERROR;
}
static STALS_ErrCode_t get_exposure(struct VD6281_device *dev,
uint32_t *pAppliedExpoTimeUs)
{
*pAppliedExpoTimeUs = dev->exposure;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t set_exposure(struct VD6281_device *dev,
uint32_t ExpoTimeInUs, int is_cache_updated)
{
const uint32_t step_size_us = 1600;
const uint32_t rounding = step_size_us / 2;
uint32_t exposure;
uint64_t exposure_acc;
STALS_ErrCode_t res;
/* avoid integer overflow using intermediate 64 bits arithmetics */
exposure_acc = ExpoTimeInUs + (uint64_t) rounding;
exposure = div64_u64(MIN(exposure_acc, 0xffffffffULL), step_size_us);
exposure = MAX(exposure, 1);
exposure = MIN(exposure, 0x3ff);
res = STALS_WrByte(dev->client, VD6281_EXPOSURE_L, exposure & 0xff);
if (res)
return res;
res = STALS_WrByte(dev->client, VD6281_EXPOSURE_M,
(exposure >> 8) & 0x3);
if (res)
return res;
if (is_cache_updated)
dev->exposure = exposure * step_size_us;
return STALS_NO_ERROR;
}
static uint8_t dev_enable_dc_chan_en_for_mode(struct VD6281_device *dev,
enum STALS_Mode_t mode, uint8_t channels)
{
int is_flk = mode == STALS_MODE_FLICKER;
uint8_t res;
res = (channels & VD6281_DC_CHANNELS_MASK) | dev->dc_chan_en;
if (dev->wa_codex_460857) {
/* wa is easy. We force channel 4 activation when we are in
* condition of the codex => als mode and als only use channel 6
* (note this is not an optimal way to fix the problem)
*/
if (!is_flk && channels == STALS_CHANNEL_6)
res |= STALS_CHANNEL_4;
}
return res;
}
static STALS_ErrCode_t dev_enable_channels_for_mode(struct VD6281_device *dev,
enum STALS_Mode_t mode, uint8_t channels)
{
uint8_t active_chan = dev->als.chan | dev->flk.chan;
int is_flk = mode == STALS_MODE_FLICKER;
uint8_t dc_chan_en;
STALS_ErrCode_t res;
dc_chan_en = dev_enable_dc_chan_en_for_mode(dev, mode, channels);
if (channels & active_chan)
return STALS_ERROR_INVALID_PARAMS;
if (dc_chan_en ^ dev->dc_chan_en) {
res = STALS_WrByte(dev->client, VD6281_DC_EN, dc_chan_en);
if (res)
return res;
}
/* if wa_codex_464174 active then be sure to always turn on ac channel
*/
if (((channels & VD6281_AC_CHANNELS_MASK) || dev->wa_codex_464174) &&
!dev->ac_chan_en) {
res = STALS_WrByte(dev->client, VD6281_AC_EN, 1);
if (res) {
STALS_WrByte(dev->client, VD6281_DC_EN,
dev->dc_chan_en);
return res;
}
dev->ac_chan_en = 1;
}
dev->dc_chan_en = dc_chan_en;
if (is_flk)
dev->flk.chan = channels;
else
dev->als.chan = channels;
return STALS_NO_ERROR;
}
static uint8_t dev_disable_dc_chan_en_for_mode(struct VD6281_device *dev,
enum STALS_Mode_t mode)
{
int is_flk = mode == STALS_MODE_FLICKER;
uint8_t channels = is_flk ? dev->flk.chan : dev->als.chan;
uint8_t res;
res = dev->dc_chan_en & ~(channels & VD6281_DC_CHANNELS_MASK);
if (dev->wa_codex_460857) {
/* We need to be sure to keep channel 4 if still need but we
* also to be sure is't turn off when no more need
*/
if (is_flk) {
/* avoid to turn off channel 4 in case we need it to wa
* als complete codex
*/
if (dev->als.chan == STALS_CHANNEL_6
&& dev->flk.chan == STALS_CHANNEL_4)
res = res | STALS_CHANNEL_4;
} else {
/* be sure to turn off channel 4 in case we turn it on
* to wa als complete codex
*/
if (dev->als.chan == STALS_CHANNEL_6 &&
dev->flk.chan != STALS_CHANNEL_4)
res = res & ~STALS_CHANNEL_4;
}
}
return res;
}
static STALS_ErrCode_t dev_disable_channels_for_mode(struct VD6281_device *dev,
enum STALS_Mode_t mode)
{
int is_flk = mode == STALS_MODE_FLICKER;
uint8_t channels = is_flk ? dev->flk.chan : dev->als.chan;
uint8_t dc_chan_en = dev_disable_dc_chan_en_for_mode(dev, mode);
STALS_ErrCode_t res;
if (dc_chan_en ^ dev->dc_chan_en) {
res = STALS_WrByte(dev->client, VD6281_DC_EN, dc_chan_en);
if (res)
return res;
}
/* if wa_codex_464174 active then only disable ac channel when no
* channels are active
*/
if (dev->wa_codex_464174) {
uint8_t next_flk_chan = is_flk ? 0 : dev->flk.chan;
uint8_t next_als_chan = is_flk ? dev->als.chan : 0;
if (next_flk_chan == 0 && next_als_chan == 0) {
res = STALS_WrByte(dev->client, VD6281_AC_EN, 0);
if (res) {
STALS_WrByte(dev->client, VD6281_DC_EN,
dev->dc_chan_en);
return res;
}
dev->ac_chan_en = 0;
}
} else if (channels & VD6281_AC_CHANNELS_MASK) {
res = STALS_WrByte(dev->client, VD6281_AC_EN, 0);
if (res) {
STALS_WrByte(dev->client, VD6281_DC_EN,
dev->dc_chan_en);
return res;
}
dev->ac_chan_en = 0;
}
dev->dc_chan_en = dc_chan_en;
if (is_flk)
dev->flk.chan = 0;
else
dev->als.chan = 0;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t enable_flicker_output_mode(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
uint8_t pdm_select_output = PDM_SELECT_GPIO;
uint8_t pdm_select_clk = PDM_SELECT_INTERNAL_CLK;
uint8_t intr_config = 0x00;
uint8_t sel_dig = 0x00;
enum STALS_FlickerOutputType_t FlickerOutputType =
dev->flicker_output_type;
/* STALS_FLICKER_OUTPUT_ANALOG_CFG_1 : pdm data on GPIO pin through
*internal resistance and use internal clock for sigma-delta 1 bit dac.
* STALS_FLICKER_OUTPUT_DIGITAL_PDM : pdm data on GPIO pin and use
* external clock feed from CLKIN pin to drive sigma-delta 1 bit dac.
* STALS_FLICKER_OUTPUT_ANALOG_CFG_2 : pdm data on CLKIN pin and use
* internal clock for sigma-delta 1 bit dac.
*/
switch (FlickerOutputType) {
case STALS_FLICKER_OUTPUT_ANALOG_CFG_1:
intr_config = 0x02;
sel_dig = 0x0f;
break;
case STALS_FLICKER_OUTPUT_DIGITAL_PDM:
pdm_select_clk = PDM_SELECT_EXTERNAL_CLK;
intr_config = 0x01;
sel_dig = 0x0f;
break;
case STALS_FLICKER_OUTPUT_ANALOG_CFG_2:
pdm_select_output = PDM_SELECT_CLKIN;
break;
default:
assert(1);
}
res = ac_mode_update(dev, PDM_SELECT_OUTPUT | PDM_SELECT_CLK,
pdm_select_output | pdm_select_clk);
if (res)
return res;
/* interrupt pin output stage configuration */
res = STALS_WrByte(dev->client, VD6281_INTR_CFG, intr_config);
if (res)
return res;
/* interrupt output selection */
res = STALS_WrByte(dev->client, VD6281_DTEST_SELECTION, sel_dig);
if (res)
return res;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t disable_flicker_output_mode(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
/* restore ac_mode bit 4 and bit 5 */
res = ac_mode_update(dev, PDM_SELECT_OUTPUT | PDM_SELECT_CLK,
PDM_SELECT_GPIO | PDM_SELECT_INTERNAL_CLK);
if (res)
return res;
/* restore OD output stage configuration */
res = STALS_WrByte(dev->client, VD6281_INTR_CFG, 0x00);
if (res)
return res;
/* and output als_complete signal */
res = STALS_WrByte(dev->client, VD6281_DTEST_SELECTION, 0x00);
if (res)
return res;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t stop_als(struct VD6281_device *dev,
enum STALS_Mode_t mode)
{
STALS_ErrCode_t res;
if (dev->st != DEV_ALS_RUN && dev->st != DEV_BOTH_RUN)
return STALS_ERROR_NOT_STARTED;
if (dev->als_started_mode != mode)
return STALS_ERROR_NOT_STARTED;
res = STALS_WrByte(dev->client, VD6281_ALS_CTRL, 0);
if (res)
return res;
res = dev_disable_channels_for_mode(dev, mode);
if (res)
return res;
dev->st = dev->st == DEV_ALS_RUN ? DEV_INIT : DEV_FLICKER_RUN;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t start_als(struct VD6281_device *dev, uint8_t channels,
enum STALS_Mode_t mode)
{
STALS_ErrCode_t res;
uint32_t cmd = (mode == STALS_MODE_ALS_SYNCHRONOUS) ? VD6281_ALS_START |
VD6281_ALS_CONTINUOUS | VD6281_ALS_CONTINUOUS_SLAVED :
VD6281_ALS_START;
if (dev->st == DEV_ALS_RUN || dev->st == DEV_BOTH_RUN)
return STALS_ERROR_ALREADY_STARTED;
if (dev->wa_codex_461428 && mode == STALS_MODE_ALS_SYNCHRONOUS &&
(channels & STALS_CHANNEL_6))
return STALS_ERROR_INVALID_PARAMS;
if (dev->wa_codex_462997 && dev->st == DEV_FLICKER_RUN) {
/* can't do als synchronous and flicker at the same time */
if (mode == STALS_MODE_ALS_SYNCHRONOUS)
return STALS_ERROR_INVALID_PARAMS;
}
res = dev_enable_channels_for_mode(dev, mode, channels);
if (res)
return res;
if (dev->wa_codex_478654 && dev->st == DEV_FLICKER_RUN &&
(dev->als.chan & STALS_CHANNEL_6)) {
/* stop flicker */
res = ac_mode_update(dev , AC_EXTRACTOR, AC_EXTRACTOR_DISABLE);
if (res)
goto start_als_error;
}
if (dev->wa_codex_462997 && dev->st == DEV_FLICKER_RUN) {
/* need this dummy write so als single is working well with
* flicker
*/
res = STALS_WrByte(dev->client,
VD6281_ALS_CTRL, VD6281_ALS_START |
VD6281_ALS_CONTINUOUS);
if (res)
goto start_als_error;
}
res = STALS_WrByte(dev->client, VD6281_ALS_CTRL, cmd);
if (res)
goto start_als_error;
if (dev->wa_codex_478654 && dev->st == DEV_FLICKER_RUN &&
(dev->als.chan & STALS_CHANNEL_6)) {
/* restart flicker */
res = ac_mode_update(dev, AC_EXTRACTOR, AC_EXTRACTOR_ENABLE);
}
dev->st = dev->st == DEV_INIT ? DEV_ALS_RUN : DEV_BOTH_RUN;
dev->als_started_mode = mode;
return STALS_NO_ERROR;
start_als_error:
dev_disable_channels_for_mode(dev, mode);
return res;
}
static STALS_ErrCode_t start_single_shot(struct VD6281_device *dev,
uint8_t channels)
{
return start_als(dev, channels, STALS_MODE_ALS_SINGLE_SHOT);
}
static STALS_ErrCode_t start_synchronous(struct VD6281_device *dev,
uint8_t channels)
{
return start_als(dev, channels, STALS_MODE_ALS_SYNCHRONOUS);
}
static STALS_ErrCode_t start_flicker(struct VD6281_device *dev,
uint8_t channels)
{
STALS_ErrCode_t res;
uint8_t ac_channel_select;
/* This check only one channel is selected */
CHECK_CHANNEL_VALID(channelId_2_index(channels));
if (dev->st == DEV_FLICKER_RUN || dev->st == DEV_BOTH_RUN)
return STALS_ERROR_ALREADY_STARTED;
if (dev->wa_codex_462997 && dev->st == DEV_ALS_RUN) {
uint8_t value;
/* can't do als synchronous and flicker at the same time */
if (dev->als_started_mode == STALS_MODE_ALS_SYNCHRONOUS)
return STALS_ERROR_INVALID_PARAMS;
/* we can do als single and flicker at the same time but only
*if inter-measurement is zero
*/
res = STALS_RdByte(dev->client, VD6281_CONTINUOUS_PERIOD,
&value);
if (res)
return res;
if (value)
return STALS_ERROR_INVALID_PARAMS;
}
res = dev_enable_channels_for_mode(dev, STALS_MODE_FLICKER, channels);
if (res)
return res;
res = enable_flicker_output_mode(dev);
if (res) {
dev_disable_channels_for_mode(dev, STALS_MODE_FLICKER);
return res;
}
/* now enable ac and select channel ac channel */
ac_channel_select = channels == STALS_CHANNEL_6 ? 1 :
channelId_2_index(channels) + 2;
res = ac_mode_update(dev, AC_CHANNEL_SELECT | AC_EXTRACTOR,
(ac_channel_select << 1) | AC_EXTRACTOR_ENABLE);
if (res) {
disable_flicker_output_mode(dev);
dev_disable_channels_for_mode(dev, STALS_MODE_FLICKER);
return res;
}
dev->st = dev->st == DEV_INIT ? DEV_FLICKER_RUN : DEV_BOTH_RUN;
return res;
}
static STALS_ErrCode_t stop_single_shot(struct VD6281_device *dev)
{
return stop_als(dev, STALS_MODE_ALS_SINGLE_SHOT);
}
static STALS_ErrCode_t stop_synchronous(struct VD6281_device *dev)
{
return stop_als(dev, STALS_MODE_ALS_SYNCHRONOUS);
}
static STALS_ErrCode_t stop_flicker(struct VD6281_device *dev)
{
STALS_ErrCode_t res;
if (dev->st != DEV_FLICKER_RUN && dev->st != DEV_BOTH_RUN)
return STALS_ERROR_NOT_STARTED;
res = ac_mode_update(dev, AC_EXTRACTOR, AC_EXTRACTOR_DISABLE);
if (res)
return res;
disable_flicker_output_mode(dev);
dev_disable_channels_for_mode(dev, STALS_MODE_FLICKER);
dev->st = dev->st == DEV_FLICKER_RUN ? DEV_INIT : DEV_ALS_RUN;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t get_pedestal_enable(struct VD6281_device *dev,
uint32_t *value)
{
STALS_ErrCode_t res;
uint8_t ac_mode;
res = STALS_RdByte(dev->client, VD6281_AC_MODE, &ac_mode);
*value = (ac_mode & AC_PEDESTAL) ? STALS_CONTROL_DISABLE :
STALS_CONTROL_ENABLE;
return res;
}
static STALS_ErrCode_t get_pedestal_value(struct VD6281_device *dev,
uint32_t *value)
{
STALS_ErrCode_t res;
uint8_t data;
res = STALS_RdByte(dev->client, VD6281_AC_PEDESTAL, &data);
*value = data & VD6281_PEDESTAL_VALUE_MASK;
return res;
}
static STALS_ErrCode_t get_otp_usage_enable(struct VD6281_device *dev,
uint32_t *value)
{
*value = dev->is_otp_usage_enable;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t get_output_dark_enable(struct VD6281_device *dev,
uint32_t *value)
{
*value = dev->is_output_dark_enable;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t get_sda_drive_value(struct VD6281_device *dev,
uint32_t *value)
{
STALS_ErrCode_t res;
uint8_t data;
res = STALS_RdByte(dev->client, VD6281_SDA_DRIVE, &data);
data &= VD6281_SDA_DRIVE_MASK;
*value = (data + 1) * 4;
return res;
}
static STALS_ErrCode_t get_wa_status(struct VD6281_device *dev, uint32_t *value)
{
STALS_ErrCode_t res = STALS_NO_ERROR;
uint32_t value_wa = (*value) & 0x7fffffff;
uint32_t state;
switch (value_wa) {
case WA_460857:
state = dev->wa_codex_460857;
break;
case WA_462997:
state = dev->wa_codex_462997;
break;
case WA_461428:
state = dev->wa_codex_461428;
break;
case WA_464174:
state = dev->wa_codex_464174;
break;
case WA_478654:
state = dev->wa_codex_478654;
break;
default:
res = STALS_ERROR_INVALID_PARAMS;
}
if (res == STALS_NO_ERROR)
*value |= state << 31;
return res;
}
static STALS_ErrCode_t set_pedestal_enable(struct VD6281_device *dev,
uint32_t value)
{
return ac_mode_update(dev, AC_PEDESTAL,
value ? AC_PEDESTAL_ENABLE : AC_PEDESTAL_DISABLE);
}
STALS_ErrCode_t set_pedestal_value(struct VD6281_device *dev,
uint32_t value)
{
return STALS_WrByte(dev->client, VD6281_AC_PEDESTAL,
value & VD6281_PEDESTAL_VALUE_MASK);
}
static STALS_ErrCode_t set_otp_usage_enable(struct VD6281_device *dev,
uint32_t value)
{
STALS_ErrCode_t res;
dev->is_otp_usage_enable = value;
/* oscillator trimming configuration need to be done again */
res = trim_oscillators(dev);
if (res)
return res;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t set_output_dark_enable(struct VD6281_device *dev,
uint32_t value)
{
STALS_ErrCode_t res;
uint8_t pd_value = value ? 0x18 : 0x07;
res = STALS_WrByte(dev->client, VD6281_SEL_PD_x(1), pd_value);
if (res)
return res;
dev->is_output_dark_enable = value;
return STALS_NO_ERROR;
}
static STALS_ErrCode_t set_sda_drive_value(struct VD6281_device *dev,
uint32_t value)
{
STALS_ErrCode_t res;
uint8_t data;
uint8_t sda_drive_reg_value;
/* valid values are 4, 8, 12, 16, 20 */
if (value > 20 || value == 0 || value % 4)
return STALS_ERROR_INVALID_PARAMS;
sda_drive_reg_value = value / 4 - 1;
res = STALS_RdByte(dev->client, VD6281_SDA_DRIVE, &data);
if (res)
return res;
data = (data & ~VD6281_SDA_DRIVE_MASK) | sda_drive_reg_value;
return STALS_WrByte(dev->client, VD6281_SDA_DRIVE, data);
}
static STALS_ErrCode_t set_wa_status(struct VD6281_device *dev, uint32_t value)
{
STALS_ErrCode_t res = STALS_NO_ERROR;
int next_state = (value >> 31);
value &= 0x7fffffff;
switch (value) {
case WA_460857:
dev->wa_codex_460857 = next_state;
break;
case WA_462997:
dev->wa_codex_462997 = next_state;
break;
case WA_461428:
dev->wa_codex_461428 = next_state;
break;
case WA_464174:
dev->wa_codex_464174 = next_state;
break;
case WA_478654:
dev->wa_codex_478654 = next_state;
break;
default:
res = STALS_ERROR_INVALID_PARAMS;
}
return res;
}
static uint32_t cook_values_slope_channel(uint8_t gain, uint32_t raw)
{
uint32_t cooked;
/* note that no overflow can occur */
cooked = (raw * gain) >> 7;
/* be sure to not generate values greater that saturation level ... */
cooked = MIN(cooked, 0x00ffffff);
/* ... but also avoid value below 0x100 except for zero */
cooked = cooked < 0x100 ? 0 : cooked;
return cooked;
}
static void cook_values_slope(struct VD6281_device *dev,
struct STALS_Als_t *pAlsValue)
{
uint8_t otp_gains[STALS_ALS_MAX_CHANNELS];
int c;
for (c = 0; c < VD6281_CHANNEL_NB; c++)
otp_gains[c] = dev->is_otp_usage_enable ? dev->otp.gains[c] :
VD6281_DEFAULT_GAIN;
for (c = 0; c < VD6281_CHANNEL_NB; c++) {
if (!(dev->als.chan & (1 << c)))
continue;
pAlsValue->CountValue[c] = cook_values_slope_channel(
otp_gains[c], pAlsValue->CountValueRaw[c]);
}
}
static void cook_values(struct VD6281_device *dev,
struct STALS_Als_t *pAlsValue)
{
cook_values_slope(dev, pAlsValue);
}
/* public API */
/* STALS_ERROR_INVALID_PARAMS */
STALS_ErrCode_t STALS_Init(char *UNUSED_P(pDeviceName), void *pClient,
void **pHandle)
{
STALS_ErrCode_t res;
struct VD6281_device *dev;
CHECK_NULL_PTR(pHandle);
dev = vd6281_get_device(pHandle);
if (!dev) {
ALS_err("%s - vd6281_get_device failed.\n", __func__);
goto get_device_error;
}
setup_device(dev, pClient, *pHandle);
res = check_supported_device(dev);
if (res) {
ALS_err("%s - check_supported_device failed.\n", __func__);
goto check_supported_device_error;
}
select_device_wa(dev);
res = dev_sw_reset(dev);
if (res) {
ALS_err("%s - select_device_wa failed.\n", __func__);
goto dev_sw_reset_error;
}
res = dev_configuration(dev);
if (res) {
ALS_err("%s - dev_configuration failed.\n", __func__);
goto dev_configuration_error;
}
return STALS_NO_ERROR;
dev_configuration_error:
dev_sw_reset_error:
check_supported_device_error:
vd6281_put_device(dev);
get_device_error:
return STALS_ERROR_INIT;
}
STALS_ErrCode_t STALS_Term(void *pHandle)
{
struct VD6281_device *dev = get_active_device(pHandle);
CHECK_DEVICE_VALID(dev);
vd6281_put_device(dev);
return STALS_NO_ERROR;
}
STALS_ErrCode_t STALS_GetVersion(uint32_t *pVersion, uint32_t *pRevision)
{
CHECK_NULL_PTR(pVersion);
CHECK_NULL_PTR(pRevision);
*pVersion = (VERSION_MAJOR << 16) + VERSION_MINOR;
*pRevision = VERSION_REVISION;
return STALS_NO_ERROR;
}
STALS_ErrCode_t STALS_GetChannelColor(void *pHandle,
enum STALS_Channel_Id_t ChannelId, enum STALS_Color_Id_t *pColor)
{
struct VD6281_device *dev = get_active_device(pHandle);
uint8_t filter_config;
const enum STALS_Color_Id_t *mapping_array;
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pColor);
CHECK_CHANNEL_VALID(channelId_2_index(ChannelId));
filter_config = dev->is_otp_usage_enable ? dev->otp.filter_config :
VD6281_DEFAULT_FILTER_CONFIG;
mapping_array = filter_mapping_array[filter_config];
*pColor = mapping_array[channelId_2_index(ChannelId)];
return STALS_NO_ERROR;
}
STALS_ErrCode_t STALS_SetExposureTime(void *pHandle, uint32_t ExpoTimeInUs,
uint32_t *pAppliedExpoTimeUs)
{
struct VD6281_device *dev = get_active_device(pHandle);
STALS_ErrCode_t res;
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pAppliedExpoTimeUs);
CHECH_DEV_ST_ALS_NOT_STARTED(dev);
res = set_exposure(dev, ExpoTimeInUs, 1);
if (res)
return res;
res = get_exposure(dev, pAppliedExpoTimeUs);
return res;
}
STALS_ErrCode_t STALS_GetExposureTime(void *pHandle,
uint32_t *pAppliedExpoTimeUs)
{
struct VD6281_device *dev = get_active_device(pHandle);
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pAppliedExpoTimeUs);
return get_exposure(dev, pAppliedExpoTimeUs);
}
STALS_ErrCode_t STALS_SetInterMeasurementTime(void *pHandle,
uint32_t InterMeasurmentInUs, uint32_t *pAppliedInterMeasurmentInUs)
{
const uint32_t step_size_us = 20500;
const uint32_t rounding = step_size_us / 2;
struct VD6281_device *dev = get_active_device(pHandle);
STALS_ErrCode_t res;
uint64_t value_acc;
uint8_t value;
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pAppliedInterMeasurmentInUs);
/* in that case also forbid change when flicker is running */
if (dev->wa_codex_462997)
CHECH_DEV_ST_INIT(dev);
else
CHECH_DEV_ST_ALS_NOT_STARTED(dev);
/* avoid integer overflow using intermediate 64 bits arithmetics */
value_acc = InterMeasurmentInUs + (uint64_t) rounding;
value_acc = div64_u64(MIN(value_acc, 0xffffffffULL), step_size_us);
value = MIN(value_acc, 0xff);
res = STALS_WrByte(dev->client, VD6281_CONTINUOUS_PERIOD, value);
if (res)
return res;
return STALS_GetInterMeasurementTime(pHandle,
pAppliedInterMeasurmentInUs);
}
STALS_ErrCode_t STALS_GetInterMeasurementTime(void *pHandle,
uint32_t *pAppliedInterMeasurmentInUs)
{
const uint32_t step_size_us = 20500;
struct VD6281_device *dev = get_active_device(pHandle);
STALS_ErrCode_t res;
uint8_t value;
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pAppliedInterMeasurmentInUs);
res = STALS_RdByte(dev->client, VD6281_CONTINUOUS_PERIOD, &value);
if (res)
return res;
*pAppliedInterMeasurmentInUs = step_size_us * value;
return STALS_NO_ERROR;
}
STALS_ErrCode_t STALS_GetProductVersion(void *pHandle, uint8_t *pDeviceID,
uint8_t *pRevisionID)
{
struct VD6281_device *dev = get_active_device(pHandle);
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pDeviceID);
CHECK_NULL_PTR(pRevisionID);
*pDeviceID = dev->device_id;
*pRevisionID = dev->revision_id;
return STALS_NO_ERROR;
}
STALS_ErrCode_t STALS_SetGain(void *pHandle, enum STALS_Channel_Id_t ChannelId,
uint16_t Gain, uint16_t *pAppliedGain)
{
struct VD6281_device *dev = get_active_device(pHandle);
int chan = channelId_2_index(ChannelId);
STALS_ErrCode_t res;
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pAppliedGain);
CHECK_CHANNEL_VALID(chan);
CHECK_CHANNEL_NOT_IN_USE(dev, ChannelId);
res = set_channel_gain(dev, chan, Gain);
if (res)
return res;
res = get_channel_gain(dev, chan, pAppliedGain);
return res;
}
STALS_ErrCode_t STALS_GetGain(void *pHandle, enum STALS_Channel_Id_t ChannelId,
uint16_t *pAppliedGain)
{
struct VD6281_device *dev = get_active_device(pHandle);
int chan = channelId_2_index(ChannelId);
STALS_ErrCode_t res;
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pAppliedGain);
CHECK_CHANNEL_VALID(chan);
res = get_channel_gain(dev, chan, pAppliedGain);
if (res)
return res;
return STALS_NO_ERROR;
}
STALS_ErrCode_t STALS_SetFlickerOutputType(void *pHandle,
enum STALS_FlickerOutputType_t FlickerOutputType)
{
struct VD6281_device *dev = get_active_device(pHandle);
STALS_ErrCode_t res;
CHECK_DEVICE_VALID(dev);
CHECH_DEV_ST_FLICKER_NOT_STARTED(dev);
switch (FlickerOutputType) {
case STALS_FLICKER_OUTPUT_ANALOG_CFG_1:
case STALS_FLICKER_OUTPUT_DIGITAL_PDM:
dev->flicker_output_type = FlickerOutputType;
res = STALS_NO_ERROR;
break;
case STALS_FLICKER_OUTPUT_ANALOG_CFG_2:
res = is_cut_2_0(dev) ? STALS_ERROR_INVALID_PARAMS :
STALS_NO_ERROR;
if (res == STALS_NO_ERROR)
dev->flicker_output_type = FlickerOutputType;
break;
default:
res = STALS_ERROR_INVALID_PARAMS;
}
return res;
}
STALS_ErrCode_t STALS_Start(void *pHandle, enum STALS_Mode_t Mode,
uint8_t Channels)
{
struct VD6281_device *dev = get_active_device(pHandle);
STALS_ErrCode_t res;
CHECK_DEVICE_VALID(dev);
CHECK_CHANNEL_MASK_VALID(Channels);
switch (Mode) {
case STALS_MODE_ALS_SINGLE_SHOT:
res = start_single_shot(dev, Channels);
break;
case STALS_MODE_ALS_SYNCHRONOUS:
res = start_synchronous(dev, Channels);
break;
case STALS_MODE_FLICKER:
res = start_flicker(dev, Channels);
break;
default:
res = STALS_ERROR_INVALID_PARAMS;
}
return res;
}
STALS_ErrCode_t STALS_Stop(void *pHandle, enum STALS_Mode_t Mode)
{
struct VD6281_device *dev = get_active_device(pHandle);
STALS_ErrCode_t res;
CHECK_DEVICE_VALID(dev);
switch (Mode) {
case STALS_MODE_ALS_SINGLE_SHOT:
res = stop_single_shot(dev);
break;
case STALS_MODE_ALS_SYNCHRONOUS:
res = stop_synchronous(dev);
break;
case STALS_MODE_FLICKER:
res = stop_flicker(dev);
break;
default:
res = STALS_ERROR_INVALID_PARAMS;
}
return res;
}
STALS_ErrCode_t STALS_GetAlsValues(void *pHandle, uint8_t Channels,
struct STALS_Als_t *pAlsValue, uint8_t *pMeasureValid)
{
struct VD6281_device *dev = get_active_device(pHandle);
STALS_ErrCode_t res;
uint8_t c;
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pAlsValue);
CHECK_NULL_PTR(pMeasureValid);
CHECK_CHANNEL_MASK_VALID_FOR_ALS(Channels);
CHECK_DEV_ST_ALS_STARTED(dev);
if (dev->st != DEV_ALS_RUN && dev->st != DEV_BOTH_RUN)
return STALS_ERROR_NOT_STARTED;
/* do we have ready datas */
res = is_data_ready(dev, pMeasureValid);
if (res)
return res;
if (!*pMeasureValid)
return STALS_NO_ERROR;
/* yes so read them */
Channels &= dev->als.chan;
for (c = 0; c < VD6281_CHANNEL_NB; c++) {
if (!(Channels & (1 << c)))
continue;
res = read_channel(dev, c, &pAlsValue->CountValueRaw[c]);
if (res)
return res;
}
pAlsValue->Channels = Channels;
cook_values(dev, pAlsValue);
/* acknowledge irq */
return acknowledge_irq(dev);
}
STALS_ErrCode_t STALS_GetFlickerFrequency(void *pHandle,
struct STALS_FlickerInfo_t *pFlickerInfo)
{
const uint32_t osc_freq = 10240000;
const uint32_t cnt_divisor = 640;
const uint32_t coeff = osc_freq / cnt_divisor;
struct VD6281_device *dev = get_active_device(pHandle);
STALS_ErrCode_t res;
uint8_t ac_sat_metric_m, ac_sat_metric_l, ac_acc_periods_m,
ac_acc_periods_l, ac_nb_of_periods, ac_amplitude_m,
ac_amplitude_l;
struct {
uint8_t addr;
uint8_t *value;
} toread[] = {{VD6281_AC_SAT_METRIC_M, &ac_sat_metric_m},
{VD6281_AC_SAT_METRIC_L, &ac_sat_metric_l},
{VD6281_AC_ACC_PERIODS_M, &ac_acc_periods_m},
{VD6281_AC_ACC_PERIODS_L, &ac_acc_periods_l},
{VD6281_AC_NB_PERIODS, &ac_nb_of_periods},
{VD6281_AC_AMPLITUDE_M, &ac_amplitude_m},
{VD6281_AC_AMPLITUDE_L, &ac_amplitude_l} };
unsigned int i;
uint16_t ac_sat_metric, ac_acc_periods, ac_amplitude;
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pFlickerInfo);
CHECK_DEV_ST_FLICKER_STARTED(dev);
for (i = 0; i < ARRAY_SIZE(toread); i++) {
res = STALS_RdByte(dev->client, toread[i].addr,
toread[i].value);
if (res)
return res;
}
ac_sat_metric = (ac_sat_metric_m << 8) + ac_sat_metric_l;
ac_acc_periods = (ac_acc_periods_m << 8) + ac_acc_periods_l;
ac_amplitude = (ac_amplitude_m << 8) + ac_amplitude_l;
pFlickerInfo->ConfidenceLevel = 0;
pFlickerInfo->Frequency = 0;
pFlickerInfo->IsMeasureFinish = 0;
/* hardware measure stop when either ac_nb_of_periods or
* ac_acc_periods reach maximum counter value
*/
if (ac_nb_of_periods == 255 || ac_acc_periods == 65535) {
pFlickerInfo->Frequency = (coeff * ac_nb_of_periods) /
ac_acc_periods;
pFlickerInfo->IsMeasureFinish = 1;
/* FIXME : confidence level need to be tune */
if (ac_amplitude < 10 || ac_sat_metric > 2)
pFlickerInfo->ConfidenceLevel = 1;
else
pFlickerInfo->ConfidenceLevel = 100;
}
return STALS_NO_ERROR;
}
STALS_ErrCode_t STALS_SetControl(void *pHandle,
enum STALS_Control_Id_t ControlId, uint32_t ControlValue)
{
struct VD6281_device *dev = get_active_device(pHandle);
STALS_ErrCode_t res;
CHECK_DEVICE_VALID(dev);
switch (ControlId) {
case STALS_PEDESTAL_ENABLE:
CHECH_DEV_ST_FLICKER_NOT_STARTED(dev);
res = set_pedestal_enable(dev, ControlValue);
break;
case STALS_PEDESTAL_VALUE:
CHECH_DEV_ST_FLICKER_NOT_STARTED(dev);
res = set_pedestal_value(dev, ControlValue);
break;
case STALS_OTP_USAGE_ENABLE:
CHECH_DEV_ST_INIT(dev);
res = set_otp_usage_enable(dev, ControlValue);
break;
case STALS_OUTPUT_DARK_ENABLE:
CHECH_DEV_ST_INIT(dev);
res = set_output_dark_enable(dev, ControlValue);
break;
case STALS_SDA_DRIVE_VALUE_MA:
CHECH_DEV_ST_INIT(dev);
res = set_sda_drive_value(dev, ControlValue);
break;
case STALS_WA_STATE:
CHECH_DEV_ST_INIT(dev);
res = set_wa_status(dev, ControlValue);
break;
default:
res = STALS_ERROR_INVALID_PARAMS;
}
return res;
}
STALS_ErrCode_t STALS_GetControl(void *pHandle,
enum STALS_Control_Id_t ControlId, uint32_t *pControlValue)
{
struct VD6281_device *dev = get_active_device(pHandle);
STALS_ErrCode_t res;
CHECK_DEVICE_VALID(dev);
CHECK_NULL_PTR(pControlValue);
switch (ControlId) {
case STALS_PEDESTAL_ENABLE:
res = get_pedestal_enable(dev, pControlValue);
break;
case STALS_PEDESTAL_VALUE:
res = get_pedestal_value(dev, pControlValue);
break;
case STALS_OTP_USAGE_ENABLE:
res = get_otp_usage_enable(dev, pControlValue);
break;
case STALS_OUTPUT_DARK_ENABLE:
res = get_output_dark_enable(dev, pControlValue);
break;
case STALS_SDA_DRIVE_VALUE_MA:
res = get_sda_drive_value(dev, pControlValue);
break;
case STALS_WA_STATE:
res = get_wa_status(dev, pControlValue);
break;
default:
res = STALS_ERROR_INVALID_PARAMS;
}
return res;
}
static int vd6281_print_reg_status(void)
{
int reg, err;
u8 recvData;
for (reg = 0; reg <= VD6281_INTR_CFG; reg++) {
err = vd6281_read_reg(vd6281_data, reg, &recvData, 1);
if (err != 0) {
ALS_err("%s - error reading 0x%02x err:%d\n",
__func__, reg, err);
} else {
ALS_dbg("%s - 0x%02x = 0x%02x\n",
__func__, reg, recvData);
}
}
return 0;
}
static int vd6281_set_sampling_rate(u32 sampling_period_ns)
{
ALS_dbg("%s - sensor_info_data not support\n", __func__);
return 0;
}
/*
static void vd6281_irq_set_state(struct vd6281_device_data *data, int irq_enable)
{
ALS_dbg("%s - irq_enable : %d, irq_state : %d\n",
__func__, irq_enable, data->irq_state);
if (irq_enable) {
if (data->irq_state++ == 0)
enable_irq(data->dev_irq);
} else {
if (data->irq_state == 0)
return;
if (--data->irq_state <= 0) {
disable_irq(data->dev_irq);
data->irq_state = 0;
}
}
}
*/
static int vd6281_power_ctrl(struct vd6281_device_data *data, int onoff)
{
int rc = 0;
static int i2c_1p8_enable;
struct regulator *regulator_i2c_1p8 = NULL;
ALS_dbg("%s - onoff : %d, state : %d\n",
__func__, onoff, data->regulator_state);
if (onoff == PWR_ON) {
if (data->regulator_state != 0) {
ALS_dbg("%s - duplicate regulator\n", __func__);
data->regulator_state++;
return 0;
}
data->regulator_state++;
data->pm_state = PM_RESUME;
} else {
if (data->regulator_state == 0) {
ALS_dbg("%s - already off the regulator\n", __func__);
return 0;
} else if (data->regulator_state != 1) {
ALS_dbg("%s - duplicate regulator\n", __func__);
data->regulator_state--;
return 0;
}
data->regulator_state--;
}
if (data->i2c_1p8 != NULL) {
regulator_i2c_1p8 = regulator_get(NULL, data->i2c_1p8);
if (IS_ERR(regulator_i2c_1p8) || regulator_i2c_1p8 == NULL) {
ALS_err("%s - get i2c_1p8 regulator failed\n", __func__);
rc = PTR_ERR(regulator_i2c_1p8);
regulator_i2c_1p8 = NULL;
goto get_i2c_1p8_failed;
}
}
if (onoff == PWR_ON) {
if (data->i2c_1p8 != NULL && i2c_1p8_enable == 0) {
rc = regulator_enable(regulator_i2c_1p8);
i2c_1p8_enable = 1;
if (rc) {
ALS_err("%s - enable i2c_1p8 failed, rc=%d\n", __func__, rc);
goto enable_i2c_1p8_failed;
}
}
if (data->pin_als_en >= 0) {
rc = gpio_direction_output(data->pin_als_en, 1);
if (rc) {
ALS_err("%s - gpio direction output failed, rc=%d\n",
__func__, rc);
goto gpio_direction_output_failed;
}
}
usleep_range(1000, 1100);
} else {
if (data->pin_als_en >= 0) {
gpio_set_value(data->pin_als_en, 0);
rc = gpio_direction_input(data->pin_als_en);
if (rc) {
ALS_err("%s - gpio direction input failed, rc=%d\n",
__func__, rc);
goto gpio_direction_input_failed;
}
}
if (data->i2c_1p8 != NULL) {
rc = regulator_disable(regulator_i2c_1p8);
i2c_1p8_enable = 0;
if (rc) {
ALS_err("%s - disable i2c_1p8 failed, rc=%d\n", __func__, rc);
goto done;
}
}
}
goto done;
gpio_direction_input_failed:
gpio_direction_output_failed:
if (data->i2c_1p8 != NULL) {
regulator_disable(regulator_i2c_1p8);
i2c_1p8_enable = 0;
}
enable_i2c_1p8_failed:
done:
if (data->i2c_1p8 != NULL)
regulator_put(regulator_i2c_1p8);
get_i2c_1p8_failed:
return rc;
}
static STALS_ErrCode_t vd6281_enable_set(struct vd6281_device_data *data, int onoff)
{
STALS_ErrCode_t res;
void *hdl;
uint32_t current_inter;
uint32_t current_exposure;
uint16_t current_gain;
int c;
if (onoff) {
res = STALS_Init("VD6281", data->client, &hdl);
if (res != STALS_NO_ERROR) {
ALS_err("%s - STALS_Init failed. %d\n", __func__, res);
goto err_device_init;
} else {
ALS_dbg("%s - STALS_Init ok\n", __func__);
}
/* wa for VD6281 cut 2.0 to allow als // with flicker */
res = STALS_SetInterMeasurementTime(hdl, 0, &current_inter);
if (res != STALS_NO_ERROR) {
ALS_err("%s - STALS_SetInterMeasurementTime failed. %d\n", __func__, res);
goto err_device_init;
} else {
ALS_dbg("%s - STALS_SetInterMeasurementTime ok\n", __func__);
}
res = STALS_SetExposureTime(hdl, 100000, &current_exposure);
if (res != STALS_NO_ERROR) {
ALS_err("%s - STALS_SetExposureTime failed. %d\n", __func__, res);
goto err_device_init;
} else {
ALS_dbg("%s - Exposure set to %d us\n", __func__, current_exposure);
}
for(c = 0; c < STALS_ALS_MAX_CHANNELS; c++) {
if ((1 << c) & ALS_CHANNELS) {
res = STALS_SetGain(hdl, 1 << c, 0x0a00, &current_gain);
if (res != STALS_NO_ERROR) {
ALS_err("%s - STALS_SetGain failed. %d %d\n", __func__, 1 << c, res);
goto err_device_init;
} else {
ALS_dbg("%s - Channel%d gain set to 0x%04x\n", __func__, c + 1, current_gain);
}
}
}
res = STALS_SetGain(hdl, FLK_CHANNEL, 0x0100, &current_gain);
if (res != STALS_NO_ERROR) {
ALS_err("%s - STALS_SetGain failed. %d %d\n", __func__, FLK_CHANNEL, res);
goto err_device_init;
} else {
ALS_dbg("%s - Channel%d gain set to 0x%04x\n", __func__, FLK_CHANNEL, current_gain);
}
res = STALS_SetFlickerOutputType(hdl, STALS_FLICKER_OUTPUT_ANALOG_CFG_2);
if (res != STALS_NO_ERROR) {
ALS_err("%s - STALS_SetFlickerOutputType failed. %d\n", __func__, res);
goto err_device_init;
} else {
ALS_dbg("%s - STALS_SetFlickerOutputType ok\n", __func__);
}
res = STALS_Start(hdl, STALS_MODE_ALS_SINGLE_SHOT, ALS_CHANNELS);
res = STALS_Start(hdl, STALS_MODE_FLICKER, FLK_CHANNEL);
start_flicker_timer();
schedule_delayed_work(&data->rear_als_work, msecs_to_jiffies(ALS_WORK_DELAY));
} else {
cancel_delayed_work_sync(&data->rear_als_work);
stop_flicker_timer();
if (data->is_als_start) {
res = STALS_Stop(hdl, STALS_MODE_ALS_SINGLE_SHOT);
if (res != 0)
ALS_err("%s - STALS_Stop STALS_MODE_ALS : %d\n", __func__, res);
}
if (data->is_flk_start) {
res = STALS_Stop(hdl, STALS_MODE_FLICKER);
if (res != 0)
ALS_err("%s - STALS_Stop STALS_MODE_FLICKER : %d\n", __func__, res);
}
res = STALS_Term(hdl);
if (res != 0)
ALS_err("%s - STALS_Term %d : %d\n", __func__, hdl, res);
}
return STALS_NO_ERROR;
err_device_init:
res = STALS_Term(hdl);
if (res != 0)
ALS_err("%s - STALS_Term %d : %d\n", __func__, hdl, res);
return STALS_ERROR_INIT;
}
/* als input enable/disable sysfs */
static ssize_t vd6281_enable_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
return snprintf(buf, strlen(buf), "%d\n", data->enabled);
}
static ssize_t vd6281_enable_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
bool value;
int err = 0;
if (strtobool(buf, &value))
return -EINVAL;
ALS_dbg("%s - en : %d, c : %d\n", __func__, value, data->enabled);
mutex_lock(&data->activelock);
if (value) {
// vd6281_irq_set_state(data, PWR_ON);
err = vd6281_power_ctrl(data, PWR_ON);
if (err < 0)
ALS_err("%s - als_regulator_on fail err = %d\n",
__func__, err);
err = vd6281_enable_set(data, value);
if (err == STALS_NO_ERROR) {
ALS_dbg("%s - vd6281_enable_set ok\n", __func__);
} else {
input_report_rel(data->als_input_dev,
REL_RZ, -5 + 1); /* F_ERR_I2C -5 detected i2c error */
input_sync(data->als_input_dev);
ALS_err("%s - enable error %d\n", __func__, err);
goto err_device_init;
}
data->enabled = 1;
data->mode_cnt.amb_cnt++;
} else {
if (data->regulator_state == 0) {
ALS_dbg("%s - already power off - disable skip\n",
__func__);
goto err_already_off;
}
err = vd6281_enable_set(data, value);
if (err != 0)
ALS_err("%s - disable err : %d\n", __func__, err);
data->enabled = 0;
err_device_init:
err = vd6281_power_ctrl(data, PWR_OFF);
if (err < 0)
ALS_err("%s - als_regulator_off fail err = %d\n",
__func__, err);
// vd6281_irq_set_state(data, PWR_OFF);
}
err_already_off:
mutex_unlock(&data->activelock);
return count;
}
static ssize_t vd6281_poll_delay_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", data->sampling_period_ns);
}
static ssize_t vd6281_poll_delay_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
u32 sampling_period_ns = 0;
int err = 0;
mutex_lock(&data->activelock);
err = kstrtoint(buf, 10, &sampling_period_ns);
if (err < 0) {
ALS_err("%s - kstrtoint failed.(%d)\n", __func__, err);
mutex_unlock(&data->activelock);
return err;
}
err = vd6281_set_sampling_rate(sampling_period_ns);
if (err > 0)
data->sampling_period_ns = err;
ALS_dbg("%s - als sensor sampling rate is setted as %dns\n", __func__, sampling_period_ns);
mutex_unlock(&data->activelock);
return size;
}
static DEVICE_ATTR(enable, S_IRUGO|S_IWUSR|S_IWGRP,
vd6281_enable_show, vd6281_enable_store);
static DEVICE_ATTR(poll_delay, S_IRUGO|S_IWUSR|S_IWGRP,
vd6281_poll_delay_show, vd6281_poll_delay_store);
static struct attribute *als_sysfs_attrs[] = {
&dev_attr_enable.attr,
&dev_attr_poll_delay.attr,
NULL
};
static struct attribute_group als_attribute_group = {
.attrs = als_sysfs_attrs,
};
/* als_sensor sysfs */
static ssize_t vd6281_name_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
char chip_name[NAME_LEN];
strlcpy(chip_name, VD6281_CHIP_NAME, strlen(VD6281_CHIP_NAME) + 1);
return snprintf(buf, PAGE_SIZE, "%s\n", chip_name);
}
static ssize_t vd6281_vendor_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
char vendor[NAME_LEN];
strlcpy(vendor, VENDOR, strlen(VENDOR) + 1);
return snprintf(buf, PAGE_SIZE, "%s\n", vendor);
}
static ssize_t vd6281_flush_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
int ret = 0;
u8 handle = 0;
mutex_lock(&data->activelock);
ret = kstrtou8(buf, 10, &handle);
if (ret < 0) {
ALS_err("%s - kstrtou8 failed.(%d)\n", __func__, ret);
mutex_unlock(&data->activelock);
return ret;
}
ALS_dbg("%s - handle = %d\n", __func__, handle);
mutex_unlock(&data->activelock);
input_report_rel(data->als_input_dev, REL_MISC, handle);
return size;
}
static ssize_t vd6281_int_pin_check_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
/* need to check if this should be implemented */
ALS_dbg("%s - not implement\n", __func__);
return snprintf(buf, PAGE_SIZE, "%d\n", 0);
}
static ssize_t vd6281_read_reg_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
ALS_info("%s - val=0x%06x\n", __func__, data->reg_read_buf);
return snprintf(buf, PAGE_SIZE, "%d\n", data->reg_read_buf);
}
static ssize_t vd6281_read_reg_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
int err = -1;
unsigned int cmd = 0;
u8 val = 0;
mutex_lock(&data->i2clock);
if (data->regulator_state == 0) {
ALS_dbg("%s - need to power on\n", __func__);
mutex_unlock(&data->i2clock);
return size;
}
err = sscanf(buf, "%8x", &cmd);
if (err == 0) {
ALS_err("%s - sscanf fail\n", __func__);
mutex_unlock(&data->i2clock);
return size;
}
err = vd6281_read_reg(data, (u8)cmd, &val, 1);
if (err != 0) {
ALS_err("%s - err=%d, val=0x%06x\n",
__func__, err, val);
mutex_unlock(&data->i2clock);
return size;
}
data->reg_read_buf = (u32)val;
mutex_unlock(&data->i2clock);
return size;
}
static ssize_t vd6281_write_reg_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
int err = -1;
unsigned int cmd = 0;
unsigned int val = 0;
mutex_lock(&data->i2clock);
if (data->regulator_state == 0) {
ALS_dbg("%s - need to power on.\n", __func__);
mutex_unlock(&data->i2clock);
return size;
}
err = sscanf(buf, "%8x, %8x", &cmd, &val);
if (err == 0) {
ALS_err("%s - sscanf fail %s\n", __func__, buf);
mutex_unlock(&data->i2clock);
return size;
}
err = vd6281_write_reg(data, (u8)cmd, (u8)val);
if (err < 0) {
ALS_err("%s - fail err = %d\n", __func__, err);
mutex_unlock(&data->i2clock);
return err;
}
mutex_unlock(&data->i2clock);
return size;
}
static ssize_t vd6281_debug_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
ALS_info("%s - debug mode = %u\n", __func__, data->debug_mode);
return snprintf(buf, PAGE_SIZE, "%u\n", data->debug_mode);
}
static ssize_t vd6281_debug_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
int err;
s32 mode;
mutex_lock(&data->activelock);
err = kstrtoint(buf, 10, &mode);
if (err < 0) {
ALS_err("%s - kstrtoint failed.(%d)\n", __func__, err);
mutex_unlock(&data->activelock);
return err;
}
data->debug_mode = (u8)mode;
ALS_info("%s - mode = %d\n", __func__, mode);
switch (data->debug_mode) {
case DEBUG_REG_STATUS:
vd6281_print_reg_status();
break;
case DEBUG_VAR:
vd6281_debug_var(data);
break;
default:
break;
}
mutex_unlock(&data->activelock);
return size;
}
static ssize_t vd6281_device_id_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
ALS_dbg("%s - device_id not support\n", __func__);
return snprintf(buf, PAGE_SIZE, "NOT SUPPORT\n");
}
static ssize_t vd6281_part_type_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE, "%d\n", data->part_type);
}
static ssize_t vd6281_i2c_err_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
u32 err_cnt = 0;
err_cnt = data->i2c_err_cnt;
return snprintf(buf, PAGE_SIZE, "%d\n", err_cnt);
}
static ssize_t vd6281_i2c_err_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
data->i2c_err_cnt = 0;
return size;
}
static ssize_t vd6281_curr_adc_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE,
"\"HRIC\":\"%d\",\"HRRC\":\"%d\",\"HRIA\":\"%d\",\"HRRA\":\"%d\"\n",
0, 0, data->user_ir_data, data->user_flicker_data);
}
static ssize_t vd6281_curr_adc_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
data->user_ir_data = 0;
data->user_flicker_data = 0;
return size;
}
static ssize_t vd6281_mode_cnt_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
return snprintf(buf, PAGE_SIZE,
"\"CNT_HRM\":\"%d\",\"CNT_AMB\":\"%d\",\"CNT_PROX\":\"%d\",\"CNT_SDK\":\"%d\",\"CNT_CGM\":\"%d\",\"CNT_UNKN\":\"%d\"\n",
data->mode_cnt.hrm_cnt, data->mode_cnt.amb_cnt, data->mode_cnt.prox_cnt,
data->mode_cnt.sdk_cnt, data->mode_cnt.cgm_cnt, data->mode_cnt.unkn_cnt);
}
static ssize_t vd6281_mode_cnt_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
data->mode_cnt.hrm_cnt = 0;
data->mode_cnt.amb_cnt = 0;
data->mode_cnt.prox_cnt = 0;
data->mode_cnt.sdk_cnt = 0;
data->mode_cnt.cgm_cnt = 0;
data->mode_cnt.unkn_cnt = 0;
return size;
}
static ssize_t vd6281_factory_cmd_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
static int cmd_result;
mutex_lock(&data->activelock);
if (data->isTrimmed)
cmd_result = 1;
else
cmd_result = 0;
ALS_dbg("%s - cmd_result = %d\n", __func__, cmd_result);
mutex_unlock(&data->activelock);
return snprintf(buf, PAGE_SIZE, "%d\n", cmd_result);
}
static ssize_t vd6281_version_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
ALS_info("%s - cmd_result = %s.%s.%s%s\n", __func__,
VERSION, SUB_VERSION, HEADER_VERSION, VENDOR_VERSION);
return snprintf(buf, PAGE_SIZE, "%s.%s.%s%s\n",
VERSION, SUB_VERSION, HEADER_VERSION, VENDOR_VERSION);
}
static ssize_t vd6281_sensor_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
ALS_dbg("%s - sensor_info_data not support\n", __func__);
return snprintf(buf, PAGE_SIZE, "NOT SUPPORT\n");
}
#ifdef CONFIG_STM_ALS_EOL_MODE
static int vd6281_eol_mode(struct vd6281_device_data *data)
{
int led_curr = 0;
int pulse_duty = 0;
int curr_state = EOL_STATE_INIT;
int ret = 0;
data->eol_state = EOL_STATE_INIT;
data->eol_enable = 1;
data->eol_result_status = 1;
ret = gpio_request(data->pin_led_en, NULL);
if (ret < 0)
return ret;
s2mpb02_led_en(S2MPB02_TORCH_LED_1, led_curr, S2MPB02_LED_TURN_WAY_GPIO);
while (data->eol_state < EOL_STATE_DONE) {
switch (data->eol_state) {
case EOL_STATE_INIT:
break;
case EOL_STATE_100:
led_curr = S2MPB02_TORCH_OUT_I_100MA;
pulse_duty = data->eol_pulse_duty[0];
break;
case EOL_STATE_120:
led_curr = S2MPB02_TORCH_OUT_I_100MA;
pulse_duty = data->eol_pulse_duty[1];
break;
default:
break;
}
if (data->eol_state >= EOL_STATE_100) {
if (curr_state != data->eol_state) {
s2mpb02_led_en(S2MPB02_TORCH_LED_1, led_curr, S2MPB02_LED_TURN_WAY_GPIO);
curr_state = data->eol_state;
} else
gpio_direction_output(data->pin_led_en, 1);
udelay(pulse_duty);
gpio_direction_output(data->pin_led_en, 0);
data->eol_pulse_count++;
}
udelay(pulse_duty);
}
s2mpb02_led_en(S2MPB02_TORCH_LED_1, 0, S2MPB02_LED_TURN_WAY_GPIO);
gpio_free(data->pin_led_en);
data->eol_enable = 0;
if (data->eol_state >= EOL_STATE_DONE) {
snprintf(data->eol_result, MAX_TEST_RESULT, "%d, %s, %d, %s, %d, %s, %d, %s, %d, %s, %d, %s\n",
data->eol_flicker_awb[EOL_STATE_100][0], FREQ100_SPEC_IN(data->eol_flicker_awb[EOL_STATE_100][0]),
data->eol_flicker_awb[EOL_STATE_100][1], IR_SPEC_IN(data->eol_flicker_awb[EOL_STATE_100][1]),
data->eol_flicker_awb[EOL_STATE_100][2], CLEAR_SPEC_IN(data->eol_flicker_awb[EOL_STATE_100][2]),
data->eol_flicker_awb[EOL_STATE_120][0], FREQ120_SPEC_IN(data->eol_flicker_awb[EOL_STATE_120][0]),
data->eol_flicker_awb[EOL_STATE_120][1], IR_SPEC_IN(data->eol_flicker_awb[EOL_STATE_120][1]),
data->eol_flicker_awb[EOL_STATE_120][2], CLEAR_SPEC_IN(data->eol_flicker_awb[EOL_STATE_120][2]));
} else
ALS_err("%s - abnormal termination\n", __func__);
ALS_dbg("%s - %d, %s, %d, %s, %d, %s, %d, %s, %d, %s, %d, %s\n",
__func__,
data->eol_flicker_awb[EOL_STATE_100][0], FREQ100_SPEC_IN(data->eol_flicker_awb[EOL_STATE_100][0]),
data->eol_flicker_awb[EOL_STATE_100][1], IR_SPEC_IN(data->eol_flicker_awb[EOL_STATE_100][1]),
data->eol_flicker_awb[EOL_STATE_100][2], CLEAR_SPEC_IN(data->eol_flicker_awb[EOL_STATE_100][2]),
data->eol_flicker_awb[EOL_STATE_120][0], FREQ120_SPEC_IN(data->eol_flicker_awb[EOL_STATE_120][0]),
data->eol_flicker_awb[EOL_STATE_120][1], IR_SPEC_IN(data->eol_flicker_awb[EOL_STATE_120][1]),
data->eol_flicker_awb[EOL_STATE_120][2], CLEAR_SPEC_IN(data->eol_flicker_awb[EOL_STATE_120][2]));
return 0;
}
static ssize_t vd6281_eol_mode_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
mutex_lock(&data->activelock);
if (data->eol_result == NULL) {
ALS_err("%s - data->eol_result is NULL\n", __func__);
mutex_unlock(&data->activelock);
return snprintf(buf, PAGE_SIZE, "%s\n", "NO_EOL_TEST");
}
if (data->eol_enable == 1) {
mutex_unlock(&data->activelock);
return snprintf(buf, PAGE_SIZE, "%s\n", "EOL_RUNNING");
} else if (data->eol_enable == 0 && data->eol_result_status == 0) {
mutex_unlock(&data->activelock);
return snprintf(buf, PAGE_SIZE, "%s\n", "NO_EOL_TEST");
}
mutex_unlock(&data->activelock);
data->eol_result_status = 0;
return snprintf(buf, PAGE_SIZE, "%s\n", data->eol_result);
}
static ssize_t vd6281_eol_mode_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
int err = 0;
int mode = 0;
err = kstrtoint(buf, 10, &mode);
if (err < 0) {
ALS_err("%s - kstrtoint failed.(%d)\n", __func__, err);
mutex_unlock(&data->activelock);
return err;
}
switch (mode) {
case 1:
gSpec_ir_min = data->eol_ir_spec[0];
gSpec_ir_max = data->eol_ir_spec[1];
gSpec_clear_min = data->eol_clear_spec[0];
gSpec_clear_max = data->eol_clear_spec[1];
break;
case 2:
gSpec_ir_min = data->eol_ir_spec[2];
gSpec_ir_max = data->eol_ir_spec[3];
gSpec_clear_min = data->eol_clear_spec[2];
gSpec_clear_max = data->eol_clear_spec[3];
break;
default:
break;
}
ALS_dbg("%s - mode = %d, gSpec_ir_min = %d, gSpec_ir_max = %d, gSpec_clear_min = %d, gSpec_clear_max = %d\n",
__func__, mode, gSpec_ir_min, gSpec_ir_max, gSpec_clear_min, gSpec_clear_max);
mutex_lock(&data->activelock);
// vd6281_irq_set_state(data, PWR_ON);
err = vd6281_power_ctrl(data, PWR_ON);
if (err < 0)
ALS_err("%s - als_regulator_on fail err = %d\n",
__func__, err);
err = vd6281_enable_set(data, 1);
if (err == STALS_NO_ERROR) {
ALS_dbg("%s - vd6281_enable_set ok\n", __func__);
} else {
ALS_err("%s - enable error %d\n", __func__, err);
goto err_device_init;
}
data->enabled = 1;
mutex_unlock(&data->activelock);
vd6281_eol_mode(data);
mutex_lock(&data->activelock);
if (data->regulator_state == 0) {
ALS_dbg("%s - already power off - disable skip\n",
__func__);
goto err_already_off;
}
err = vd6281_enable_set(data, 0);
if (err != 0)
ALS_err("%s - disable err : %d\n", __func__, err);
data->enabled = 0;
err_device_init:
err = vd6281_power_ctrl(data, PWR_OFF);
if (err < 0)
ALS_err("%s - als_regulator_off fail err = %d\n",
__func__, err);
// vd6281_irq_set_state(data, PWR_OFF);
err_already_off:
mutex_unlock(&data->activelock);
return size;
}
static ssize_t vd6281_eol_spec_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
ALS_dbg("%s - ir_spec = %d, %d, %d, %d, %d, %d, %d, %d\n", __func__,
data->eol_ir_spec[0], data->eol_ir_spec[1], data->eol_clear_spec[0], data->eol_clear_spec[1],
data->eol_ir_spec[2], data->eol_ir_spec[3], data->eol_clear_spec[2], data->eol_clear_spec[3]);
return snprintf(buf, PAGE_SIZE, "%d, %d, %d, %d, %d, %d, %d, %d\n",
data->eol_ir_spec[0], data->eol_ir_spec[1], data->eol_clear_spec[0], data->eol_clear_spec[1],
data->eol_ir_spec[2], data->eol_ir_spec[3], data->eol_clear_spec[2], data->eol_clear_spec[3]);
}
#endif
static DEVICE_ATTR(name, S_IRUGO, vd6281_name_show, NULL);
static DEVICE_ATTR(vendor, S_IRUGO, vd6281_vendor_show, NULL);
static DEVICE_ATTR(als_flush, S_IWUSR | S_IWGRP, NULL, vd6281_flush_store);
static DEVICE_ATTR(int_pin_check, S_IRUGO, vd6281_int_pin_check_show, NULL);
static DEVICE_ATTR(read_reg, S_IRUGO | S_IWUSR | S_IWGRP,
vd6281_read_reg_show, vd6281_read_reg_store);
static DEVICE_ATTR(write_reg, S_IWUSR | S_IWGRP, NULL, vd6281_write_reg_store);
static DEVICE_ATTR(als_debug, S_IRUGO | S_IWUSR | S_IWGRP,
vd6281_debug_show, vd6281_debug_store);
static DEVICE_ATTR(device_id, S_IRUGO, vd6281_device_id_show, NULL);
static DEVICE_ATTR(part_type, S_IRUGO, vd6281_part_type_show, NULL);
static DEVICE_ATTR(i2c_err_cnt, S_IRUGO | S_IWUSR | S_IWGRP, vd6281_i2c_err_show, vd6281_i2c_err_store);
static DEVICE_ATTR(curr_adc, S_IRUGO | S_IWUSR | S_IWGRP, vd6281_curr_adc_show, vd6281_curr_adc_store);
static DEVICE_ATTR(mode_cnt, S_IRUGO | S_IWUSR | S_IWGRP, vd6281_mode_cnt_show, vd6281_mode_cnt_store);
static DEVICE_ATTR(als_factory_cmd, S_IRUGO, vd6281_factory_cmd_show, NULL);
static DEVICE_ATTR(als_version, S_IRUGO, vd6281_version_show, NULL);
static DEVICE_ATTR(sensor_info, S_IRUGO, vd6281_sensor_info_show, NULL);
//static DEVICE_ATTR(als_raw_data, S_IRUGO, als_raw_data_show, NULL);
#ifdef CONFIG_STM_ALS_EOL_MODE
static DEVICE_ATTR(eol_mode, S_IRUGO | S_IWUSR | S_IWGRP, vd6281_eol_mode_show, vd6281_eol_mode_store);
static DEVICE_ATTR(eol_spec, S_IRUGO, vd6281_eol_spec_show, NULL);
#endif
static struct device_attribute *vd6281_sensor_attrs[] = {
&dev_attr_name,
&dev_attr_vendor,
&dev_attr_als_flush,
&dev_attr_int_pin_check,
&dev_attr_read_reg,
&dev_attr_write_reg,
&dev_attr_als_debug,
&dev_attr_device_id,
&dev_attr_part_type,
&dev_attr_i2c_err_cnt,
&dev_attr_curr_adc,
&dev_attr_mode_cnt,
&dev_attr_als_factory_cmd,
&dev_attr_als_version,
&dev_attr_sensor_info,
// &dev_attr_als_raw_data,
#ifdef CONFIG_STM_ALS_EOL_MODE
&dev_attr_eol_mode,
&dev_attr_eol_spec,
#endif
NULL,
};
#if 0
static int vd6281_eol_mode_handler(struct vd6281_device_data *data)
{
int i;
ams_deviceCtx_t *ctx = data->deviceCtx;
switch (data->eol_state) {
case EOL_STATE_INIT:
if (data->eol_result == NULL)
data->eol_result = devm_kzalloc(&data->client->dev, MAX_TEST_RESULT, GFP_KERNEL);
for (i = 0; i < EOL_STATE_DONE; i++) {
data->eol_flicker_awb[i][0] = 0;
data->eol_flicker_awb[i][1] = 0;
data->eol_flicker_awb[i][2] = 0;
}
data->eol_count = 0;
data->eol_awb = 0;
data->eol_clear = 0;
data->eol_flicker = 0;
data->eol_flicker_count = 0;
data->eol_state = EOL_STATE_100;
data->eol_pulse_count = 0;
break;
default:
data->eol_count++;
ALS_dbg("%s - %d, %d, %d, %d, %d\n", __func__,
data->eol_state, data->eol_count, data->eol_flicker, data->eol_awb, data->eol_clear);
ALS_dbg("%s - raw: %d, %d, %d, %d, %d\n", __func__, ctx->ccbAlsCtx.ctxAlgAls.uvir_cpl,
ctx->ccbAlsCtx.ctxAlgAls.results.rawClear, ctx->ccbAlsCtx.ctxAlgAls.results.rawWideband,
ctx->ccbAlsCtx.ctxAlgAls.results.irrClear, ctx->ccbAlsCtx.ctxAlgAls.results.irrWideband);
if (data->eol_count >= (EOL_COUNT + EOL_SKIP_COUNT)) {
data->eol_flicker_awb[data->eol_state][0] = data->eol_flicker / data->eol_flicker_count;
data->eol_flicker_awb[data->eol_state][1] = data->eol_awb / EOL_COUNT;
data->eol_flicker_awb[data->eol_state][2] = data->eol_clear / EOL_COUNT;
ALS_dbg("%s - eol_state = %d, pulse_duty = %d %d, pulse_count = %d\n",
__func__, data->eol_state, data->eol_pulse_duty[0], data->eol_pulse_duty[1], data->eol_pulse_count);
data->eol_count = 0;
data->eol_awb = 0;
data->eol_clear = 0;
data->eol_flicker = 0;
data->eol_flicker_count = 0;
data->eol_pulse_count = 0;
data->eol_state++;
}
break;
}
return 0;
}
#endif
irqreturn_t vd6281_irq_handler(int dev_irq, void *device)
{
// int err;
struct vd6281_device_data *data = device;
// int interruptsHandled = 0;
ALS_info("%s - als_irq = %d\n", __func__, dev_irq);
if (data->regulator_state == 0 || data->enabled == 0) {
ALS_dbg("%s - stop irq handler (reg_state : %d, enabled : %d)\n",
__func__, data->regulator_state, data->enabled);
return IRQ_HANDLED;
}
#ifdef CONFIG_ARCH_QCOM
pm_qos_add_request(&data->pm_qos_req_fpm, PM_QOS_CPU_DMA_LATENCY,
PM_QOS_DEFAULT_VALUE);
#endif
/*
err = ams_deviceEventHandler(data->deviceCtx);
interruptsHandled = ams_getResult(data->deviceCtx);
if (err == 0) {
if (data->als_input_dev == NULL) {
ALS_err("%s - als_input_dev is NULL\n", __func__);
} else {
#ifdef CONFIG_AMS_OPTICAL_SENSOR_ALS
if (interruptsHandled & (1 << AMS_AMBIENT_SENSOR)) {
report_als(data);
#ifdef CONFIG_STM_ALS_EOL_MODE
if (data->eol_enable)
vd6281_eol_mode_handler(data);
#endif
}
#endif
#ifdef CONFIG_AMS_OPTICAL_SENSOR_FLICKER
if (interruptsHandled & (1 << AMS_FLICKER_SENSOR))
report_flicker(data);
#endif
}
} else {
ALS_err("%s - ams_deviceEventHandler failed\n", __func__);
}
*/
#ifdef CONFIG_ARCH_QCOM
pm_qos_remove_request(&data->pm_qos_req_fpm);
#endif
return IRQ_HANDLED;
}
/*
static int vd6281_setup_irq(struct vd6281_device_data *data)
{
int errorno = -EIO;
errorno = request_threaded_irq(data->dev_irq, NULL,
vd6281_irq_handler, IRQF_TRIGGER_FALLING|IRQF_ONESHOT,
"als_rear_sensor_irq", data);
if (errorno < 0) {
ALS_err("%s - failed for setup dev_irq errono= %d\n",
__func__, errorno);
errorno = -ENODEV;
return errorno;
}
disable_irq(data->dev_irq);
return errorno;
}
*/
static void vd6281_init_var(struct vd6281_device_data *data)
{
data->client = NULL;
data->dev = NULL;
data->als_input_dev = NULL;
data->als_pinctrl = NULL;
data->pins_sleep = NULL;
data->pins_idle = NULL;
data->i2c_1p8 = NULL;
data->enabled = 0;
data->sampling_period_ns = 0;
data->regulator_state = 0;
data->irq_state = 0;
data->reg_read_buf = 0;
data->pm_state = PM_RESUME;
data->i2c_err_cnt = 0;
data->user_ir_data = 0;
data->user_flicker_data = 0;
data->flicker_cnt = 0;
#ifdef CONFIG_STM_ALS_EOL_MODE
data->eol_pulse_duty[0] = DEFAULT_DUTY_50HZ;
data->eol_pulse_duty[1] = DEFAULT_DUTY_60HZ;
data->eol_pulse_count = 0;
#endif
}
static int vd6281_parse_dt(struct vd6281_device_data *data)
{
struct device *dev = &data->client->dev;
struct device_node *dNode = dev->of_node;
enum of_gpio_flags flags;
const char *buf;
// u32 gain_max = 0;
if (dNode == NULL)
return -ENODEV;
data->pin_als_int = of_get_named_gpio_flags(dNode,
"als_rear,int-gpio", 0, &flags);
if (data->pin_als_int < 0) {
ALS_err("%s - get als_rear_int error\n", __func__);
return -ENODEV;
}
data->pin_als_en = of_get_named_gpio_flags(dNode,
"als_rear,als_en-gpio", 0, &flags);
if (data->pin_als_en < 0)
ALS_dbg("%s - get als_en failed\n", __func__);
#ifdef CONFIG_STM_ALS_EOL_MODE
data->pin_led_en = of_get_named_gpio_flags(dNode,
"als_rear,led_en-gpio", 0, &flags);
if (data->pin_led_en < 0) {
ALS_err("%s - get pin_led_en error\n", __func__);
return -ENODEV;
}
#endif
if (of_property_read_string(dNode, "als_rear,vdd_1p8",
(char const **)&data->vdd_1p8) < 0)
ALS_dbg("%s - vdd_1p8 doesn`t exist\n", __func__);
if (of_property_read_string(dNode, "als_rear,i2c_1p8",
(char const **)&data->i2c_1p8) < 0)
ALS_dbg("%s - i2c_1p8 doesn`t exist\n", __func__);
data->als_pinctrl = devm_pinctrl_get(dev);
if (IS_ERR_OR_NULL(data->als_pinctrl)) {
ALS_err("%s - get pinctrl(%li) error\n",
__func__, PTR_ERR(data->als_pinctrl));
data->als_pinctrl = NULL;
return -EINVAL;
}
data->pins_sleep =
pinctrl_lookup_state(data->als_pinctrl, "sleep");
if (IS_ERR_OR_NULL(data->pins_sleep)) {
ALS_err("%s - get pins_sleep(%li) error\n",
__func__, PTR_ERR(data->pins_sleep));
devm_pinctrl_put(data->als_pinctrl);
data->pins_sleep = NULL;
return -EINVAL;
}
data->pins_idle =
pinctrl_lookup_state(data->als_pinctrl, "idle");
if (IS_ERR_OR_NULL(data->pins_idle)) {
ALS_err("%s - get pins_idle(%li) error\n",
__func__, PTR_ERR(data->pins_idle));
devm_pinctrl_put(data->als_pinctrl);
data->pins_idle = NULL;
return -EINVAL;
}
// if (of_property_read_u32(dNode, "als_rear,gain_max", &gain_max) == 0) {
// deviceRegisterDefinition[DEVREG_AGC_GAIN_MAX].resetValue = gain_max;
//
// ALS_dbg("%s - DEVREG_AGC_GAIN_MAX = 0x%x\n", __func__, gain_max);
// }
#ifdef CONFIG_STM_ALS_EOL_MODE
if (of_property_read_u32_array(dNode, "als_rear,ir_spec",
data->eol_ir_spec, ARRAY_SIZE(data->eol_ir_spec)) < 0) {
ALS_err("%s - get ir_spec error\n", __func__);
data->eol_ir_spec[0] = DEFAULT_IR_SPEC_MIN;
data->eol_ir_spec[1] = DEFAULT_IR_SPEC_MAX;
data->eol_ir_spec[2] = DEFAULT_IR_SPEC_MIN;
data->eol_ir_spec[3] = DEFAULT_IR_SPEC_MAX;
}
ALS_dbg("%s - ir_spec = %d, %d, %d, %d\n", __func__,
data->eol_ir_spec[0], data->eol_ir_spec[1], data->eol_ir_spec[2], data->eol_ir_spec[3]);
if (of_property_read_u32_array(dNode, "als_rear,clear_spec",
data->eol_clear_spec, ARRAY_SIZE(data->eol_clear_spec)) < 0) {
ALS_err("%s - get clear_spec error\n", __func__);
data->eol_clear_spec[0] = DEFAULT_IR_SPEC_MIN;
data->eol_clear_spec[1] = DEFAULT_IR_SPEC_MAX;
data->eol_clear_spec[2] = DEFAULT_IR_SPEC_MIN;
data->eol_clear_spec[3] = DEFAULT_IR_SPEC_MAX;
}
ALS_dbg("%s - clear_spec = %d, %d, %d, %d\n", __func__,
data->eol_clear_spec[0], data->eol_clear_spec[1], data->eol_clear_spec[2], data->eol_clear_spec[3]);
#endif
if (of_property_read_string(dNode, "io-channel-names", &buf)) {
return -ENOENT;
} else {
data->chan = iio_channel_get(&data->client->dev, buf);
ALS_dbg("%s - get iio_channel : %d\n", __func__, !IS_ERR_OR_NULL(data->chan));
}
ALS_dbg("%s - done.\n", __func__);
return 0;
}
static int vd6281_setup_gpio(struct vd6281_device_data *data)
{
int errorno = -EIO;
errorno = gpio_request(data->pin_als_int, "als_rear_int");
if (errorno) {
ALS_err("%s - failed to request als_int\n", __func__);
return errorno;
}
errorno = gpio_direction_input(data->pin_als_int);
if (errorno) {
ALS_err("%s - failed to set als_int as input\n", __func__);
goto err_gpio_direction_input;
}
data->dev_irq = gpio_to_irq(data->pin_als_int);
if (data->pin_als_en >= 0) {
errorno = gpio_request(data->pin_als_en, "als_rear_en");
if (errorno) {
ALS_err("%s - failed to request als_en\n", __func__);
goto err_gpio_direction_input;
}
}
goto done;
err_gpio_direction_input:
gpio_free(data->pin_als_int);
done:
return errorno;
}
static long vd6281_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
void __user *argp = (void __user *)arg;
int ret = 0;
struct vd6281_device_data *data = container_of(file->private_data,
struct vd6281_device_data, miscdev);
ALS_info("%s - ioctl start\n", __func__);
mutex_lock(&data->flickerdatalock);
switch (cmd) {
case VD6281_IOCTL_READ_FLICKER:
ret = copy_to_user(argp,
data->flicker_data,
sizeof(int)*FLICKER_DATA_CNT);
if (unlikely(ret))
goto ioctl_error;
complete(&data->completion);
break;
default:
ALS_err("%s - invalid cmd\n", __func__);
break;
}
mutex_unlock(&data->flickerdatalock);
return ret;
ioctl_error:
mutex_unlock(&data->flickerdatalock);
ALS_err("%s - read flicker data err(%d)\n", __func__, ret);
return -ret;
}
static const struct file_operations vd6281_fops = {
.owner = THIS_MODULE,
.open = nonseekable_open,
.unlocked_ioctl = vd6281_ioctl,
};
int vd6281_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int err = -ENODEV;
// STALS_ErrCode_t res;
struct device *dev = &client->dev;
struct vd6281_device_data *data;
// void *hdl;
ALS_dbg("%s - start\n", __func__);
/* check to make sure that the adapter supports I2C */
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
ALS_err("%s - I2C_FUNC_I2C not supported\n", __func__);
return -ENODEV;
}
/* allocate some memory for the device */
data = devm_kzalloc(dev, sizeof(struct vd6281_device_data), GFP_KERNEL);
if (data == NULL) {
ALS_err("%s - couldn't allocate device data memory\n", __func__);
return -ENOMEM;
}
/*
data->flicker_data = kzalloc(sizeof(int)*FLICKER_DATA_CNT * 2, GFP_KERNEL);
if (data->flicker_data == NULL) {
HRM_err("%s - couldn't allocate flicker data memory\n", __func__);
goto err_flicker_alloc_fail;
}
*/
vd6281_data = data;
vd6281_init_var(data);
data->client = client;
data->miscdev.minor = MISC_DYNAMIC_MINOR;
data->miscdev.name = MODULE_NAME_ALS;
data->miscdev.mode = S_IRUGO;
data->miscdev.fops = &vd6281_fops;
i2c_set_clientdata(client, data);
ALS_info("%s client = %p\n", __func__, client);
err = misc_register(&data->miscdev);
if (err < 0) {
ALS_err("%s - failed to misc device register\n", __func__);
goto err_misc_register;
}
mutex_init(&data->i2clock);
mutex_init(&data->activelock);
mutex_init(&data->suspendlock);
mutex_init(&data->flickerdatalock);
init_completion(&data->completion);
tasklet_hrtimer_init(&data->timer,
my_hrtimer_callback, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
err = vd6281_parse_dt(data);
if (err < 0) {
ALS_err("%s - failed to parse dt\n", __func__);
err = -ENODEV;
goto err_parse_dt;
}
err = vd6281_setup_gpio(data);
if (err) {
ALS_err("%s - failed to setup gpio\n", __func__);
goto err_setup_gpio;
}
err = vd6281_power_ctrl(data, PWR_ON);
if (err < 0) {
ALS_err("%s - failed to power on ctrl\n", __func__);
goto err_power_on;
}
/*
res = STALS_Init("VD6281", data->client, &hdl);
if (res != STALS_NO_ERROR) {
ALS_err("%s - STALS_Init failed. %d\n", __func__, res);
goto err_device_init;
} else {
ALS_dbg("%s - STALS_Init ok\n", __func__);
}
err = vd6281_enable_set(data, 1);
if (err == STALS_NO_ERROR) {
ALS_dbg("%s - vd6281_enable_set ok\n", __func__);
} else {
ALS_err("%s - enable error %d\n", __func__, err);
goto err_device_init;
}
*/
data->enabled = 1;
data->flicker_work = create_singlethread_workqueue("flicker");
INIT_DELAYED_WORK(&data->rear_als_work, vd6281_als_work);
data->als_input_dev = input_allocate_device();
if (!data->als_input_dev) {
ALS_err("%s - could not allocate input device\n", __func__);
err = -EIO;
goto err_input_allocate_device;
}
data->als_input_dev->name = MODULE_NAME_ALS;
data->als_input_dev->id.bustype = BUS_I2C;
input_set_drvdata(data->als_input_dev, data);
input_set_capability(data->als_input_dev, EV_REL, REL_X);
input_set_capability(data->als_input_dev, EV_REL, REL_Y);
input_set_capability(data->als_input_dev, EV_REL, REL_Z);
input_set_capability(data->als_input_dev, EV_REL, REL_RX);
input_set_capability(data->als_input_dev, EV_REL, REL_RY);
input_set_capability(data->als_input_dev, EV_REL, REL_RZ);
input_set_capability(data->als_input_dev, EV_REL, REL_MISC);
input_set_capability(data->als_input_dev, EV_ABS, ABS_X);
input_set_capability(data->als_input_dev, EV_ABS, ABS_Y);
input_set_capability(data->als_input_dev, EV_ABS, ABS_Z);
err = input_register_device(data->als_input_dev);
if (err < 0) {
input_free_device(data->als_input_dev);
ALS_err("%s - could not register input device\n", __func__);
goto err_input_register_device;
}
#ifdef CONFIG_ARCH_QCOM
err = sensors_create_symlink(&data->als_input_dev->dev.kobj,
data->als_input_dev->name);
#else
err = sensors_create_symlink(data->als_input_dev);
#endif
if (err < 0) {
ALS_err("%s - could not create_symlink\n", __func__);
goto err_sensors_create_symlink;
}
err = sysfs_create_group(&data->als_input_dev->dev.kobj,
&als_attribute_group);
if (err) {
ALS_err("%s - could not create sysfs group\n", __func__);
goto err_sysfs_create_group;
}
#ifdef CONFIG_ARCH_QCOM
err = sensors_register(&data->dev, data, vd6281_sensor_attrs,
MODULE_NAME_ALS);
#else
err = sensors_register(data->dev, data, vd6281_sensor_attrs,
MODULE_NAME_ALS);
#endif
if (err) {
ALS_err("%s - cound not register als_sensor(%d).\n", __func__, err);
goto als_sensor_register_failed;
}
/*
err = vd6281_setup_irq(data);
if (err) {
ALS_err("%s - could not setup dev_irq\n", __func__);
goto err_setup_irq;
}
*/
err = vd6281_enable_set(data, 0);
if (err != 0)
ALS_err("%s - disable err : %d\n", __func__, err);
data->enabled = 0;
err = vd6281_power_ctrl(data, PWR_OFF);
if (err < 0) {
ALS_err("%s - failed to power off ctrl\n", __func__);
goto dev_set_drvdata_failed;
}
ALS_dbg("%s - success\n", __func__);
goto done;
dev_set_drvdata_failed:
// free_irq(data->dev_irq, data);
//err_setup_irq:
sensors_unregister(data->dev, vd6281_sensor_attrs);
als_sensor_register_failed:
sysfs_remove_group(&data->als_input_dev->dev.kobj,
&als_attribute_group);
err_sysfs_create_group:
#ifdef CONFIG_ARCH_QCOM
sensors_remove_symlink(&data->als_input_dev->dev.kobj,
data->als_input_dev->name);
#else
sensors_remove_symlink(data->als_input_dev);
#endif
err_sensors_create_symlink:
input_unregister_device(data->als_input_dev);
err_input_register_device:
err_input_allocate_device:
//err_device_init:
vd6281_power_ctrl(data, PWR_OFF);
err_power_on:
gpio_free(data->pin_als_int);
if (data->pin_als_en >= 0)
gpio_free(data->pin_als_en);
err_setup_gpio:
err_parse_dt:
//err_malloc_pdata:
if (data->als_pinctrl) {
devm_pinctrl_put(data->als_pinctrl);
data->als_pinctrl = NULL;
}
if (data->pins_idle)
data->pins_idle = NULL;
if (data->pins_sleep)
data->pins_sleep = NULL;
mutex_destroy(&data->i2clock);
mutex_destroy(&data->activelock);
mutex_destroy(&data->suspendlock);
mutex_destroy(&data->flickerdatalock);
misc_deregister(&data->miscdev);
err_misc_register:
// kfree(data->flicker_data);
//err_flicker_alloc_fail:
// devm_kfree(data);
ALS_err("%s failed\n", __func__);
done:
return err;
}
int vd6281_remove(struct i2c_client *client)
{
struct vd6281_device_data *data = i2c_get_clientdata(client);
vd6281_power_ctrl(data, PWR_OFF);
sensors_unregister(data->dev, vd6281_sensor_attrs);
sysfs_remove_group(&data->als_input_dev->dev.kobj,
&als_attribute_group);
#ifdef CONFIG_ARCH_QCOM
sensors_remove_symlink(&data->als_input_dev->dev.kobj,
data->als_input_dev->name);
#else
sensors_remove_symlink(data->als_input_dev);
#endif
input_unregister_device(data->als_input_dev);
if (data->als_pinctrl) {
devm_pinctrl_put(data->als_pinctrl);
data->als_pinctrl = NULL;
}
if (data->pins_idle)
data->pins_idle = NULL;
if (data->pins_sleep)
data->pins_sleep = NULL;
disable_irq(data->dev_irq);
free_irq(data->dev_irq, data);
gpio_free(data->pin_als_int);
if (data->pin_als_en >= 0)
gpio_free(data->pin_als_en);
mutex_destroy(&data->i2clock);
mutex_destroy(&data->activelock);
mutex_destroy(&data->suspendlock);
mutex_destroy(&data->flickerdatalock);
misc_deregister(&data->miscdev);
destroy_workqueue(data->flicker_work);
iio_channel_release(data->chan);
// devm_kfree(data->deviceCtx);
// devm_kfree(data->pdata);
// devm_kfree(data);
i2c_set_clientdata(client, NULL);
data = NULL;
return 0;
}
static void vd6281_shutdown(struct i2c_client *client)
{
ALS_dbg("%s - start\n", __func__);
}
void vd6281_pin_control(struct vd6281_device_data *data, bool pin_set)
{
int status = 0;
if (!data->als_pinctrl) {
ALS_err("%s - als_pinctrl is null\n", __func__);
return;
}
if (pin_set) {
if (!IS_ERR_OR_NULL(data->pins_idle)) {
status = pinctrl_select_state(data->als_pinctrl,
data->pins_idle);
if (status)
ALS_err("%s - can't set pin default state\n",
__func__);
ALS_info("%s idle\n", __func__);
}
} else {
if (!IS_ERR_OR_NULL(data->pins_sleep)) {
status = pinctrl_select_state(data->als_pinctrl,
data->pins_sleep);
if (status)
ALS_err("%s - can't set pin sleep state\n",
__func__);
ALS_info("%s sleep\n", __func__);
}
}
}
#ifdef CONFIG_PM
static int vd6281_suspend(struct device *dev)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
int err = 0;
ALS_dbg("%s - %d\n", __func__, data->enabled);
if (data->enabled != 0 || data->regulator_state != 0) {
mutex_lock(&data->activelock);
vd6281_enable_set(data, 0);
err = vd6281_power_ctrl(data, PWR_OFF);
if (err < 0)
ALS_err("%s - als_regulator_off fail err = %d\n",
__func__, err);
// vd6281_irq_set_state(data, PWR_OFF);
mutex_unlock(&data->activelock);
}
mutex_lock(&data->suspendlock);
data->pm_state = PM_SUSPEND;
vd6281_pin_control(data, false);
mutex_unlock(&data->suspendlock);
return err;
}
static int vd6281_resume(struct device *dev)
{
struct vd6281_device_data *data = dev_get_drvdata(dev);
int err = 0;
ALS_dbg("%s - %d\n", __func__, data->enabled);
mutex_lock(&data->suspendlock);
vd6281_pin_control(data, true);
data->pm_state = PM_RESUME;
mutex_unlock(&data->suspendlock);
if (data->enabled != 0) {
mutex_lock(&data->activelock);
// vd6281_irq_set_state(data, PWR_ON);
err = vd6281_power_ctrl(data, PWR_ON);
if (err < 0)
ALS_err("%s - als_regulator_on fail err = %d\n",
__func__, err);
vd6281_enable_set(data, 1);
if (err < 0) {
input_report_rel(data->als_input_dev,
REL_RZ, -5 + 1); /* F_ERR_I2C -5 detected i2c error */
input_sync(data->als_input_dev);
ALS_err("%s - awb mode enable error : %d\n", __func__, err);
}
mutex_unlock(&data->activelock);
}
return err;
}
static const struct dev_pm_ops vd6281_pm_ops = {
.suspend = vd6281_suspend,
.resume = vd6281_resume
};
#endif
static const struct of_device_id vd6281_match_table[] = {
{ .compatible = "stm,vd6281",},
{},
};
static const struct i2c_device_id vd6281_idtable[] = {
{ "vd6281", 0 },
{ }
};
/* descriptor of the vd6281 I2C driver */
static struct i2c_driver vd6281_driver = {
.driver = {
.name = "vd6281",
.owner = THIS_MODULE,
#if defined(CONFIG_PM)
.pm = &vd6281_pm_ops,
#endif
.of_match_table = vd6281_match_table,
},
.probe = vd6281_probe,
.remove = vd6281_remove,
.shutdown = vd6281_shutdown,
.id_table = vd6281_idtable,
};
/* initialization and exit functions */
static int __init vd6281_init(void)
{
if (!lpcharge)
return i2c_add_driver(&vd6281_driver);
else
return 0;
}
static void __exit vd6281_exit(void)
{
i2c_del_driver(&vd6281_driver);
}
module_init(vd6281_init);
module_exit(vd6281_exit);
MODULE_AUTHOR("Samsung Electronics");
MODULE_DESCRIPTION("VD6281 ALS Driver");
MODULE_LICENSE("GPL");