gp2_hardware.c

操作系统SunOS 4.1.3版本的源码

#ifndef lint
static	char sccsid[] = "@(#)gp2_hardware.c 1.1 92/07/30 Copyright Sun Micro";
#endif

/*
 * Copyright (c) 1988 by Sun Microsystems, Inc.
 */
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include <math.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <pixrect/pixrect.h>
#include <pixrect/pixrect_hs.h>
#include <pixrect/memreg.h>
#include <pixrect/cg2reg.h>
#include <pixrect/gp1cmds.h>
#include <sun/gpio.h>
#include <suntool/sunview.h>
#include <suntool/fullscreen.h>
#include <suntool/gfx_hs.h>
#include "gp2test.h"
#include "gp2test_msgs.h"
#include "gp2_hardware.h"
#include "sdrtns.h"

extern char *sprintf();

extern short *gp1_shmem;
extern int ioctlfd;

/*
 *************************************************************************
 *      Test XP Local ram
 *
 *	Test xp local ram, test all but 4 of the 64k of ram. The stack 
 *	lives in the upper portions of local ram. This is done by sending
 *	commands to the GP2 runing GPCI micro code to test local ram.
 *	If an error is detected it will be reported.
 *************************************************************************
 */
test_xp_local_ram(shmptr, offset)
    short *shmptr;
    int offset;
{
    int i, *error, err_cnt = 0;
    u_long addr, size;
    u_long data, data1;

    if ((!exec_by_sundiag) || (debug))
        gp_send_message(0, DEBUG, "\tTesting XP Local Ram\n");
    addr = 0x0;
    size = 0xf000;
    data = 0x00000001;
    for (i = 0; i < 32; i++) {
        error = (int *)post_mem_test(XPMEMTST,addr,size,data,shmptr,offset);
        data1 = *(error+4);
        if (data1 != 0 )
            gp_send_message(-DATA_ERROR, FATAL, xp_local_ram_msg1);
        if (*error != 0) {
            err_cnt++;
	    (void) sprintf(msg, xp_local_ram_msg2, *(error+1));
            gp_send_message(0, ERROR, msg);
	    (void) sprintf(msg, data_err_msg1, *(error+2),*(error+3),*error);
            gp_send_message(-DATA_ERROR, FATAL, msg);
        }
        data = data << 1;
    }
    return(err_cnt);
}

/*
 **********************************************************************
 *      Test XP Shared ram
 **********************************************************************
 */
test_xp_shared_ram(shmptr, offset)
    short *shmptr;
    int offset;
{
    int i, *error, err_cnt = 0;
    u_long addr, size;
    u_long data, data1;

    if ((!exec_by_sundiag) || (debug))
        gp_send_message(0, DEBUG, "\tTesting XP Shared Ram\n");
    addr = 0x70000;
    size = 0x0fb00;
    data = 1;
    for (i = 0; i < 32; i++) {
        error = (int *)post_mem_test(XPMEMTST,addr,size,data,shmptr,offset);
        data1 = *(error+4);
        if (data1 != 0 )
            gp_send_message(-DATA_ERROR, FATAL, xp_shared_ram_msg1);
        data1 = *error;
        if (data1 != 0) {
            err_cnt++;
	    (void) sprintf(msg, xp_shared_ram_msg2, *(error+1));
            gp_send_message(0, ERROR, msg);
	    (void) sprintf(msg, data_err_msg1, *(error+2),*(error+3),*error);
            gp_send_message(-DATA_ERROR, FATAL, msg);
        }
        data = data << 1;
    }
    return(err_cnt);
}

/*
 *********************************************************************
 *      Test XP sequencer
 *
 *	Test the XP sequencer to determine if it processes the condition
 *	codes correctly.
 *********************************************************************
 */

test_xp_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 XP Sequencer\n");
    for (i = 0; i < 12; i++) {
        error = (int *)post_alu_test(XPSEQ,seq_tst[i][0],seq_tst[i][1],
            seq_tst[i][2],shmptr,offset);
        data1 = *(error+4);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, xp_sequencer_msg1);
        if (*error != seq_tst[i][3]) {
            err_cnt++;
	    (void) sprintf(msg, xp_sequencer_msg2, seq_tst[i][3], *error, i);
            gp_send_message(-DATA_ERROR, FATAL, msg);
        }
    }
    return(err_cnt);
}

/*
 *********************************************************************
 *      Test XP Alu
 *
 *	Simple ALU test to determine if the basic arithmetic functions
 *	work.
 *********************************************************************
 */
test_xp_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 XP Alu\n");
    for (i = 0; i < 8; i++) {
        error = (int *)post_alu_test(XPALUTST,alu_tst[i][0],
                                alu_tst[i][1],alu_tst[i][2],shmptr, offset);
        data1 = *(error+4);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, xp_alu_msg1);
        if (*error != alu_tst[i][3]) {
            err_cnt++;
	    (void) sprintf(msg, xp_alu_msg2, alu_tst[i][3],*error);
            gp_send_message(-DATA_ERROR, FATAL, msg);
        }
    }
    return(err_cnt);
}
 
/*
 *********************************************************************
 *      XP -> RP fifo -> XP read back reg test
 *
 *	XP sends data to RP fifo. 
 *	RP read fifo data and sends to XP readback register
 *	XP reads readback register and checks data.
 *	Reports error if any.
 *********************************************************************
 */
test_xp_rp_fifo(shmptr, offset)
    short *shmptr;
    int offset;
{
    int i, *error, err_cnt = 0;
    u_long data, data1;

    data = 0x55555555;
    if ((!exec_by_sundiag) || (debug))
    	gp_send_message(0, DEBUG, "\tTesting XP -> RP Fifo\n");
    for (i = 0; i < 2; i++) {
        error = (int *)post_fifo(XPFIFO,data,shmptr,offset);
        data1 = *(error+5);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, xp_rp_fifo_msg1);
        if (*error != 0) {
            err_cnt++;
	    (void) sprintf(msg, xp_rp_fifo_msg2, *error);
            gp_send_message(0, ERROR, xp_rp_fifo_msg2);
	    (void) sprintf(msg, data_err_msg2, data,*(error-1));
            gp_send_message(-DATA_ERROR, FATAL, msg);
        }
        data = ~data;
    }
    return(err_cnt);
}

/*        
 ***********************************************************************
 *      RP Local Ram Test
 **********************************************************************
 */
test_rp_local_ram(shmptr, offset)
    short *shmptr;
    int offset;
{
    int i, *error, err_cnt = 0;
    u_long addr, size;
    u_long data, data1;

    if ((!exec_by_sundiag) || (debug))
    	gp_send_message(0, DEBUG, "\tTesting RP Local Ram\n");
    addr = 0x0;
    size = 0xf000;
    data = 1;
    for (i = 0; i < 32; i++) {
        error = (int *)post_mem_test(RPMEMTST,addr,size,data,shmptr,offset);
        data1 = *(error+4);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, rp_local_ram_msg1);
        data1 = *(error+5);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, rp_local_ram_msg2);
        if (*error != 0) {
            err_cnt++;
	    (void) sprintf(msg, rp_local_ram_msg3, *(error+1));
            gp_send_message(0, ERROR, msg);
	    (void) sprintf(msg, data_err_msg1, *(error+2),*(error+3),*error);
            gp_send_message(-DATA_ERROR, FATAL, msg);
        }
        data = data << 1;
    }
    return(err_cnt);
}

/*
 ***********************************************************************
 *      Test RP Shared ram
 ***********************************************************************
 */
test_rp_shared_ram(shmptr, offset)
    short *shmptr;
    int offset;
{
    int i, *error, err_cnt = 0;
    u_long addr, size;
    u_long data, data1;

    if ((!exec_by_sundiag) || (debug))
        gp_send_message(0, DEBUG, "\tTesting RP Shared Ram\n");
    addr = 0x70000;
    size = 0xfbc0;
    data = 1;
    for (i = 0; i < 32; i++) {
	error = (int *)post_mem_test(RPMEMTST,addr,size,data,shmptr,offset);
       	data1 = *(error+4);
       	if (data1 != 0 )
            gp_send_message(-DATA_ERROR, FATAL, rp_shared_ram_msg1);
        data1 = *(error+5);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, rp_shared_ram_msg2);
        data1 = *error;
        if (*error != 0) {
            err_cnt++;
	    (void) sprintf(msg, rp_shared_ram_msg3, *(error+1));
            gp_send_message(0, ERROR, msg);
	    (void) sprintf(msg, data_err_msg1, *(error+2),*(error+3),*error);
            gp_send_message(-DATA_ERROR, FATAL, msg);
        }
        data = data << 1;
    }
    return(err_cnt);
}

/*
 *********************************************************************
 *      Test RP sequencer
 *
 *	Test RP sequencer to determine if the condition codes and branch
 *	work.
 *********************************************************************
 */
test_rp_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 RP Sequencer\n");
    for (i = 0; i < 12; i++) {
        error = (int *)post_alu_test(RPSEQ,seq_tst[i][0],seq_tst[i][1],
                                seq_tst[i][2],shmptr,offset);
        data1 = *(error+4);
        if (data1 != 0 )
            gp_send_message(-DATA_ERROR, FATAL, rp_sequencer_msg1);
        data1 = *(error+5);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, rp_sequencer_msg2);
        if (*error != seq_tst[i][3]) {
            err_cnt++;
	    (void) sprintf(msg, rp_sequencer_msg3, 
                        seq_tst[i][0],seq_tst[i][3],*error);
            gp_send_message(-DATA_ERROR, FATAL, msg);
        }
    }
    return(err_cnt);
}

/*
 *********************************************************************
 *      Test RP Alu
 *
 *	Test bacic alu functions to determine if arithmetic functions
 *	work.
 *********************************************************************
 */
test_rp_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 RP Alu\n");
    for (i = 0; i < 8; i++) {
        error = (int *)post_alu_test(RPALUTST,alu_tst[i][0],
                                alu_tst[i][1],alu_tst[i][2],shmptr,offset);
        data1 = *(error+4);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, rp_alu_msg1);
        data1 = *(error+5);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, rp_alu_msg2);
        if (*error != alu_tst[i][3]) {
            err_cnt++;
	    (void) sprintf(msg, rp_alu_msg3, alu_tst[i][3],*error);
            gp_send_message(-DATA_ERROR, FATAL, msg); 
        }
    }
    return(err_cnt);
}
/*
 *********************************************************************
 *      RP -> PP fifo -> RP read back reg test
 *
 *	RP sends data to PP fifo.
 *	PP read fifo.
 *	PP writes RP read back register.
 *	RP reads PP Read back register and checks data.
 *********************************************************************
 */

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

    data = 0x55555555;
    for (i = 0; i < 2; i++) {
    	if ((!exec_by_sundiag) || (debug))
            gp_send_message(0, DEBUG, "\tTesting RP -> PP Fifo\n");
        error = (int *)post_fifo(RPFIFO,data,shmptr,offset);
        data1 = *(error+5);
        if (data1 != 0)
            gp_send_message(-DATA_ERROR, FATAL, rp_pp_fifo_msg1);
        data1 = *(error+6);
        if (data1 != 0 )
            gp_send_message(-DATA_ERROR, FATAL, rp_pp_fifo_msg2);
        if (*error != 0) {
            err_cnt++;
            (void) sprintf(msg, rp_pp_fifo_msg3, *error);
            gp_send_message(0, ERROR, msg);
	    (void) sprintf(msg, data_err_msg2, data,*(error-1));
            gp_send_message(-DATA_ERROR, FATAL, data_err_msg2);
        }
    	data = ~data;
    }
    return(err_cnt);
}

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

    data = 0x00067788;
    data = 1;
    if ((!exec_by_sundiag) || (debug))
        gp_send_message(0, DEBUG, "\tTesting PP LDX AGO\n");
    (void) post_ppld_reg(PP_LD_REG,(u_long)4,(u_long)4,shmptr,offset);
    error = (int *)post_pp_ago(PPLDXAGO,data,shmptr,offset);
    data1 = *(error+6);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_ldx_ago_msg1);
    data1 = *(error+7);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_ldx_ago_msg2);
    data1 = *(error+8);
    if (data1 != 0)
        gp_send_message(-DATA_ERROR, FATAL, pp_ldx_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.
 */
    if ( (*error & 0xfffff) != data) {	/*	srm	*/
        err_cnt++;
	(void) sprintf(msg, pp_ldx_ago_msg4, data,*error);
        gp_send_message(-DATA_ERROR, FATAL, msg);
    }
    return(err_cnt);
}

/*
 **********************************************************************
 *      Test PP ADY AGO  ldx + (ady * 1152)