subsys/shell: update to use new ring_buffer api

Move to new ring_buffer API.

Signed-off-by: Måns Ansgariusson <[email protected]>

Author: Mattemagikern

include/zephyr/shell/shell_mqtt.h

@@ -47,7 +47,7 @@ struct shell_mqtt {
 	/** Handler function registered by shell. */
 	shell_transport_handler_t shell_handler;
 
-	struct ring_buf rx_rb;
+	struct ring_buffer rx_rb;
 	uint8_t rx_rb_buf[RX_RB_SIZE];
 	uint8_t *rx_rb_ptr;
 

include/zephyr/shell/shell_uart.h

@@ -49,8 +49,8 @@ struct shell_uart_common {
 
 struct shell_uart_int_driven {
 	struct shell_uart_common common;
-	struct ring_buf tx_ringbuf;
-	struct ring_buf rx_ringbuf;
+	struct ring_buffer tx_ringbuf;
+	struct ring_buffer rx_ringbuf;
 	uint8_t tx_buf[CONFIG_SHELL_BACKEND_SERIAL_TX_RING_BUFFER_SIZE];
 	uint8_t rx_buf[CONFIG_SHELL_BACKEND_SERIAL_RX_RING_BUFFER_SIZE];
 	struct k_timer dtr_timer;
@@ -68,7 +68,7 @@ struct shell_uart_async {
 
 struct shell_uart_polling {
 	struct shell_uart_common common;
-	struct ring_buf rx_ringbuf;
+	struct ring_buffer rx_ringbuf;
 	uint8_t rx_buf[CONFIG_SHELL_BACKEND_SERIAL_RX_RING_BUFFER_SIZE];
 	struct k_timer rx_timer;
 };

subsys/shell/backends/Kconfig.backends

@@ -18,7 +18,6 @@ config SHELL_BACKEND_SERIAL
 	bool "Serial backend"
 	default "$(dt_chosen_enabled,$(DT_CHOSEN_Z_SHELL_UART))"
 	select SERIAL
-	select RING_BUFFER
 	help
 	  Enable serial backend.
 

subsys/shell/backends/shell_mqtt.c

@@ -573,20 +573,20 @@ static void mqtt_evt_handler(struct mqtt_client *const client, const struct mqtt
 
 		while (payload_left > 0) {
 			/* Attempt to claim `payload_left` bytes of buffer in rb */
-			size = (size_t)ring_buf_put_claim(&sh->rx_rb, &sh->rx_rb_ptr,
-							  payload_left);
+			size = (size_t)MIN(ring_buffer_write_ptr(&sh->rx_rb, &sh->rx_rb_ptr),
+					payload_left);
 			/* Read `size` bytes of payload from mqtt */
 			rc = mqtt_read_publish_payload_blocking(client, sh->rx_rb_ptr, size);
 
 			/* errno value, return */
 			if (rc < 0) {
-				ring_buf_reset(&sh->rx_rb);
+				ring_buffer_reset(&sh->rx_rb);
 				return;
 			}
 
 			size = (size_t)rc;
 			/* Indicate that `size` bytes of payload has been written into rb */
-			(void)ring_buf_put_finish(&sh->rx_rb, size);
+			ring_buffer_commit(&sh->rx_rb, size);
 			/* Update `payload_left` */
 			payload_left -= size;
 			/* Tells the shell that we have new data for it */
@@ -598,9 +598,9 @@ static void mqtt_evt_handler(struct mqtt_client *const client, const struct mqtt
 		/* Shell won't execute the cmds without \r\n */
 		while (true) {
 			/* Check if rb's free space is enough to fit in \r\n */
-			size = ring_buf_space_get(&sh->rx_rb);
+			size = ring_buffer_space(&sh->rx_rb);
 			if (size >= sizeof("\r\n")) {
-				(void)ring_buf_put(&sh->rx_rb, "\r\n", sizeof("\r\n"));
+				(void)ring_buffer_write(&sh->rx_rb, "\r\n", sizeof("\r\n"));
 				break;
 			}
 			/* Arbitrary sleep for the shell to do its thing */
@@ -652,7 +652,7 @@ static int init(const struct shell_transport *transport, const void *config,
 	(void)snprintf(sh->sub_topic, SH_MQTT_TOPIC_RX_MAX_SIZE, "%s" CONFIG_SHELL_MQTT_TOPIC_RX_ID,
 		       sh->device_id);
 
-	ring_buf_init(&sh->rx_rb, RX_RB_SIZE, sh->rx_rb_buf);
+	ring_buffer_init(&sh->rx_rb, sh->rx_rb_buf, RX_RB_SIZE);
 
 	LOG_DBG("Initializing shell MQTT backend");
 
@@ -795,10 +795,10 @@ static int read_data(const struct shell_transport *transport, void *data, size_t
 		return 0;
 	}
 
-	*cnt = ring_buf_get(&sh->rx_rb, data, length);
+	*cnt = ring_buffer_read(&sh->rx_rb, data, length);
 
 	/* Inform the shell if there are still data in the rb */
-	if (ring_buf_size_get(&sh->rx_rb) > 0) {
+	if (ring_buffer_size(&sh->rx_rb) > 0) {
 		sh->shell_handler(SHELL_TRANSPORT_EVT_RX_RDY, sh->shell_context);
 	}
 

subsys/shell/backends/shell_uart.c

@@ -78,9 +78,7 @@ static void uart_rx_handle(const struct device *dev, struct shell_uart_int_drive
 #endif
 
 	do {
-		len = ring_buf_put_claim(&sh_uart->rx_ringbuf, &data,
-					 sh_uart->rx_ringbuf.size);
-
+		len = ring_buffer_write_ptr(&sh_uart->rx_ringbuf, &data);
 		if (len > 0) {
 			rd_len = uart_fifo_read(dev, data, len);
 
@@ -105,9 +103,7 @@ static void uart_rx_handle(const struct device *dev, struct shell_uart_int_drive
 				}
 			}
 #endif /* CONFIG_MCUMGR_TRANSPORT_SHELL */
-			int err = ring_buf_put_finish(&sh_uart->rx_ringbuf, rd_len);
-			(void)err;
-			__ASSERT_NO_MSG(err == 0);
+			ring_buffer_commit(&sh_uart->rx_ringbuf, rd_len);
 		} else {
 			uint8_t dummy;
 
@@ -176,15 +172,10 @@ static void uart_tx_handle(const struct device *dev, struct shell_uart_int_drive
 		return;
 	}
 
-	len = ring_buf_get_claim(&sh_uart->tx_ringbuf, (uint8_t **)&data,
-				 sh_uart->tx_ringbuf.size);
+	len = ring_buffer_read_ptr(&sh_uart->tx_ringbuf, (uint8_t **)&data);
 	if (len) {
-		int err;
-
 		len = uart_fifo_fill(dev, data, len);
-		err = ring_buf_get_finish(&sh_uart->tx_ringbuf, len);
-		__ASSERT_NO_MSG(err == 0);
-		ARG_UNUSED(err);
+		ring_buffer_consume(&sh_uart->tx_ringbuf, len);
 	} else {
 		uart_irq_tx_disable(dev);
 		sh_uart->tx_busy = 0;
@@ -212,10 +203,10 @@ static void irq_init(struct shell_uart_int_driven *sh_uart)
 {
 	const struct device *dev = sh_uart->common.dev;
 
-	ring_buf_init(&sh_uart->rx_ringbuf, CONFIG_SHELL_BACKEND_SERIAL_RX_RING_BUFFER_SIZE,
-		      sh_uart->rx_buf);
-	ring_buf_init(&sh_uart->tx_ringbuf, CONFIG_SHELL_BACKEND_SERIAL_TX_RING_BUFFER_SIZE,
-		      sh_uart->tx_buf);
+	ring_buffer_init(&sh_uart->rx_ringbuf, sh_uart->rx_buf,
+			CONFIG_SHELL_BACKEND_SERIAL_RX_RING_BUFFER_SIZE);
+	ring_buffer_init(&sh_uart->tx_ringbuf, sh_uart->tx_buf,
+		      CONFIG_SHELL_BACKEND_SERIAL_TX_RING_BUFFER_SIZE);
 	sh_uart->tx_busy = 0;
 	uart_irq_callback_user_data_set(dev, uart_callback, (void *)sh_uart);
 	uart_irq_rx_enable(dev);
@@ -266,7 +257,7 @@ static void polling_rx_timeout_handler(struct k_timer *timer)
 	struct shell_uart_polling *sh_uart = k_timer_user_data_get(timer);
 
 	while (uart_poll_in(sh_uart->common.dev, &c) == 0) {
-		if (ring_buf_put(&sh_uart->rx_ringbuf, &c, 1) == 0U) {
+		if (ring_buffer_write(&sh_uart->rx_ringbuf, &c, 1) == 0U) {
 			/* ring buffer full. */
 			LOG_WRN("RX ring buffer full.");
 		}
@@ -280,8 +271,8 @@ static void polling_init(struct shell_uart_polling *sh_uart)
 	k_timer_user_data_set(&sh_uart->rx_timer, (void *)sh_uart);
 	k_timer_start(&sh_uart->rx_timer, RX_POLL_PERIOD, RX_POLL_PERIOD);
 
-	ring_buf_init(&sh_uart->rx_ringbuf, CONFIG_SHELL_BACKEND_SERIAL_RX_RING_BUFFER_SIZE,
-		      sh_uart->rx_buf);
+	ring_buffer_init(&sh_uart->rx_ringbuf, sh_uart->rx_buf,
+			CONFIG_SHELL_BACKEND_SERIAL_RX_RING_BUFFER_SIZE);
 }
 
 static int init(const struct shell_transport *transport,
@@ -375,7 +366,7 @@ static int polling_write(struct shell_uart_common *sh_uart,
 static int irq_write(struct shell_uart_int_driven *sh_uart,
 		 const void *data, size_t length, size_t *cnt)
 {
-	*cnt = ring_buf_put(&sh_uart->tx_ringbuf, data, length);
+	*cnt = ring_buffer_write(&sh_uart->tx_ringbuf, data, length);
 
 	if (atomic_set(&sh_uart->tx_busy, 1) == 0) {
 		uart_irq_tx_enable(sh_uart->common.dev);
@@ -420,15 +411,15 @@ static int write_uart(const struct shell_transport *transport,
 static int irq_read(struct shell_uart_int_driven *sh_uart,
 		    void *data, size_t length, size_t *cnt)
 {
-	*cnt = ring_buf_get(&sh_uart->rx_ringbuf, data, length);
+	*cnt = ring_buffer_read(&sh_uart->rx_ringbuf, data, length);
 
 	return 0;
 }
 
 static int polling_read(struct shell_uart_polling *sh_uart,
 			void *data, size_t length, size_t *cnt)
 {
-	*cnt = ring_buf_get(&sh_uart->rx_ringbuf, data, length);
+	*cnt = ring_buffer_read(&sh_uart->rx_ringbuf, data, length);
 
 	return 0;
 }