Package prim_mubi_pkg

Enums

mubi12_t
Enum Items:

  • MuBi12True = 12'h696

    enabled

  • MuBi12False = 12'h969

    disabled

mubi16_t
Enum Items:

  • MuBi16True = 16'h9696

    enabled

  • MuBi16False = 16'h6969

    disabled

mubi20_t
Enum Items:

  • MuBi20True = 20'h69696

    enabled

  • MuBi20False = 20'h96969

    disabled

mubi24_t
Enum Items:

  • MuBi24True = 24'h969696

    enabled

  • MuBi24False = 24'h696969

    disabled

mubi28_t
Enum Items:

  • MuBi28True = 28'h6969696

    enabled

  • MuBi28False = 28'h9696969

    disabled

mubi32_t
Enum Items:

  • MuBi32True = 32'h96969696

    enabled

  • MuBi32False = 32'h69696969

    disabled

mubi4_t
Enum Items:

  • MuBi4True = 4'h6

    enabled

  • MuBi4False = 4'h9

    disabled

mubi8_t
Enum Items:

  • MuBi8True = 8'h96

    enabled

  • MuBi8False = 8'h69

    disabled

Functions

mubi12_and(mubi12_t a, mubi12_t b, mubi12_t act)

Performs a logical AND operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | !act !act | act | !act act | act | act

Parameters:
Return type:

mubi12_t

mubi12_and_hi(mubi12_t a, mubi12_t b)

Performs a logical AND operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi12_t

mubi12_and_lo(mubi12_t a, mubi12_t b)

Performs a logical AND operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi12_t

mubi12_bool_to_mubi(logic val)

Convert a 1 input value to a mubi output

Parameters:

val (logic)

Return type:

mubi12_t

mubi12_or(mubi12_t a, mubi12_t b, mubi12_t act)

Performs a logical OR operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | act !act | act | act act | act | act

Parameters:
Return type:

mubi12_t

mubi12_or_hi(mubi12_t a, mubi12_t b)

Performs a logical OR operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi12_t

mubi12_or_lo(mubi12_t a, mubi12_t b)

Performs a logical OR operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi12_t

mubi12_test_false_loose(mubi12_t val)

Test whether the multibit value signals a "disabled" condition. The loose version of this function interprets all values other than True as "disabled".

Parameters:

val (mubi12_t)

mubi12_test_false_strict(mubi12_t val)

Test whether the multibit value signals a "disabled" condition. The strict version of this function requires the multibit value to equal False.

Parameters:

val (mubi12_t)

mubi12_test_invalid(mubi12_t val)

Test whether the multibit value is one of the valid enumerations

Parameters:

val (mubi12_t)

mubi12_test_true_loose(mubi12_t val)

Test whether the multibit value signals an "enabled" condition. The loose version of this function interprets all values other than False as "enabled".

Parameters:

val (mubi12_t)

mubi12_test_true_strict(mubi12_t val)

Test whether the multibit value signals an "enabled" condition. The strict version of this function requires the multibit value to equal True.

Parameters:

val (mubi12_t)

mubi16_and(mubi16_t a, mubi16_t b, mubi16_t act)

Performs a logical AND operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | !act !act | act | !act act | act | act

Parameters:
Return type:

mubi16_t

mubi16_and_hi(mubi16_t a, mubi16_t b)

Performs a logical AND operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi16_t

mubi16_and_lo(mubi16_t a, mubi16_t b)

Performs a logical AND operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi16_t

mubi16_bool_to_mubi(logic val)

Convert a 1 input value to a mubi output

Parameters:

val (logic)

Return type:

mubi16_t

mubi16_or(mubi16_t a, mubi16_t b, mubi16_t act)

Performs a logical OR operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | act !act | act | act act | act | act

Parameters:
Return type:

mubi16_t

mubi16_or_hi(mubi16_t a, mubi16_t b)

Performs a logical OR operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi16_t

mubi16_or_lo(mubi16_t a, mubi16_t b)

Performs a logical OR operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi16_t

mubi16_test_false_loose(mubi16_t val)

Test whether the multibit value signals a "disabled" condition. The loose version of this function interprets all values other than True as "disabled".

Parameters:

val (mubi16_t)

mubi16_test_false_strict(mubi16_t val)

Test whether the multibit value signals a "disabled" condition. The strict version of this function requires the multibit value to equal False.

Parameters:

val (mubi16_t)

mubi16_test_invalid(mubi16_t val)

Test whether the multibit value is one of the valid enumerations

Parameters:

val (mubi16_t)

mubi16_test_true_loose(mubi16_t val)

Test whether the multibit value signals an "enabled" condition. The loose version of this function interprets all values other than False as "enabled".

Parameters:

val (mubi16_t)

mubi16_test_true_strict(mubi16_t val)

Test whether the multibit value signals an "enabled" condition. The strict version of this function requires the multibit value to equal True.

Parameters:

val (mubi16_t)

mubi20_and(mubi20_t a, mubi20_t b, mubi20_t act)

Performs a logical AND operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | !act !act | act | !act act | act | act

Parameters:
Return type:

mubi20_t

mubi20_and_hi(mubi20_t a, mubi20_t b)

Performs a logical AND operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi20_t

mubi20_and_lo(mubi20_t a, mubi20_t b)

Performs a logical AND operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi20_t

mubi20_bool_to_mubi(logic val)

Convert a 1 input value to a mubi output

Parameters:

val (logic)

Return type:

mubi20_t

mubi20_or(mubi20_t a, mubi20_t b, mubi20_t act)

Performs a logical OR operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | act !act | act | act act | act | act

Parameters:
Return type:

mubi20_t

mubi20_or_hi(mubi20_t a, mubi20_t b)

Performs a logical OR operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi20_t

mubi20_or_lo(mubi20_t a, mubi20_t b)

Performs a logical OR operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi20_t

mubi20_test_false_loose(mubi20_t val)

Test whether the multibit value signals a "disabled" condition. The loose version of this function interprets all values other than True as "disabled".

Parameters:

val (mubi20_t)

mubi20_test_false_strict(mubi20_t val)

Test whether the multibit value signals a "disabled" condition. The strict version of this function requires the multibit value to equal False.

Parameters:

val (mubi20_t)

mubi20_test_invalid(mubi20_t val)

Test whether the multibit value is one of the valid enumerations

Parameters:

val (mubi20_t)

mubi20_test_true_loose(mubi20_t val)

Test whether the multibit value signals an "enabled" condition. The loose version of this function interprets all values other than False as "enabled".

Parameters:

val (mubi20_t)

mubi20_test_true_strict(mubi20_t val)

Test whether the multibit value signals an "enabled" condition. The strict version of this function requires the multibit value to equal True.

Parameters:

val (mubi20_t)

mubi24_and(mubi24_t a, mubi24_t b, mubi24_t act)

Performs a logical AND operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | !act !act | act | !act act | act | act

Parameters:
Return type:

mubi24_t

mubi24_and_hi(mubi24_t a, mubi24_t b)

Performs a logical AND operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi24_t

mubi24_and_lo(mubi24_t a, mubi24_t b)

Performs a logical AND operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi24_t

mubi24_bool_to_mubi(logic val)

Convert a 1 input value to a mubi output

Parameters:

val (logic)

Return type:

mubi24_t

mubi24_or(mubi24_t a, mubi24_t b, mubi24_t act)

Performs a logical OR operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | act !act | act | act act | act | act

Parameters:
Return type:

mubi24_t

mubi24_or_hi(mubi24_t a, mubi24_t b)

Performs a logical OR operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi24_t

mubi24_or_lo(mubi24_t a, mubi24_t b)

Performs a logical OR operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi24_t

mubi24_test_false_loose(mubi24_t val)

Test whether the multibit value signals a "disabled" condition. The loose version of this function interprets all values other than True as "disabled".

Parameters:

val (mubi24_t)

mubi24_test_false_strict(mubi24_t val)

Test whether the multibit value signals a "disabled" condition. The strict version of this function requires the multibit value to equal False.

Parameters:

val (mubi24_t)

mubi24_test_invalid(mubi24_t val)

Test whether the multibit value is one of the valid enumerations

Parameters:

val (mubi24_t)

mubi24_test_true_loose(mubi24_t val)

Test whether the multibit value signals an "enabled" condition. The loose version of this function interprets all values other than False as "enabled".

Parameters:

val (mubi24_t)

mubi24_test_true_strict(mubi24_t val)

Test whether the multibit value signals an "enabled" condition. The strict version of this function requires the multibit value to equal True.

Parameters:

val (mubi24_t)

mubi28_and(mubi28_t a, mubi28_t b, mubi28_t act)

Performs a logical AND operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | !act !act | act | !act act | act | act

Parameters:
Return type:

mubi28_t

mubi28_and_hi(mubi28_t a, mubi28_t b)

Performs a logical AND operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi28_t

mubi28_and_lo(mubi28_t a, mubi28_t b)

Performs a logical AND operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi28_t

mubi28_bool_to_mubi(logic val)

Convert a 1 input value to a mubi output

Parameters:

val (logic)

Return type:

mubi28_t

mubi28_or(mubi28_t a, mubi28_t b, mubi28_t act)

Performs a logical OR operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | act !act | act | act act | act | act

Parameters:
Return type:

mubi28_t

mubi28_or_hi(mubi28_t a, mubi28_t b)

Performs a logical OR operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi28_t

mubi28_or_lo(mubi28_t a, mubi28_t b)

Performs a logical OR operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi28_t

mubi28_test_false_loose(mubi28_t val)

Test whether the multibit value signals a "disabled" condition. The loose version of this function interprets all values other than True as "disabled".

Parameters:

val (mubi28_t)

mubi28_test_false_strict(mubi28_t val)

Test whether the multibit value signals a "disabled" condition. The strict version of this function requires the multibit value to equal False.

Parameters:

val (mubi28_t)

mubi28_test_invalid(mubi28_t val)

Test whether the multibit value is one of the valid enumerations

Parameters:

val (mubi28_t)

mubi28_test_true_loose(mubi28_t val)

Test whether the multibit value signals an "enabled" condition. The loose version of this function interprets all values other than False as "enabled".

Parameters:

val (mubi28_t)

mubi28_test_true_strict(mubi28_t val)

Test whether the multibit value signals an "enabled" condition. The strict version of this function requires the multibit value to equal True.

Parameters:

val (mubi28_t)

mubi32_and(mubi32_t a, mubi32_t b, mubi32_t act)

Performs a logical AND operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | !act !act | act | !act act | act | act

Parameters:
Return type:

mubi32_t

mubi32_and_hi(mubi32_t a, mubi32_t b)

Performs a logical AND operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi32_t

mubi32_and_lo(mubi32_t a, mubi32_t b)

Performs a logical AND operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi32_t

mubi32_bool_to_mubi(logic val)

Convert a 1 input value to a mubi output

Parameters:

val (logic)

Return type:

mubi32_t

mubi32_or(mubi32_t a, mubi32_t b, mubi32_t act)

Performs a logical OR operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | act !act | act | act act | act | act

Parameters:
Return type:

mubi32_t

mubi32_or_hi(mubi32_t a, mubi32_t b)

Performs a logical OR operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi32_t

mubi32_or_lo(mubi32_t a, mubi32_t b)

Performs a logical OR operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi32_t

mubi32_test_false_loose(mubi32_t val)

Test whether the multibit value signals a "disabled" condition. The loose version of this function interprets all values other than True as "disabled".

Parameters:

val (mubi32_t)

mubi32_test_false_strict(mubi32_t val)

Test whether the multibit value signals a "disabled" condition. The strict version of this function requires the multibit value to equal False.

Parameters:

val (mubi32_t)

mubi32_test_invalid(mubi32_t val)

Test whether the multibit value is one of the valid enumerations

Parameters:

val (mubi32_t)

mubi32_test_true_loose(mubi32_t val)

Test whether the multibit value signals an "enabled" condition. The loose version of this function interprets all values other than False as "enabled".

Parameters:

val (mubi32_t)

mubi32_test_true_strict(mubi32_t val)

Test whether the multibit value signals an "enabled" condition. The strict version of this function requires the multibit value to equal True.

Parameters:

val (mubi32_t)

mubi4_and(mubi4_t a, mubi4_t b, mubi4_t act)

Performs a logical AND operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | !act !act | act | !act act | act | act

Parameters:
Return type:

mubi4_t

mubi4_and_hi(mubi4_t a, mubi4_t b)

Performs a logical AND operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi4_t

mubi4_and_lo(mubi4_t a, mubi4_t b)

Performs a logical AND operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi4_t

mubi4_bool_to_mubi(logic val)

Convert a 1 input value to a mubi output

Parameters:

val (logic)

Return type:

mubi4_t

mubi4_or(mubi4_t a, mubi4_t b, mubi4_t act)

Performs a logical OR operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | act !act | act | act act | act | act

Parameters:
Return type:

mubi4_t

mubi4_or_hi(mubi4_t a, mubi4_t b)

Performs a logical OR operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi4_t

mubi4_or_lo(mubi4_t a, mubi4_t b)

Performs a logical OR operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi4_t

mubi4_test_false_loose(mubi4_t val)

Test whether the multibit value signals a "disabled" condition. The loose version of this function interprets all values other than True as "disabled".

Parameters:

val (mubi4_t)

mubi4_test_false_strict(mubi4_t val)

Test whether the multibit value signals a "disabled" condition. The strict version of this function requires the multibit value to equal False.

Parameters:

val (mubi4_t)

mubi4_test_invalid(mubi4_t val)

Test whether the multibit value is one of the valid enumerations

Parameters:

val (mubi4_t)

mubi4_test_true_loose(mubi4_t val)

Test whether the multibit value signals an "enabled" condition. The loose version of this function interprets all values other than False as "enabled".

Parameters:

val (mubi4_t)

mubi4_test_true_strict(mubi4_t val)

Test whether the multibit value signals an "enabled" condition. The strict version of this function requires the multibit value to equal True.

Parameters:

val (mubi4_t)

mubi8_and(mubi8_t a, mubi8_t b, mubi8_t act)

Performs a logical AND operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | !act !act | act | !act act | act | act

Parameters:
Return type:

mubi8_t

mubi8_and_hi(mubi8_t a, mubi8_t b)

Performs a logical AND operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi8_t

mubi8_and_lo(mubi8_t a, mubi8_t b)

Performs a logical AND operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi8_t

mubi8_bool_to_mubi(logic val)

Convert a 1 input value to a mubi output

Parameters:

val (logic)

Return type:

mubi8_t

mubi8_or(mubi8_t a, mubi8_t b, mubi8_t act)

Performs a logical OR operation between two multibit values. This treats "act" as logical 1, and all other values are treated as 0. Truth table:

A | B | OUT ------+------+----- !act | !act | !act act | !act | act !act | act | act act | act | act

Parameters:
Return type:

mubi8_t

mubi8_or_hi(mubi8_t a, mubi8_t b)

Performs a logical OR operation between two multibit values. This treats "True" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi8_t

mubi8_or_lo(mubi8_t a, mubi8_t b)

Performs a logical OR operation between two multibit values. This treats "False" as logical 1, and all other values are treated as 0.

Parameters:
Return type:

mubi8_t

mubi8_test_false_loose(mubi8_t val)

Test whether the multibit value signals a "disabled" condition. The loose version of this function interprets all values other than True as "disabled".

Parameters:

val (mubi8_t)

mubi8_test_false_strict(mubi8_t val)

Test whether the multibit value signals a "disabled" condition. The strict version of this function requires the multibit value to equal False.

Parameters:

val (mubi8_t)

mubi8_test_invalid(mubi8_t val)

Test whether the multibit value is one of the valid enumerations

Parameters:

val (mubi8_t)

mubi8_test_true_loose(mubi8_t val)

Test whether the multibit value signals an "enabled" condition. The loose version of this function interprets all values other than False as "enabled".

Parameters:

val (mubi8_t)

mubi8_test_true_strict(mubi8_t val)

Test whether the multibit value signals an "enabled" condition. The strict version of this function requires the multibit value to equal True.

Parameters:

val (mubi8_t)