Subversion Repositories mips_enhanced

#include "testmod.h"
#include <stdlib.h>
 
struct spwregs 
{
   volatile int ctrl;
   volatile int status;
   volatile int nodeaddr;
   volatile int clkdiv;
   volatile int destkey;
   volatile int time;
   volatile int unused[2];
   volatile int dmactrl;
   volatile int rxmaxlen;
   volatile int txdesc;
   volatile int rxdesc;
};
 
static int snoopen;
 
static char *almalloc(int sz)
{
  char *tmp;
  tmp = (char *) malloc(2*sz);
  tmp = (char *) (((int)tmp+sz) & ~(sz -1));
  return(tmp);
}
 
static inline int loadmem(int addr)
{
  int tmp;        
  if (snoopen) {
    asm volatile (" ld [%1], %0 "
      : "=r"(tmp)
      : "r"(addr)
    );
  } else {
    asm volatile (" lda [%1]1, %0 "
      : "=r"(tmp)
      : "r"(addr)
    );
  }
  return tmp;
}
 
static inline char loadb(int addr)
{
  char tmp;        
  if (snoopen) {
    asm volatile (" ldub [%1], %0 "
      : "=r"(tmp)
      : "r"(addr)
    );
  } else {
    asm volatile (" lduba [%1]1, %0 "
      : "=r"(tmp)
      : "r"(addr)
    );
  }
  return tmp;
}
 
int spw_test(int addr)
{
  int i;
  int rmapaddr;
  int  *tmp;
  int  *size;
  volatile char *rx;
  volatile char *tx;
  volatile char *rmap;
  volatile char *rmaphdr;
  volatile int *rxd;
  volatile int *txd;
 
  struct spwregs *regs;
 
  report_device(0x0101F000);
  snoopen = rsysreg(0) & (1 << 23);
 
  if (snoopen) report_subtest(SPW_SNOOP_TEST);
  else report_subtest(SPW_NOSNOOP_TEST);
 
  regs = (struct spwregs *) addr;
  rx = (char *) malloc(64);
  tx = (char *) malloc(64);
  rmaphdr = (char *) malloc(32);
  rmap = (char *) malloc(64);
  rxd = (int *) almalloc(1024);
  txd = (int *) almalloc(1024);
  size = (int *) malloc(sizeof(int));
 
  /*reset link */
  regs->ctrl = (1 << 6);
 
  /*initiate registers*/
  regs->ctrl = 0x2;
  regs->ctrl = 0x2;
  regs->status = 0xFFFFFFFF;
  regs->nodeaddr = 0xFE;
  regs->clkdiv = 0;
  regs->destkey = 0;
  regs->time = 0;
  regs->dmactrl = 0x01E0;
  regs->rxmaxlen = 1024;
  regs->txdesc = 0;
  regs->rxdesc = 0;
 
  while(((loadmem((int)&regs->status) >> 21) & 7) != 5) {}
 
  /*check dma channel*/
  tmp = (int *) rx;
  for (i = 0; i < 64/sizeof(int); i++) {
    tmp[i] = 0;
  }
  tmp = (int *) tx;
  for (i = 0; i < 64/sizeof(int); i++) {
    tmp[i] = 0;
  }
  tmp = (int *) rmap;
  for (i = 0; i < 64/sizeof(int); i++) {
    tmp[i] = 0;
  }
  tmp = (int *) rmaphdr;
  for (i = 0; i < 32/sizeof(int); i++) {
    tmp[i] = 0;
  }
  for (i = 0; i < 8; i++) {
    txd[i] = 0;
  }
  for (i = 0; i < 8; i++) {
    rxd[i] = 0;
  }
  for(i = 1; i < 64; i++) {
    tx[i] = (char) i;
  }
  tx[0] = (char) 0xFE;
 
  rxd[1] = (int) rx;
  rxd[0] = (1 << 26) | (1 << 25);
 
  txd[4] = 0;
  txd[3] = (int)tx;
  txd[2] = 32;
  txd[1] = 0;
  txd[0] = (1 << 13) | (1 << 12);
 
  regs->txdesc = (int) txd;
  regs->rxdesc = (int) rxd;
 
  regs->dmactrl = 0x19E3;
 
  while((loadmem((int)&rxd[0]) >> 25) & 1) {}
 
  if (!((loadmem((int)&regs->dmactrl) >> 6) & 1)) {
    fail(3);
  }
  if (!((loadmem((int)&regs->dmactrl) >> 5) & 1)) {
    fail(4);
  }
  if ((loadmem((int)&regs->dmactrl) & 1)) {
    fail(5);
  }
 
  for(i = 0; i < 32; i++) {
    if (loadb((int)&rx[i]) != tx[i]) {
      fail(6);
    }
  }
 
  /*check rmap*/
  rmapaddr = (int) rmap;
  if ((loadmem((int)&regs->ctrl) >> 31) & 1) {
    report_subtest(SPW_RMAP_TEST);
    regs->ctrl = loadmem((int)&regs->ctrl) | (1 << 16);
    rmaphdr[0] = 0xFE;
    rmaphdr[1] = 1;
    rmaphdr[2] = 0x6C;
    rmaphdr[3] = 0;
    rmaphdr[4] = 0xFE;
    rmaphdr[5] = 0;
    rmaphdr[6] = 0;
    rmaphdr[7] = 0;
    rmaphdr[8] = (rmapaddr >> 24) & 0xFF;
    rmaphdr[9] = (rmapaddr >> 16) & 0xFF;
    rmaphdr[10] = (rmapaddr >> 8) & 0xFF;
    rmaphdr[11] = rmapaddr & 0xFF;
    rmaphdr[12] = 0;
    rmaphdr[13] = 0;
    rmaphdr[14] = 64;
 
    rxd[0] = (1 << 26) | (1 << 25);
    txd[2] = 64;
    txd[1] = (int) rmaphdr;
    txd[0] = (1 << 13) | (1 << 12) | 15 | (1 << 16) | (1 << 17);
    regs->dmactrl = 0x19E3;
 
    while((loadmem((int)&rxd[0]) >> 25) & 1) {}
 
    for(i = 0; i < 64; i++) {
      if (loadb((int)&rmap[i]) != tx[i]) {
        fail(7);
      }
    }
 
    rmaphdr[0] = 0xFE;
    rmaphdr[1] = 1;
    rmaphdr[2] = 0x2C;
    rmaphdr[3] = 0;
    rmaphdr[4] = 0xFE;
    rmaphdr[5] = 0;
    rmaphdr[6] = 0;
 
    if ((rxd[0] & 0x1FFFFFF) != 8) {
      fail(7);
    }
 
    for(i = 0; i < 7; i++) {
      if (loadb((int)&rx[i]) != rmaphdr[i]) {
        fail(8);
      }
    }
 
  }
 
  /*check time interface*/
  report_subtest(SPW_TIME_TEST);
  regs->ctrl = loadmem((int)&regs->ctrl) | (1 << 11) | (1 << 10);
  regs->ctrl = loadmem((int)&regs->ctrl) | (1 << 4);
 
  while((loadmem((int)&regs->ctrl) >> 4) & 1) {}
 
  if ((loadmem((int)&regs->status) & 1)) {
    fail(1);
  }
  if ((loadmem((int)&regs->time) & 0xFF) != 1) {
    fail(2);
  }
 
  return 0;
}