How does CRC_Handle_16 work within the HAL library?

[DOver.1]

Hello,

I am currently trying to understand exactly how CRC_Handle_16 function works within the stm32f0xx_hal_crc.c file so I can implement the algorithm in a non-hardware way. The non-hardware implementation I have works fine if there is an even number of BufferLength. The problem I'm having is when I try to insert an odd number of elements. Basically, what I want to know is what exactly is happening on lines 23-24 and how would I implement this in a non-hardware way?

Any help is appreciated, thanks.

/**
 * @brief Enter 16-bit input data to the CRC calculator.
 * Specific data handling to optimize processing time.
 * @param hcrc CRC handle
 * @param pBuffer pointer to the input data buffer
 * @param BufferLength input data buffer length
 * @retval uint32_t CRC (returned value LSBs for CRC shorter than 32 bits)
 */
static uint32_t CRC_Handle_16(CRC_HandleTypeDef *hcrc, uint16_t pBuffer[], uint32_t BufferLength)
{
 uint32_t i; /* input data buffer index */
 __IO uint16_t *pReg;
 
 /* Processing time optimization: 2 HalfWords are entered in a row with a single word write,
 * in case of odd length, last HalfWord must be carefully fed to the CRC calculator to ensure
 * a correct type handling by the peripheral */
 for (i = 0U; i < (BufferLength / 2U); i++)
 {
 hcrc->Instance->DR = ((uint32_t)pBuffer[2U * i] << 16U) | (uint32_t)pBuffer[(2U * i) + 1U];
 }
 if ((BufferLength % 2U) != 0U)
 {
 pReg = (__IO uint16_t *)(__IO void *)(&hcrc->Instance->DR); /* Derogation MisraC2012 R.11.5 */
 *pReg = pBuffer[2U * i];
 }
 
 /* Return the CRC computed value */
 return hcrc->Instance->DR;
}

[waclawek.jan]

Type punning, to allow 16-bit write to the data register (which is otherwise defined as a pointer to 32-bit word, i.e. "plain" writes to it (assignments) result in 32-bit writes).

See disasm.

JW

[Tesla DeLorean]

>>..so I can implement the algorithm in a non-hardware way

Not sure I understand, surely doing a 16-bit sw implementation would be trivial for both odd and even counts.

The method here feeds 32-bit value pairs into the hardware until it is left with one 16-bit word to feed, and then it does an explicit 16-bit wide write to the register.