Interfaccia registri e istante degli effetti

Definire «scrivere un registro»

Prerequisiti: decoder^{iDecoder Attiva la linea corrispondente a un codice binario. Con enable disattivato può portare tutte le uscite a 0. Approfondisci} d'indirizzo, ready/valid^{iHandshake Contratto che conferma il trasferimento quando valid del mittente e ready del destinatario valgono 1 allo stesso fronte. Include il mantenimento dei dati in attesa. Approfondisci} e priorità d'aggiornamento.

Collegare registri^{iRegistro Memorizza uno stato di più bit. I registri sincroni del corso acquisiscono gli ingressi specificati al fronte di clock. Approfondisci} di configurazione a un controllore esterno richiede più dell'indirizzo corretto: vanno definiti accettazione, mantenimento della risposta bloccata e scritture su indirizzi di sola lettura. Usiamo una semplice interfaccia richiesta/risposta sullo stesso clock.

Gli indirizzi sono a byte con allineamento a 32 bit. Ogni richiesta genera esattamente una risposta di successo o errore.

Accettare se lo spazio per la risposta è vuoto o si libera

module register_interface (
    input  logic        clk, rst,
    input  logic        req_valid, req_write,
    output logic        req_ready,
    input  logic [3:0]  req_addr,
    input  logic [31:0] req_wdata,
    input  logic [3:0]  req_wstrb,
    output logic        rsp_valid,
    input  logic        rsp_ready,
    output logic [31:0] rsp_rdata,
    output logic        rsp_error,
    input  logic [31:0] status_value,
    output logic [31:0] config_value,
    output logic        start_pulse
);
    assign req_ready = !rsp_valid || rsp_ready;
    always_ff @(posedge clk) begin
        if (rst) begin
            rsp_valid    <= 1'b0;
            config_value <= 32'd0;
            start_pulse  <= 1'b0;
        end else begin
            start_pulse <= 1'b0;
            if (req_ready) begin
                rsp_valid <= req_valid;
                if (req_valid) begin
                    rsp_rdata <= 32'd0;
                    rsp_error <= 1'b0;
                    case (req_addr)
                        4'h0: begin
                            if (req_write) begin
                                for (int i=0; i<4; i++)
                                    if (req_wstrb[i])
                                        config_value[8*i +: 8]
                                            <= req_wdata[8*i +: 8];
                            end else rsp_rdata <= config_value;
                        end
                        4'h4: begin
                            if (req_write) rsp_error <= 1'b1;
                            else rsp_rdata <= status_value;
                        end
                        4'h8: begin
                            if (req_write)
                                start_pulse <= req_wstrb[0] && req_wdata[0];
                        end
                        default: rsp_error <= 1'b1;
                    endcase
                end
            end
        end
    end
endmodule

Con risposta bloccata req_ready=0: scrittura CONFIG e impulso COMMAND non si ripetono. L'effetto può essere già avvenuto mentre attende solo la risposta. Ritrasmettere automaticamente per un ritardo può eseguire il comando due volte.

Calcolare i byte strobe

Con CONFIG=32'h11223344, req_wdata=32'hAABBCCDD, req_wstrb=4'b0101, cambiano solo byte 0 e 2: 32'h11BB33DD. Controllate separatamente allineamento, posizioni e ordine dei byte. Una scrittura wstrb=0000 risponde con successo senza cambiare il valore.

Dal MSB^{iMSB Bit di peso maggiore. L’indice dipende dalla direzione dichiarata: non è necessariamente il numero più alto. Approfondisci} l'ordine è byte3,2,1,0. Strobe 0101 seleziona byte2 e byte0, quindi solo BB e DD. Un bit strobe abilita un byte, non un singolo bit.

A quale istante appartiene lo stato?

STATUS salva status_value all'accettazione. Se lo stato reale cambia mentre la risposta attende, rsp_rdata deve restare fermo. Collegare direttamente lo status combinatorio con rsp_valid=1, rsp_ready=0 viola il protocollo.

req_valid e req_ready entrambi 1 a fronti consecutivi indicano due richieste diverse. Dopo l'accettazione il mittente abbassa valid o presenta la richiesta seguente. Tenere la stessa richiesta non implica un'unica esecuzione.

Tre assi di verifica

1. Indirizzi/permessi: validi, non allineati, scritture su STATUS e indirizzi indefiniti, controllando errori ed effetti.
2. Dati: tutte le combinazioni dei quattro strobe e conservazione dei byte inattivi.
3. Flusso: la risposta resta stabile se bloccata per più cicli; conteggio coerente anche consumando una risposta e accettando la successiva insieme.