![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mtpr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4|
Return to mtpr.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 ! root 1: ! 2: #include "fpp_defs.h" ! 3: ! 4: #define TBL_SIZE 1024 /* size of the prom table */ ! 5: ! 6: /***************************************************************************** ! 7: * ! 8: * MTPR - TEST THE "READ TABLE DATA" MTPR INSTRUCTION ! 9: * ! 10: * This test checks the ability to use an MTPR to the Diagnostic Control ! 11: * Register (DCR) to read an entry in the FPP tables. ! 12: * ! 13: * The instruction is: ! 14: * MTPR $2048,$DCR ! 15: * R0 = the table address to check ! 16: * ! 17: * The MTPR instruction will put the table data into R1. ! 18: * ! 19: *****************************************************************************/ ! 20: mtpr_tst() ! 21: { ! 22: asm(".globl _mtpr_t"); ! 23: asm("_mtpr_t:"); /* entry address */ ! 24: if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */ ! 25: writes(" MTPR"); ! 26: mtpr_1(); /* read w/ sgl accumulator */ ! 27: mtpr_2(); /* read w/ dbl accumulator */ ! 28: mtpr_3(); /* read during "sinf" */ ! 29: asm("jmp *return"); /* return to the test monitor */ ! 30: } ! 31: ! 32: ! 33: ! 34: /************************************************************************ ! 35: * ! 36: * SUBTEST 1 - Read the tables with a single precision accumulator ! 37: * ! 38: ************************************************************************/ ! 39: mtpr_1() ! 40: { ! 41: force_loop = FALSE; ! 42: subtest = 1; ! 43: index = 0; ! 44: for( sgl_value_1 = 0; sgl_value_1 < TBL_SIZE; sgl_value_1++ ) { ! 45: sgl_ld_acc = ldf_1_data[index].ld; /* get a sgl value */ ! 46: sgl_expected = ldf_1_data[index].exp; /* & expected acc. */ ! 47: /* ! 48: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 49: * The force loop flag is set after the first error. ! 50: */ ! 51: asm("_mtpr_1_lp1:"); ! 52: asm("ldf _sgl_ld_acc"); /* load the accumulator */ ! 53: asm("movl _sgl_value_1,r0"); /* move table address to r0 */ ! 54: asm("clrl r1"); /* clear R1 */ ! 55: asm("mtpr $0x800,$27"); /* read the table entry */ ! 56: asm("stf _sgl_st_acc"); /* save the accumulator */ ! 57: asm("movl r1,_sgl_value_2"); /* save the value read */ ! 58: if( force_loop ) ! 59: asm("brb _mtpr_1_lp1");; /* loop on the error */ ! 60: /* ! 61: * end error loop ! 62: */ ! 63: if( sgl_st_acc != sgl_expected ) { /* verify the accumulator */ ! 64: errcnt++; /* bump the error count */ ! 65: if( prt_error ) ! 66: print_mtpr_error( ! 67: " (SGL Accumulator) -THE ACC WAS MODIFIED"); ! 68: if( halt_flg ) ! 69: mtpr_er_halt( 2 ); ! 70: if( loop_on_err ) { ! 71: force_loop = TRUE; /* set the force loop flag */ ! 72: asm("jmp _mtpr_1_lp1"); /* and loop */ ! 73: } ! 74: } /* end of compare error */ ! 75: if( ++index > max_ldf_1_index ) ! 76: index = 0; /* reset the Acc's index */ ! 77: } ! 78: } /* end of subtest 1 */ ! 79: ! 80: ! 81: ! 82: ! 83: ! 84: /************************************************************************ ! 85: * ! 86: * SUBTEST 2 - Read the tables with a double precision accumulator ! 87: * ! 88: ************************************************************************/ ! 89: mtpr_2() ! 90: { ! 91: force_loop = FALSE; ! 92: subtest = 2; ! 93: index = 0; ! 94: for( sgl_value_1 = 0; sgl_value_1 < TBL_SIZE; sgl_value_1++ ) { ! 95: dbl_ld_acc = ldd_1_data[index].ld; /* get a dbl value */ ! 96: dbl_expected = ldd_1_data[index].exp; /* & expected acc. */ ! 97: /* ! 98: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 99: * The force loop flag is set after the first error. ! 100: */ ! 101: asm("_mtpr_2_lp1:"); ! 102: asm("ldd _dbl_ld_acc"); /* load the accumulator */ ! 103: asm("movl _sgl_value_1,r0"); /* move table address to r0 */ ! 104: asm("clrl r1"); /* clear R1 */ ! 105: asm("mtpr $0x800,$27"); /* read the table entry */ ! 106: asm("std _dbl_st_acc"); /* save the accumulator */ ! 107: asm("movl r1,_sgl_value_2"); /* save the value read */ ! 108: if( force_loop ) ! 109: asm("brb _mtpr_2_lp1");; /* loop on the error */ ! 110: /* ! 111: * end error loop ! 112: */ ! 113: if( (dbl_st_acc.m != dbl_expected.m) || /* verify the acc. */ ! 114: (dbl_st_acc.l != dbl_expected.l) ) { ! 115: errcnt++; /* bump the error count */ ! 116: if( prt_error ) ! 117: print_mtpr_error( ! 118: " (DBL Accumulator) -THE ACC WAS MODIFIED"); ! 119: if( halt_flg ) ! 120: mtpr_er_halt( 2 ); ! 121: if( loop_on_err ) { ! 122: force_loop = TRUE; /* set the force loop flag */ ! 123: asm("jmp _mtpr_2_lp1"); /* and loop */ ! 124: } ! 125: } /* end of compare error */ ! 126: if( ++index > max_ldf_1_index ) ! 127: index = 0; /* reset the Acc's index */ ! 128: } ! 129: } /* end of subtest 2 */ ! 130: ! 131: ! 132: ! 133: ! 134: ! 135: /************************************************************************ ! 136: * ! 137: * SUBTEST 3 - Read table data during a SINF function ! 138: * ! 139: * Read every 10th table entry while doing SINF's. ! 140: * Read the entry once, read it again during a SINF, verify that the SINF ! 141: * result is correct and that the same table data was read. ! 142: ************************************************************************/ ! 143: mtpr_3() ! 144: { ! 145: int max_index; ! 146: force_loop = FALSE; ! 147: subtest = 3; ! 148: max_index = TBL_SIZE / 10; ! 149: if( max_index > max_sinf_1_index ) /* don't go over the SIN data */ ! 150: max_index = max_sinf_1_index; /* set the max index value */ ! 151: for( index = 0; index < max_sinf_1_index; index++ ) { ! 152: sgl_value_1 = index * 10; /* get table entry to read */ ! 153: sgl_ld_acc = sinf_1_data[index].ld; /* get a sgl value */ ! 154: sgl_expected = sinf_1_data[index].exp; /* & expected acc. */ ! 155: asm("movl _sgl_value_1,r0"); /* move table address to r0 */ ! 156: asm("clrl r1"); /* clear R1 */ ! 157: asm("mtpr $0x800,$27"); /* read the table entry */ ! 158: asm("movl r1,_sgl_value_3"); /* save the value read */ ! 159: /* ! 160: * If LOOP ON ERROR is set, this is the loop for this subtest. ! 161: * The force loop flag is set after the first error. ! 162: */ ! 163: asm("_mtpr_3_lp1:"); ! 164: asm("ldf _sgl_ld_acc"); /* load the accumulator */ ! 165: asm("movl _sgl_value_1,r0"); /* move table address to r0 */ ! 166: asm("clrl r1"); /* clear R1 */ ! 167: asm("sinf"); /* start the SIN function */ ! 168: asm("mtpr $0x800,$27"); /* read the table entry */ ! 169: asm("stf _sgl_st_acc"); /* save the accumulator */ ! 170: asm("movl r1,_sgl_value_2"); /* save the value read */ ! 171: if( force_loop ) ! 172: asm("brb _mtpr_3_lp1");; /* loop on the error */ ! 173: /* ! 174: * end error loop ! 175: */ ! 176: if( sgl_value_2 != sgl_value_3 ) { /* verify the data read */ ! 177: errcnt++; /* bump the error count */ ! 178: if( prt_error ) ! 179: print_mtpr_error( bad_tbl_entry_msg ); ! 180: if( halt_flg ) ! 181: mtpr_er_halt( 1 ); ! 182: if( loop_on_err ) { ! 183: force_loop = TRUE; /* set the force loop flag */ ! 184: asm("jmp _mtpr_3_lp1"); /* and loop */ ! 185: } ! 186: } /* end of table data compare error */ ! 187: if( sgl_st_acc != sgl_expected ) { /* verify the accumulator */ ! 188: errcnt++; /* bump the error count */ ! 189: if( prt_error ) ! 190: print_mtpr_error(" -BAD FINAL ACC"); ! 191: if( halt_flg ) ! 192: mtpr_er_halt( 3 ); ! 193: if( loop_on_err ) { ! 194: force_loop = TRUE; /* set the force loop flag */ ! 195: asm("jmp _mtpr_3_lp1"); /* and loop */ ! 196: } ! 197: } /* end of SINF compare error */ ! 198: if( ++index > max_sinf_1_index ) ! 199: index = 0; /* reset the Acc's index */ ! 200: } ! 201: } /* end of subtest 3 */ ! 202: ! 203: ! 204: ! 205: /****************************************************************************** ! 206: * ! 207: * Print an error message of the form: ! 208: * ! 209: * cycle: xx MTPR test xx, subtest xx <your message here> ! 210: * table index = xxxxxxxx, table entry read = xxxxxxxx (2nd read) ! 211: * expected entry = xxxxxxxx (1st read) ! 212: * or ! 213: * cycle: xx MTPR test xx, subtest xx <your message here> ! 214: * table index = xxxxxxxx, table entry = xxxxxxxx ! 215: * initial Acc = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx ! 216: * expected Acc = xxxxxxxx xxxxxxxx ! 217: ******************************************************************************/ ! 218: print_mtpr_error( msg ) ! 219: char *msg; ! 220: { ! 221: writes(" \n"); /* start a new print line */ ! 222: writes("cycle: "); ! 223: writed( cycle ); ! 224: writes(" MTPR test "); ! 225: writed( test_no ); ! 226: writes( msg ); ! 227: writes("\ntable index = "); ! 228: write32h( sgl_value_1 ); ! 229: if( msg == bad_tbl_entry_msg ) { /* bad data read? */ ! 230: writes(", table entry = "); ! 231: write32h( sgl_value_2 ); ! 232: writes(" (2nd read)\n"); ! 233: writes(" entry expected = "); ! 234: write32h( sgl_value_3 ); ! 235: writes(" (1st read)\n"); ! 236: } else { /* bad accumulator error */ ! 237: writes(", table entry = "); ! 238: write32h( sgl_value_2 ); ! 239: writes("\ninitial Acc = "); ! 240: if( subtest == 2 ) { /* DBL precision? */ ! 241: write32h( dbl_ld_acc.m ); ! 242: writec(' '); ! 243: write32h( dbl_ld_acc.l ); ! 244: writes(", final Acc = "); ! 245: write32h( dbl_st_acc.m ); ! 246: writec(' '); ! 247: write32h( dbl_st_acc.l ); ! 248: writes("\n expected Acc = "); ! 249: write32h( dbl_expected.m ); ! 250: writec(' '); ! 251: write32h( dbl_expected.l ); ! 252: } else { /* SGL precision */ ! 253: write32h( sgl_ld_acc ); ! 254: writes(", final Acc = "); ! 255: write32h( sgl_st_acc ); ! 256: writes("\n expected Acc = "); ! 257: write32h( sgl_expected ); ! 258: } ! 259: writec('\n'); ! 260: } ! 261: } ! 262: ! 263: ! 264: ! 265: ! 266: /****************************************************************************** ! 267: * ! 268: * halt with the failure information in registers ! 269: * ! 270: ******************************************************************************/ ! 271: mtpr_er_halt( code ) ! 272: int code; /* error code to halt with */ ! 273: { ! 274: sgl_dummy1 = code; /* get the halt code */ ! 275: if( subtest != 2 ) { /* check for DBL accumulator */ ! 276: dbl_ld_acc.m = sgl_ld_acc; /* get the init Acc */ ! 277: dbl_ld_acc.l = 0; ! 278: dbl_st_acc.m = sgl_st_acc; /* get the final Acc */ ! 279: dbl_st_acc.l = 0; ! 280: dbl_expected.m = sgl_expected; /* get the expected Acc */ ! 281: dbl_expected.l = 0; ! 282: } ! 283: asm("movl _test_no,r0"); /* r0 = test number */ ! 284: asm("movl _subtest,r1"); /* r1 = subtest # */ ! 285: asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 286: asm("movl _cycle,r3"); /* r3 = cycle count */ ! 287: if( code == 2 ) { /* corrupted Acc */ ! 288: asm("movl _dbl_ld_acc,r4"); /* r4 = MS initial Acc */ ! 289: asm("movl _dbl_ld_acc+4,r5"); /* r5 = LS initial Acc */ ! 290: asm("movl _dbl_st_acc,r6"); /* r6 = MS final Acc */ ! 291: asm("movl _dbl_st_acc+4,r7"); /* r7 = LS final Acc */ ! 292: asm("movl _dbl_expected,r8"); /* r8 = MS expected */ ! 293: asm("movl _dbl_expected+4,r9"); /* r9 = LS expected */ ! 294: asm("movl _sgl_value_1,r10"); /* r10 = table addr. */ ! 295: asm("movl _sgl_value_2,r11");; /* r11 = entry read */ ! 296: } else { /* wrong data read or wrong final Acc */ ! 297: asm("movl _sgl_value_1,r4"); /* r4 = table addr. */ ! 298: asm("movl _sgl_value_2,r5"); /* r5 = entry read */ ! 299: asm("movl _sgl_value_3,r6"); /* r6 = expected entry */ ! 300: asm("movl _sgl_ld_acc,r7"); /* r7 = initial Acc */ ! 301: asm("movl _sgl_st_acc,r8"); /* r8 = final Acc */ ! 302: asm("movl _sgl_expected,r9");; /* r9 = sgl expected */ ! 303: }; ! 304: asm("halt");; /* HALT ... */ ! 305: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.