hdl_uti.c

操作系统SunOS 4.1.3版本的源码

    dl_ctx->dpc = (unsigned) dl_vm;

/* Allocate and load a display list */
 
    if ((fd = fopen(dl_file, "r")) == NULL) {
        sprintf(errtxt, DLXERR_OPEN_HDL_FILE, dl_file);
        goto err_return;
    }
 
    dl_size = hk_read_hdl_header(fd);
    if (dl_size < 0) {
        sprintf(errtxt, DLXERR_READ_HDL_FILE, dl_file);
        goto err_return;
    } else if (dl_size > (((int)base_vm + (int)vm_size) - ((int)dl_vm)) - (SCRATCH_BUFFER_SIZE+1)*sizeof(unsigned)) {
	sprintf(errtxt, DLXERR_HDL_FILE_TOO_BIG, dl_size, (((int)base_vm + (int)vm_size) - ((int)dl_vm)) - (SCRATCH_BUFFER_SIZE+1)*sizeof(unsigned));
	goto err_return;
    }

    if (hk_load_hdl_file(fd, dl_size, dl_vm, dl_vm)) {
        sprintf(errtxt, DLXERR_READ_HDL_FILE, dl_file);
        goto err_return;
    }
    (void)fclose(fd);
    (void)unlink(dl_file);
    fd = (FILE *)0;

    dl_vm += dl_size/sizeof(unsigned);

    /* set scratch buffer */
    dl_ctx->scratch_buffer = (Hk_scratch_buffer *)dl_vm;
    *dl_vm++ = SCRATCH_BUFFER_SIZE;
    dl_vm += SCRATCH_BUFFER_SIZE+1;
    dl_ctx->risc_regs[HK_RISC_SP] = (int)(base_vm + (vm_size/sizeof(unsigned)));
    /* Pass the current WID to the display list for double buffering */
    dl_ctx->risc_regs[HK_RISC_R2] = wid;
    dl_ctx->risc_regs[HK_RISC_R3] = fastclear_set;
    dl_ctx->s.current_wid = wid;
    dl_ctx->s.wid_clip_mask = 0x000;
    dl_ctx->s.wid_write_mask = 0x3ff;
    dl_ctx->fast_clear_set = fastclear_set;

    /* if -1, wait for other argumens to be passed into VM */
    if (wait != -1) {
	(void)start_dl(dl_ctx, wait);
    }

    finished = 0;
    if (error) {
	sprintf(errtxt, DLXERR_HDL_EXEC, error, (error < 0) ? diag_escape_error_string(error) : hk_error_string(error));
	TRACE_OUT
	return errtxt;
    } else {
	TRACE_OUT
	return (char *)0;
    }

    err_return:
	if (fd) {
	    (void)fclose(fd);
	}
	(void)unlink(dl_file);
        finished = 0;
	TRACE_OUT
        return errtxt;

}

/**********************************************************************/
start_dl(ctx, wait)
/**********************************************************************/
Hk_context *ctx;
int wait;

{

    func_name = "start_dl";
    TRACE_IN

    user_mcb_ptr->errorcode = 0;
    user_mcb_ptr->context = (unsigned *) ctx;
    user_mcb_ptr->command = HKUVC_LOAD_CONTEXT; /* Don't pause == go */

#ifdef DEBUG [
	printf("**** start_dl() Make sure Hawk is ready ****\n");
#endif DEBUG ]

    delay = FE_DELAY;
    /* Make sure Hawk is ready */
    while (*vcom_host_s && (delay-- >= 0)) usleep(10);    /* Wait for completion */
    if (delay < 0) {
	dump_status();
	fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_FE_TIMEOUT);
    }

#ifdef DEBUG [
	printf("**** start_dl() Make sure Hawk is stopped ****\n");
#endif DEBUG ]

    delay = FE_DELAY;
    while (!user_mcb_ptr->gt_stopped && (delay-- >= 0)) usleep(10); /* Make sure Hawk is stopped */
    if (delay < 0) {
	dump_status();
	fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_FE_TIMEOUT);
    }

    finished = 0;

    *vcom_host_s = 1;

#ifdef DEBUG
    printf("*** LOAD in start_dl() ***\n");
    printf("user mcb: gt_stopped=0x%x status=0x%x, dpc=0x%x, errorcode=0x%x, command=0x%x\n", user_mcb_ptr->gt_stopped, status, dpc, error, user_mcb_ptr->command);
    printf("trap_instruction = 0x%x gt_flags=0x%x instruction_count=0x%x\n", user_mcb_ptr->trap_instruction, user_mcb_ptr->gt_flags, user_mcb_ptr->instruction_count);
#endif DEBUG

    if (wait) {
	delay = FE_DELAY*10;
	if (!finished) {	
		/* Wait for interrupt */
		while (!finished && (delay-- >= 0)) usleep(10);  
		if (delay < 0) {
	    		dump_status();
	    		fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_FE_TIMEOUT);
		}
	}
    }

    TRACE_OUT
}

/**********************************************************************/
stop_dl()
/**********************************************************************/
{
    int save_cmd;


    func_name = "stop_dl";
    TRACE_IN

#ifdef DEBUG [
	printf("**** stop_dl() Make sure Hawk is ready ****\n");
#endif DEBUG ]

    delay = FE_DELAY;
    while (*vcom_host_s && (delay-- >= 0)) usleep(10);    /* Make sure Hawk is ready */
    if (delay < 0) {
	dump_status();
	fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_FE_TIMEOUT);
    }

    save_cmd = user_mcb_ptr->command;

    user_mcb_ptr->command = HKUVC_FLUSH_RENDERING_PIPE
			    | HKUVC_FLUSH_FULL_CONTEXT
			    | HKUVC_PAUSE_WITHOUT_INTERRUPT;
    *vcom_host_s = 1;       /* Tell Front End to do it */
    delay = FE_DELAY;

#ifdef DEBUG
    printf("*** FLUSH in stop_dl() ***\n");
    printf("user mcb: gt_stopped=0x%x status=0x%x, dpc=0x%x, errorcode=0x%x, command=0x%x\n", user_mcb_ptr->gt_stopped, status, dpc, error, user_mcb_ptr->command);
    printf("trap_instruction = 0x%x gt_flags=0x%x instruction_count=0x%x\n", user_mcb_ptr->trap_instruction, user_mcb_ptr->gt_flags, user_mcb_ptr->instruction_count);
#endif DEBUG

    while (*vcom_host_s && (delay-- >= 0)) usleep(10);    /* Wait for completion */
    if (delay < 0) {
	dump_status();
	fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_FE_TIMEOUT);
    }

    user_mcb_ptr->command = save_cmd;

    TRACE_OUT
}

/**********************************************************************/
clear_all()
/**********************************************************************/
{

    func_name = "clear_all";
    TRACE_IN

    /*
    int op;

    wid = wid_alloc(pr, FB_WID_DBL_24);
    pr_set_planes(pr, PIXPG_WID, PIX_ALL_PLANES);
    op = PIX_SRC | PIX_COLOR(wid);
    op = pr_clear(pr, op);
    */

    (void)fast_clear_all(wid);

    TRACE_OUT

}
/**********************************************************************/
fast_clear_all(wid_index)
/**********************************************************************/
int wid_index;
{
    func_name = "fast_clear_all";
    TRACE_IN

    (void)fast_clear(fastclear_set, HK_BUFFER_B, HK_BUFFER_B, BG_R, BG_G, BG_B, wid_index);
    (void)fast_clear(fastclear_set, HK_BUFFER_A, HK_BUFFER_A, BG_R, BG_G, BG_B, wid_index);

    TRACE_OUT
}

/**********************************************************************/
fast_clear(fcs, disp, clr, bg_r, bg_g, bg_b, wid_index)
/**********************************************************************/
int fcs;	/* Fast clear set */
int disp;	/* Display buffer */
int clr;	/* Clear buffer */
float bg_r, bg_g, bg_b; /* clear to bg color */
int wid_index;
{


    func_name = "fast_clear";
    TRACE_IN


    dl_ctx->dpc = (unsigned) clearscreen_dl;

    dl_ctx->window_bg_color.r = bg_r;
    dl_ctx->window_bg_color.g = bg_g;
    dl_ctx->window_bg_color.b = bg_b;
    dl_ctx->s.z_buffer_update = HK_Z_UPDATE_ALL;
    dl_ctx->fast_clear_set = *fcs_fcbg = *fcs_wlut = fcs;
    *wid_entry = wid_index;
    *imgbuf = *ovlbuf = disp;
    dl_ctx->draw_buffer = clr;

    *fcbg = ((int)(bg_b * 255.0) << 16) | ((int)(bg_g * 255.0) << 8) |
	    (int)(bg_r * 255.0);

    /* fast clear the screen */
    (void)start_dl(dl_ctx, 1);

    TRACE_OUT

}

/**********************************************************************/
close_hawk()
/**********************************************************************/

{

    func_name = "close_hawk";
    TRACE_IN

    if(hawk_opened) {
	stop_dl();
	if (hk_disconnect()) {
	    fb_send_message(SKIP_ERROR, WARNING, DLXERR_HK_DISCONNECT_FAILED);
	}
	if (hk_munmap(base_vm, vm_size)) {
	    fb_send_message(SKIP_ERROR, WARNING, DLXERR_HK_MUNMAP_FAILED);
	}
    }
    hk_close(1);
    hawk_opened = 0;

    TRACE_OUT

}

/**********************************************************************/
init_dl_ctx()
/**********************************************************************/
{

    func_name = "init_dl_ctx";
    TRACE_IN

/* Initialize the context area */
    (void)hk_init_default_context(dl_ctx);
/* Initialize the window boundaries */
    dl_ctx->ptr_window_boundary = window_boundary;

    TRACE_OUT

}
    
/*********************************************************************/
char *
chk_prb()
/*********************************************************************/
{
    int *rb;
    int miss_line;
    int miss_tri;
    int miss_outside;

    func_name = "chk_prb";
    TRACE_IN

    rb = (int *)vm;
    rb++;
    rb++;

    miss_line = 50 - *rb;
    rb++;
    miss_tri = 50 - *rb;
    rb++;
    miss_outside = *rb;

    if (miss_line || miss_tri || miss_outside) {
	sprintf(errtxt, DLXERR_PICK_MISSES, miss_line, miss_tri, miss_outside);
	TRACE_OUT
	return errtxt;
    }

    TRACE_OUT
    return (char *) 0;

}

/*********************************************************************/
set_fb_stereo()
/*********************************************************************/
{
    int fd;
    int mode;

    func_name = "set_fb_stereo";
    TRACE_IN

    fd = open(device_name, O_RDWR);
    if (fd < 0) {
        dump_status();
        (void)fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_OPEN);
    }

    /* save the original fb mode */
    if (ioctl(fd, FB_GETMONITOR, &fbmode) < 0) {
        dump_status();
        (void)fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_FB_GETMONITOR, sys_errlist[errno]);
    }

    /* Have to set this first in order to be able to set fb mode */
    if (ioctl(fd, FB_SETDIAGMODE) < 0) {
        dump_status();
        (void)fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_FB_SETDIAGMODE, sys_errlist[errno]);
    }

    /* set fb to stereo mode */
    mode = GT_MONITOR_TYPE_STEREO;
    if (ioctl(fd, FB_SETMONITOR, &mode) < 0) {
        dump_status();
        (void)fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_FB_SETMONITOR, mode, sys_errlist[errno]);
    }

    dev_fd = fd;

    TRACE_OUT
}

/*********************************************************************/
save_fb_regs()
/*********************************************************************/
{
    char *errmsg;
    unsigned int *reg;

    func_name = "save_fb_regs";
    TRACE_IN

    xtract_hdl(SAVE_FB_MODE);
    errmsg = exec_dl(getfname(SAVE_FB_MODE, HDL_CHK));
    if (errmsg) {
	(void)fb_send_message(SKIP_ERROR, WARNING, errmsg);
    }

    /* save the FB regs */
    reg = vm;
    reg++;
    reg++;
    bcopy(reg, fb_regs, sizeof(fb_regs));

    /* turn the flag on */
    fb_saved = 1;

    TRACE_OUT
}

/*********************************************************************/
restore_fb()
/*********************************************************************/
{
    char *errmsg;
    int fd;
    unsigned int *reg;

    func_name = "restore_fb";
    TRACE_IN

    if (!fb_saved) {
	TRACE_OUT
	return;
    }


    if (dev_fd < 0) {
	fd = open(device_name, O_RDWR);
	if (fd < 0) {
	    dump_status();
	    (void)fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_OPEN);
	}
	/* Have to set this first in order to be able to set fb mode */
	if (ioctl(fd, FB_SETDIAGMODE) < 0) {
	    dump_status();
	    (void)fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_FB_SETDIAGMODE, sys_errlist[errno]);
	}
    } else {
	fd = dev_fd;
    }

    if (ioctl(fd, FB_SETMONITOR, &fbmode) < 0) {
        dump_status();
        (void)fb_send_message(HAWK_FATAL_ERROR, FATAL, DLXERR_FB_SETMONITOR, fbmode, sys_errlist[errno]);
    }
    (void)close(fd);
    dev_fd = -1;

    (void)stop_dl();

    /* load the hdl file (DIAG_ESCAPE), but don't start it (-1) */
    xtract_hdl(RESTORE_FB_MODE);
    errmsg = exec_dl_op(getfname(RESTORE_FB_MODE, HDL_CHK), -1);
    if (errmsg) {
	(void)fb_send_message(SKIP_ERROR, WARNING, errmsg);
    }

    /* copy register values to VM */
    reg = vm;
    reg++;
    reg++;
    bcopy(fb_regs, reg, sizeof(fb_regs));

    /* start restoring the FB registers */
    (void)start_dl(dl_ctx, 1);

    finished = 0;
    if (error) {
	sprintf(errtxt, DLXERR_HDL_EXEC, error, (error < 0) ? diag_escape_error_string(error) : hk_error_string(error));
	TRACE_OUT
	(void)fb_send_message(SKIP_ERROR, WARNING, errtxt);
	return;
    }

    fb_saved = 0;
    TRACE_OUT
}

/*********************************************************************/
char *
diag_escape_error_string(err)
/*********************************************************************/
int err;

{
    static char *diag_esc_errlist[] = {
					"",
					MEMORY_ERROR,
					MEMORY_ERROR,
					HARDWARE_TIMEOUT,
					CHECKSUMS_DONT_MATCH,
					(char *)0,
				      };
    int list_size;

    /* strip minus sign */
    err = -err;

    /* count the messages in the list */
    for (list_size = 0 ; diag_esc_errlist[list_size] ; list_size++);

    if (err > list_size) {
	return UNKNOWN_ERROR;
    }

    return diag_esc_errlist[err];
}

/*********************************************************************/
ctx_set(va_alist)
/*********************************************************************/
va_dcl

{
    Ctx_attr attr;
    va_list	ap;

    func_name = "ctx_set";
    TRACE_IN

    va_start(ap);

    while (attr = va_arg(ap, Ctx_attr)) {
	switch ((Ctx_attr)attr) {

	    case	CTX_ATTR_END:
	    break;

	    default:
		va_end(pa);
		fb_send_message(SKIP_ERROR, ERROR, DLXERR_UNKNOWN_CTX_ATTRIBUTE);
		return -1;
	}
    }
    va_end(pa);
    TRACE_OUT
    return 0;
}