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

 /*
  * Copyright (c) 2016-2017 ARM Ltd.
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <errno.h>
 #include <i2c.h>
 #include <soc.h>
 #include <nrf.h>
 #include <misc/util.h>
 #include <gpio.h>

 #include "i2c-priv.h"

 #define SYS_LOG_LEVEL CONFIG_SYS_LOG_I2C_LEVEL
 #include <logging/sys_log.h>

 /* @todo
  *
  * Only one instance of twi0 and spi0 may be active at any point in time.
  * Only one instance of twi1, spi1 and spis1 may be active at a time.
  */

 #define NRF5_TWI_INT_STOPPED \
 	(TWI_INTENSET_STOPPED_Set << TWI_INTENSET_STOPPED_Pos)
 #define NRF5_TWI_INT_RXDREADY \
 	(TWI_INTENSET_RXDREADY_Set << TWI_INTENSET_RXDREADY_Pos)
 #define NRF5_TWI_INT_TXDSENT \
 	(TWI_INTENSET_TXDSENT_Set << TWI_INTENSET_TXDSENT_Pos)
 #define NRF5_TWI_INT_ERROR \
 	(TWI_INTENSET_ERROR_Set << TWI_INTENSET_ERROR_Pos)


 struct i2c_nrf5_config {
 	volatile NRF_TWI_Type *base;
 	void (*irq_config_func)(struct device *dev);
 	u32_t bitrate;
 	u32_t sda_pin;
 	u32_t scl_pin;
 };


 struct i2c_nrf5_data {
 	struct k_sem sem;
 	u32_t rxd:1;
 	u32_t txd:1;
 	u32_t err:1;
 	u32_t stopped:1;
 	struct device *gpio;
 	struct k_sem lock;
 };


 static int i2c_nrf5_configure(struct device *dev, u32_t dev_config_raw)
 {
 	const struct i2c_nrf5_config *config = dev->config->config_info;
 	struct i2c_nrf5_data *data = dev->driver_data;
 	volatile NRF_TWI_Type *twi = config->base;
 	int ret = 0;


 	SYS_LOG_DBG("");

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

 	k_sem_take(&data->lock, K_FOREVER);

 	switch (I2C_SPEED_GET(dev_config_raw)) {
 	case I2C_SPEED_STANDARD:
 		twi->FREQUENCY = TWI_FREQUENCY_FREQUENCY_K100;
 		break;
 	case I2C_SPEED_FAST:
 		twi->FREQUENCY = TWI_FREQUENCY_FREQUENCY_K400;
 		break;
 	default:
 		SYS_LOG_ERR("unsupported speed");
 		ret = -EINVAL;
 	}

 	k_sem_give(&data->lock);

 	return ret;
 }

 static int i2c_nrf5_read(struct device *dev, struct i2c_msg *msg)
 {
 	const struct i2c_nrf5_config *config = dev->config->config_info;
 	struct i2c_nrf5_data *data = dev->driver_data;
 	volatile NRF_TWI_Type *twi = config->base;

 	__ASSERT_NO_MSG(msg->len);

 	if (msg->flags & I2C_MSG_RESTART) {
 		/* No special behaviour required for
 		 * repeated start.
 		 */
 	}

 	for (int offset = 0; offset < msg->len; offset++) {
 		if (offset == msg->len-1) {
 			SYS_LOG_DBG("SHORTS=2");
 			twi->SHORTS = 2; /* BB->STOP */
 		} else {
 			SYS_LOG_DBG("SHORTS=1");
 			twi->SHORTS = 1; /* BB->SUSPEND */
 		}

 		if (offset == 0) {
 			SYS_LOG_DBG("STARTRX");
 			twi->TASKS_STARTRX = 1;
 		} else {
 			SYS_LOG_DBG("RESUME");
 			twi->TASKS_RESUME = 1;
 		}

 		k_sem_take(&data->sem, K_FOREVER);

 		if (data->err) {
 			data->err = 0;
 			SYS_LOG_DBG("rx error 0x%x", twi->ERRORSRC);
 			twi->TASKS_STOP = 1;
 			twi->ENABLE = TWI_ENABLE_ENABLE_Disabled;
 			return -EIO;
 		}

 		__ASSERT_NO_MSG(data->rxd);

 		SYS_LOG_DBG("RXD");
 		data->rxd = 0;
 		msg->buf[offset] = twi->RXD;
 	}

 	if (msg->flags & I2C_MSG_STOP) {
 		SYS_LOG_DBG("TASK_STOP");
 		k_sem_take(&data->sem, K_FOREVER);
 		SYS_LOG_DBG("err=%d txd=%d rxd=%d stopped=%d errsrc=0x%x",
 			    data->err, data->txd, data->rxd,
 			    data->stopped, twi->ERRORSRC);
 		__ASSERT_NO_MSG(data->stopped);
 		data->stopped = 0;
 	}

 	return 0;
 }

 static int i2c_nrf5_write(struct device *dev,
 			  struct i2c_msg *msg)
 {
 	const struct i2c_nrf5_config *config = dev->config->config_info;
 	struct i2c_nrf5_data *data = dev->driver_data;
 	volatile NRF_TWI_Type *twi = config->base;

 	__ASSERT_NO_MSG(msg->len);

 	SYS_LOG_DBG("");

 	data->stopped = 0;
 	data->txd = 0;

 	twi->EVENTS_TXDSENT = 0;
 	twi->SHORTS = 0;

 	for (int offset = 0; offset < msg->len; offset++) {
 		SYS_LOG_DBG("txd=0x%x", msg->buf[offset]);
 		twi->TXD = msg->buf[offset];

 		if (offset == 0) {
 			SYS_LOG_DBG("STARTTX");
 			twi->TASKS_STARTTX = 1;
 		}

 		SYS_LOG_DBG("wait for sync");
 		k_sem_take(&data->sem, K_FOREVER);
 		SYS_LOG_DBG("err=%d txd=%d stopped=%d errsrc=0x%x",
 			    data->err, data->txd,
 			    data->stopped, twi->ERRORSRC);

 		if (data->err) {
 			data->err = 0;
 			SYS_LOG_ERR("tx error 0x%x",
 				    twi->ERRORSRC);
 			twi->ERRORSRC = twi->ERRORSRC;
 			twi->TASKS_STOP = 1;
 			return -EIO;
 		}

 		__ASSERT_NO_MSG(data->txd);
 		data->txd = 0;
 		SYS_LOG_DBG("txdsent arrived");
 	}

 	if (msg->flags & I2C_MSG_STOP) {
 		SYS_LOG_DBG("TASK_STOP");
 		twi->TASKS_STOP = 1;
 		k_sem_take(&data->sem, K_FOREVER);
 		SYS_LOG_DBG("err=%d txd=%d rxd=%d stopped=%d errsrc=0x%x",
 			    data->err, data->txd, data->rxd,
 			    data->stopped, twi->ERRORSRC);
 		data->stopped = 0;
 	}

 	return 0;
 }

 static int i2c_nrf5_transfer(struct device *dev, struct i2c_msg *msgs,
 			     u8_t num_msgs, u16_t addr)
 {
 	const struct i2c_nrf5_config *config = dev->config->config_info;
 	struct i2c_nrf5_data *data = dev->driver_data;
 	volatile NRF_TWI_Type *twi = config->base;
 	int ret = 0;

 	k_sem_take(&data->lock, K_FOREVER);

 	SYS_LOG_DBG("transaction-start addr=0x%x", addr);

 	/* @todo The NRF5 imposes constraints on which peripherals can
 	 * be simultaneously active.  We should take steps here to
 	 * enforce appropriate mutual exclusion between SPI, TWI and
 	 * SPIS drivers.
 	 */

 	twi->ENABLE = TWI_ENABLE_ENABLE_Enabled;
 	twi->ADDRESS = addr;
 	for (int i = 0; i < num_msgs; i++) {
 		SYS_LOG_DBG("msg len=%d %s%s%s", msgs[i].len,
 			    (msgs[i].flags & I2C_MSG_READ) ? "R":"W",
 			    (msgs[i].flags & I2C_MSG_STOP) ? "S":"-",
 			    (msgs[i].flags & I2C_MSG_RESTART) ? "+":"-");

 		if (msgs[i].flags & I2C_MSG_READ) {
 			twi->EVENTS_RXDREADY = 0;
 			twi->INTENSET = (NRF5_TWI_INT_TXDSENT
 					 | NRF5_TWI_INT_RXDREADY
 					 | NRF5_TWI_INT_ERROR
 					 | NRF5_TWI_INT_STOPPED);
 			ret = i2c_nrf5_read(dev, msgs + i);
 		} else {
 			ret = i2c_nrf5_write(dev, msgs + i);
 		}

 		if (ret != 0) {
 			break;
 		}
 	}
 	twi->ENABLE = TWI_ENABLE_ENABLE_Disabled;

 	k_sem_give(&data->lock);

 	return ret;
 }

 static void i2c_nrf5_isr(void *arg)
 {
 	struct device *dev = (struct device *)arg;
 	const struct i2c_nrf5_config *config = dev->config->config_info;
 	struct i2c_nrf5_data *data = dev->driver_data;
 	volatile NRF_TWI_Type *twi = config->base;

 	if (twi->EVENTS_RXDREADY) {
 		data->rxd = 1;
 		twi->EVENTS_RXDREADY = 0;
 		k_sem_give(&data->sem);
 	}

 	if (twi->EVENTS_TXDSENT) {
 		data->txd = 1;
 		twi->EVENTS_TXDSENT = 0;
 		k_sem_give(&data->sem);
 	}

 	if (twi->EVENTS_ERROR) {
 		data->err = 1;
 		twi->EVENTS_ERROR = 0;
 		k_sem_give(&data->sem);
 	}

 	if (twi->EVENTS_STOPPED) {
 		data->stopped = 1;
 		twi->EVENTS_STOPPED = 0;
 		k_sem_give(&data->sem);
 	}
 }

 static int i2c_nrf5_init(struct device *dev)
 {
 	const struct i2c_nrf5_config *config = dev->config->config_info;
 	struct i2c_nrf5_data *data = dev->driver_data;
 	volatile NRF_TWI_Type *twi = config->base;
 	u32_t bitrate_cfg;
 	int status;

 	SYS_LOG_DBG("");

 	data->gpio = device_get_binding(CONFIG_GPIO_NRF5_P0_DEV_NAME);

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

 	config->irq_config_func(dev);

 	twi->ENABLE = TWI_ENABLE_ENABLE_Disabled;

 	status = gpio_pin_configure(data->gpio, config->scl_pin,
 				    GPIO_DIR_IN
 				    | GPIO_PUD_PULL_UP
 				    | GPIO_DS_DISCONNECT_HIGH);
 	__ASSERT_NO_MSG(status == 0);

 	status = gpio_pin_configure(data->gpio, config->sda_pin,
 				    GPIO_DIR_IN
 				    | GPIO_PUD_PULL_UP
 				    | GPIO_DS_DISCONNECT_HIGH);
 	__ASSERT_NO_MSG(status == 0);

 	twi->PSELSCL = config->scl_pin;
 	twi->PSELSDA = config->sda_pin;
 	twi->ERRORSRC = twi->ERRORSRC;
 	twi->EVENTS_TXDSENT = 0;
 	twi->EVENTS_RXDREADY = 0;
 	twi->EVENTS_ERROR = 0;
 	twi->INTENSET = (NRF5_TWI_INT_TXDSENT
 			 | NRF5_TWI_INT_RXDREADY
 			 | NRF5_TWI_INT_ERROR
 			 | NRF5_TWI_INT_STOPPED);

 	bitrate_cfg = _i2c_map_dt_bitrate(config->bitrate);
 	status = i2c_nrf5_configure(dev, I2C_MODE_MASTER | bitrate_cfg);

 	k_sem_give(&data->lock);

 	return status;
 }

 static const struct i2c_driver_api i2c_nrf5_driver_api = {
 	.configure = i2c_nrf5_configure,
 	.transfer = i2c_nrf5_transfer,
 };

 /* i2c & spi instance with the same id (e.g. I2C_0 and SPI_0) can NOT be used
  * at the same time on nRF5x chip family.
  */
 #if defined(CONFIG_I2C_0) && !defined(CONFIG_SPI_0)
 static void i2c_nrf5_config_func_0(struct device *dev);

 static const struct i2c_nrf5_config i2c_nrf5_config_0 = {
 	.base = (volatile NRF_TWI_Type *)CONFIG_I2C_0_BASE_ADDR,
 	.irq_config_func = i2c_nrf5_config_func_0,
 	.bitrate = CONFIG_I2C_0_BITRATE,
 	.sda_pin = CONFIG_I2C_NRF5_0_GPIO_SDA_PIN,
 	.scl_pin = CONFIG_I2C_NRF5_0_GPIO_SCL_PIN,
 };

 static struct i2c_nrf5_data i2c_nrf5_data_0 = {
 	.lock = _K_SEM_INITIALIZER(i2c_nrf5_data_0.lock, 1, 1),
 };

 DEVICE_AND_API_INIT(i2c_nrf5_0, CONFIG_I2C_0_NAME, i2c_nrf5_init,
 		    &i2c_nrf5_data_0, &i2c_nrf5_config_0,
 		    POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
 		    &i2c_nrf5_driver_api);

 static void i2c_nrf5_config_func_0(struct device *dev)
 {
 	IRQ_CONNECT(CONFIG_I2C_0_IRQ, CONFIG_I2C_0_IRQ_PRI, i2c_nrf5_isr,
 		    DEVICE_GET(i2c_nrf5_0), 0);

 	irq_enable(CONFIG_I2C_0_IRQ);
 }
 #endif /* CONFIG_I2C_0 && !CONFIG_SPI_0 */

 #if defined(CONFIG_I2C_1) && !defined(CONFIG_SPI_1)
 static void i2c_nrf5_config_func_1(struct device *dev);

 static const struct i2c_nrf5_config i2c_nrf5_config_1 = {
 	.base = (volatile NRF_TWI_Type *)CONFIG_I2C_1_BASE_ADDR,
 	.irq_config_func = i2c_nrf5_config_func_1,
 	.bitrate = CONFIG_I2C_1_BITRATE,
 	.sda_pin = CONFIG_I2C_NRF5_1_GPIO_SDA_PIN,
 	.scl_pin = CONFIG_I2C_NRF5_1_GPIO_SCL_PIN,
 };

 static struct i2c_nrf5_data i2c_nrf5_data_1 = {
 	.lock = _K_SEM_INITIALIZER(i2c_nrf5_data_1.lock, 1, 1),
 };

 DEVICE_AND_API_INIT(i2c_nrf5_1, CONFIG_I2C_1_NAME, i2c_nrf5_init,
 		    &i2c_nrf5_data_1, &i2c_nrf5_config_1,
 		    POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
 		    &i2c_nrf5_driver_api);

 static void i2c_nrf5_config_func_1(struct device *dev)
 {
 	IRQ_CONNECT(CONFIG_I2C_1_IRQ, CONFIG_I2C_1_IRQ_PRI, i2c_nrf5_isr,
 		    DEVICE_GET(i2c_nrf5_1), 0);

 	irq_enable(CONFIG_I2C_1_IRQ);
 }
 #endif /* CONFIG_I2C_1 && !CONFIG_SPI_1 */
	/*
	* Copyright (c) 2016-2017 ARM Ltd.
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <errno.h>
	#include <i2c.h>
	#include <soc.h>
	#include <nrf.h>
	#include <misc/util.h>
	#include <gpio.h>

	#include "i2c-priv.h"

	#define SYS_LOG_LEVEL CONFIG_SYS_LOG_I2C_LEVEL
	#include <logging/sys_log.h>

	/* @todo
	*
	* Only one instance of twi0 and spi0 may be active at any point in time.
	* Only one instance of twi1, spi1 and spis1 may be active at a time.
	*/

	#define NRF5_TWI_INT_STOPPED \
	(TWI_INTENSET_STOPPED_Set << TWI_INTENSET_STOPPED_Pos)
	#define NRF5_TWI_INT_RXDREADY \
	(TWI_INTENSET_RXDREADY_Set << TWI_INTENSET_RXDREADY_Pos)
	#define NRF5_TWI_INT_TXDSENT \
	(TWI_INTENSET_TXDSENT_Set << TWI_INTENSET_TXDSENT_Pos)
	#define NRF5_TWI_INT_ERROR \
	(TWI_INTENSET_ERROR_Set << TWI_INTENSET_ERROR_Pos)


	struct i2c_nrf5_config {
	volatile NRF_TWI_Type *base;
	void (irq_config_func)(struct device dev);
	u32_t bitrate;
	u32_t sda_pin;
	u32_t scl_pin;
	};


	struct i2c_nrf5_data {
	struct k_sem sem;
	u32_t rxd:1;
	u32_t txd:1;
	u32_t err:1;
	u32_t stopped:1;
	struct device *gpio;
	struct k_sem lock;
	};


	static int i2c_nrf5_configure(struct device *dev, u32_t dev_config_raw)
	{
	const struct i2c_nrf5_config *config = dev->config->config_info;
	struct i2c_nrf5_data *data = dev->driver_data;
	volatile NRF_TWI_Type *twi = config->base;
	int ret = 0;


	SYS_LOG_DBG("");

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

	k_sem_take(&data->lock, K_FOREVER);

	switch (I2C_SPEED_GET(dev_config_raw)) {
	case I2C_SPEED_STANDARD:
	twi->FREQUENCY = TWI_FREQUENCY_FREQUENCY_K100;
	break;
	case I2C_SPEED_FAST:
	twi->FREQUENCY = TWI_FREQUENCY_FREQUENCY_K400;
	break;
	default:
	SYS_LOG_ERR("unsupported speed");
	ret = -EINVAL;
	}

	k_sem_give(&data->lock);

	return ret;
	}

	static int i2c_nrf5_read(struct device dev, struct i2c_msg msg)
	{
	const struct i2c_nrf5_config *config = dev->config->config_info;
	struct i2c_nrf5_data *data = dev->driver_data;
	volatile NRF_TWI_Type *twi = config->base;

	__ASSERT_NO_MSG(msg->len);

	if (msg->flags & I2C_MSG_RESTART) {
	/* No special behaviour required for
	* repeated start.
	*/
	}

	for (int offset = 0; offset < msg->len; offset++) {
	if (offset == msg->len-1) {
	SYS_LOG_DBG("SHORTS=2");
	twi->SHORTS = 2; /* BB->STOP */
	} else {
	SYS_LOG_DBG("SHORTS=1");
	twi->SHORTS = 1; /* BB->SUSPEND */
	}

	if (offset == 0) {
	SYS_LOG_DBG("STARTRX");
	twi->TASKS_STARTRX = 1;
	} else {
	SYS_LOG_DBG("RESUME");
	twi->TASKS_RESUME = 1;
	}

	k_sem_take(&data->sem, K_FOREVER);

	if (data->err) {
	data->err = 0;
	SYS_LOG_DBG("rx error 0x%x", twi->ERRORSRC);
	twi->TASKS_STOP = 1;
	twi->ENABLE = TWI_ENABLE_ENABLE_Disabled;
	return -EIO;
	}

	__ASSERT_NO_MSG(data->rxd);

	SYS_LOG_DBG("RXD");
	data->rxd = 0;
	msg->buf[offset] = twi->RXD;
	}

	if (msg->flags & I2C_MSG_STOP) {
	SYS_LOG_DBG("TASK_STOP");
	k_sem_take(&data->sem, K_FOREVER);
	SYS_LOG_DBG("err=%d txd=%d rxd=%d stopped=%d errsrc=0x%x",
	data->err, data->txd, data->rxd,
	data->stopped, twi->ERRORSRC);
	__ASSERT_NO_MSG(data->stopped);
	data->stopped = 0;
	}

	return 0;
	}

	static int i2c_nrf5_write(struct device *dev,
	struct i2c_msg *msg)
	{
	const struct i2c_nrf5_config *config = dev->config->config_info;
	struct i2c_nrf5_data *data = dev->driver_data;
	volatile NRF_TWI_Type *twi = config->base;

	__ASSERT_NO_MSG(msg->len);

	SYS_LOG_DBG("");

	data->stopped = 0;
	data->txd = 0;

	twi->EVENTS_TXDSENT = 0;
	twi->SHORTS = 0;

	for (int offset = 0; offset < msg->len; offset++) {
	SYS_LOG_DBG("txd=0x%x", msg->buf[offset]);
	twi->TXD = msg->buf[offset];

	if (offset == 0) {
	SYS_LOG_DBG("STARTTX");
	twi->TASKS_STARTTX = 1;
	}

	SYS_LOG_DBG("wait for sync");
	k_sem_take(&data->sem, K_FOREVER);
	SYS_LOG_DBG("err=%d txd=%d stopped=%d errsrc=0x%x",
	data->err, data->txd,
	data->stopped, twi->ERRORSRC);

	if (data->err) {
	data->err = 0;
	SYS_LOG_ERR("tx error 0x%x",
	twi->ERRORSRC);
	twi->ERRORSRC = twi->ERRORSRC;
	twi->TASKS_STOP = 1;
	return -EIO;
	}

	__ASSERT_NO_MSG(data->txd);
	data->txd = 0;
	SYS_LOG_DBG("txdsent arrived");
	}

	if (msg->flags & I2C_MSG_STOP) {
	SYS_LOG_DBG("TASK_STOP");
	twi->TASKS_STOP = 1;
	k_sem_take(&data->sem, K_FOREVER);
	SYS_LOG_DBG("err=%d txd=%d rxd=%d stopped=%d errsrc=0x%x",
	data->err, data->txd, data->rxd,
	data->stopped, twi->ERRORSRC);
	data->stopped = 0;
	}

	return 0;
	}

	static int i2c_nrf5_transfer(struct device dev, struct i2c_msg msgs,
	u8_t num_msgs, u16_t addr)
	{
	const struct i2c_nrf5_config *config = dev->config->config_info;
	struct i2c_nrf5_data *data = dev->driver_data;
	volatile NRF_TWI_Type *twi = config->base;
	int ret = 0;

	k_sem_take(&data->lock, K_FOREVER);

	SYS_LOG_DBG("transaction-start addr=0x%x", addr);

	/* @todo The NRF5 imposes constraints on which peripherals can
	* be simultaneously active. We should take steps here to
	* enforce appropriate mutual exclusion between SPI, TWI and
	* SPIS drivers.
	*/

	twi->ENABLE = TWI_ENABLE_ENABLE_Enabled;
	twi->ADDRESS = addr;
	for (int i = 0; i < num_msgs; i++) {
	SYS_LOG_DBG("msg len=%d %s%s%s", msgs[i].len,
	(msgs[i].flags & I2C_MSG_READ) ? "R":"W",
	(msgs[i].flags & I2C_MSG_STOP) ? "S":"-",
	(msgs[i].flags & I2C_MSG_RESTART) ? "+":"-");

	if (msgs[i].flags & I2C_MSG_READ) {
	twi->EVENTS_RXDREADY = 0;
	twi->INTENSET = (NRF5_TWI_INT_TXDSENT
	\| NRF5_TWI_INT_RXDREADY
	\| NRF5_TWI_INT_ERROR
	\| NRF5_TWI_INT_STOPPED);
	ret = i2c_nrf5_read(dev, msgs + i);
	} else {
	ret = i2c_nrf5_write(dev, msgs + i);
	}

	if (ret != 0) {
	break;
	}
	}
	twi->ENABLE = TWI_ENABLE_ENABLE_Disabled;

	k_sem_give(&data->lock);

	return ret;
	}

	static void i2c_nrf5_isr(void *arg)
	{
	struct device dev = (struct device )arg;
	const struct i2c_nrf5_config *config = dev->config->config_info;
	struct i2c_nrf5_data *data = dev->driver_data;
	volatile NRF_TWI_Type *twi = config->base;

	if (twi->EVENTS_RXDREADY) {
	data->rxd = 1;
	twi->EVENTS_RXDREADY = 0;
	k_sem_give(&data->sem);
	}

	if (twi->EVENTS_TXDSENT) {
	data->txd = 1;
	twi->EVENTS_TXDSENT = 0;
	k_sem_give(&data->sem);
	}

	if (twi->EVENTS_ERROR) {
	data->err = 1;
	twi->EVENTS_ERROR = 0;
	k_sem_give(&data->sem);
	}

	if (twi->EVENTS_STOPPED) {
	data->stopped = 1;
	twi->EVENTS_STOPPED = 0;
	k_sem_give(&data->sem);
	}
	}

	static int i2c_nrf5_init(struct device *dev)
	{
	const struct i2c_nrf5_config *config = dev->config->config_info;
	struct i2c_nrf5_data *data = dev->driver_data;
	volatile NRF_TWI_Type *twi = config->base;
	u32_t bitrate_cfg;
	int status;

	SYS_LOG_DBG("");

	data->gpio = device_get_binding(CONFIG_GPIO_NRF5_P0_DEV_NAME);

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

	config->irq_config_func(dev);

	twi->ENABLE = TWI_ENABLE_ENABLE_Disabled;

	status = gpio_pin_configure(data->gpio, config->scl_pin,
	GPIO_DIR_IN
	\| GPIO_PUD_PULL_UP
	\| GPIO_DS_DISCONNECT_HIGH);
	__ASSERT_NO_MSG(status == 0);

	status = gpio_pin_configure(data->gpio, config->sda_pin,
	GPIO_DIR_IN
	\| GPIO_PUD_PULL_UP
	\| GPIO_DS_DISCONNECT_HIGH);
	__ASSERT_NO_MSG(status == 0);

	twi->PSELSCL = config->scl_pin;
	twi->PSELSDA = config->sda_pin;
	twi->ERRORSRC = twi->ERRORSRC;
	twi->EVENTS_TXDSENT = 0;
	twi->EVENTS_RXDREADY = 0;
	twi->EVENTS_ERROR = 0;
	twi->INTENSET = (NRF5_TWI_INT_TXDSENT
	\| NRF5_TWI_INT_RXDREADY
	\| NRF5_TWI_INT_ERROR
	\| NRF5_TWI_INT_STOPPED);

	bitrate_cfg = _i2c_map_dt_bitrate(config->bitrate);
	status = i2c_nrf5_configure(dev, I2C_MODE_MASTER \| bitrate_cfg);

	k_sem_give(&data->lock);

	return status;
	}

	static const struct i2c_driver_api i2c_nrf5_driver_api = {
	.configure = i2c_nrf5_configure,
	.transfer = i2c_nrf5_transfer,
	};

	/* i2c & spi instance with the same id (e.g. I2C_0 and SPI_0) can NOT be used
	* at the same time on nRF5x chip family.
	*/
	#if defined(CONFIG_I2C_0) && !defined(CONFIG_SPI_0)
	static void i2c_nrf5_config_func_0(struct device *dev);

	static const struct i2c_nrf5_config i2c_nrf5_config_0 = {
	.base = (volatile NRF_TWI_Type *)CONFIG_I2C_0_BASE_ADDR,
	.irq_config_func = i2c_nrf5_config_func_0,
	.bitrate = CONFIG_I2C_0_BITRATE,
	.sda_pin = CONFIG_I2C_NRF5_0_GPIO_SDA_PIN,
	.scl_pin = CONFIG_I2C_NRF5_0_GPIO_SCL_PIN,
	};

	static struct i2c_nrf5_data i2c_nrf5_data_0 = {
	.lock = _K_SEM_INITIALIZER(i2c_nrf5_data_0.lock, 1, 1),
	};

	DEVICE_AND_API_INIT(i2c_nrf5_0, CONFIG_I2C_0_NAME, i2c_nrf5_init,
	&i2c_nrf5_data_0, &i2c_nrf5_config_0,
	POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
	&i2c_nrf5_driver_api);

	static void i2c_nrf5_config_func_0(struct device *dev)
	{
	IRQ_CONNECT(CONFIG_I2C_0_IRQ, CONFIG_I2C_0_IRQ_PRI, i2c_nrf5_isr,
	DEVICE_GET(i2c_nrf5_0), 0);

	irq_enable(CONFIG_I2C_0_IRQ);
	}
	#endif /* CONFIG_I2C_0 && !CONFIG_SPI_0 */

	#if defined(CONFIG_I2C_1) && !defined(CONFIG_SPI_1)
	static void i2c_nrf5_config_func_1(struct device *dev);

	static const struct i2c_nrf5_config i2c_nrf5_config_1 = {
	.base = (volatile NRF_TWI_Type *)CONFIG_I2C_1_BASE_ADDR,
	.irq_config_func = i2c_nrf5_config_func_1,
	.bitrate = CONFIG_I2C_1_BITRATE,
	.sda_pin = CONFIG_I2C_NRF5_1_GPIO_SDA_PIN,
	.scl_pin = CONFIG_I2C_NRF5_1_GPIO_SCL_PIN,
	};

	static struct i2c_nrf5_data i2c_nrf5_data_1 = {
	.lock = _K_SEM_INITIALIZER(i2c_nrf5_data_1.lock, 1, 1),
	};

	DEVICE_AND_API_INIT(i2c_nrf5_1, CONFIG_I2C_1_NAME, i2c_nrf5_init,
	&i2c_nrf5_data_1, &i2c_nrf5_config_1,
	POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEVICE,
	&i2c_nrf5_driver_api);

	static void i2c_nrf5_config_func_1(struct device *dev)
	{
	IRQ_CONNECT(CONFIG_I2C_1_IRQ, CONFIG_I2C_1_IRQ_PRI, i2c_nrf5_isr,
	DEVICE_GET(i2c_nrf5_1), 0);

	irq_enable(CONFIG_I2C_1_IRQ);
	}
	#endif /* CONFIG_I2C_1 && !CONFIG_SPI_1 */