drivers: i2c: silabs: i2c driver enhancements for EFR series 2 devices

Updated the I2C driver for EFR Series 2 devices based on the
design improvements in the GSDK I2C implementation

Signed-off-by: S Mohamed Fiaz <[email protected]>

Author: fimohame

drivers/i2c/i2c_silabs.c

@@ -10,17 +10,13 @@
 #include <zephyr/drivers/pinctrl.h>
 #include <zephyr/kernel.h>
 #include <zephyr/logging/log.h>
-#if defined(CONFIG_I2C_SILABS_DMA)
 #include <zephyr/drivers/dma.h>
-#endif
 #include <zephyr/drivers/clock_control.h>
 #include <zephyr/drivers/clock_control/clock_control_silabs.h>
 #include <zephyr/pm/device.h>
 #include <zephyr/pm/device_runtime.h>
 #include <zephyr/pm/policy.h>
-#include <sl_hal_i2c.h>
 #include <sl_i2c.h>
-#include <sl_status.h>
 #include <sli_i2c.h>
 
 #define LOG_LEVEL CONFIG_I2C_LOG_LEVEL
@@ -36,7 +32,7 @@ struct i2c_silabs_dma_config {
 /* Structure for I2C device configuration */
 struct i2c_silabs_dev_config {
 	const struct pinctrl_dev_config *pcfg; /* Pin configuration for the I2C instance */
-	I2C_TypeDef *base;                     /* I2C peripheral base address */
+	sl_peripheral_t peripheral;            /* I2C peripheral structure */
 	uint32_t bitrate;                      /* I2C bitrate (clock frequency) */
 	void (*irq_config_func)(void);         /* IRQ configuration function */
 	const struct device *clock;            /* Clock device */
@@ -47,11 +43,12 @@ struct i2c_silabs_dev_config {
 struct i2c_silabs_dev_data {
 	struct k_sem bus_lock;               /* Semaphore to lock the I2C bus */
 	struct k_sem transfer_sem;           /* Semaphore to manage transfer */
-	sli_i2c_instance_t i2c_instance;     /* I2C instance structure */
+	sl_i2c_handle_t i2c_handle;          /* I2C handle structure */
 	struct i2c_silabs_dma_config dma_rx; /* DMA configuration for RX */
 	struct i2c_silabs_dma_config dma_tx; /* DMA configuration for TX */
 	bool asynchronous;                   /* Indicates if transfer is asynchronous */
 	bool last_transfer;                  /* Transfer is the last in the sequence */
+	bool is_10bit_addr;                  /* Indicates if addr is 7-bit or 10-bit */
 #if defined CONFIG_I2C_CALLBACK
 	i2c_callback_t callback; /* I2C callback function pointer */
 	void *callback_context;  /* Context for I2C callback */
@@ -64,15 +61,11 @@ static int i2c_silabs_pm_action(const struct device *dev, enum pm_device_action
 
 static bool i2c_silabs_is_dma_enabled_instance(const struct device *dev)
 {
-#ifdef CONFIG_I2C_SILABS_DMA
 	struct i2c_silabs_dev_data *data = dev->data;
 
 	__ASSERT_NO_MSG(!!data->dma_tx.dma_dev == !!data->dma_rx.dma_dev);
 
 	return data->dma_rx.dma_dev != NULL;
-#else
-	return false;
-#endif
 }
 
 static void i2c_silabs_pm_policy_state_lock_get(const struct device *dev)
@@ -92,18 +85,17 @@ static int i2c_silabs_dev_configure(const struct device *dev, uint32_t dev_confi
 {
 	const struct i2c_silabs_dev_config *config = dev->config;
 	struct i2c_silabs_dev_data *data = dev->data;
-	sl_i2c_init_params_t init_params;
 
 	/* Determine the I2C speed and corresponding baudrate */
 	switch (I2C_SPEED_GET(dev_config)) {
 	case I2C_SPEED_STANDARD:
-		init_params.freq_mode = SL_I2C_FREQ_STANDARD_MODE;
+		data->i2c_handle.frequency_mode = SL_I2C_FREQ_STANDARD_MODE;
 		break;
 	case I2C_SPEED_FAST:
-		init_params.freq_mode = SL_I2C_FREQ_FAST_MODE;
+		data->i2c_handle.frequency_mode = SL_I2C_FREQ_FAST_MODE;
 		break;
 	case I2C_SPEED_FAST_PLUS:
-		init_params.freq_mode = SL_I2C_FREQ_FASTPLUS_MODE;
+		data->i2c_handle.frequency_mode = SL_I2C_FREQ_FASTPLUS_MODE;
 		break;
 	default:
 		return -EINVAL;
@@ -112,19 +104,13 @@ static int i2c_silabs_dev_configure(const struct device *dev, uint32_t dev_confi
 	/* Take the bus lock semaphore to ensure exclusive access */
 	k_sem_take(&data->bus_lock, K_FOREVER);
 	/* Initialize I2C parameters */
-	init_params.i2c_base_addr = config->base;
-	data->i2c_instance.i2c_base_addr = init_params.i2c_base_addr;
+	data->i2c_handle.i2c_peripheral = config->peripheral;
 
-	/* Set the operating mode (leader or follower) */
-#if defined(CONFIG_I2C_TARGET)
-	init_params.operating_mode = SL_I2C_FOLLOWER_MODE;
-#else
-	init_params.operating_mode = SL_I2C_LEADER_MODE;
-#endif /* CONFIG_I2C_TARGET */
-	data->i2c_instance.operating_mode = init_params.operating_mode;
+	/* Set the operating mode (leader) */
+	data->i2c_handle.operating_mode = SL_I2C_LEADER_MODE;
 
 	/* Configure the I2C instance */
-	sli_i2c_instance_configuration(&init_params);
+	sli_i2c_init_core(&data->i2c_handle);
 
 	/* Release the bus lock semaphore */
 	k_sem_give(&data->bus_lock);
@@ -137,25 +123,21 @@ static int i2c_silabs_transfer_dma(const struct device *dev, struct i2c_msg *msg
 				   uint16_t addr, i2c_callback_t cb, void *userdata,
 				   bool asynchronous)
 {
-#if defined(CONFIG_I2C_SILABS_DMA)
 	struct i2c_silabs_dev_data *data = dev->data;
-	__maybe_unused const struct i2c_silabs_dev_config *config = dev->config;
-	sl_i2c_handle_t *i2c_handle = (sl_i2c_handle_t *)&data->i2c_instance;
 #if defined(CONFIG_I2C_CALLBACK)
 	data->callback_invoked = false;
 #endif
 	data->pm_lock_done = false;
 	uint8_t i = 0;
 	int err = 0;
 
+	if (!IS_ENABLED(CONFIG_I2C_SILABS_DMA)) {
+		return -ENOTSUP;
+	}
+
 	/* Get the power management policy state lock */
 	i2c_silabs_pm_policy_state_lock_get(dev);
 
-#if defined(CONFIG_I2C_TARGET)
-	/* Set follower address in target mode */
-	sli_i2c_set_follower_address(config->base, addr, data->i2c_instance.is_10bit_addr);
-#endif /* CONFIG_I2C_TARGET */
-
 	while (i < num_msgs) {
 		uint8_t msgs_in_transfer = 1;
 
@@ -167,24 +149,27 @@ static int i2c_silabs_transfer_dma(const struct device *dev, struct i2c_msg *msg
 		data->last_transfer = (i + msgs_in_transfer) == num_msgs;
 
 		if (msgs_in_transfer == 2) {
-			if (sl_i2c_transfer_non_blocking(i2c_handle, msgs[i].buf, msgs[i].len,
-							 msgs[i + 1].buf, msgs[i + 1].len, NULL,
-							 NULL) != 0) {
+			if (sl_i2c_leader_transfer_non_blocking(
+				    &data->i2c_handle, addr, msgs[i].buf, msgs[i].len,
+				    msgs[i + 1].buf, msgs[i + 1].len, NULL) != 0) {
 				k_sem_give(&data->bus_lock);
+				i2c_silabs_pm_policy_state_lock_put(dev);
 				return -EIO;
 			}
 		} else if (msgs[i].flags & I2C_MSG_READ) {
 			/* Start DMA receive */
-			if (sl_i2c_receive_non_blocking(i2c_handle, msgs[i].buf, msgs[i].len, NULL,
-							NULL) != 0) {
+			if (sl_i2c_leader_receive_non_blocking(&data->i2c_handle, addr, msgs[i].buf,
+							       msgs[i].len, NULL) != 0) {
 				k_sem_give(&data->bus_lock);
+				i2c_silabs_pm_policy_state_lock_put(dev);
 				return -EIO;
 			}
 		} else {
 			/* Start DMA send */
-			if (sl_i2c_send_non_blocking(i2c_handle, msgs[i].buf, msgs[i].len, NULL,
-						     NULL) != 0) {
+			if (sl_i2c_leader_send_non_blocking(&data->i2c_handle, addr, msgs[i].buf,
+							    msgs[i].len, NULL) != 0) {
 				k_sem_give(&data->bus_lock);
+				i2c_silabs_pm_policy_state_lock_put(dev);
 				return -EIO;
 			}
 		}
@@ -193,30 +178,28 @@ static int i2c_silabs_transfer_dma(const struct device *dev, struct i2c_msg *msg
 			if (k_sem_take(&data->transfer_sem, K_MSEC(CONFIG_I2C_SILABS_TIMEOUT))) {
 				err = -ETIMEDOUT;
 			}
-			if (data->i2c_instance.state == SLI_I2C_STATE_ERROR) {
+			if (data->i2c_handle.state == SL_I2C_STATE_ERROR) {
 				err = -EIO;
 			}
 			k_sem_reset(&data->transfer_sem);
 			if (err < 0) {
+				i2c_silabs_pm_policy_state_lock_put(dev);
 				break;
 			}
 		}
 		i += msgs_in_transfer;
 	}
 
 	return err;
-#else
-	return -ENOTSUP;
-#endif /* CONFIG_I2C_SILABS_DMA */
 }
 
 /* Function to handle synchronous transfer */
 static int i2c_silabs_transfer_sync(const struct device *dev, struct i2c_msg *msgs,
 				    uint8_t num_msgs, uint16_t addr)
 {
 	struct i2c_silabs_dev_data *data = dev->data;
-	sl_i2c_handle_t *i2c_handle = (sl_i2c_handle_t *)&data->i2c_instance;
 	uint8_t i = 0;
+	int err = 0;
 
 	/* Get the power management policy state lock */
 	i2c_silabs_pm_policy_state_lock_get(dev);
@@ -227,35 +210,43 @@ static int i2c_silabs_transfer_sync(const struct device *dev, struct i2c_msg *ms
 		if ((msgs[i].flags & I2C_MSG_WRITE) == 0 && (i + 1 < num_msgs) &&
 		    (msgs[i + 1].flags & I2C_MSG_READ)) {
 			msgs_in_transfer = 2;
-			if (sl_i2c_transfer(i2c_handle, msgs[i].buf, msgs[i].len, msgs[i + 1].buf,
-					    msgs[i + 1].len) != 0) {
+			if (sl_i2c_leader_transfer_blocking(&data->i2c_handle, addr, msgs[i].buf,
+							    msgs[i].len, msgs[i + 1].buf,
+							    msgs[i + 1].len,
+							    CONFIG_I2C_SILABS_TIMEOUT) != 0) {
 				k_sem_give(&data->bus_lock);
-				return -EIO;
+				err = -EIO;
+				goto out;
 			}
 			i++;
 		} else if (msgs[i].flags & I2C_MSG_READ) {
-			if (sl_i2c_receive_blocking(i2c_handle, msgs[i].buf, msgs[i].len,
-						    CONFIG_I2C_SILABS_TIMEOUT) != 0) {
+			if (sl_i2c_leader_receive_blocking(&data->i2c_handle, addr, msgs[i].buf,
+							   msgs[i].len,
+							   CONFIG_I2C_SILABS_TIMEOUT) != 0) {
 				k_sem_give(&data->bus_lock);
-				return -ETIMEDOUT;
+				err = -ETIMEDOUT;
+				goto out;
 			}
 		} else {
-			if (sl_i2c_send_blocking(i2c_handle, msgs[i].buf, msgs[i].len,
-						 CONFIG_I2C_SILABS_TIMEOUT) != 0) {
+			if (sl_i2c_leader_send_blocking(&data->i2c_handle, addr, msgs[i].buf,
+							msgs[i].len,
+							CONFIG_I2C_SILABS_TIMEOUT) != 0) {
 				k_sem_give(&data->bus_lock);
-				return -ETIMEDOUT;
+				err = -ETIMEDOUT;
+				goto out;
 			}
 		}
 		i += msgs_in_transfer;
 	}
 
+out:
 	/* Release the bus lock semaphore */
 	k_sem_give(&data->bus_lock);
 
 	/* Release the power management policy state lock */
 	i2c_silabs_pm_policy_state_lock_put(dev);
 
-	return 0;
+	return err;
 }
 
 /* Function to perform I2C transfer */
@@ -264,8 +255,6 @@ static int i2c_silabs_transfer_impl(const struct device *dev, struct i2c_msg *ms
 				    void *userdata)
 {
 	struct i2c_silabs_dev_data *data = dev->data;
-	__maybe_unused const struct i2c_silabs_dev_config *config = dev->config;
-	sl_i2c_handle_t *i2c_handle = (sl_i2c_handle_t *)&data->i2c_instance;
 	int ret = -EINVAL; /* Initialize ret to a default error value */
 
 	/* Check for invalid number of messages */
@@ -276,9 +265,9 @@ static int i2c_silabs_transfer_impl(const struct device *dev, struct i2c_msg *ms
 	/* Check and set the address mode (7-bit or 10-bit) based on */
 	/* the provided address */
 	if (addr <= 0x7F) {
-		data->i2c_instance.is_10bit_addr = false; /* 7-bit address */
+		data->is_10bit_addr = false; /* 7-bit address */
 	} else if (addr <= 0x3FF) {
-		data->i2c_instance.is_10bit_addr = true; /* 10-bit address */
+		data->is_10bit_addr = true; /* 10-bit address */
 	} else {
 		return -EINVAL;
 	}
@@ -292,12 +281,6 @@ static int i2c_silabs_transfer_impl(const struct device *dev, struct i2c_msg *ms
 		return ret;
 	}
 
-	/* Set the follower address */
-	if (sl_i2c_set_follower_address(i2c_handle, addr) != 0) {
-		k_sem_give(&data->bus_lock);
-		return -EINVAL;
-	}
-
 	if (i2c_silabs_is_dma_enabled_instance(dev)) {
 		/* DMA transfer handle a/synchronous transfers */
 		ret = i2c_silabs_transfer_dma(dev, msgs, num_msgs, addr, cb, userdata,
@@ -373,25 +356,23 @@ static int i2c_silabs_dev_init(const struct device *dev)
 		return -EINVAL;
 	}
 
-#if defined(CONFIG_I2C_SILABS_DMA)
 	if (i2c_silabs_is_dma_enabled_instance(dev)) {
 		if (!device_is_ready(data->dma_rx.dma_dev) ||
 		    !device_is_ready(data->dma_tx.dma_dev)) {
 			return -ENODEV;
 		}
 		data->dma_rx.dma_channel = dma_request_channel(data->dma_rx.dma_dev, NULL);
-		data->i2c_instance.dma_channel.dma_rx_channel = data->dma_rx.dma_channel;
+		data->i2c_handle.dma_channel.dma_rx_channel = data->dma_rx.dma_channel;
 
 		data->dma_tx.dma_channel = dma_request_channel(data->dma_tx.dma_dev, NULL);
-		data->i2c_instance.dma_channel.dma_tx_channel = data->dma_tx.dma_channel;
+		data->i2c_handle.dma_channel.dma_tx_channel = data->dma_tx.dma_channel;
 
 		if (data->dma_rx.dma_channel < 0 || data->dma_tx.dma_channel < 0) {
 			dma_release_channel(data->dma_rx.dma_dev, data->dma_rx.dma_channel);
 			dma_release_channel(data->dma_tx.dma_dev, data->dma_tx.dma_channel);
 			return -EAGAIN;
 		}
 	}
-#endif /* CONFIG_I2C_SILABS_DMA */
 
 	/* Configure IRQ */
 	config->irq_config_func();
@@ -445,15 +426,10 @@ static int i2c_silabs_pm_action(const struct device *dev, enum pm_device_action
 void i2c_silabs_isr_handler(const struct device *dev)
 {
 	struct i2c_silabs_dev_data *data = dev->data;
-	sli_i2c_instance_t *sl_i2c_instance = &data->i2c_instance;
+	sl_i2c_handle_t *sl_i2c_handle = &data->i2c_handle;
 
-#if defined(CONFIG_I2C_TARGET)
-	sli_i2c_follower_dispatch_interrupt(sl_i2c_instance);
-#else
-	sli_i2c_leader_dispatch_interrupt(sl_i2c_instance);
-#endif
-	if (sl_i2c_instance->transfer_event != SL_I2C_EVENT_IN_PROGRESS &&
-	    sl_i2c_instance->rstart == 0) {
+	sli_i2c_leader_dispatch_interrupt(sl_i2c_handle);
+	if (sl_i2c_handle->event != SL_I2C_EVENT_IN_PROGRESS) {
 		if (!data->asynchronous) {
 			k_sem_give(&data->transfer_sem);
 		}
@@ -462,9 +438,9 @@ void i2c_silabs_isr_handler(const struct device *dev)
 			int err = 0;
 
 			data->callback_invoked = true;
-			if (sl_i2c_instance->transfer_event == SL_I2C_EVENT_ARBITRATION_LOST ||
-			    sl_i2c_instance->transfer_event == SL_I2C_EVENT_BUS_ERROR ||
-			    sl_i2c_instance->transfer_event == SL_I2C_EVENT_INVALID_ADDR) {
+			if (sl_i2c_handle->event == SL_I2C_EVENT_ARBITRATION_LOST ||
+			    sl_i2c_handle->event == SL_I2C_EVENT_BUS_ERROR ||
+			    sl_i2c_handle->event == SL_I2C_EVENT_INVALID_ADDR) {
 				err = -EIO;
 			}
 			data->callback(dev, err, data->callback_context);
@@ -503,10 +479,17 @@ static DEVICE_API(i2c, i2c_silabs_dev_driver_api) = {
 			     irq_enable(DT_INST_IRQ(idx, irq));),                                  \
 			    ())									   \
 	}                                                                                          \
-                                                                                                   \
+	                                                                                           \
+	static const uint32_t i2c_bus_clock_##idx = DT_INST_CLOCKS_CELL(idx, enable);              \
+	static const sl_peripheral_val_t i2c_peripheral_val_##idx = {                              \
+		.base = DT_INST_REG_ADDR(idx),                                                     \
+		.clk_branch = DT_INST_CLOCKS_CELL(idx, branch),                                    \
+		.bus_clock = (DT_INST_CLOCKS_CELL(idx, enable) ? &i2c_bus_clock_##idx : NULL),     \
+	};                                                                                         \
+												   \
 	static const struct i2c_silabs_dev_config i2c_silabs_dev_config_##idx = {                  \
 		.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(idx),                                       \
-		.base = (I2C_TypeDef *)DT_INST_REG_ADDR(idx),                                      \
+		.peripheral = &i2c_peripheral_val_##idx,                                           \
 		.bitrate = DT_INST_PROP(idx, clock_frequency),                                     \
 		.irq_config_func = i2c_silabs_irq_config_##idx,                                    \
 		.clock = DEVICE_DT_GET(DT_INST_CLOCKS_CTLR(idx)),                                  \