vfctest.c

操作系统SunOS 4.1.3版本的源码

		  errnum = 0;
		  while ((memerr[errnum].pixloc > 0) && (errnum < 3000))
		    {
		      sprintf(mesgstr,
			      "Walking Mem.: (Transient) Data Exp = 0x%x, Obs = 0x%x, Field %d, Pixel# %d",
			      memerr[errnum].wpatt, memerr[errnum].rpatt,
			      field, memerr[errnum].pixloc);
		      errorlog(SKIP_ERROR, mesgstr);
		      errnum++;
		    }
		}
	      if (retstat == 2)
		{
		  errnum = 0;
		  while ((memerr[errnum].pixloc > 0) && (errnum < 3000))
		    {
		      sprintf(mesgstr,
			      "Walking Mem.: Data Exp = 0x%x, Obs = 0x%x, Field %d, Pixel# %d",
			      memerr[errnum].wpatt, memerr[errnum].rpatt,
			      field, memerr[errnum].pixloc);
		      errorlog(SKIP_ERROR, mesgstr);
		      errnum++;
		    }
		  if (retstat == 0)
		    {		/* check for bad cells in same location */
		      walking_write(taddr, loop);
		      if ((walking_read(taddr, loop, field, 2)) != 1) /* errors */
			{
			  errnum = 0;
			  while ((memerr[errnum].pixloc > 0) && (errnum < 3000))
			    {
			      sprintf(mesgstr,
				      "Walking Mem.: (Cell Chk.)Data Exp = 0x%x, Obs = 0x%x, Field %d, Pixel# %d",
				      memerr[errnum].wpatt, memerr[errnum].rpatt,
				      field, memerr[errnum].pixloc);
			      errorlog(SKIP_ERROR, mesgstr);
			      errnum++;
			    }
			}
		    }		/* if retstat == 0 */
		}
	    }
	}
    }				/* for loop= */
  }				/* for field=  */
  return(0);
}


walking_write(taddr, loop)
     u_int *taddr;
     int   loop;
{
  int i, subcmd;
  u_int data, rdata, wdata;

  subcmd = MEMPRST;
  ioctl(vfcfd, VFCSCTRL, &subcmd);
  zaptopmem (taddr, WRITE);	/* throwaway top 248 pixels */
  data = 0x00010000;	/* initial data */
  for (i = 0; i < FIELD_SIZE; ++i) {
    if (loop == 1)
      wdata = data & FRAM_MASK; /* walking 1s pattern */
    else
      wdata = ~data & FRAM_MASK; /* walking 0s pattern */
    *taddr = wdata;		/* write to the FRAM */
    if ((data & FRAM_MASK) == 0x80000000)
      data = 0x00010000;
    else
      data <<= 1;
  }
  
  return(0);
}


walking_read(taddr, loop, field, flag)
     int flag, loop, field;
     u_int *taddr;
{
  int i;
  u_int data, rdata, wdata;
  int subcmd;
  int retcode, mismatchflag;
  

  subcmd = MEMPRST;
  ioctl(vfcfd, VFCSCTRL, &subcmd); /* reset memptr before reading */

  data = 0x00010000;
  errnum = 0;
  if (flag == 2)
    {
      retcode = 1;
      mismatchflag = 0;
    }
  zaptopmem (taddr, READ);	/* throwaway top 248 pixels */
  for (i = 0; i < FIELD_SIZE; ++i)
    {
      rdata = *taddr;
      rdata &= FRAM_MASK;	/* mask off the read data */
      if (loop == 1)
	wdata = data & FRAM_MASK;
      else
	wdata = ~data & FRAM_MASK;
      if (wdata != rdata)
	{
	  if (flag == 1)
	    {			/* entry into memerr structre */
	      if (errnum >= 3000)
		  {
		errorlog(SKIP_ERROR, "memerr structure out of memory");
		goto walkend;
		}
	      else
		{
		  memerr[errnum].pixloc = i;
		  memerr[errnum].rpatt = rdata;
		  memerr[errnum].wpatt = wdata;
		  errnum++;
		}
	    }
	  if (flag == 2)
	    {			/* check against the log */
	      if ((errnum >= 3000) || (memerr[errnum].pixloc < 0))
		;
	      else
		{
		  if ((memerr[errnum].pixloc == i) &&
		      (memerr[errnum].rpatt == rdata))
		    retcode = 0;
		  else
		    {
		      mismatchflag = 1;
		    }
		  errnum++;
		}
	    }
	  if (flag == 3) /* Engg debug flag */
	    {
	      sprintf(mesgstr,
	      "Walking Mem: Data Exp. = 0x%x - Data Obs. = 0x%x, Field %d, Pixel# %d",
		     wdata, rdata, field, i);
	      errorlog(SKIP_ERROR, mesgstr);
	    }
	}
      if ((data & FRAM_MASK) == 0x80000000)
	data = 0x00010000;
      else
	data <<= 1;
    }

 walkend:
  if (flag == 1)
    {
      retcode = errnum;
      if (errnum < 3000)
	memerr[errnum].pixloc = -1;
      else
	memerr[2999].pixloc = -1;
    }
  if ((flag == 2) && mismatchflag)
    retcode = 2;
  return(retcode);
  
}


unique_test()
{

  int incr, field, data;
  int rdata, lcnt;
  int subcmd, retstat;
  u_int *taddr;


  incr = 0x10 << 16;		/* incr. data: it is left-shifted
				 * to align with the upper bytes */

  subcmd = MEMPRST;
  ioctl(vfcfd, VFCSCTRL, &subcmd);
  zaptopmem (vfc_port1, WRITE);	/* increment pointers for port1 and port2 */
  zaptopmem (vfc_port2, WRITE);

  data = 0;			/* initial data */
  for (lcnt = 0; lcnt < 0x2000; ++lcnt) {
    *vfc_port1 = data & FRAM_MASK;
    data += incr;
    *vfc_port2 = data & FRAM_MASK;
    data += incr;
  }

  if (enggflag)
    uniq_read(3);
  else
    {
      if (uniq_read(1) > 0)	/* first loop */
	{
	  errnum = 0;
	  retstat = uniq_read(2);
	  if (retstat == 1)
	    {
	      errnum = 0;
	      while ((memerr[errnum].pixloc > 0) && (errnum < 3000))
		{
		  sprintf(mesgstr,
			  "Uniq Mem: (Transient) Data Exp = 0x%x, Obs = 0x%x, Pixel# %d",
			  memerr[errnum].wpatt, memerr[errnum].rpatt, memerr[errnum].pixloc);
		  errorlog(SKIP_ERROR, mesgstr);
		}
	    }
	  if (retstat == 2)
	    {
	      errnum = 0;
	      while ((memerr[errnum].pixloc > 0) && (errnum < 3000))
		{
		  sprintf(mesgstr,
			  "Uniq Mem: Data Exp = 0x%x, Obs = 0x%x, Pixel# %d",
			  memerr[errnum].wpatt, memerr[errnum].rpatt, memerr[errnum].pixloc);
		  errorlog(SKIP_ERROR, mesgstr);
		}
	    }
	}
    }

  return(0);

}


uniq_read(flag)
     int flag;
{
  int incr, field, data;
  int rdata, lcnt;
  int subcmd;
  u_int *taddr;
  int retcode, mismatchflag = 0;

  subcmd = MEMPRST;
  ioctl(vfcfd, VFCSCTRL, &subcmd); /* reset memptr */
  errnum = 0;
  incr = 0x10 << 16;
  if (flag == 2)
    retcode = 1;
  for (field = 1; field <= 2; field++) {
    if (field == 1) {
      data = 0;
      taddr = vfc_port1;
    }
    else {
      data = incr;
      taddr = vfc_port2;
    }

    zaptopmem (taddr, READ);
    for (lcnt = 0; lcnt < 0x1000; ++lcnt) {
      rdata = *taddr;
      rdata &= FRAM_MASK;
      if ((data & FRAM_MASK) != rdata)
	{
	  if (flag == 1)
	    {
	      if (errnum >= 3000)
		  {
		errorlog(SKIP_ERROR, "memerr structure out of memory");
		goto uniqend;
		}
	      else
		{
		  memerr[errnum].pixloc = lcnt;
		  memerr[errnum].rpatt = rdata;
		  memerr[errnum].wpatt = data & FRAM_MASK;
		  errnum++;
		}
	    }
	  if (flag == 2)
	    {
	      if ((errnum >= 3000) || (memerr[errnum].pixloc < 0))
		;
	      else
		{
		  if ((memerr[errnum].pixloc == lcnt) &&
		      (memerr[errnum].rpatt == rdata))
		    retcode = 0;
		  else
		    {
		      mismatchflag = 1;
		    }
		  errnum++;
		}
	    }
	  if (flag == 3)
	    {
	      sprintf(mesgstr,
		      "Uniq. Mem.: Data Exp. = 0x%x, Obs. = 0x%x, Field %d, Pixel# %d",
		      data & FRAM_MASK, rdata, field, lcnt);
	      errorlog(SKIP_ERROR, mesgstr);
	    }
	}
      data += 2*incr;
    }
  }

 uniqend:
  if (flag == 1)
    {
      retcode = errnum;
      if (errnum < 3000)
	memerr[errnum].pixloc = -1;
      else
	memerr[2999].pixloc = -1;
    }
  if ((flag == 2) && mismatchflag)
    retcode = 2;

  return(retcode);
}

/* Central error-handler */
errorlog(errcode, errmsg)
     int errcode;
     char *errmsg;
{

  send_message(errcode, ERROR, errmsg);

  /*  If the error code is non-zero, then the send_message
   *  will not return back to us. All non-fatal errors are
   *  logged as 0 error code. We count those errors.
   */
     
  ++errors;			/* increment error count */
  if (errors >= ERROR_LIMIT)
    send_message(TOO_MANY_ERRS, ERROR, "Too many errors \n");
  
  return(0);
}


/*
 * clean_up(), contains necessary code to clean up resources before exiting.
 * Note: this function is always required in order to link with sdrtns.c
 * successfully.
 */
clean_up()
{
}