lpm_ram_dp.vhd

8-1024可变点数FFT/IFFT变换,VHDL语言设计, 仿真通过,可以很容易综合.

                  data_tmp <= data;
            else
                  ASSERT FALSE
                  REPORT "Illegal LPM_INDATA property value for LPM_RAM_DP!"
                  SEVERITY ERROR;
            end if;
            if (lpm_outdata = "REGISTERED") then
                 q <= q_reg;
            elsif (lpm_outdata = "UNREGISTERED") then
                 q <= q_tmp;
            else
                 ASSERT FALSE
                 REPORT "Illegal LPM_OUTDATA property value for LPM_RAM_DP!"
                 SEVERITY ERROR;
            end if;
        end process;

        input_reg: process (wrclock)
        begin
            if wrclock'event and wrclock = '1' and wrclken = '1' then
                  data_reg <= data;
                  wraddress_reg <= wraddress;
                  wren_reg <= wren;
            end if;
        end process;

        output_reg: process (rdclock)
        begin
            if rdclock'event and rdclock = '1' and rdclken = '1' then
                  rdaddress_reg <= rdaddress;
                  rden_reg <= rden; 
                  q_reg <= q_tmp;
            end if;
        end process;

        memory: process(data_tmp, wren_tmp, rdaddress_tmp, wraddress_tmp, rden_tmp)
        variable mem_data : lpm_memory;
        variable mem_data_tmp : integer := 0;
        variable mem_init: boolean := false;
        variable i,j,k,lineno: integer := 0;
        variable buf: line ;
        variable booval: boolean ;
        FILE unused_file: TEXT IS OUT "UNUSED";
        FILE mem_data_file: TEXT IS IN LPM_FILE;
        variable base, byte, rec_type, datain, addr, checksum: string(2 downto 1);
        variable startadd: string(4 downto 1);
        variable ibase: integer := 0;
        variable ibyte: integer := 0;
        variable istartadd: integer := 0;
        variable check_sum_vec, check_sum_vec_tmp: std_logic_vector(7 downto 0);
        begin
            -- INITIALIZE --
            if NOT(mem_init) then
                 -- INITIALIZE TO 0 --
                 for i in mem_data'LOW to mem_data'HIGH loop
                      mem_data(i) := (OTHERS => '0');
                 end loop;

                 if (LPM_FILE = "UNUSED") then
                      ASSERT FALSE
                      REPORT "Initialization file not found!"
                      SEVERITY WARNING;
                 else
                      WHILE NOT ENDFILE(mem_data_file) loop
                          booval := true;
                          READLINE(mem_data_file, buf);
                          lineno := lineno + 1;
                          check_sum_vec := (OTHERS => '0');
                          if (buf(buf'LOW) = ':') then
                              i := 1;
                              shrink_line(buf, i);
                              READ(L=>buf, VALUE=>byte, good=>booval);
                              if not (booval) then
                                  ASSERT FALSE
                                  REPORT "[Line "& int_to_str(lineno) & "]:Illegal Intel Hex Format!"
                                  SEVERITY ERROR;
                              end if;
                              ibyte := hex_str_to_int(byte);
                              check_sum_vec := unsigned(check_sum_vec) + unsigned(CONV_STD_LOGIC_VECTOR(ibyte, 8));
                              READ(L=>buf, VALUE=>startadd, good=>booval);
                              if not (booval) then
                                  ASSERT FALSE
                                  REPORT "[Line "& int_to_str(lineno) & "]:Illegal Intel Hex Format! "
                                  SEVERITY ERROR;
                              end if;
                              istartadd := hex_str_to_int(startadd);
                              addr(2) := startadd(4);
                              addr(1) := startadd(3);
                              check_sum_vec := unsigned(check_sum_vec) + unsigned(CONV_STD_LOGIC_VECTOR(hex_str_to_int(addr), 8));
                              addr(2) := startadd(2);
                              addr(1) := startadd(1);
                              check_sum_vec := unsigned(check_sum_vec) + unsigned(CONV_STD_LOGIC_VECTOR(hex_str_to_int(addr), 8));
                              READ(L=>buf, VALUE=>rec_type, good=>booval);
                              if not (booval) then
                                   ASSERT FALSE
                                   REPORT "[Line "& int_to_str(lineno) & "]:Illegal Intel Hex Format! "
                                   SEVERITY ERROR;
                              end if;
                              check_sum_vec := unsigned(check_sum_vec) + unsigned(CONV_STD_LOGIC_VECTOR(hex_str_to_int(rec_type), 8));
                          else
                              ASSERT FALSE
                              REPORT "[Line "& int_to_str(lineno) & "]:Illegal Intel Hex Format! "
                              SEVERITY ERROR;
                          end if;
                          case rec_type is
                              when "00"=>     -- Data record
                                   i := 0;
                                   k := lpm_width / 8;
                                   if ((lpm_width MOD 8) /= 0) then
                                        k := k + 1; 
                                   end if;
                                   -- k = no. of bytes per CAM entry.
                                   while (i < ibyte) loop
                                        mem_data_tmp := 0;
                                        for j in 1 to k loop
                                             READ(L=>buf, VALUE=>datain,good=>booval); -- read in data a byte (2 hex chars) at a time.
                                             if not (booval) then
                                                 ASSERT FALSE
                                                 REPORT "[Line "& int_to_str(lineno) & "]:Illegal Intel Hex Format! "
                                                 SEVERITY ERROR;
                                             end if;
                                             check_sum_vec := unsigned(check_sum_vec) + unsigned(CONV_STD_LOGIC_VECTOR(hex_str_to_int(datain), 8));
                                             mem_data_tmp := mem_data_tmp * 256 + hex_str_to_int(datain);
                                        end loop;
                                        i := i + k;
                                        mem_data(ibase + istartadd) := CONV_STD_LOGIC_VECTOR(mem_data_tmp, lpm_width);
                                        istartadd := istartadd + 1;
                                    end loop;
                               when "01"=>
                                    exit;
                               when "02"=>
                                     ibase := 0;
                                     if (ibyte /= 2) then
                                          ASSERT FALSE
                                          REPORT "[Line "& int_to_str(lineno) & "]:Illegal Intel Hex Format for record type 02! "
                                          SEVERITY ERROR;
                                     end if;
                                     for i in 0 to (ibyte-1) loop
                                          READ(L=>buf, VALUE=>base,good=>booval);
                                          ibase := ibase * 256 + hex_str_to_int(base);
                                          if not (booval) then
                                              ASSERT FALSE
                                              REPORT "[Line "& int_to_str(lineno) & "]:Illegal Intel Hex Format! "
                                              SEVERITY ERROR;
                                          end if;
                                          check_sum_vec := unsigned(check_sum_vec) + unsigned(CONV_STD_LOGIC_VECTOR(hex_str_to_int(base), 8));
                                      end loop;
                                      ibase := ibase * 16;
                                 when OTHERS =>
                                      ASSERT FALSE
                                      REPORT "[Line "& int_to_str(lineno) & "]:Illegal record type in Intel Hex File! "
                                      SEVERITY ERROR;
                             end case;
                             READ(L=>buf, VALUE=>checksum,good=>booval);
                             if not (booval) then
                                  ASSERT FALSE
                                  REPORT "[Line "& int_to_str(lineno) & "]:Checksum is missing! "
                                  SEVERITY ERROR;
                             end if;

                             check_sum_vec := unsigned(not (check_sum_vec)) + 1 ;
                             check_sum_vec_tmp := CONV_STD_LOGIC_VECTOR(hex_str_to_int(checksum),8);

                             if (unsigned(check_sum_vec) /= unsigned(check_sum_vec_tmp)) then
                                  ASSERT FALSE
                                  REPORT "[Line "& int_to_str(lineno) & "]:Incorrect checksum!"
                                  SEVERITY ERROR;
                             end if;
                         end loop;
                     end if;
                     mem_init := TRUE;
                end if;

                -- MEMORY FUNCTION --
                if wren_tmp = '1' then
                     mem_data (conv_integer(wraddress_tmp)) := data_tmp;
                end if;
                if rden_tmp = '1' then
                     q_tmp <= mem_data(conv_integer(rdaddress_tmp));
                --else
                --    q_tmp <= (OTHERS => 'Z');
                end if;
        end process;

end LPM_SYN;