[subsys|drivers|tests]/modem: update to new ring_buffer api

Mattemagikern · Mattemagikern · commit b4c8870f5c4d · 2025-10-15T07:57:08.000+02:00
move to new ring_buffer api.

Signed-off-by: Måns Ansgariusson &lt;Mansgariusson@gmail.com&gt;
diff --git a/drivers/modem/Kconfig b/drivers/modem/Kconfig
@@ -18,7 +18,6 @@ config MODEM_RECEIVER
 	bool "Modem receiver helper driver"
 	depends on SERIAL_SUPPORT_INTERRUPT
 	select UART_INTERRUPT_DRIVEN
-	select RING_BUFFER
 	help
 	  This driver allows modem drivers to communicate over UART with custom
 	  defined protocols. Driver doesn't inspect received data and all
@@ -64,7 +63,6 @@ config MODEM_CONTEXT_VERBOSE_DEBUG
 
 config MODEM_IFACE_UART
 	bool "UART-based modem interface"
-	select RING_BUFFER
 	help
 	  To configure this layer for use, create a modem_iface_uart_data
 	  object and pass it's reference to modem_iface_uart_init()
diff --git a/drivers/modem/Kconfig.cellular b/drivers/modem/Kconfig.cellular
@@ -11,7 +11,6 @@ config MODEM_CELLULAR
 	select MODEM_PIPELINK
 	select MODEM_BACKEND_UART
 	select UART_USE_RUNTIME_CONFIGURE
-	select RING_BUFFER
 	select NET_L2_PPP_OPTION_MRU
 	select NET_L2_PPP_PAP
 	select NET_L2_PPP_MGMT
diff --git a/drivers/modem/modem_cellular.c b/drivers/modem/modem_cellular.c
@@ -165,7 +165,7 @@ struct modem_cellular_data {
 	/* Event dispatcher */
 	struct k_work event_dispatch_work;
 	uint8_t event_buf[8];
-	struct ring_buf event_rb;
+	struct ring_buffer event_rb;
 	struct k_mutex event_rb_lock;
 
 	struct k_mutex api_lock;
@@ -723,7 +723,7 @@ static void modem_cellular_event_dispatch_handler(struct k_work *item)
 
 	k_mutex_lock(&data->event_rb_lock, K_FOREVER);
 
-	events_cnt = (uint8_t)ring_buf_get(&data->event_rb, events, sizeof(data->event_buf));
+	events_cnt = (uint8_t)ring_buffer_read(&data->event_rb, events, sizeof(data->event_buf));
 
 	k_mutex_unlock(&data->event_rb_lock);
 
@@ -736,7 +736,7 @@ static void modem_cellular_delegate_event(struct modem_cellular_data *data,
 					  enum modem_cellular_event evt)
 {
 	k_mutex_lock(&data->event_rb_lock, K_FOREVER);
-	ring_buf_put(&data->event_rb, (uint8_t *)&evt, 1);
+	ring_buffer_write(&data->event_rb, (uint8_t *)&evt, 1);
 	k_mutex_unlock(&data->event_rb_lock);
 	k_work_submit(&data->event_dispatch_work);
 }
@@ -2192,7 +2192,7 @@ static int modem_cellular_init(const struct device *dev)
 	k_work_init_delayable(&data->timeout_work, modem_cellular_timeout_handler);
 
 	k_work_init(&data->event_dispatch_work, modem_cellular_event_dispatch_handler);
-	ring_buf_init(&data->event_rb, sizeof(data->event_buf), data->event_buf);
+	ring_buffer_init(&data->event_rb, data->event_buf, sizeof(data->event_buf));
 
 	k_sem_init(&data->suspended_sem, 0, 1);
 
diff --git a/drivers/modem/modem_iface_uart.h b/drivers/modem/modem_iface_uart.h
@@ -24,7 +24,7 @@ struct modem_iface_uart_data {
 	bool hw_flow_control;
 
 	/* ring buffer */
-	struct ring_buf rx_rb;
+	struct ring_buffer rx_rb;
 
 	/* rx semaphore */
 	struct k_sem rx_sem;
diff --git a/drivers/modem/modem_iface_uart_async.c b/drivers/modem/modem_iface_uart_async.c
@@ -52,7 +52,7 @@ static void iface_uart_async_callback(const struct device *dev,
 		break;
 	case UART_RX_RDY:
 		/* Place received data on the ring buffer */
-		written = ring_buf_put(&data->rx_rb,
+		written = ring_buffer_write(&data->rx_rb,
 				       evt->data.rx.buf + evt->data.rx.offset,
 				       evt->data.rx.len);
 		if (written != evt->data.rx.len) {
@@ -97,7 +97,7 @@ static int modem_iface_uart_async_read(struct modem_iface *iface,
 
 	/* Pull data off the ring buffer */
 	data = iface->iface_data;
-	*bytes_read = ring_buf_get(&data->rx_rb, buf, size);
+	*bytes_read = ring_buffer_read(&data->rx_rb, buf, size);
 	return 0;
 }
 
@@ -176,7 +176,7 @@ int modem_iface_uart_init(struct modem_iface *iface, struct modem_iface_uart_dat
 	iface->read = modem_iface_uart_async_read;
 	iface->write = modem_iface_uart_async_write;
 
-	ring_buf_init(&data->rx_rb, config->rx_rb_buf_len, config->rx_rb_buf);
+	ring_buffer_init(&data->rx_rb, config->rx_rb_buf_len, config->rx_rb_buf);
 	k_sem_init(&data->rx_sem, 0, 1);
 	k_sem_init(&data->tx_sem, 0, 1);
 
diff --git a/drivers/modem/modem_iface_uart_interrupt.c b/drivers/modem/modem_iface_uart_interrupt.c
@@ -52,7 +52,7 @@ static void modem_iface_uart_isr(const struct device *uart_dev,
 {
 	struct modem_context *ctx;
 	struct modem_iface_uart_data *data;
-	int rx = 0, ret;
+	int rx = 0;
 	uint8_t *dst;
 	uint32_t partial_size = 0;
 	uint32_t total_size = 0;
@@ -70,8 +70,7 @@ static void modem_iface_uart_isr(const struct device *uart_dev,
 	while (uart_irq_update(ctx->iface.dev) &&
 	       uart_irq_rx_ready(ctx->iface.dev)) {
 		if (!partial_size) {
-			partial_size = ring_buf_put_claim(&data->rx_rb, &dst,
-							  UINT32_MAX);
+			partial_size = ring_buffer_write_ptr(&data->rx_rb, &dst);
 		}
 		if (!partial_size) {
 			if (data->hw_flow_control) {
@@ -93,8 +92,7 @@ static void modem_iface_uart_isr(const struct device *uart_dev,
 		partial_size -= rx;
 	}
 
-	ret = ring_buf_put_finish(&data->rx_rb, total_size);
-	__ASSERT_NO_MSG(ret == 0);
+	ring_buffer_commit(&data->rx_rb, total_size);
 
 	if (total_size > 0) {
 		k_sem_give(&data->rx_sem);
@@ -116,7 +114,7 @@ static int modem_iface_uart_read(struct modem_iface *iface,
 	}
 
 	data = (struct modem_iface_uart_data *)(iface->iface_data);
-	*bytes_read = ring_buf_get(&data->rx_rb, buf, size);
+	*bytes_read = ring_buffer_read(&data->rx_rb, buf, size);
 
 	if (data->hw_flow_control && *bytes_read == 0) {
 		uart_irq_rx_enable(iface->dev);
@@ -190,7 +188,7 @@ int modem_iface_uart_init(struct modem_iface *iface, struct modem_iface_uart_dat
 	iface->read = modem_iface_uart_read;
 	iface->write = modem_iface_uart_write;
 
-	ring_buf_init(&data->rx_rb, config->rx_rb_buf_len, config->rx_rb_buf);
+	ring_buffer_init(&data->rx_rb, config->rx_rb_buf, config->rx_rb_buf_len);
 	k_sem_init(&data->rx_sem, 0, 1);
 
 	/* Configure hardware flow control */
diff --git a/drivers/modem/modem_receiver.c b/drivers/modem/modem_receiver.c
@@ -121,7 +121,7 @@ static void mdm_receiver_isr(const struct device *uart_dev, void *user_data)
 	       uart_irq_rx_ready(ctx->uart_dev)) {
 		rx = uart_fifo_read(ctx->uart_dev, read_buf, sizeof(read_buf));
 		if (rx > 0) {
-			ret = ring_buf_put(&ctx->rx_rb, read_buf, rx);
+			ret = ring_buffer_write(&ctx->rx_rb, read_buf, rx);
 			if (ret != rx) {
 				LOG_ERR("Rx buffer doesn't have enough space. "
 						"Bytes pending: %d, written: %d",
@@ -174,7 +174,7 @@ int mdm_receiver_recv(struct mdm_receiver_context *ctx,
 		return 0;
 	}
 
-	*bytes_read = ring_buf_get(&ctx->rx_rb, buf, size);
+	*bytes_read = ring_buffer_read(&ctx->rx_rb, buf, size);
 	return 0;
 }
 
@@ -232,7 +232,7 @@ int mdm_receiver_register(struct mdm_receiver_context *ctx,
 	}
 
 	ctx->uart_dev = uart_dev;
-	ring_buf_init(&ctx->rx_rb, size, buf);
+	ring_buffer_init(&ctx->rx_rb, buf, size);
 	k_sem_init(&ctx->rx_sem, 0, 1);
 
 	ret = mdm_receiver_get(ctx);
diff --git a/drivers/modem/modem_receiver.h b/drivers/modem/modem_receiver.h
@@ -25,7 +25,7 @@ struct mdm_receiver_context {
 	const struct device *uart_dev;
 
 	/* rx data */
-	struct ring_buf rx_rb;
+	struct ring_buffer rx_rb;
 	struct k_sem rx_sem;
 
 	/* modem data */
diff --git a/include/zephyr/modem/backend/uart.h b/include/zephyr/modem/backend/uart.h
@@ -22,8 +22,8 @@ extern "C" {
 #endif
 
 struct modem_backend_uart_isr {
-	struct ring_buf receive_rdb[2];
-	struct ring_buf transmit_rb;
+	struct ring_buffer receive_rdb[2];
+	struct ring_buffer transmit_rb;
 	atomic_t transmit_buf_len;
 	atomic_t receive_buf_len;
 	uint8_t receive_rdb_used;
@@ -60,7 +60,7 @@ struct modem_backend_uart_async {
 	struct modem_backend_uart_async_common common;
 	uint8_t *receive_bufs[2];
 	uint32_t receive_buf_size;
-	struct ring_buf receive_rb;
+	struct ring_buffer receive_rb;
 	struct k_spinlock receive_rb_lock;
 };
 
diff --git a/include/zephyr/modem/cmux.h b/include/zephyr/modem/cmux.h
@@ -106,7 +106,7 @@ struct modem_cmux_dlci {
 	struct modem_cmux *cmux;
 
 	/* Receive buffer */
-	struct ring_buf receive_rb;
+	struct ring_buffer receive_rb;
 	struct k_mutex receive_rb_lock;
 
 	/* Work */
@@ -167,7 +167,7 @@ struct modem_cmux {
 	uint8_t work_buf[MODEM_CMUX_WORK_BUFFER_SIZE];
 
 	/* Transmit buffer */
-	struct ring_buf transmit_rb;
+	struct ring_buffer transmit_rb;
 	struct k_mutex transmit_rb_lock;
 
 	/* Received frame */
diff --git a/include/zephyr/modem/ppp.h b/include/zephyr/modem/ppp.h
@@ -105,7 +105,7 @@ struct modem_ppp {
 	uint16_t tx_pkt_fcs;
 
 	/* Ring buffer used for transmitting partial PPP frame */
-	struct ring_buf transmit_rb;
+	struct ring_buffer transmit_rb;
 
 	struct k_fifo tx_pkt_fifo;
 
diff --git a/subsys/modem/Kconfig b/subsys/modem/Kconfig
@@ -23,7 +23,6 @@ endif # MODEM_DEDICATED_WORKQUEUE
 
 config MODEM_CHAT
 	bool "Modem chat module"
-	select RING_BUFFER
 	select MODEM_PIPE
 
 if MODEM_CHAT
@@ -37,7 +36,6 @@ endif
 config MODEM_CMUX
 	bool "Modem CMUX module"
 	select MODEM_PIPE
-	select RING_BUFFER
 	select EVENTS
 	select CRC
 
@@ -88,7 +86,6 @@ config MODEM_PPP
 	bool "Modem PPP module"
 	depends on NET_L2_PPP
 	select MODEM_PIPE
-	select RING_BUFFER
 	select CRC
 	select PM_DEVICE_RUNTIME_ASYNC if PM_DEVICE_RUNTIME
 
@@ -116,7 +113,6 @@ config MODEM_STATS_BUFFER_NAME_SIZE
 
 config MODEM_UBX
 	bool "Modem U-BLOX module"
-	select RING_BUFFER
 	select MODEM_PIPE
 	help
 	  Enable Modem U-BLOX module.
diff --git a/subsys/modem/backends/Kconfig b/subsys/modem/backends/Kconfig
@@ -9,7 +9,6 @@ config MODEM_BACKEND_TTY
 config MODEM_BACKEND_UART
 	bool "Modem UART backend module"
 	select MODEM_PIPE
-	select RING_BUFFER
 	depends on UART_INTERRUPT_DRIVEN || UART_ASYNC_API
 
 if MODEM_BACKEND_UART
diff --git a/subsys/modem/backends/modem_backend_uart_async.c b/subsys/modem/backends/modem_backend_uart_async.c
@@ -45,7 +45,7 @@ static bool modem_backend_uart_async_is_open(struct modem_backend_uart *backend)
 
 static uint32_t get_receive_buf_length(struct modem_backend_uart *backend)
 {
-	return ring_buf_size_get(&backend->async.receive_rb);
+	return ring_buffer_size(&backend->async.receive_rb);
 }
 
 static void modem_backend_uart_async_event_handler(const struct device *dev,
@@ -112,14 +112,14 @@ static void modem_backend_uart_async_event_handler(const struct device *dev,
 
 	case UART_RX_RDY:
 		key = k_spin_lock(&backend->async.receive_rb_lock);
-		received = ring_buf_put(&backend->async.receive_rb,
+		received = ring_buffer_write(&backend->async.receive_rb,
 					&evt->data.rx.buf[evt->data.rx.offset],
 					evt->data.rx.len);
 
 		if (received < evt->data.rx.len) {
 			const unsigned int buf_size = get_receive_buf_length(backend);
 
-			ring_buf_reset(&backend->async.receive_rb);
+			ring_buffer_reset(&backend->async.receive_rb);
 			k_spin_unlock(&backend->async.receive_rb_lock, key);
 
 			LOG_WRN("Receive buffer overrun (dropped %u + %u)",
@@ -155,7 +155,7 @@ static int modem_backend_uart_async_open(void *data)
 	int ret;
 
 	atomic_clear(&backend->async.common.state);
-	ring_buf_reset(&backend->async.receive_rb);
+	ring_buffer_reset(&backend->async.receive_rb);
 
 	atomic_set_bit(&backend->async.common.state,
 		       MODEM_BACKEND_UART_ASYNC_STATE_RX_BUF0_USED_BIT);
@@ -180,7 +180,7 @@ static int modem_backend_uart_async_open(void *data)
 #if CONFIG_MODEM_STATS
 static uint32_t get_receive_buf_size(struct modem_backend_uart *backend)
 {
-	return ring_buf_capacity_get(&backend->async.receive_rb);
+	return ring_buffer_capacity(&backend->async.receive_rb);
 }
 
 static void advertise_transmit_buf_stats(struct modem_backend_uart *backend, uint32_t length)
@@ -250,8 +250,8 @@ static int modem_backend_uart_async_receive(void *data, uint8_t *buf, size_t siz
 	advertise_receive_buf_stats(backend);
 #endif
 
-	received = ring_buf_get(&backend->async.receive_rb, buf, size);
-	empty = ring_buf_is_empty(&backend->async.receive_rb);
+	received = ring_buffer_read(&backend->async.receive_rb, buf, size);
+	empty = ring_buffer_empty(&backend->async.receive_rb);
 	k_spin_unlock(&backend->async.receive_rb_lock, key);
 
 	if (!empty) {
@@ -326,8 +326,9 @@ int modem_backend_uart_async_init(struct modem_backend_uart *backend,
 	backend->async.receive_bufs[1] = &config->receive_buf[receive_buf_size_quarter];
 
 	/* Use half the receive buffer for the received data ring buffer */
-	ring_buf_init(&backend->async.receive_rb, (receive_buf_size_quarter * 2),
-		      &config->receive_buf[receive_buf_size_quarter * 2]);
+	ring_buffer_init(&backend->async.receive_rb,
+			&config->receive_buf[receive_buf_size_quarter * 2],
+			(receive_buf_size_quarter * 2));
 
 	backend->async.common.transmit_buf = config->transmit_buf;
 	backend->async.common.transmit_buf_size = config->transmit_buf_size;
diff --git a/subsys/modem/backends/modem_backend_uart_isr.c b/subsys/modem/backends/modem_backend_uart_isr.c
diff --git a/subsys/modem/modem_cmux.c b/subsys/modem/modem_cmux.c
diff --git a/subsys/modem/modem_ppp.c b/subsys/modem/modem_ppp.c
diff --git a/tests/subsys/modem/backends/uart/src/main.c b/tests/subsys/modem/backends/uart/src/main.c
diff --git a/tests/subsys/modem/mock/modem_backend_mock.c b/tests/subsys/modem/mock/modem_backend_mock.c
diff --git a/tests/subsys/modem/mock/modem_backend_mock.h b/tests/subsys/modem/mock/modem_backend_mock.h
