eribld_aq.c

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

			OS$gen_long,		DD$bci3_csr);
	if( status == EI$FAIL )
		return(EI$FAIL);
	else
		return(EI$SUCC);
}

int  v9000_bld_syndrome(eis_ptr,dis_ptr,cds_ptr,sds_ptr,ads_ptr,sis_ptr,elrp_old)
EIS  *eis_ptr;
DIS  *dis_ptr;
CDS  *cds_ptr;
SDS  *sds_ptr;
ADS  *ads_ptr;
SIS  *sis_ptr;
struct el_rec *elrp_old;
{
	int status;
	struct el_rec_new *elrp = (struct el_rec_new *)elrp_old;

		if( elrp->el_body.el_aqcpusyn.format == aqsyn_io )
			cds_ptr->subtype = DD$AQIOSYN_CDS;
		else
			cds_ptr->subtype = DD$AQCPUSYN_CDS;

		if (ini_seg(cds_ptr) == EI$FAIL)
		    status = EI$FAIL;
#define CPUSYN &elrp->el_body.el_aqcpusyn
		os_std(CPUSYN.format, OS$gen_short, DD$aqsyn_format);
		os_std(CPUSYN.attn_code, OS$gen_tiny, DD$aqsyn_attn_code);
		os_std(CPUSYN.end_time[0], OS$gen_long, DD$aqsyn_end_time);
		os_std(CPUSYN.begin_time[0], OS$gen_long, DD$aqsyn_begin_time);
		os_std(CPUSYN.proc_id, OS$gen_tiny, DD$aqsyn_proc_id);
		os_std(CPUSYN.proc_rev, OS$gen_short, DD$aqsyn_proc_rev);
		os_std(CPUSYN.cpu_num, OS$gen_short, DD$aqsyn_cpu_num);
		os_std(CPUSYN.event_cnt, OS$gen_short, DD$aqsyn_event_cnt);
		os_std(CPUSYN.sid, OS$gen_long, DD$aqsyn_sid);
		os_std(CPUSYN.sys_type, OS$gen_long, DD$aqsyn_sys_type);
		os_std(CPUSYN.cpu_id, OS$gen_long, DD$aqsyn_cpu_id);
		os_std(CPUSYN.node_name[0], OS$gen_asc_16, DD$aqsyn_node_name);
		os_std(CPUSYN.bcm_dev_name[0], OS$gen_asc_24, DD$aqsyn_bcm_dev_name);
		os_std(CPUSYN.bcm_rev[0], OS$gen_asc_12, DD$aqsyn_bcm_rev);
		os_std(CPUSYN.synd_code[0], OS$gen_asc_52, DD$aqsyn_synd_code);
		os_std(CPUSYN.pcs_synd_code[0], OS$gen_asc_52, DD$aqsyn_pcs_synd_code);
		if( elrp->el_body.el_aqcpusyn.format == aqsyn_io ) {
#define IOSYN &elrp->el_body.el_aqiosyn
			os_std(IOSYN.dev_type, OS$gen_long, DD$aqsyn_dev_type);
			os_std(IOSYN.dev_name[0], OS$gen_bv_32, DD$aqsyn_dev_name);
			os_std(IOSYN.dev_serial_num[0], OS$gen_bv_8,
											DD$aqsyn_dev_serial_num);
			os_std(IOSYN.media_type, OS$gen_long, DD$aqsyn_media_type);
			os_std(IOSYN.media_label[0], OS$gen_asc_12, DD$aqsyn_media_label);
			os_std(IOSYN.media_serial_num[0], OS$gen_bv_8,
											DD$aqsyn_media_serial_num);
			os_std(IOSYN.mount_time[0], OS$gen_long, DD$aqsyn_mount_time);
		}

	if( status == EI$FAIL )
		return(EI$FAIL);
	else
		return(EI$SUCC);
}

int  v9000_bld_mem(eis_ptr,dis_ptr,cds_ptr,sds_ptr,ads_ptr,sis_ptr,elrp)
EIS  *eis_ptr;
DIS  *dis_ptr;
CDS  *cds_ptr;
SDS  *sds_ptr;
ADS  *ads_ptr;
SIS  *sis_ptr;
struct el_rec *elrp;
{
	int status, i, j, k;
	unsigned long ecc, internal1, internal2, internal3;
	unsigned long ext, phys, longw, quadw, mpam, rowcol, row, col;

			/* check rhdr_sid, rhdr_systype to determine if
				spu or host error packet */
			/* sid == 0e, aquarius host,
			   sid == 08, type == 6., aquarius SPU */
	  if((elrp->elrhdr.rhdr_sid>>24) == 0x0e) {
				/* aquarius host */
    	if(elrp->elsubid.subid_ctldevtyp == ELMCNTR_9000_SE)
			cds_ptr->subtype = DD$AQSE_CDS;
		else
			cds_ptr->subtype = DD$AQHE_CDS;
		if (ini_seg(cds_ptr) == EI$FAIL)
		    status = EI$FAIL;
#define HESE &elrp->el_body.el_aqhese
		os_std(HESE.time_stamp[0], OS$gen_long, DD$aqhese_time_stamp);
		os_std(HESE.err_adr, OS$gen_long, DD$aqhese_err_adr);
				/* do address decoding */
		ext = elrp->el_body.el_aqhese.err_adr >> 30;
		phys = elrp->el_body.el_aqhese.err_adr << 2;
		longw = elrp->el_body.el_aqhese.err_adr & 0x1;
		quadw = elrp->el_body.el_aqhese.err_adr & 0xe;
		mpam = (elrp->el_body.el_aqhese.err_adr & 0x30) >> 4 |
				(elrp->el_body.el_aqhese.err_adr & 0xff000000) >> 22;
		rowcol = (elrp->el_body.el_aqhese.err_adr & 0x00ffffc0) >> 6 |
				((elrp->el_body.el_aqhese.ecc_synd & 0x1f800000) >> 5);
		os_std(&ext, OS$gen_long, DD$aqhese_err_adr_ext);
		os_std(&phys, OS$gen_long, DD$aqhese_err_adr_phys);
		os_std(&longw, OS$gen_long, DD$aqhese_err_adr_long);
		os_std(&quadw, OS$gen_long, DD$aqhese_err_adr_quad);
		os_std(&mpam, OS$gen_long, DD$aqhese_err_adr_mpam);
		os_std(&rowcol, OS$gen_long, DD$aqhese_err_adr_rowcol);
		for(row=0,col=0,j=0,k=1,i=0; i<=11; i++) {
			row |= ((rowcol>>j) & 0x1) << i;
			col |= ((rowcol>>k) & 0x1) << i;
			j += 2;
			k += 2;
		}
		os_std(&row, OS$gen_long, DD$aqhese_err_adr_row);
		os_std(&col, OS$gen_long, DD$aqhese_err_adr_col);
		

		os_std(HESE.ecc_synd, OS$gen_long, DD$aqhese_ecc_synd);
				/* interpret ecc syndrome */
#define AQHESE_INT3_SBE 0x1
#define AQHESE_INT3_DBE 0x2
#define AQHESE_INT3_FORCED 0x4
#define AQHESE_ECC_FLAG 0x8000
#define AQHESE_ECC_TYPE 0x4000
#define AQHESE_ECC_BADDATA 0x0080
		ecc = elrp->el_body.el_aqhese.ecc_synd;
		if( ecc & AQHESE_ECC_FLAG ) {
			if( ecc & AQHESE_ECC_TYPE ) {
				if( ecc & AQHESE_ECC_BADDATA ) {
					/* ERROR FORCED DURING MEM WRITE */
					internal3 = AQHESE_INT3_FORCED;
				} else {
					/* DBE ERROR DETECTED */
					internal3 = AQHESE_INT3_DBE;
				}
			} else {
					/* SBE ERROR DETECTED */
					internal3 = AQHESE_INT3_SBE;
			}
			os_std(&internal3, OS$gen_long, DD$aqhese_internal_3);
		}

		os_std(HESE.log_errcnt, OS$gen_long, DD$aqhese_log_errcnt);
		os_std(HESE.cur_errcnt, OS$gen_long, DD$aqhese_cur_errcnt);
		os_std(HESE.cnt_threshld, OS$gen_long, DD$aqhese_cnt_threshld);
		os_std(HESE.valid_cnt, OS$gen_long, DD$aqhese_valid_cnt);
		os_std(HESE.buff_sts, OS$gen_long, DD$aqhese_buff_sts);
		os_std(HESE.size_threshld, OS$gen_long, DD$aqhese_size_threshld);
		os_std(HESE.init_threshld, OS$gen_long, DD$aqhese_init_threshld);
		os_std(HESE.filter_factor, OS$gen_long, DD$aqhese_filter_factor);
		os_std(HESE.inhibit_per, OS$gen_long, DD$aqhese_inhibit_per);
		os_std(HESE.defect_threshld, OS$gen_long, DD$aqhese_defect_threshld);
		os_std(HESE.maint_threshld, OS$gen_long, DD$aqhese_maint_threshld);
		os_std(HESE.defect_list_sz, OS$gen_long, DD$aqhese_defect_list_sz);
	  } else if((elrp->elrhdr.rhdr_sid>>24) == 0x08 && 
				(elrp->elrhdr.rhdr_systype>>24) == 6) {
				/* aquarius SPU */
    	if(elrp->elsubid.subid_ctldevtyp == ELMCNTR_9000_SE) {
#define SPUSE elrp->el_body.el_spuse
			cds_ptr->subtype = DD$AQSPUSE_CDS;
			if (ini_seg(cds_ptr) == EI$FAIL)
	    		status = EI$FAIL;
			ads_ptr->subtype = DD$AQSPUSE_ADS;
			if (ini_seg(ads_ptr) == EI$FAIL)
	    		status = EI$FAIL;
    		        sis_ptr->subtype = DD$AQ_CRD_SIS;
		        if (ini_seg(sis_ptr) == EI$FAIL)
		            status = EI$FAIL;
			os_std(&SPUSE.n_entries, OS$gen_long, DD$aqspuse_nentries);
			if(SPUSE.n_entries) {
				os_std(&SPUSE.smcs[0].smc0, OS$gen_long, DD$mck9000spu_smc0);
				os_std(&SPUSE.smcs[0].smc1, OS$gen_long, DD$mck9000spu_smc1);
				os_std(&SPUSE.smcs[0].smc1, OS$gen_long, DD$sum_smc1);
				os_std(&SPUSE.smcs[0].smc2, OS$gen_long, DD$mck9000spu_smc2);
				os_std(&SPUSE.smcs[0].smc3, OS$gen_long, DD$mck9000spu_smc3);
			}
			spu_crd_cnt = 1;
		} else {
#define SPUHE elrp->el_body.el_spuhe
			cds_ptr->subtype = DD$AQSPUHE_CDS;
			if (ini_seg(cds_ptr) == EI$FAIL)
	    		status = EI$FAIL;
		        sis_ptr->subtype = DD$AQ_CRD_SIS;
		        if (ini_seg(sis_ptr) == EI$FAIL)
		            status = EI$FAIL;
			os_std(&SPUHE.smc0, OS$gen_long, DD$mck9000spu_smc0);
			os_std(&SPUHE.smc1, OS$gen_long, DD$mck9000spu_smc1);
			os_std(&SPUHE.smc1, OS$gen_long, DD$sum_smc1);
			os_std(&SPUHE.smc2, OS$gen_long, DD$mck9000spu_smc2);
			os_std(&SPUHE.smc3, OS$gen_long, DD$mck9000spu_smc3);
		}
	  }
	if( status == EI$FAIL )
		return(EI$FAIL);
	else
		return(EI$SUCC);
}

int  v9000_bld_kaf(eis_ptr,dis_ptr,cds_ptr,sds_ptr,ads_ptr,sis_ptr,elrp_old)
EIS  *eis_ptr;
DIS  *dis_ptr;
CDS  *cds_ptr;
SDS  *sds_ptr;
ADS  *ads_ptr;
SIS  *sis_ptr;
struct el_rec *elrp_old;
{
	int status, i;
	int short_i, len;
		/* 32 chars output per line */
#define AQSTRN 32
	static char kaf_name1[AQSTRN+2], kaf_name2[AQSTRN+1], kaf_name3[AQSTRN+1];
	static char kaf_name4[AQSTRN+2];
	static char kaf_name5[AQSTRN+2], kaf_name6[AQSTRN+1], kaf_name7[AQSTRN+1];
	static char kaf_name8[AQSTRN+2];
	struct el_rec_new *elrp = (struct el_rec_new *)elrp_old;

		cds_ptr->subtype = DD$AQKAF_CDS;
		if (ini_seg(cds_ptr) == EI$FAIL)
		    status = EI$FAIL;
		  strncpy(kaf_name1, &elrp->el_body.el_aqkaf.name[0],
					AQSTRN);
		  os_std(kaf_name1, OS$gen_asc_52, DD$aqkaf_1);
		  strncpy(kaf_name2, &elrp->el_body.el_aqkaf.name[AQSTRN],
					AQSTRN);
		  os_std(kaf_name2, OS$gen_asc_52, DD$aqkaf_2);
		  strncpy(kaf_name3, &elrp->el_body.el_aqkaf.name[AQSTRN*2],
					AQSTRN);
		  os_std(kaf_name3, OS$gen_asc_52, DD$aqkaf_3);
		  strncpy(kaf_name4, &elrp->el_body.el_aqkaf.name[AQSTRN*3],
					AQSTRN);
		  os_std(kaf_name4, OS$gen_asc_52, DD$aqkaf_4);
		  strncpy(kaf_name5, &elrp->el_body.el_aqkaf.name[AQSTRN*4],
					AQSTRN);
		  os_std(kaf_name5, OS$gen_asc_52, DD$aqkaf_5);
		  strncpy(kaf_name6, &elrp->el_body.el_aqkaf.name[AQSTRN*5],
					AQSTRN);
		  os_std(kaf_name6, OS$gen_asc_52, DD$aqkaf_6);
		  strncpy(kaf_name7, &elrp->el_body.el_aqkaf.name[AQSTRN*6],
					AQSTRN);
		  os_std(kaf_name7, OS$gen_asc_52, DD$aqkaf_7);
		  strncpy(kaf_name8, &elrp->el_body.el_aqkaf.name[AQSTRN*7],
					AQSTRN);
		  os_std(kaf_name8, OS$gen_asc_52, DD$aqkaf_8);

	if( status == EI$FAIL )
		return(EI$FAIL);
	else
		return(EI$SUCC);
}

int  v9000_bld_bi(eis_ptr,dis_ptr,cds_ptr,sds_ptr,ads_ptr,sis_ptr,elrp_old)
EIS  *eis_ptr;
DIS  *dis_ptr;
CDS  *cds_ptr;
SDS  *sds_ptr;
ADS  *ads_ptr;
SIS  *sis_ptr;
struct el_rec *elrp_old;
{
	int status;
	struct el_rec_new *elrp = (struct el_rec_new *)elrp_old;

	  if( elrp->el_body.el_aqbi.dtype == 0x120 ) {
			/* SJA */
#define SJA &elrp->el_body.el_aqbi.sjascm.sja
		cds_ptr->subtype = DD$AQBI_SJA_CDS;
		if (ini_seg(cds_ptr) == EI$FAIL)
		    status = EI$FAIL;
		sis_ptr->subtype = DD$AQ_SJA_SIS;
		if (ini_seg(sis_ptr) == EI$FAIL)
		    status = EI$FAIL;
		os_std(&elrp->el_body.el_aqbi.dtype, OS$gen_long, DD$aqbi_dtype);
		os_std(SJA.sjcs, OS$gen_long, DD$aqbi_sjcs);
		os_std(SJA.sjcs, OS$gen_long, DD$sum_sjcs);
		os_std(SJA.flag, OS$gen_long, DD$aqbi_flag);
		os_std(SJA.flag, OS$gen_long, DD$sum_flag);
		os_std(SJA.cmnd, OS$gen_long, DD$aqbi_cmnd);
		os_std(SJA.addr, OS$gen_long, DD$aqbi_addr);
		os_std(SJA.datlo, OS$gen_long, DD$aqbi_datlo);
		os_std(SJA.dathi, OS$gen_long, DD$aqbi_dathi);
		os_std(SJA.dmask, OS$gen_long, DD$aqbi_dmask);
		os_std(SJA.dxcs, OS$gen_long, DD$aqbi_dxcs);
		os_std(SJA.dxcs, OS$gen_long, DD$sum_dxcs);
		os_std(SJA.dxspu, OS$gen_long, DD$aqbi_dxspu);
		os_std(SJA.dxmem, OS$gen_long, DD$aqbi_dxmem);
		os_std(SJA.dxcnt, OS$gen_long, DD$aqbi_dxcnt);
		os_std(SJA.rxpar, OS$gen_long, DD$aqbi_rxpar);
	  } else if( elrp->el_body.el_aqbi.dtype == 0x121 ) {
			/* SCM */
#define SCM &elrp->el_body.el_aqbi.sjascm.scm
		cds_ptr->subtype = DD$AQBI_SCM_CDS;
		if (ini_seg(cds_ptr) == EI$FAIL)
		    status = EI$FAIL;
		sis_ptr->subtype = DD$AQ_SCM_SIS;
		if (ini_seg(sis_ptr) == EI$FAIL)
		    status = EI$FAIL;
		os_std(&elrp->el_body.el_aqbi.dtype, OS$gen_long, DD$aqbi_dtype);
		os_std(SCM.bicsr, OS$gen_long, DD$bicsr);
		os_std(SCM.bicsr, OS$gen_long, DD$sum_bicsr);
		os_std(SCM.ber, OS$gen_long, DD$ber);
		os_std(SCM.ber, OS$gen_long, DD$sum_ber);
		os_std(SCM.gpr0, OS$gen_long, DD$aqbi_gpr0);
		os_std(SCM.gpr1, OS$gen_long, DD$aqbi_gpr1);
		os_std(SCM.gpr1, OS$gen_long, DD$sum_gpr1);
		os_std(SCM.gpr2, OS$gen_long, DD$aqbi_gpr2);
		os_std(SCM.gpr2, OS$gen_long, DD$sum_gpr2);
		switch( elrp->el_body.el_aqbi.sjascm.scm.gpr2 ) {
			case 0x01:
			case 0x03:
			case 0x04:
				os_std(SCM.gpr3, OS$gen_long, DD$aqbi_gpr3_1);

			case 0x02:
				os_std(SCM.gpr3, OS$gen_long, DD$aqbi_gpr3_2);

			case 0x08:
				os_std(SCM.gpr3, OS$gen_long, DD$aqbi_gpr3_3);

			case 0x09:
			case 0x0a:
			case 0x1a:
				os_std(SCM.gpr3, OS$gen_long, DD$aqbi_gpr3_4);

			case 0x0b:
				os_std(SCM.gpr3, OS$gen_long, DD$aqbi_gpr3_5);

			case 0x0c:
				os_std(SCM.gpr3, OS$gen_long, DD$aqbi_gpr3_6);

			case 0x13:
				os_std(SCM.gpr3, OS$gen_long, DD$aqbi_gpr3_7);

			case 0x16:
				os_std(SCM.gpr3, OS$gen_long, DD$aqbi_gpr3_8);

			case 0x17:
				os_std(SCM.gpr3, OS$gen_long, DD$aqbi_gpr3_9);

			case 0x19: