xmiinit.c

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

	register struct uba_device *ui;
	register struct uba_ctlr *um;
	register int (**xmiprobe)();
	register struct uba_driver *udp;
	register struct xmisw *pxmisw = xmidata->xmierr[xminode].pxmisw;
	int level;
	int (**ivec)();
	int found = 0;

	
	for ( xmiprobe =  pxmisw->probes; *xmiprobe; xmiprobe++) {
		if ((um = xmifindum(xminumber,xminode,xmiprobe,pxmisw->xmi_name)) == 0)
			if ((um = xmifindum(xminumber,'?',xmiprobe,pxmisw->xmi_name))==0) 
				if ((um = xmifindum('?','?',xmiprobe,pxmisw->xmi_name))==0) 

					continue;
		found =1;
                if (((*xmiprobe)(nxv,nxp,xminumber,xminode,um))
			== 0){
			continue;
		}
		um->um_adpt = xminumber;
		um->um_nexus = xminode;
		um->um_alive = 1;
		um->um_addr = (char *)nxv;
		um->um_physaddr = (char *)svtophy(um->um_addr);
		udp = um->um_driver;
		udp->ud_minfo[um->um_ctlr] = um;
		config_fillin(um);
		printf("\n");

#define V2.4
#ifndef V2.4
		level = LEVEL15;
		xmicon_vec(xminumber, xminode, level, um);
#endif V2.4
		for (ui = ubdinit; ui->ui_driver; ui++) {
			if (ui->ui_driver != udp || ui->ui_alive ||
			    ui->ui_ctlr != um->um_ctlr && ui->ui_ctlr != '?')
				continue;
			if ((*udp->ud_slave)(ui, nxv)) {
				ui->ui_alive = 1;
				ui->ui_ctlr = um->um_ctlr;
				ui->ui_addr = (char *)nxv;
				ui->ui_ubanum = um->um_ubanum;
				ui->ui_hd = um->um_hd;
				ui->ui_physaddr = nxp;
				ui->ui_adpt = xminumber;
				ui->ui_nexus = xminode;

				if (ui->ui_dk && dkn < DK_NDRIVE)
					ui->ui_dk = dkn++;
				else
					ui->ui_dk = -1;
				ui->ui_mi = um;
				/* ui_type comes from driver */
				udp->ud_dinfo[ui->ui_unit] = ui;
				if(ui->ui_slave >= 0)
				printf("%s%d at %s%d slave %d\n",
				    ui->ui_devname, ui->ui_unit,
				    udp->ud_mname, um->um_ctlr, ui->ui_slave);
				else
				printf("%s%d at %s%d\n",
				    ui->ui_devname, ui->ui_unit,
				    udp->ud_mname, um->um_ctlr);

				(*udp->ud_attach)(ui);
			}
	    }


	}
	return(found);
}




struct uba_ctlr *xmifindum(xminumber,xminode,xmiprobe,xmiconn)
register int xminumber;
register int xminode;
register int (**xmiprobe)();
register char *xmiconn;
{
	struct uba_driver *udp;
	register struct uba_ctlr *um;
        register struct config_adpt *p_adpt;
        struct config_adpt *p_aie;
        extern struct config_adpt config_adpt[];



	for (um=ubminit; udp =um->um_driver; um++) {
		/* first check that the drivers probe routine equals the 
		 * xmi's probe routine then 
		 * crosscheck xminumber with um's xmi number then
		 * crosscheck xminode number with um's node number then
		 * make sure not alive already then
		 * make sure its not a valid unibus number.
		 */
	
		if ((udp->ud_probe != *xmiprobe) ||
		    (um->um_adpt != xminumber) ||
		    (um->um_nexus != xminode) ||
		    (um->um_alive) ||
		    ((um->um_ubanum >=0) && ((um->um_ubanum < nNUBA)
		        		 || (um->um_ubanum == '?'))))continue;

                for(p_adpt = &config_adpt[0];p_adpt->p_name; p_adpt++) {

			/* first look for iobus entry for this board 
			   then check if the driver is correct for 
			   this board then check that the controller 
			   number is the same as the iobus 
			*/
                	if (strcmp(xmiconn, p_adpt->p_name)==0 && 
                       		(char *)udp == p_adpt->c_name &&
                       		p_adpt->c_num == um->um_ctlr) {

		       		/* this case checks that the adapter 
				 structure has not been used. */
		 		if (p_adpt->c_ptr == 0)
                               		return(um);
			}
		}

	}
	return(0);
}		


struct uba_device *xmifindui();

xmi_config_dev(nxv,nxp,xminumber,xminode,xmidata)
struct	xmi_reg *nxv;
char *nxp;
register int    xminumber;
register int    xminode;
register struct xmidata *xmidata;
{

	register struct uba_device *ui;
	register int found = 0;
	register int (**xmiprobe)();
	register struct xmisw *pxmisw = xmidata->xmierr[xminode].pxmisw;

	
	for ( xmiprobe = pxmisw->probes; *xmiprobe; xmiprobe++) {
		
		if ((ui = xmifindui(xminumber,xminode,xmiprobe)) == 0)
			if ((ui = xmifindui(xminumber,'?',xmiprobe))==0) 
				if ((ui = xmifindui('?','?',xmiprobe))==0) 
					continue;
		found =1;
		if (((*xmiprobe)(nxv,nxp,xminumber,xminode,ui))
			== 0){
			continue;
		}

 		ui->ui_adpt = xminumber;
		ui->ui_nexus = xminode;
		config_fillin(ui);
		printf("\n");
		ui->ui_dk = -1;
		ui->ui_alive = 1;
		ui->ui_addr=(char *)nxv;
		ui->ui_driver->ud_dinfo[ui->ui_unit] = ui;
		(*ui->ui_driver->ud_attach)(ui);

	}
	return(found);
}



struct uba_device *xmifindui(xminumber,xminode,xmiprobe) 
register int xminumber;
register int xminode;
register int (**xmiprobe)();
{
	struct uba_driver *udp;
	register struct uba_device *ui;
        register struct config_adpt *p_adpt;


	for (ui=ubdinit; udp =ui->ui_driver; ui++) {
	
		if ((udp->ud_probe != *xmiprobe) ||
		    (ui->ui_adpt != xminumber) ||
		    (ui->ui_nexus != xminode) ||
		    (ui->ui_alive) ||
		    (ui->ui_slave != -1)) continue;

		 /* check that the adapter structure that is associated
		    with this device has not been used.  It could have been
		    used in the case of a DEBNK/DEBNT. */
		 if (is_adapt_alive(ui)) continue;

		 /* next we verify that this "ui" entry is hooked to an
		    XMI and not a BI in the case of the xna */
		 for(p_adpt = &config_adpt[0];p_adpt->p_name; p_adpt++) {
		 	if (((char *) ui->ui_driver == p_adpt->c_name) &&  
			    (p_adpt->c_type == 'D') &&
			    (ui->ui_unit == p_adpt->c_num) &&
			    (strcmp(p_adpt->p_name,"xmi")==0) &&
			    ((p_adpt->p_num == xminumber) ||
			     (p_adpt->p_num == '?')))
				return(ui);
		}


	}
	return(0);

}		



/* TODO: This routine should use xminumber .  Ali */
xmi_io_space(xminumber,xminode) 
 	int xminode,xminumber;
{

	if(cpu == VAX_9000)
		return(((int)0x22000000) + (0x02000000 * vecbi)); 
	else
		return(((int)0x20000000) + (0x02000000 * xminode)); 
}


/* 
	xmi errors -- currently the only device that will interrupt
	here are the XBI and XBI+.

*/

xmierrors(xminumber,pcpsl)
int xminumber;
int *pcpsl;
{
	int xminode;

	struct xmi_reg	*nxv;	/* virtual pointer to XMI node */
	register struct xmidata *xmidata;

	xmidata = get_xmi(xminumber); 
			
	nxv = xmidata->xmivirt;
	for(xminode = 0; xminode < MAX_XMI_NODE; xminode++,nxv++) {
		if (xmidata->xminodes_alive & (1<<xminode)) {
		   if ((short) (nxv->xmi_dtype) == XMI_XBI ||
		       (short) (nxv->xmi_dtype) == XMI_XBIPLUS) {
		     if ( (xbi_check_errs(xminumber,xminode,nxv)==0))
		           panic("xbi error");
		   }

		}	

	}
}


log_xmi_bierrors(xminumber,pcpsl)
int xminumber;
int *pcpsl;

/*
 *
 * function: scan xmi and log any pending vaxbi errors found.      
 *
 */

{
	int xminode;
	register struct bidata *bid;
	register int binumber;


	struct xmi_reg	*nxv;	/* virtual pointer to XMI node */
	register struct xmidata *xmidata;

	xmidata = get_xmi(xminumber); 
			
	nxv = xmidata->xmivirt;
	for(xminode = 0; xminode < MAX_XMI_NODE; xminode++,nxv++) {
		if (xmidata->xminodes_alive & (1<<xminode)) {
			if ((short) (nxv->xmi_dtype) == XMI_XBI ||
			    (short) (nxv->xmi_dtype) == XMI_XBIPLUS) {
  	                   binumber = xminode + (xminumber<<4);
    	                   bid = &bidata[binumber];
 	                   if (bid->binodes_alive){
 	                     log_bierrors(binumber,pcpsl);
                           }
			}
		}	

	}

}


log_xmierrors(xminumber,pcpsl)
int xminumber;
int *pcpsl;

/*
 *
 * function: scan xmi and log any pending errors found.      
 *
 */

{
	int xminode;

	struct xmi_reg	*nxv;	/* virtual pointer to XMI node */
	register struct xmidata *xmidata;

	xmidata = get_xmi(xminumber); 
			
	nxv = xmidata->xmivirt;
	for(xminode = 0; xminode < MAX_XMI_NODE; xminode++,nxv++) {
		if (xmidata->xminodes_alive & (1<<xminode)) {
			if ((short) (nxv->xmi_dtype) == XMI_XBI ||
			    (short) (nxv->xmi_dtype) == XMI_XBIPLUS) {
			  xbi_check_errs(xminumber,xminode,nxv);
			}
		}	

	}
}


/*
 * xmidev_vec(): To set up XMI device interrupt vectors.
 * It is called with 4 parameters:
 *	xminum:	the XMI number that the device is on
 *	xminode: the XMI node number of the device
 *	level:  the offset corresponding to the interrupt priority level
 *		to start at.  See xmireg.h: LEVEL{14,15,16,17}.
 *	ui:	the device structure (for names of interrupt routines)
 */

xmidev_vec(xminum, xminode, level, ui)
	int xminum, xminode, level;
	struct uba_device *ui;
{
	register int (**ivec)();
	register int (**addr)();	/* double indirection neccessary to keep
				   	   the C compiler happy */
	register struct xmidata *xmidata;

	xmidata = get_xmi(xminum); 
	for (ivec = ui->ui_intr; *ivec; ivec++) {
		addr = (int (**)())(SCB_XMI_VEC_ADDR(xmidata, xminum,xminode,level));
		*addr = scbentry(*ivec,SCB_ISTACK);
		level += XMIVECSIZE;
	}
}

xmisst(nxv)
struct	xmi_reg *nxv;
{
	int totaldelay;
	int ret = 0;
	int s;
	register struct xmidata *xmidata;
	register struct xmi_reg *cpunode=0;

	s= spl5();
	nxv->xmi_xbe = (nxv->xmi_xbe & ~XMI_XBAD) | XMI_NRST;

	/* need to give time for XMI bad line to be set */
	DELAY(10000);
	
	xmidata = head_xmidata;

	while(xmidata) {
		if ((xmidata->xminum != -1) &&
		    (nxv >= xmidata->xmivirt) && 
		    (nxv < (xmidata->xmivirt +16)))
		    	cpunode = xmidata->cpu_xmi_addr;
		xmidata = xmidata->next;
	}

	if (!cpunode) panic("invalid xmi address");
	
	/* wait for XMI_XBAD line to be deasserted.  or 10 seconds.*/
	totaldelay = 1000;
	while((cpunode->xmi_xbe & XMI_XBAD) && (totaldelay-- > 0)) {
		DELAY(10000);
	}
/*
 * Wait for the self tests to finish (10 seconds)
 */
	totaldelay = 1000;
	while (((nxv->xmi_xbe & XMI_ETF) || (nxv->xmi_xbe & XMI_STF))
	     &&(totaldelay > 0)) {
		--totaldelay;
		DELAY(10000);
	}
	nxv->xmi_xbe = (nxv->xmi_xbe & ~(XMI_XBAD | XMI_NRST));
	if (totaldelay > 0)
		ret = 1;

	splx(s);
	return (ret);
}