pci_lib.vhd

vhdl 写的 PCI IP核程序

       when x"0" => C := '0'; Good1 := true;
       when x"1" => C := '1'; Good1 := true;
       when x"2" => C := '2'; Good1 := true;
       when x"3" => C := '3'; Good1 := true;
       when x"4" => C := '4'; Good1 := true;
       when x"5" => C := '5'; Good1 := true;
       when x"6" => C := '6'; Good1 := true;
       when x"7" => C := '7'; Good1 := true;
       when x"8" => C := '8'; Good1 := true;
       when x"9" => C := '9'; Good1 := true;
       when x"A" => C := 'A'; Good1 := true;
       when x"B" => C := 'B'; Good1 := true;
       when x"C" => C := 'C'; Good1 := true;
       when x"D" => C := 'D'; Good1 := true;
       when x"E" => C := 'E'; Good1 := true;
       when x"F" => C := 'F'; Good1 := true;
       when "ZZZZ" => C := 'Z'; Good1 := true;
       when others => Good1 := false;
    end case;
    if not Good1 then
       C := '0';
       report HeaderMsg&"Expected a Hex character (0-F)"
         severity MsgSeverity;
    end if;
    Good := Good1;        
   end Bit2Hex;
   --------------------------------------------------------------------
   --------------------------------------------------------------------
   procedure Vec2Hex (
      Value   : in   Std_Logic_Vector(31 downto 0);
      Result  : out  String(1 to 8); 
      GOOD    : out  BOOLEAN) is
      variable OK          : Boolean;
      variable C           : Character;
      constant NE          : Integer := value'length/4;	-- number of Hex chars
      variable BV          : Std_Logic_Vector(value'length-1 downto 0) := Value;
      variable Res         : String(1 to 8);
      constant HeaderMsg   : String := "Vec2Hex: ";
      constant MsgSeverity : Severity_Level	:= Error;
   begin
     if Value'length mod 4 /= 0 then	-- Testing if Vector is mod 4
        Good := false;
        report HeaderMsg&"The length of input vector is not modulo 4!"
           severity MsgSeverity;
        return;
     end if;
     Bit2Hex(BV(3 downto 0), C, OK);	-- Conversion of the 4 LSB bits
     if not OK then 
        Good := false;
        return;
     end if;
     Res := C & Res(2 to NE);	-- Places first Char in Result
     for i in 1 to NE-1 loop
        Bit2Hex(BV(4*i+3 downto 4*i), C, OK);	-- Converts next Char
        if not OK then
           Good := false;
           return;
        end if;
        Res := Res(1 to i) & C & Res(i+2 to NE);
     end loop;
     for i in 0 to NE-1 loop
         Result (1+i) := Res (NE-i);
     end loop;
     Good := true;
   end Vec2Hex; 
   --------------------------------------------------------------------
   --------------------------------------------------------------------
   procedure Read (
      L     : inout line;
      Value : out   integer;
      Radix : in    positive) is
      constant not_digit : integer := -999;
      variable Digit     : integer;
      variable Result    : integer := 0;
      variable Pos       : integer;
   begin
      -- calculate the value
      if (L'length <=0 ) then
         for i in Pos to L'right loop
             digit := digit_value(L(i));
             exit when (Digit = not_digit) or (digit >= radix);
             Result := Result * Radix + digit;
             Pos := Pos + 1;
         end loop;
         Value := Result;
      end if;
   end Read;
   --------------------------------------------------------------------
   --------------------------------------------------------------------
   procedure ReadHex (
      L      : inout Line; 
      Value  : out   Std_Logic_Vector;
      Good   : out   Boolean;
      Enable : out   Std_Logic_Vector) is
      variable OK          : Boolean;
      variable C           : Character;
      constant NE          : Integer := value'length/4;
      variable BV          : Std_Logic_Vector(value'length-1 downto 0);
      variable TEMP        : Std_Logic_Vector(value'length-1 downto 0);
      variable S           : String(1 to NE-1);
      constant HeaderMsg   : String := "Vec2Hex";
      constant MsgSeverity : Severity_Level := Warning;
    begin
      Enable(3 downto 0) :="0000";  
      if Value'length mod 4 /= 0 then	-- Testing if Vector is mod 4
         Good := false;
         report HeaderMsg&"The length of input vector is not modulo 4!"
            severity MsgSeverity;
         return;
      end if;
      loop
         read(L, C, OK);		-- Finds the first Hex Char
         exit when (((C /= ' ') and (C /= CR) and (C /= HT)) or
         (L'length = 0));
      end loop;
      Hex2Bit(C, BV( 3 downto 0), OK);	-- Converts first Hex Char to 4 Bits
      if C ='X' or C ='x' then
         Enable(3) :='1';
      end if;

      if not OK then 
         Good := false;
         return;
      end if;
      read(L, S, OK);			-- Reads the next three Hex Chars
      if not OK then
         Good := false;
         return;
      end if;
      for i in 1 to NE-1 loop
         if s(i) ='X' or s(i) ='x' then
            if i=1 then
               Enable(3):='1';
            end if;
            if i=2 or i=3 then
               Enable(2):='1';
            end if;   
            if i=4 or i=5 then
               Enable(1):='1';
            end if;
            if i=6 or i=7 then
               Enable(0):='1';
            end if;          
         end if;
         Hex2Bit(s(i), BV(4*i+3 downto 4*i), OK); -- Converts to BitVector
         if not OK then
            Good := false;
            return;
         end if;		
	  end loop;
      Good := true;
      
      -- for byte	
   	  if (value'length = 8 ) then
         for i in 0 to 3 loop
            TEMP(i) := BV(value'length-4+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+4) := BV(value'length-8+i);
         end loop;
      end if;   	  
   	  
      -- for word
      if (value'length = 16 ) then
         for i in 0 to 3 loop
            TEMP(i) := BV(value'length-4+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+4) := BV(value'length-8+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+8) := BV(value'length-12+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+12) := BV(value'length-16+i);
         end loop;
      end if;
 
      -- for DWORD
      if (value'length =32 ) then 
         for i in 0 to 3 loop
            TEMP(i) := BV(value'length-4+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+4) := BV(value'length-8+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+8) := BV(value'length-12+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+12) := BV(value'length-16+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+16) := BV(value'length-20+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+20) := BV(value'length-24+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+24) := BV(value'length-28+i);
         end loop;
         for i in 0 to 3 loop
            TEMP(i+28) := BV(value'length-32+i);
         end loop;
      end if;
    
      Value := TEMP;
   end ReadHex;
   --------------------------------------------------------------------
   --------------------------------------------------------------------
   procedure FileParser (
      constant file_name   : in    String ;
      variable Commands    : inout CommandArray;
      variable NumCommands : out   Natural;
      variable ErrFlag     : inout Boolean) is
      File     CmdFile     : text;
      constant HeaderMsg   : String := "FileParser:";
      constant MsgSeverity : Severity_Level	:= Error;
      variable L           : Line := NULL;
      variable Linenum     : Natural := 0;
      variable LblNum      : Natural := 0;
      variable CmdNum      : Natural := 0;
      variable EndOfFile   : Boolean := false;
      variable Good        : Boolean := false;
      variable Int         : Integer;
      variable Tm          : Time;
      variable C           : Character;
      variable Addr        : Std_Logic_Vector(31 downto 0);
      variable Data        : Std_Logic_Vector(31 downto 0);
      variable Enable      : Std_Logic_Vector(3 downto 0);
      variable Vect_count  : Std_Logic_Vector(7 downto 0);	
      variable Data_word   : Std_Logic_Vector(15 downto 0);
      variable Data_byte   : Std_Logic_Vector(7 downto 0);
      variable str4        : string(1 to 4);
      variable count_nr    : Integer;
      variable count       : Integer;
   begin
      ErrFlag := false;
      FILE_OPEN(CmdFile,file_name,READ_MODE);
      loop
        readline(CmdFile,L);
        EndOfFile := endfile(CmdFile);
        CmdNum := CmdNum + 1;
        LineNum := LineNum + 1;
        read(L, str4, Good);
        if not Good then
           CmdNum := CmdNum-1;
        else
           case str4 is
  	           when "WRSW" =>      -- write single word command
                  readhex(L,Addr,Good,Enable);
                  if not Good then
                     report HeaderMsg&"Invalid WRSW command in :"&file_name&", line #"& integer'image(LineNum) &",  "&"Address parameter should be 8 hex characters"
                        severity MsgSeverity;
                     ErrFlag := true;   
                  else
                     Good := true; 
                     readhex(L,Data_byte,Good,Enable);
                     count_nr := Byte2Int(Data_Byte);	
                     count := 0;
                     for I in 0 to count_nr-1 loop
                         readhex(L,Data,Good,Enable);
                         if (Good =true) then
                            count := count + 1;
                            commands(CmdNum).command       := "WRSW";