Why does 4 wire SPI read operation need me to read MISO line on every transmit operation?

Question

I wish to read a SPI slave device. Here's what I thought the procedure would be like :

CS_LOW

1. SPI_Write(slave_address)
2. SPI_Write(register)
3. SPI_Write(0x00) //dummy byte
4. data = SPI_Read()

CS_HIGH

However, this doesn't work. To make it work, here's what I have to follow:

CS_LOW

1. SPI_Write(slave_address)
2. temp = SPI_Read()
3. SPI_Write(register)
4. temp = SPI_Read()
5. SPI_Write(0x00) //dummy byte
6. data = SPI_Read()

CS_HIGH

Why do I have to read the data on MISO line even when I know there will be nothing desirable?

PS: The SPI Read() and Write() functions are just my own implementations, nothing particular to a single MCU.

Edit : As requested, I am providing some details on the MCUs.

I am using two MCUs - STM32F303VCT and TI TIVA123GH6PM. Both the MCUs require me to follow the said procedure.

Here's my implementation of SPI transmit & receive function on STM32

uint8_t SPI_rdwr(uint8_t data)
{
    
    *(__IO uint8_t *)&SPI1->DR = data;              //send data
    
    while(!(SPI1->SR & SPI_SR_TXE));                // wait till TX buffer is empty
    
    while(SPI1->SR & SPI_SR_BSY);                  // wait if SPI line is busy
    
    while(!(SPI1->SR & SPI_SR_RXNE));               //wait till RX buffe is NOT empty                   

    return *(__IO uint8_t *)&SPI1->DR;          //return data if data received on MISO line
    
}

Answer 1

Why does 4 wire SPI read operation need me to read MISO line on every transmit operation?

Because:

1. For performance reasons, the HAL implementers wrote SPI_Write without the "wait for transmit register empty" loop built in, but SPI_Read has such a loop. In that case, issuing writes without reads would overrun the buffer. Your implementation also wastes time in that loop - once you can read, you can write, too; or

2. The hardware abstraction library (HAL) you're using configures the silicon to work that way, when the silicon doesn't require it to be so,

3. and perhaps you're not configuring the HAL to do it the way you want, in case the HAL supported it (and necessarily also the silicon); or

4. perhaps you're not configuring the silicon to do the "right" thing when the silicon allows that; or

5. the silicon is designed to work that way and no other way.

I don't recall the details of SPI implementation on the chips you're using, but:

1. Some SPI implementations can have the receiver switched off, and thus reads won't be necessary since that function will be disabled.

2. SPI can be probably used with DMA, thus you won't care about the overhead of doing the reads too much.

3. Even if you do it in software, the reads may be cheap. Not using the HAL would probably help with that too, although be sure to compile the code in optimized release configuration, and audit the assembly to confirm that it doesn't do anything unnecessary. Even your hand-written code does unnecessary things.