commands.cpp

linux下vme总线驱动代码

 *------------------------------------------------------------------------mjw-*/
void TestDMA(char *b,int l)
{
  int num;
  unsigned int vme_pnt,len,n,x;
  char buf[16];

  num = sscanf(b,"%x %x",&vme_pnt,&len);

  if (num == 0) {
    vme_pnt = 0x8000;
    len     = 16;
    num     = 2;
  }

  if (num != 2) {
    printf("Usage: TestDMA offset len");
    printf("  This will read len bytes via DMA from address offset");
  } else {

    printf("Read Test.");
    ioctl(vme_handle,IOCTL_SET_MODE,MODE_DMA);
    lseek(vme_handle,vme_pnt,SEEK_SET);
    n = read(vme_handle,buf,len);
    ioctl(vme_handle,IOCTL_SET_MODE,MODE_PROGRAMMED);

    for (x=0;x<n;x++) {
      if (x % 16 == 0)
        printf("%08X: ",x);
      if (x % 16 == 8)
        printf("- ");
      printf("%02X ",(unsigned char)buf[x]);
      if (x % 16 == 15)
        printf("\n");
    }

//    printf("Write Test.");
//    ioctl(vme_handle,IOCTL_SET_MODE,MODE_DMA);
//    lseek(vme_handle,vme_pnt,SEEK_SET);
//    write(vme_handle,buf,len);
//    ioctl(vme_handle,IOCTL_SET_MODE,MODE_PROGRAMMED);
  }
}

/*------------------------------------------------------------------------------
 * TestProgrammed
 *
 *------------------------------------------------------------------------mjw-*/
void TestProgrammed(char *b,int l)
{
  int num;
  unsigned int vme_pnt,len, n, x;
  char buf[16];

  num = sscanf(b,"%x %x",&vme_pnt,&len);

  if (num == 0) {
    vme_pnt = 0x8000;
    len     = 16;
    num     = 2;
  }

  if (num != 2) {
    printf("Usage: TestDMA offset len");
    printf("  This will read len bytes via DMA from address offset");
  } else {

    printf("Read Test.");
    ioctl(vme_handle,IOCTL_SET_MODE,MODE_PROGRAMMED);
    lseek(vme_handle,vme_pnt,SEEK_SET);
    n = read(vme_handle,buf,len);

    for (x=0;x<n;x++) {
      if (x % 16 == 0)
        printf("%08X: ",x);
      if (x % 16 == 8)
        printf("- ");
      printf("%02X ",(unsigned char)buf[x]);
      if (x % 16 == 15)
        printf("\n");
    }

    printf("Write Test.");
    ioctl(vme_handle,IOCTL_SET_MODE,MODE_PROGRAMMED);
    lseek(vme_handle,vme_pnt,SEEK_SET);
    write(vme_handle,buf,len);
  }
}

/*------------------------------------------------------------------------------
 * TestRead 
 *
 *------------------------------------------------------------------------mjw-*/
void TestRead(char *b,int l)
{
  unsigned int pnt,len,x,n,num;
  unsigned char block[1024];

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

  if (num != 2) {
    len = 16;
    pnt = 0;
  }

  pnt += FixedAdder;

  if (ValidAddress(pnt)) {
    lseek(vme_handle,pnt,SEEK_SET);
    n = read(vme_handle,block,len);

    if (n) {
      for (x=0;x<n;x++) {
        if (x % 16 == 0)
          printf("%08X: ",x+pnt);
        if (x % 16 == 8)
          printf("- ");
        printf("%02X ",block[x]);
        if (x % 16 == 15)
          printf("\n");
      }
    } else {
      printf(" Read Failed.\n");
    }  

    printf("Test Read Done..\n");
  }
}

/*------------------------------------------------------------------------------
 * TestWrite 
 *
 *------------------------------------------------------------------------mjw-*/
void TestWrite(char *b,int l)
{
  long pnt,num,x;         
  int error;

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

  if (num != 1) {
    pnt = 0;
  }

  pnt += FixedAdder;

  if (ValidAddress(pnt)) {
    for (x=0;x<16;x++) {
      wb(pnt+x,0xAB,&error);
    }  

    printf("Test Write Done..\n");
  }
}

/*-----------------------------------------------------------------------------
 * regs 
 *
 *------------------------------------------------------------------------mjw-*/
void regs(char *b,int l)
{
  unsigned int val;
  unsigned int temp;

  printf("Registers:\n");

  val = ReadUniReg(LMISC);
  printf("  LMISC    = %08X\n",val);
  temp = (val & 0xF0000000) >> 28;
  if (temp == 0)
    printf("    CRT    = Disabled\n");
  else if (temp == 1)
    printf("    CRT    = 128us\n");
  else if (temp == 2)
    printf("    CRT    = 256us\n");
  else if (temp == 3)
    printf("    CRT    = 512us\n");
  else if (temp == 4)
    printf("    CRT    = 1024us\n");
  else if (temp == 5)
    printf("    CRT    = 2048us\n");
  else if (temp == 6)
    printf("    CRT    = 4096us\n");
  else if (temp == 7)
    printf("    CRT    = Reserved\n");

  temp = (val & 0x0F000000) >> 24;
  if (temp == 0)
    printf("    CWT    = Disabled\n");
  else if (temp == 1)
    printf("    CWT    = 16 PCI Clocks\n");
  else if (temp == 2)
    printf("    CWT    = 32 PCI Clocks\n");
  else if (temp == 3)
    printf("    CWT    = 64 PCI Clocks\n");
  else if (temp == 4)
    printf("    CWT    = 128 PCI Clocks\n");
  else if (temp == 5)
    printf("    CWT    = 256 PCI Clocks\n");
  else if (temp == 6)
    printf("    CWT    = 512 PCI Clocks\n");
  else if (temp == 7)
    printf("    CWT    = Reserved\n");

  val = ReadUniReg(LSI0_CTL);
  printf("  LSIO_CTL = %08X\n",val);
  temp = (val & 0x80000000) >> 31;
  if (temp == 0)
    printf("    EN     = Disabled\n");
  else if (temp == 1)
    printf("    EN     = Enabled\n");

  temp = val & 0x40000000;
  if (temp)
    printf("    PWEN   = Enabled\n");
  else
    printf("    PWEN   = Disabled\n");
  temp = (val & 0x00C00000) >> 22;
  if (temp == 0)
    printf("    VDW    = 8 bit\n");
  else if (temp == 1)
    printf("    VDW    = 16 Bit\n");
  else if (temp == 2)
    printf("    VDW    = 32 Bit\n");
  else if (temp == 3)
    printf("    VDW    = 64 Bit\n");

  temp = (val & 0x70000) >> 16;
  if (temp == 0)
    printf("    VAS    = A16\n");
  else if (temp == 1)
    printf("    VAS    = A24\n");
  else if (temp == 2)
    printf("    VAS    = A32\n");
  else if (temp == 3)
    printf("    VAS    = Reserved\n");
  else if (temp == 4)
    printf("    VAS    = Reserved\n");
  else if (temp == 5)
    printf("    VAS    = CR/CSR\n");
  else if (temp == 6)
    printf("    VAS    = User 1\n");
  else if (temp == 7)
    printf("    VAS    = User 2\n");

  temp = (val & 0xC000) >> 14;
  if (temp == 0)
    printf("    PGM    = Data\n");
  else if (temp == 1)
    printf("    PGM    = Program\n");
  else if (temp == 2)
    printf("    PGM    = Reserved\n");
  else if (temp == 3)
    printf("    PGM    = Reserved\n");

  temp = (val & 0x3000) >> 12;
  if (temp == 0)
    printf("    SUPER  = Non-Privileged\n");
  else if (temp == 1)
    printf("    SUPER  = Supervisor\n");

  temp = (val & 0x0100) >> 8;
  if (temp == 0)
    printf("    VCT    = Single Cycles Only\n");
  else if (temp == 1)
    printf("    VCT    = Block Transfers OK\n");

  temp = (val & 0x03);
  if (temp == 0)
    printf("    LAS    = PCI Bus Memory Space\n");
  else if (temp == 1)
    printf("    LAS    = PCI Bus I/O Space\n");
  else if (temp == 2)
    printf("    LAS    = PCI Bus Type 1 Config Space\n");
  else if (temp == 3)
    printf("    LAS    = Reserved\n");

  printf("  LSIO_BS  = %08X\n",ReadUniReg(LSI0_BS));
  printf("  LSIO_BD  = %08X\n",ReadUniReg(LSI0_BD));
  printf("  LSIO_TO  = %08X\n",ReadUniReg(LSI0_TO));
}  

/*------------------------------------------------------------------------------
 *  vmespace1
 *
 *------------------------------------------------------------------------mjw-*/
void vmespace1(char *b,int l)
{
  int num,temp;

  num = sscanf(b,"%x",&temp);

  if (num == 0) {
    printf("  VME Address Space: ");
    if (VMEspace == 1) {
      printf("A16\n");
    } else if (VMEspace == 2) {
      printf("A24\n");
    } else if (VMEspace == 3) {
      printf("A32\n");
    }
  } else if (num == 1) {
    if (temp == 1) {
      printf("Setting to A16\n");
//      vmespace(VME_A16);
    } else if (temp == 2) {
      printf("Setting to A24\n");
//      vmespace(VME_A24);
    } else if (temp == 3) {
      printf("Setting to A32\n");
//      vmespace(VME_A32);
    } else
      printf("Invalid Value for VMEspace\n");
  } else {
    printf("\nUsage: vmespace space\n");
    printf("  where if space = 1, VME Address Space = A16\n");
    printf("  where if space = 2, VME Address Space = A24\n");
    printf("  where if space = 3, VME Address Space = A32\n");
  }  
}

/*------------------------------------------------------------------------------
 * vmemap1 
 *
 *------------------------------------------------------------------------mjw-*/
void vmemap1(char *b,int l)
{
  int num;
  long temp,count,space,size,type;
  char vmespc = 0;

  num = sscanf(b,"%lx %lx %lx %lx %lx",&temp,&count,&space,&size,&type);

  if (num != 5) {
    printf("Usage: map address count space size type\n");
    printf("  where address is VME Address to set Universe image to\n");
    printf("    Space = 0 CR/CSR    Space = 1 A16\n");
    printf("    Space = 2 A24       Space = 3 A32\n\n");
    printf("    Size  = 1 8 bit     Size  = 2 16 bit\n");
    printf("    Size  = 3 32 bit    Size  = 4 64 bit\n\n");
    printf("    Type  = 0 USR/DATA  Type  = 1 USR/PRG\n");
    printf("    Type  = 2 SUP/DATA  Type  = 3 SUP/PRG\n");
  } else {
    if (!quiet)
      printf("Setting PCI Slave Image to address %08lX\n",temp);

    // VME Size
    if (size == 1) {
      vmespc = VME_SIZE_8;         
    } else if (size == 2) {
      vmespc = VME_SIZE_16;        
    } else if (size == 3) {
      vmespc = VME_SIZE_32;        
    } else if (size == 4) {
      vmespc = VME_SIZE_64;        
    } else
      printf(" Bad Size\n");
    FixedAdder = temp;                           

    vmespc |= space;

    switch (type) {
    case 0:
      vmespc &= ~VME_SUP_USR;
      vmespc &= ~VME_PRG_DATA;
      break;
    case 1:
      vmespc &= ~VME_SUP_USR;
      vmespc |= VME_PRG_DATA;
      break;
    case 2:
      vmespc |= VME_SUP_USR;
      vmespc &= ~VME_PRG_DATA;
      break;
    case 3:
      vmespc |= VME_SUP_USR;
      vmespc |= VME_PRG_DATA;
      break;
    }
    VME_Valid_Base = temp;
    VME_Valid_Cnt  = count;
    vmemap(temp,count,vmespc);
  }
}

/*------------------------------------------------------------------------------
 * quit 
 *
 *------------------------------------------------------------------------mjw-*/
void quit(char *b,int l)
{
  shutdown_vmelib();
  if (!quiet)
    printf("Exiting\n\n");
  exit(0);
}

/*------------------------------------------------------------------------------
 * help
 *
 *------------------------------------------------------------------------mjw-*/
void help(char *b,int l)
{
  int x = 0;
  int done = 0;

  printf("Commands:\n"); 
  while (!done) {
    printf("%10s ",cmdTable[x].command);
    if ((x+1) % 6 == 0)
      printf("\n");
    if (cmdTable[x++].CmdType == CMDT_NULL)
      done = 1;
  } // While
}

/*------------------------------------------------------------------------------
 * status 
 *
 *------------------------------------------------------------------------mjw-*/
void status(char *b,int l)
{
  printf("Program Status:\n");
  printf("  Fixed Adder: %08lX\n",FixedAdder);
}

/*-----------------------------------------------------------------------------
 *  ProcessCommand
 *
 *------------------------------------------------------------------------mjw-*/
void ProcessCommand(char *buffer,int len)
{
  int done = 0;
  int cmdi = 0;
  COMMAND *cpnt;
  char *cmd;
  char *params = 0;
  int x,plen = 0;
  long temp;

  cmd = buffer;
  for (x=0;x < len;x++) {
    if (buffer[x] == ' ') {
      buffer[x] = 0;             // NULL Term the string
      params = &buffer[x+ 1];
      plen = len - x;
      break;
    }
  } 

  while (!done) {
    if (!strcmp(cmd,cmdTable[cmdi].command)) {
      done = 1;
      cpnt = &cmdTable[cmdi];
      switch (cpnt->CmdType) {
      case CMDT_NULL:
        break;
      case CMDT_FUNC:
        func(cpnt->pointer)(params,plen);
        break;
      case CMDT_MODC:
        sscanf(params,"%li",&temp);
        *(char*)(cpnt->pointer) = temp;
        break;  
      case CMDT_MODI:
        sscanf(params,"%li",&temp);
        *(int*)(cpnt->pointer) = temp;
        break;  
      case CMDT_MODL:
        sscanf(params,"%lx",&temp);
        *(long*)(cpnt->pointer) = temp;
        break;  
      case CMDT_MODB:
        if (!strcmp(params,"ON")) {
          *(int*)(cpnt->pointer) = 1;
        } else if (!strcmp(params,"TRUE")) {
          *(int*)(cpnt->pointer) = 1;
        } else if (!strcmp(params,"OFF")) {
          *(int*)(cpnt->pointer) = 0;
        } else if (!strcmp(params,"FALSE")) {
          *(int*)(cpnt->pointer) = 0;
        } else {
          sscanf(params,"%li",&temp);
          *(int*)(cpnt->pointer) = temp;
        }  
        break;  
      } // switch
    }
    if (cmdTable[cmdi++].CmdType == CMDT_NULL) {
      done = 1;
      printf("Unknown Command\n");
    }
  } // While
}