AMBPEX5_v20_SX50T_CORE
testbench/test_pkg.vhd
00001 ---------------------------------------------------------------------------------------------------
00002 --
00003 -- Title       : test_pkg.vhd
00004 -- Author      : Dmitry Smekhov 
00005 -- Company     : Instrumental System
00006 --      
00007 -- Version     : 1.0                     
00008 --
00009 ---------------------------------------------------------------------------------------------------
00010 --
00011 -- Description : Пакет для тестирования ambpex5.
00012 --
00013 ---------------------------------------------------------------------------------------------------
00014 
00015 
00016 library ieee;
00017 use ieee.std_logic_1164.all;            
00018 use ieee.std_logic_arith.all;  
00019 use ieee.std_logic_unsigned.all;
00020 use ieee.std_logic_textio.all;
00021 use std.textio.all;
00022 
00023 
00024 library work;
00025 use work.cmd_sim_pkg.all;               
00026 use work.block_pkg.all; 
00027 use work.trd_pkg.all;
00028 
00029 
00030 
00031 package test_pkg is
00032         
00033 --! Инициализация теста       
00034 procedure test_init(
00035                 fname: in string        --! имя файла отчёта
00036         );
00037         
00038 --! Завершение теста             
00039 procedure test_close;                                           
00040         
00041         
00042         
00043 --! Запуск DMA с неправильным дескриптором 
00044 procedure test_dsc_incorrect (
00045                 signal  cmd:    out bh_cmd; --! команда
00046                 signal  ret:    in  bh_ret  --! ответ
00047                 );
00048 
00049 --! Запуск DMA на приём одного блока 4 кБ
00050 procedure test_read_4kb (
00051                 signal  cmd:    out bh_cmd; --! команда
00052                 signal  ret:    in  bh_ret  --! ответ
00053                 );
00054 
00055                                 
00056 --! Чтение 8 кБ из тетрады DIO_IN 
00057 procedure test_adm_read_8kb (
00058                 signal  cmd:    out bh_cmd; --! команда
00059                 signal  ret:    in  bh_ret  --! ответ
00060                 );
00061 
00062 --! Проверка обращений к блоку MAIN 
00063 procedure test_block_main (
00064                 signal  cmd:    out bh_cmd; --! команда
00065                 signal  ret:    in  bh_ret  --! ответ
00066                 );
00067                 
00068 --! Чтение 16 кБ с использованием двух блоков дескрипторов
00069 procedure test_adm_read_16kb (
00070                 signal  cmd:    out bh_cmd; --! команда
00071                 signal  ret:    in  bh_ret  --! ответ
00072                 );
00073                 
00074 --! Запись 16 кБ с использованием двух блоков дескрипторов
00075 procedure test_adm_write_16kb (
00076                 signal  cmd:    out bh_cmd; --! команда
00077                 signal  ret:    in  bh_ret  --! ответ
00078                 );              
00079         
00080 end package     test_pkg;
00081 
00082 package body test_pkg is
00083         
00084         FILE   log: text;
00085         
00086         shared variable cnt_ok, cnt_error: integer;
00087         
00088         -- Инициализация теста        
00089         procedure test_init(
00090                 fname: in string                                        -- имя файла отчёта
00091                 ) is
00092         begin
00093                 
00094                 file_open( log, fname, WRITE_MODE );
00095                 cnt_ok:=0;
00096                 cnt_error:=0;
00097                 
00098         end test_init;  
00099         
00100         -- Завершение теста              
00101         procedure test_close is         
00102                 variable str : LINE;            -- pointer to string
00103         begin                                           
00104                 
00105                 std.textio.write( str, string'(" " ));
00106                 writeline( log, str );          
00107                 writeline( log, str );          
00108                 
00109                 write( str, string'("Проверка завершена" ));
00110                 writeline( log, str );          
00111                 write( str, string'("Число успешных тестов:  " ));
00112                 write( str, cnt_ok );
00113                 writeline( log, str );          
00114                 write( str, string'("Число ошибочных тестов: " ));
00115                 write( str, cnt_error );
00116                 writeline( log, str );          
00117                 
00118                 
00119                 file_close( log ); 
00120                 
00121         end test_close; 
00122         
00123         
00124         
00125 --! Запуск DMA с неправильным дескриптором 
00126 procedure test_dsc_incorrect (
00127                 signal  cmd:    out bh_cmd; --! команда
00128                 signal  ret:    in  bh_ret  --! ответ
00129                 ) 
00130 is
00131 
00132 variable        adr             : std_logic_vector( 31 downto 0 );
00133 variable        data    : std_logic_vector( 31 downto 0 );
00134 variable        str             : line;
00135 begin
00136                 
00137         write( str, string'("TEST_DSC_INCORRECT" ));
00138         writeline( log, str );  
00139         
00140         ---- Формирование блока дескрипторов ---
00141         for ii in 0 to 127 loop
00142                 adr:= x"00100000";
00143                 adr:=adr + ii*4;
00144                 int_mem_write( cmd, ret, adr,  x"00000000" );
00145         end loop;                                                                                
00146         
00147         int_mem_write( cmd, ret, x"00100000",  x"03020100" );
00148         int_mem_write( cmd, ret, x"001001FC",  x"FF00AA00" );
00149         
00150         ---- Программирование канала DMA ----
00151         block_write( cmd, ret, 4, 8, x"00000027" );             -- DMA_MODE 
00152         block_write( cmd, ret, 4, 9, x"00000010" );             -- DMA_CTRL - RESET FIFO 
00153         
00154         block_write( cmd, ret, 4, 20, x"00100000" );    -- PCI_ADRL 
00155         block_write( cmd, ret, 4, 21, x"00100000" );    -- PCI_ADRH  
00156         block_write( cmd, ret, 4, 23, x"0000A400" );    -- LOCAL_ADR 
00157         
00158         block_write( cmd, ret, 4, 9, x"00000001" );             -- DMA_CTRL - START 
00159         
00160         wait for 10 us;
00161         
00162         block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00163         
00164         write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00165         if( data( 15 downto 0 )=x"A021" ) then
00166                 write( str, string'(" - Ok" )); 
00167                 cnt_ok := cnt_ok + 1;
00168         else
00169                 write( str, string'(" - Error" ));
00170                 cnt_error := cnt_error + 1;
00171         end if;
00172         
00173         writeline( log, str );  
00174         
00175         block_write( cmd, ret, 4, 9, x"00000000" );             -- DMA_CTRL - STOP  
00176                 
00177 end test_dsc_incorrect;
00178         
00179 
00180 --! Запуск DMA приём одного блока 4 кБ
00181 procedure test_read_4kb (
00182                 signal  cmd:    out bh_cmd; --! команда
00183                 signal  ret:    in  bh_ret  --! ответ
00184                 )
00185 is
00186 
00187 variable        adr                             : std_logic_vector( 31 downto 0 );
00188 variable        data                    : std_logic_vector( 31 downto 0 );
00189 variable        str                             : line;                    
00190 
00191 variable        error                   : integer:=0;
00192 variable        dma_complete    : integer;
00193 
00194 begin
00195                 
00196         write( str, string'("TEST_READ_4KB" ));
00197         writeline( log, str );  
00198         
00199         ---- Формирование блока дескрипторов ---
00200         for ii in 0 to 127 loop
00201                 adr:= x"00100000";
00202                 adr:=adr + ii*4;
00203                 int_mem_write( cmd, ret, adr,  x"00000000" );
00204         end loop;                                                                                
00205         
00206         int_mem_write( cmd, ret, x"00100000",  x"00008000" );
00207         int_mem_write( cmd, ret, x"00100004",  x"00000100" );
00208 
00209         
00210         int_mem_write( cmd, ret, x"001001F8",  x"00000000" );
00211         int_mem_write( cmd, ret, x"001001FC",  x"762C4953" );
00212         
00213         ---- Программирование канала DMA ----
00214         block_write( cmd, ret, 4, 8, x"00000025" );             -- DMA_MODE 
00215         block_write( cmd, ret, 4, 9, x"00000010" );             -- DMA_CTRL - RESET FIFO 
00216         
00217         block_write( cmd, ret, 4, 20, x"00100000" );    -- PCI_ADRL 
00218         block_write( cmd, ret, 4, 21, x"00100000" );    -- PCI_ADRH  
00219         block_write( cmd, ret, 4, 23, x"0000A400" );    -- LOCAL_ADR 
00220         
00221         block_write( cmd, ret, 4, 9, x"00000001" );             -- DMA_CTRL - START 
00222         
00223         wait for 20 us;
00224         
00225         block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00226         
00227         write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00228         if( data( 8 )='1' ) then
00229                 write( str, string'(" - Дескриптор правильный" ));  
00230         else
00231                 write( str, string'(" - Ошибка чтения дескриптора" ));
00232                 error := error + 1;
00233         end if;
00234         
00235         writeline( log, str );  
00236         
00237         if( error=0 ) then
00238                 
00239                 ---- Ожидание завершения DMA ----
00240                 dma_complete := 0;
00241                 for ii in 0 to 100 loop
00242                         
00243                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00244                 write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00245                         if( data(5)='1' ) then
00246                                 write( str, string'(" - DMA завершён " ));
00247                                 dma_complete := 1;
00248                         end if;
00249                         writeline( log, str );                  
00250                         
00251                         if( dma_complete=1 ) then
00252                                 exit;
00253                         end if;            
00254                         
00255                         wait for 1 us;
00256                         
00257                 end loop;
00258         
00259                 writeline( log, str );                  
00260                 
00261                 if( dma_complete=0 ) then
00262                         write( str, string'("Ошибка - DMA не завершён " ));
00263                         writeline( log, str );                  
00264                         error:=error+1;
00265                 end if;
00266 
00267         end if; 
00268         
00269         for ii in 0 to 3 loop
00270                         
00271                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00272                 write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00273                 writeline( log, str );                  
00274                 wait for 500 ns;
00275                 
00276         end loop;
00277         
00278         
00279         block_write( cmd, ret, 4, 9, x"00000000" );             -- DMA_CTRL - STOP      
00280         
00281         write( str, string'(" Прочитано: " ));
00282         writeline( log, str );          
00283         
00284         for ii in 0 to 15 loop
00285 
00286                 adr:= x"00800000";
00287                 adr:=adr + ii*4;
00288                 int_mem_read( cmd, ret, adr,  data );
00289                 
00290                 write( str, ii ); write( str, string'("   " )); hwrite( str, data );
00291                 writeline( log, str );          
00292                 
00293         end loop;
00294         
00295         
00296 --      block_write( cmd, ret, 4, 9, x"00000010" );             -- DMA_CTRL - RESET FIFO 
00297 --      block_write( cmd, ret, 4, 9, x"00000000" );             -- DMA_CTRL 
00298 --      block_write( cmd, ret, 4, 9, x"00000001" );             -- DMA_CTRL - START     
00299         
00300         
00301         writeline( log, str );          
00302         if( error=0 ) then
00303                 write( str, string'(" Тест завершён успешно " ));
00304                 cnt_ok := cnt_ok + 1;
00305         else
00306                 write( str, string'(" Тест не выполнен " ));
00307                 cnt_error := cnt_error + 1;
00308         end if;
00309         writeline( log, str );  
00310         writeline( log, str );          
00311 
00312 end test_read_4kb;
00313 
00314 
00315 --! Чтение 8 кБ из тетрады DIO_IN 
00316 procedure test_adm_read_8kb (
00317                 signal  cmd:    out bh_cmd; --! команда
00318                 signal  ret:    in  bh_ret  --! ответ
00319                 )
00320 is
00321 
00322 variable        adr                             : std_logic_vector( 31 downto 0 );
00323 variable        data                    : std_logic_vector( 31 downto 0 );
00324 variable        str                             : line;                    
00325 
00326 variable        error                   : integer:=0;
00327 variable        dma_complete    : integer;
00328 
00329 begin
00330                 
00331         write( str, string'("TEST_ADM_READ_8KB" ));
00332         writeline( log, str );  
00333         
00334         ---- Формирование блока дескрипторов ---
00335         for ii in 0 to 127 loop
00336                 adr:= x"00100000";
00337                 adr:=adr + ii*4;
00338                 int_mem_write( cmd, ret, adr,  x"00000000" );
00339         end loop;                                                                                
00340         
00341         --- Дескриптор 0 ---
00342         int_mem_write( cmd, ret, x"00100000",  x"00008000" ); 
00343         int_mem_write( cmd, ret, x"00100004",  x"00000111" );   -- переход к следующему 
00344 
00345         --- Дескриптор 1 ---
00346         int_mem_write( cmd, ret, x"00100008",  x"00008010" ); 
00347         int_mem_write( cmd, ret, x"0010000C",  x"00000110" );   -- остановка
00348         
00349         
00350         int_mem_write( cmd, ret, x"001001F8",  x"00000000" );
00351         int_mem_write( cmd, ret, x"001001FC",  x"D6644953" );
00352         
00353         trd_test_mode( cmd, ret, 0 );   -- переход в рабочий режим --
00354         
00355         ---- Программирование канала DMA ----
00356         block_write( cmd, ret, 4, 8, x"00000027" );             -- DMA_MODE 
00357         block_write( cmd, ret, 4, 9, x"00000010" );             -- DMA_CTRL - RESET FIFO 
00358         
00359         block_write( cmd, ret, 4, 20, x"00100000" );    -- PCI_ADRL 
00360         block_write( cmd, ret, 4, 21, x"00100000" );    -- PCI_ADRH  
00361         block_write( cmd, ret, 4, 23, x"00019000" );    -- LOCAL_ADR 
00362         
00363         
00364         ---- Подготовка тетрады ----
00365         trd_test_mode( cmd, ret, 0 );   -- переход в рабочий режим --
00366         trd_wait_cmd( cmd, ret, 0, 16, x"1600" );               -- DMAR0 - от тетрады 6 --
00367 
00368         trd_wait_cmd( cmd, ret, 1, 16#1F#, x"0001" );   -- Размер блока = 4 кБ --
00369 
00370         block_write( cmd, ret, 4, 9, x"00000001" );             -- DMA_CTRL - START 
00371 
00372         trd_wait_cmd( cmd, ret, 1, 16#0F#, x"0001" );   -- Подключение выхода генератора к DIO_IN --
00373         
00374         trd_wait_cmd( cmd, ret, 6,      0, x"2038" );           -- запуск тетрады DIO_IN
00375         
00376         trd_wait_cmd( cmd, ret, 1, 16#1E#, x"0020" );   -- Запуск тестовой последовательности --
00377         
00378         wait for 20 us;
00379         
00380         block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00381         
00382         write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00383         if( data( 8 )='1' ) then
00384                 write( str, string'(" - Дескриптор правильный" ));  
00385         else
00386                 write( str, string'(" - Ошибка чтения дескриптора" ));
00387                 error := error + 1;
00388         end if;
00389         
00390         writeline( log, str );  
00391         
00392         if( error=0 ) then
00393                 
00394                 ---- Ожидание завершения DMA ----
00395                 dma_complete := 0;
00396                 for ii in 0 to 100 loop
00397                         
00398                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00399                 write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00400                         if( data(5)='1' ) then
00401                                 write( str, string'(" - DMA завершён " ));
00402                                 dma_complete := 1;      
00403                                 
00404                                 block_write( cmd, ret, 4, 16#11#, x"00000010" );                -- FLAG_CLR - сброс EOT 
00405                                 
00406                         end if;
00407                         writeline( log, str );                  
00408                         
00409                         if( dma_complete=1 ) then
00410                                 exit;
00411                         end if;            
00412                         
00413                         wait for 1 us;
00414                         
00415                 end loop;
00416         
00417                 writeline( log, str );                  
00418                 
00419                 if( dma_complete=0 ) then
00420                         write( str, string'("Ошибка - DMA не завершён " ));
00421                         writeline( log, str );                  
00422                         error:=error+1;
00423                 end if;
00424 
00425         end if; 
00426         
00427         for ii in 0 to 3 loop
00428                         
00429                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00430                 write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00431                 writeline( log, str );                  
00432                 wait for 500 ns;
00433                 
00434         end loop;
00435         
00436         
00437         block_write( cmd, ret, 4, 9, x"00000000" );             -- DMA_CTRL - STOP      
00438         
00439         write( str, string'(" Блок 0 - прочитано: " ));
00440         writeline( log, str );          
00441         
00442         for ii in 0 to 15 loop
00443 
00444                 adr:= x"00800000";
00445                 adr:=adr + ii*4;
00446                 int_mem_read( cmd, ret, adr,  data );
00447                 
00448                 write( str, ii ); write( str, string'("   " )); hwrite( str, data );
00449                 writeline( log, str );          
00450                 
00451         end loop;
00452 
00453         writeline( log, str );          
00454         
00455         write( str, string'(" Блок 1 - прочитано: " ));
00456         writeline( log, str );          
00457         
00458         for ii in 0 to 15 loop
00459 
00460                 adr:= x"00801000";
00461                 adr:=adr + ii*4;
00462                 int_mem_read( cmd, ret, adr,  data );
00463                 
00464                 write( str, ii ); write( str, string'("   " )); hwrite( str, data );
00465                 writeline( log, str );          
00466                 
00467         end loop;
00468         
00469         
00470 --      block_write( cmd, ret, 4, 9, x"00000010" );             -- DMA_CTRL - RESET FIFO 
00471 --      block_write( cmd, ret, 4, 9, x"00000000" );             -- DMA_CTRL 
00472 --      block_write( cmd, ret, 4, 9, x"00000001" );             -- DMA_CTRL - START     
00473         
00474         
00475         writeline( log, str );          
00476         if( error=0 ) then
00477                 write( str, string'(" Тест завершён успешно " ));
00478                 cnt_ok := cnt_ok + 1;
00479         else
00480                 write( str, string'(" Тест не выполнен " ));
00481                 cnt_error := cnt_error + 1;
00482         end if;
00483         writeline( log, str );  
00484         writeline( log, str );          
00485 
00486 end test_adm_read_8kb;
00487 
00488 
00489 --! Проверка обращений к блоку MAIN 
00490 procedure test_block_main (
00491                 signal  cmd:    out bh_cmd; --! команда
00492                 signal  ret:    in  bh_ret  --! ответ
00493                 )
00494 is
00495 
00496 variable        adr                             : std_logic_vector( 31 downto 0 );
00497 variable        data                    : std_logic_vector( 31 downto 0 );
00498 variable        str                             : line;                    
00499 
00500 variable        error                   : integer:=0;
00501 variable        dma_complete    : integer;
00502 
00503 begin
00504                 
00505         write( str, string'("TEST_BLOCK_MAIN" ));
00506         writeline( log, str );  
00507 
00508         block_read( cmd, ret, 4, 16#00#, data );                        
00509         write( str,  string'("БЛОК 4: " )); hwrite( str, data ); writeline( log, str );     
00510 
00511         wait for 10 us;
00512         
00513 --      write( str, "Константы:" );
00514 --      writeline( log, str );  
00515 --      for ii in 0 to 5 loop
00516 --              write( str, "Блок " );
00517 --              write( str, ii );
00518 --              for jj in 0 to 7 loop
00519 --                      block_read( cmd, ret, ii, jj, data );                   
00520 --                      write( str, "   " );
00521 --                      hwrite( str, data );
00522 --              end loop;
00523 --              writeline( log, str );          
00524 --      end loop;
00525 --              
00526 --      
00527 --      writeline( log, str );                                                  
00528 --      
00529 --      block_read( cmd, ret, 0, 16#10#, data );                        
00530 --      write( str,  "STATUS: " ); hwrite( str, data ); writeline( log, str );  
00531 --      
00532 --      block_write( cmd, ret, 80, 16#08#, x"00000100" );                       
00533 --      
00534 --      block_read( cmd, ret, 0, 16#10#, data );                        
00535 --      write( str, "STATUS: " ); hwrite( str, data ); writeline( log, str );   
00536 --      
00537 --      block_write( cmd, ret, 80, 16#08#, x"00000200" );                       
00538 --      
00539 --      block_read( cmd, ret, 0, 16#10#, data );                        
00540 --      write( str, "STATUS: " ); hwrite( str, data ); writeline( log, str );   
00541 --      
00542 --      
00543 --      writeline( log, str );          
00544 --      if( error=0 ) then
00545 --              write( str, " Тест завершён успешно " );
00546 --              cnt_ok := cnt_ok + 1;
00547 --      else
00548 --              write( str, " Тест не выполнен " );
00549 --              cnt_error := cnt_error + 1;
00550 --      end if;
00551 
00552         for ii in 0 to 127 loop
00553         
00554                 block_write( cmd, ret, 4, 16#08#, x"0000AA55" );                                
00555                 block_read( cmd, ret, 4, 8, data );
00556                 write( str, string'("READ: " )); hwrite( str, data( 15 downto 0 ) ); writeline( log, str );             
00557                 if( data/=x"0000AA55" ) then
00558                         error:=error+1;
00559                 end if;
00560         
00561         end loop;
00562         
00563         
00564 
00565 
00566         writeline( log, str );  
00567         writeline( log, str );          
00568 
00569 end test_block_main;
00570                         
00571 
00572 
00573 
00574 --! Чтение 16 кБ с использованием двух блоков дескрипторов
00575 procedure test_adm_read_16kb (
00576                 signal  cmd:    out bh_cmd; --! команда
00577                 signal  ret:    in  bh_ret  --! ответ
00578                 )
00579 is
00580 
00581 variable        adr                             : std_logic_vector( 31 downto 0 );
00582 variable        data                    : std_logic_vector( 31 downto 0 );
00583 variable        str                             : line;                    
00584 
00585 variable        error                   : integer:=0;
00586 variable        dma_complete    : integer; 
00587 variable        kk                              : integer;       
00588 variable        status                  : std_logic_vector( 15 downto 0 );
00589 
00590 begin
00591                 
00592         write( str, string'("TEST_ADM_READ_16KB" ));
00593         writeline( log, str );  
00594         
00595         ---- Формирование блока дескрипторов ---
00596         for ii in 0 to 256 loop
00597                 adr:= x"00100000";
00598                 adr:=adr + ii*4;
00599                 int_mem_write( cmd, ret, adr,  x"00000000" );
00600         end loop;                                                                                
00601         
00602         --- Блок 0 ---
00603         
00604         --- Дескриптор 0 ---
00605         int_mem_write( cmd, ret, x"00100000",  x"00008000" ); 
00606         int_mem_write( cmd, ret, x"00100004",  x"00000111" );   -- переход к следующему дескриптору 
00607 
00608         --- Дескриптор 1 ---
00609         int_mem_write( cmd, ret, x"00100008",  x"00008010" ); 
00610         int_mem_write( cmd, ret, x"0010000C",  x"00000112" );   -- переход к следующему блоку 
00611 
00612         --- Дескриптор 2 ---
00613         int_mem_write( cmd, ret, x"00100010",  x"00001002" );   -- адрес следующего дескриптора 
00614         int_mem_write( cmd, ret, x"00100014",  x"00000000" );   
00615         
00616         
00617         int_mem_write( cmd, ret, x"001001F8",  x"00000000" );
00618         int_mem_write( cmd, ret, x"001001FC",  x"14644953" );      
00619         
00620 
00621         --- Блок 1 ---
00622         
00623         --- Дескриптор 0 ---
00624         int_mem_write( cmd, ret, x"00100200",  x"00008020" ); 
00625         int_mem_write( cmd, ret, x"00100204",  x"00000111" );   -- переход к следующему дескриптору 
00626 
00627         --- Дескриптор 1 ---
00628         int_mem_write( cmd, ret, x"00100208",  x"00008030" ); 
00629         int_mem_write( cmd, ret, x"0010020C",  x"00000110" );   -- остановка
00630         
00631         
00632         int_mem_write( cmd, ret, x"001003F8",  x"00000000" );
00633         int_mem_write( cmd, ret, x"001003FC",  x"D67C4953" );      
00634         
00635         
00636         
00637         ---- Программирование канала DMA ----
00638         block_write( cmd, ret, 4, 8, x"00000027" );             -- DMA_MODE 
00639         block_write( cmd, ret, 4, 9, x"00000010" );             -- DMA_CTRL - RESET FIFO 
00640         
00641         block_write( cmd, ret, 4, 20, x"00100000" );    -- PCI_ADRL 
00642         block_write( cmd, ret, 4, 21, x"00100000" );    -- PCI_ADRH  
00643         block_write( cmd, ret, 4, 23, x"00019000" );    -- LOCAL_ADR 
00644         
00645         
00646         ---- Подготовка тетрады ----
00647         trd_test_mode( cmd, ret, 0 );   -- переход в рабочий режим --
00648         trd_wait_cmd( cmd, ret, 0, 16, x"1600" );               -- DMAR0 - от тетрады 6 --
00649 
00650         trd_wait_cmd( cmd, ret, 1, 16#1F#, x"0001" );   -- Размер блока = 4 кБ --
00651 
00652         block_write( cmd, ret, 4, 9, x"00000001" );             -- DMA_CTRL - START 
00653 
00654         trd_wait_cmd( cmd, ret, 1, 16#0F#, x"0001" );   -- Подключение выхода генератора к DIO_IN --
00655         
00656         trd_wait_cmd( cmd, ret, 6,      0, x"2038" );           -- запуск тетрады DIO_IN
00657         
00658         trd_wait_cmd( cmd, ret, 1, 16#1E#, x"06A0" );   -- Запуск тестовой последовательности --
00659         
00660         wait for 20 us;
00661         
00662         block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00663         
00664         write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00665         if( data( 8 )='1' ) then
00666                 write( str, string'(" - Дескриптор правильный" ));  
00667         else
00668                 write( str, string'(" - Ошибка чтения дескриптора" ));
00669                 error := error + 1;
00670         end if;
00671         
00672         writeline( log, str );  
00673         
00674         if( error=0 ) then                 
00675                 
00676                 kk:=0;
00677                 loop
00678                         
00679                 trd_status( cmd, ret, 6, status );
00680                 write( str, string'("TRD_STATUS: " )); hwrite( str, status );
00681                         
00682                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00683                 write( str, string'("    STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00684                 
00685                         if( data(4)='1' ) then
00686                                 write( str, string'(" - завершено чтение блока " ));
00687                                 block_write( cmd, ret, 4, 16#11#, x"00000010" );                -- FLAG_CLR - сброс EOT 
00688                                 kk:=kk+1;
00689                                 if( kk=4 ) then
00690                                         exit;
00691                                 end if;
00692                         end if;
00693                         writeline( log, str );                  
00694                         
00695                         wait for 500 ns;
00696                         
00697                         
00698                 end loop;
00699                 
00700                 ---- Ожидание завершения DMA ----
00701                 dma_complete := 0;
00702                 for ii in 0 to 100 loop
00703                         
00704                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00705                 write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00706                         if( data(5)='1' ) then
00707                                 write( str, string'(" - DMA завершён " ));
00708                                 dma_complete := 1;      
00709                                 
00710                                 block_write( cmd, ret, 4, 16#11#, x"00000010" );                -- FLAG_CLR - сброс EOT 
00711                                 
00712                         end if;
00713                         writeline( log, str );                  
00714                         
00715                         if( dma_complete=1 ) then
00716                                 exit;
00717                         end if;            
00718                         
00719                         wait for 1 us;
00720                         
00721                 end loop;
00722         
00723                 writeline( log, str );                  
00724                 
00725                 if( dma_complete=0 ) then
00726                         write( str, string'("Ошибка - DMA не завершён " ));
00727                         writeline( log, str );                  
00728                         error:=error+1;
00729                 end if;
00730 
00731         end if; 
00732         
00733         for ii in 0 to 3 loop
00734                         
00735                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00736                 write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00737                 writeline( log, str );                  
00738                 wait for 500 ns;
00739                 
00740         end loop;
00741         
00742         
00743         block_write( cmd, ret, 4, 9, x"00000000" );             -- DMA_CTRL - STOP      
00744         
00745         write( str, string'(" Блок 0 - прочитано: " ));
00746         writeline( log, str );          
00747         
00748         for ii in 0 to 15 loop
00749 
00750                 adr:= x"00800000";
00751                 adr:=adr + ii*4;
00752                 int_mem_read( cmd, ret, adr,  data );
00753                 
00754                 write( str, ii ); write( str, string'("   " )); hwrite( str, data );
00755                 writeline( log, str );          
00756                 
00757         end loop;
00758 
00759         writeline( log, str );          
00760         
00761         write( str, string'(" Блок 1 - прочитано: " ));
00762         writeline( log, str );          
00763         
00764         for ii in 0 to 15 loop
00765 
00766                 adr:= x"00801000";
00767                 adr:=adr + ii*4;
00768                 int_mem_read( cmd, ret, adr,  data );
00769                 
00770                 write( str, ii ); write( str, string'("   " )); hwrite( str, data );
00771                 writeline( log, str );          
00772                 
00773         end loop;
00774 
00775         write( str, string'(" Блок 2 - прочитано: " ));
00776         writeline( log, str );          
00777         
00778         for ii in 0 to 15 loop
00779 
00780                 adr:= x"00802000";
00781                 adr:=adr + ii*4;
00782                 int_mem_read( cmd, ret, adr,  data );
00783                 
00784                 write( str, ii ); write( str, string'("   " )); hwrite( str, data );
00785                 writeline( log, str );          
00786                 
00787         end loop;
00788                 
00789         
00790         write( str, string'(" Блок 3 - прочитано: " ));
00791         writeline( log, str );          
00792         
00793         for ii in 0 to 15 loop
00794 
00795                 adr:= x"00803000";
00796                 adr:=adr + ii*4;
00797                 int_mem_read( cmd, ret, adr,  data );
00798                 
00799                 write( str, ii ); write( str, string'("   " )); hwrite( str, data );
00800                 writeline( log, str );          
00801                 
00802         end loop;
00803                 
00804 --      block_write( cmd, ret, 4, 9, x"00000010" );             -- DMA_CTRL - RESET FIFO 
00805 --      block_write( cmd, ret, 4, 9, x"00000000" );             -- DMA_CTRL 
00806 --      block_write( cmd, ret, 4, 9, x"00000001" );             -- DMA_CTRL - START     
00807         
00808         
00809         writeline( log, str );          
00810         if( error=0 ) then
00811                 write( str, string'(" Тест завершён успешно " ));
00812                 cnt_ok := cnt_ok + 1;
00813         else
00814                 write( str, string'(" Тест не выполнен " ));
00815                 cnt_error := cnt_error + 1;
00816         end if;
00817         writeline( log, str );  
00818         writeline( log, str );          
00819 
00820 end test_adm_read_16kb;
00821 
00822 
00823 
00824 
00825 --! Запись 16 кБ с использованием двух блоков дескрипторов
00826 procedure test_adm_write_16kb (
00827                 signal  cmd:    out bh_cmd; --! команда
00828                 signal  ret:    in  bh_ret  --! ответ
00829                 )
00830 is
00831 
00832 variable        adr                             : std_logic_vector( 31 downto 0 );
00833 variable        data                    : std_logic_vector( 31 downto 0 );
00834 variable        str                             : line;                    
00835 
00836 variable        error                   : integer:=0;
00837 variable        dma_complete    : integer; 
00838 variable        kk                              : integer;       
00839 variable        status                  : std_logic_vector( 15 downto 0 );
00840 
00841 begin
00842                 
00843         write( str, string'("TEST_ADM_WRITE_16KB" ));
00844         writeline( log, str );  
00845         
00846         ---- Формирование блока дескрипторов ---
00847         for ii in 0 to 256 loop
00848                 adr:= x"00100000";
00849                 adr:=adr + ii*4;
00850                 int_mem_write( cmd, ret, adr,  x"00000000" );
00851         end loop;                                                                                
00852         
00853         ---- Заполнение памяти ----
00854         for ii in 0 to 256 loop
00855                 adr:= x"00800000";
00856                 adr:=adr + ii*4;
00857                 data:=x"00A00000";
00858                 data:=data + ii;
00859                 int_mem_write( cmd, ret, adr,  data );
00860         end loop;       
00861 
00862         for ii in 0 to 1023 loop
00863                 adr:= x"00801000";
00864                 adr:=adr + ii*4;
00865                 data:=x"00A10000";
00866                 data:=data + ii;
00867                 int_mem_write( cmd, ret, adr,  data );
00868         end loop;       
00869 
00870         for ii in 0 to 256 loop
00871                 adr:= x"00802000";
00872                 adr:=adr + ii*4;
00873                 data:=x"00A20000";
00874                 data:=data + ii;
00875                 int_mem_write( cmd, ret, adr,  data );
00876         end loop;       
00877 
00878         for ii in 0 to 256 loop
00879                 adr:= x"00803000";
00880                 adr:=adr + ii*4;
00881                 data:=x"00A30000";
00882                 data:=data + ii;
00883                 int_mem_write( cmd, ret, adr,  data );
00884         end loop;       
00885         
00886         --- Блок 0 ---
00887         
00888         --- Дескриптор 0 ---
00889         int_mem_write( cmd, ret, x"00100000",  x"00008000" ); 
00890         int_mem_write( cmd, ret, x"00100004",  x"00000011" );   -- переход к следующему дескриптору 
00891 
00892         --- Дескриптор 1 ---
00893         int_mem_write( cmd, ret, x"00100008",  x"00008010" ); 
00894         int_mem_write( cmd, ret, x"0010000C",  x"00000012" );   -- переход к следующему блоку 
00895 
00896         --- Дескриптор 2 ---
00897         int_mem_write( cmd, ret, x"00100010",  x"00001002" );   -- адрес следующего дескриптора 
00898         int_mem_write( cmd, ret, x"00100014",  x"00000000" );   
00899         
00900         
00901         int_mem_write( cmd, ret, x"001001F8",  x"00000000" );
00902         int_mem_write( cmd, ret, x"001001FC",  x"14A44953" );      
00903         
00904 
00905         --- Блок 1 ---
00906         
00907         --- Дескриптор 0 ---
00908         int_mem_write( cmd, ret, x"00100200",  x"00008020" ); 
00909         int_mem_write( cmd, ret, x"00100204",  x"00000011" );   -- переход к следующему дескриптору 
00910 
00911         --- Дескриптор 1 ---
00912         int_mem_write( cmd, ret, x"00100208",  x"00008030" ); 
00913         int_mem_write( cmd, ret, x"0010020C",  x"00000010" );   -- остановка
00914         
00915         
00916         int_mem_write( cmd, ret, x"001003F8",  x"00000000" );
00917         int_mem_write( cmd, ret, x"001003FC",  x"D6BC4953" );      
00918         
00919         
00920         
00921         ---- Программирование канала DMA ----
00922         block_write( cmd, ret, 4, 8, x"00000023" );             -- DMA_MODE 
00923         block_write( cmd, ret, 4, 9, x"00000010" );             -- DMA_CTRL - RESET FIFO 
00924         
00925         block_write( cmd, ret, 4, 20, x"00100000" );    -- PCI_ADRL 
00926         block_write( cmd, ret, 4, 21, x"00100000" );    -- PCI_ADRH  
00927         block_write( cmd, ret, 4, 23, x"0001D000" );    -- LOCAL_ADR 
00928         
00929         
00930         ---- Подготовка тетрады ----
00931         trd_test_mode( cmd, ret, 0 );   -- переход в рабочий режим --
00932         trd_wait_cmd( cmd, ret, 0, 16, x"1700" );               -- DMAR0 - от тетрады 7 --
00933 
00934         trd_wait_cmd( cmd, ret, 1, 16#1D#, x"0001" );   -- Размер блока = 4 кБ --
00935 
00936         block_write( cmd, ret, 4, 9, x"00000001" );             -- DMA_CTRL - START 
00937 
00938         trd_wait_cmd( cmd, ret, 1, 16#0F#, x"0001" );   -- Подключение выхода генератора к DIO_IN --
00939         
00940         trd_wait_cmd( cmd, ret, 7,      0, x"2038" );           -- запуск тетрады DIO_OUT 
00941         
00942         trd_wait_cmd( cmd, ret, 1, 16#1C#, x"0020" );   -- Запуск тестовой последовательности --
00943         
00944         wait for 20 us;
00945         
00946         
00947         for ii in 0 to 20 loop
00948                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00949                 
00950                 write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00951                 if( data( 8 )='1' ) then
00952                         write( str, string'(" - Дескриптор правильный" ));  
00953                         error := 0;
00954                         exit;
00955                 else
00956                         write( str, string'(" - Ошибка чтения дескриптора" ));
00957                         error := error + 1;
00958                         wait for 10 us;
00959                 end if;
00960                 
00961                 writeline( log, str );  
00962         end loop;
00963         
00964         
00965         if( error=0 ) then                 
00966                 
00967                 kk:=0;
00968                 loop
00969                         
00970                 trd_status( cmd, ret, 6, status );
00971                 write( str, string'("TRD_STATUS: " )); hwrite( str, status );
00972                         
00973                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00974                 write( str, string'("    STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00975                 
00976                         if( data(4)='1' ) then
00977                                 write( str, string'(" - завершено чтение блока " ));
00978                                 block_write( cmd, ret, 4, 16#11#, x"00000010" );                -- FLAG_CLR - сброс EOT 
00979                                 kk:=kk+1;
00980                                 if( kk=4 ) then
00981                                         exit;
00982                                 end if;
00983                         end if;
00984                         writeline( log, str );                  
00985                         
00986                         wait for 500 ns;
00987                         
00988                         
00989                 end loop;
00990                 
00991                 ---- Ожидание завершения DMA ----
00992                 dma_complete := 0;
00993                 for ii in 0 to 100 loop
00994                         
00995                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
00996                 write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
00997                         if( data(5)='1' ) then
00998                                 write( str, string'(" - DMA завершён " ));
00999                                 dma_complete := 1;      
01000                                 
01001                                 block_write( cmd, ret, 4, 16#11#, x"00000010" );                -- FLAG_CLR - сброс EOT 
01002                                 
01003                         end if;
01004                         writeline( log, str );                  
01005                         
01006                         if( dma_complete=1 ) then
01007                                 exit;
01008                         end if;            
01009                         
01010                         wait for 1 us;
01011                         
01012                 end loop;
01013         
01014                 writeline( log, str );                  
01015                 
01016                 if( dma_complete=0 ) then
01017                         write( str, string'("Ошибка - DMA не завершён " ));
01018                         writeline( log, str );                  
01019                         error:=error+1;
01020                 end if;
01021 
01022         end if; 
01023         
01024         for ii in 0 to 3 loop
01025                         
01026                 block_read( cmd, ret, 4, 16, data );                    -- STATUS 
01027                 write( str, string'("STATUS: " )); hwrite( str, data( 15 downto 0 ) );
01028                 writeline( log, str );                  
01029                 wait for 500 ns;
01030                 
01031         end loop;
01032         
01033         
01034         block_write( cmd, ret, 4, 9, x"00000000" );             -- DMA_CTRL - STOP      
01035         
01036                 
01037 --      block_write( cmd, ret, 4, 9, x"00000010" );             -- DMA_CTRL - RESET FIFO 
01038 --      block_write( cmd, ret, 4, 9, x"00000000" );             -- DMA_CTRL 
01039 --      block_write( cmd, ret, 4, 9, x"00000001" );             -- DMA_CTRL - START     
01040         
01041         
01042         writeline( log, str );          
01043         if( error=0 ) then
01044                 write( str, string'(" Тест завершён успешно " ));
01045                 cnt_ok := cnt_ok + 1;
01046         else
01047                 write( str, string'(" Тест не выполнен " ));
01048                 cnt_error := cnt_error + 1;
01049         end if;
01050         writeline( log, str );  
01051         writeline( log, str );          
01052 
01053 end test_adm_write_16kb;
01054                 
01055 end package     body test_pkg;
01056 
01057