fpa_systest.c

操作系统SunOS 4.1.3版本的源码

		} else if ((shad_res_msw != 0x0) || (res_i_msw != value_i) || (res0_msw != value_0)) {
		    printf("Err4:reg = %x, shadow = %x, rres= %x, sres = %x\n",
			   i, j, res0_msw, shad_res_msw);
		    printf("res_i_msw = %x\n", res_i_msw);
		    return (-1);
		}
	    }
	    *reg0 = 0x0;
	    *reg0_lsw = 0x0;
	    *reg_i = 0x0;
	    *reg_i_lsw = 0x0;
	}
	*ptr2 = 0x0;
	*ptr2_lsw = 0x0;
    }
    return (0);

}

dp_short_test()
{
    u_long          res, res1_lsw, res1_msw, res2_lsw, res2_msw, res3_lsw, res3_msw;
    u_long          i, j;
    u_long         *soft_clear, *ptr1, *ptr2, *ptr1_lsw, *ptr2_lsw, *ptr3, *ptr3_lsw;
    u_long         *pipe;

    pipe = (u_long *) (FPA_BASE + FPA_STABLE_PIPE_STATUS);
    soft_clear = (u_long *) FPA_CLEAR_PIPE_PTR;
    for (i = 0; i < 16; i++) {
	ptr2 = (u_long *) user[i].reg_msw;
	ptr2_lsw = (u_long *) user[i].reg_lsw;

	/* initialize */
	*ptr2 = 0x0;
	*ptr2_lsw = 0x0;
    }
    res3_msw = 0x3FD55555;		       /* the result is always dp
					        * value 0.3333333333333333 */
    res3_lsw = 0x55555555;

    for (i = 0; i < 8; i++) {
	ptr1 = (u_long *) dps[i].addr;	       /* for higher significant
					        * value */
	ptr1_lsw = (u_long *) 0xE0001000;      /* for least significant value */
	ptr2 = (u_long *) user[i].reg_msw;
	ptr2_lsw = (u_long *) user[i].reg_lsw;

	for (j = 0; j < 8; j++) {

	    ptr3 = (u_long *) shadow[j].shreg_msw;
	    ptr3_lsw = (u_long *) shadow[j].shreg_lsw;
	    *ptr2 = 0x3FF00000;		       /* register has dp value 1 */
	    *ptr2_lsw = 0x0;
	    *(u_long *) FPA_IMASK_PTR = 0x1;


	    *ptr1 = 0x40080000;		       /* operand is a dp value  3 */

	    *ptr1_lsw = 0x0;

	    res1_msw = *ptr3;		       /* read the shadow register */
	    res1_lsw = *ptr3_lsw;

	    *soft_clear = 0x0;

	    res2_msw = *ptr2;		       /* read the result from the
					        * reg */
	    res2_lsw = *ptr2_lsw;
	    *(u_long *) FPA_IMASK_PTR = 0x0;

	    if (i == j) {

		if ((res3_msw != res2_msw) || (res3_msw != res1_msw)) {
		    printf("Err1:reg = %x, shadow = %x, rres= %x, sres = %x\n",
			   i, j, res2_msw, res1_msw);

		    return (-1);
		}
	    }
	    if (i != j) {
		if ((res1_msw != 0x0) || (res2_msw != 0x3FF00000)) {
		    printf("Err2:reg = %x, shadow = %x, rres= %x, sres = %x\n", i, j, res2_msw, res1_msw);

		    return (-1);
		}
	    }
	}
	*ptr2 = 0x0;
	*ptr2_lsw = 0x0;
    }
    return (0);
}

dp_ext_test()
{
    u_long          res, res1_lsw, res1_msw, res2_lsw, res2_msw, res3_lsw, res3_msw;
    int             i, j;
    u_long         *soft_clear, *ptr1, *ptr2, *ptr1_lsw, *ptr2_lsw, *ptr3, *ptr3_lsw;

    soft_clear = (u_long *) FPA_CLEAR_PIPE_PTR;
    for (i = 0; i < 16; i++) {
	ptr2 = (u_long *) user[i].reg_msw;
	ptr2_lsw = (u_long *) user[i].reg_lsw;

	/* initialize */
	*ptr2 = 0x0;
	*ptr2_lsw = 0x0;
    }
    res3_msw = 0x3FD55555;		       /* the result is always dp
					        * value 0.33333333 */
    res3_lsw = 0x55555555;

    for (i = 0; i < 16; i++) {
	ptr1 = (u_long *) ext[i].addr;
	ptr1_lsw = (u_long *) ext[i].addr_lsw;
	ptr2 = (u_long *) user[i].reg_msw;
	ptr2_lsw = (u_long *) user[i].reg_lsw;
	for (j = 0; j < 8; j++) {
	    ptr3 = (u_long *) shadow[j].shreg_msw;
	    ptr3_lsw = (u_long *) shadow[j].shreg_lsw;
	    *ptr2 = 0x3FF00000;		       /* register has dp value 1 */
	    *ptr2_lsw = 0x0;
	    *(u_long *) FPA_IMASK_PTR = 0x1;

	    *ptr1 = 0x40080000;		       /* operand is a dp value 3 */
	    *ptr1_lsw = 0x0;
	    res1_msw = *ptr3;		       /* read the shadow register */
	    res1_lsw = *ptr3_lsw;
	    *soft_clear = 0x0;

	    res2_msw = *ptr2;		       /* read the result from the
					        * reg */
	    res2_lsw = *ptr2_lsw;
	    *(u_long *) FPA_IMASK_PTR = 0x2;

	    if (i == j) {
		if ((res3_msw != res2_msw) && (res3_msw != res1_msw)) {
		    printf("Err1:reg = %x, shadow = %x, rres= %x, sres = %x\n",
			   i, j, res2_msw, res1_msw);
		    return (-1);
		}
	    } else {
		if ((res1_msw != 0x0) || (res2_msw != 0x3FF00000)) {
		    printf("Err2:reg = %x, shadow = %x, rres= %x, sres = %x\n", i, j, res2_msw, res1_msw);
		    return (-1);
		}
	    }

	}
	*ptr2 = 0x0;
	*ptr2_lsw = 0x0;
    }
    return (0);
}

dp_cmd_test()
{
    u_long          res, res1_lsw, res1_msw, res2_lsw, res2_msw, res3_lsw, res3_msw;
    int             i, j, k, l;
    u_long         *soft_clear, *ptr1, *ptr2, *ptr1_lsw, *ptr2_lsw, *ptr3, *ptr3_lsw;
    u_long         *ptr4, *ptr4_lsw, *ptr5, *ptr5_lsw;

    soft_clear = (u_long *) FPA_CLEAR_PIPE_PTR;
    for (i = 0; i < 32; i++) {
	ptr2 = (u_long *) user[i].reg_msw;
	ptr2_lsw = (u_long *) user[i].reg_lsw;

	/* initialize */
	*ptr2 = 0x0;
	*ptr2_lsw = 0x0;
    }
    res3_msw = 0x3FD55555;		       /* the result is always dp
					        * value 0.3333333333 */
    res3_lsw = 0x55555555;

    for (i = 0; i < 30; i++) {
	ptr1 = (u_long *) 0xE0000A34;	       /* for dp divide from weitek
					        * spec */
	ptr2 = (u_long *) user[i].reg_msw;
	ptr2_lsw = (u_long *) user[i].reg_lsw;
	k = i + 1;
	l = i + 2;
	ptr4 = (u_long *) user[k].reg_msw;
	ptr4_lsw = (u_long *) user[k].reg_lsw;
	ptr5 = (u_long *) user[l].reg_msw;
	ptr5_lsw = (u_long *) user[l].reg_lsw;

	for (j = 0; j < 8; j++) {
	    ptr3 = (u_long *) shadow[j].shreg_msw;
	    ptr3_lsw = (u_long *) shadow[j].shreg_lsw;
	    *ptr4 = 0x3FF00000;		       /* register has dp value 1 */
	    *ptr4_lsw = 0x0;
	    *ptr5 = 0x40080000;		       /* register has dp value 3 */
	    *ptr5_lsw = 0x0;

	    *(u_long *) FPA_IMASK_PTR = 0x1;

	    *ptr1 = cmd[i].data;
	    res1_msw = *ptr3;		       /* read the shadow register */
	    res1_lsw = *ptr3_lsw;
	    *soft_clear = 0x0;

	    res2_msw = *ptr2;		       /* read the result from the
					        * reg */
	    res2_lsw = *ptr2_lsw;
	    *(u_long *) FPA_IMASK_PTR = 0x0;

	    if (i == j) {

		if ((res3_msw != res2_msw) || (res3_msw != res1_msw)) {
		    printf("Err1:reg = %x, shadow = %x, rres= %x, sres = %x\n",
			   i, j, res2_msw, res1_msw);
		    return (-1);
		}
	    } else if (j == k) {
		if ((res2_msw != 0x0) || (res1_msw != 0x3FF00000)) {
		    printf("Err2:reg = %x, shadow = %x, rres= %x, sres = %x\n",
			   i, j, res2_msw, res1_msw);
		    return (-1);
		}
	    } else if (j == l) {
		if ((res2_msw != 0x0) || (res1_msw != 0x40080000)) {
		    printf("Err3:reg = %x, shadow = %x, rres= %x, sres = %x\n",
			   i, j, res2_msw, res1_msw);
		    return (-1);
		}
	    }
	    *ptr2 = 0x0;
	    *ptr2_lsw = 0x0;
	}
    }
    return (0);
}



map_ram()
{
    u_long          i, temp_val, tmp_data;
    u_long         *ram_ptr, *rw_ram_ptr;
    u_char          no_data_flag = 0xff;

    ram_ptr = (u_long *) FPA_RAM_ACC;
    if (debug)
	printf("passed ram_ptr = (u_long *)FPA_RAM_ACC\n");
    rw_ram_ptr = (u_long *) FPA_RW_RAM;
    if (debug)
	printf("passed rw_ram_ptr = (u_long *)FPA_RW_RAM\n");
    *ram_ptr = TEST_PTR(0, MR_LB);
    if (debug)
	printf("passed *ram_ptr = TEST_PTR(0, MR_LB)\n");
    temp_val = *rw_ram_ptr;
    if (debug)
	printf("passed temp_val = *rw_ram_ptr\n");
    temp_val = temp_val & MR_DMASK;
    if (debug)
	printf("passed temp_val = temp_val & MR_DMASK\n");
    if (temp_val)
	no_data_flag = 0x0;		       /* data  is non zero */
    if (debug)
	printf("temp_val = %x\n", temp_val);
    for (i = 1; i < MAXSIZE_MAP_RAM; i++) {
	*ram_ptr = TEST_PTR(i, MR_LB);
	if (debug && (i % 1024) == 0)
	    printf("passed *ram_ptr = TEST_PTR(i, MR_LB)\n");
	tmp_data = *rw_ram_ptr & MR_DMASK;
	if (debug && (i % 1024) == 0)
	    printf("passed tmp_data = *rw_ram_ptr & MR_DMASK\n");
	if (tmp_data)
	    no_data_flag = 0x0;		       /* data is non zero */
	if (debug && (i % 512) == 0)
	    printf("tmp_data = %d\n", tmp_data);
	temp_val = (temp_val ^ tmp_data) & MR_DMASK;
	if (debug && (i % 1024) == 0)
	    printf("passed temp_val = (temp_val ^ tmp_data) & MR_DMASK\n");
	if (debug && (i % 512) == 0)
	    printf("temp_val = %x\n", temp_val);
    }
    if (debug)
	printf("no_data_flag = %d\n", no_data_flag);
    if (no_data_flag)
	return (-1);			       /* data is zero , error */
    if (debug)
	printf("temp_val = %x\n", temp_val);
    if (temp_val == 0xadface)
	return (0);

    else
	return (-1);
}

ustore_ram()
{
    u_long          i, tmp_val, tmp_data;
    u_long          tmp_val1, tmp_data1;
    u_long          tmp_val2, tmp_data2;
    u_char          no_data_flag = 0xff;
    u_long         *ram_ptr, *rw_ram_ptr;

    ram_ptr = (u_long *) FPA_RAM_ACC;
    rw_ram_ptr = (u_long *) FPA_RW_RAM;

    *ram_ptr = TEST_PTR(0, UR_LBL);
    tmp_val = *rw_ram_ptr;
    *ram_ptr = TEST_PTR(0, UR_LBM);
    tmp_val1 = *rw_ram_ptr;
    *ram_ptr = TEST_PTR(0, UR_LBH);
    tmp_val2 = *rw_ram_ptr & UR_DMASK;
    if ((tmp_val) || (tmp_val1) || (tmp_val2))
	no_data_flag = 0x0;		       /* data is non zero */

    for (i = 1; i < MAXSIZE_USTORE_RAM; i++) {

	*ram_ptr = TEST_PTR(i, UR_LBL);
	tmp_data = *rw_ram_ptr;
	*ram_ptr = TEST_PTR(i, UR_LBM);
	tmp_data1 = *rw_ram_ptr;
	*ram_ptr = TEST_PTR(i, UR_LBH);
	tmp_data2 = *rw_ram_ptr & UR_DMASK;
	if ((tmp_data) || (tmp_data1) || (tmp_data2))
	    no_data_flag = 0x0;		       /* data is non zero */

	tmp_val = tmp_val ^ tmp_data;
	tmp_val1 = tmp_val1 ^ tmp_data1;
	tmp_val2 = (tmp_val2 ^ tmp_data2) & UR_DMASK;
    }
    if (no_data_flag)
	return (-1);			       /* data is zero , error */
    if ((tmp_val == 0xbeadface) && (tmp_val1 == 0xbeadface) && (tmp_val2 == 0xce))
	return (0);

    else
	return (-1);
}

reg_uh_ram()
{
    u_long          i, tmp_val, tmp_data;
    u_long          tmp_val1, tmp_data1;
    u_long         *ram_ptr, *rw_ram_ptr;
    u_char          no_data_flag = 0xff;

    ram_ptr = (u_long *) FPA_RAM_ACC;
    if (debug)
	printf("passed ram_ptr = (u_long *)FPA_RAM_ACC\n");
    rw_ram_ptr = (u_long *) FPA_RW_LREG_RR;
    if (debug)
	printf("passed rw_ram_ptr = (u_long *)FPA_RW_LREG_RR\n");
    *ram_ptr = TEST_PTR(0x400, RR_LB);
    if (debug)
	printf("passed *ram_ptr = TEST_PTR(0x400, RR_LB)\n");
    tmp_val = *rw_ram_ptr;
    if (debug)
	printf("passed tmp_val = *rw_ram_ptr \n");
    if (tmp_val)
	no_data_flag = 0x0;		       /* data is non zero */

    for (i = 0x401; i <= MAXSIZE_CON_RAM; i++) {

	*ram_ptr = TEST_PTR(i, RR_LB);
	tmp_data = *rw_ram_ptr;
	if (tmp_data)
	    no_data_flag = 0x0;		       /* data is non zero */
	tmp_val = tmp_val ^ tmp_data;
    }
    if (debug)
	printf("passed for loop\n");
    *ram_ptr = TEST_PTR(0x7FF, RR_LB);
    if (debug)
	printf("passed *ram_ptr = TEST_PTR(0x7FF, RR_LB)\n");
    tmp_data = *rw_ram_ptr;
    if (debug)
	printf("passed tmp_data = *rw_ram_ptr\n");
    if (tmp_data)
	no_data_flag = 0x0;		       /* data is non zero */
    tmp_val = tmp_val ^ tmp_data;
    if (debug)
	printf("passed tmp_val = tmp_val ^ tmp_data\n");

    rw_ram_ptr = (u_long *) FPA_RW_MREG_RR;
    if (debug)
	printf("passed rw_ram_ptr = (u_long *)FPA_RW_MREG_RR\n");
    *ram_ptr = TEST_PTR(0x400, RR_LB);
    if (debug)
	printf("passed *ram_ptr = TEST_PTR(0x400, RR_LB)\n");
    tmp_val1 = *rw_ram_ptr;
    if (debug)
	printf("tmp_val1 = %x", tmp_val);
    if (tmp_val1)
	no_data_flag = 0x0;		       /* data is non zero */

    for (i = 0x401; i <= MAXSIZE_CON_RAM; i++) {

	*ram_ptr = TEST_PTR(i, RR_LB);
	tmp_data1 = *rw_ram_ptr;
	if (tmp_data1)
	    no_data_flag = 0x0;		       /* data is non zero */
	tmp_val1 = tmp_val1 ^ tmp_data1;
    }
    if (debug)
	printf("passed for loop\n");
    *ram_ptr = TEST_PTR(0x7FF, RR_LB);
    if (debug)
	printf("passed *ram_ptr = TEST_PTR(0x7FF, RR_LB)\n");
    tmp_data1 = *rw_ram_ptr;
    if (debug)
	printf("passed tmp_data1 = *rw_ram_ptr\n");
    if (debug)
	printf("tmp_data1 = %x\n", tmp_data1);
    if (tmp_data1)
	no_data_flag = 0x0;		       /* data is non zero */
    tmp_val1 = tmp_val1 ^ tmp_data1;
    if (debug)
	printf("passed tmp_val1 = tmp_val1 ^ tmp_data1\n");
    if (debug)
	printf("no_data_flag = %d\n", no_data_flag);
    if (no_data_flag) {
	return (-1);			       /* data is zero , error */
    }
    if (debug)
	printf("tmp_val = %x    tmp_val1 = %x\n", tmp_val, tmp_val1);
    if ((tmp_val == 0xBEADFACE) && (tmp_val1 == 0xBEADFACE))
	return (0);
    else {
	return (-1);
    }
}

pointer_test()
{
    if (pointer_short())
	return (-1);
    if (pointer_sp_ext())
	return (-1);
    if (pointer_dp_ext())
	return (-1);
    if (pointer_cmd())
	return (-1);
    return (0);
}


pointer_cmd()
{
    u_long          temp_ptr3, temp_ptr4, res1, res2;
    u_long         *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;
    u_char          i, j, k, l, m, n;

    /* Initialize  by giving the diagnostic initialize command */
    *(u_long *) DIAG_INIT_CMD = 0x0;
    *(u_long *) MODE_WRITE_REGISTER = 0x2;

    for (n = 0; n < 2; n++) {
	if (n == 0)
	    ptr1 = (u_long *) 0xE0000888;
	else
	    ptr1 = (u_long *) 0xE000088C;


	for (i = 0; i < 28; i++) {
	    for (j = 0; j < 32; j++) {
		ptr2 = (u_long *) users[j].reg;
		*ptr2 = 0x0;
		ptr2++;
		*ptr2 = 0x0;		       /* low order word */
	    }
	    k = i + 1;
	    l = i + 2;
	    m = i + 3;

	    ptr2 = (u_long *) users[k].reg;
	    ptr3 = (u_long *) users[l].reg;
	    ptr4 = (u_long *) users[m].reg;

	    *ptr2 = sp_dp_res[n].reg1;
	    *ptr3 = sp_dp_res[n].reg2;
	    *ptr4 = sp_dp_res[n].reg3;

	    *ptr1 = cmd_reg[i];

	    for (j = 0; j < 32; j++) {
		ptr5 = (u_long *) users[j].reg;
		res1 = *ptr5;

		if (i == j) {
		    if (res1 != sp_dp_res[n].res)
			return (-1);
		} else if (j == k) {
		    if (res1 != sp_dp_res[n].reg1)
			return (-1);
		} else if (j == l) {
		    if (res1 != sp_dp_res[n].reg2)
			return (-1);
		} else if (j == m) {
		    if (res1 != sp_dp_res[n].reg3)
			return (-1);
		} else if (res1 != 0x0)
		    return (-1);
	    }
	}
    }
    return (0);
}

pointer_sp_ext()
{