rggen 0.3.0

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

@@ -0,0 +1,205 @@
+list_item :bit_field, :type do
+  register_map do
+    item_base 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
+
+        attr_setter :required_width
+
+        def full_width
+          :full_width
+        end
+
+        def need_initial_value
+          @need_initial_value = true
+        end
+
+        def need_initial_value?
+          @need_initial_value || false
+        end
+
+        def use_reference(options = {})
+          @use_reference      = true
+          @reference_options  = options
+        end
+
+        attr_reader :reference_options
+
+        def use_reference?
+          @use_reference || false
+        end
+
+        def same_width
+          :same_width
+        end
+      end
+
+      field :type
+      field :readable?  , forward_to_helper: true
+      field :writable?  , forward_to_helper: true
+      field :read_only? , forward_to_helper: true
+      field :write_only?, forward_to_helper: true
+      field :reserved?  , forward_to_helper: true
+
+      class_delegator :full_width
+      class_delegator :need_initial_value?
+      class_delegator :use_reference?
+      class_delegator :reference_options
+      class_delegator :same_width
+
+      build do |cell|
+        @type = cell.to_sym.downcase
+      end
+
+      validate do
+        case
+        when width_mismatch?
+          error "#{required_width} bit(s) width required:" \
+                " #{bit_field.width} bit(s)"
+        when need_initial_value? && no_initial_value?
+          error 'no initial value'
+        when required_refercne_not_exist?
+          error 'reference bit field required'
+        when reference_width_mismatch?
+          error "#{required_reference_width} bit(s) reference bit field" \
+                " required: #{bit_field.reference.width}"
+        end
+      end
+
+      def width_mismatch?
+        return false if required_width.nil?
+        if required_width.respond_to?(:include?)
+          required_width.not.include?(bit_field.width)
+        else
+          bit_field.width != required_width
+        end
+      end
+
+      def required_width
+        width = self.class.required_width
+        return nil if width.nil?
+        return configuration.data_width if width == full_width
+        width
+      end
+
+      def no_initial_value?
+        !bit_field.initial_value?
+      end
+
+      def required_refercne_not_exist?
+        return false unless use_reference?
+        return false unless reference_options[:required]
+        return false if bit_field.has_reference?
+        true
+      end
+
+      def reference_width_mismatch?
+        return false unless use_reference?
+        return false unless bit_field.has_reference?
+        bit_field.reference.width != required_reference_width
+      end
+
+      def required_reference_width
+        return 1 unless reference_options[:width]
+        return bit_field.width if reference_options[:width] == same_width
+        reference_options[:width]
+      end
+    end
+
+    factory do
+      def select_target_item(cell)
+        type  = cell.value.to_sym.downcase
+        @target_items.fetch(type) do
+          error "unknown bit field type: #{type}", cell
+        end
+      end
+    end
+  end
+
+  rtl do
+    item_base do
+      build do
+        next if bit_field.reserved?
+        logic :value, name: value_name, width: width, dimensions: dimensions
+      end
+
+      def value_name
+        "#{bit_field.name}_value"
+      end
+
+      delegate [:dimensions                          ] => :register
+      delegate [:width                               ] => :bit_field
+      delegate [:index, :local_index, :loop_variables] => :register
+    end
+
+    default_item do
+    end
+
+    factory do
+      def select_target_item(_, bit_field)
+        @target_items[bit_field.type]
+      end
+    end
+  end
+
+  ral do
+    item_base do
+      export :access
+
+      define_helpers do
+        attr_setter :access
+      end
+
+      def access
+        string((self.class.access || bit_field.type).to_s.upcase)
+      end
+    end
+
+    default_item do
+    end
+
+    factory do
+      def select_target_item(_, bit_field)
+        @target_items[bit_field.type]
+      end
+    end
+  end
+end

data/lib/rggen/builtins/bit_field/wo.rb

@@ -0,0 +1,5 @@
+list_item :bit_field, :type, :wo do
+  register_map do
+    write_only
+  end
+end

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

@@ -0,0 +1,17 @@
+simple_item :global, :address_width do
+  configuration do
+    field :address_width, default: 32
+
+    build do |width|
+      begin
+        @address_width  = Integer(width)
+      rescue
+        error "invalid value for address width: #{width.inspect}"
+      end
+
+      unless @address_width.positive?
+        error "zero/negative address width is not allowed: #{@address_width}"
+      end
+    end
+  end
+end

data/lib/rggen/builtins/global/data_width.rb

@@ -0,0 +1,20 @@
+simple_item :global, :data_width do
+  configuration do
+    field :data_width, default: 32
+    field :byte_width do
+      data_width / 8
+    end
+
+    build do |width|
+      begin
+        @data_width = Integer(width)
+      rescue
+        error "invalid value for data width: #{width.inspect}"
+      end
+
+      unless @data_width >= 8 && @data_width.pow2?
+        error "under 8/non-power of 2 data width is not allowed: #{@data_width}"
+      end
+    end
+  end
+end

data/lib/rggen/builtins/loaders/configuration/json_loader.rb

@@ -0,0 +1,7 @@
+loader :configuration, :json do
+  require 'json'
+
+  def load_file(file)
+    JSON.parse(File.read(file))
+  end
+end

data/lib/rggen/builtins/loaders/configuration/yaml_loader.rb

@@ -0,0 +1,7 @@
+loader :configuration, [:yml, :yaml] do
+  require 'yaml'
+
+  def load_file(file)
+    YAML.load_file(file)
+  end
+end

data/lib/rggen/builtins/loaders/register_map/csv_loader.rb

@@ -0,0 +1,14 @@
+loader :register_map, [:csv, :tsv] do
+  require 'csv'
+
+  def load_file(file)
+    create_map(file) do |map|
+      sheet_name      = File.basename(file, '.*')
+      map[sheet_name] = CSV.read(file, col_sep: separator(file))
+    end
+  end
+
+  def separator(file)
+    (File.ext(file) == 'csv') ? ',' : "\t"
+  end
+end

data/lib/rggen/builtins/loaders/register_map/xls_loader.rb

@@ -0,0 +1,19 @@
+loader :register_map, :xls do
+  require 'spreadsheet'
+
+  def load_file(file)
+    create_map(file) do |map|
+      load_spreadsheet(file).each do |worksheet|
+        map[worksheet.name] = worksheet.rows
+      end
+    end
+  end
+
+  def load_spreadsheet(file)
+    Spreadsheet.open(file, 'rb') do |book|
+      book.worksheets.select do |worksheet|
+        worksheet.row_count > 0
+      end
+    end
+  end
+end

data/lib/rggen/builtins/loaders/register_map/xlsx_ods_loader.rb

@@ -0,0 +1,24 @@
+loader :register_map, [:xlsx, :ods] do
+  require 'roo'
+
+  def load_file(file)
+    create_map(file) do |map|
+      load_spreadsheet(file).each do |sheet_name, sheet|
+        map[sheet_name] = sheet
+      end
+    end
+  end
+
+  def load_spreadsheet(file)
+    sheets  = {}
+    Roo::Spreadsheet.open(file).each_with_pagename do |sheet_name, sheet|
+      next unless sheet.first_row
+      sheets[sheet_name]  = 1.upto(sheet.last_row).map do |row|
+        1.upto(sheet.last_column).map do |column|
+          sheet.cell(row, column)
+        end
+      end
+    end
+    sheets
+  end
+end

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

@@ -0,0 +1,23 @@
+simple_item :register, :accessibility do
+  register_map do
+    field :readable? do
+      register.bit_fields.any?(&:readable?)
+    end
+
+    field :writable? do
+      register.bit_fields.any?(&:writable?)
+    end
+
+    field :read_only? do
+      readable? && !writable?
+    end
+
+    field :write_only? do
+      writable? && !readable?
+    end
+
+    field :reserved? do
+      register.bit_fields.all?(&:reserved?)
+    end
+  end
+end

data/lib/rggen/builtins/register/address_decoder.erb

@@ -0,0 +1,16 @@
+rggen_address_decoder #(
+  .READABLE           (<%= readable %>),
+  .WRITABLE           (<%= writable %>),
+  .ADDRESS_WIDTH      (<%= local_address_width - address_lsb %>),
+  .START_ADDRESS      (<%= start_address%>),
+  .END_ADDRESS        (<%= end_address %>),
+  .USE_SHADOW_INDEX   (<%= use_shadow_index %>),
+  .SHADOW_INDEX_WIDTH (<%= shadow_index_width %>),
+  .SHADOW_INDEX_VALUE (<%= shadow_index_value %>)
+) u_<%= register.name%>_address_decoder (
+  .i_read         (<%= register_block.host_if.read %>),
+  .i_write        (<%= register_block.host_if.write %>),
+  .i_address      (<%= register_block.host_if.address[local_address_width - 1, address_lsb] %>),
+  .i_shadow_index (<%= (shadow? && shadow_index[loop_variables]) || shadow_index_value %>),
+  .o_select       (<%= register_block.register_select[register.index] %>)
+);

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

@@ -0,0 +1,92 @@
+simple_item :register, :address_decoder do
+  rtl do
+    build do
+      next unless register.shadow?
+      logic :shadow_index,
+            name:       "#{register.name}_shadow_index",
+            width:      shadow_index_width,
+            dimensions: register.dimensions
+    end
+
+    generate_code :module_item do |buffer|
+      buffer << shadow_index_assignment << nl if shadow?
+      buffer << process_template
+    end
+
+    delegate [:local_address_width] => :register_block
+    delegate [:array?, :shadow?, :multiple?] => :register
+    delegate [:shadow_indexes, :loop_variables] => :register
+
+    def readable
+      ((register.readable? || register.reserved?) && 1) || 0
+    end
+
+    def writable
+      ((register.writable? || register.reserved?) && 1) || 0
+    end
+
+    def address_lsb
+      Math.clog2(configuration.byte_width)
+    end
+
+    def start_address
+      address_code(register.start_address)
+    end
+
+    def end_address
+      if array?
+        address = register.start_address + configuration.byte_width - 1
+        address_code(address)
+      else
+        address_code(register.end_address)
+      end
+    end
+
+    def address_code(address)
+      shift = address_lsb
+      base  = hex(address >> shift, local_address_width - shift)
+      (array? && multiple? && "#{base} + #{register.local_index}") || base
+    end
+
+    def shadow_index_assignment
+      assign(
+        shadow_index[register.loop_variables],
+        concat(*shadow_index_fields.map(&:value))
+      )
+    end
+
+    def use_shadow_index
+      (shadow? && 1) || 0
+    end
+
+    def shadow_index_width
+      return 1 unless shadow?
+      shadow_index_fields.map(&:width).sum(0)
+    end
+
+    def shadow_index_value
+      return hex(0, 1) unless shadow?
+      concat(*shadow_index_values)
+    end
+
+    def shadow_index_fields
+      @shadow_index_fields ||= shadow_indexes.map do |index|
+        register_block.bit_fields.find do |bit_field|
+          bit_field.name == index.name
+        end
+      end
+    end
+
+    def shadow_index_values
+      variables = loop_variables
+      shadow_indexes.map.with_index do |index, i|
+        if index.value
+          hex(index.value, shadow_index_fields[i].width)
+        else
+          loop_variable = variables.shift
+          loop_variable[shadow_index_fields[i].width - 1, 0]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+simple_item :register, :array do
+  register_map do
+    field :array?
+    field :dimensions
+    field :count
+
+    input_pattern %r{\[(#{number}(?:,#{number})*)\]},
+                  match_automatically: false
+
+    build do |cell|
+      @dimensions = parse_array_dimensions(cell)
+      @array      = @dimensions.not_nil?
+      @count      = (@dimensions && @dimensions.inject(&:*)) || 1
+      if @dimensions && @dimensions.any?(&:zero?)
+        error "0 is not allowed for array dimension: #{cell.inspect}"
+      end
+    end
+
+    validate do
+      case
+      when multi_dimensions_array_with_real_register?
+        error 'not use multi dimensions array with real register'
+      when mismatch_with_own_byte_size?
+        error "mismatches with own byte size(#{register.byte_size}):" \
+              " #{dimensions}"
+      end
+    end
+
+    def parse_array_dimensions(cell)
+      case
+      when cell.nil? || cell.empty?
+        nil
+      when pattern_match(cell)
+        captures.first.split(',').map(&method(:Integer))
+      else
+        error "invalid value for array dimension: #{cell.inspect}"
+      end
+    end
+
+    def multi_dimensions_array_with_real_register?
+      return false unless array?
+      return false if register.shadow?
+      register.multiple? && dimensions.size > 1
+    end
+
+    def mismatch_with_own_byte_size?
+      return false unless array?
+      return false if register.shadow?
+      register.byte_size != dimensions.first * configuration.byte_width
+    end
+  end
+
+  rtl do
+    export :index
+    export :local_index
+    export :loop_variables
+    export :loop_variable
+
+    def index
+      (register.array? && "#{base_index}+#{local_index}") || base_index
+    end
+
+    def local_index
+      return nil unless register.array?
+      local_index_terms(0).join('+')
+    end
+
+    def loop_variables
+      return nil unless register.array?
+      Array.new(register.dimensions.size) { |l| loop_variable(l) }
+    end
+
+    def loop_variable(level)
+      return nil unless register.array? && level < register.dimensions.size
+      @loop_variables ||= Hash.new do |h, l|
+        h[l]  = create_identifier("g_#{loop_index(l)}")
+      end
+      @loop_variables[level]
+    end
+
+    def base_index
+      previous_registers.map(&:count).sum(0)
+    end
+
+    def local_index_terms(level)
+      if level < (register.dimensions.size - 1)
+        partial_count = register.dimensions[(level + 1)..-1].inject(:*)
+        term          = [partial_count, '*', loop_variable(level)].join
+        local_index_terms(level + 1).unshift(term)
+      else
+        [loop_variable(level)]
+      end
+    end
+
+    def previous_registers
+      register_block.registers.take_while { |r| !register.equal?(r) }
+    end
+
+    generate_pre_code :module_item do |buffer|
+      register.dimensions.each_with_index do |dimension, level|
+        generate_for_begin_code(dimension, level, buffer)
+      end if register.array?
+    end
+
+    generate_post_code :module_item do |buffer|
+      register.dimensions.size.times do
+        generate_for_end_code(buffer)
+      end if register.array?
+    end
+
+    def generate_for_begin_code(dimension, level, buffer)
+      buffer << generate_for_header(dimension, level)
+      buffer << ' begin : '
+      buffer << block_name(level)
+      buffer << nl
+      buffer.indent += 2
+    end
+
+    def generate_for_end_code(buffer)
+      buffer.indent -= 2
+      buffer << 'end' << nl
+    end
+
+    def generate_for_header(dimension, level)
+      genvar  = loop_variable(level)
+      "for (genvar #{genvar} = 0;#{genvar} < #{dimension};#{genvar}++)"
+    end
+
+    def block_name(level)
+      "gen_#{register.name}_#{level}"
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+simple_item :register, :field_model_creator do
+  ral do
+    generate_code :reg_model_item do
+      function_definition :create_fields do |f|
+        f.return_type :void
+        f.body { register.generate_code(:field_model_creation, :top_down) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+simple_item :register, :field_model_declarations do
+  ral do
+    generate_code :reg_model_item do |buffer|
+      register.generate_code(:field_model_declaration, :top_down, buffer)
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+simple_item :register, :name do
+  register_map do
+    field :name
+
+    input_pattern %r{(#{variable_name})}
+
+    build do |cell|
+      @name = parse_name(cell)
+      error "repeated register name: #{@name}" if repeated_name?
+    end
+
+    def parse_name(cell)
+      if pattern_matched?
+        captures.first
+      else
+        error "invalid value for register name: #{cell.inspect}"
+      end
+    end
+
+    def repeated_name?
+      register_block.registers.any? do |register|
+        @name == register.name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+simple_item :register, :offset_address do
+  register_map do
+    field :start_address
+    field :end_address
+    field :byte_size do
+      end_address - start_address + 1
+    end
+    field :single? do
+      byte_size == configuration.byte_width
+    end
+    field :multiple? do
+      byte_size > configuration.byte_width
+    end
+
+    input_pattern %r{(#{number})(?:-(#{number}))?}
+
+    build do |cell|
+      @start_address, @end_address  = parse_address(cell)
+      case
+      when @start_address >= @end_address
+        error "start address is equal to or greater than end address: #{cell}"
+      when unaligned_address?
+        error 'not aligned with data width' \
+              "(#{configuration.data_width}): #{cell}"
+      when @end_address > max_address
+        error 'exceeds the maximum offset address' \
+              "(0x#{max_address.to_s(16)}): #{cell}"
+      end
+    end
+
+    def parse_address(cell)
+      if pattern_matched?
+        addresses = captures.compact.map(&method(:Integer))
+        if addresses.size == 2
+          addresses
+        else
+          [addresses[0], addresses[0] + configuration.byte_width - 1]
+        end
+      else
+        error "invalid value for offset address: #{cell.inspect}"
+      end
+    end
+
+    def unaligned_address?
+      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 max_address
+      register_block.byte_size - 1
+    end
+  end
+end