sg.c

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

			}
			rsel = u.u_procp;
			sgflags.selmask |= SEL_READ;
			splx(s);
			return(0);
		}
		else {
                    tp = &sm_tty;
                    if (ttnread(tp))
                        return(1);
                    tp->t_rsel = u.u_procp;
                    splx(s);
                    return(0);
                }

	    case FWRITE:		/* FIFO done? */

		if (unit == 1) {
                	if (DMA_ISEMPTY(FIFOheader)) {
                    	    splx(s);
                    	    return(1);          /* return "1" if FIFO is done */
			}
			rsel = u.u_procp;
			sgflags.selmask |= SEL_WRITE;
			splx(s);
			return(0);
		}
		else {
                    tp = &sm_tty;
                    if (tp->t_outq.c_cc <= TTLOWAT(tp))
                        return(1);
                    tp->t_wsel = u.u_procp;
                    splx(s);
                    return(0);
                }
	    }
}






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

/*ARGSUSED*/
sgioctl(dev, cmd, data, flag)
	dev_t dev;
	int cmd;
	register caddr_t data;
{
	register int *ptep;		/* page table entry pointer */
	register struct _vs_event *vep;
	register struct tty *tp;
	register struct color_cursor *pcc;
	register struct adder *sgaddr;
	register struct vdac *sgvdac;
        register short  *eight_planes;
	register struct nb_regs *nbaddr = (struct nb_regs *)nexus;

	struct sgmap *sg;		/* pointer to device map struct */
	struct adder *adder;		/* ADDER reg structure pointer */

	struct prgkbd *cmdbuf;
	struct prg_cursor *curs;
	struct _vs_cursor *pos;

	struct devget *devget;
	register int unit = minor(dev);

	int error;
	int s;

	int i;				/* SIGNED index */
	int sbr;			/* SBR variable (you silly boy) */
	u_int ix;

	short status;
	short *shortp;			/* generic pointer to a short */
	char *chrp;			/* generic character pointer */

	short *temp;			/* a pointer to template RAM */

/*
 * service the VAXstar color device ioctl commands
 */

	switch (cmd) {


	    case QD_MAPDEVICE:
		sg = (struct sgmap *) &sgmap;
		bcopy(sg, data, sizeof(struct sgmap));
		    break;

	    case QD_MAPCOLOR:

		sgflags.mapped |= MAPCOLOR;
		ptep = (int *) ((VTOP(color_buf) * 4)
				+ (mfpr(SBR) | 0x80000000));

		/* allow user write to color map write buffer */

		*ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
		*ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
		*ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;

		mtpr(TBIA, 0);			/* clr CPU translation buf */

		*(int *)data = (int) color_buf;
		break;


	    /*--------------------------------------------------------------
	    * unmap shared color map write buffer and kill VSYNC intrpts */

	    case QD_UNMAPCOLOR:

		if (sgflags.mapped & MAPCOLOR) {

		    sgflags.mapped &= ~MAPCOLOR;

		    ptep = (int *) ((VTOP(color_buf) * 4)
				    + (mfpr(SBR) | 0x80000000));

		    /* re-protect color map write buffer */

		    *ptep++ = (*ptep & ~PG_PROT) | PG_KW | PG_V;
		    *ptep++ = (*ptep & ~PG_PROT) | PG_KW | PG_V;
		    *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;

		    mtpr(TBIA, 0);	/* smash CPU's translation buf */
		}
		break;


	    case QD_MAPSCROLL:

		sgflags.mapped |= MAPSCR;
		ptep = (int *) ((VTOP(scroll) * 4)
				+ (mfpr(SBR) | 0x80000000));

		/* allow user write to scroll area */

		*ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;

		mtpr(TBIA, 0);			/* clr CPU translation buf */

		scroll->status = 0;

		sgaddr = (struct adder *) sgmap.adder;

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

		*(int *)data = (int) scroll;
		break;


	    /*-------------------------------------------------------------
	    * unmap shared scroll param area and disable scroll intrpts */

	    case QD_UNMAPSCROLL:

		if (sgflags.mapped & MAPSCR) {

		    sgflags.mapped &= ~MAPSCR;

		    ptep = (int *) ((VTOP(scroll) * 4)
				    + (mfpr(SBR) | 0x80000000));

		    /* re-protect 512 scroll param area */

		    *ptep = (*ptep & ~PG_PROT) | PG_KW | PG_V;

		    mtpr(TBIA, 0);	/* smash CPU's translation buf */

		    sgaddr = (struct adder *) sgmap.adder;
		    sgflags.adder_ie &= ~FRAME_SYNC;
		    *(unsigned long *)&sgaddr->interrupt_enable = 
   			(unsigned long)((sgaddr->status << 16) | sgflags.adder_ie);
		}
		break;



           /*---------------------------------------------
            * give user write access to the event queue */

            case QD_MAPEVENT:

		sgflags.mapped |= MAPEQ;
                ptep = (int *) ((VTOP(eq_header) * 4)
                                + (mfpr(SBR) | 0x80000000));

                /* allow user write to 1K event queue */

                *ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;
                *ptep = (*ptep & ~PG_PROT) | PG_UW | PG_V;

                mtpr(TBIA, 0);                  /* clr CPU translation buf */

                /* return event queue address */

                *(int *)data = (int) eq_header;
                break;


           /*-------------------------------------
            * do setup for FIFO by user process  */

            case QD_MAPIOBUF:

               /*------------------------------------------------
                * set 'user write enable' bits for FIFO buffer  */

                sgflags.mapped |= MAPFIFO;

                ptep = (int *) ((VTOP(FIFOheader) * 4)
                               + (mfpr(SBR) | 0x80000000));

                for (i = (FIFObuf_size >> PGSHIFT); i > 0; --i)
                    *ptep++ = (*ptep & ~PG_PROT) | PG_UW | PG_V;

                mtpr(TBIA, 0);                  /* clr CPU translation buf */

                /*----------------------
               * return I/O buf adr */

                *(int *)data = (int) FIFOheader;
                break;


	    case QD_RDCONFIG:   /* return number of planes */
		*(short *)data = sg_num_planes;
		break;

	    case QD_GETEVENT:	/* extract the oldest event from event queue */

		if (ISEMPTY(eq_header)) {
		    vep = (struct _vs_event *) data;
		    vep->vse_device = VSE_NULL;
		    break;
		}

		vep = (struct _vs_event *) GETBEGIN(eq_header);
		s = spl5();
		GETEND(eq_header);
		splx(s);
		bcopy(vep, data, sizeof(struct _vs_event));
		break;


	    case QD_RESET:    /* init the dragon, DUART, and driver variables */

		sg_init_shared();		/* init shared memory */
		sg_setup_dragon();	/* init the ADDER/VIPER stuff */
		sg_clr_screen();
		sg_load_cursor( def_cur);	/* load default cursor map */
		sg_ld_font();			/* load the console font */
		break;


	    case QD_SET:	/* init the DUART and driver variables */

		sg_init_shared();
		break;


	    case QD_CLRSCRN:	/* clear the screen. This reinits the dragon */

		sg_setup_dragon();
		sg_clr_screen();
		break;


	    case QD_WTCURSOR:	/* load a cursor into template RAM */

		sg_load_cursor(data);
		break;

/*	    case QD_RDCURSOR:

		break;
*/


	    case QD_POSCURSOR:		/* position the mouse cursor */

		pos = (struct _vs_cursor *) data;
		pcc = (struct color_cursor *) sgmap.cur;
		s = spl5();
	        pcc->xpos = CURS_MIN_X + pos->x;
	        pcc->ypos = CURS_MIN_Y + pos->y;
		eq_header->curs_pos.x = pos->x;
		eq_header->curs_pos.y = pos->y;
		splx(s);
		break;

	    /*--------------------------------------
	    * set the cursor acceleration factor */

	    case QD_PRGCURSOR:

		curs = (struct prg_cursor *) data;
		s = spl5();
		sgflags.curs_acc = curs->acc_factor;
		sgflags.curs_thr = curs->threshold;
		splx(s);
		break;


	    /*--------------------------------------
   	     * pass caller's programming commands to LK201 */

	    case QD_PRGKBD:

		cmdbuf = (struct prgkbd *)data;     /* pnt to kbd cmd buf */

		sg_key_out (cmdbuf->cmd);
		
/*
 * Send param1?
 */
		if (cmdbuf->cmd & LAST_PARAM)
		    break;
		sg_key_out (cmdbuf->param1);

/*
 * Send param2?
 */
		if (cmdbuf->param1 & LAST_PARAM)
		    break;
		sg_key_out (cmdbuf->param2);
		break;


	    /*--------------------------------------
   	     * pass caller's programming commands to mouse */

	    case QD_PRGMOUSE:

		break;



	    case QD_KERN_LOOP:		/* redirect kernel messages */
		sgflags.kernel_loop = -1;
		break;

	    case QD_KERN_UNLOOP:	/* don't redirect kernel messages */

		sgflags.kernel_loop = 0;
		break;


	    case QD_PRGTABRES:      /* program the tablet resolution factor*/

		sgflags.tab_res = *(short *)data;
		break;

	    case QD_VIDEOON:		/* turn on the video */
		sg_video_on();
		break;

	    case QD_VIDEOOFF:		/* turn off the video */
		if (sg_num_planes == 8) {
		    eight_planes = (short *)sgmap.vdac;
	    	    *eight_planes++ = 0;		  /* select color map 0 */
		    sg_red_save = *eight_planes & 0xFF;	  /* save value for red */
		    sg_green_save = *eight_planes & 0xFF; /* save value for green */
		    sg_blue_save = *eight_planes & 0xFF;  /* save value for blue */
		    eight_planes = (short *)sgmap.vdac;
	    	    *eight_planes = 6;			/* select control reg. */
	    	    eight_planes += 2;
	    	    *eight_planes = 0x40;		/* disable cursor video */
		    eight_planes = (short *)sgmap.vdac;
	    	    *eight_planes++ = 0;		/* select color map 0 */
		    *eight_planes = 0; 			/* set value for red */
		    *eight_planes = 0; 			/* set value for green */
		    *eight_planes = 0; 			/* set value for blue */
		    eight_planes = (short *)sgmap.vdac;
	    	    *eight_planes = 4;			/* select read mask reg. */
	    	    eight_planes += 2;
		    *eight_planes = 0; 			/* set it to zero */
		}
		else {
		    sgvdac = (struct vdac *)sgmap.vdac;
		    sg_vdac_reg &= ~0x0002;
		    sgvdac->mode = sg_vdac_reg;
		}
		sg_video_off = 1;
		break;

	    case QD_CURSORON:		/* turn on the cursor */
		sgvdac = (struct vdac *)sgmap.vdac;
		sg_vdac_reg |= 0x0001;
		sgvdac->mode = sg_vdac_reg;
		break;

	    case QD_CURSOROFF:		/* turn off the cursor */
		sgvdac = (struct vdac *)sgmap.vdac;
		sg_vdac_reg &= 0xfffe;
		sgvdac->mode = sg_vdac_reg;
		break;

	    case DEVIOCGET:			    /* device status */
		    devget = (struct devget *)data;
		    bzero(devget,sizeof(struct devget));
		    devget->category = DEV_TERMINAL;
		    devget->bus = DEV_NB;
		    bcopy(DEV_VS_SLU,devget->interface,
			  strlen(DEV_VS_SLU));
		    if(unit == 0)
		    	bcopy(DEV_VR290,devget->device,
			  strlen(DEV_VR290));		    /* terminal */
		    else if(sm_pointer_id == MOUSE_ID)
		    	bcopy(DEV_MOUSE,devget->device,
			  strlen(DEV_MOUSE));
		    else if(sm_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;		    /* which line   */
		    bcopy("sg", devget->dev_name, 3);	    /* Ultrix "sg" */
		    devget->unit_num = unit;		    /* sg line?     */
		    devget->soft_count = 0;		    /* soft er. cnt.*/
		    devget->hard_count = 0;		    /* hard er cnt. */
		    devget->stat = 0;           	    /* status	    */
		    devget->category_stat = 0;		    /* cat. stat.   */
		    break;

	    default:

		if ((unit == 2) && (major(dev) == CONSOLEMAJOR))
		    tp = &sm_tty;
		else
		    tp = &ss_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);
		/* if error = -1 then ioctl does not exist */
		if (u.u_procp->p_progenv == A_POSIX) 
		    return (EINVAL);
		return (ENOTTY);
		
		break;
	}

	return(0);
}





/******************************************************************
 **                                                              **
 ** ADDER interrupt routine.                                     **
 **                                                              **
 ******************************************************************/

sgaint(sg)
register int sg;
{
	register struct	adder	*sgaddr;
	register struct fcc	*sgfcc;
	register struct nb_regs *nbaddr = (struct nb_regs *)nexus;
	register struct	vdac	*sgvdac;
	register short  *eight_planes;
	struct color_buf *cbuf;

	short status;
	int i;
	register struct rgb *rgbp;