reggae_eda 0.0.6

data/assets/uart_tx.vhd

@@ -0,0 +1,102 @@
+-- pong p.chu code.
+library ieee;
+use ieee.std_logic_1164.all;
+use ieee.numeric_std.all;
+entity uart_tx is
+  generic(
+    DBIT    : integer := 8;             -- # data bits
+    SB_TICK : integer := 16             -- # ticks for stop bits
+    );
+  port(
+    clk, reset_n   : in  std_logic;
+    tx_start     : in  std_logic;
+    s_tick       : in  std_logic;
+    din          : in  std_logic_vector(7 downto 0);
+    tx_done_tick : out std_logic;
+    tx           : out std_logic
+    );
+end uart_tx;
+
+architecture arch of uart_tx is
+  type state_type is (idle, start, data, stop);
+  signal state_reg, state_next : state_type;
+  signal s_reg, s_next         : unsigned(3 downto 0);
+  signal n_reg, n_next         : unsigned(2 downto 0);
+  signal b_reg, b_next         : std_logic_vector(7 downto 0);
+  signal tx_reg, tx_next       : std_logic;
+begin
+  -- FSMD state & data registers
+  process(clk, reset_n)
+  begin
+    if reset_n = '0' then
+      state_reg <= idle;
+      s_reg     <= (others => '0');
+      n_reg     <= (others => '0');
+      b_reg     <= (others => '0');
+      tx_reg    <= '1';
+    elsif (clk'event and clk = '1') then
+      state_reg <= state_next;
+      s_reg     <= s_next;
+      n_reg     <= n_next;
+      b_reg     <= b_next;
+      tx_reg    <= tx_next;
+    end if;
+  end process;
+  -- next-state logic & data path functional units/routing
+  process(state_reg, s_reg, n_reg, b_reg, s_tick,
+          tx_reg, tx_start, din)
+  begin
+    state_next   <= state_reg;
+    s_next       <= s_reg;
+    n_next       <= n_reg;
+    b_next       <= b_reg;
+    tx_next      <= tx_reg;
+    tx_done_tick <= '0';
+    case state_reg is
+      when idle =>
+        tx_next <= '1';
+        if tx_start = '1' then
+          state_next <= start;
+          s_next     <= (others => '0');
+          b_next     <= din;
+        end if;
+      when start =>
+        tx_next <= '0';
+        if (s_tick = '1') then
+          if s_reg = 15 then
+            state_next <= data;
+            s_next     <= (others => '0');
+            n_next     <= (others => '0');
+          else
+            s_next <= s_reg + 1;
+          end if;
+        end if;
+      when data =>
+        tx_next <= b_reg(0);
+        if (s_tick = '1') then
+          if s_reg = 15 then
+            s_next <= (others => '0');
+            b_next <= '0' & b_reg(7 downto 1);
+            if n_reg = (DBIT-1) then
+              state_next <= stop;
+            else
+              n_next <= n_reg + 1;
+            end if;
+          else
+            s_next <= s_reg + 1;
+          end if;
+        end if;
+      when stop =>
+        tx_next <= '1';
+        if (s_tick = '1') then
+          if s_reg = (SB_TICK-1) then
+            state_next   <= idle;
+            tx_done_tick <= '1';
+          else
+            s_next <= s_reg + 1;
+          end if;
+        end if;
+    end case;
+  end process;
+  tx <= tx_reg;
+end arch;

data/bin/reggae

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require_relative '../lib/reggae'
+
+reggae=Reggae::Compiler.new
+reggae.analyze_options ARGV
+reggae.compile

data/lib/reggae.rb

@@ -0,0 +1,3 @@
+require_relative 'reggae/compiler'
+module Reggae
+end

data/lib/reggae/ast.rb

@@ -0,0 +1,72 @@
+module Reggae
+
+  module Visitable
+    def accept(visitor, arg=nil)
+      name = self.class.name.split(/::/)[1]
+      visitor.send("visit#{name}".to_sym, self ,arg) # Metaprograming !
+    end
+  end
+
+  class MemoryMap < Struct.new(:name,:parameters,:zones,:comments)
+    include Visitable
+  end
+
+  class Comment < Struct.new(:txt)
+    include Visitable
+  end
+
+  class Parameters < Struct.new(:bus,:range)
+    include Visitable
+  end
+
+  class Bus < Struct.new(:frequency,:address_size,:data_size)
+    include Visitable
+  end
+
+  class Range < Struct.new(:from,:to)
+    include Visitable
+  end
+
+  class Zone < Struct.new(:name,:range,:registers,:subzones,:instances)
+    include Visitable
+  end
+
+  class Instance < Struct.new(:name,:mapping)
+    include Visitable
+  end
+
+  class Connect < Struct.new(:formal,:actual)
+    include Visitable
+  end
+
+  class Input < Struct.new(:name)
+    include Visitable
+  end
+
+  class Output < Struct.new(:name)
+    include Visitable
+  end
+
+  class RegSig < Struct.new(:name,:field)
+    include Visitable
+  end
+
+  class Subzone < Zone
+    include Visitable
+  end
+
+  class Register < Struct.new(:name,:address,:init,:sampling,:writable,:bits,:bitfields)
+    include Visitable
+    def bit(n)
+      @bits.find{|bit| bit.position==n}
+    end
+  end
+
+  class Bit < Struct.new(:position,:name,:purpose,:toggle)
+    include Visitable
+  end
+
+  class Bitfield < Bit
+    include Visitable
+  end
+end

data/lib/reggae/code.rb

@@ -0,0 +1,55 @@
+class Code
+
+  attr_accessor :indent,:code
+
+  def initialize indent=0
+    @code=[]
+    @indent=indent
+  end
+
+  def empty?
+    @code.size==0
+  end
+
+  def <<(str)
+    if str.is_a? Code
+      str.code.each do |line|
+        @code << " "*@indent+line
+      end
+    elsif str.nil?
+    else
+      @code << " "*@indent+str
+    end
+  end
+
+  def finalize dot=false
+    if dot
+      return @code.join('\n')
+    end
+    @code.join("\n")
+  end
+
+  def newline
+    @code << " "
+  end
+
+  def save_as filename,verbose=true
+    str=self.finalize
+    if filename.end_with? ".vhd"
+      str=clean_vhdl(str)
+    end
+    File.open(filename,'w'){|f| f.puts(str)}
+    puts "saved code in file #{filename}" if verbose
+    return filename
+  end
+
+  def size
+    @code.size
+  end
+
+  def clean_vhdl str
+    str1=str.gsub(/\;\s*\)/,")")
+    str2=str1.gsub(/\,\s*\)/,")")
+  end
+
+end

data/lib/reggae/compiler.rb

@@ -0,0 +1,110 @@
+require 'pp'
+require 'optparse'
+require_relative 'parser'
+require_relative 'pretty_printer'
+require_relative 'vhdl_generator'
+require_relative 'version'
+
+module Reggae
+
+  class Compiler
+
+    attr_accessor :ast
+
+    def initialize
+      puts "Reggae generator #{VERSION}"
+      @options={}
+    end
+
+    def analyze_options args
+      args << "-h" if args.empty?
+
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: reggae <filename.sexp>"
+
+        opts.on("-v", "--version", "Prints version") do
+          puts VERSION
+          abort
+        end
+
+        opts.on("-h", "--help", "Prints this help") do
+          puts
+          puts "Generates an IP-based system, from its memory-map expressed in s-expressions."
+          puts
+          puts "Author mail: jean-christophe.le_lann@ensta-bretagne.fr"
+          puts
+          @options[:show_help]=true
+          puts opts
+          abort
+        end
+
+        opts.on("-s", "--system", "Generates a top-level system") do
+          @options[:gen_system]=true
+        end
+
+        opts.on("-d","Shows VHDL generated in the terminal,during generation") do
+          @options[:show_code]=true
+        end
+
+        opts.on("-u", "--include_uart", "Generates an UART Master in the system top-level") do
+          @options[:include_uart]=true
+        end
+
+        opts.on("--gen_ruby", "Generates Ruby code to interact with the system from a PC host") do
+          @options[:gen_ruby]=true
+        end
+
+        opts.on("-x", "--gen_xdc", "Generates a Xilinx XDC constraint file for Artix7 FPGA (IP only)") do
+          @options[:gen_xdc]=true
+        end
+
+        opts.on("--from_vivado_hls", "Indicates that the sexp file is generated from VHDL_WRAP tuned for VivadoHLS") do
+          @options[:from_vivado_hls]=true
+        end
+      end
+
+      begin
+        opt_parser.parse!(args)
+      rescue Exception => e
+        puts e
+        #puts e.backtrace
+        exit
+      end
+      @filename = ARGV.pop
+      $dirname = File.dirname(@filename) if @filename
+      unless @filename or @options[:show_help]
+        puts "Need to specify a filename to process"
+        #exit
+      end
+    end
+
+    def compile
+      if @options.any?
+        puts
+        puts "running with the following options :"
+        pp @options
+        puts
+      end
+      @ast=parse(@filename)
+      #pretty_print
+      generate_vhdl
+    end
+
+    def parse filename
+      puts "=> parsing #{filename}"
+      $working_dir=Dir.pwd
+      @ast=Reggae::Parser.new.parse(filename)
+    end
+
+    def pretty_print
+      puts "=> pretty print..."
+      Reggae::Visitor.new.visit(ast)
+    end
+
+    def generate_vhdl
+      puts "=> generating VHDL..."
+      Reggae::VHDLGenerator.new(@options).generate_from(ast)
+    end
+  end
+
+end

data/lib/reggae/parser.rb

@@ -0,0 +1,281 @@
+require 'sxp'
+require 'pp'
+
+require_relative 'ast'
+
+class Array
+  def header
+    self.first
+  end
+end
+
+module Reggae
+
+  class Parser
+
+    def parse filename
+      str=IO.read(filename)
+      str=fix_sexpistol_bug(str)
+      mm_a=SXP.read(str)
+      parseMemoryMap(mm_a)
+    end
+
+    def fix_sexpistol_bug str
+      s1=str.gsub(/0x(\w+)/,'\1') #0x....
+      s2=s1.gsub(/(\d+)\.\.(\d+)/,'\1 \2') #range
+    end
+
+    def parseMemoryMap ary
+      mm=MemoryMap.new(nil,nil,[])
+      ary.shift
+      mm.name=ary.shift
+      while ary.any?
+        case h=ary.first.header
+        when :comment
+          mm.comments ||=[]
+          mm.comments << parseComment(ary.shift)
+        when :parameters
+          mm.parameters=parseParameters(ary.shift)
+        when :zone
+          mm.zones << parseZone(ary.shift)
+        else
+          raise "error.expecting 'zone' or 'parameters'. got a '#{h}'"
+        end
+      end
+      mm
+    end
+
+    def parseComment ary
+      comment=Comment.new(nil)
+      ary.shift
+      comment.txt=ary.shift
+      comment
+    end
+
+    def parseParameters ary
+      param=Parameters.new(nil,nil)
+      ary.shift
+      while ary.any?
+        case h=ary.first.header
+        when :bus
+          param.bus=parseBus(ary.shift)
+        when :range
+          param.range=parseRange(ary.shift)
+        else
+          raise "error.expecting 'bus' or 'range'. Got a '#{h}'"
+        end
+      end
+      @param=param
+      param
+    end
+
+    def parseBus ary
+      bus=Bus.new(nil,nil,nil)
+      ary.shift
+      while ary.any?
+        case h=ary.first.header
+        when :frequency
+          bus.frequency=ary.first.last.to_i
+        when :address_size
+          bus.address_size=ary.first.last.to_i
+        when :data_size
+          bus.data_size=ary.first.last.to_i
+        else
+          raise "error during parseBus. Expecting 'frequency','address_size' or 'data_size'. Got '#{h}'"
+        end
+        ary.shift
+      end
+      bus
+    end
+
+    def parseHexa sym
+      "0x#{sym}"
+    end
+
+    def parseRange ary
+      rg=Range.new(nil,nil)
+      rg.from=parseHexa(ary[1])
+      rg.to=parseHexa(ary[2])
+      rg
+    end
+
+    def parseZone ary
+      zone=Zone.new(nil,nil,[],[],[])
+      ary.shift
+      zone.name=ary.shift
+      while ary.any?
+        case h=ary.first.header
+        when :range
+          zone.range=parseRange(ary.shift)
+        when :register
+          zone.registers << parseRegister(ary.shift)
+        when :subzone
+          zone.subzones << parseSubZone(ary.shift)
+        when :instance
+          zone.instances << parseInstance(ary.shift)
+        else
+          raise "error during parseZone.Expecting 'range' or 'register'. Got '#{h}'"
+        end
+      end
+      zone
+    end
+
+    def parseInstance ary
+      inst=Instance.new(nil,[])
+      ary.shift
+      inst.name=ary.shift
+      while ary.any?
+        case h=ary.first.header
+        when :connect
+          inst.mapping << parseConnect(ary.shift)
+        else
+          raise "error during parseZone.Expecting 'connect'. Got '#{h}'"
+        end
+      end
+      inst
+    end
+
+    def parseConnect ary
+      map=Connect.new(nil,nil)
+      ary.shift
+      map.formal=parseFormalIO(ary.shift)
+      map.actual=parseRegSig(ary.shift)
+      map
+    end
+
+    def parseFormalIO ary
+      dir=ary.shift
+      case dir
+      when :input
+        return Input.new(ary.shift)
+      when :output
+        return Output.new(ary.shift)
+      else
+        raise "error in formal io : #{ary}"
+      end
+    end
+
+    def parseRegSig ary
+      sig=RegSig.new(nil,nil)
+      ary.shift #register
+      sig.name=ary.shift
+      sig.field=ary.shift
+      sig
+    end
+
+    def parseSubZone ary
+      zone=Subzone.new(nil,nil,[],[])
+      ary.shift
+      zone.name=ary.shift
+      while ary.any?
+        case h=ary.first.header
+        when :range
+          zone.range=parseRange(ary.shift)
+        when :register
+          zone.registers << parseRegister(ary.shift)
+        when :subzone
+          zone.subzones << parseSubZone(ary.shift)
+        else
+          raise "error during parseZone.Expecting 'range' or 'register'. Got '#{h}'"
+        end
+      end
+      zone
+    end
+
+    def parseRegister ary
+      reg=Register.new(nil,nil,nil,nil,true,[],[])
+      ary.shift
+      reg.name=ary.shift
+      while ary.any?
+        case h=ary.first.header
+        when :address
+          reg.address=parseAddress(ary.shift)
+        when :init
+          reg.init=parseInit(ary.shift)
+        when :sampling
+          reg.sampling=parseSampling(ary.shift)
+        when :writable
+          reg.writable=parseWritable(ary.shift)
+        when :bit
+          reg.bits << parseBit(ary.shift)
+        when :bitfield
+          reg.bitfields << parseBitfield(ary.shift)
+        else
+          raise "Error during parseRegister"
+        end
+      end
+      if reg.bits.empty? and reg.bitfields.empty?
+        bus_size=@param.bus.data_size
+        position=[bus_size-1,0]
+        reg.bitfields << Bitfield.new(position,name=:value,nil,nil)
+      end
+      reg
+    end
+
+    def parseAddress ary
+      parseHexa(ary.last)
+    end
+
+    def parseInit ary
+      parseHexa(ary.last)
+    end
+
+    def parseSampling ary
+      ary.shift
+      ary.shift==:true
+    end
+
+    def parseWritable ary
+      ary.shift
+      ary.shift==:true
+    end
+
+    def parseBit ary
+      bit=Bit.new(nil,nil,nil,nil)
+      ary.shift
+      bit.position=ary.shift.to_i
+      while ary.any?
+        case h=ary.first.header
+        when :name
+          bit.name=parseName(ary.shift)
+        when :purpose
+          bit.purpose=parsePurpose(ary.shift)
+        when :toggle
+          bit.toggle=parseToggle(ary.shift)
+        end
+      end
+      bit
+    end
+
+    def parseName ary
+      ary[1]
+    end
+
+    def parsePurpose ary
+      ary[1]
+    end
+
+    def parseToggle ary
+      ary[1]==:true
+    end
+
+    def parseBitfield ary
+      bf=Bitfield.new(nil,nil,nil,nil)
+      ary.shift
+      bf.position=[]
+      bf.position << ary.shift.to_s.to_i
+      bf.position << ary.shift.to_s.to_i
+      while ary.any?
+        case h=ary.first.header
+        when :name
+          bf.name=parseName(ary.shift)
+        when :purpose
+          bf.purpose=parsePurpose(ary.shift)
+        when :toggle
+          bf.toggle=parseToggle(ary.shift)
+        end
+      end
+      bf
+    end
+  end #parser
+end #module