how to prevent sleep mode in ZEPHYR while UARTE DMA transaction is not completed

Question

Our project is built wit NRF Connect SDK 2.9.0. For the UART we use nrfx_uarte library directly. 
 RX works perfectly, but TX is working only in blocking mode. If I call `nrfx_uarte_tx()` with flags=0, which assumes that the entire buffer will be sent over DMA in one go, the packet gets corrupted. I think this is because zephyr is not aware that the sleep should not be that deep. 
 To circumvent entering the sleep mode I place a loop after the nrfx_uarte_tx() which runs until the ISR resets a flag indicating the TX completion 
 static void uart0_handler(nrfx_uarte_event_t const * p_event, void * p_context)
{
 nrfx_uarte_t * p_inst = p_context;
 static k_timeout_t idle_period = K_MSEC(IDLE_PERIOD);

switch (p_event->type)
 {
 case NRFX_UARTE_EVT_TX_DONE:
 LOG_INF("TX0 done");
 txRunning = false; // this is the flag indicating the completion
 break;
 
 // other event types
 ...
 }
}

bool uart0_tx_blocking(uint8_t *data, uint16_t size, uart0_tx_done_cb cb)
{
 nrfx_err_t err;
 err = nrfx_uarte_tx(&uart0_inst, data, size, 0);
 if (err == NRFX_SUCCESS) {
 // prevent sleep while DMA transfer is running
 txRunning = true;
 while (txRunning) {}
 return true;
 }
 
 return false;
}

So far it works like this, but as you can see it is blocking now. I can of course call it in a separate thread, but it's not nice to create a thread just for that. 
 Cleaner solution would be to somehow tell the Zephyr, that it should not sleep, it should use less restrictive power mode, so that DMA could finish the transaction. 
 I tried different pm_* functions, but without success. Obviously I'm missing something. 
 
 So the question is how to force a power mode that will allow DMA to finish?

Evgeny M · Accepted Answer

So, I think I found when it happens. 
 the uart0_tx_blocking() that I posted here was simplified a bit, because I wanted to post only essential stuff. 
 My real function is this: 
 bool uart0_tx(uint8_t *data, uint16_t size, uart0_tx_done_cb cb)
{
 txDoneCallback = cb;
 nrfx_err_t err;

// data must be in RAM for DMA
 if (nrf_dma_accessible_check(&uart0_inst, data)) {
 err = nrfx_uarte_tx(&uart0_inst, data, size, 0);
 } else {
 // allow max 32 string literals
 if (size > 32) {
 LOG_ERR("The size of string literal must not exceed 32 bytes");
 return false;
 }

uint8_t ram_data[32];
 memcpy(ram_data, data, size);

err = nrfx_uarte_tx(&uart0_inst, ram_data, size, 0);
 }
 
 if (err != NRFX_SUCCESS) {
 logReadableError("TX start error", err);
 return false;
 }

return true;
} 
 It also handles the case when string literal is used in the call, like `uart0_tx("12345678", 8, NULL)`. In this case it copies data to a buffer in RAM. 
 It turned out that the error occurs only when I call it with a string in double quotes. If I call it using a pointer to variable in RAM, receiver gets correct data. 
 I guess this might be compiler optimization magic. Or maybe I should put a memory barrier after memcpy. I don't know. 
 Anyway, the real application will use only a buffer in memory when calling this function, so it should not be a problem