Skip to main content
Associate III
July 21, 2025
Question

STM32N6 DCMI DMA initialization

  • July 21, 2025
  • 3 replies
  • 435 views

Hello,

Because there is no active handle in DMA list for DCMI DMA initialization (bug!?) I searching for the ways to enable and use DMA, I can't find examples for parallel mode except for CSI serial, if I switch to use DCMIPP in parallel mode then the cubeMX do not generate msp initialization code function HAL_DCMIPP_MspInit for DCMIPP interface (no pinout, RCC, IRQ...), and in DMA list DCMI_PSSI handle stays inactive,

all my attempts to setup DCMI DMA do not work and DMA throws error 0x40, DCMI and camera working well, I getting hsync and vsync callbacks firing and counters show correct values, I tryed various settings but still cant start DMA transfer, there is my test and msp initialization code, please check:

 	uint32 err0 = HAL_DCMI_Start_DMA(&hdcmi, DCMI_MODE_CONTINUOUS, (uint32)frame_buff_DCMI, 320 * 240 / 2);
	uint32 err1 = HAL_DCMI_GetError(&hdcmi);
 	HAL_Delay(5000);
	uint32 err = HAL_DCMI_GetError(&hdcmi);
 	printf("DCMI %u %u, %u %u %u, %u %u\n", hdcmi.State, err, frNrCaptured, dcmiVsync, dcmiHsync, err0, err1);
 	HAL_DCMI_Stop(&hdcmi);
	err = HAL_DCMI_GetError(&hdcmi);
 	printf("DCMI %u %u, %u %u %u\n", hdcmi.State, err, frNrCaptured, dcmiVsync, dcmiHsync);
void HAL_DCMI_MspInit(DCMI_HandleTypeDef* hdcmi)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
 if(hdcmi->Instance==DCMI)
 {
 /* USER CODE BEGIN DCMI_MspInit 0 */
 /* USER CODE END DCMI_MspInit 0 */

 /** Initializes the peripherals clock
 */
 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_DCMIPP;
 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
 {
 Error_Handler();
 }
 /* Peripheral clock enable */
 __HAL_RCC_DCMI_PSSI_CLK_ENABLE();

 __HAL_RCC_GPIOF_CLK_ENABLE();
 __HAL_RCC_GPIOA_CLK_ENABLE();
 __HAL_RCC_GPIOG_CLK_ENABLE();
 __HAL_RCC_GPIOB_CLK_ENABLE();
 __HAL_RCC_GPION_CLK_ENABLE();
 /**DCMI GPIO Configuration
 PF1 ------> DCMI_D7
 PA1 ------> DCMI_D0
 PG3 ------> DCMI_HSYNC
 PG15 ------> DCMI_D4
 PA10 ------> DCMI_D1
 PG1 ------> DCMI_PIXCLK
 PG10 ------> DCMI_D2
 PG2 ------> DCMI_D6
 PB4(NJTRST) ------> DCMI_VSYNC
 PN9 ------> DCMI_D5
 PA4 ------> DCMI_D3
 */
 GPIO_InitStruct.Pin = GPIO_PIN_1;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF9_DCMI;
 HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

 GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_10|GPIO_PIN_4;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF9_DCMI;
 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

 GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_15|GPIO_PIN_1|GPIO_PIN_10
 |GPIO_PIN_2;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF9_DCMI;
 HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);

 GPIO_InitStruct.Pin = GPIO_PIN_4;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF9_DCMI;
 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

 GPIO_InitStruct.Pin = GPIO_PIN_9;
 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 GPIO_InitStruct.Alternate = GPIO_AF10_DCMI;
 HAL_GPIO_Init(GPION, &GPIO_InitStruct);

 /* DCMI interrupt Init */
 //HAL_NVIC_SetPriority(DCMI_PSSI_IRQn, 3, 0);
 //HAL_NVIC_EnableIRQ(DCMI_PSSI_IRQn);
 /* USER CODE BEGIN DCMI_MspInit 1 */

	DMA_NodeConfTypeDef NodeConfig = {0};
	NodeConfig.NodeType = DMA_GPDMA_LINEAR_NODE;
	NodeConfig.Init.Request = GPDMA1_REQUEST_DCMI_PSSI;
	NodeConfig.Init.BlkHWRequest = DMA_BREQ_SINGLE_BURST;
	NodeConfig.Init.Direction = DMA_PERIPH_TO_MEMORY;
	NodeConfig.Init.SrcInc = DMA_SINC_FIXED;
	NodeConfig.Init.DestInc = DMA_DINC_INCREMENTED;
	NodeConfig.Init.SrcDataWidth = DMA_SRC_DATAWIDTH_WORD;
	NodeConfig.Init.DestDataWidth = DMA_DEST_DATAWIDTH_WORD;
	NodeConfig.Init.SrcBurstLength = 1;
	NodeConfig.Init.DestBurstLength = 4;
	NodeConfig.Init.TransferAllocatedPort = DMA_SRC_ALLOCATED_PORT0 | DMA_DEST_ALLOCATED_PORT1;
	NodeConfig.Init.TransferEventMode = DMA_TCEM_LAST_LL_ITEM_TRANSFER;
	NodeConfig.Init.Mode = DMA_NORMAL;
	NodeConfig.TriggerConfig.TriggerPolarity = DMA_TRIG_POLARITY_MASKED;
	NodeConfig.DataHandlingConfig.DataExchange = DMA_EXCHANGE_NONE;
	NodeConfig.DataHandlingConfig.DataAlignment = DMA_DATA_RIGHTALIGN_ZEROPADDED;
	NodeConfig.SrcSecure = DMA_CHANNEL_SRC_SEC;
	NodeConfig.DestSecure = DMA_CHANNEL_DEST_SEC;

	NodeConfig.SrcAddress = (uint32_t)&DCMI->DR;
	NodeConfig.DstAddress = (uint32_t)frame_buff_DCMI;
	//NodeConfig.DataSize = 320 * 240 / 2; // in WORDs
	NodeConfig.TriggerConfig.TriggerPolarity = DMA_TRIG_POLARITY_RISING;
	if (HAL_DMAEx_List_BuildNode(&NodeConfig, &Node_GPDMA1_Channel6) != HAL_OK) {
		Error_Handler();
	}
	if (HAL_DMAEx_List_InsertNode(&List_GPDMA1_Channel6, NULL, &Node_GPDMA1_Channel6) != HAL_OK) {
		Error_Handler();
	}
	if (HAL_DMAEx_List_SetCircularMode(&List_GPDMA1_Channel6) != HAL_OK) {
		Error_Handler();
	}
	handle_GPDMA1_Channel6.Instance = GPDMA1_Channel6;
	handle_GPDMA1_Channel6.InitLinkedList.Priority = DMA_LOW_PRIORITY_MID_WEIGHT;
	handle_GPDMA1_Channel6.InitLinkedList.LinkStepMode = DMA_LSM_FULL_EXECUTION;
	handle_GPDMA1_Channel6.InitLinkedList.LinkAllocatedPort = DMA_LINK_ALLOCATED_PORT0;
	handle_GPDMA1_Channel6.InitLinkedList.TransferEventMode = DMA_TCEM_LAST_LL_ITEM_TRANSFER;
	handle_GPDMA1_Channel6.InitLinkedList.LinkedListMode = DMA_LINKEDLIST_CIRCULAR;
	if (HAL_DMAEx_List_Init(&handle_GPDMA1_Channel6) != HAL_OK) {
		Error_Handler();
	}
	if (HAL_DMAEx_List_LinkQ(&handle_GPDMA1_Channel6, &List_GPDMA1_Channel6) != HAL_OK) {
		Error_Handler();
	}
	HAL_DMAEx_List_Start(&handle_GPDMA1_Channel6);
	__HAL_LINKDMA(hdcmi, DMA_Handle, handle_GPDMA1_Channel6);
 HAL_NVIC_SetPriority(DCMI_PSSI_IRQn, 3, 0);
 HAL_NVIC_EnableIRQ(DCMI_PSSI_IRQn);
 /* USER CODE END DCMI_MspInit 1 */
 }
}

 

3 replies

ST Employee
July 30, 2025

Hello,

There are a few key points to address regarding the DMA initialization for DCMI in your code:

  • GPDMA Clock Enable is Missing
    The clock for the GPDMA peripheral must be explicitly enabled before using DMA channels. Without this, the DMA controller will not function properly.

  • Incorrect Call to HAL_DMAEx_List_Start at MSP Level
    The call to HAL_DMAEx_List_Start(&handle_GPDMA1_Channel6); is placed too early in the MSP initialization. At this point, the DMA transfer size is not yet configured, which can cause errors. Instead, the DCMI driver itself should handle starting the DMA transfer with the appropriate size via the function:

     
    HAL_DCMI_Start_DMA(DCMI_HandleTypeDef *hdcmi, uint32_t DCMI_Mode, uint32_t pData, uint32_t Length)

    This ensures the DMA is started with the correct parameters.

  • NodeConfig.Init.DestBurstLength Should Be Set to 1
    In your DMA node configuration, the DestBurstLength is currently set to 4. For DCMI DMA transfers, this should be set to 1 to match the peripheral's burst requirements and avoid transfer errors

  • The linking of the DMA handle to the DCMI handle, as well as enabling the DMA(missing)/DCMI IRQ, should be done before starting the transfer so that the DCMI driver knows which DMA handle to use and can correctly handle the received data.

You can use the example shared for STM32U5, which uses the same DMA linked list feature, as a reference.

STM32CubeU5/Projects/STM32U575I-EV/Examples/DCMI/DCMI_ContinousCap_EmbeddedSynchMode at main · STMicroelectronics/STM32CubeU5 · GitHub

 

Best Regards

 

 

Associate II
June 22, 2026

Hello ST team,

I'm facing the issue with STM32N6 DCMI DMA configurations, I could see the data flowing down from the cmos & clocking at 50MHZ. I could spot the first 4 pixels data (2 words) on live watch window. the next word data is intermittent & getting into DMA error 0x41,



The cube MX (6.17.0) unable to generate the DMA init functions appropriately for DCMI, however i’ve added the Config explicitly,  



Any suggestions on the below configurations?


 

/**

* @brief DCMI Initialization Function

* @param None

* @retval None

*/

static void MX_DCMI_Init(void)

{

 

/* USER CODE BEGIN DCMI_Init 0 */

 

/* USER CODE END DCMI_Init 0 */

 

/* USER CODE BEGIN DCMI_Init 1 */

 

/* USER CODE END DCMI_Init 1 */

hdcmi.Instance = DCMI;

hdcmi.Init.SynchroMode = DCMI_SYNCHRO_HARDWARE;

hdcmi.Init.PCKPolarity = DCMI_PCKPOLARITY_FALLING;

hdcmi.Init.VSPolarity = DCMI_VSPOLARITY_LOW;

hdcmi.Init.HSPolarity = DCMI_HSPOLARITY_LOW;

hdcmi.Init.CaptureRate = DCMI_CR_ALL_FRAME;

hdcmi.Init.ExtendedDataMode = DCMI_EXTEND_DATA_12B;

hdcmi.Init.JPEGMode = DCMI_JPEG_DISABLE;

hdcmi.Init.ByteSelectMode = DCMI_BSM_ALL;

hdcmi.Init.ByteSelectStart = DCMI_OEBS_ODD;

hdcmi.Init.LineSelectMode = DCMI_LSM_ALL;

hdcmi.Init.LineSelectStart = DCMI_OELS_ODD;

if (HAL_DCMI_Init(&hdcmi) != HAL_OK)

{

Error_Handler();

}

/* USER CODE BEGIN DCMI_Init 2 */

 

/* USER CODE END DCMI_Init 2 */

 

}

 

/**

* @brief GPDMA1 Initialization Function

* @param None

* @retval None

*/

static void MX_GPDMA1_Init(void)

{

 

/* USER CODE BEGIN GPDMA1_Init 0 */

HAL_StatusTypeDef status;

/* USER CODE END GPDMA1_Init 0 */

 

/* Peripheral clock enable */

__HAL_RCC_GPDMA1_CLK_ENABLE();

 

/* GPDMA1 interrupt Init */

HAL_NVIC_SetPriority(GPDMA1_Channel15_IRQn, 0, 0);

HAL_NVIC_EnableIRQ(GPDMA1_Channel15_IRQn);

 

/* USER CODE BEGIN GPDMA1_Init 1 */

/* Initialize GPDMA1 Channel 0 for DCMI */

handle_GPDMA1_Channel15.Instance = GPDMA1_Channel15;

 

/* DCMI hardware request */

handle_GPDMA1_Channel15.Init.Request = GPDMA1_REQUEST_DCMI_PSSI;

 

/* Block request at single/burst level */

handle_GPDMA1_Channel15.Init.BlkHWRequest = DMA_BREQ_SINGLE_BURST;

 

/* Peripheral to memory direction */

handle_GPDMA1_Channel15.Init.Direction = DMA_PERIPH_TO_MEMORY;

 

/* Source (DCMI) increment: fixed, Destination (RAM) increment: enabled */

handle_GPDMA1_Channel15.Init.SrcInc = DMA_SINC_FIXED;

handle_GPDMA1_Channel15.Init.DestInc = DMA_DINC_INCREMENTED;

 

/* Word (32-bit) data width for both source and destination

to match DCMI peripheral register width */

handle_GPDMA1_Channel15.Init.SrcDataWidth = DMA_SRC_DATAWIDTH_WORD;

handle_GPDMA1_Channel15.Init.DestDataWidth = DMA_DEST_DATAWIDTH_WORD;

 

/* High priority */

handle_GPDMA1_Channel15.Init.Priority = DMA_HIGH_PRIORITY;

 

/* Single transfer */

handle_GPDMA1_Channel15.Init.SrcBurstLength = 1;

handle_GPDMA1_Channel15.Init.DestBurstLength = 1;

 

/* Allocated ports */

handle_GPDMA1_Channel15.Init.TransferAllocatedPort = DMA_SRC_ALLOCATED_PORT0 | DMA_DEST_ALLOCATED_PORT0;

 

/* Block transfer mode */

handle_GPDMA1_Channel15.Init.TransferEventMode = DMA_TCEM_BLOCK_TRANSFER;

 

/* Normal mode */

handle_GPDMA1_Channel15.Init.Mode = DMA_NORMAL;

 

/* Initialize the DMA channel */

status = HAL_DMA_Init(&handle_GPDMA1_Channel15);

if (status != HAL_OK) {

return status;

}

 

/* Link the DMA to the DCMI peripheral */

__HAL_LINKDMA(&hdcmi, DMA_Handle, handle_GPDMA1_Channel15);

 

return HAL_OK;

/* USER CODE END GPDMA1_Init 1 */

/* USER CODE BEGIN GPDMA1_Init 2 */

 

/* USER CODE END GPDMA1_Init 2 */

 

}


 

/**

* @brief RIF Initialization Function

* @param None

* @retval None

*/

static void SystemIsolation_Config(void)

{

 

/* USER CODE BEGIN RIF_Init 0 */

 

/* USER CODE END RIF_Init 0 */

 

/* set all required IPs as secure privileged */

__HAL_RCC_RIFSC_CLK_ENABLE();

 

/* RIF-Aware IPs Config */

 

/* set up GPDMA configuration */

/* set GPDMA1 channel 15 used by DCMI */

if (HAL_DMA_ConfigChannelAttributes(&handle_GPDMA1_Channel15,DMA_CHANNEL_SEC|DMA_CHANNEL_PRIV|DMA_CHANNEL_SRC_SEC|DMA_CHANNEL_DEST_SEC)!= HAL_OK )

{

Error_Handler();

}

 

/* set up GPIO configuration */

HAL_GPIO_ConfigPinAttributes(GPIOA,GPIO_PIN_3,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOA,GPIO_PIN_4,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOA,GPIO_PIN_5,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOA,GPIO_PIN_7,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOA,GPIO_PIN_9,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOA,GPIO_PIN_10,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOA,GPIO_PIN_11,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOB,GPIO_PIN_10,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOB,GPIO_PIN_11,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOC,GPIO_PIN_1,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOC,GPIO_PIN_6,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOC,GPIO_PIN_8,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOC,GPIO_PIN_9,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOC,GPIO_PIN_12,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOC,GPIO_PIN_13,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOD,GPIO_PIN_8,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOD,GPIO_PIN_9,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOE,GPIO_PIN_4,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOE,GPIO_PIN_8,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_0,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_1,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_3,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_4,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_5,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_6,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_9,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_10,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_12,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_13,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOF,GPIO_PIN_15,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOG,GPIO_PIN_0,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOG,GPIO_PIN_1,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOH,GPIO_PIN_3,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOP,GPIO_PIN_13,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOP,GPIO_PIN_14,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

HAL_GPIO_ConfigPinAttributes(GPIOP,GPIO_PIN_15,GPIO_PIN_SEC|GPIO_PIN_NPRIV);

 

/* USER CODE BEGIN RIF_Init 1 */

 

/* USER CODE END RIF_Init 1 */

/* USER CODE BEGIN RIF_Init 2 */

 

/* USER CODE END RIF_Init 2 */

 

}




 

/**

* @brief This function handles GPDMA1 Channel 15 global interrupt.

*/

void GPDMA1_Channel15_IRQHandler(void)

{

/* USER CODE BEGIN GPDMA1_Channel15_IRQn 0 */

 

 

/* USER CODE END GPDMA1_Channel15_IRQn 0 */

HAL_DMA_IRQHandler(&handle_GPDMA1_Channel15);

/* USER CODE BEGIN GPDMA1_Channel15_IRQn 1 */

dma_counter++;

HAL_NVIC_ClearPendingIRQ(GPDMA1_Channel15_IRQn);

/* USER CODE END GPDMA1_Channel15_IRQn 1 */

}

 

/**

* @brief This function handles DCMI/PSSI global interrupt.

*/

void DCMI_PSSI_IRQHandler(void)

{

/* USER CODE BEGIN DCMI_PSSI_IRQn 0 */

 

/* USER CODE END DCMI_PSSI_IRQn 0 */

HAL_DCMI_IRQHandler(&hdcmi);

/* USER CODE BEGIN DCMI_PSSI_IRQn 1 */

dcmi_counter++;

/* USER CODE END DCMI_PSSI_IRQn 1 */

}

Thanks,
Madhu

David Littell
Senior II
June 22, 2026

Don’t hijack old threads, start your own.