rggen-default-register-map 0.13.0

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:bit_field, :reference) do
+  register_map do
+    property :reference, initial: -> { reference_bit_field }, verify: :all
+    property :reference?, body: -> { use_reference? && !no_reference? }
+    property :reference_width, forward_to: :required_width
+    property :find_reference, forward_to: :find_reference_bit_field
+
+    input_pattern [
+      /(#{variable_name})\.(#{variable_name})/,
+      /(#{variable_name})/
+    ]
+
+    build do |value|
+      @input_reference =
+        if pattern_matched?
+          match_data[1..2].compact.join('.')
+        else
+          error "illegal input value for reference: #{value.inspect}"
+        end
+    end
+
+    verify(:component) do
+      error_condition { require_reference? && no_reference? }
+      message { 'no reference bit field is given' }
+    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
+
+    verify(:all) do
+      error_condition { reference? && !match_width? }
+      message do
+        "#{required_width} bits reference bit field is required: " \
+        "#{reference_bit_field.width} bit(s) width"
+      end
+    end
+
+    private
+
+    def settings
+      @settings ||=
+        (bit_field.settings && bit_field.settings[:reference]) || {}
+    end
+
+    def use_reference?
+      settings.fetch(:use, false)
+    end
+
+    def require_reference?
+      use_reference? && settings[:require]
+    end
+
+    def no_reference?
+      @input_reference.nil?
+    end
+
+    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
+
+    def required_width
+      settings[:width] || bit_field.width
+    end
+
+    def match_width?
+      reference_bit_field.width >= required_width
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# 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 read_only?
+          readable? && !writable?
+        end
+
+        def write_only?
+          writable? && !readable?
+        end
+
+        def reserved?
+          !(readable? || writable?)
+        end
+
+        def volatile
+          @volatility = -> { true }
+        end
+
+        def non_volatile
+          @volatility = -> { false }
+        end
+
+        def volatile?(&block)
+          @volatility = block
+        end
+
+        attr_reader :volatility
+
+        def settings
+          @settings ||= {}
+        end
+
+        def initial_value(**setting)
+          settings[:initial_value] = setting
+        end
+
+        def reference(**setting)
+          settings[:reference] = setting
+        end
+      end
+
+      property :type
+      property :settings, forward_to_helper: true
+      property :readable?, forward_to_helper: true
+      property :writable?, forward_to_helper: true
+      property :read_only?, forward_to_helper: true
+      property :write_only?, forward_to_helper: true
+      property :reserved?, forward_to_helper: true
+      property :volatile?, initial: -> { volatility }
+
+      build { |value| @type = value }
+
+      printable :type
+
+      private
+
+      def volatility
+        helper.volatility.nil? || instance_exec(&helper.volatility)
+      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
+end

data/lib/rggen/default_register_map/bit_field/type/rc.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, :rc) do
+  register_map do
+    read_only
+    reference use: true
+    initial_value require: true
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/reserved.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, :reserved) do
+  register_map do
+    reserved
+    non_volatile
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/ro.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, :ro) do
+  register_map do
+    read_only
+    reference use: true
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/rof.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, :rof) do
+  register_map do
+    read_only
+    non_volatile
+    initial_value require: true
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/rs.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, :rs) do
+  register_map do
+    read_only
+    initial_value require: true
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/rw.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, :rw) do
+  register_map do
+    read_write
+    non_volatile
+    initial_value require: true
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/rwc.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, :rwc) do
+  register_map do
+    read_write
+    initial_value require: true
+    reference use: true, width: 1
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/rwe_rwl.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, [:rwe, :rwl]) do
+  register_map do
+    read_write
+    volatile? { !bit_field.reference? }
+    initial_value require: true
+    reference use: true, width: 1
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/w0c_w1c.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, [:w0c, :w1c]) do
+  register_map do
+    read_write
+    reference use: true
+    initial_value require: true
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/w0s_w1s.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, [:w0s, :w1s]) do
+  register_map do
+    read_write
+    initial_value require: true
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/w0trg_w1trg.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, [:w0trg, :w1trg]) do
+  register_map do
+    write_only
+    non_volatile
+  end
+end

data/lib/rggen/default_register_map/bit_field/type/wo.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RgGen.define_list_item_feature(:bit_field, :type, :wo) do
+  register_map do
+    write_only
+    non_volatile
+    initial_value require: true
+  end
+end

data/lib/rggen/default_register_map/global/address_width.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:global, :address_width) do
+  configuration do
+    property :address_width, default: 32
+
+    build do |value|
+      @address_width =
+        begin
+          Integer(value)
+        rescue ArgumentError, TypeError
+          error "cannot convert #{value.inspect} into address width"
+        end
+    end
+
+    verify(:component) do
+      error_condition { address_width < min_address_width }
+      message do
+        'input address width is less than minimum address width: ' \
+        "address width #{address_width} " \
+        "minimum address width #{min_address_width}"
+      end
+    end
+
+    printable :address_width
+
+    private
+
+    def min_address_width
+      byte_width = configuration.byte_width
+      byte_width == 1 ? 1 : (byte_width - 1).bit_length
+    end
+  end
+end

data/lib/rggen/default_register_map/global/bus_width.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+RgGen.define_simple_feature(:global, :bus_width) do
+  configuration do
+    property :bus_width, default: 32
+    property :byte_width, initial: -> { bus_width / 8 }
+
+    build do |value|
+      @bus_width =
+        begin
+          Integer(value)
+        rescue ArgumentError, TypeError
+          error "cannot convert #{value.inspect} into bus width"
+        end
+    end
+
+    verify(:feature) do
+      error_condition { bus_width < 8 }
+      message { "input bus width is less than 8: #{bus_width}" }
+    end
+
+    verify(:feature) do
+      error_condition { !power_of_2?(bus_width) }
+      message { "input bus width is not power of 2: #{bus_width}" }
+    end
+
+    printable :bus_width
+
+    private
+
+    def power_of_2?(value)
+      value.positive? && (value & value.pred).zero?
+    end
+  end
+end