[nrf fromlist] drivers: nordic: Adapt drivers to changes in DMM API

dmm_buffer_out_release and dmm_buffer_in_release now have one additional
argument which is the allocated length. Length need to be know to
correctly free the buffer as internal heap allocator cannot determine
the size of the buffer just based on the address of the buffer.
Allocated length may be different then valid data length in the buffer
thus dmm_buffer_in_release requires additional argument, too.

Upstream PR #: 95306

Signed-off-by: Krzysztof Chruściński <[email protected]>

Author: nordic-krch

drivers/adc/adc_nrfx_saadc.c

@@ -611,6 +611,7 @@ static int start_read(const struct device *dev,
 	uint8_t active_channel_cnt = 0U;
 	uint8_t channel_id = 0U;
 	void *samples_buffer;
+	size_t samples;
 
 	/* Signal an error if channel selection is invalid (no channels or
 	 * a non-existing one is selected).
@@ -681,12 +682,11 @@ static int start_read(const struct device *dev,
 
 	m_data.active_channel_cnt = active_channel_cnt;
 	m_data.user_buffer = sequence->buffer;
+	samples = m_data.internal_timer_enabled ?
+			 (1 + sequence->options->extra_samplings) : active_channel_cnt;
 
 	error = dmm_buffer_in_prepare(
-		m_data.mem_reg, m_data.user_buffer,
-		(m_data.internal_timer_enabled
-			 ? NRFX_SAADC_SAMPLES_TO_BYTES(1 + sequence->options->extra_samplings)
-			 : NRFX_SAADC_SAMPLES_TO_BYTES(active_channel_cnt)),
+		m_data.mem_reg, m_data.user_buffer, NRFX_SAADC_SAMPLES_TO_BYTES(samples),
 		&samples_buffer);
 	if (error != 0) {
 		LOG_ERR("DMM buffer allocation failed err=%d", error);
@@ -696,11 +696,7 @@ static int start_read(const struct device *dev,
 	/* Buffer is filled in chunks, each chunk composed of number of samples equal to number
 	 * of active channels. Buffer pointer is advanced and reloaded after each chunk.
 	 */
-	nrfx_err = nrfx_saadc_buffer_set(
-		samples_buffer,
-		(m_data.internal_timer_enabled
-			 ? (1 + sequence->options->extra_samplings)
-			 : active_channel_cnt));
+	nrfx_err = nrfx_saadc_buffer_set(samples_buffer, samples);
 	if (nrfx_err != NRFX_SUCCESS) {
 		LOG_ERR("Failed to set buffer: 0x%08x", nrfx_err);
 		return -EINVAL;
@@ -745,13 +741,13 @@ static void event_handler(const nrfx_saadc_evt_t *event)
 	nrfx_err_t err;
 
 	if (event->type == NRFX_SAADC_EVT_DONE) {
-		dmm_buffer_in_release(
-			m_data.mem_reg, m_data.user_buffer,
-			(m_data.internal_timer_enabled
+		size_t len = m_data.internal_timer_enabled
 				 ? NRFX_SAADC_SAMPLES_TO_BYTES(
 					   1 + m_data.ctx.sequence.options->extra_samplings)
-				 : NRFX_SAADC_SAMPLES_TO_BYTES(m_data.active_channel_cnt)),
-			event->data.done.p_buffer);
+				 : NRFX_SAADC_SAMPLES_TO_BYTES(m_data.active_channel_cnt);
+
+		dmm_buffer_in_release(
+			m_data.mem_reg, m_data.user_buffer, len, event->data.done.p_buffer, len);
 
 		if (has_single_ended(&m_data.ctx.sequence)) {
 			correct_single_ended(&m_data.ctx.sequence, m_data.user_buffer,

drivers/audio/dmic_nrfx_pdm.c

@@ -145,7 +145,8 @@ static void event_handler(const struct device *dev, const nrfx_pdm_evt_t *evt)
 				return;
 			}
 			ret = dmm_buffer_in_release(drv_cfg->mem_reg, mem_slab_buffer,
-						    drv_data->block_size, evt->buffer_released);
+						    drv_data->block_size, evt->buffer_released,
+						    drv_data->block_size);
 			if (ret < 0) {
 				LOG_ERR("Failed to release buffer: %d", ret);
 				return;
@@ -169,7 +170,8 @@ static void event_handler(const struct device *dev, const nrfx_pdm_evt_t *evt)
 			return;
 		}
 		ret = dmm_buffer_in_release(drv_cfg->mem_reg, mem_slab_buffer,
-					    drv_data->block_size, evt->buffer_released);
+					    drv_data->block_size, evt->buffer_released,
+					    drv_data->block_size);
 		if (ret < 0) {
 			LOG_ERR("Failed to release buffer: %d", ret);
 			stop_pdm(drv_data);

drivers/i2s/i2s_nrf_tdm.c

@@ -301,7 +301,7 @@ static void free_tx_buffer(struct tdm_drv_data *drv_data, struct tdm_buf *buf)
 {
 	const struct tdm_drv_cfg *drv_cfg = drv_data->drv_cfg;
 
-	(void)dmm_buffer_out_release(drv_cfg->mem_reg, buf->dmm_buf);
+	(void)dmm_buffer_out_release(drv_cfg->mem_reg, buf->dmm_buf, buf->size);
 	k_mem_slab_free(drv_data->tx.cfg.mem_slab, buf->mem_block);
 	LOG_DBG("Freed TX %p", buf->mem_block);
 }
@@ -310,7 +310,8 @@ static void free_rx_buffer(struct tdm_drv_data *drv_data, struct tdm_buf *buf)
 {
 	const struct tdm_drv_cfg *drv_cfg = drv_data->drv_cfg;
 
-	(void)dmm_buffer_in_release(drv_cfg->mem_reg, buf->mem_block, buf->size, buf->dmm_buf);
+	(void)dmm_buffer_in_release(drv_cfg->mem_reg, buf->mem_block, buf->size, buf->dmm_buf,
+				    buf->size);
 	k_mem_slab_free(drv_data->rx.cfg.mem_slab, buf->mem_block);
 	LOG_DBG("Freed RX %p", buf->mem_block);
 }
@@ -641,7 +642,8 @@ static int tdm_nrf_read(const struct device *dev, void **mem_block, size_t *size
 	LOG_DBG("Released RX %p", buf.mem_block);
 
 	if (ret == 0) {
-		(void)dmm_buffer_in_release(drv_cfg->mem_reg, buf.mem_block, buf.size, buf.dmm_buf);
+		(void)dmm_buffer_in_release(drv_cfg->mem_reg, buf.mem_block, buf.size, buf.dmm_buf,
+					    buf.size);
 		*mem_block = buf.mem_block;
 		*size = buf.size;
 	}

drivers/serial/uart_nrfx_uarte.c

@@ -2404,7 +2404,8 @@ static void endrx_isr(const struct device *dev)
 #ifdef CONFIG_HAS_NORDIC_DMM
 	const struct uarte_nrfx_config *config = dev->config;
 	int err =
-		dmm_buffer_in_release(config->mem_reg, async_rx->usr_buf, rx_amount, async_rx->buf);
+		dmm_buffer_in_release(config->mem_reg, async_rx->usr_buf, rx_amount,
+					async_rx->buf, async_rx->buf_len);
 
 	(void)err;
 	__ASSERT_NO_MSG(err == 0);
@@ -2554,7 +2555,8 @@ static void rxto_isr(const struct device *dev)
 
 	if (async_rx->buf) {
 #ifdef CONFIG_HAS_NORDIC_DMM
-		(void)dmm_buffer_in_release(config->mem_reg, async_rx->usr_buf, 0, async_rx->buf);
+		(void)dmm_buffer_in_release(config->mem_reg, async_rx->usr_buf, 0, async_rx->buf,
+					    async_rx->buf_len);
 		async_rx->buf = async_rx->usr_buf;
 #endif
 		rx_buf_release(dev, async_rx->buf);
@@ -2789,7 +2791,7 @@ static void uarte_nrfx_isr_async(const void *arg)
 		int ret;
 
 		ret = dmm_buffer_in_release(config->mem_reg, async_rx->usr_buf, async_rx->buf_len,
-					    async_rx->buf);
+					    async_rx->buf, async_rx->buf_len);
 
 		(void)ret;
 		__ASSERT_NO_MSG(ret == 0);

drivers/spi/spi_nrfx_spim.c

@@ -558,9 +558,10 @@ static void transfer_next_chunk(const struct device *dev)
 
 		/* On nrfx_spim_xfer() error */
 		dmm_buffer_in_release(dev_config->mem_reg, rx_buf, xfer.rx_length,
-				      (void **)&xfer.p_rx_buffer);
+				      (void **)&xfer.p_rx_buffer, xfer.rx_length);
 in_alloc_failed:
-		dmm_buffer_out_release(dev_config->mem_reg, (void **)&xfer.p_tx_buffer);
+		dmm_buffer_out_release(dev_config->mem_reg, (void **)&xfer.p_tx_buffer,
+					xfer.tx_length);
 	}
 
 out_alloc_failed:
@@ -588,12 +589,14 @@ static void event_handler(const nrfx_spim_evt_t *p_event, void *p_context)
 
 		if (spi_context_tx_buf_on(&dev_data->ctx)) {
 			dmm_buffer_out_release(dev_config->mem_reg,
-					       (void **)p_event->xfer_desc.p_tx_buffer);
+					       (void **)p_event->xfer_desc.p_tx_buffer,
+					       dev_data->chunk_len);
 		}
 
 		if (spi_context_rx_buf_on(&dev_data->ctx)) {
 			dmm_buffer_in_release(dev_config->mem_reg, dev_data->ctx.rx_buf,
-				dev_data->chunk_len, p_event->xfer_desc.p_rx_buffer);
+				dev_data->chunk_len, p_event->xfer_desc.p_rx_buffer,
+				dev_data->chunk_len);
 		}
 
 #ifdef SPI_BUFFER_IN_RAM

drivers/spi/spi_nrfx_spis.c

@@ -243,9 +243,9 @@ static int prepare_for_transfer(const struct device *dev,
 	return 0;
 
 buffers_set_failed:
-	dmm_buffer_in_release(dev_config->mem_reg, rx_buf, rx_buf_len, dmm_rx_buf);
+	dmm_buffer_in_release(dev_config->mem_reg, rx_buf, rx_buf_len, dmm_rx_buf, rx_buf_len);
 in_alloc_failed:
-	dmm_buffer_out_release(dev_config->mem_reg, (void *)dmm_tx_buf);
+	dmm_buffer_out_release(dev_config->mem_reg, (void *)dmm_tx_buf, tx_buf_len);
 out_alloc_failed:
 	return err;
 }
@@ -418,12 +418,13 @@ static void event_handler(const nrfx_spis_evt_t *p_event, void *p_context)
 		int err;
 
 
-		err = dmm_buffer_out_release(dev_config->mem_reg, p_event->p_tx_buf);
+		err = dmm_buffer_out_release(dev_config->mem_reg, p_event->p_tx_buf,
+					     p_event->tx_buf_size);
 		(void)err;
 		__ASSERT_NO_MSG(err == 0);
 
 		err = dmm_buffer_in_release(dev_config->mem_reg, dev_data->ctx.rx_buf,
-				      p_event->rx_amount, p_event->p_rx_buf);
+				      p_event->rx_amount, p_event->p_rx_buf, p_event->rx_buf_size);
 		__ASSERT_NO_MSG(err == 0);
 
 		spi_context_complete(&dev_data->ctx, dev_data->dev,