Case Statement em Verilog: Decodificação multi-way do jeito certo

O multi-way branch

case é a construção de dispatch achatado do Verilog. Você dá a ele uma expressão; ele escolhe o ramo que casar:

case (expression)
    pattern_1: statement_1;
    pattern_2: statement_2;
    pattern_3: begin
        statement_3a;
        statement_3b;
    end
    default: default_statement;
endcase

É estruturalmente similar ao switch do C, mas:

• Não há break - cada ramo é implicitamente terminado pelo próximo.
• Padrões podem ser vetores, não apenas inteiros.
• O sintetizador transforma o todo em um mux achatado (ou um decodificador one-hot quando os padrões permitem).

Um exemplo trabalhado: Mux 4-para-1

module mux4(
    input  wire [1:0] sel,
    input  wire [7:0] in0, in1, in2, in3,
    output reg  [7:0] out
);
    always @(*) begin
        case (sel)
            2'd0: out = in0;
            2'd1: out = in1;
            2'd2: out = in2;
            2'd3: out = in3;
            default: out = 8'bx;
        endcase
    end
endmodule

module test;
    reg [1:0] sel;
    wire [7:0] out;
    wire [7:0] a = 8'hA0, b = 8'hB0, c = 8'hC0, d = 8'hD0;

    mux4 dut(.sel(sel), .in0(a), .in1(b), .in2(c), .in3(d), .out(out));

    initial begin
        for (integer i = 0; i < 4; i = i + 1) begin
            sel = i[1:0];
            #1 $display("sel=%0d out=%h", sel, out);
        end
        $finish;
    end
endmodule

O corpo do case tem quatro padrões explícitos mais um default. O sintetizador vê uma entrada de 2 bits mapeada para um de quatro valores e emite um multiplexador 4-para-1. Limpo, achatado, rápido.

Por que você precisa de default

Para case combinacional, omitir default é a mesma armadilha de if sem else: qualquer valor de entrada não casado deixa out não atribuído, e o sintetizador infere um latch.

Para um sel de 2 bits, os padrões acima cobrem todos os quatro valores possíveis - então em teoria default é redundante. Na prática:

1. O sintetizador nem sempre prova que os casos são exaustivos.
2. O seletor pode ser x ou z em simulação, o que não casa com nenhum caso explícito.
3. Adicionar um novo caso mais tarde pode deixar o comportamento default não especificado.

Sempre escreva default. Para máquinas de estado e lógica de mux onde você sabe que o default é inalcançável, atribuir 'x:

default: out = 8'bx;

…diz ao sintetizador "isso é um don't-care, otimize livremente" e exibe um x vermelho brilhante em simulação se o caso inalcançável for de alguma forma alcançado. Esse é o melhor dos dois mundos.

Uma máquina de estado em case

O uso clássico do case é a lógica de transição de estado de uma máquina de estado finita:

module traffic_light(
    input  wire       clk,
    input  wire       reset,
    output reg  [1:0] light    // 00=vermelho, 01=amarelo, 10=verde
);
    localparam RED    = 2'd0;
    localparam GREEN  = 2'd1;
    localparam YELLOW = 2'd2;

    reg [1:0] state;
    reg [3:0] timer;

    always @(posedge clk) begin
        if (reset) begin
            state <= RED;
            timer <= 4'd0;
        end else if (timer == 4'd0) begin
            case (state)
                RED:    begin state <= GREEN;  timer <= 4'd6; end
                GREEN:  begin state <= YELLOW; timer <= 4'd2; end
                YELLOW: begin state <= RED;    timer <= 4'd5; end
                default: begin state <= RED;   timer <= 4'd0; end
            endcase
        end else begin
            timer <= timer - 4'd1;
        end
    end

    always @(*) light = state;
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    wire [1:0] light;
    traffic_light dut(.clk(clk), .reset(reset), .light(light));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #200 $finish;
    end

    always @(posedge clk)
        $display("t=%0t light=%0d", $time, light);
endmodule

O bloco case (state) é a lógica de transição de estado. Cada ramo decide qual é o próximo estado e quanto tempo ficar nele. default é inalcançável aqui (cobrimos RED/GREEN/YELLOW exaustivamente no espaço de 2 bits), mas está lá como rede de segurança - se state de alguma forma virar 2'd3, a FSM reseta limpinha para RED em vez de ficar travada.

Finite State Machines vai mais a fundo nesse padrão.

Múltiplos padrões por ramo

Você pode listar vários padrões compartilhando uma única declaração, separados por vírgulas:

case (opcode)
    4'h0, 4'h1, 4'h2: result = a + b;
    4'h3, 4'h4:       result = a - b;
    4'h8:             result = a & b;
    default:          result = 8'd0;
endcase

São dois opcodes ambos significando "subtrair", três significando "somar". O sintetizador faz OR dos padrões juntos para o comparador.

casez e casex: Casamento don't-care

Às vezes você quer casar um padrão com alguns bits não especificados - "qualquer opcode que começa com 010":

casez (opcode)
    8'b010?_????: instruction = ALU_OP;
    8'b110?_????: instruction = LOAD_OP;
    8'b1110_????: instruction = JUMP_OP;
    default:      instruction = UNKNOWN;
endcasez

casez trata ? (e z) no padrão como don't-cares. Cada ? casa com 0 ou 1. Útil para decodificar formatos de instrução onde algumas posições de bit não são usadas para certas classes de opcode.

casex estende isso para tratar x como don't-care também. casex é perigoso porque sinais não inicializados (que são x em simulação) casam com todo caso, produzindo comportamento surpreendente. A maioria dos guias de estilo modernos recomenda casez e proíbe casex.

Em SystemVerilog você também ganha case inside, que é a versão mais limpa de todas - aceita ranges e listas - mas Verilog puro para em casez.

case vs cadeia if/else if

As duas construções podem expressar decisões multi-way, mas sintetizam para hardware diferente:

• case é um dispatch achatado. O sintetizador pode produzir um decodificador one-hot, uma árvore de mux balanceada ou outras estruturas achatadas. Tempo constante para avaliar.
• if/else if é uma cadeia de prioridade. O sintetizador produz uma cascade onde cada nível adiciona delay. Logaritmicamente mais lento.

Funcionalmente se sobrepõem. Estilisticamente: use case sempre que as condições são sobre o valor de uma única expressão. Use if/else if quando há uma prioridade real ou quando condições envolvem sinais diferentes.

// Melhor como case:
if      (sel == 2'd0) out = a;
else if (sel == 2'd1) out = b;
else if (sel == 2'd2) out = c;
else                  out = d;

// Melhor como if/else if:
if      (urgent_event)  next_state = HANDLE_URGENT;
else if (timer_expired) next_state = TIMEOUT;
else if (data_ready)    next_state = PROCESS;
else                    next_state = state;

As três primeiras condições são todas "qual é o sel?" - um case lê mais naturalmente e sintetiza mais achatado. As três segundas são eventos independentes com uma prioridade óbvia - if/else if é melhor encaixe.

O que vem a seguir

O último doc deste capítulo - For Loops - cobre o for do Verilog e a coisa surpreendente que acontece quando você o usa em código sintetizável. Depois entramos em lógica sequencial e FSMs para valer.