configurable_priority_encoder.v

/**
 * Configurable Priority Encoder
 * 
 * This module implements a priority encoder that converts a one-hot or
 * multi-hot input vector into a binary-encoded output representing the
 * highest priority active input. Priority is determined by bit position,
 * with MSB having highest priority.
 * 
 * Key Features:
 * - Priority encoding: Converts input vector to binary index
 * - MSB priority: Highest bit position has highest priority
 * - Valid output: Indicates when at least one input is active
 * - Configurable width: Any input width via INPUT_WIDTH parameter
 * 
 * Priority Encoding:
 * - Input: One-hot or multi-hot vector (e.g., 0b00101000)
 * - Output: Binary index of highest priority active bit (e.g., 5 for bit 5)
 * - Priority: MSB (bit N-1) has highest priority, LSB (bit 0) has lowest
 * 
 * Operation:
 * - Scans from MSB to LSB
 * - Finds first active bit (highest priority)
 * - Outputs binary index of that bit
 * - Sets valid=1 if any bit is active, valid=0 if all bits are zero
 * 
 * Use Cases:
 * - Interrupt controllers
 * - Request arbitration
 * - Address decoding
 * - Priority-based selection
 * 
 * @param INPUT_WIDTH Width of input vector (default: 8 bits)
 *                   Input range: 0 to 2^INPUT_WIDTH - 1
 * @param OUTPUT_WIDTH Width of output (default: $clog2(INPUT_WIDTH))
 *                    Automatically calculated from INPUT_WIDTH
 * 
 * @input request[INPUT_WIDTH-1:0] Input request vector
 *       Each bit represents a request, MSB has highest priority
 * @output grant_index[OUTPUT_WIDTH-1:0] Binary-encoded index of highest priority active bit
 * @output valid High when at least one input is active, low when all inputs are zero
 */
module configurable_priority_encoder #(
    parameter INPUT_WIDTH = 8,                     // Width of the input vector
    parameter OUTPUT_WIDTH = $clog2(INPUT_WIDTH)   // Width of the output (calculated)
) (
    input wire [INPUT_WIDTH-1:0] request,          // Input request vector
    output reg [OUTPUT_WIDTH-1:0] grant_index,     // Binary encoded output
    output reg valid                              // Valid output signal
);

    integer i;
    
    // ============================================================================
    // Priority Encoding Logic (Combinational)
    // ============================================================================
    // Scans input vector from MSB to LSB, finds highest priority active bit
    always @(*) begin
        // ========================================================================
        // Default Values
        // ========================================================================
        // Default: no valid output, index is zero
        valid = 1'b0;
        grant_index = {OUTPUT_WIDTH{1'b0}};
        
        // ========================================================================
        // Priority Encoding (MSB has Highest Priority)
        // ========================================================================
        // Scan from MSB to LSB to find highest priority active bit
        for (i = INPUT_WIDTH-1; i >= 0; i = i - 1) begin
            if (request[i]) begin
                // ================================================================
                // Highest Priority Active Bit Found
                // ================================================================
                // Assign the index of this bit as the output
                // This is the highest priority because we scan from MSB
                grant_index = i;
                // Set valid flag to indicate at least one input is active
                valid = 1'b1;
                // ================================================================
                // Force Loop Exit
                // ================================================================
                // Break out of the loop using a manual approach
                // Set i to -1 to force loop exit (simulator-compatible alternative to 'break')
                i = -1;
            end
        end
        // ========================================================================
        // No Active Input
        // ========================================================================
        // If no input is active, valid remains 0 and grant_index remains 0
        // (default values are already set above)
    end
    
    // Alternative implementation without using break (compatible with all simulators)
    /*
    always @(*) begin
        valid = 1'b0;
        grant_index = {OUTPUT_WIDTH{1'b0}};
        
        // Priority encoding logic using casez
        casez (request)
            {INPUT_WIDTH{1'b0}}: begin
                // All zeros case
                valid = 1'b0;
                grant_index = {OUTPUT_WIDTH{1'b0}};
            end
            default: begin
                // Find the highest priority bit (MSB)
                valid = 1'b1;
                
                // Priority encoding logic
                for (i = INPUT_WIDTH-1; i >= 0; i = i - 1) begin
                    if (request[i]) begin
                        grant_index = i[OUTPUT_WIDTH-1:0];
                        i = -1; // Force exit from the loop
                    end
                end
            end
        endcase
    end
    */

endmodule