How to accurately read a 64 bit register value using a method that can only read 32 bits at a time?

Question

Came across this question during a past interview, but got no feedback.

Since its a register, would I need to disable interrupts before accessing the register inorder to prevent data corruption? Thought of using two buffers, 32 bit and 64 bit, and sending the 32 bit buffer into a read32() and shifting it over accordingly to the 64 bit buffer. Lets just assume this is little-endian architecture.

I wrote a quick sample code on repl.it (Output does not match register value)

#include <stdio.h>
#include <string.h>
#include <stdint.h>

void read32(uint64_t *reg, uint32_t *buffer){
  memcpy(buffer, reg, 4);
}

int main(void) {
  
  //register
  uint64_t reg = 0xAAAAAAAAFFFFFFFF;
  
  //buffers
  uint32_t buf_32 = 0;
  uint64_t buf_64 = 0;

  //read LSW
  read32(&reg, &buf_32);
  buf_64 |= buf_32; //add LSW

  //read MSW
  read32(&reg+4, &buf_32);
  buf_64 |= ((uint64_t)buf_32 << 32);
  
  printf("64 bit register value: 0x%lx\n", buf_64);
  return 0;
}

Output:

64 bit register value: 0x1ffffffff

Answer 1

Disabling interrupts will not prevent an I/O register that may change independently of the code sequence from changing.

Often where data consistency is required between two hardware registers that are larger than the architecture width, the hardware data sheet or reference manual will advise on how to read the data - usually by specifying the order in which the registers must be read to work with hardware mechanisms that make that "safe".

In other cases the method might be dictated by the nature of the registers and their function/behaviour. For example if you have two 32bit timer/counters, with the overflow of one triggering an increment of the other, to form a 64 bit counter, then clearly the high-order counter will only change when the low-order counter overflows. In that case you can simply read the low, then the high and repeat if the low has since wrapped :

uint32_t low_word = 0, high_word = 0;

do
{
    low_word = *low_reg_addr ;
    high_word = *high_reg_addr ;

} while( *low_reg_addr > low_word ) ;  // If low has wrapped, re-read

uint64_t full_word = (uint64_t)high_word << 32 | low_word;

So if the low-order register not wrapped after the high-order register has been read, then the data must be consistent, and the loop exit. If it has wrapped, the data may not be consistent, and must be re-read.

Answer 2

One mistake I see with your code is &reg+4 would increment the pointer to x + 32 bytes. This isn't what you want since it should be just x + 4 bytes. You might want to consider typecasting to uint32_t. ((uint32_t *)&reg + 1) should increment by 4 byte. However, you will have to change your read function accordingly too.

Answer 3

This should work...

void read32(uint32_t *reg, uint32_t *buffer){
  memcpy(buffer, reg, 4);
}

int main(void) {
  
  //register
  uint64_t reg = 0xAAAAAAAAFFFFFFFF;
  
  //buffers
  uint32_t buf_32 = 0;
  uint32_t buf1_32 = 0;
  uint64_t buf_64 = 0;

  uint64_t *ptr = ®
  read32((uint32_t *)ptr, &buf_32);
  printf("32 bit register value: 0x%lx\n", buf_32);
  read32((uint32_t *)ptr+1, &buf1_32);
  printf("32 bit register value: 0x%lx\n", buf1_32);
  
  buf_64 = ((uint64_t)buf1_32 << 32 )| buf_32;
  printf("64 bit register value: 0x%lx\n", buf_64);
  return 0;
}