rggen 0.8.2 → 0.9.0

data/lib/rggen/built_in/bit_field/comment.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:bit_field, :comment) do
+  register_map do
+    property :comment, body: -> { @comment ||= '' }
+
+    build do |value|
+      @comment =
+        if value.is_a?(Array)
+          value.join("\n")
+        else
+          value.to_s
+        end
+    end
+  end
+end

data/lib/rggen/built_in/bit_field/initial_value.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:bit_field, :initial_value) do
+  register_map do
+    property :initial_value, default: 0
+    property :initial_value?, body: -> { !@initial_value.nil? }
+
+    build do |value|
+      @initial_value =
+        begin
+          Integer(value)
+        rescue ArgumentError, TypeError
+          error "cannot convert #{value.inspect} into initial value"
+        end
+    end
+
+    verify(:component) do
+      error_condition { initial_value? && initial_value < min_initial_value }
+      message do
+        'input initial value is less than minimum initial value: ' \
+        "initial value #{initial_value} " \
+        "minimum initial value #{min_initial_value}"
+      end
+    end
+
+    verify(:component) do
+      error_condition { initial_value? && initial_value > max_initial_value }
+      message do
+        'input initial value is greater than maximum initial value: ' \
+        "initial value #{initial_value} " \
+        "maximum initial value #{max_initial_value}"
+      end
+    end
+
+    private
+
+    def min_initial_value
+      bit_field.width == 1 ? 0 : -(2**(bit_field.width - 1))
+    end
+
+    def max_initial_value
+      2**bit_field.width - 1
+    end
+  end
+end

data/lib/rggen/built_in/bit_field/name.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:bit_field, :name) do
+  register_map do
+    property :name
+    property :full_name, forward_to: :get_full_name
+
+    input_pattern variable_name
+
+    build do |value|
+      @name =
+        if pattern_matched?
+          match_data.to_s
+        else
+          error "illegal input value for bit field name: #{value.inspect}"
+        end
+    end
+
+    verify(:feature) do
+      error_condition { !name }
+      message { 'no bit field name is given' }
+    end
+
+    verify(:feature) do
+      error_condition { duplicated_name? }
+      message { "duplicated bit field name: #{name}" }
+    end
+
+    private
+
+    def get_full_name(separator = '.')
+      [register.name, name].join(separator)
+    end
+
+    def duplicated_name?
+      register.bit_fields.any? { |bit_field| bit_field.name == name }
+    end
+  end
+end

data/lib/rggen/built_in/bit_field/reference.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:bit_field, :reference) do
+  register_map do
+    property :reference, forward_to: :reference_bit_field, verify: :all
+    property :reference?, body: -> { !@input_reference.nil? }
+    property :find_reference, forward_to: :find_reference_bit_field
+
+    input_pattern /(#{variable_name})\.(#{variable_name})/
+
+    build do |value|
+      @input_reference =
+        if pattern_matched?
+          "#{match_data[1]}.#{match_data[2]}"
+        else
+          error "illegal input value for reference: #{value.inspect}"
+        end
+    end
+
+    verify(:component) do
+      error_condition { reference? && @input_reference == bit_field.full_name }
+      message { "self reference: #{@input_reference}" }
+    end
+
+    verify(:all) do
+      error_condition { reference? && !reference_bit_field }
+      message { "no such bit field found: #{@input_reference}" }
+    end
+
+    verify(:all) do
+      error_condition do
+        reference? && !register.array? && reference_bit_field.register.array?
+      end
+      message do
+        'bit field of array register is not allowed for ' \
+        "reference bit field: #{@input_reference}"
+      end
+    end
+
+    verify(:all) do
+      error_condition { reference? && !match_array_size? }
+      message do
+        'array size is not matched: ' \
+        "own #{register.array_size} " \
+        "reference #{reference_bit_field.register.array_size}"
+      end
+    end
+
+    verify(:all) do
+      error_condition do
+        reference? && !bit_field.sequential? && reference_bit_field.sequential?
+      end
+      message do
+        'sequential bit field is not allowed for ' \
+        "reference bit field: #{@input_reference}"
+      end
+    end
+
+    verify(:all) do
+      error_condition { reference? && !match_sequence_size? }
+      message do
+        'sequence size is not matched: ' \
+        "own #{bit_field.sequence_size} " \
+        "reference #{reference_bit_field.sequence_size}"
+      end
+    end
+
+    verify(:all) do
+      error_condition { reference? && reference_bit_field.reserved? }
+      message { "refer to reserved bit field: #{@input_reference}" }
+    end
+
+    private
+
+    def reference_bit_field
+      (reference? || nil) &&
+        (@reference_bit_field ||= lookup_reference)
+    end
+
+    def find_reference_bit_field(bit_fields)
+      (reference? || nil) &&
+        bit_fields
+          .find { |bit_field| bit_field.full_name == @input_reference }
+    end
+
+    def lookup_reference
+      find_reference_bit_field(register_block.bit_fields)
+    end
+
+    def match_array_size?
+      !(register.array? && reference_bit_field.register.array?) ||
+        register.array_size == reference_bit_field.register.array_size
+    end
+
+    def match_sequence_size?
+      !(bit_field.sequential? && reference_bit_field.sequential?) ||
+        bit_field.sequence_size == reference_bit_field.sequence_size
+    end
+  end
+end

data/lib/rggen/built_in/bit_field/sv_rtl_top.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:bit_field, :sv_rtl_top) do
+  sv_rtl do
+    export :local_index
+    export :loop_variables
+    export :array_size
+    export :value
+
+    build do
+      interface :bit_field, :bit_field_sub_if, {
+        name: 'bit_field_sub_if',
+        interface_type: 'rggen_bit_field_if',
+        parameter_values: [bit_field.width]
+      }
+    end
+
+    main_code :register do
+      local_scope("g_#{bit_field.name}") do |scope|
+        scope.loop_size loop_size
+        scope.variables variables
+        scope.body(&method(:body_code))
+      end
+    end
+
+    pre_code :bit_field do |code|
+      code << bit_field_if_connection << nl
+    end
+
+    def local_index
+      (bit_field.sequential? || nil) &&
+        create_identifier(index_name)
+    end
+
+    def index_name
+      depth = (register.loop_variables&.size || 0) + 1
+      loop_index(depth)
+    end
+
+    def loop_variables
+      (inside_loop? || nil) &&
+        [*register.loop_variables, local_index].compact
+    end
+
+    def array_size
+      (inside_loop? || nil) &&
+        [*register.array_size, bit_field.sequence_size].compact
+    end
+
+    def value(register_offset = nil, bit_field_offset = nil)
+      register_block
+        .register_if[register.index(register_offset)]
+        .value[bit_field.lsb(bit_field_offset || local_index), bit_field.width]
+    end
+
+    private
+
+    def inside_loop?
+      register.array? || bit_field.sequential?
+    end
+
+    def loop_size
+      (bit_field.sequential? || nil) &&
+        { index_name => bit_field.sequence_size }
+    end
+
+    def variables
+      bit_field.declarations(:bit_field, :variable)
+    end
+
+    def body_code(code)
+      bit_field.generate_code(:bit_field, :top_down, code)
+    end
+
+    def bit_field_if_connection
+      macro_call(
+        :rggen_connect_bit_field_if,
+        [
+          register.bit_field_if,
+          bit_field.bit_field_sub_if,
+          bit_field.lsb(local_index),
+          bit_field.width
+        ]
+      )
+    end
+  end
+end

data/lib/rggen/built_in/bit_field/type.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+RgGen.define_list_feature(:bit_field, :type) do
+  register_map do
+    base_feature do
+      define_helpers do
+        def read_write
+          @readable = true
+          @writable = true
+        end
+
+        def read_only
+          @readable = true
+          @writable = false
+        end
+
+        def write_only
+          @readable = false
+          @writable = true
+        end
+
+        def reserved
+          @readable = false
+          @writable = false
+        end
+
+        def readable?
+          @readable.nil? || @readable
+        end
+
+        def writable?
+          @writable.nil? || @writable
+        end
+
+        def volatile
+          @volatile = true
+        end
+
+        def non_volatile
+          @volatile = false
+        end
+
+        def volatile?
+          @volatile.nil? || @volatile
+        end
+
+        def need_initial_value(**options)
+          @initial_value_options = options.merge(needed: true)
+        end
+
+        attr_reader :initial_value_options
+
+        def use_reference(**options)
+          @reference_options = options.merge(usable: true)
+        end
+
+        attr_reader :reference_options
+      end
+
+      property :type
+      property :readable?, forward_to_helper: true
+      property :writable?, forward_to_helper: true
+      property :read_only?, body: -> { readable? && !writable? }
+      property :write_only?, body: -> { writable? && !readable? }
+      property :reserved?, body: -> { !(readable? || writable?) }
+      property :volatile?, forward_to_helper: true
+
+      build { |value| @type = value }
+
+      verify(:component) do
+        error_condition { no_initial_value_given? }
+        message { 'no initial value is given' }
+      end
+
+      verify(:component) do
+        error_condition do
+          bit_field.initial_value? && not_match_initial_value?
+        end
+        message do
+          "value 0x#{required_initial_value.to_s(16)} is only allowed for " \
+          "initial value: 0x#{bit_field.initial_value.to_s(16)}"
+        end
+      end
+
+      verify(:component) do
+        error_condition { no_reference_bit_field_given? }
+        message { 'no reference bit field is given' }
+      end
+
+      verify(:all) do
+        error_condition { invalid_reference_width? }
+        message do
+          "#{reference_width} bit(s) reference bit field is required: " \
+          "#{bit_field.reference.full_name} " \
+          "#{bit_field.reference.width} bit(s)"
+        end
+      end
+
+      private
+
+      def no_initial_value_given?
+        helper.initial_value_options&.key?(:needed) &&
+          !bit_field.initial_value?
+      end
+
+      def not_match_initial_value?
+        helper.initial_value_options&.key?(:value) &&
+          bit_field.initial_value != required_initial_value
+      end
+
+      def required_initial_value
+        value = helper.initial_value_options[:value]
+        if value.is_a?(Proc)
+          instance_exec(&value)
+        else
+          value
+        end
+      end
+
+      def no_reference_bit_field_given?
+        use_reference? &&
+          helper.reference_options[:required] &&
+          !bit_field.reference?
+      end
+
+      def invalid_reference_width?
+        use_reference? &&
+          bit_field.reference? &&
+          bit_field.reference.width != reference_width
+      end
+
+      def use_reference?
+        helper.reference_options&.key?(:usable)
+      end
+
+      def reference_width
+        helper.reference_options[:width] || bit_field.width
+      end
+    end
+
+    default_feature do
+      verify(:feature) do
+        error_condition { !type }
+        message { 'no bit field type is given' }
+      end
+
+      verify(:feature) do
+        error_condition { type }
+        message { "unknown bit field type: #{type.inspect}" }
+      end
+    end
+
+    factory do
+      convert_value do |value|
+        types = target_features.keys
+        types.find(&value.to_sym.method(:casecmp?)) || value
+      end
+
+      def select_feature(cell)
+        target_features[cell.value]
+      end
+    end
+  end
+
+  sv_rtl do
+    base_feature do
+      private
+
+      def array_port_format
+        configuration.array_port_format
+      end
+
+      def full_name
+        bit_field.full_name('_')
+      end
+
+      def initial_value
+        hex(bit_field.initial_value, bit_field.width)
+      end
+
+      def mask
+        reference_bit_field ||
+          hex(2**bit_field.width - 1, bit_field.width)
+      end
+
+      def reference_bit_field
+        bit_field
+          .find_reference(register_block.bit_fields)
+          &.value(register.local_index, bit_field.local_index)
+      end
+    end
+
+    factory do
+      def select_feature(_configuration, bit_field)
+        target_features[bit_field.type]
+      end
+    end
+  end
+
+  sv_ral do
+    base_feature do
+      define_helpers do
+        attr_setter :access
+
+        def model_name(name = nil, &block)
+          @model_name = name || block || @model_name
+          @model_name
+        end
+      end
+
+      export :access
+      export :model_name
+      export :constructors
+
+      build do
+        variable :register, :ral_model, {
+          name: bit_field.name,
+          data_type: model_name,
+          array_size: array_size,
+          random: true
+        }
+      end
+
+      def access
+        (helper.access || bit_field.type).to_s.upcase
+      end
+
+      def model_name
+        if helper.model_name&.is_a?(Proc)
+          instance_eval(&helper.model_name)
+        else
+          helper.model_name || :rggen_ral_field
+        end
+      end
+
+      def constructors
+        (bit_field.sequence_size&.times || [nil]).map do |index|
+          macro_call(
+            :rggen_ral_create_field_model, arguments(index)
+          )
+        end
+      end
+
+      private
+
+      def array_size
+        Array(bit_field.sequence_size)
+      end
+
+      def arguments(index)
+        [
+          ral_model[index], bit_field.lsb(index), bit_field.width,
+          access, volatile, reset_value, valid_reset
+        ]
+      end
+
+      def volatile
+        bit_field.volatile? && 1 || 0
+      end
+
+      def reset_value
+        hex(bit_field.initial_value, bit_field.width)
+      end
+
+      def valid_reset
+        bit_field.initial_value? && 1 || 0
+      end
+    end
+
+    default_feature do
+    end
+
+    factory do
+      def select_feature(_configuration, bit_field)
+        target_features[bit_field.type]
+      end
+    end
+  end
+end