vba_errors.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

	   must_panic = 1;
	 }

         if (aesr & XBIA_INV_PFN) {
	   error_type = VBA_INVALID_PFN;
	   must_panic = 1;
	 }

        /* log vba error packet: allocate packet fill in header */

	if ((elp = ealloc(sizeof(struct el_vba),
		(must_panic?EL_PRILOW:EL_PRIHIGH))) == EL_FULL)
		return(PANIC_YES);

	LSUBID( elp,
		ELCT_ADPTR,              /* adapter class */
	        ELADP_VBA,               /* VMEbus adapter */
		ELDT_XBIA,               /* what VME adapter set */
		vhp->vbanum,             /* VMEbus number */
		EL_UNDEF,
		error_type );            /* error class */ 

	elvba_ptr = &elp->el_body.el_vba;

        elvba_ptr->elvba_reg.elxbia.xbia_dtype = xbireg->xbi_dtype;
	elvba_ptr->elvba_reg.elxbia.xbia_xbe = xbireg->xbi_xbe;
	elvba_ptr->elvba_reg.elxbia.xbia_fadr = xbireg->xbi_fadr;
	elvba_ptr->elvba_reg.elxbia.xbia_arear = xbireg->xbi_arear;
	elvba_ptr->elvba_reg.elxbia.xbia_aesr = xbireg->xbi_aesr;
	elvba_ptr->elvba_reg.elxbia.xbia_aimr = xbireg->xbi_aimr;
	elvba_ptr->elvba_reg.elxbia.xbia_aivintr=xbireg->xbi_aivintr;
	elvba_ptr->elvba_reg.elxbia.xbia_adg1 = xbireg->xbi_adg1;

	elvba_ptr->elvba_reg.elxbia.xvib_vdcr = *Xvibregs.vdcr ;
	elvba_ptr->elvba_reg.elxbia.xvib_vesr =  *Xvibregs.vesr ;
	elvba_ptr->elvba_reg.elxbia.xvib_vfadr =  *Xvibregs.vfadr ;
	elvba_ptr->elvba_reg.elxbia.xvib_vicr =  *Xvibregs.vicr ;
	elvba_ptr->elvba_reg.elxbia.xvib_vvor =  *Xvibregs.vvor ;
	elvba_ptr->elvba_reg.elxbia.xvib_vevr =  *Xvibregs.vevr ;

	EVALID( elp );  /* validate error packet */

        /* reset/clear status registers  -- !!!!!verbatum from vbainit.c for now!!!! */

           xbireg->xbi_aesr = xbireg->xbi_aesr;
           xbireg->xbi_xbe = xbireg->xbi_xbe & ~XMI_XBAD; /* write 1 to clear */
           xbireg->xbi_besr = xbireg->xbi_besr;


        /* report to console and return panic status to calling routine */

        if (must_panic) {
	  cprintf("Fatal VMEbus adapter error has occured");
	  cprintf("??report register info");
	  return(PANIC_YES);
	}

        printf("VMEbus adapter error recovery being attempted");
        return(PANIC_NO);

} 


/*****************************************************************************
 * vbaerrors - the VMEbus adapter error handler
 *
 *  function:  The entry point for vba errors. It will take
 *             care of any general adapter details and 
 *             dispatch to the individual adapter error
 *             handler to take care of the adapter specific
 *             details.
 *
 *
 *   1. get the vba_hd structure which contains the vba information 
 *   2. dispatch to the individual adapter error routine using the
 *      vba_type field from the vba_hd structure. These adapter
 *      routine will handle specific error handling details and
 *      return recovery status.
 *   3. take care of any other general details (additional logging??)
 *   4. panic if the recovery status returned says to
 *
 *****************************************************************************/

vbaerrors(vbanumber)
int vbanumber;

{
	register struct vba_hd *vhp;
	int must_panic = 0;

	vhp = get_vba(vbanumber);

	switch (vhp->vba_type) {

	      case VBA_3VIA: {if (MVIBerrors(vhp) == PANIC_YES)
		               must_panic = 1;
			      break;}

	      case VBA_XBIA: {if (XBIAerrors(vhp) == PANIC_YES)
		               must_panic = 1;
			     break;}

	      default: panic("unknown vba adapter type");

	} /*switch*/

	/*
	 * take care of any other general stuff here
         * perhaps some additional logging of information
         * depending on cpu type - ala vaxbierrors...
         */
	if (must_panic) panic("VMEbus adapter error");

} /*vba_errors*/


/******************************************************************************
 *
 *      log_vme_device_error
 *
 *	function: Provide device driver with an error logging
 *                routine for device errors (VME modules that
 *                use a uba_device structure). The routine will
 *                log a packet with an error message from the
 *                driver, device information, and the VMEbus
 *                adapter registers.
 *
 *      NOTE: Although the device and the controller routines are
 *            similar, they are going to be kept seperate for
 *            clarity and ease of use by the device drivers. 
 *            (as opposed to passing a flag indicating dev/crtl)
 *
 ******************************************************************************/


log_vme_device_error(text,vhp, devptr)
char		   *text;                    /* ASCII error message*/
struct	vba_hd	   *vhp;                     /* ptr to vba_hd struct */
struct  uba_device *devptr;                  /* ptr to uba struct */

{
register struct el_rec	*elp;
register struct el_vme_dev_cntl *elvme_ptr;
register struct xbi_reg *xbireg;
int adapter_type;
char *msg_ptr;
int i;

/*								
 *	Allocate error log packet				
 */								

	if ((elp = ealloc(sizeof(struct el_vme_dev_cntl),
		EL_PRIHIGH)) == EL_FULL)
		return;
/*								
 *	Get adapter type and Initialize subid fields
 */							
        switch (vhp->vba_type) {
	  case VBA_3VIA: {adapter_type = ELDT_3VIA;
	                  break;}
	  case VBA_XBIA: {adapter_type = ELDT_XBIA;
	                  break;}
	} /*switch*/

	LSUBID( elp,
		ELCT_DCNTL,              /* device controller class */
	        ELVME_DEV_CNTL,          /* VME device controller */
		adapter_type,            /* what VME adapter set */
		vhp->vbanum,             /* VMEbus number */
		EL_UNDEF,
		VME_DEVICE);             /* device type error */ 

	elvme_ptr = &elp->el_body.elvme_devcntl;

/*
 *      put name string into the packet 
 */
        msg_ptr = devptr->ui_devname;
        for (i=1; *msg_ptr++ != '\0' && i > EL_SIZE64; i++) ;
        bcopy(devptr->ui_devname, elvme_ptr->module, i);
        elvme_ptr->module[i-1] = '\0' ;

/*
 *      fill in rest of packet 
 */
        elvme_ptr->num  = devptr->ui_unit ;
        elvme_ptr->csr1 = devptr->ui_addr ;
        elvme_ptr->csr2 = devptr->ui_addr2 ;

        if (text == NULL) text = "NO ERROR MESSAGE ENTERED BY DRIVER" ;
	elvme_ptr->el_vme_error_msg.msg_len = sizeof(text);
        bcopy(text, elvme_ptr->el_vme_error_msg.msg_asc, sizeof(text));

	switch (adapter_type) {
	  case ELDT_3VIA: {
            elvme_ptr->elvba.elvba_reg.elmvib.mvib_viacsr = *Xviaregs.viacsr ;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_csr = *Xviaregs.csr ;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_vfadr = *Xviaregs.vfadr;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_cfadr = *Xviaregs.cfadr;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_ivs = *Xviaregs.ivs;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_besr = *Xviaregs.besr;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_errgi = *Xviaregs.errgi;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_lvb = *Xviaregs.lvb;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_err = *Xviaregs.err;
	    break; 
          }
	  case ELDT_XBIA: {
	    xbireg = (struct xbi_reg *)vhp->vbavirt;

	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_dtype = xbireg->xbi_dtype;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_xbe = xbireg->xbi_xbe;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_fadr = xbireg->xbi_fadr;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_arear = xbireg->xbi_arear;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_aesr = xbireg->xbi_aesr;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_aimr = xbireg->xbi_aimr;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_aivintr=xbireg->xbi_aivintr;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_adg1 = xbireg->xbi_adg1;

	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vdcr = *Xvibregs.vdcr ;
	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vesr =  *Xvibregs.vesr ;
	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vfadr =  *Xvibregs.vfadr ;
	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vicr =  *Xvibregs.vicr ;
	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vvor =  *Xvibregs.vvor ;
	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vevr =  *Xvibregs.vevr ;
            break;
          }
	} /*switch*/

/*
 *	Validate error log packet				
 */

	EVALID( elp );

} /*logdevice*/



/****************************************************************************
 *
 *      log_vme_crtl_error
 *
 *	function: Provide device driver with an error logging
 *                routine for controller errors (VME modules that
 *                use a uba_ctlr structure). The routine will
 *                log a packet with an error message from the
 *                driver, ctlr information, and the VMEbus
 *                adapter registers.
 *
 ******************************************************************************/


log_vme_ctlr_error(text,vhp, devptr)
char		   *text;                    /* ASCII error message*/
struct	vba_hd	   *vhp;                     /* ptr to vba_hd struct */
struct  uba_ctlr   *devptr;                  /* ptr to uba struct */

{
register struct el_rec	*elp;
register struct el_vme_dev_cntl *elvme_ptr;
register struct xbi_reg *xbireg;
int adapter_type;
char *msg_ptr;
int i;

/*								
 *	Allocate error log packet				
 */								

	if ((elp = ealloc(sizeof(struct el_vme_dev_cntl),
		EL_PRIHIGH)) == EL_FULL)
		return;
/*								
 *	Get adapter type and Initialize subid fields
 */							
        switch (vhp->vba_type) {
	  case VBA_3VIA: {adapter_type = ELDT_3VIA;
	                  break;}
	  case VBA_XBIA: {adapter_type = ELDT_XBIA;
	                  break;}
	} /*switch*/

	LSUBID( elp,
		ELCT_DCNTL,              /* device controller class */
	        ELVME_DEV_CNTL,          /* VME device controller */
		adapter_type,            /* what VME adapter set */
		vhp->vbanum,             /* VMEbus number */
		EL_UNDEF,
		VME_CONTROLLER);         /* controller type error */ 

	elvme_ptr = &elp->el_body.elvme_devcntl;

/*
 *      put name string into the packet 
 */
        msg_ptr = devptr->um_ctlrname;
        for (i=1; *msg_ptr++ != '\0' && i > EL_SIZE64; i++) ;
        bcopy(devptr->um_ctlrname, elvme_ptr->module, i);
        elvme_ptr->module[i-1] = '\0' ;

/*
 *      fill in rest of packet 
 */
        elvme_ptr->num  = devptr->um_ctlr ;
        elvme_ptr->csr1 = devptr->um_addr ;
        elvme_ptr->csr2 = devptr->um_addr2 ;

        if (text == NULL) text = "NO ERROR MESSAGE ENTERED BY DRIVER" ;
	elvme_ptr->el_vme_error_msg.msg_len = sizeof(text);
        bcopy(text, elvme_ptr->el_vme_error_msg.msg_asc, sizeof(text));

	switch (adapter_type) {
	  case ELDT_3VIA: {
            elvme_ptr->elvba.elvba_reg.elmvib.mvib_viacsr = *Xviaregs.viacsr ;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_csr = *Xviaregs.csr ;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_vfadr = *Xviaregs.vfadr;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_cfadr = *Xviaregs.cfadr;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_ivs = *Xviaregs.ivs;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_besr = *Xviaregs.besr;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_errgi = *Xviaregs.errgi;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_lvb = *Xviaregs.lvb;
	    elvme_ptr->elvba.elvba_reg.elmvib.mvib_err = *Xviaregs.err;
	    break; 
          }
	  case ELDT_XBIA: {
	    xbireg = (struct xbi_reg *)vhp->vbavirt;

	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_dtype = xbireg->xbi_dtype;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_xbe = xbireg->xbi_xbe;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_fadr = xbireg->xbi_fadr;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_arear = xbireg->xbi_arear;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_aesr = xbireg->xbi_aesr;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_aimr = xbireg->xbi_aimr;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_aivintr=xbireg->xbi_aivintr;
	    elvme_ptr->elvba.elvba_reg.elxbia.xbia_adg1 = xbireg->xbi_adg1;

	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vdcr = *Xvibregs.vdcr ;
	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vesr =  *Xvibregs.vesr ;
	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vfadr =  *Xvibregs.vfadr ;
	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vicr =  *Xvibregs.vicr ;
	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vvor =  *Xvibregs.vvor ;
	    elvme_ptr->elvba.elvba_reg.elxbia.xvib_vevr =  *Xvibregs.vevr ;
            break;
          }
	} /*switch*/

/*
 *	Validate error log packet				
 */

	EVALID( elp );

} /*logctlr*/