gp2_hardware.c

操作系统SunOS 4.1.3版本的源码

 **********************************************************************
 */
test_pp_ady_ago(shmptr, offset)
    short *shmptr;
    int offset;
{
    int *error, err_cnt = 0;
    u_long data, data1;

    data = 0x00034455;
    data = 0;
    if ((!exec_by_sundiag) || (debug))
        gp_send_message(0, DEBUG, "\tTesting PP ADY AGO\n");
    (void) post_ppld_reg(PP_LD_REG,(u_long)4,(u_long)4,shmptr,offset);
    error = (int *)post_pp_ago(PPADYAGO,data,shmptr,offset);
    data1 = *(error+6);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_ady_ago_msg1);
    data1 = *(error+7);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_ady_ago_msg2);
    data1 = *(error+8);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_ady_ago_msg3); 
/*
 *	srm	the folowing addition of the & with 0xfffff is because
 *	srm	the ago is only 20 bits wide and when read will include
 *	srm	two bits from the amd which are not predictable.
 */
    data = 1;
    if ( (*error & 0xfffff) != data) {	/*	srm	*/
        err_cnt++;
	(void) sprintf(msg, pp_ady_ago_msg4, data,*error);
        gp_send_message(-DATA_ERROR, FATAL, msg);
    }
    return(err_cnt);
}

/*
 **********************************************************************
 *      Test PP ADX AGO  above ago + adx
 **********************************************************************
 */
test_pp_adx_ago(shmptr, offset)
    short *shmptr;
    int offset;
{
    int *error, err_cnt = 0;
    u_long data, data1;

    data = 0x000609f8;
    if ((!exec_by_sundiag) || (debug))
        gp_send_message(0, DEBUG, "\tTesting PP ADX AGO\n");
    (void) post_ppld_reg(PP_LD_REG,(u_long)4,(u_long)4,shmptr,offset);
    error = (int *)post_pp_ago(PPADXAGO,data,shmptr,offset);
    data1 = *(error+6);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_adx_ago_msg1);
    data1 = *(error+7);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_adx_ago_msg2); 
    data1 = *(error+8);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_adx_ago_msg3);
/*
 *	srm	the folowing addition of the & with 0xfffff is because
 *	srm	the ago is only 20 bits wide and when read will include
 *	srm	two bits from the amd which are not predictable.
 */
    data = 0x609f9;
    if ( (*error & 0xfffff) != data) {	/*	srm	*/
        err_cnt++;
	(void) sprintf(msg, pp_adx_ago_msg4, data,*error);
        gp_send_message(-DATA_ERROR, FATAL, msg);
    }
    return(err_cnt);
}

/*
 **********************************************************************
 *      Test PP Sequencer Test
 **********************************************************************
 */
test_pp_sequencer(shmptr, offset)
    short *shmptr;
    int offset;
{
    int i, *error, err_cnt = 0;
    u_long data1;

    if ((!exec_by_sundiag) || (debug))
        gp_send_message(0, DEBUG, "\tTesting PP Sequencer\n");
    for (i = 0; i < 12; i++) {
        error = (int *)post_alu_test(PPSEQ,ppseq_tst[i][0],ppseq_tst[i][1],
                                ppseq_tst[i][2],shmptr,offset);
        data1 = *(error+4);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, pp_sequencer_msg1);
        data1 = *(error+5);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, pp_sequencer_msg2); 
        data1 = *(error+6);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, pp_sequencer_msg3);
        if (*error != ppseq_tst[i][3]) {
            err_cnt++;
	    (void) sprintf(msg, pp_sequencer_msg4, 
                ppseq_tst[i][0],ppseq_tst[i][3],*error);
            gp_send_message(-DATA_ERROR, FATAL, msg);
        }
    }
    return(err_cnt);
}

/*
 **********************************************************************
 *      Test PP ALU Test
 **********************************************************************
 */
test_pp_alu(shmptr, offset)
    short *shmptr;
    int offset;
{
    int i, *error, err_cnt = 0;
    u_long data1;

    if ((!exec_by_sundiag) || (debug))
        gp_send_message(0, DEBUG, "\tTesting PP ALU \n");
    for (i = 0; i < 8; i++) {
        error = (int *)post_alu_test(PPALU,ppalu_tst[i][0],ppalu_tst[i][1],
                                ppalu_tst[i][2],shmptr,offset);
        data1 = *(error+4);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, pp_alu_msg1);
        data1 = *(error+5);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, pp_alu_msg2);
        data1 = *(error+6);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, pp_alu_msg3);
        if (*error != ppalu_tst[i][3]) {
            err_cnt++;
	    (void) sprintf(msg, pp_alu_msg4,
                        ppalu_tst[i][0],ppalu_tst[i][3],*error);
            gp_send_message(-DATA_ERROR, FATAL, msg);
        }
    }
    return(err_cnt);
}

/*
 **********************************************************************
 *      Test PP Simple R/W of Zbuffer
 **********************************************************************
 */
test_pp_rw_zbuf(shmptr, offset)
    short *shmptr;
    int offset;
{
    int *error, err_cnt = 0;
    u_long data, data1;

    data = 1;
    if ((!exec_by_sundiag) || (debug))
        gp_send_message(0, DEBUG, "\tTesting PP one R/W Zbuffer \n");
    error = (int *)post_pp_ago(PPRW,data,shmptr,offset);
    data1 = *(error+6);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_rw_zbuf_msg1);
    data1 = *(error+7);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_rw_zbuf_msg2);
        data1 = *(error+8);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_rw_zbuf_msg3);
    if (*(error-1) != 0) {
        err_cnt++;
        switch(*(error-1)) {
            case 1 :
                data = 0;
                break;
            case 2 :
                data = 0xff;
                break;
            case 3 :
                data = 0xa5;
                break;
            case 4 :
                data = 0x5a;
                break;
        }
        (void) sprintf(msg, pp_rw_zbuf_msg4, data);
        gp_send_message(-DATA_ERROR, FATAL, msg);
    }
    return(err_cnt);
}

/*
 **********************************************************************
 *      Test PP Zbuffer
 **********************************************************************
 */
test_pp_zbuf(shmptr, offset)
    short *shmptr;
    int offset;
{
    int *error, err_cnt = 0;
    u_long data, data1;

    data = -1;
    if ((!exec_by_sundiag) || (debug))
        gp_send_message(0, DEBUG, "\tTesting PP ZBuffer\n");
    error = (int *)post_pp_ago(PPZBUF,data,shmptr,offset);
    data1 = *(error+6);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_zbuf_msg1);
    data1 = *(error+7);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_zbuf_msg2);
    data1 = *(error+8);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_zbuf_msg3);
    if (*error != 0) {
        err_cnt++;
	(void) sprintf(msg, pp_zbuf_msg4, *error);
        gp_send_message(-DATA_ERROR, FATAL, msg);
    }
    if (*(error-1) != 0) {
        err_cnt++;
	(void) sprintf(msg, pp_zbuf_msg5, *(error-1));
        gp_send_message(-DATA_ERROR, FATAL, msg);
    }
    return(err_cnt);
}

/*
 ************************************************************************
 *      Post memory test parameters to GP2
 *
 *      inputs:
 *              starting address
 *              size
 *      returns:
 *              *errors         number of errors
 *              *errors+1       failed address
 *              *errors+2       exp data
 *              *errors+3       obs data
 ************************************************************************
 */
post_mem_test(subcmd, addr, size, data, shmptr, offset)
    int subcmd;
    u_long addr,size,data;
    short *shmptr;
    int offset;
{
    int i;
    short *error;
    u_long value;

    value = GPCI_DIAG + subcmd;
    GP1_PUT_I(shmptr, value);
    GP1_PUT_I(shmptr, addr);
    GP1_PUT_I(shmptr, size);
    GP1_PUT_I(shmptr, data);
    error = shmptr;
    value = -1;
    GP1_PUT_I(shmptr, value);
    value = 0;
    for (i = 0; i < 3; i++)
        GP1_PUT_I(shmptr, value);
    value = -1;
    for (i = 0; i < 3; i++)
        GP1_PUT_I(shmptr, value);
    if ((gp1_post(gp1_shmem, offset, ioctlfd)) != 0)
        gp_send_message(-POST_ERROR, ERROR, post_mem_msg1);
    for (i = 0; i < 90000; i++);
        if ((gp1_sync(gp1_shmem, ioctlfd)) != 0)
        gp_send_message(-SYNC_ERROR, ERROR, post_mem_msg2);
    return((int)error);
}

/*
 **********************************************************************
 *      post alu parameters to GP2
 *
 *      inputs:
 *              gpci subcmd
 *              alu function:  or       seq function:
 *                      0 = add         0 = eqz
 *                      1 = sub         1 = nez
 *                      2 = xor         2 = gez
 *                      3 = xnor        3 = ltz
 *                      4 = and         4 = gtz
 *                      5 = or          5 = lez
 *                      6 = nor         6 = nov
 *                      7 = not         7 = ovf
 *              1st data
 *              2nd data
 *      returns:
 *              *results        results of function
 ************************************************************************
 */
post_alu_test(subcmd, function, data1, data2, shmptr, offset)
    int subcmd;
    u_long function,data1,data2;
    short *shmptr;
    int offset;
{
    int                i;
    short              *results;
    u_long             value;

    value = GPCI_DIAG + subcmd;
    GP1_PUT_I(shmptr, value);
    GP1_PUT_I(shmptr, function);
    GP1_PUT_I(shmptr, data1);
    GP1_PUT_I(shmptr, data2);
    results = shmptr;
    value = -1;
    for (i = 0; i < 6; i++)
        GP1_PUT_I(shmptr, value);
    GP1_PUT_I(shmptr, value);
    if ((gp1_post(gp1_shmem, offset, ioctlfd)) != 0)
        gp_send_message(-POST_ERROR, ERROR, post_alu_msg1);
    if ((gp1_sync(gp1_shmem, ioctlfd)) != 0)
        gp_send_message(-SYNC_ERROR, ERROR, post_alu_msg2);
    return((int)results);
}

/*
 *************************************************************************
 *      post fifo parameters to GP2
 *
 *      inputs:
 *              subcmd
 *              data
 *      returns:
 *              *error
 ************************************************************************
 */
post_fifo(subcmd,data,shmptr,offset)
int subcmd;
u_long data;
short *shmptr;
int offset;
{
    int i;
    short *error;
    u_long value;

    value = GPCI_DIAG + subcmd;
    GP1_PUT_I(shmptr, value);
    GP1_PUT_I(shmptr, data);
    value = -1;
    GP1_PUT_I(shmptr, value);
    error = shmptr;
    value = -1;
    for (i = 0; i < 7; i++)
    	GP1_PUT_I(shmptr, value);
    if ((gp1_post(gp1_shmem, offset, ioctlfd)) != 0)
        gp_send_message(-POST_ERROR, ERROR, post_fifo_msg1);
    for (i = 0; i < 9000; i++);
    if ((gp1_sync(gp1_shmem, ioctlfd)) != 0 )
        gp_send_message(-SYNC_ERROR, ERROR, post_fifo_msg2);
    return((int)error);
}

/*
 *************************************************************************
 *      post_pp_ago parameters to GP2
 *
 *      inputs:
 *              subcmd
 *              data
 *      returns:
 *              *error
 ************************************************************************
 */

post_pp_ago(subcmd,data,shmptr,offset)
    int subcmd;
    u_long data;
    short *shmptr;
    int offset;
{
    int                i;
    short              *error;
    u_long             value;

    value = GPCI_DIAG + subcmd;
    GP1_PUT_I(shmptr, value);
    GP1_PUT_I(shmptr, data);
    error = shmptr;
    value = -1;
    for (i = 0; i < 8; i++)
        GP1_PUT_I(shmptr, value);
    if ((gp1_post(gp1_shmem, offset, ioctlfd)) != 0 )
        gp_send_message(-POST_ERROR, ERROR, post_pp_ago_msg1);
    if ((gp1_sync(gp1_shmem, ioctlfd)) != 0)
        gp_send_message(-SYNC_ERROR, ERROR, post_pp_ago_msg2);
    return((int)error);
}
/*
 *************************************************************************
 *      post_ppld_reg parameters to GP2
 *
 *      inputs:
 *              subcmd
 *		reg
 *              data
 *      returns:
 *              *error
 ************************************************************************
 */

post_ppld_reg(subcmd,reg,data,shmptr,offset)
    int subcmd;
    u_long reg,data;
    short *shmptr;
    int offset;
{
    u_long             value;
    short              *error;
    int                i;

    value = GPCI_DIAG + subcmd;
    GP1_PUT_I(shmptr, value);
    GP1_PUT_I(shmptr,reg);
    GP1_PUT_I(shmptr,data);
    error = shmptr;
    value = -1;
    for (i = 0; i < 8; i++)
    	GP1_PUT_I(shmptr, value);
    if ((gp1_post(gp1_shmem, offset, ioctlfd)) != 0)
    	gp_send_message(-POST_ERROR, ERROR, post_ppld_msg1);
    if ((gp1_sync(gp1_shmem, ioctlfd)) !=0)
    	gp_send_message(-SYNC_ERROR, ERROR, post_ppld_msg2);
    return((int)error);
}