commands.cpp

linux下vme总线驱动代码

 *------------------------------------------------------------------------mjw-*/
void DisplayWord(char *b,int l)
{
  unsigned short *dma_buffer;
  long pnt;
  unsigned int count,x,num,n;
  int error;
  unsigned short v;

  num = sscanf(b,"%lx %x",&pnt,&count);

  pnt *= 2;
  pnt += FixedAdder;

  if (num < 1) {
    pnt = lastpnt;
    num = 1;
  }

  if (num == 1) {
    count = DEFCNT;
    num = 2;
  }

  if (num != 2) {
    printf("Usage: dw address [count]");
  } else {
//    count /= 2;  
    if (ValidAddress(pnt)) {
      if (default_mode == MODE_PROGRAMMED) {
        lastpnt = pnt + count * 2;
        for (x=0;x<count;x++) {
          if (!binary) {
            if (x % 8 == 0) {
              printf("%08lX: ",(x*2)+pnt);
              printf("%08lX: ",(x+((pnt-FixedAdder)/2)));
            }
            if (x % 8 == 4)
              printf("- ");

            v = rw(x*2+pnt,&error);  
            if (!error)
              printf("%04X ",v);
            else
              printf("**** ");

            if (x % 8 == 7)
              printf("\n");
          } else {
            v = rw(pnt+x*2,&error);  
            if (!error)
              printf("%c%c",(v&0x00FF),((v&0xFF00)>>8));
            else
              printf("**");
          }
        }
      } else {  // end Mode Programmed
        if (!quiet)
          printf("--> Doing Read via DMA <--\n");
        dma_buffer = (unsigned short *)malloc(count);
        lastpnt = pnt + count * 2;
        // Do The DMA Transfer
        ioctl(vme_handle,IOCTL_SET_MODE,MODE_DMA);
        lseek(vme_handle,pnt,SEEK_SET);
        n = read(vme_handle,dma_buffer,count*2);
        ioctl(vme_handle,IOCTL_SET_MODE,MODE_PROGRAMMED);

        if (n < 1) {
          printf("BUS Error\n");
        } else {
          // Print the Results
          for (x=0;x<(n/2);x++) {
            if (!binary) {
              if (x % 8 == 0)
                printf("%08lX: ",(x+pnt));
              if (x % 8 == 4)
                printf("- ");
              printf("%04X ",(unsigned short)dma_buffer[x]);
              if (x % 8 == 7)
                printf("\n");
            } else {
              v = dma_buffer[x];
              printf("%c%c",(v&0x00FF),((v&0xFF00)>>8));
            }
          }  
        }  
        free(dma_buffer);
      } // end Mode DMA
    }
  }
}

/*------------------------------------------------------------------------------
 * DisplayLong
 *   usage: display addr count
 *------------------------------------------------------------------------mjw-*/
void DisplayLong(char *b,int l)
{
  unsigned int *dma_buffer;
  long pnt;
  unsigned int count,x,num,n;
  int error;
  unsigned long v;

  num = sscanf(b,"%lx %x",&pnt,&count);

  pnt += FixedAdder;

  if (num < 1) {
    pnt = lastpnt;
    num = 1;
  }

  if (num == 1) {
    count = DEFCNT;
    num = 2;
  }

  if (num != 2) {
    printf("Usage: dl address [count]");
  } else {
    count /= 4;  
    if (ValidAddress(pnt)) {
      if (default_mode == MODE_PROGRAMMED) {
        lastpnt = pnt + count*4;
        for (x=0;x<count;x++) {
          if (!binary) {
            if (x % 4 == 0)
              printf("%08lX: ",(x*4+pnt));
            if (x % 4 == 2)
              printf("- ");
            v = rl(x*4+pnt,&error);  
            if (!error)
              printf("%08lX ",v);
            else
              printf("******** ");
            if (x % 4 == 3)
              printf("\n");

          } else {
            v = rl(x*4+pnt,&error);  
            if (!error)
              printf("%c%c%c%c",  (char)(v&0x000000FF), (char) ((v&0x0000FF00)>>8),
                     (char)((v&0x00FF0000)>>16), (char)((v&0xFF000000)>>24));
            else
              printf("****");
          }  
        }         
      } else {
        if (!quiet)
          printf("--> Doing Read via DMA <--\n");
        dma_buffer = (unsigned int *)malloc(count);
        lastpnt = pnt + count * 4;
        // Do The DMA Transfer
        ioctl(vme_handle,IOCTL_SET_MODE,MODE_DMA);
        lseek(vme_handle,pnt,SEEK_SET);
        n = read(vme_handle,dma_buffer,count*4);
        ioctl(vme_handle,IOCTL_SET_MODE,MODE_PROGRAMMED);

        if (n < 1) {
          printf("BUS Error\n");
        } else {
          for (x=0;x<(n/4);x++) {
            if (!binary) {
              if (x % 4 == 0)
                printf("%08lX: ",(x*4+pnt));
              if (x % 4 == 2)
                printf("- ");
              printf("%08X ",(unsigned int)dma_buffer[x]);
              if (x % 4 == 3)
                printf("\n");
            } else {
              v = dma_buffer[x];
              printf("%c%c%c%c",  (char)(v&0x000000FF),  (char)((v&0x0000FF00)>>8),
                     (char)((v&0x00FF0000)>>16), (char)((v&0xFF000000)>>24));
            }
          }   
        }    
      }
    }
  }
}

/*------------------------------------------------------------------------------
 * Write 
 *   usage: Write addr value
 *------------------------------------------------------------------------mjw-*/
void Write(char *b,int l)
{
  long pnt,num,cnt,x;
  unsigned char v;
  int error;

  num = sscanf(b,"%lx %hhx %lx",&pnt,&v,&cnt);

  pnt += FixedAdder;

  if (num < 2) {
    printf("Usage: w address value [count]");
  } else {
    if (num < 3)
      cnt = 1;
    if (ValidAddress(pnt)) {
      for (x=0;x<cnt;x++) {
        wb(pnt++,v,&error);
        if (error)
          printf("BUS Error during Write at address %08lX\n",pnt-1);
      } 
    }
  }  
}

/*------------------------------------------------------------------------------
 * WriteWord 
 *   usage: Write addr value
 *------------------------------------------------------------------------mjw-*/
void WriteWord(char *b,int l)
{
  long pnt,num,cnt,x;
  unsigned short v;
  int error;

  num = sscanf(b,"%lx %hx %lx",&pnt,&v,&cnt);

  pnt *= 2;            // word addressing
  pnt += FixedAdder;

  if (num < 2) {
    printf("Usage: ww address value [count]");
  } else {
    if (num < 3)
      cnt = 1;
    if (ValidAddress(pnt)) {
      for (x=0;x<cnt;x++) {
        ww(pnt,v,&error);
        pnt += 2;         
        if (error)
          printf("BUS Error during Write at address %08lX\n",pnt-2);
      } 
    }
  }  
}

/*------------------------------------------------------------------------------
 * WriteLong 
 *   usage: Write addr value
 *------------------------------------------------------------------------mjw-*/
void WriteLong(char *b,int l)
{
  long pnt,num,cnt,x;
  unsigned long v;
  int error;

  num = sscanf(b,"%lx %lx %lx",&pnt,&v,&cnt);

  pnt += FixedAdder;

  if (num < 2) {
    printf("Usage: wl address value [count]");
  } else {
    if (num < 3)
      cnt = 1;
    if (ValidAddress(pnt)) {
      for (x=0;x<cnt;x++) {
        wl(pnt,v,&error);
        pnt += 4;         
        if (error)
          printf("BUS Error during Write at address %08lX\n",pnt-4);
      } 
    }
  }  
}

/*------------------------------------------------------------------------------
 * Seek
 *
 *------------------------------------------------------------------------mjw-*/
void Seek(char *b,int l)
{
  unsigned int num;
  long ptr;

  num = sscanf(b,"%lx",&ptr);

  ptr += FixedAdder;

  if (ValidAddress(ptr)) {
    if (num != 1) {
      printf("Seek usage:  SEEK address\n");
    } else {
      lseek(vme_handle,ptr,SEEK_SET);
    } 
  }
}                                                                               

/*------------------------------------------------------------------------------
 * wint
 *  wait for VME interrupt
 *------------------------------------------------------------------------mjw-*/
void wint(char *b, int l)
{
  unsigned int a,num;
  num = sscanf(b, "%x", &a);

  if (num != 1) {
    printf("wint usage:  wint v\n");
    printf("  where v = 0 is don't wait for ints\n");
    printf("        v = n (vme interrupt) is wait for ints before read\n");  
  } else {
    ioctl(vme_handle,IOCTL_SET_WINT,a);    // Set WINT flag
  }     
}  

/*------------------------------------------------------------------------------
 * WriteReg
 *
 *------------------------------------------------------------------------mjw-*/
void WriteReg(char *b,int l)
{
  unsigned int num,value;
  long reg;

  num = sscanf(b,"%lx %x",&reg,&value);

  if (num != 2) {
    printf("REGW usage:  REGW register value\n");    
  } else {
    printf("Universe Reg Assigned %04lX = %08X\n",reg,value);  
    WriteUniReg(reg,value);
  }
}                                                                               

/*------------------------------------------------------------------------------
 * ReadReg
 *
 *------------------------------------------------------------------------mjw-*/
void ReadReg(char *b,int l)
{
  unsigned int num,value;
  long reg;

  num = sscanf(b,"%lx",&reg);

  if (num != 1) {
    printf("REGR usage:  REGW register\n");
  } else {
    value = ReadUniReg(reg);
    printf("Universe Reg %04lX = %08X\n",reg,value);  
  }
}                                                                               

/*------------------------------------------------------------------------------
 * ReadFile
 *
 *------------------------------------------------------------------------mjw-*/
void ReadFile(char *b,int l)
{
  int num,c,n;
  long pnt,len,i = 0;
  char fname[255];
  FILE *fout;
  int error;
  unsigned int *dma_buffer;

  num = sscanf(b,"%lx %li %s",&pnt,&len,fname);

  pnt += FixedAdder;

  if (num != 3) {
    printf("Usage: ReadFile address len filename");
  } else {
    if (ValidAddress(pnt)) {
      fout = fopen(fname,"wb");
      if (!fout) {
        printf("Can't open file %s\n",fname);
      } else {
        if (default_mode == MODE_PROGRAMMED) {
          // Do it via PROGRAMMED IO
          while (i++ < len) {
            c = rb(pnt++,&error);
            if (error) {
              printf("Bus Error during Readfile. File may be truncated.\n");
              len = 0;
            } else
              putc(c,fout);
          }
          // VIA DMA
        } else {
          if (!quiet)
            printf("--> Doing ReadFile via DMA <--\n");
          dma_buffer = (unsigned int *)malloc(len);
          // Do The DMA Transfer
          ioctl(vme_handle,IOCTL_SET_MODE,MODE_DMA);
          lseek(vme_handle,pnt,SEEK_SET);
          n = read(vme_handle,dma_buffer,len);
          ioctl(vme_handle,IOCTL_SET_MODE,MODE_PROGRAMMED);
          if (n < 1) {
            printf("BUS Error during DMA Transfer\n");
          } else {
            while (i++ < len)
              putc(dma_buffer[i],fout);
          }
          free(dma_buffer);
        }    

        fclose(fout);
        if (!quiet)
          printf("Done Reading Memory to a File\n");
      } 
    }
  }  
}

/*------------------------------------------------------------------------------
 * TestDMA
 *
 *------------------------------------------------------------------------mjw-*/
/*
void TestDMA(char *b,int l)
{
  int num;
  unsigned int pci_pnt,vme_pnt,len, val, temp;
  char testme[] = 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
      0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27;
      
  num = sscanf(b,"%lx %lx %lx",&pci_pnt,&vme_pnt,&len);

  if (num == 0) {
    pci_pnt = 0;
    vme_pnt = 0xa5000000;
    len     = 16;
    num     = 3;
  }
  
  if (num != 3) {
    printf("Usage: TestDMA pciaddr vmeaddr len");
  } else {

    val = ReadUniReg(PCI_CSR);    // Lets Clear any error flags
    WriteUniReg(PCI_CSR,val | 0xF8000000);
  
    WriteUniReg(DCTL,0x80820100);  // Setup Control Reg
    WriteUniReg(DTBC,len);         // Setup Length
    WriteUniReg(DLA,pci_pnt);      // Setup PCI Address
    WriteUniReg(DVA,vme_pnt);      // Setup VME Address
    WriteUniReg(DGCS,0x80006F00);  // GO
 
    val = ReadUniReg(DGCS); 
  
    printf("DMA General Control Reg Value   = %08X\n",val);
    temp = val & 0x00008000;
    if (temp)
      printf("    Active\n");
    temp = val & 0x00004000;
    if (temp)
      printf("    Stopped Flag\n");
    temp = val & 0x00002000;
    if (temp)
      printf("    Halted Flag\n");
    temp = val & 0x00000800;
    if (temp)
      printf("    Transfers Complete\n");
    temp = val & 0x00000400;
    if (temp)
      printf("    PCI Bus Error\n");
    temp = val & 0x00000200;
    if (temp)
      printf("    VME Bus Error\n");
    temp = val & 0x00000100;
    if (temp)
      printf("    Protocol Error\n");
      
    val = ReadUniReg(PCI_CSR); 
  
    printf("PCI Configuration Space Control = %08X\n",val);
    temp = val & 0x80000000;
    if (temp)
      printf("    Parity Error\n");
    temp = val & 0x40000000;
    if (temp)
      printf("    Signalled SERR#\n");
    temp = val & 0x20000000;
    if (temp)
      printf("    Received Master-Abort\n");
    temp = val & 0x10000000;
    if (temp)
      printf("    Reveiced Target-Abort\n");
    temp = val & 0x08000000;
    if (temp)
      printf("    Signalled Target-Abort\n");
  }  
}
*/

/*------------------------------------------------------------------------------
 * TestDMA
 *