round_robin

module round_robin_arbiter#(
    DW_width = 128
)
(
    //clk
    input                                 clk,
    //rstn
    input                                 rstn,
    //input chnl_a
    input                                 chnl_a_valid,
    input    [DW_width-1:0]    chnl_a_data,
    output    reg                        chnl_a_ready,
    //input chnl_b
    input                                 chnl_b_valid,
    input    [DW_width-1:0]     chnl_b_data,
    output    reg                        chnl_b_ready,
    //output chnl_c
    output     reg                        chnl_c_valid,
    output [DW_width-1:0]    chnl_c_data,
    input                                    chnl_c_ready
);

    reg     [1:0] state;
    wire    [2:0] req;
    
    parameter chnl_a = 2'b00,
                        chnl_b = 2'b01,
                        chnl_c = 2'b10,
                        idle     = 2'b11;
    
    assign req = {chnl_c_ready, chnl_b_valid, chnl_a_valid};
    
    
    always@(posedge clk or negedge rstn) begin
        if(!rstn) begin
            state <= chnl_a;
        end
        else begin
            case(state) 
                chnl_a: begin                                    //优先级 chnl_b,chnl_c,chnl_a
                    case(req)
                        3'000: state <= chnl_a;
                        3'001: state <= chnl_a;
                        3'010: state <= chnl_b;
                        3'011: state <= chnl_b;
                        3'100: state <= chnl_c;
                        3'101: state <= chnl_c;
                        3'110: state <= chnl_b;
                        3'111: state <= chnl_b;
                        default: state <= chnl_a;
                    endcase
                end
                chnl_b: begin                                    

//优先级 chnl_c,chnl_a,chnl_b
                    case(req)
                        3'000: state <= chnl_b;               //保持优先级
                        3'001: state <= chnl_a;
                        3'010: state <= chnl_b;
                        3'011: state <= chnl_a;
                        3'100: state <= chnl_c;
                        3'101: state <= chnl_c;
                        3'110: state <= chnl_c;
                        3'111: state <= chnl_c;
                        default: state <= chnl_b;
                    endcase
                end
                chnl_c: begin                                    //优先级 chnl_a,chnl_b,chnl_c
                    case(req)
                        3'000: state <= chnl_c;             //保持优先级
                        3'001: state <= chnl_a;
                        3'010: state <= chnl_b;
                        3'011: state <= chnl_a;
                        3'100: state <= chnl_c;
                        3'101: state <= chnl_a;
                        3'110: state <= chnl_b;
                        3'111: state <= chnl_a;
                        default: state <= chnl_c;
                    endcase
                end
                idle:    state <= chnl_a;
                default: state <= chnl_a;
            endcase
        end
    end

    always@(*) begin
        case(state) 
            chnl_a: {chnl_a_ready, chnl_b_ready, chnl_c_valid} = 3'b100;
            chnl_b: {chnl_a_ready, chnl_b_ready, chnl_c_valid} = 3'b010;
            chnl_c: {chnl_a_ready, chnl_b_ready, chnl_c_valid} = 3'b001;
            idle    : {chnl_a_ready, chnl_b_ready, chnl_c_valid} = 3'b000;
            default:{chnl_a_ready, chnl_b_ready, chnl_c_valid} = 3'b000;
        endcase
    end

endmodule