gx.c

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

     */
    return ((*linesw[tp->t_line].l_open)(dev, tp));
}
/* gxopen */


/******************************************************************
 **                                                              **
 ** Routine to close the graphic device.                         **
 **                                                              **
 ******************************************************************/

/*ARGSUSED*/
gxclose(dev, flag)
    dev_t dev;
    int flag;
{
    register struct tty *tp;
    register int unit = minor(dev);

    unit = minor(dev);

    /*
     * If unit is not the mouse call the line disc. 
     * otherwise clear the state
     * flag, and put the keyboard into down/up.
     */
    if( unit == 0 ) {
	tp = &cdevsw[0].d_ttys[0];
	(*linesw[tp->t_line].l_close)(tp);
	ttyclose(tp);
	gx_dev_inuse &= ~CONS_DEV;
	gx_keyboard.cntrl = gx_keyboard.shift = 0;
	tp->t_state = 0;
	
	/* Remove termio flags that do not map */
	tp->t_iflag &= ~TERMIO_ONLY_IFLAG;
	tp->t_oflag &= ~TERMIO_ONLY_OFLAG;
	tp->t_cflag &= ~TERMIO_ONLY_CFLAG;
	tp->t_lflag &= ~TERMIO_ONLY_LFLAG;
    } else {
#	ifdef GX_MULTIOPEN
	register int i;
	/* garbage collect all entries now... */
	for (i = 1; i < GX_MAX_INFOS; i++) {
	    if (gx_infos[i].pid == -1)
		continue;
	    if (   gx_infos[i].pid == u.u_procp->p_pid
		|| gx_info_gone(gx_infos[i].pid))
	    {
		GX_DEBUG(GX_GAB,
			 gx_printf("gxclose: slave pid %d\n", gx_infos[i].pid);
			 );
		gx_infos[i].pid = -1;
		gx_infos[i].shmat = 0;
	    }
	}
#	endif gx_multiopen
	if (gx_openflag != 1) {
	    GX_DEBUG(GX_GAB,
		     gx_puts("gxclose: no server\n");
		     );
	    GX_CALL(_gx_close)(dev, flag);
	    return(EBUSY);
	}
	GX_DEBUG(GX_GAB,
		 gx_printf("gxclose: server %d\n", gx_server.pid);
		 );
	gx_openflag = 0;	     /* mark the graphics device available */
	gx_mouseon = 0;
	GX_CALL(_gx_close)(dev, flag);
	gx_serverp = 0;
	gx_server.pid = -1;
	gx_server.shmat = 0;
	gx_dev_inuse &= ~GRAPHIC_DEV;
	gx_init();
	/*
	 * Prevent past text from getting clobbered
	 */
	gx_scroll(0);
    }
    return(0);			     /* fhsu */
}
/* gxclose */


/******************************************************************
 **                                                              **
 ** Mouse activity select routine.                               **
 **                                                              **
 ******************************************************************/

gxselect(dev, rw)
    dev_t dev;
{
    register int unit = minor(dev);
    register int s;

    IPLTTY(s);

    if( unit == 1 )
    {
#	ifdef GX_MULTIOPEN
	/* should never happen when GX_MAX_INFOS==1 */
	if (!GX_IAMSERVER)
	    return(EACCES);
#	endif gx_multiopen
	switch(rw)
	{
	 case FREAD:		/* if events okay */
	    if (gxp->qe.eHead != gxp->qe.eTail) {
		splx(s);
		return(1);
	    }
	    gx_rsel = u.u_procp;
	    splx(s);
	    return(0);

	 case FWRITE:		/* can never write */
	    splx(s);
	    return(EACCES);
	}
    } else {
	splx(s);
	return( ttselect(dev, rw) );
    }
}
/* gxselect */

gx_ack_mode_change()
{
    if (gx_mode_change) {
	gx_mode_change = 0;
	wakeup(&gx_mode_change);
    }
}

/******************************************************************
 **                                                              **
 ** Graphic device ioctl routine.                                **
 **                                                              **
 ******************************************************************/

/*ARGSUSED*/
gxioctl(dev, cmd, data, flag)
    dev_t dev;
    register caddr_t data;
{
    register struct tty *tp;
    register int unit = minor(dev);
    register gxKPCmd *qk;
    register unsigned char *cp;
    register int s, i;
    int error;
    struct devget *devget;

#   ifdef GX_MULTIOPEN
    /* nb: this may be removed when !defined(GX_MULTIOPEN) since only 1 process
     * may open the graphics device then.
     */
    if (!GX_IAMSERVER) {
	switch (cmd)
	{
	 case QIOCGXSTATE:
	 case QIOCKPCMD:
	 case QIOKERNLOOP:
	 case QIOKERNUNLOOP:
	 case QIO_WCCOLOR:
	 case QIO_WCURSOR:
	 case QIO_SETCMAP:
	    printf("Illegal operation on graphics device:\n");
	    printf("    pid %d not server pid %d\n",
		    u.u_procp->p_pid, (gx_serverp ? gx_serverp->p_pid : -1));
	    return(-1);
	 default:
	    break;
	}
    }
#   endif gx_multiopen
    
    switch( cmd ) 
    {
     case QIOCGINFO:		     /* return screen info */
	i = gx_info_get(0);
	if (i < 0 || gx_infos[i].pid != u.u_procp->p_pid)
	    panic("gxioctl - QIOCGINFO");

	if (gx_infos[i].shmat) {
	    *(gxInfo **)data = gx_infos[i].shmat;
	    break;
	}

	if ((i = (*_gx_ioctl)(makedev(0,i), cmd, data, flag)) > 0)
	{
	    printf ("Could not map shared data structure: %s\nu_error = %d\n",
		     gx_err_msg[i], u.u_error);
	    *(gxInfo **)data = 0;
	    return (-1);
	}
	break;

     case QIOCGXSTATE:		     /* set mouse position */
	gxp->mouse = *((pmCursor *)data);
	gx_pos_cur( (int)(gxp->mouse).x, (int)(gxp->mouse).y );
	break;

     case QIOCINIT:		     /* init screen	*/
	if (GX_IAMSERVER)
	    gx_init();		     /* nb: this halts the N10!!! */
	else
	    gx_init_stic();	     /* non-destructive */
	break;

     case QIOCKPCMD:
	qk = (gxKPCmd *)data;
	if (qk->nbytes == 0) qk->cmd |= 0200;
	if (gx_mouseon == 0) qk->cmd |= 1; /* no mode changes */
	IPLTTY(s);
	(*slu.kbd_putc)(qk->cmd);
#	ifdef notdef
	cprintf ("qk->cmd= %x\n", qk->cmd);
#	endif
	cp = &qk->par[0];
	while (qk->nbytes-- > 0) 
	{			     /* terminate parameters */
	    if (qk->nbytes <= 0) *cp |= 0200;
#	    ifdef notdef
	    cprintf ("nbyte [%d]= %x\n", qk->nbytes, *cp);
#	    endif
	    (*slu.kbd_putc)(*cp++);
	}
	/* low bit clear if a mode change command */
	if ((qk->cmd & 0x1) == 0) {
	    gx_mode_change = 1;
	    /* set timer in case ack never comes in */
	    timeout(gx_ack_mode_change, (caddr_t)0, hz);
	    sleep(&gx_mode_change, TTIPRI);
	}
	splx(s);
	break;

     case QIOCADDR:		     /* get struct addr */
	i = gx_info_get(0);
	if (i < 0 || gx_infos[i].pid != u.u_procp->p_pid)
	    panic("gxioctl: gx_info_get(QIOCADDR)");
	*(gxInfo **) data = (gxInfo *)svtophy(&gx_infos[i].info);
	break;

     case QIO_WCURSOR:
	return gx_load_cursor();

     case QIO_WCCOLOR:
	gx_load_ccolor();
	break;
	     
     case QIO_SETCMAP:
	if (gxp->cmap_index > 255 ||
	    gxp->cmap_count > 256 ||
	    gxp->cmap_index + gxp->cmap_count > 256)
	{
	    u.u_error = EINVAL;
	    return (-1);
	}
	IPLTTY(s);
        gxp->flags |= GX_F_NEW_CMAP;
	splx(s);
	/* load with reckless abandon ... */
	gx_load_colormap();
	break;

     case QIOKERNLOOP:			/* redirect kernel console output */
	xcons_kern_loop = -1;
	break;

     case QIOKERNUNLOOP:		/* dont redirect kernel cons output */
	xcons_kern_loop = 0;
	break;

     case QIOVIDEOON:			/* display on	*/
	gx_video_on();
	break;

     case QIOVIDEOOFF:			/* display off	*/
	gx_video_off();
	break;

     case DEVIOCGET:			/* device status */
	devget = (struct devget *)data;
	bzero(devget,sizeof(struct devget));
	devget->category = DEV_TERMINAL; /* terminal cat.*/
	devget->bus = DEV_NB;		/* NO bus	*/
	bcopy(DEV_VS_SLU,devget->interface,
	      strlen(DEV_VS_SLU));	/* interface	*/
	if((unit == 0) || (unit == 1))
	{
	    bcopy(gx_devtype(), devget->device, 6); /* Ultrix "gq"*/
	}
	if(pointer_id == MOUSE_ID)
	{
	    bcopy(gx_devtype(), devget->device, 6); /* Ultrix "gq"*/
	}
	else if(pointer_id == TABLET_ID)
	    bcopy(DEV_TABLET, devget->device, strlen(DEV_TABLET));
	else
	    bcopy(DEV_UNKNOWN, devget->device, strlen(DEV_UNKNOWN));
	devget->adpt_num = 0;		/* NO adapter	*/
	devget->nexus_num = 0;		/* fake nexus 0	*/
	devget->bus_num = 0;		/* NO bus	*/
	devget->ctlr_num = 0;		/* cntlr number */
	devget->slave_num = unit;	/* line number 	*/
        bcopy(gx_devtype(), devget->dev_name, 6); /* Ultrix "gq" */
	devget->unit_num = unit;	/* dc line?	*/
	/* TODO: should say not supported instead of zero!	*/
	devget->soft_count = 0;		/* soft err cnt */
	devget->hard_count = 0;		/* hard err cnt */
	devget->stat = 0;		/* status	*/
	devget->category_stat = 0;	/* cat. stat.	*/
	break;

      default:
	i = (*_gx_ioctl)(dev, cmd, data, flag);
	/* expected result: a-ok */
	if (i == 0)
	    break;
	/* error encountered - print message and return error */
	if (i > 0)
	{
	    printf("gxioctl: %s\nu_error = %d", gx_err_msg[i], u.u_error);
	    return (-1);
	}
	/* unsupported or ignored - not ours??? */
	tp = &slu.slu_tty[unit];
	error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag);
	if (error >= 0)
	    return (error);
	error = ttioctl(tp, cmd, data, flag);
	if (error >= 0) 
	    return (error);
	break;
    }
    return (0);
}
/* gxioctl */


/******************************************************************
 **                                                              **
 ** Graphice device interrupt routine.                           **
 **                                                              **
 ******************************************************************/

#define CHAR_S	0xc7
#define CHAR_Q	0xc1

gxkint(ch)           /* XXX this has to run at spltty or lower!!! */
    register int ch;
{
    register pmEvent *qep;
    struct mouse_report *new_rep;
    struct tty *tp;
    register int unit;
    register u_short c;
    register int i, j;
    u_short data;
    int	cnt;
    static char temp, old_switch, new_switch;

    /*
     * Mouse state info
     */
    unit = (ch>>8)&03;
    new_rep = &current_rep;
    tp = &slu.slu_tty[unit];

    /*
     * If graphic device is turned on
     */

    if (gx_mouseon == 1) 
    {
  	cnt = 0;
	while (cnt++ == 0) 
	{
	    /*
	     * Pick up LK-201 input (if any)
	     */
	    if (unit == 0) 
	    {
		data = ch & 0xff;

		if (data == LK_MODE_CHG_ACK) {
		    untimeout(gx_ack_mode_change, (caddr_t)0);
		    gx_ack_mode_change();
		}

		if(data == LK_POWER_ERROR || data == LK_KDOWN_ERROR ||
		   data == LK_INPUT_ERROR || data == LK_OUTPUT_ERROR) 
		{
		    if(!gx_inkbdreset) { /* Ignore errors from reset */
		        mprintf("\ngx0: gxkint: keyboard error,code=%x",data);
		        gx_kbdreset();
		    }
		    return(0);
		}

		if (data < LK_LOWEST) 
		    return(0);

		/* why can't we write this event??? */
		if ((i = EVROUND(gxp->qe.eTail+1)) == gxp->qe.eHead) 
		    return(0);

		/* for any key */
		qep = &gx_events[gxp->qe.eTail];

		qep->type = BUTTON_RAW_TYPE;
		qep->device = KEYBOARD_DEVICE;
		qep->x = gxp->mouse.x;
		qep->y = gxp->mouse.y;
		qep->time = TOY;
		qep->key = data;
		gxp->qe.eTail = i;

		GX_DEBUG(GX_YOW,
			 gx_putevent(qep);
			 );

		if((i=EVROUND(gxp->qe.eTail+1)) == gxp->qe.eHead) 
		    return(0);
		qep = &gx_events[gxp->qe.eTail];

		switch (data)
		{
		 case CNTRL:
		    gx_keyboard.cntrl ^= 0xffff;
		    break;
		 case ALLUP:
		    gx_keyboard.cntrl = gx_keyboard.shift = 0;
		    break;
		 case SHIFT:
		    gx_keyboard.shift ^= 0xffff;
		    break;
		 default:
		    ;
		}
	    }

	    /*
	     * Pick up the mouse input (if any)
	     */
	    if ((unit == 1) && (pointer_id == MOUSE_ID)) 
	    {
	    	/*
		 * see if mouse position has changed
		 */
		if( new_rep->dx != 0 || new_rep->dy != 0) 
		{
		    unsigned int millis = TOY;

		    /*
		     * Check to see if we have to accelerate the mouse
		     *
		     */
		    if (gxp->mscale >=0) 
		    {
			if (new_rep->dx >= gxp->mthreshold)
			    new_rep->dx +=
				(new_rep->dx - gxp->mthreshold)*gxp->mscale;
			if (new_rep->dy >= gxp->mthreshold)
			    new_rep->dy +=
				(new_rep->dy - gxp->mthreshold)*gxp->mscale;
		    }

		    /*
		     * update mouse position
		     */
		    if( new_rep->state & X_SIGN) 
		    {
			gxp->mouse.x += new_rep->dx;
			if( gxp->mouse.x > gxp->max_cur_x )
			    gxp->mouse.x = gxp->max_cur_x;
		    }
		    else 
		    {
			gxp->mouse.x -= new_rep->dx;
			if( gxp->mouse.x < gxp->min_cur_x )
			    gxp->mouse.x = gxp->min_cur_x;
		    }
		    if( new_rep->state & Y_SIGN) 
		    {
			gxp->mouse.y -= new_rep->dy;
			if( gxp->mouse.y < gxp->min_cur_y )
			    gxp->mouse.y = gxp->min_cur_y;
		    }
		    else 
		    {
			gxp->mouse.y += new_rep->dy;
			if( gxp->mouse.y > gxp->max_cur_y )
			    gxp->mouse.y = gxp->max_cur_y;
		    }
		    if( tp->t_state & TS_ISOPEN )
			gx_pos_cur( gxp->mouse.x, gxp->mouse.y );
		    gx_tcs[gxp->qe.tcNext].time = millis;
		    gx_tcs[gxp->qe.tcNext].x = gxp->mouse.x;
		    gx_tcs[gxp->qe.tcNext].y = gxp->mouse.y;
		    if (++(gxp->qe.tcNext) >= MOTION_BUFFER_SIZE)
			gxp->qe.tcNext = 0;
		    if (gxp->mouse.y < gxp->mbox.bottom &&
			gxp->mouse.y >=  gxp->mbox.top &&
			gxp->mouse.x < gxp->mbox.right &&
			gxp->mouse.x >=  gxp->mbox.left) goto mbuttons;
		    gxp->mbox.bottom = 0; /* trash box */
		    if (EVROUND(gxp->qe.eTail+1) == gxp->qe.eHead)
			goto mbuttons;

		    i = EVROUND(gxp->qe.eTail -1);
		    if ((gxp->qe.eTail != gxp->qe.eHead) && (i != gxp->qe.eHead)) 
		    {