drivers/i2c/i2c_nrfx_twi.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2018, Nordic Semiconductor ASA
  *
  * SPDX-License-Identifier: Apache-2.0
  */


 #include <zephyr/drivers/i2c.h>
 #include <zephyr/dt-bindings/i2c/i2c.h>
 #include <zephyr/pm/device.h>
 #include <zephyr/drivers/pinctrl.h>
 #include <soc.h>
 #include <nrfx_twi.h>

 #include <zephyr/logging/log.h>
 #include <zephyr/irq.h>
 LOG_MODULE_REGISTER(i2c_nrfx_twi, CONFIG_I2C_LOG_LEVEL);

 #if CONFIG_I2C_NRFX_TRANSFER_TIMEOUT
 #define I2C_TRANSFER_TIMEOUT_MSEC K_MSEC(CONFIG_I2C_NRFX_TRANSFER_TIMEOUT)
 #else
 #define I2C_TRANSFER_TIMEOUT_MSEC K_FOREVER
 #endif

 struct i2c_nrfx_twi_data {
 	struct k_sem transfer_sync;
 	struct k_sem completion_sync;
 	volatile nrfx_err_t res;
 	uint32_t dev_config;
 };

 struct i2c_nrfx_twi_config {
 	nrfx_twi_t twi;
 	nrfx_twi_config_t config;
 	const struct pinctrl_dev_config *pcfg;
 };

 static int i2c_nrfx_twi_recover_bus(const struct device *dev);

 static int i2c_nrfx_twi_transfer(const struct device *dev,
 				 struct i2c_msg *msgs,
 				 uint8_t num_msgs, uint16_t addr)
 {
 	const struct i2c_nrfx_twi_config *config = dev->config;
 	struct i2c_nrfx_twi_data *data = dev->data;
 	int ret = 0;

 	k_sem_take(&data->transfer_sync, K_FOREVER);

 	/* Dummy take on completion_sync sem to be sure that it is empty */
 	k_sem_take(&data->completion_sync, K_NO_WAIT);

 	nrfx_twi_enable(&config->twi);

 	for (size_t i = 0; i < num_msgs; i++) {
 		if (I2C_MSG_ADDR_10_BITS & msgs[i].flags) {
 			ret = -ENOTSUP;
 			break;
 		}

 		nrfx_twi_xfer_desc_t cur_xfer = {
 			.p_primary_buf  = msgs[i].buf,
 			.primary_length = msgs[i].len,
 			.address	= addr,
 			.type		= (msgs[i].flags & I2C_MSG_READ) ?
 					  NRFX_TWI_XFER_RX : NRFX_TWI_XFER_TX
 		};
 		uint32_t xfer_flags = 0;
 		nrfx_err_t res;

 		/* In case the STOP condition is not supposed to appear after
 		 * the current message, check what is requested further:
 		 */
 		if (!(msgs[i].flags & I2C_MSG_STOP)) {
 			/* - if the transfer consists of more messages
 			 *   and the I2C repeated START is not requested
 			 *   to appear before the next message, suspend
 			 *   the transfer after the current message,
 			 *   so that it can be resumed with the next one,
 			 *   resulting in the two messages merged into
 			 *   a continuous transfer on the bus
 			 */
 			if ((i < (num_msgs - 1)) &&
 			    !(msgs[i + 1].flags & I2C_MSG_RESTART)) {
 				xfer_flags |= NRFX_TWI_FLAG_SUSPEND;
 			/* - otherwise, just finish the transfer without
 			 *   generating the STOP condition, unless the current
 			 *   message is an RX request, for which such feature
 			 *   is not supported
 			 */
 			} else if (msgs[i].flags & I2C_MSG_READ) {
 				ret = -ENOTSUP;
 				break;
 			} else {
 				xfer_flags |= NRFX_TWI_FLAG_TX_NO_STOP;
 			}
 		}

 		res = nrfx_twi_xfer(&config->twi, &cur_xfer, xfer_flags);
 		if (res != NRFX_SUCCESS) {
 			if (res == NRFX_ERROR_BUSY) {
 				ret = -EBUSY;
 				break;
 			} else {
 				ret = -EIO;
 				break;
 			}
 		}

 		ret = k_sem_take(&data->completion_sync,
 				 I2C_TRANSFER_TIMEOUT_MSEC);
 		if (ret != 0) {
 			/* Whatever the frequency, completion_sync should have
 			 * been given by the event handler.
 			 *
 			 * If it hasn't, it's probably due to an hardware issue
 			 * on the I2C line, for example a short between SDA and
 			 * GND.
 			 * This is issue has also been when trying to use the
 			 * I2C bus during MCU internal flash erase.
 			 *
 			 * In many situation, a retry is sufficient.
 			 * However, some time the I2C device get stuck and need
 			 * help to recover.
 			 * Therefore we always call i2c_nrfx_twi_recover_bus()
 			 * to make sure everything has been done to restore the
 			 * bus from this error.
 			 */
 			LOG_ERR("Error on I2C line occurred for message %d", i);
 			nrfx_twi_disable(&config->twi);
 			(void)i2c_nrfx_twi_recover_bus(dev);
 			ret = -EIO;
 			break;
 		}

 		res = data->res;
 		if (res != NRFX_SUCCESS) {
 			LOG_ERR("Error 0x%08X occurred for message %d", res, i);
 			ret = -EIO;
 			break;
 		}
 	}

 	nrfx_twi_disable(&config->twi);
 	k_sem_give(&data->transfer_sync);

 	return ret;
 }

 static void event_handler(nrfx_twi_evt_t const *p_event, void *p_context)
 {
 	struct i2c_nrfx_twi_data *dev_data = p_context;

 	switch (p_event->type) {
 	case NRFX_TWI_EVT_DONE:
 		dev_data->res = NRFX_SUCCESS;
 		break;
 	case NRFX_TWI_EVT_ADDRESS_NACK:
 		dev_data->res = NRFX_ERROR_DRV_TWI_ERR_ANACK;
 		break;
 	case NRFX_TWI_EVT_DATA_NACK:
 		dev_data->res = NRFX_ERROR_DRV_TWI_ERR_DNACK;
 		break;
 	default:
 		dev_data->res = NRFX_ERROR_INTERNAL;
 		break;
 	}

 	k_sem_give(&dev_data->completion_sync);
 }

 static int i2c_nrfx_twi_configure(const struct device *dev,
 				  uint32_t dev_config)
 {
 	const struct i2c_nrfx_twi_config *config = dev->config;
 	struct i2c_nrfx_twi_data *data = dev->data;
 	nrfx_twi_t const *inst = &config->twi;

 	if (I2C_ADDR_10_BITS & dev_config) {
 		return -EINVAL;
 	}

 	switch (I2C_SPEED_GET(dev_config)) {
 	case I2C_SPEED_STANDARD:
 		nrf_twi_frequency_set(inst->p_twi, NRF_TWI_FREQ_100K);
 		break;
 	case I2C_SPEED_FAST:
 		nrf_twi_frequency_set(inst->p_twi, NRF_TWI_FREQ_400K);
 		break;
 	default:
 		LOG_ERR("unsupported speed");
 		return -EINVAL;
 	}
 	data->dev_config = dev_config;

 	return 0;
 }

 static int i2c_nrfx_twi_recover_bus(const struct device *dev)
 {
 	const struct i2c_nrfx_twi_config *config = dev->config;
 	uint32_t scl_pin;
 	uint32_t sda_pin;
 	nrfx_err_t err;

 	scl_pin = nrf_twi_scl_pin_get(config->twi.p_twi);
 	sda_pin = nrf_twi_sda_pin_get(config->twi.p_twi);

 	err = nrfx_twi_bus_recover(scl_pin, sda_pin);
 	return (err == NRFX_SUCCESS ? 0 : -EBUSY);
 }

 static const struct i2c_driver_api i2c_nrfx_twi_driver_api = {
 	.configure   = i2c_nrfx_twi_configure,
 	.transfer    = i2c_nrfx_twi_transfer,
 	.recover_bus = i2c_nrfx_twi_recover_bus,
 };

 static int init_twi(const struct device *dev)
 {
 	const struct i2c_nrfx_twi_config *config = dev->config;
 	struct i2c_nrfx_twi_data *dev_data = dev->data;
 	nrfx_err_t result = nrfx_twi_init(&config->twi, &config->config,
 					  event_handler, dev_data);
 	if (result != NRFX_SUCCESS) {
 		LOG_ERR("Failed to initialize device: %s",
 			    dev->name);
 		return -EBUSY;
 	}

 	return 0;
 }

 #ifdef CONFIG_PM_DEVICE
 static int twi_nrfx_pm_action(const struct device *dev,
 			      enum pm_device_action action)
 {
 	const struct i2c_nrfx_twi_config *config = dev->config;
 	struct i2c_nrfx_twi_data *data = dev->data;
 	int ret = 0;

 	switch (action) {
 	case PM_DEVICE_ACTION_RESUME:
 		ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT);
 		if (ret < 0) {
 			return ret;
 		}
 		init_twi(dev);
 		if (data->dev_config) {
 			i2c_nrfx_twi_configure(dev, data->dev_config);
 		}
 		break;

 	case PM_DEVICE_ACTION_SUSPEND:
 		nrfx_twi_uninit(&config->twi);

 		ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_SLEEP);
 		if (ret < 0) {
 			return ret;
 		}
 		break;

 	default:
 		ret = -ENOTSUP;
 	}

 	return ret;
 }
 #endif /* CONFIG_PM_DEVICE */

 #define I2C_NRFX_TWI_INVALID_FREQUENCY  ((nrf_twi_frequency_t)-1)
 #define I2C_NRFX_TWI_FREQUENCY(bitrate)					       \
 	 (bitrate == I2C_BITRATE_STANDARD ? NRF_TWI_FREQ_100K		       \
 	: bitrate == 250000               ? NRF_TWI_FREQ_250K		       \
 	: bitrate == I2C_BITRATE_FAST     ? NRF_TWI_FREQ_400K		       \
 					  : I2C_NRFX_TWI_INVALID_FREQUENCY)
 #define I2C(idx) DT_NODELABEL(i2c##idx)
 #define I2C_FREQUENCY(idx)						       \
 	I2C_NRFX_TWI_FREQUENCY(DT_PROP(I2C(idx), clock_frequency))

 #define I2C_NRFX_TWI_DEVICE(idx)					       \
 	NRF_DT_CHECK_NODE_HAS_PINCTRL_SLEEP(I2C(idx));			       \
 	BUILD_ASSERT(I2C_FREQUENCY(idx)	!=				       \
 		     I2C_NRFX_TWI_INVALID_FREQUENCY,			       \
 		     "Wrong I2C " #idx " frequency setting in dts");	       \
 	static int twi_##idx##_init(const struct device *dev)		       \
 	{								       \
 		IRQ_CONNECT(DT_IRQN(I2C(idx)), DT_IRQ(I2C(idx), priority),     \
 			    nrfx_isr, nrfx_twi_##idx##_irq_handler, 0);	       \
 		const struct i2c_nrfx_twi_config *config = dev->config;	       \
 		int err = pinctrl_apply_state(config->pcfg,		       \
 					      PINCTRL_STATE_DEFAULT);	       \
 		if (err < 0) {						       \
 			return err;					       \
 		}							       \
 		return init_twi(dev);					       \
 	}								       \
 	static struct i2c_nrfx_twi_data twi_##idx##_data = {		       \
 		.transfer_sync = Z_SEM_INITIALIZER(                            \
 			twi_##idx##_data.transfer_sync, 1, 1),                 \
 		.completion_sync = Z_SEM_INITIALIZER(                          \
 			twi_##idx##_data.completion_sync, 0, 1)		       \
 	};								       \
 	PINCTRL_DT_DEFINE(I2C(idx));					       \
 	static const struct i2c_nrfx_twi_config twi_##idx##z_config = {	       \
 		.twi = NRFX_TWI_INSTANCE(idx),				       \
 		.config = {						       \
 			.skip_gpio_cfg = true,				       \
 			.skip_psel_cfg = true,				       \
 			.frequency = I2C_FREQUENCY(idx),		       \
 		},							       \
 		.pcfg = PINCTRL_DT_DEV_CONFIG_GET(I2C(idx)),		       \
 	};								       \
 	PM_DEVICE_DT_DEFINE(I2C(idx), twi_nrfx_pm_action);		       \
 	I2C_DEVICE_DT_DEFINE(I2C(idx),					       \
 		      twi_##idx##_init,					       \
 		      PM_DEVICE_DT_GET(I2C(idx)),			       \
 		      &twi_##idx##_data,				       \
 		      &twi_##idx##z_config,				       \
 		      POST_KERNEL,					       \
 		      CONFIG_I2C_INIT_PRIORITY,				       \
 		      &i2c_nrfx_twi_driver_api)

 #ifdef CONFIG_HAS_HW_NRF_TWI0
 I2C_NRFX_TWI_DEVICE(0);
 #endif

 #ifdef CONFIG_HAS_HW_NRF_TWI1
 I2C_NRFX_TWI_DEVICE(1);
 #endif
	/*
	* Copyright (c) 2018, Nordic Semiconductor ASA
	*
	* SPDX-License-Identifier: Apache-2.0
	*/


	#include <zephyr/drivers/i2c.h>
	#include <zephyr/dt-bindings/i2c/i2c.h>
	#include <zephyr/pm/device.h>
	#include <zephyr/drivers/pinctrl.h>
	#include <soc.h>
	#include <nrfx_twi.h>

	#include <zephyr/logging/log.h>
	#include <zephyr/irq.h>
	LOG_MODULE_REGISTER(i2c_nrfx_twi, CONFIG_I2C_LOG_LEVEL);

	#if CONFIG_I2C_NRFX_TRANSFER_TIMEOUT
	#define I2C_TRANSFER_TIMEOUT_MSEC K_MSEC(CONFIG_I2C_NRFX_TRANSFER_TIMEOUT)
	#else
	#define I2C_TRANSFER_TIMEOUT_MSEC K_FOREVER
	#endif

	struct i2c_nrfx_twi_data {
	struct k_sem transfer_sync;
	struct k_sem completion_sync;
	volatile nrfx_err_t res;
	uint32_t dev_config;
	};

	struct i2c_nrfx_twi_config {
	nrfx_twi_t twi;
	nrfx_twi_config_t config;
	const struct pinctrl_dev_config *pcfg;
	};

	static int i2c_nrfx_twi_recover_bus(const struct device *dev);

	static int i2c_nrfx_twi_transfer(const struct device *dev,
	struct i2c_msg *msgs,
	uint8_t num_msgs, uint16_t addr)
	{
	const struct i2c_nrfx_twi_config *config = dev->config;
	struct i2c_nrfx_twi_data *data = dev->data;
	int ret = 0;

	k_sem_take(&data->transfer_sync, K_FOREVER);

	/* Dummy take on completion_sync sem to be sure that it is empty */
	k_sem_take(&data->completion_sync, K_NO_WAIT);

	nrfx_twi_enable(&config->twi);

	for (size_t i = 0; i < num_msgs; i++) {
	if (I2C_MSG_ADDR_10_BITS & msgs[i].flags) {
	ret = -ENOTSUP;
	break;
	}

	nrfx_twi_xfer_desc_t cur_xfer = {
	.p_primary_buf = msgs[i].buf,
	.primary_length = msgs[i].len,
	.address = addr,
	.type = (msgs[i].flags & I2C_MSG_READ) ?
	NRFX_TWI_XFER_RX : NRFX_TWI_XFER_TX
	};
	uint32_t xfer_flags = 0;
	nrfx_err_t res;

	/* In case the STOP condition is not supposed to appear after
	* the current message, check what is requested further:
	*/
	if (!(msgs[i].flags & I2C_MSG_STOP)) {
	/* - if the transfer consists of more messages
	* and the I2C repeated START is not requested
	* to appear before the next message, suspend
	* the transfer after the current message,
	* so that it can be resumed with the next one,
	* resulting in the two messages merged into
	* a continuous transfer on the bus
	*/
	if ((i < (num_msgs - 1)) &&
	!(msgs[i + 1].flags & I2C_MSG_RESTART)) {
	xfer_flags \|= NRFX_TWI_FLAG_SUSPEND;
	/* - otherwise, just finish the transfer without
	* generating the STOP condition, unless the current
	* message is an RX request, for which such feature
	* is not supported
	*/
	} else if (msgs[i].flags & I2C_MSG_READ) {
	ret = -ENOTSUP;
	break;
	} else {
	xfer_flags \|= NRFX_TWI_FLAG_TX_NO_STOP;
	}
	}

	res = nrfx_twi_xfer(&config->twi, &cur_xfer, xfer_flags);
	if (res != NRFX_SUCCESS) {
	if (res == NRFX_ERROR_BUSY) {
	ret = -EBUSY;
	break;
	} else {
	ret = -EIO;
	break;
	}
	}

	ret = k_sem_take(&data->completion_sync,
	I2C_TRANSFER_TIMEOUT_MSEC);
	if (ret != 0) {
	/* Whatever the frequency, completion_sync should have
	* been given by the event handler.
	*
	* If it hasn't, it's probably due to an hardware issue
	* on the I2C line, for example a short between SDA and
	* GND.
	* This is issue has also been when trying to use the
	* I2C bus during MCU internal flash erase.
	*
	* In many situation, a retry is sufficient.
	* However, some time the I2C device get stuck and need
	* help to recover.
	* Therefore we always call i2c_nrfx_twi_recover_bus()
	* to make sure everything has been done to restore the
	* bus from this error.
	*/
	LOG_ERR("Error on I2C line occurred for message %d", i);
	nrfx_twi_disable(&config->twi);
	(void)i2c_nrfx_twi_recover_bus(dev);
	ret = -EIO;
	break;
	}

	res = data->res;
	if (res != NRFX_SUCCESS) {
	LOG_ERR("Error 0x%08X occurred for message %d", res, i);
	ret = -EIO;
	break;
	}
	}

	nrfx_twi_disable(&config->twi);
	k_sem_give(&data->transfer_sync);

	return ret;
	}

	static void event_handler(nrfx_twi_evt_t const p_event, void p_context)
	{
	struct i2c_nrfx_twi_data *dev_data = p_context;

	switch (p_event->type) {
	case NRFX_TWI_EVT_DONE:
	dev_data->res = NRFX_SUCCESS;
	break;
	case NRFX_TWI_EVT_ADDRESS_NACK:
	dev_data->res = NRFX_ERROR_DRV_TWI_ERR_ANACK;
	break;
	case NRFX_TWI_EVT_DATA_NACK:
	dev_data->res = NRFX_ERROR_DRV_TWI_ERR_DNACK;
	break;
	default:
	dev_data->res = NRFX_ERROR_INTERNAL;
	break;
	}

	k_sem_give(&dev_data->completion_sync);
	}

	static int i2c_nrfx_twi_configure(const struct device *dev,
	uint32_t dev_config)
	{
	const struct i2c_nrfx_twi_config *config = dev->config;
	struct i2c_nrfx_twi_data *data = dev->data;
	nrfx_twi_t const *inst = &config->twi;

	if (I2C_ADDR_10_BITS & dev_config) {
	return -EINVAL;
	}

	switch (I2C_SPEED_GET(dev_config)) {
	case I2C_SPEED_STANDARD:
	nrf_twi_frequency_set(inst->p_twi, NRF_TWI_FREQ_100K);
	break;
	case I2C_SPEED_FAST:
	nrf_twi_frequency_set(inst->p_twi, NRF_TWI_FREQ_400K);
	break;
	default:
	LOG_ERR("unsupported speed");
	return -EINVAL;
	}
	data->dev_config = dev_config;

	return 0;
	}

	static int i2c_nrfx_twi_recover_bus(const struct device *dev)
	{
	const struct i2c_nrfx_twi_config *config = dev->config;
	uint32_t scl_pin;
	uint32_t sda_pin;
	nrfx_err_t err;

	scl_pin = nrf_twi_scl_pin_get(config->twi.p_twi);
	sda_pin = nrf_twi_sda_pin_get(config->twi.p_twi);

	err = nrfx_twi_bus_recover(scl_pin, sda_pin);
	return (err == NRFX_SUCCESS ? 0 : -EBUSY);
	}

	static const struct i2c_driver_api i2c_nrfx_twi_driver_api = {
	.configure = i2c_nrfx_twi_configure,
	.transfer = i2c_nrfx_twi_transfer,
	.recover_bus = i2c_nrfx_twi_recover_bus,
	};

	static int init_twi(const struct device *dev)
	{
	const struct i2c_nrfx_twi_config *config = dev->config;
	struct i2c_nrfx_twi_data *dev_data = dev->data;
	nrfx_err_t result = nrfx_twi_init(&config->twi, &config->config,
	event_handler, dev_data);
	if (result != NRFX_SUCCESS) {
	LOG_ERR("Failed to initialize device: %s",
	dev->name);
	return -EBUSY;
	}

	return 0;
	}

	#ifdef CONFIG_PM_DEVICE
	static int twi_nrfx_pm_action(const struct device *dev,
	enum pm_device_action action)
	{
	const struct i2c_nrfx_twi_config *config = dev->config;
	struct i2c_nrfx_twi_data *data = dev->data;
	int ret = 0;

	switch (action) {
	case PM_DEVICE_ACTION_RESUME:
	ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT);
	if (ret < 0) {
	return ret;
	}
	init_twi(dev);
	if (data->dev_config) {
	i2c_nrfx_twi_configure(dev, data->dev_config);
	}
	break;

	case PM_DEVICE_ACTION_SUSPEND:
	nrfx_twi_uninit(&config->twi);

	ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_SLEEP);
	if (ret < 0) {
	return ret;
	}
	break;

	default:
	ret = -ENOTSUP;
	}

	return ret;
	}
	#endif /* CONFIG_PM_DEVICE */

	#define I2C_NRFX_TWI_INVALID_FREQUENCY ((nrf_twi_frequency_t)-1)
	#define I2C_NRFX_TWI_FREQUENCY(bitrate) \
	(bitrate == I2C_BITRATE_STANDARD ? NRF_TWI_FREQ_100K \
	: bitrate == 250000 ? NRF_TWI_FREQ_250K \
	: bitrate == I2C_BITRATE_FAST ? NRF_TWI_FREQ_400K \
	: I2C_NRFX_TWI_INVALID_FREQUENCY)
	#define I2C(idx) DT_NODELABEL(i2c##idx)
	#define I2C_FREQUENCY(idx) \
	I2C_NRFX_TWI_FREQUENCY(DT_PROP(I2C(idx), clock_frequency))

	#define I2C_NRFX_TWI_DEVICE(idx) \
	NRF_DT_CHECK_NODE_HAS_PINCTRL_SLEEP(I2C(idx)); \
	BUILD_ASSERT(I2C_FREQUENCY(idx) != \
	I2C_NRFX_TWI_INVALID_FREQUENCY, \
	"Wrong I2C " #idx " frequency setting in dts"); \
	static int twi_##idx##_init(const struct device *dev) \
	{ \
	IRQ_CONNECT(DT_IRQN(I2C(idx)), DT_IRQ(I2C(idx), priority), \
	nrfx_isr, nrfx_twi_##idx##_irq_handler, 0); \
	const struct i2c_nrfx_twi_config *config = dev->config; \
	int err = pinctrl_apply_state(config->pcfg, \
	PINCTRL_STATE_DEFAULT); \
	if (err < 0) { \
	return err; \
	} \
	return init_twi(dev); \
	} \
	static struct i2c_nrfx_twi_data twi_##idx##_data = { \
	.transfer_sync = Z_SEM_INITIALIZER( \
	twi_##idx##_data.transfer_sync, 1, 1), \
	.completion_sync = Z_SEM_INITIALIZER( \
	twi_##idx##_data.completion_sync, 0, 1) \
	}; \
	PINCTRL_DT_DEFINE(I2C(idx)); \
	static const struct i2c_nrfx_twi_config twi_##idx##z_config = { \
	.twi = NRFX_TWI_INSTANCE(idx), \
	.config = { \
	.skip_gpio_cfg = true, \
	.skip_psel_cfg = true, \
	.frequency = I2C_FREQUENCY(idx), \
	}, \
	.pcfg = PINCTRL_DT_DEV_CONFIG_GET(I2C(idx)), \
	}; \
	PM_DEVICE_DT_DEFINE(I2C(idx), twi_nrfx_pm_action); \
	I2C_DEVICE_DT_DEFINE(I2C(idx), \
	twi_##idx##_init, \
	PM_DEVICE_DT_GET(I2C(idx)), \
	&twi_##idx##_data, \
	&twi_##idx##z_config, \
	POST_KERNEL, \
	CONFIG_I2C_INIT_PRIORITY, \
	&i2c_nrfx_twi_driver_api)

	#ifdef CONFIG_HAS_HW_NRF_TWI0
	I2C_NRFX_TWI_DEVICE(0);
	#endif

	#ifdef CONFIG_HAS_HW_NRF_TWI1
	I2C_NRFX_TWI_DEVICE(1);
	#endif