drivers/sensor/vcnl4040/vcnl4040.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2020 Richard Osterloh
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #define DT_DRV_COMPAT vishay_vcnl4040

 #include "vcnl4040.h"
 #include <zephyr/pm/device.h>
 #include <zephyr/sys/__assert.h>
 #include <zephyr/sys/byteorder.h>
 #include <zephyr/sys/util.h>
 #include <zephyr/logging/log.h>
 #include <stdlib.h>

 LOG_MODULE_REGISTER(vcnl4040, CONFIG_SENSOR_LOG_LEVEL);

 int vcnl4040_read(const struct device *dev, uint8_t reg, uint16_t *out)
 {
 	const struct vcnl4040_config *config = dev->config;
 	struct vcnl4040_data *data = dev->data;
 	uint8_t buff[2] = { 0 };
 	int ret = 0;

 	ret = i2c_write_read(data->i2c, config->i2c_address,
 			     &reg, sizeof(reg), buff, sizeof(buff));

 	if (!ret)
 		*out = sys_get_le16(buff);

 	return ret;
 }

 int vcnl4040_write(const struct device *dev, uint8_t reg, uint16_t value)
 {
 	const struct vcnl4040_config *config = dev->config;
 	struct vcnl4040_data *data = dev->data;
 	struct i2c_msg msg;
 	int ret;
 	uint8_t buff[3];

 	sys_put_le16(value, &buff[1]);

 	buff[0] = reg;

 	msg.buf = buff;
 	msg.flags = 0;
 	msg.len = sizeof(buff);

 	ret = i2c_transfer(data->i2c, &msg, 1, config->i2c_address);

 	if (ret < 0) {
 		LOG_ERR("write block failed");
 		return ret;
 	}

 	return 0;
 }

 static int vcnl4040_sample_fetch(const struct device *dev,
 				 enum sensor_channel chan)
 {
 	struct vcnl4040_data *data = dev->data;
 	int ret = 0;

 #ifdef CONFIG_VCNL4040_ENABLE_ALS
 	__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL ||
 			chan == SENSOR_CHAN_PROX ||
 			chan == SENSOR_CHAN_LIGHT);
 #else
 	__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_PROX);
 #endif
 	k_sem_take(&data->sem, K_FOREVER);

 	if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_PROX) {
 		ret = vcnl4040_read(dev, VCNL4040_REG_PS_DATA,
 				    &data->proximity);
 		if (ret < 0) {
 			LOG_ERR("Could not fetch proximity");
 			goto exit;
 		}
 	}
 #ifdef CONFIG_VCNL4040_ENABLE_ALS
 	if (chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_LIGHT) {
 		ret = vcnl4040_read(dev, VCNL4040_REG_ALS_DATA,
 				    &data->light);
 		if (ret < 0) {
 			LOG_ERR("Could not fetch ambient light");
 		}
 	}
 #endif
 exit:
 	k_sem_give(&data->sem);

 	return ret;
 }

 static int vcnl4040_channel_get(const struct device *dev,
 				enum sensor_channel chan,
 				struct sensor_value *val)
 {
 	struct vcnl4040_data *data = dev->data;
 	int ret = 0;

 	k_sem_take(&data->sem, K_FOREVER);

 	switch (chan) {
 	case SENSOR_CHAN_PROX:
 		val->val1 = data->proximity;
 		val->val2 = 0;
 		break;

 #ifdef CONFIG_VCNL4040_ENABLE_ALS
 	case SENSOR_CHAN_LIGHT:
 		val->val1 = data->light * data->sensitivity;
 		val->val2 = 0;
 		break;
 #endif

 	default:
 		ret = -ENOTSUP;
 	}

 	k_sem_give(&data->sem);

 	return ret;
 }

 static int vcnl4040_proxy_setup(const struct device *dev)
 {
 	const struct vcnl4040_config *config = dev->config;
 	uint16_t conf = 0;

 	if (vcnl4040_read(dev, VCNL4040_REG_PS_MS, &conf)) {
 		LOG_ERR("Could not read proximity config");
 		return -EIO;
 	}

 	/* Set LED current */
 	conf |= config->led_i << VCNL4040_LED_I_POS;

 	if (vcnl4040_write(dev, VCNL4040_REG_PS_MS, conf)) {
 		LOG_ERR("Could not write proximity config");
 		return -EIO;
 	}

 	if (vcnl4040_read(dev, VCNL4040_REG_PS_CONF, &conf)) {
 		LOG_ERR("Could not read proximity config");
 		return -EIO;
 	}

 	/* Set PS_HD */
 	conf |= VCNL4040_PS_HD_MASK;
 	/* Set duty cycle */
 	conf |= config->led_dc << VCNL4040_PS_DUTY_POS;
 	/* Set integration time */
 	conf |= config->proxy_it << VCNL4040_PS_IT_POS;
 	/* Clear proximity shutdown */
 	conf &= ~VCNL4040_PS_SD_MASK;

 	if (vcnl4040_write(dev, VCNL4040_REG_PS_CONF, conf)) {
 		LOG_ERR("Could not write proximity config");
 		return -EIO;
 	}

 	return 0;
 }

 #ifdef CONFIG_VCNL4040_ENABLE_ALS
 static int vcnl4040_ambient_setup(const struct device *dev)
 {
 	const struct vcnl4040_config *config = dev->config;
 	struct vcnl4040_data *data = dev->data;
 	uint16_t conf = 0;

 	if (vcnl4040_read(dev, VCNL4040_REG_ALS_CONF, &conf)) {
 		LOG_ERR("Could not read proximity config");
 		return -EIO;
 	}

 	/* Set ALS integration time */
 	conf |= config->als_it << VCNL4040_ALS_IT_POS;
 	/* Clear ALS shutdown */
 	conf &= ~VCNL4040_ALS_SD_MASK;

 	if (vcnl4040_write(dev, VCNL4040_REG_ALS_CONF, conf)) {
 		LOG_ERR("Could not write proximity config");
 		return -EIO;
 	}

 	/*
 	 * scale the lux depending on the value of the integration time
 	 * see page 8 of the VCNL4040 application note:
 	 * https://www.vishay.com/docs/84307/designingvcnl4040.pdf
 	 */
 	switch (config->als_it) {
 	case VCNL4040_AMBIENT_INTEGRATION_TIME_80MS:
 		data->sensitivity = 0.12;
 		break;
 	case VCNL4040_AMBIENT_INTEGRATION_TIME_160MS:
 		data->sensitivity = 0.06;
 		break;
 	case VCNL4040_AMBIENT_INTEGRATION_TIME_320MS:
 		data->sensitivity = 0.03;
 		break;
 	case VCNL4040_AMBIENT_INTEGRATION_TIME_640MS:
 		data->sensitivity = 0.015;
 		break;
 	default:
 		data->sensitivity = 1.0;
 		LOG_WRN("Cannot set ALS sensitivity from ALS_IT=%d",
 			config->als_it);
 		break;
 	}

 	return 0;
 }
 #endif

 #ifdef CONFIG_PM_DEVICE
 static int vcnl4040_pm_action(const struct device *dev,
 			      enum pm_device_action action)
 {
 	int ret = 0;
 	uint16_t ps_conf;

 	ret = vcnl4040_read(dev, VCNL4040_REG_PS_CONF, &ps_conf);
 	if (ret < 0)
 		return ret;
 #ifdef CONFIG_VCNL4040_ENABLE_ALS
 	uint16_t als_conf;

 	ret = vcnl4040_read(dev, VCNL4040_REG_ALS_CONF, &als_conf);
 	if (ret < 0)
 		return ret;
 #endif
 	switch (action) {
 	case PM_DEVICE_ACTION_RESUME:
 		/* Clear proximity shutdown */
 		ps_conf &= ~VCNL4040_PS_SD_MASK;

 		ret = vcnl4040_write(dev, VCNL4040_REG_PS_CONF,
 					ps_conf);
 		if (ret < 0)
 			return ret;
 #ifdef CONFIG_VCNL4040_ENABLE_ALS
 		/* Clear als shutdown */
 		als_conf &= ~VCNL4040_ALS_SD_MASK;

 		ret = vcnl4040_write(dev, VCNL4040_REG_ALS_CONF,
 					als_conf);
 		if (ret < 0)
 			return ret;
 #endif
 		break;
 	case PM_DEVICE_ACTION_SUSPEND:
 		/* Set proximity shutdown bit 0 */
 		ps_conf |= VCNL4040_PS_SD_MASK;

 		ret = vcnl4040_write(dev, VCNL4040_REG_PS_CONF,
 					ps_conf);
 		if (ret < 0)
 			return ret;
 #ifdef CONFIG_VCNL4040_ENABLE_ALS
 		/* Clear als shutdown bit 0 */
 		als_conf |= VCNL4040_ALS_SD_MASK;

 		ret = vcnl4040_write(dev, VCNL4040_REG_ALS_CONF,
 					als_conf);
 		if (ret < 0)
 			return ret;
 #endif
 		break;
 	default:
 		return -ENOTSUP;
 	}

 	return ret;
 }
 #endif

 static int vcnl4040_init(const struct device *dev)
 {
 	const struct vcnl4040_config *config = dev->config;
 	struct vcnl4040_data *data = dev->data;
 	uint16_t id;

 	/* Get the I2C device */
 	data->i2c = device_get_binding(config->i2c_name);
 	if (data->i2c == NULL) {
 		LOG_ERR("Could not find I2C device");
 		return -EINVAL;
 	}

 	/* Check device id */
 	if (vcnl4040_read(dev, VCNL4040_REG_DEVICE_ID, &id)) {
 		LOG_ERR("Could not read device id");
 		return -EIO;
 	}

 	if (id != VCNL4040_DEFAULT_ID) {
 		LOG_ERR("Incorrect device id (%d)", id);
 		return -EIO;
 	}

 	if (vcnl4040_proxy_setup(dev)) {
 		LOG_ERR("Failed to setup proximity functionality");
 		return -EIO;
 	}

 #ifdef CONFIG_VCNL4040_ENABLE_ALS
 	if (vcnl4040_ambient_setup(dev)) {
 		LOG_ERR("Failed to setup ambient light functionality");
 		return -EIO;
 	}
 #endif

 	k_sem_init(&data->sem, 0, K_SEM_MAX_LIMIT);

 #if CONFIG_VCNL4040_TRIGGER
 	if (vcnl4040_trigger_init(dev)) {
 		LOG_ERR("Could not initialise interrupts");
 		return -EIO;
 	}
 #endif

 	k_sem_give(&data->sem);

 	LOG_DBG("Init complete");

 	return 0;
 }

 static const struct sensor_driver_api vcnl4040_driver_api = {
 	.sample_fetch = vcnl4040_sample_fetch,
 	.channel_get = vcnl4040_channel_get,
 #ifdef CONFIG_VCNL4040_TRIGGER
 	.attr_set = vcnl4040_attr_set,
 	.trigger_set = vcnl4040_trigger_set,
 #endif
 };

 static const struct vcnl4040_config vcnl4040_config = {
 	.i2c_name = DT_INST_BUS_LABEL(0),
 	.i2c_address = DT_INST_REG_ADDR(0),
 #ifdef CONFIG_VCNL4040_TRIGGER
 #if DT_INST_NODE_HAS_PROP(0, int_gpios)
 	.gpio_name = DT_INST_GPIO_LABEL(0, int_gpios),
 	.gpio_pin = DT_INST_GPIO_PIN(0, int_gpios),
 	.gpio_flags = DT_INST_GPIO_FLAGS(0, int_gpios),
 #else
 	.gpio_name = NULL,
 	.gpio_pin = 0,
 	.gpio_flags = 0,
 #endif
 #endif
 	.led_i = DT_INST_ENUM_IDX(0, led_current),
 	.led_dc = DT_INST_ENUM_IDX(0, led_duty_cycle),
 	.als_it = DT_INST_ENUM_IDX(0, als_it),
 	.proxy_it = DT_INST_ENUM_IDX(0, proximity_it),
 	.proxy_type = DT_INST_ENUM_IDX(0, proximity_trigger),
 };

 static struct vcnl4040_data vcnl4040_data;

 PM_DEVICE_DT_INST_DEFINE(0, vcnl4040_pm_action);

 DEVICE_DT_INST_DEFINE(0, vcnl4040_init,
 	      PM_DEVICE_DT_INST_GET(0), &vcnl4040_data, &vcnl4040_config,
 	      POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &vcnl4040_driver_api);
	/*
	* Copyright (c) 2020 Richard Osterloh
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#define DT_DRV_COMPAT vishay_vcnl4040

	#include "vcnl4040.h"
	#include <zephyr/pm/device.h>
	#include <zephyr/sys/__assert.h>
	#include <zephyr/sys/byteorder.h>
	#include <zephyr/sys/util.h>
	#include <zephyr/logging/log.h>
	#include <stdlib.h>

	LOG_MODULE_REGISTER(vcnl4040, CONFIG_SENSOR_LOG_LEVEL);

	int vcnl4040_read(const struct device dev, uint8_t reg, uint16_t out)
	{
	const struct vcnl4040_config *config = dev->config;
	struct vcnl4040_data *data = dev->data;
	uint8_t buff[2] = { 0 };
	int ret = 0;

	ret = i2c_write_read(data->i2c, config->i2c_address,
	&reg, sizeof(reg), buff, sizeof(buff));

	if (!ret)
	*out = sys_get_le16(buff);

	return ret;
	}

	int vcnl4040_write(const struct device *dev, uint8_t reg, uint16_t value)
	{
	const struct vcnl4040_config *config = dev->config;
	struct vcnl4040_data *data = dev->data;
	struct i2c_msg msg;
	int ret;
	uint8_t buff[3];

	sys_put_le16(value, &buff[1]);

	buff[0] = reg;

	msg.buf = buff;
	msg.flags = 0;
	msg.len = sizeof(buff);

	ret = i2c_transfer(data->i2c, &msg, 1, config->i2c_address);

	if (ret < 0) {
	LOG_ERR("write block failed");
	return ret;
	}

	return 0;
	}

	static int vcnl4040_sample_fetch(const struct device *dev,
	enum sensor_channel chan)
	{
	struct vcnl4040_data *data = dev->data;
	int ret = 0;

	#ifdef CONFIG_VCNL4040_ENABLE_ALS
	__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL \|\|
	chan == SENSOR_CHAN_PROX \|\|
	chan == SENSOR_CHAN_LIGHT);
	#else
	__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL \|\| chan == SENSOR_CHAN_PROX);
	#endif
	k_sem_take(&data->sem, K_FOREVER);

	if (chan == SENSOR_CHAN_ALL \|\| chan == SENSOR_CHAN_PROX) {
	ret = vcnl4040_read(dev, VCNL4040_REG_PS_DATA,
	&data->proximity);
	if (ret < 0) {
	LOG_ERR("Could not fetch proximity");
	goto exit;
	}
	}
	#ifdef CONFIG_VCNL4040_ENABLE_ALS
	if (chan == SENSOR_CHAN_ALL \|\| chan == SENSOR_CHAN_LIGHT) {
	ret = vcnl4040_read(dev, VCNL4040_REG_ALS_DATA,
	&data->light);
	if (ret < 0) {
	LOG_ERR("Could not fetch ambient light");
	}
	}
	#endif
	exit:
	k_sem_give(&data->sem);

	return ret;
	}

	static int vcnl4040_channel_get(const struct device *dev,
	enum sensor_channel chan,
	struct sensor_value *val)
	{
	struct vcnl4040_data *data = dev->data;
	int ret = 0;

	k_sem_take(&data->sem, K_FOREVER);

	switch (chan) {
	case SENSOR_CHAN_PROX:
	val->val1 = data->proximity;
	val->val2 = 0;
	break;

	#ifdef CONFIG_VCNL4040_ENABLE_ALS
	case SENSOR_CHAN_LIGHT:
	val->val1 = data->light * data->sensitivity;
	val->val2 = 0;
	break;
	#endif

	default:
	ret = -ENOTSUP;
	}

	k_sem_give(&data->sem);

	return ret;
	}

	static int vcnl4040_proxy_setup(const struct device *dev)
	{
	const struct vcnl4040_config *config = dev->config;
	uint16_t conf = 0;

	if (vcnl4040_read(dev, VCNL4040_REG_PS_MS, &conf)) {
	LOG_ERR("Could not read proximity config");
	return -EIO;
	}

	/* Set LED current */
	conf \|= config->led_i << VCNL4040_LED_I_POS;

	if (vcnl4040_write(dev, VCNL4040_REG_PS_MS, conf)) {
	LOG_ERR("Could not write proximity config");
	return -EIO;
	}

	if (vcnl4040_read(dev, VCNL4040_REG_PS_CONF, &conf)) {
	LOG_ERR("Could not read proximity config");
	return -EIO;
	}

	/* Set PS_HD */
	conf \|= VCNL4040_PS_HD_MASK;
	/* Set duty cycle */
	conf \|= config->led_dc << VCNL4040_PS_DUTY_POS;
	/* Set integration time */
	conf \|= config->proxy_it << VCNL4040_PS_IT_POS;
	/* Clear proximity shutdown */
	conf &= ~VCNL4040_PS_SD_MASK;

	if (vcnl4040_write(dev, VCNL4040_REG_PS_CONF, conf)) {
	LOG_ERR("Could not write proximity config");
	return -EIO;
	}

	return 0;
	}

	#ifdef CONFIG_VCNL4040_ENABLE_ALS
	static int vcnl4040_ambient_setup(const struct device *dev)
	{
	const struct vcnl4040_config *config = dev->config;
	struct vcnl4040_data *data = dev->data;
	uint16_t conf = 0;

	if (vcnl4040_read(dev, VCNL4040_REG_ALS_CONF, &conf)) {
	LOG_ERR("Could not read proximity config");
	return -EIO;
	}

	/* Set ALS integration time */
	conf \|= config->als_it << VCNL4040_ALS_IT_POS;
	/* Clear ALS shutdown */
	conf &= ~VCNL4040_ALS_SD_MASK;

	if (vcnl4040_write(dev, VCNL4040_REG_ALS_CONF, conf)) {
	LOG_ERR("Could not write proximity config");
	return -EIO;
	}

	/*
	* scale the lux depending on the value of the integration time
	* see page 8 of the VCNL4040 application note:
	* https://www.vishay.com/docs/84307/designingvcnl4040.pdf
	*/
	switch (config->als_it) {
	case VCNL4040_AMBIENT_INTEGRATION_TIME_80MS:
	data->sensitivity = 0.12;
	break;
	case VCNL4040_AMBIENT_INTEGRATION_TIME_160MS:
	data->sensitivity = 0.06;
	break;
	case VCNL4040_AMBIENT_INTEGRATION_TIME_320MS:
	data->sensitivity = 0.03;
	break;
	case VCNL4040_AMBIENT_INTEGRATION_TIME_640MS:
	data->sensitivity = 0.015;
	break;
	default:
	data->sensitivity = 1.0;
	LOG_WRN("Cannot set ALS sensitivity from ALS_IT=%d",
	config->als_it);
	break;
	}

	return 0;
	}
	#endif

	#ifdef CONFIG_PM_DEVICE
	static int vcnl4040_pm_action(const struct device *dev,
	enum pm_device_action action)
	{
	int ret = 0;
	uint16_t ps_conf;

	ret = vcnl4040_read(dev, VCNL4040_REG_PS_CONF, &ps_conf);
	if (ret < 0)
	return ret;
	#ifdef CONFIG_VCNL4040_ENABLE_ALS
	uint16_t als_conf;

	ret = vcnl4040_read(dev, VCNL4040_REG_ALS_CONF, &als_conf);
	if (ret < 0)
	return ret;
	#endif
	switch (action) {
	case PM_DEVICE_ACTION_RESUME:
	/* Clear proximity shutdown */
	ps_conf &= ~VCNL4040_PS_SD_MASK;

	ret = vcnl4040_write(dev, VCNL4040_REG_PS_CONF,
	ps_conf);
	if (ret < 0)
	return ret;
	#ifdef CONFIG_VCNL4040_ENABLE_ALS
	/* Clear als shutdown */
	als_conf &= ~VCNL4040_ALS_SD_MASK;

	ret = vcnl4040_write(dev, VCNL4040_REG_ALS_CONF,
	als_conf);
	if (ret < 0)
	return ret;
	#endif
	break;
	case PM_DEVICE_ACTION_SUSPEND:
	/* Set proximity shutdown bit 0 */
	ps_conf \|= VCNL4040_PS_SD_MASK;

	ret = vcnl4040_write(dev, VCNL4040_REG_PS_CONF,
	ps_conf);
	if (ret < 0)
	return ret;
	#ifdef CONFIG_VCNL4040_ENABLE_ALS
	/* Clear als shutdown bit 0 */
	als_conf \|= VCNL4040_ALS_SD_MASK;

	ret = vcnl4040_write(dev, VCNL4040_REG_ALS_CONF,
	als_conf);
	if (ret < 0)
	return ret;
	#endif
	break;
	default:
	return -ENOTSUP;
	}

	return ret;
	}
	#endif

	static int vcnl4040_init(const struct device *dev)
	{
	const struct vcnl4040_config *config = dev->config;
	struct vcnl4040_data *data = dev->data;
	uint16_t id;

	/* Get the I2C device */
	data->i2c = device_get_binding(config->i2c_name);
	if (data->i2c == NULL) {
	LOG_ERR("Could not find I2C device");
	return -EINVAL;
	}

	/* Check device id */
	if (vcnl4040_read(dev, VCNL4040_REG_DEVICE_ID, &id)) {
	LOG_ERR("Could not read device id");
	return -EIO;
	}

	if (id != VCNL4040_DEFAULT_ID) {
	LOG_ERR("Incorrect device id (%d)", id);
	return -EIO;
	}

	if (vcnl4040_proxy_setup(dev)) {
	LOG_ERR("Failed to setup proximity functionality");
	return -EIO;
	}

	#ifdef CONFIG_VCNL4040_ENABLE_ALS
	if (vcnl4040_ambient_setup(dev)) {
	LOG_ERR("Failed to setup ambient light functionality");
	return -EIO;
	}
	#endif

	k_sem_init(&data->sem, 0, K_SEM_MAX_LIMIT);

	#if CONFIG_VCNL4040_TRIGGER
	if (vcnl4040_trigger_init(dev)) {
	LOG_ERR("Could not initialise interrupts");
	return -EIO;
	}
	#endif

	k_sem_give(&data->sem);

	LOG_DBG("Init complete");

	return 0;
	}

	static const struct sensor_driver_api vcnl4040_driver_api = {
	.sample_fetch = vcnl4040_sample_fetch,
	.channel_get = vcnl4040_channel_get,
	#ifdef CONFIG_VCNL4040_TRIGGER
	.attr_set = vcnl4040_attr_set,
	.trigger_set = vcnl4040_trigger_set,
	#endif
	};

	static const struct vcnl4040_config vcnl4040_config = {
	.i2c_name = DT_INST_BUS_LABEL(0),
	.i2c_address = DT_INST_REG_ADDR(0),
	#ifdef CONFIG_VCNL4040_TRIGGER
	#if DT_INST_NODE_HAS_PROP(0, int_gpios)
	.gpio_name = DT_INST_GPIO_LABEL(0, int_gpios),
	.gpio_pin = DT_INST_GPIO_PIN(0, int_gpios),
	.gpio_flags = DT_INST_GPIO_FLAGS(0, int_gpios),
	#else
	.gpio_name = NULL,
	.gpio_pin = 0,
	.gpio_flags = 0,
	#endif
	#endif
	.led_i = DT_INST_ENUM_IDX(0, led_current),
	.led_dc = DT_INST_ENUM_IDX(0, led_duty_cycle),
	.als_it = DT_INST_ENUM_IDX(0, als_it),
	.proxy_it = DT_INST_ENUM_IDX(0, proximity_it),
	.proxy_type = DT_INST_ENUM_IDX(0, proximity_trigger),
	};

	static struct vcnl4040_data vcnl4040_data;

	PM_DEVICE_DT_INST_DEFINE(0, vcnl4040_pm_action);

	DEVICE_DT_INST_DEFINE(0, vcnl4040_init,
	PM_DEVICE_DT_INST_GET(0), &vcnl4040_data, &vcnl4040_config,
	POST_KERNEL, CONFIG_SENSOR_INIT_PRIORITY, &vcnl4040_driver_api);