sg.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

	spl4(); 			/* allow interval timer in */

	sgaddr = (struct adder *) sgmap.adder;
	sgfcc = (struct fcc *) sgmap.fcc;

	if (sgaddr->status & ADDRESS_COMPLETE) {
	    if (sgflags.adder_ie & ADDRESS_COMPLETE) {
	    	sgfcc->cbcsr |= FLUSH;
	    	if (sgfcc->fwused > 0)
	    	    sgfcc->get += sgfcc->fwused;
	    	sgflags.adder_ie &= ~ADDRESS_COMPLETE;
		*(unsigned long *)&sgaddr->interrupt_enable = 
   			(unsigned long)((sgaddr->status << 16) | sgflags.adder_ie);
	    	while (!(sgfcc->cbcsr & IDLE));
	    	if (sgfcc->fwused > 0)
	    	    sgfcc->get += sgfcc->fwused;
		if (sgflags.user_fifo) {
		    sgflags.user_fifo = 0;
		    wakeup((caddr_t)&sgflags.user_fifo);
		} else
			*sg_int_flag = -1;
	    	sgfcc->cbcsr &= 0xE0FF;
	    }
	}
	if (sgaddr->status & VSYNC) {

/*
 * service the vertical blank interrupt (VSYNC bit) by loading any pending
 * color map load request
 */

	    *(unsigned long *)&sgaddr->interrupt_enable = 
   		(unsigned long)(((sgaddr->status &~VSYNC) << 16) | sgflags.adder_ie);

	    cbuf = color_buf;
	    if (cbuf->status & LOAD_COLOR_MAP) {
		sgvdac = (struct vdac *) sgmap.vdac;

		for (i = cbuf->count, rgbp = cbuf->rgb; --i >= 0; rgbp++) {

		    if (sg_num_planes != 8) {
		    	status = rgbp->green << 8;
		    	status |= (rgbp->blue << 4);
		    	status |= rgbp->red;
		    	sgvdac->a_color_map[rgbp->offset] = status;
		    }
		    else {
			eight_planes = (short *) sgmap.vdac;
			*eight_planes++ = rgbp->offset;
			*eight_planes = rgbp->red;
			*eight_planes = rgbp->green;
			*eight_planes = rgbp->blue;
		    }
		}

		cbuf->status &= ~LOAD_COLOR_MAP;
	    }
	}

/*
 * service the scroll interrupt (FRAME_SYNC bit)
 */

	if (sgaddr->status & FRAME_SYNC) {
	    *(unsigned long *)&sgaddr->interrupt_enable = 
   		(unsigned long)(((sgaddr->status &~FRAME_SYNC) << 16) | sgflags.adder_ie);

	    if (scroll->status & LOAD_REGS) {

		for ( i = 1000, sgaddr->status = 0
		    ; i > 0  &&  !((status = sgaddr->status)
			 & ID_SCROLL_READY)

		    ; --i);

		if (i == 0) {
		    mprintf("\nsg: sgaint: timeout on ID_SCROLL_READY");
		    return;
		}

		sgaddr->ID_scroll_data = scroll->viper_constant;
		sgaddr->ID_scroll_command = ID_LOAD | SCROLL_CONSTANT;

		sgaddr->y_scroll_constant = scroll->y_scroll_constant;
		sgaddr->y_offset_pending = scroll->y_offset;

		if (scroll->status & LOAD_INDEX) {

		    sgaddr->x_index_pending = scroll->x_index_pending;
		    sgaddr->y_index_pending = scroll->y_index_pending;
		}

	    scroll->status = 0x00;
	    }
	}
}





/******************************************************************
 **                                                              **
 ** FCC (FIFO) interrupt routine.                                **
 **                                                              **
 ******************************************************************/

sgfint(sg)
	int sg;
{
	register struct fcc *sgfcc;
	register struct adder *sgaddr;
	register struct FIFOreq_header *header;
	register struct FIFOreq *request;
	int	unit;
	u_short	temp;
	u_short	xfer_type;
	u_short	section_num;
	int	nbytes_rem;

	spl4();
	unit = sg<<2;

	header = FIFOheader;
	sgfcc = (struct fcc *) sgmap.fcc;
	sgaddr = (struct adder *) sgmap.adder;
	nbytes_rem = sgfcc->fwused;
	section_num = sgfcc->cbcsr & 0x3;
	if (*change_section == 1) {
		temp = section_num * 0x4000;
		*(unsigned long *)&sgfcc->put =
		   	(unsigned long)(( temp << 16) | temp);
		sgfcc->icsr = 0;
		*change_section = 0;
		sgfcc->put = *sg_next_fifo;
		return;
	}
	xfer_type = sgfcc->cbcsr & 0x1f00;
	if (xfer_type == DL_ENB) {
	    if (nbytes_rem > 0) {
		if (sgfcc->fwused < sgfcc->thresh)
		    sgfcc->thresh = sgfcc->fwused;
	    	sgfcc->icsr &= ~ITHRESH;
		*sg_int_flag = 0;
		return;
	    } else {
	    	sgfcc->icsr &= ~ENTHRSH;
	    	sgfcc->icsr &= ~ITHRESH;
 	    	*sg_int_flag = -1;
	    }
	} else {
		if ((xfer_type == PTB_ENB) || (xfer_type == PTB_UNPACK_ENB)) {
		    if (nbytes_rem > 0) {
			if (sgfcc->fwused < sgfcc->thresh)
		    	    sgfcc->thresh = sgfcc->fwused;
			sgfcc->icsr &= ~ITHRESH;
			sgfcc->icsr |= ENIDLE;
			sgfcc->cbcsr |= FLUSH;
		 	*sg_int_flag = 0;
			return;
		    } else {
			*sg_int_flag = -1;
		    }
		} else if (xfer_type == BTP_ENB) {
loop:
				sgfcc->get += sgfcc->fwused;
				if (sgfcc->fwused > sgfcc->thresh) goto loop;
		    		sgflags.adder_ie |= ADDRESS_COMPLETE;
				*(unsigned long *)&sgaddr->interrupt_enable = 
   			            (unsigned long)((sgaddr->status << 16) | sgflags.adder_ie);
				*sg_int_flag = 0;
			} else {
				    mprintf("\nsg: sgfint: illegal FIFOtype\n");
				    return;
				}
	}

}





/******************************************************************
 **                                                              **
 ** Graphic device input interrupt Routine.                      **
 **                                                              **
 ******************************************************************/

sgiint(ch)
register int ch;
{
	register struct _vs_event *vep;
	register struct sginput *eqh;
	register struct color_cursor *sgcursor;
	struct mouse_report *new_rep;
	struct tty *tp;
	register int unit;
	register u_short c;
	register int i, j;
	u_short data;
	char	wakeup_flag = 0;	/* flag to do a select wakeup call */
	int	cnt;
/*
 * Mouse state info
 */
	static char temp, old_switch, new_switch;

	eqh = eq_header;
	unit = (ch>>8)&03;
	new_rep = &current_rep;
	tp = &ss_tty[unit];

/*
 * If graphic device is turned on
 */

   if (sg_mouseon == 1) {
  
	cnt = 0;
	while (cnt++ == 0) {

/*
 * Pick up LK-201 input (if any)
 */

	    if (unit == 0) {

/* event queue full ? */

		if (ISFULL(eqh) == TRUE) {
/*		    mprintf("\nsg0: sgiint: event queue overflow");*/
		    return(0);
		}
/*
 * Get a character.
 */

		data = ch & 0xff;

/*
 * Check for various keyboard errors
 */

		if( data == LK_POWER_ERROR || data == LK_KDOWN_ERROR ||
	    	    data == LK_INPUT_ERROR || data == LK_OUTPUT_ERROR) {
			mprintf("\nsg0: sgiint: keyboard error, code = %x",data);
			return(0);
		}

		if (data < LK_LOWEST) 
		    	return(0);
		++wakeup_flag;		/* request a select wakeup call */

		vep = PUTBEGIN(eqh);
		PUTEND(eqh);
/*
 * Check for special case in which "Hold Screen" key is pressed. If so, treat is
 * as if ^s or ^q was typed.
 */
		if (data == HOLD) {
			vep->vse_direction = VSE_KBTRAW;
			vep->vse_type = VSE_BUTTON;
			vep->vse_device = VSE_DKB;
			vep->vse_x = eqh->curs_pos.x;
			vep->vse_y = eqh->curs_pos.y;
			vep->vse_time = TOY;
			vep->vse_key = CNTRL;    	/* send CTRL */
			vep = PUTBEGIN(eqh);
			PUTEND(eqh);
			vep->vse_direction = VSE_KBTRAW;
			vep->vse_type = VSE_BUTTON;
			vep->vse_device = VSE_DKB;
			vep->vse_x = eqh->curs_pos.x;
			vep->vse_y = eqh->curs_pos.y;
			vep->vse_time = TOY;
			if( sg_keyboard.hold  == 0) {
			    if((tp->t_state & TS_TTSTOP) == 0) {
		            	vep->vse_key = CHAR_S;  /* send character "s" */
			    	sg_key_out( LK_LED_ENABLE );
				sg_key_out(LED_4);
				sg_keyboard.hold = 1;
			    }
			    else {
		            	vep->vse_key = CHAR_Q;  /* send character "q" */
			    }
			}
			else {
		            vep->vse_key = CHAR_Q;     /* send character "q" */
			    sg_key_out( LK_LED_DISABLE );
			    sg_key_out( LED_4 );
			    sg_keyboard.hold = 0;
			}
			vep = PUTBEGIN(eqh);
			PUTEND(eqh);
			vep->vse_direction = VSE_KBTRAW;
			vep->vse_type = VSE_BUTTON;
			vep->vse_device = VSE_DKB;
			vep->vse_x = eqh->curs_pos.x;
			vep->vse_y = eqh->curs_pos.y;
			vep->vse_time = TOY;
			vep->vse_key = ALLUP;
		}
		else {
			if (sg_keyboard.cntrl == 1) {
			    switch (data) {
			    case CHAR_S:
					break;
			    case CHAR_Q:
			    		sg_key_out( LK_LED_DISABLE );
			    		sg_key_out( LED_4 );
			    		sg_keyboard.hold = 0;
					break;
			    default:
					sg_keyboard.cntrl = 0;
			    }
			}
			vep->vse_direction = VSE_KBTRAW;
			vep->vse_type = VSE_BUTTON;
			vep->vse_device = VSE_DKB;
			vep->vse_x = eqh->curs_pos.x;
			vep->vse_y = eqh->curs_pos.y;
			vep->vse_time = TOY;
			vep->vse_key = data;
			if (data == CNTRL)
			    sg_keyboard.cntrl = 1;
		}
	    }

/*
 * Pick up the mouse input (if any)
 */

	    if ((unit == 1) && (sm_pointer_id == MOUSE_ID)) {

/* event queue full ? */

		if (ISFULL(eqh) == TRUE) {
/*		    mprintf("\nsg0: sgiint: event queue overflow");*/
		    return(0);
		}

/*
 * see if mouse position has changed
 */
		if( new_rep->dx != 0 || new_rep->dy != 0) {

/*
 * Check to see if we have to accelerate the mouse
 *
 */
		    if (sgflags.curs_acc > ACC_OFF) {
			if (new_rep->dx >= sgflags.curs_thr)
			    new_rep->dx +=
				(new_rep->dx - sgflags.curs_thr) * sgflags.curs_acc;
			if (new_rep->dy >= sgflags.curs_thr)
			    new_rep->dy +=
				(new_rep->dy - sgflags.curs_thr) * sgflags.curs_acc;
		    }

/*
 * update mouse position
 */
		    if( new_rep->state & X_SIGN) {
			eqh->curs_pos.x += new_rep->dx;
			if( eqh->curs_pos.x > MAX_CUR_X )
			    eqh->curs_pos.x = MAX_CUR_X;
		    }
		    else {
			eqh->curs_pos.x -= new_rep->dx;
			if( eqh->curs_pos.x < -15 )
			    eqh->curs_pos.x = -15;
		    }
		    if( new_rep->state & Y_SIGN) {
			eqh->curs_pos.y -= new_rep->dy;
			if( eqh->curs_pos.y < -15 )
			    eqh->curs_pos.y = -15;
		    }
		    else {
			eqh->curs_pos.y += new_rep->dy;
			if( eqh->curs_pos.y > MAX_CUR_Y )
			    eqh->curs_pos.y = MAX_CUR_Y;
		    }
		    if( tp->t_state & TS_ISOPEN ) {
			sgcursor = (struct color_cursor *) sgmap.cur;
			sgcursor->xpos = CURS_MIN_X + eqh->curs_pos.x;
			sgcursor->ypos = CURS_MIN_Y + eqh->curs_pos.y;
		    }
		    if (eqh->curs_pos.y <= eqh->curs_box.bottom &&
			eqh->curs_pos.y >=  eqh->curs_box.top &&
			eqh->curs_pos.x <= eqh->curs_box.right &&
			eqh->curs_pos.x >=  eqh->curs_box.left) goto mbuttons;
		    vep = PUTBEGIN(eqh);
		    PUTEND(eqh);
		    ++wakeup_flag;	/* request a select wakeup call */

/*
 * Put event into queue and do select
 */

		    vep->vse_x = eqh->curs_pos.x;
		    vep->vse_y = eqh->curs_pos.y;
		    vep->vse_device = VSE_MOUSE;	/* mouse */
		    vep->vse_type = VSE_MMOTION;	/* position changed */
		    vep->vse_time = TOY;		/* time stamp */
		    vep->vse_direction = 0;
		    vep->vse_key = 0;
		}

/*
 * See if mouse buttons have changed.
 */

mbuttons:

		new_switch = new_rep->state & 0x07;
		old_switch = last_rep.state & 0x07;

		temp = old_switch ^ new_switch;
		if( temp ) {
		    for (j = 1; j < 8; j <<= 1) {/* check each button */
			if (!(j & temp))  /* did this button change? */
			    continue;
/* event queue full? */

			if (ISFULL(eqh) == TRUE) {
/*		    	    mprintf("\nsg0: sgiint: event queue overflow");*/
		    	    return(0);
			}

			vep = PUTBEGIN(eqh);	/* get new event */
			PUTEND(eqh);

			++wakeup_flag;      /* request a select wakeup call */

/* put event into queue */

			switch (j) {
			case RIGHT_BUTTON:
					vep->vse_key = VSE_RIGHT_BUTTON;
					break;

			case MIDDLE_BUTTON:
					vep->vse_key = VSE_MIDDLE_BUTTON;
					break;

			case LEFT_BUTTON:
					vep->vse_key = VSE_LEFT_BUTTON;
					break;

			}
			if (new_switch & j)
				vep->vse_direction = VSE_KBTDOWN;
			else
				vep->vse_direction = VSE_KBTUP;
			vep->vse_type = VSE_BUTTON;
			vep->vse_device = VSE_MOUSE;	/* mouse */
			vep->vse_time = TOY;
		    	vep->vse_x = eqh->curs_pos.x;
		    	vep->vse_y = eqh->curs_pos.y;
		    }

/* update the last report */

		    last_rep = current_rep;
		}
	    } /* Pick up mouse input */

	    else if ((unit == 1) && (sm_pointer_id == TABLET_ID)) {

/* event queue full? */

		    if (ISFULL(eqh) == TRUE) {
/*		    	mprintf("\nsg0: sgiint: event queue overflow");*/
		    	return(0);
		    }


/* update cursor position coordinates */

		    new_rep->dx /= sgflags.tab_res;
		    new_rep->dy = (2200 - new_rep->dy) / sgflags.tab_res;
		    if( new_rep->dx > MAX_CUR_X )
			new_rep->dx = MAX_CUR_X;
		    if( new_rep->dy > MAX_CUR_Y )
			new_rep->dy = MAX_CUR_Y;

/*
 * see if the puck/stylus has moved