subsys/*: update to new ring_buffer api

Update various subsystems to use the new ring_buffer API.

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

Author: Mattemagikern

subsys/bluetooth/audio/shell/bap_usb.c

@@ -95,7 +95,7 @@ struct decoded_sdu {
 	uint32_t ts;
 } decoded_sdu;
 
-RING_BUF_DECLARE(usb_in_ring_buf, USB_IN_RING_BUF_SIZE);
+RING_BUFFER_DECLARE(usb_in_ring_buf, USB_IN_RING_BUF_SIZE);
 K_MEM_SLAB_DEFINE_STATIC(usb_in_buf_pool, ROUND_UP(USB_STEREO_FRAME_SIZE, UDC_BUF_GRANULARITY),
 			 USB_ENQUEUE_COUNT, UDC_BUF_ALIGN);
 
@@ -118,7 +118,7 @@ static void usb_data_request(const struct device *dev)
 	}
 
 	/* This may fail without causing issues since usb_audio_data is 0-initialized */
-	size = ring_buf_get(&usb_in_ring_buf, pcm_buf, USB_STEREO_FRAME_SIZE);
+	size = ring_buffer_read(&usb_in_ring_buf, pcm_buf, USB_STEREO_FRAME_SIZE);
 	if (size != USB_STEREO_FRAME_SIZE) {
 		/* If we could not fill the buffer, zero-fill the rest (possibly all) */
 		memset(((uint8_t *)pcm_buf) + size, 0, USB_STEREO_FRAME_SIZE - size);
@@ -181,7 +181,7 @@ static void bap_usb_send_frames_to_usb(void)
 		uint32_t rb_size;
 
 		/* Not enough space to store data */
-		if (ring_buf_space_get(&usb_in_ring_buf) < sizeof(stereo_frame)) {
+		if (ring_buffer_space(&usb_in_ring_buf) < sizeof(stereo_frame)) {
 			if ((fail_cnt % bap_get_stats_interval()) == 0U) {
 				LOG_WRN("[%zu] Could not send more than %zu frames to USB",
 					fail_cnt, i);
@@ -219,7 +219,7 @@ static void bap_usb_send_frames_to_usb(void)
 			}
 		}
 
-		rb_size = ring_buf_put(&usb_in_ring_buf, (uint8_t *)stereo_frame,
+		rb_size = ring_buffer_write(&usb_in_ring_buf, (uint8_t *)stereo_frame,
 				       sizeof(stereo_frame));
 		if (rb_size != sizeof(stereo_frame)) {
 			LOG_WRN("Failed to put frame on USB ring buf");

subsys/gnss/rtk/serial/serial.c

@@ -18,13 +18,13 @@
 LOG_MODULE_REGISTER(rtk_serial, CONFIG_GNSS_RTK_LOG_LEVEL);
 
 static const struct device *rtk_serial_dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_rtk_serial));
-static struct ring_buf process_ringbuf;
+static struct ring_buffer process_ringbuf;
 static uint8_t process_buf[2048];
 
 static void gnss_rtk_process_work_handler(struct k_work *work)
 {
 	static uint8_t work_buf[2048];
-	uint32_t len = ring_buf_get(&process_ringbuf, work_buf, sizeof(work_buf));
+	uint32_t len = ring_buffer_read(&process_ringbuf, work_buf, sizeof(work_buf));
 	uint32_t offset = 0;
 
 	ARG_UNUSED(work);
@@ -70,7 +70,7 @@ static void rtk_uart_isr_callback(const struct device *dev, void *user_data)
 
 			ret = uart_fifo_read(dev, &c, 1);
 			if (ret > 0) {
-				ret = ring_buf_put(&process_ringbuf, &c, 1);
+				ret = ring_buffer_write(&process_ringbuf, &c, 1);
 			}
 		} while (ret > 0);
 
@@ -86,7 +86,7 @@ static int rtk_serial_client_init(void)
 {
 	int err;
 
-	ring_buf_init(&process_ringbuf, ARRAY_SIZE(process_buf), process_buf);
+	ring_buffer_init(&process_ringbuf, process_buf, ARRAY_SIZE(process_buf));
 
 	err = uart_irq_callback_user_data_set(rtk_serial_dev, rtk_uart_isr_callback, NULL);
 	if (err < 0) {

subsys/mgmt/osdp/Kconfig

@@ -6,7 +6,6 @@
 
 menuconfig OSDP
 	bool "Open Supervised Device Protocol (OSDP) driver"
-	select RING_BUFFER
 	imply SERIAL_SUPPORT_INTERRUPT
 	imply UART_INTERRUPT_DRIVEN
 	imply UART_USE_RUNTIME_CONFIGURE

subsys/mgmt/osdp/src/osdp.c

@@ -26,8 +26,8 @@ LOG_MODULE_REGISTER(osdp, CONFIG_OSDP_LOG_LEVEL);
 #endif	/* CONFIG_OSDP_SC_ENABLED */
 
 struct osdp_device {
-	struct ring_buf rx_buf;
-	struct ring_buf tx_buf;
+	struct ring_buffer rx_buf;
+	struct ring_buffer tx_buf;
 #ifdef CONFIG_OSDP_MODE_PD
 	int rx_event_data;
 	struct k_fifo rx_event_fifo;
@@ -52,15 +52,15 @@ static void osdp_handle_in_byte(struct osdp_device *p, uint8_t *buf, int len)
 		/* Check for new packet beginning with [FF,53,...] sequence */
 		if (p->last_byte == 0xFF && buf[0] == 0x53) {
 			buf[0] = 0xFF;
-			ring_buf_put(&p->rx_buf, buf, 1);   /* put last byte */
+			ring_buffer_write(&p->rx_buf, buf, 1);   /* put last byte */
 			buf[0] = 0x53;
-			ring_buf_put(&p->rx_buf, buf, len); /* put rest */
+			ring_buffer_write(&p->rx_buf, buf, len); /* put rest */
 			p->wait_for_mark = 0; /* Mark found. Clear flag */
 		}
 		p->last_byte = buf[0];
 		return;
 	}
-	ring_buf_put(&p->rx_buf, buf, len);
+	ring_buffer_write(&p->rx_buf, buf, len);
 }
 
 static void osdp_uart_isr(const struct device *dev, void *user_data)
@@ -79,7 +79,7 @@ static void osdp_uart_isr(const struct device *dev, void *user_data)
 		}
 
 		if (uart_irq_tx_ready(dev)) {
-			len = ring_buf_get(&p->tx_buf, buf, 1);
+			len = ring_buffer_read(&p->tx_buf, buf, 1);
 			if (!len) {
 				uart_irq_tx_disable(dev);
 			} else {
@@ -99,15 +99,15 @@ static int osdp_uart_receive(void *data, uint8_t *buf, int len)
 {
 	struct osdp_device *p = data;
 
-	return (int)ring_buf_get(&p->rx_buf, buf, len);
+	return (int)ring_buffer_read(&p->rx_buf, buf, len);
 }
 
 static int osdp_uart_send(void *data, uint8_t *buf, int len)
 {
 	int sent = 0;
 	struct osdp_device *p = data;
 
-	sent = (int)ring_buf_put(&p->tx_buf, buf, len);
+	sent = (int)ring_buffer_write(&p->tx_buf, buf, len);
 	uart_irq_tx_enable(p->dev);
 	return sent;
 }
@@ -117,8 +117,8 @@ static void osdp_uart_flush(void *data)
 	struct osdp_device *p = data;
 
 	p->wait_for_mark = 1;
-	ring_buf_reset(&p->tx_buf);
-	ring_buf_reset(&p->rx_buf);
+	ring_buffer_reset(&p->tx_buf);
+	ring_buffer_reset(&p->rx_buf);
 }
 
 struct osdp *osdp_get_ctx()
@@ -193,8 +193,8 @@ static int osdp_init(void)
 	k_fifo_init(&p->rx_event_fifo);
 #endif
 
-	ring_buf_init(&p->rx_buf, sizeof(p->rx_fbuf), p->rx_fbuf);
-	ring_buf_init(&p->tx_buf, sizeof(p->tx_fbuf), p->tx_fbuf);
+	ring_buffer_init(&p->rx_buf, p->rx_fbuf, sizeof(p->rx_fbuf));
+	ring_buffer_init(&p->tx_buf, p->tx_fbuf, sizeof(p->tx_fbuf));
 
 	/* init OSDP uart device */
 	p->dev = DEVICE_DT_GET(DT_CHOSEN(zephyr_osdp_uart));

subsys/testsuite/Kconfig

@@ -210,7 +210,6 @@ config TEST_BUSY_SIM
 	bool "Busy simulator"
 	depends on TEST
 	select ENTROPY_GENERATOR
-	select RING_BUFFER if !XOSHIRO_RANDOM_GENERATOR
 	select COUNTER
 	help
 	  It simulates cpu load by using counter device to generate interrupts

subsys/testsuite/busy_sim/busy_sim.c

@@ -84,7 +84,7 @@ static uint32_t get_timeout(bool idle, bool use_rand)
 	if (use_rand) {
 		sys_rand_get(&rand_val, sizeof(rand_val));
 	} else {
-		len = ring_buf_get(&rnd_rbuf,
+		len = ring_buffer_read(&rnd_rbuf,
 				   (uint8_t *)&rand_val,
 				   sizeof(rand_val));
 		if (len < sizeof(rand_val)) {
@@ -198,7 +198,7 @@ static int busy_sim_init(const struct device *dev)
 
 	if (config->entropy) {
 		k_work_init(&sim_work, rng_pool_work_handler);
-		ring_buf_init(&rnd_rbuf, BUFFER_SIZE, rnd_buf);
+		ring_buffer_init(&rnd_rbuf, rnd_buf, BUFFER_SIZE);
 	}
 
 	data->us_tick = freq / 1000000;

subsys/tracing/Kconfig

@@ -80,14 +80,12 @@ choice TRACING_METHOD_CHOICE
 
 config TRACING_SYNC
 	bool "Synchronous Tracing"
-	select RING_BUFFER
 	help
 	  Enable synchronous tracing. This requires the backend to be
 	  very low-latency.
 
 config TRACING_ASYNC
 	bool "Asynchronous Tracing"
-	select RING_BUFFER
 	help
 	  Enable asynchronous tracing. This will buffer all the tracing
 	  packets to the ring buffer first, tracing thread will try to

subsys/tracing/tracing_buffer.c

@@ -3,10 +3,10 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
-
+#include <zephyr/sys/util.h>
 #include <zephyr/sys/ring_buffer.h>
 
-static struct ring_buf tracing_ring_buf;
+static struct ring_buffer tracing_ring_buf;
 static uint8_t tracing_buffer[CONFIG_TRACING_BUFFER_SIZE + 1];
 static uint8_t tracing_cmd_buffer[CONFIG_TRACING_CMD_BUFFER_SIZE];
 
@@ -19,51 +19,52 @@ uint32_t tracing_cmd_buffer_alloc(uint8_t **data)
 
 uint32_t tracing_buffer_put_claim(uint8_t **data, uint32_t size)
 {
-	return ring_buf_put_claim(&tracing_ring_buf, data, size);
+	return MIN(ring_buffer_write_ptr(&tracing_ring_buf, data), size);
 }
 
 int tracing_buffer_put_finish(uint32_t size)
 {
-	return ring_buf_put_finish(&tracing_ring_buf, size);
+	ring_buffer_commit(&tracing_ring_buf, size);
+	return 0;
 }
 
 uint32_t tracing_buffer_put(uint8_t *data, uint32_t size)
 {
-	return ring_buf_put(&tracing_ring_buf, data, size);
+	return ring_buffer_write(&tracing_ring_buf, data, size);
 }
 
 uint32_t tracing_buffer_get_claim(uint8_t **data, uint32_t size)
 {
-	return ring_buf_get_claim(&tracing_ring_buf, data, size);
+	return MIN(ring_buffer_read_ptr(&tracing_ring_buf, data), size);
 }
 
 int tracing_buffer_get_finish(uint32_t size)
 {
-	return ring_buf_get_finish(&tracing_ring_buf, size);
+	ring_buffer_consume(&tracing_ring_buf, size);
+	return 0;
 }
 
 uint32_t tracing_buffer_get(uint8_t *data, uint32_t size)
 {
-	return ring_buf_get(&tracing_ring_buf, data, size);
+	return ring_buffer_read(&tracing_ring_buf, data, size);
 }
 
 void tracing_buffer_init(void)
 {
-	ring_buf_init(&tracing_ring_buf,
-		      sizeof(tracing_buffer), tracing_buffer);
+	ring_buffer_init(&tracing_ring_buf, tracing_buffer, sizeof(tracing_buffer));
 }
 
 bool tracing_buffer_is_empty(void)
 {
-	return ring_buf_is_empty(&tracing_ring_buf);
+	return ring_buffer_empty(&tracing_ring_buf);
 }
 
 uint32_t tracing_buffer_capacity_get(void)
 {
-	return ring_buf_capacity_get(&tracing_ring_buf);
+	return ring_buffer_capacity(&tracing_ring_buf);
 }
 
 uint32_t tracing_buffer_space_get(void)
 {
-	return ring_buf_space_get(&tracing_ring_buf);
+	return ring_buffer_space(&tracing_ring_buf);
 }