Subversion Repositories f9daq

Rev

Rev 83 | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1.  
  2.  
  3. // sudo ./pts -a 0x1000000 -v 1 -w 2 turn LED ON
  4. // sudo ./pts -a 0x1000000 -v 1 -w 1 turn LED OFF
  5. // sudo ./ptsvmusb  -a 0x02501000  -v 2 -i a.bit -b 2
  6. #include <stdlib.h>
  7. #include <stdio.h>
  8. #include <stdint.h>
  9. #include <ctype.h>
  10.  
  11. #include <string.h>
  12.  
  13. #include "vme.h"
  14.  
  15. #include <cvirte.h>            
  16.  
  17. #include "PtsModule.h"
  18. #include <userint.h>
  19. #include "PtsModule_CVI.h"
  20. #include <utility.h>
  21. #include <formatio.h>  
  22. static int p1;
  23.  
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31. int verbose;
  32. uint32_t ptaddr=0;
  33. char str[255];  
  34.  
  35. int Pts_write(uint32_t addr, uint32_t data ){
  36. int i;
  37. VME_A32D32_W(ptaddr+addr,data);
  38. return 0;
  39. }
  40.  
  41. int Pts_Mwrite(uint32_t addr, uint32_t data ){
  42. int i;
  43. VME_MW(VME_A32, VME_D32, ptaddr+addr,data);
  44. return 0;
  45. }
  46.  
  47. int Pts_read(uint32_t addr, uint32_t *data ){
  48. VME_A32D32_R(ptaddr+addr,data);
  49. return 0;
  50. }
  51.  
  52. int Pts_Mread(uint32_t addr, uint32_t *data ){
  53. VME_MRRST();   
  54. VME_MR(VME_A32, VME_D32,ptaddr+addr, data);
  55. VME_MREXEC(data);
  56. return 0;
  57. }
  58.  
  59.  
  60. int Pts_erase( int verbose ) {
  61.   uint32_t dum;
  62.  
  63.   Pts_write( ADR_CSR1, 0 );
  64.   Delay(0.1);
  65.   Pts_read( ADR_CSR1, &dum);
  66.   if( verbose ) {
  67.     sprintf(str, "CSR1(0x%02x) = 0x%04x\n", ADR_CSR1,dum & 0xffff );
  68.     SetCtrlVal (p1, P1_RESPONSE, str);
  69.   }  
  70.   Pts_write( ADR_CSR1, CSR1_PROGRAM_ );
  71.   Delay(0.1);
  72.   Pts_read( ADR_CSR1, &dum);
  73.   if( verbose ) {
  74.     sprintf( str, "CSR1(0x%02x) = 0x%04x\n", ADR_CSR1, dum & 0xffff );
  75.     SetCtrlVal (p1, P1_RESPONSE, str);
  76.   }  
  77.   return 1;
  78. }
  79.  
  80. int Pts_configure_bit( const char *filename, int mode, int verbose ) {
  81.   int c,j;
  82.   int dummyword;
  83.   FILE *fp;
  84.   const long byte_per_dot = BYTE_PER_DOT;
  85.   unsigned long nchar = 0;
  86.  
  87.   if( ( fp = fopen( filename, "rb" ) ) == NULL ) {
  88.     if( verbose ) {
  89.       sprintf( str, "cannot open \"%s\"\n", filename );
  90.     SetCtrlVal (p1, P1_RESPONSE, str);
  91.         }
  92.     return -1;
  93.   }
  94.   if(verbose) sprintf( str, "file \"%s\" opened.\n", filename );
  95.  
  96.   /* ------------------------------------------------------------ *\
  97.     The data for the configuration start from 0xffff_ffff_aa99_aa66
  98.     ( cf. xapp138; we don't know the definition of the BIT file )
  99.   \* ------------------------------------------------------------ */
  100.   dummyword = 0;
  101.   do{
  102.     if( (c = getc( fp )) == EOF ) {
  103.       if(verbose) {
  104.          sprintf(str, "EOF detected. Exit.\n");
  105.          
  106.          SetCtrlVal (p1, P1_RESPONSE, str);
  107.     }
  108.       return -1;
  109.     }
  110.     (c == 0xff) ? dummyword++ : (dummyword=0);
  111.   } while( dummyword < 4 );
  112.  
  113.   if( mode == SLAVESERIAL_MODE ) {
  114.     if(verbose)  SetCtrlVal(p1,P1_RESPONSE,"slave serial mode");
  115.     Pts_write( ADR_MODE, mode );
  116.     Pts_erase( verbose );
  117.     for( j=0; j<32; j++ ) Pts_write( ADR_CFG, 0x1 );
  118.     while( (c=getc(fp))!=EOF ){
  119.       for( j=0; j<8; j++ ) Pts_write( ADR_CFG, (c>>(7-j))&0x1 );
  120.       nchar++;
  121.       if( verbose && nchar%byte_per_dot==0 ) {
  122.         sprintf( str,"#");
  123.         SetCtrlVal(p1,P1_RESPONSE,str);
  124.       }  
  125.     }
  126.   } else if( mode == SELECTMAP_MODE ) {
  127.     if( verbose )  SetCtrlVal(p1,P1_RESPONSE,"select map mode\n");
  128.     Pts_write( ADR_MODE, SELECTMAP_MODE );
  129.     Pts_erase( verbose );
  130.         VME_MWRST();
  131.     for( j=0; j<4; j++ ) Pts_Mwrite( ADR_CFG, 0xff );
  132.         VME_MWEXEC();
  133.        
  134.     VME_MWRST();
  135.     while( (c=getc(fp))!=EOF ){
  136.       int cc = 0;
  137.       for(j=0; j<8; j++) cc |= ((c&(1<<j))>>j)<<(7-j);
  138.       Pts_Mwrite( ADR_CFG, cc );
  139.       nchar++;
  140.       if( verbose && nchar%byte_per_dot==0 ){
  141.         VME_MWEXEC();
  142.         VME_MWRST();
  143.         sprintf( str,"#");
  144.         SetCtrlVal(p1,P1_RESPONSE,str);
  145.       }  
  146.     }
  147.     VME_MWEXEC();
  148.   } else {
  149.     if(verbose) {
  150.       sprintf(str, "\nIllegal mode\n");
  151.       SetCtrlVal(p1,P1_RESPONSE,str);
  152.     }  
  153.     return -1;
  154.   }
  155.   if(verbose) {
  156.      sprintf(str,"\ntotal %ld bits\n", nchar);
  157.      
  158.       SetCtrlVal(p1,P1_RESPONSE,str);
  159.   }    
  160.   fclose(fp);
  161.   return Pts_check_configure( verbose );
  162. }
  163.  
  164. int Pts_check_configure( int verbose ) {
  165.   uint32_t csr1_value;
  166.   Pts_read(ADR_CSR1,&csr1_value);
  167.   if(verbose) {
  168.       sprintf( str,"CSR1(0x%02x)=0x%04x\n",ADR_CSR1,csr1_value&0xffff);
  169.    
  170.       SetCtrlVal(p1,P1_RESPONSE,str);
  171.   }    
  172.   if(csr1_value&CSR1_DONE) {
  173.     if(verbose) SetCtrlVal(p1,P1_RESPONSE, "configure complete.\n");
  174.     return 1;
  175.   } else {
  176.     if(verbose)  SetCtrlVal(p1,P1_RESPONSE,"configure not complete.");
  177.     return -1;
  178.   }
  179. }
  180.  
  181. int Pts_reset( int verbose ) {
  182.   Pts_write(ADR_CSR0,1);
  183.   if( verbose ) {
  184.     sprintf( str, "CSR0(0x%02x) = 0x01\n", ADR_CSR0 );
  185.      SetCtrlVal(p1,P1_RESPONSE,str);
  186.   }  
  187.   return 1;
  188. }
  189.  
  190. int Pts_write_csr( int verbose, uint32_t value ) {
  191.   Pts_write(ADR_CSR0,value);
  192.   if( verbose ) {
  193.     sprintf( str,"Pts_write_csr 0x%08x\n", value  );
  194.     SetCtrlVal(p1,P1_RESPONSE,str);
  195.   }  
  196.   return 1;
  197. }
  198.  
  199.  
  200. void help(char *argv){
  201.  sprintf(str,"Usage: %s -a ptsaddr -v verbose -c  .... Pts_check_configure\n", argv);
  202.  SetCtrlVal(p1,P1_RESPONSE,str);
  203.  sprintf(str,"Usage: %s -a ptsaddr -v verbose -i filename -b mode (2) ... Pts_configure_bit\n", argv);
  204.  SetCtrlVal(p1,P1_RESPONSE,str);
  205.  sprintf(str,"Usage: %s -a ptsaddr -v verbose -e  .... Pts_erase\n", argv);
  206.  SetCtrlVal(p1,P1_RESPONSE,str);
  207.  sprintf(str,"Usage: %s -a ptsaddr -v verbose -x  .... Pts_reset\n", argv);
  208.  SetCtrlVal(p1,P1_RESPONSE,str);
  209.  sprintf(str,"Usage: %s -a ptsaddr -v verbose -c  .... Pts_check_configure\n", argv);
  210.  SetCtrlVal(p1,P1_RESPONSE,str);
  211.  sprintf(str,"Usage: %s -a ptsaddr -v verbose -r  .... vme read\n", argv);
  212.  SetCtrlVal(p1,P1_RESPONSE,str);
  213.  sprintf(str,"Usage: %s -a ptsaddr -v verbose -w value .... vme write\n", argv);
  214.  SetCtrlVal(p1,P1_RESPONSE,str);
  215.  sprintf(str,"Usage: %s -a ptsaddr -v verbose -s value .... Pts_write_csr\n", argv);
  216.  SetCtrlVal(p1,P1_RESPONSE,str);
  217.  sprintf(str,"Example: %s  --address  0x1000000 --verbose 1 --erase\n", argv);
  218.  SetCtrlVal(p1,P1_RESPONSE,str);
  219.  sprintf(str,"Example: %s --address  0x1000000 --verbose 1 --input pts_scaler.bit --load-bit 2\n", argv);
  220.  SetCtrlVal(p1,P1_RESPONSE,str);
  221.  sprintf(str,"Example: %s --address  0x1000004 --write-csr 0x7600\n", argv);SetCtrlVal(p1,P1_RESPONSE,str);
  222. }
  223.  
  224.  
  225. int CVICALLBACK Reset (int panel, int control, int event,
  226.                 void *callbackData, int eventData1, int eventData2)
  227. {
  228.         switch (event)
  229.                 {
  230.                 case EVENT_COMMIT:
  231.                         Pts_reset(verbose);
  232.                         break;
  233.                 }
  234.         return 0;
  235. }
  236.  
  237. int CVICALLBACK Erase (int panel, int control, int event,
  238.                 void *callbackData, int eventData1, int eventData2)
  239. {
  240.         switch (event)
  241.                 {
  242.                 case EVENT_COMMIT:
  243.                          Pts_erase(verbose);  
  244.                         break;
  245.                 }
  246.         return 0;
  247. }
  248.  
  249. int CVICALLBACK Download (int panel, int control, int event,
  250.                 void *callbackData, int eventData1, int eventData2)
  251. {
  252.     char filename[254];
  253.     int mode=0;
  254.         switch (event)
  255.                 {
  256.                 case EVENT_COMMIT:
  257.                          GetCtrlVal(p1,P1_FIRMWARE,filename);
  258.                          GetCtrlVal(p1,P1_MODE,&mode);
  259.              if(VME_CONNECTED() >=0 ) {
  260.                Pts_configure_bit( filename, mode,  verbose );
  261.                          } else {
  262.                            MessagePopup ("Warning", "Connect VME!!");
  263.                          }  
  264.                         break;
  265.                 }
  266.         return 0;
  267. }
  268.  
  269. int CVICALLBACK Check (int panel, int control, int event,
  270.                 void *callbackData, int eventData1, int eventData2)
  271. {
  272.         switch (event)
  273.                 {
  274.                 case EVENT_COMMIT:
  275.                          Pts_check_configure( verbose );  
  276.                         break;
  277.                 }
  278.         return 0;
  279. }
  280.  
  281. int CVICALLBACK Read (int panel, int control, int event,
  282.                 void *callbackData, int eventData1, int eventData2)
  283. {
  284.     uint32_t value=0;
  285.     char str[0xFF];
  286.         char saddr[256];
  287.         int offset;
  288.         switch (event)
  289.                 {
  290.                 case EVENT_COMMIT:
  291.                         GetCtrlVal(p1,P1_OFFSET,saddr);
  292.                         offset = strtoul (saddr,NULL,0);
  293.                         Pts_read( offset , &value );
  294.                         if( verbose ) {
  295.                sprintf(str, "VME Read addr 0x%0x+0x%0x  response 0x%0x\n", ptaddr, offset, value );
  296.                SetCtrlVal (p1, P1_RESPONSE, str);
  297.             }
  298.                         break;
  299.                 }
  300.         return 0;
  301. }
  302.  
  303. int CVICALLBACK Write (int panel, int control, int event,
  304.                 void *callbackData, int eventData1, int eventData2)
  305. {
  306.     int value;
  307.         int offset;
  308.     char svalue[256];
  309.     char saddr[256];
  310.         switch (event)
  311.                 {
  312.                 case EVENT_COMMIT:
  313.                       GetCtrlVal(p1,P1_DATA,svalue);
  314.                           GetCtrlVal(p1,P1_OFFSET,saddr);  
  315.                          value  = strtoul (svalue,NULL,0);
  316.                          offset = strtoul (saddr,NULL,0);
  317.             Pts_write( offset , value );
  318.                         if( verbose ) {
  319.                sprintf(str, "VME Write addr 0x%0x+0x%0x  data 0x%0x\n", ptaddr, offset, value );
  320.                SetCtrlVal (p1, P1_RESPONSE, str);
  321.             }
  322.                         break;
  323.                 }
  324.         return 0;
  325. }
  326.  
  327. int CVICALLBACK WriteCSR (int panel, int control, int event,
  328.                 void *callbackData, int eventData1, int eventData2)
  329. {
  330.       int value;
  331.     char svalue[256];
  332.         switch (event)
  333.                 {
  334.                 case EVENT_COMMIT:
  335.                      GetCtrlVal(p1,P1_DATA,svalue);
  336.                          value = strtoul (svalue,NULL,0);
  337.                          Pts_write_csr( verbose, value );
  338.                         break;
  339.                 }
  340.         return 0;
  341. }
  342.  
  343. int CVICALLBACK Verbose (int panel, int control, int event,
  344.                 void *callbackData, int eventData1, int eventData2)
  345. {
  346.     int * data;
  347.         switch (event)
  348.                 {
  349.                 case EVENT_COMMIT:
  350.                     GetCtrlVal(panel,control,&verbose);
  351.                          
  352.                         break;
  353.                 }
  354.         return 0;
  355. }
  356.  
  357. int CVICALLBACK Help (int panel, int control, int event,
  358.                 void *callbackData, int eventData1, int eventData2)
  359. {
  360.         switch (event)
  361.                 {
  362.                 case EVENT_COMMIT:
  363.                         help("PtsModule");
  364.                         break;
  365.                 }
  366.         return 0;
  367. }
  368.  
  369. int CVICALLBACK Address (int panel, int control, int event,
  370.                 void *callbackData, int eventData1, int eventData2)
  371. {
  372.    char saddr[100];
  373.         switch (event)
  374.                 {
  375.                 case EVENT_COMMIT:
  376.                     GetCtrlVal(p1,P1_ADDRESS,saddr);
  377.                         ptaddr  =  strtoul (saddr,NULL,0);  
  378.                         break;
  379.                 }
  380.         return 0;
  381. }
  382.  
  383. int CVICALLBACK Exit (int panel, int control, int event,
  384.                 void *callbackData, int eventData1, int eventData2)
  385. {
  386.         switch (event)
  387.                 {
  388.                 case EVENT_COMMIT:
  389.                         QuitUserInterface(0);
  390.                         break;
  391.                 }
  392.         return 0;
  393. }
  394.  
  395. int CVICALLBACK FSelect (int panel, int control, int event,
  396.                 void *callbackData, int eventData1, int eventData2)
  397. {
  398.    int status;
  399.    char pathName[MAX_PATHNAME_LEN];
  400.         switch (event)
  401.                 {
  402.                 case EVENT_COMMIT:
  403.                         status = FileSelectPopup ("", "*.bit", "*.bit", "Select Firmware file",
  404.                                                                           VAL_SELECT_BUTTON, 0, 0, 1, 0, pathName);
  405.                         if (status>0) SetCtrlVal(p1,P1_FIRMWARE,pathName);                                               
  406.                         break;
  407.                 }
  408.         return 0;
  409. }
  410.  
  411. int CVICALLBACK LedCB (int panel, int control, int event,
  412.                 void *callbackData, int eventData1, int eventData2)
  413. {
  414.         switch (event)
  415.                 {
  416.                 int value=0;
  417.                 case EVENT_COMMIT:
  418.                         if(VME_CONNECTED() <0 ) {
  419.                            MessagePopup ("Warning", "Connect VME!!");
  420.                            return 0;
  421.                         }  
  422.                         GetCtrlVal(p1,P1_LED,&value);
  423.                          
  424.             Pts_write( 0 , value+1 );
  425.                        
  426.                         break;
  427.                 }
  428.         return 0;
  429. }
  430.  
  431. int CVICALLBACK Execute (int panel, int control, int event,
  432.                 void *callbackData, int eventData1, int eventData2)
  433. {
  434.         switch (event)
  435.         {
  436.                 case EVENT_COMMIT:{
  437.                     int n,i,nb;
  438.                         char buf[400];
  439.                         unsigned int data, addr;
  440.                         char sdata[255], saddr[255], rw[255];
  441.                         if(VME_CONNECTED() <0 ) {
  442.                            MessagePopup ("Warning", "Connect VME!!");
  443.                            return 0;
  444.                          }  
  445.                         GetNumTextBoxLines(panel, P1_COMMANDS,&n);
  446.                         for (i=0;i<n;i++){
  447.                       GetTextBoxLine(panel, P1_COMMANDS, i, buf);
  448.                       nb = sscanf(buf,"%s%s%s",rw, saddr,sdata);
  449.                       addr  =   strtoul (saddr,NULL,0);
  450.                           data  =   strtoul (sdata,NULL,0);    
  451.               if (strstr(rw,"W")!=NULL){
  452.                              Pts_write( addr , data );
  453.                                  if( verbose ) {
  454.                    sprintf(str, "VME Write addr 0x%0x+0x%0x  data 0x%0x\n", ptaddr, addr, data );
  455.                    SetCtrlVal (p1, P1_RESPONSE, str);
  456.                  }
  457.                           } else {
  458.                             Pts_Mread( addr , &data );
  459.                             if( verbose ) {
  460.                   sprintf(str, "VME Read addr 0x%0x+0x%0x  response 0x%0x\n", ptaddr,  addr, data);
  461.                   SetCtrlVal (p1, P1_RESPONSE, str);
  462.                 }
  463.                           }
  464.                         }  
  465.                         break;
  466.                                                   }
  467.         }
  468.         return 0;
  469. }
  470.  
  471. int CVICALLBACK Connect (int panel, int control, int event,
  472.                                                  void *callbackData, int eventData1, int eventData2)
  473. {
  474.         int interface = 0;
  475.         switch (event)
  476.         {
  477.                
  478.                 case EVENT_COMMIT:
  479.                         GetCtrlVal (p1, P1_VMEINTERFACE, &interface);
  480.                 VME_START(interface);  
  481.                         break;
  482.         }
  483.         return 0;
  484. }
  485.  
  486. int CVICALLBACK Disconnect (int panel, int control, int event,
  487.                                                         void *callbackData, int eventData1, int eventData2)
  488. {
  489.         switch (event)
  490.         {
  491.                 case EVENT_COMMIT:
  492.                         VME_STOP();
  493.                         break;
  494.         }
  495.         return 0;
  496. }
  497.  
  498.  
  499. int __stdcall WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
  500.                        LPSTR lpszCmdLine, int nCmdShow)
  501. {
  502.     char saddr[255];
  503.         if (InitCVIRTE (hInstance, 0, 0) == 0)
  504.                 return -1;      /* out of memory */
  505.         if ((p1 = LoadPanel (0, "PtsModule_CVI.uir", P1)) < 0)
  506.                 return -1;
  507.         DisplayPanel (p1);
  508.        
  509.         GetCtrlVal(p1,P1_VERBOSE,&verbose);  
  510.         GetCtrlVal(p1,P1_ADDRESS,saddr);
  511.      ptaddr  =  strtoul (saddr,NULL,0);  
  512.         RunUserInterface ();
  513.         DiscardPanel (p1);
  514.         VME_STOP();
  515.         return 0;
  516. }
  517.