rggen 0.8.2 → 0.9.0

data/lib/rggen/builtins/register/types/default.erb

@@ -1,10 +0,0 @@
-rggen_default_register #(
-  .ADDRESS_WIDTH  (<%= local_address_width %>),
-  .START_ADDRESS  (<%= start_address %>),
-  .END_ADDRESS    (<%= end_address %>),
-  .DATA_WIDTH     (<%= data_width %>),
-  .VALID_BITS     (<%= valid_bits %>)
-) u_register (
-  .register_if  (<%= register.register_if %>),
-  .bit_field_if (<%= bit_field_if %>)
-);

data/lib/rggen/builtins/register/types/external.erb

@@ -1,11 +0,0 @@
-rggen_external_register #(
-  .ADDRESS_WIDTH  (<%= local_address_width %>),
-  .START_ADDRESS  (<%= start_address %>),
-  .END_ADDRESS    (<%= end_address %>),
-  .DATA_WIDTH     (<%= configuration.data_width %>)
-) u_register (
-  .clk          (<%= register_block.clock %>),
-  .rst_n        (<%= register_block.reset %>),
-  .register_if  (<%= register.register_if %>),
-  .bus_if       (<%= bus_if %>)
-);

data/lib/rggen/builtins/register/types/external.rb

@@ -1,77 +0,0 @@
-list_item :register, :type, :external do
-  register_map do
-    read_write
-    required_byte_size any_size
-    need_no_bit_fields
-  end
-
-  rtl do
-    delegate [:unfold_sv_interface_port?] => :configuration
-    delegate [:name] => :register
-
-    build do
-      if unfold_sv_interface_port?
-        output :register_block, :request,
-          name: "o_#{name}_request", data_type: :logic, width: 1
-        output :register_block, :address,
-          name: "o_#{name}_address", data_type: :logic, width: address_width
-        output :register_block, :direction,
-          name: "o_#{name}_direction", data_type: :logic, width: 1
-        output :register_block, :write_data,
-          name: "o_#{name}_write_data", data_type: :logic, width: data_width
-        output :register_block, :strobe,
-          name: "o_#{name}_strobe", data_type: :logic, width: data_width / 8
-        input :register_block, :done,
-          name: "i_#{name}_done", data_type: :logic, width: 1
-        input :register_block, :write_done,
-          name: "i_#{name}_write_done", data_type: :logic, width: 1
-        input :register_block, :read_done,
-          name: "i_#{name}_read_done", data_type: :logic, width: 1
-        input :register_block, :read_data,
-          name: "i_#{name}_read_data", data_type: :logic, width: data_width
-        input :register_block, :status,
-          name: "i_#{name}_status", data_type: :logic, width: 2
-        interface :register, :bus_if,
-          type: :rggen_bus_if, parameters: [address_width, data_width]
-
-      else
-          interface_port :register_block, :bus_if,
-            name: "#{name}_bus_if", type: :rggen_bus_if, modport: :master
-      end
-    end
-
-    def address_width
-      Math.clog2(address_range.end - address_range.begin + 1)
-    end
-
-    generate_code :register do |code|
-      unfold_sv_interface_port? && bus_if_assignment(code)
-      code << process_template
-    end
-
-    def bus_if_assignment(code)
-      code << assign(request   , "#{bus_if}.request"     ) << nl
-      code << assign(address   , "#{bus_if}.address"     ) << nl
-      code << assign(direction , "#{bus_if}.direction"   ) << nl
-      code << assign(write_data, "#{bus_if}.write_data"  ) << nl
-      code << assign(strobe    , "#{bus_if}.write_strobe") << nl
-      code << assign("#{bus_if}.done"      , done         ) << nl
-      code << assign("#{bus_if}.write_done", write_done   ) << nl
-      code << assign("#{bus_if}.read_done" , read_done    ) << nl
-      code << assign("#{bus_if}.read_data" , read_data    ) << nl
-      code << assign("#{bus_if}.status"    , casted_status) << nl
-    end
-
-    def casted_status
-      "rggen_rtl_pkg::rggen_status'(#{status})"
-    end
-  end
-
-  c_header do
-    delegate [:name, :byte_size] => :register
-
-    address_struct_member do
-      "RGGEN_EXTERNAL_REGISTERS(#{byte_size}, #{name.upcase}) #{name}"
-    end
-  end
-end

data/lib/rggen/builtins/register/types/indirect.erb

@@ -1,13 +0,0 @@
-rggen_indirect_register #(
-  .ADDRESS_WIDTH  (<%= local_address_width %>),
-  .START_ADDRESS  (<%= start_address %>),
-  .END_ADDRESS    (<%= end_address %>),
-  .INDEX_WIDTH    (<%= indirect_index_width %>),
-  .INDEX_VALUE    (<%= indirect_index_value %>),
-  .DATA_WIDTH     (<%= data_width %>),
-  .VALID_BITS     (<%= valid_bits %>)
-) u_register (
-  .register_if  (<%= register.register_if %>),
-  .bit_field_if (<%= bit_field_if %>),
-  .i_index      (<%= indirect_index %>)
-);

data/lib/rggen/builtins/register/types/indirect.rb

@@ -1,175 +0,0 @@
-list_item :register, :type, :indirect do
-  register_map do
-    field :indexes
-
-    readable? { register.bit_fields.any?(&:readable?) }
-    writable? { register.bit_fields.any?(&:writable?) }
-
-    need_options
-    support_array_register support_multiple_dimensions: true
-    required_byte_size data_width
-
-    input_pattern %r{(#{variable_name})(?::(#{number}))?}
-
-    define_struct :index_entry, [: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
-
-    build do |cell|
-      @indexes  = parse_indexes(cell.options.strip)
-    end
-
-    def parse_indexes(options)
-      options.split(/[,\n]/).map do |entry|
-        if pattern_match(entry)
-          index_entry.new(captures[0], captures[1])
-        else
-          error "invalid value for index: #{options.inspect}"
-        end
-      end
-    end
-
-    validate do
-      check_index_entries
-      check_number_of_array_indexes
-      check_array_index_values
-      check_fixed_value_index_values
-    end
-
-    def check_index_entries
-      indexes.each(&method(:check_index_entry))
-    end
-
-    def check_index_entry(entry)
-      [
-        :check_using_same_index_more_than_once,
-        :check_using_non_existing_index,
-        :check_using_own_bit_field_for_index,
-        :check_using_arrayed_bit_field_for_index
-      ].each { |checker| send(checker, entry) }
-    end
-
-    def check_using_same_index_more_than_once(entry)
-      return if indexes.one? { |index| index.name == entry.name }
-      error "not use the same index field more than once: #{entry.name}"
-    end
-
-    def check_using_non_existing_index(entry)
-      return unless index_bit_fields[entry.name].nil?
-      error "no such index field: #{entry.name}"
-    end
-
-    def check_using_own_bit_field_for_index(entry)
-      return unless register.bit_fields.find_by(name: entry.name)
-      error "not use own bit field for index field: #{entry.name}"
-    end
-
-    def check_using_arrayed_bit_field_for_index(entry)
-      return unless index_bit_fields[entry.name].register.array?
-      error "not use arrayed bit field for index field: #{entry.name}"
-    end
-
-    def check_number_of_array_indexes
-      return if array_indexes.size == size_of_dimensions
-      error 'not match size of array dimensions and number of array indexes'
-    end
-
-    def check_array_index_values
-      array_indexes.each_with_index do |entry, i|
-        next if register.dimensions[i] <= (max_value(entry.name) + 1)
-        error "array size(#{register.dimensions[i]}) is greater than " \
-              "maximum value of #{entry.name}(#{max_value(entry.name)})"
-      end
-    end
-
-    def check_fixed_value_index_values
-      fixed_value_indexes.each do |entry|
-        next if entry.value <= max_value(entry.name)
-        error "index value(#{entry.value}) is greater thatn " \
-              "maximum value of #{entry.name}(#{max_value(entry.name)})"
-      end
-    end
-
-    def index_bit_fields
-      @index_bit_fields ||= Hash.new do |h, name|
-        h[name] = register_block.bit_fields.find_by(
-          name: name, reserved?: false
-        )
-      end
-    end
-
-    def array_indexes
-      indexes.select { |entry| entry.value.nil? }
-    end
-
-    def fixed_value_indexes
-      indexes.select(&:value)
-    end
-
-    def size_of_dimensions
-      (register.array? && register.dimensions.size) || 0
-    end
-
-    def max_value(index_name)
-      2**index_bit_fields[index_name].width - 1
-    end
-  end
-
-  rtl do
-    build do
-      logic :register, :indirect_index, width: indirect_index_width
-    end
-
-    generate_code :register do |code|
-      code << indirect_index_assignment << nl
-      code << process_template
-    end
-
-    def indirect_index_fields
-      @indirect_index_fields  ||= register.indexes.map do |i|
-        register_block.bit_fields.find_by(name: i.name)
-      end
-    end
-
-    def indirect_index_assignment
-      assign(
-        indirect_index, concat(indirect_index_fields.map(&:value))
-      )
-    end
-
-    def indirect_index_width
-      indirect_index_fields.sum(0, &:width)
-    end
-
-    def indirect_index_value
-      concat(indirect_index_values)
-    end
-
-    def indirect_index_values
-      variables = loop_variables
-      register.indexes.map.with_index do |index, i|
-        if index.value
-          hex(index.value, indirect_index_fields[i].width)
-        else
-          variable  = variables.shift
-          variable[indirect_index_fields[i].width - 1, 0]
-        end
-      end
-    end
-  end
-
-  c_header do
-    address_struct_member do
-      variable_declaration(name: register.name, data_type: data_type)
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-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)
-      if overlap_offset_address?(previous_register)
-        error 'offset address is not unique', error_position(:start_address)
-      elsif overlap_indirect_indexes?(previous_register)
-        error 'indirect indexes is not unique', error_position(:indexes)
-      end
-    end
-
-    def overlap_offset_address?(previous_register)
-      return false if both_register_indirect?(previous_register)
-      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_indirect_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 both_register_indirect?(previous_register)
-      [register, previous_register].all? { |r| r.type?(:indirect) }
-    end
-
-    def unique_shadw_indexes?(lhs, rhs)
-      lhs.indexes.any?(&rhs.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/address_struct.rb

@@ -1,56 +0,0 @@
-simple_item :register_block, :address_struct do
-  c_header do
-    delegate [:data_width, :byte_width] => :configuration
-    delegate [:registers, :name] => :register_block
-
-    generate_code :c_header_item do
-      struct_definition(stuct_name) do |s|
-        s.with_typedef
-        s.members address_struct_members
-      end
-    end
-
-    def stuct_name
-      "s_#{name}_address_struct"
-    end
-
-    def address_struct_members
-      address_struct_entries.each_cons(2).with_object([]) do |entries, members|
-        dummy_size  = entries[1].start_address - entries[0].end_address - 1
-        members << dummy_member(dummy_size) if dummy_size > 0
-        members << entries[1].address_struct_member
-      end
-    end
-
-    def dummy_member(size)
-      variable_declaration(
-        data_type:  "rggen_uint#{data_width}",
-        name:       "__dummy_#{dummy_index}",
-        dimensions: [size / byte_width]
-      )
-    end
-
-    def dummy_index
-      @dummy_index ||= -1
-      @dummy_index += 1
-    end
-
-    def address_struct_entries
-      [].tap do |entries|
-        entries << dummy_entry
-        entries.concat(non_reserved_registers)
-      end
-    end
-
-    def dummy_entry
-      Object.new.tap do |dummy|
-        dummy.attr_singleton_accessor :end_address
-        dummy.end_address = -1
-      end
-    end
-
-    def non_reserved_registers
-      registers.reject(&:reserved?).sort_by(&:start_address)
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-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