rggen 0.3.0

data/lib/rggen/builtins/register/read_data.rb

@@ -0,0 +1,36 @@
+simple_item :register, :read_data do
+  rtl do
+    generate_code :module_item do |buffer|
+      buffer  << assign(register_read_data, read_data) << nl
+    end
+
+    def register_read_data
+      register_block.register_read_data[register.index]
+    end
+
+    def read_data
+      if register.readable?
+        concat(*read_data_expressions)
+      else
+        hex(0, configuration.data_width)
+      end
+    end
+
+    def read_data_expressions
+      last_lsb    = configuration.data_width
+      expressions = []
+      readable_fields.each do |field|
+        padding_bits  = last_lsb - field.msb - 1
+        last_lsb      = field.lsb
+        expressions << hex(0, padding_bits) if padding_bits > 0
+        expressions << field.value[register.loop_variables]
+      end
+      expressions << hex(0, last_lsb) if last_lsb > 0
+      expressions
+    end
+
+    def readable_fields
+      register.bit_fields.select(&:readable?).sort_by(&:msb).reverse
+    end
+  end
+end

data/lib/rggen/builtins/register/reg_model_constructor.rb

@@ -0,0 +1,17 @@
+simple_item :register, :reg_model_constructor do
+  ral do
+    generate_code :reg_model_item do
+      function_definition :new do |f|
+        f.arguments [
+          argument(:name, data_type: :string, default: string(register.name))
+        ]
+        f.body { "super.new(name, #{bits}, 0);" }
+      end
+    end
+
+    def bits
+      max_msb = register.bit_fields.map(&:msb).max
+      ((max_msb + 8) / 8) * 8
+    end
+  end
+end

data/lib/rggen/builtins/register/reg_model_creation.rb

@@ -0,0 +1,64 @@
+simple_item :register, :reg_model_creation do
+  ral do
+    delegate [:byte_width] => :configuration
+    delegate [:local_address_width] => :register_block
+    delegate [:name, :dimensions, :array?, :shadow?] => :register
+
+    generate_code :reg_model_creation  do |buffer|
+      foreach_header(buffer) if array?
+      model_creation(buffer)
+      foreach_footer(buffer) if array?
+    end
+
+    def foreach_header(buffer)
+      buffer << "foreach (#{name}[#{loop_varibles.join(', ')}]) begin" << nl
+      buffer.indent += 2
+    end
+
+    def model_creation(buffer)
+      buffer << "`rggen_ral_create_reg_model(#{arguments.join(', ')})" << nl
+    end
+
+    def foreach_footer(buffer)
+      buffer.indent -= 2
+      buffer << 'end' << nl
+    end
+
+    def arguments
+      [handle, string(name), array_index, offset_address, rights, unmapped]
+    end
+
+    def handle
+      create_identifier(name)[loop_varibles]
+    end
+
+    def array_index
+      return '\'{}' unless array?
+      array(*loop_varibles)
+    end
+
+    def offset_address
+      base  = hex(register.start_address, local_address_width)
+      if !array? || shadow?
+        base
+      else
+        "#{base} + #{byte_width} * #{loop_varibles.first}"
+      end
+    end
+
+    def rights
+      return string(:RO) if register.read_only?
+      return string(:WO) if register.write_only?
+      string(:RW)
+    end
+
+    def unmapped
+      (shadow? && 1) || 0
+    end
+
+    def loop_varibles
+      return nil unless array?
+      @loop_varibles ||= Array.new(dimensions.size, &method(:loop_index))
+    end
+  end
+end

data/lib/rggen/builtins/register/reg_model_declaration.rb

@@ -0,0 +1,13 @@
+simple_item :register, :reg_model_declaration do
+  ral do
+    delegate [:model_name, :name, :dimensions] => :register
+
+    generate_code :reg_model_declaration do |buffer|
+      buffer << declaration << semicolon << nl
+    end
+
+    def declaration
+      model_declaration(model_name, name, dimensions: dimensions)
+    end
+  end
+end

data/lib/rggen/builtins/register/reg_model_definition.rb

@@ -0,0 +1,22 @@
+simple_item :register, :reg_model_definition do
+  ral do
+    export :model_name
+
+    generate_code :package_item do
+      class_definition model_name do |c|
+        c.base base_model
+        c.body do |buffer|
+          register.generate_code(:reg_model_item, :top_down, buffer)
+        end
+      end
+    end
+
+    def model_name
+      "#{register.name}_reg_model"
+    end
+
+    def base_model
+      (register.shadow? && :rggen_ral_shadow_reg) || :rggen_ral_reg
+    end
+  end
+end

data/lib/rggen/builtins/register/shadow.rb

@@ -0,0 +1,130 @@
+simple_item :register, :shadow do
+  register_map do
+    ShadowIndexEntry  = Struct.new(:name, :value) do
+      def initialize(name, value)
+        self.name   = name
+        self.value  = value && Integer(value)
+      end
+
+      def ==(other)
+        return false unless name == other.name
+        return true if [value, other.value].any?(&:nil?)
+        value == other.value
+      end
+    end
+
+    field :shadow?
+    field :shadow_indexes
+
+    input_pattern %r{(#{variable_name})(?::(#{number}))?}
+
+    build do |cell|
+      @shadow_indexes = parse_shadow_indexes(cell)
+      @shadow         = @shadow_indexes.not_nil?
+    end
+
+    validate do
+      next unless shadow?
+      check_using_shadow_register_only
+      check_index_fields
+      check_size_of_array_index_fields
+      check_array_index_values
+      check_specific_value_index_values
+    end
+
+    def parse_shadow_indexes(cell)
+      return nil if cell.nil? || cell.empty?
+      cell.split(/[,\n]/).map do |entry|
+        if pattern_match(entry)
+          ShadowIndexEntry.new(captures[0], captures[1])
+        else
+          error "invalid value for shadow index: #{cell.inspect}"
+        end
+      end
+    end
+
+    def check_using_shadow_register_only
+      return unless register.multiple? && register.array?
+      error 'not use real array and shadow register on the same register'
+    end
+
+    def check_index_fields
+      shadow_indexes.each do |entry|
+        case
+        when use_same_index_field_more_than_once?(entry.name)
+          error "not use the same index field more than once: #{entry.name}"
+        when not_find_shadow_index_field?(entry)
+          error "no such shadow index field: #{entry.name}"
+        when use_own_bit_field?(entry)
+          error 'own bit field is specified for shadow index field:' \
+                " #{entry.name}"
+        when use_arrayed_bit_field?(entry)
+          error 'arrayed bit field is specified for shadow index field:' \
+                " #{entry.name}"
+        end
+      end
+    end
+
+    def use_same_index_field_more_than_once?(name)
+      shadow_indexes.count { |entry| entry.name == name } > 1
+    end
+
+    def not_find_shadow_index_field?(entry)
+      shadow_index_bit_field[entry.name].nil?
+    end
+
+    def use_own_bit_field?(entry)
+      register.bit_fields.map(&:name).include?(entry.name)
+    end
+
+    def use_arrayed_bit_field?(entry)
+      shadow_index_bit_field[entry.name].register.array?
+    end
+
+    def check_size_of_array_index_fields
+      return if size_of_dimensions == array_indexes.size
+      error 'not match number of array dimensions and' \
+            ' number of array index fields'
+    end
+
+    def check_array_index_values
+      array_indexes.each_with_index do |entry, i|
+        next if register.dimensions[i] <= (maximum_value(entry.name) + 1)
+        error "exceeds maximum array size specified by #{entry.name}" \
+              "(#{maximum_value(entry.name) + 1}): #{register.dimensions[i]}"
+      end
+    end
+
+    def check_specific_value_index_values
+      specific_value_indexes.each do |entry|
+        next if entry.value <= maximum_value(entry.name)
+        error "exceeds maximum value of #{entry.name}" \
+              "(#{maximum_value(entry.name)}): #{entry.value}"
+      end
+    end
+
+    def size_of_dimensions
+      (register.array? && register.dimensions.size) || 0
+    end
+
+    def array_indexes
+      shadow_indexes.select { |entry| entry.value.nil? }
+    end
+
+    def specific_value_indexes
+      shadow_indexes.select { |entry| entry.value.not_nil? }
+    end
+
+    def maximum_value(index_name)
+      2**shadow_index_bit_field[index_name].width - 1
+    end
+
+    def shadow_index_bit_field
+      @shadow_index_bit_field ||= Hash.new do |hash, index_name|
+        hash[index_name]  = register_block.bit_fields.find do |bit_field|
+          bit_field.name == index_name && !bit_field.reserved?
+        end
+      end
+    end
+  end
+end

data/lib/rggen/builtins/register/shadow_index_configurator.rb

@@ -0,0 +1,53 @@
+simple_item :register, :shadow_index_configurator do
+  ral do
+    generate_code :reg_model_item do
+      function_definition :configure_shadow_indexes do |f|
+        f.return_type :void
+        f.body { |code| function_body(code) }
+      end if register.shadow?
+    end
+
+    def function_body(code)
+      register.shadow_indexes.each do |shadow_index|
+        code << "set_shadow_index(#{arguments(shadow_index)});" << nl
+      end
+    end
+
+    def arguments(shadow_index)
+      [
+        parent_name(shadow_index),
+        index_name(shadow_index),
+        index_value(shadow_index)
+      ].join(', ')
+    end
+
+    def parent_name(shadow_index)
+      parent_register = fild_parent_register(shadow_index.name)
+      string(parent_register.name)
+    end
+
+    def fild_parent_register(index_name)
+      index_field = register_block.bit_fields.find do |bit_field|
+        bit_field.name == index_name
+      end
+      index_field.register
+    end
+
+    def index_name(shadow_index)
+      string(shadow_index.name)
+    end
+
+    def index_value(shadow_index)
+      if shadow_index.value
+        shadow_index.value
+      else
+        "indexes[#{array_index}]"
+      end
+    end
+
+    def array_index
+      @array_index  ||= -1
+      @array_index  += 1
+    end
+  end
+end

data/lib/rggen/builtins/register/uniqueness_validator.rb

@@ -0,0 +1,48 @@
+simple_item :register, :uniqueness_validator do
+  register_map do
+    validate do
+      previous_registers.each do |previous_register|
+        validate_uniqueness(previous_register)
+      end
+    end
+
+    def previous_registers
+      register_block.registers.take_while { |r| !r.equal?(register) }
+    end
+
+    def validate_uniqueness(previous_register)
+      case
+      when overlap_offset_address?(previous_register)
+        error 'offset address is not unique', error_position(:start_address)
+      when overlap_shadow_indexes?(previous_register)
+        error 'shadow indexes is not unique', error_position(:shadow_indexes)
+      end
+    end
+
+    def overlap_offset_address?(previous_register)
+      return false if [previous_register, register].all?(&:shadow?)
+      overlap_address_range?(register, previous_register)
+    end
+
+    def overlap_address_range?(lhs, rhs)
+      lhs_range = lhs.start_address..lhs.end_address
+      rhs_range = rhs.start_address..rhs.end_address
+      lhs_range.overlap?(rhs_range)
+    end
+
+    def overlap_shadow_indexes?(previous_register)
+      return false unless overlap_address_range?(register, previous_register)
+      return true  unless unique_shadw_indexes?(register, previous_register)
+      return true  unless unique_shadw_indexes?(previous_register, register)
+      false
+    end
+
+    def unique_shadw_indexes?(lhs, rhs)
+      lhs.shadow_indexes.any?(&rhs.shadow_indexes.method(:exclude?))
+    end
+
+    def error_position(field)
+      register.items.find { |i| i.fields.include?(field) }.position
+    end
+  end
+end

data/lib/rggen/builtins/register_block/apb.erb

@@ -0,0 +1,27 @@
+rggen_host_if_apb #(
+  .DATA_WIDTH           (<%= configuration.data_width %>),
+  .HOST_ADDRESS_WIDTH   (<%= configuration.address_width %>),
+  .LOCAL_ADDRESS_WIDTH  (<%= register_block.local_address_width %>)
+) u_host_if (
+  .clk              (<%= register_block.clock %>),
+  .rst_n            (<%= register_block.reset %>),
+  .i_paddr          (<%= apb.paddr %>),
+  .i_pprot          (<%= apb.pprot %>),
+  .i_psel           (<%= apb.psel %>),
+  .i_penable        (<%= apb.penable %>),
+  .i_pwrite         (<%= apb.pwrite %>),
+  .i_pwdata         (<%= apb.pwdata %>),
+  .i_pstrb          (<%= apb.pstrb %>),
+  .o_pready         (<%= apb.pready %>),
+  .o_prdata         (<%= apb.prdata %>),
+  .o_pslverr        (<%= apb.pslverr %>),
+  .o_command_valid  (<%= host_if.command_valid %>),
+  .o_write          (<%= host_if.write %>),
+  .o_read           (<%= host_if.read %>),
+  .o_address        (<%= host_if.address %>),
+  .o_write_data     (<%= host_if.write_data %>),
+  .o_write_mask     (<%= host_if.write_mask %>),
+  .i_response_ready (<%= host_if.response_ready %>),
+  .i_read_data      (<%= host_if.read_data %>),
+  .i_status         (<%= host_if.status %>)
+);

data/lib/rggen/builtins/register_block/apb.rb

@@ -0,0 +1,20 @@
+list_item :register_block, :host_if, :apb do
+  rtl do
+    build do
+      group(:apb) do
+        input  :paddr  , name: 'i_paddr'  , width: configuration.address_width
+        input  :pprot  , name: 'i_pprot'  , width: 3
+        input  :psel   , name: 'i_psel'   , width: 1
+        input  :penable, name: 'i_penable', width: 1
+        input  :pwrite , name: 'i_pwrite' , width: 1
+        input  :pwdata , name: 'i_pwdata' , width: configuration.data_width
+        input  :pstrb  , name: 'i_pstrb'  , width: configuration.byte_width
+        output :pready , name: 'o_pready' , width: 1
+        output :prdata , name: 'o_prdata' , width: configuration.data_width
+        output :pslverr, name: 'o_pslverr', width: 1
+      end
+    end
+
+    generate_code_from_template :module_item
+  end
+end

data/lib/rggen/builtins/register_block/base_address.rb

@@ -0,0 +1,64 @@
+simple_item :register_block, :base_address do
+  register_map do
+    field :start_address
+    field :end_address
+    field :byte_size
+    field :local_address_width
+
+    input_pattern %r{(#{number})-(#{number})}
+
+    build do |cell|
+      parse_address(cell)
+      case
+      when @start_address >= @end_address
+        error "start address is equal to or greater than end address: #{cell}"
+      when not_aligned_with_data_width?
+        error 'not aligned with data width' \
+              "(#{configuration.data_width}): #{cell}"
+      when not_aligned_with_local_address_width?
+        error 'not aligned with local address width' \
+              "(#{@local_address_width}): #{cell}"
+      when @end_address > max_address
+        error 'exceeds the maximum base address' \
+              "(0x#{max_address.to_s(16)}): #{cell}"
+      when overlapped_address?
+        error "overlapped base address: #{cell}"
+      end
+    end
+
+    def parse_address(cell)
+      if pattern_matched?
+        @start_address        = Integer(captures[0])
+        @end_address          = Integer(captures[1])
+        @byte_size            = @end_address - @start_address + 1
+        @local_address_width  = Math.clog2(@byte_size) if @byte_size > 0
+      else
+        error "invalid value for base address: #{cell.inspect}"
+      end
+    end
+
+    def not_aligned_with_data_width?
+      byte_width  = configuration.byte_width
+      return true unless (@start_address + 0).multiple?(byte_width)
+      return true unless (@end_address   + 1).multiple?(byte_width)
+      false
+    end
+
+    def not_aligned_with_local_address_width?
+      window_size = 2**@local_address_width
+      return true unless @start_address.multiple?(window_size)
+      false
+    end
+
+    def max_address
+      2**configuration.address_width - 1
+    end
+
+    def overlapped_address?
+      own_range = @start_address..@end_address
+      register_map.register_blocks.any? do |block|
+        own_range.overlap?(block.start_address..block.end_address)
+      end
+    end
+  end
+end

data/lib/rggen/builtins/register_block/block_model_constructor.rb

@@ -0,0 +1,14 @@
+simple_item :register_block, :block_model_constructor do
+  ral do
+    delegate [:name] => :register_block
+
+    generate_code :block_model_item do
+      function_definition :new do |f|
+        f.arguments [
+          argument(:name, data_type: :string, default: string(name))
+        ]
+        f.body { 'super.new(name);' }
+      end
+    end
+  end
+end

data/lib/rggen/builtins/register_block/block_model_default_map_creator.rb

@@ -0,0 +1,39 @@
+simple_item :register_block, :block_model_default_map_creator do
+  ral do
+    generate_code :block_model_item do
+      function_definition :create_default_map do |f|
+        f.return_type :uvm_reg_map
+        f.body do |code|
+          code << :return
+          code << space
+          code << "create_map(#{arguments.join(', ')})"
+          code << semicolon
+        end
+      end
+    end
+
+    def arguments
+      [name, base_address, n_bytes, endian, byte_addressing]
+    end
+
+    def name
+      string(:default_map)
+    end
+
+    def base_address
+      0
+    end
+
+    def n_bytes
+      configuration.byte_width
+    end
+
+    def endian
+      :UVM_LITTLE_ENDIAN
+    end
+
+    def byte_addressing
+      1
+    end
+  end
+end

data/lib/rggen/builtins/register_block/block_model_definition.rb

@@ -0,0 +1,18 @@
+simple_item :register_block, :block_model_definition do
+  ral do
+    generate_code :package_item do
+      class_definition model_name do |c|
+        c.base :rggen_ral_block
+        c.body { |code| body_code(code) }
+      end
+    end
+
+    def model_name
+      "#{register_block.name}_block_model"
+    end
+
+    def body_code(code)
+      register_block.generate_code(:block_model_item, :top_down, code)
+    end
+  end
+end

data/lib/rggen/builtins/register_block/byte_size.rb

@@ -0,0 +1,37 @@
+simple_item :register_block, :byte_size do
+  register_map do
+    field :byte_size
+    field :local_address_width
+
+    build do |cell|
+      begin
+        @byte_size  = Integer(cell)
+      rescue
+        error "invalid value for byte size: #{cell.inspect}"
+      end
+
+      case
+      when @byte_size.not.positive?
+        error "zero or negative value is not allowed for byte size: #{cell}"
+      when @byte_size.not.multiple?(configuration.byte_width)
+        error 'not aligned with data width' \
+              "(#{configuration.data_width}): #{cell}"
+      when total_byte_size > upper_bound
+        error 'exceeds upper bound of total byte size' \
+              "(#{upper_bound}): #{total_byte_size}"
+      end
+
+      @local_address_width  = Math.clog2(@byte_size)
+    end
+
+    def upper_bound
+      2**configuration.address_width
+    end
+
+    def total_byte_size
+      register_map.register_blocks.inject(@byte_size) do |total, block|
+        total + block.byte_size
+      end
+    end
+  end
+end

data/lib/rggen/builtins/register_block/clock_reset.rb

@@ -0,0 +1,8 @@
+simple_item :register_block, :clock_reset do
+  rtl do
+    build do
+      input :clock, name: 'clk'  , width: 1
+      input :reset, name: 'rst_n', width: 1
+    end
+  end
+end

data/lib/rggen/builtins/register_block/host_if.rb

@@ -0,0 +1,46 @@
+list_item :register_block, :host_if do
+  shared_context do
+    attr_accessor :enabled_host_ifs
+  end
+
+  configuration do
+    item_class do
+      field :host_if do
+        @host_if || shared_context.enabled_host_ifs.first
+      end
+
+      build do |value|
+        @host_if  = shared_context.enabled_host_ifs.find do |host_if|
+          host_if.to_sym.casecmp(value.to_sym) == 0
+        end
+        error "unknown host interface: #{value}" if @host_if.nil?
+      end
+    end
+  end
+
+  rtl do
+    shared_context.enabled_host_ifs = @enabled_items
+
+    item_base do
+      build do
+        group(:host_if) do
+          logic :command_valid , width: 1
+          logic :write         , width: 1
+          logic :read          , width: 1
+          logic :address       , width: register_block.local_address_width
+          logic :write_data    , width: configuration.data_width
+          logic :write_mask    , width: configuration.data_width
+          logic :response_ready, width: 1
+          logic :read_data     , width: configuration.data_width
+          logic :status        , width: 2
+        end
+      end
+    end
+
+    factory do
+      def select_target_item(configuration, _register_block)
+        @target_items[configuration.host_if]
+      end
+    end
+  end
+end

data/lib/rggen/builtins/register_block/module_definition.rb

@@ -0,0 +1,13 @@
+define_simple_item :register_block, :module_definition do
+  rtl do
+    write_file '<%= register_block.name %>.sv' do
+      module_definition register_block.name do |m|
+        m.parameters register_block.parameter_declarations
+        m.ports      register_block.port_declarations
+        m.body do |code|
+          register_block.generate_code(:module_item, :top_down, code)
+        end
+      end
+    end
+  end
+end