fb_start.c

早期freebsd实现

{
	int data;
#ifdef CPU_SINGLE
	register int s = splbitmap();
#endif

	if (fb->cursorSet && !fb->cursorShow) {
		if (cfb && cfb != fb) {
			cursorOff(cfb);
			cfb->cursorShow = 0;
		}
		cfb = fb;
		fb->cursorShow = 1;
		mp = fb->cursorP;
		cursorOn(fb);
#ifdef CPU_SINGLE
		data = FB_INT_VSYNC;
		fbbm_ioctl(fb, FB_INTENABLE, &data);
		splx(s);
#endif
		return (FB_ROK);
	}
#ifdef CPU_SINGLE
	splx(s);
#endif
	return (FB_RERROR);
}


hideCursor(fb)
	register struct fbdev *fb;
{
	int data;
#ifdef CPU_SINGLE
	int s = splbitmap();
#endif

	if (cfb == fb) {
		cursorOff(fb);
		fb->cursorShow = 0;
#ifdef CPU_SINGLE
		data = FB_INT_VSYNC;
		fbbm_ioctl(fb, FB_INTCLEAR, &data);
		splx(s);
#endif
		return (FB_ROK);
	}
#ifdef CPU_SINGLE
	splx(s);
#endif
	return (FB_RERROR);
}


moveCursor(fb, point)
	struct fbdev *fb;
	lPoint *point;
{
	if (cfb == fb) {
		updateCursor(&point->x, &point->y, 1);
		return (FB_ROK);
	}
	return (FB_RERROR);
}

#ifdef CPU_SINGLE
rop_xint()
{
	register struct fbdev *fb;
	register int i;
	register int done = 0;
	int event, data;
	int s = splbitmap();

	for (i = 0, fb = fbdev; i < nfbdev; i++, fb++) {
		if (fb->type && (event = fbbm_ioctl(fb, FB_INTCHECK, 0))) {
#ifdef notyet /* KU:XXX */
			intrcnt[INTR_BITMAP]++;
#endif
			done = 1;
			if (event & FB_INT_VSYNC) {
				data = FB_INT_VSYNC;
				fbbm_ioctl(fb, FB_INTCLEAR, &data);
				if (!lock_bitmap_poll()) {
					curs_pending = 0;
					redrawCursor(fb);
					unlock_bitmap_poll();
				} else {
					curs_pending = 1;
				}
				data = FB_INT_VSYNC;
				fbbm_ioctl(fb, FB_INTENABLE, &data);
			}
			if (event & FB_INT_ROPDONE) {
				if(fb->run_flag & FB_WAITING) {
					data = FB_INT_ROPDONE;
					fbbm_ioctl(fb, FB_INTCLEAR, &data);
					if (!(fbbm_ioctl(fb, FB_STATUSCHECK, 0)
					& (FB_STATUS_ROPWAIT|FB_STATUS_ROPEXEC))) {
						fb->run_flag &= ~FB_WAITING;
						wakeup(&(fb->run_flag));
					} else {
						data = FB_INT_ROPDONE|0x100;
						fbbm_ioctl(fb, FB_INTENABLE, &data);
					}
				}
			}
		}
	}
	splx(s);
	return (done);
}
#endif /* CPU_SINGLE */

cliprect2(sr, sc, dr, dc)
	register lRectangle *sr;
	register lRectangle *sc;
	register lRectangle *dr;	
	register lRectangle *dc;	
{
	register int d;

	/* src left/right edge */
	if ((d = sr->origin.x - sc->origin.x) < 0) {
		sr->extent.x += d;
		sr->origin.x -= d;
		dr->origin.x -= d;
		d = sr->extent.x - sc->extent.x;
	} else
		d += sr->extent.x - sc->extent.x;
	if (d > 0)
		sr->extent.x -= d;

	/* src top/bottom edge */
	if ((d = sr->origin.y - sc->origin.y) < 0) {
		sr->extent.y += d;
		sr->origin.y -= d;
		dr->origin.y -= d;
		d = sr->extent.y - sc->extent.y;
	} else
		d += sr->extent.y - sc->extent.y;
	if (d > 0)
		sr->extent.y -= d;

	if (sr->extent.x <= 0 || sr->extent.y <= 0)
		return (0);

	/* dst left/right edge */
	if ((d = dr->origin.x - dc->origin.x) < 0) {
		dr->origin.x -= d;
		sr->extent.x += d;
		sr->origin.x -= d;
		d = sr->extent.x - dc->extent.x;
	} else
		d += sr->extent.x - dc->extent.x;
	if (d > 0)
		sr->extent.x -= d;

	/* dst top/bottom edge */
	if ((d = dr->origin.y - dc->origin.y) < 0) {
		dr->origin.y -= d;
		sr->extent.y += d;
		sr->origin.y -= d;
		d = sr->extent.y - dc->extent.y;
	} else
		d += sr->extent.y - dc->extent.y;
	if (d > 0)
		sr->extent.y -= d;

	if (sr->extent.x <= 0 || sr->extent.y <= 0)
		return (0);

	dr->extent = sr->extent;
	return (1);
}

cliprect(r, crp, p)
	register lRectangle *r;
	register lRectangle *crp;
	register lRectangle *p;	
{
	register int d;

	/* left edge */
	if ((d = r->origin.x - crp->origin.x) < 0) {
		r->extent.x += d;
		r->origin.x -= d;
		if (p) {
			p->extent.x += d;
			p->origin.x -= d;
		}
		d = r->extent.x - crp->extent.x;
	} else
		d += r->extent.x - crp->extent.x;

	/* right edge */
	if (d > 0) {
		r->extent.x -= d;
		if (p)
			p->extent.x -= d;
	}

	/* top edge */
	if ((d = r->origin.y - crp->origin.y) < 0) {
		r->extent.y += d;
		r->origin.y -= d;
		if (p) {
			p->extent.y += d;
			p->origin.y -= d;
		}
		d = r->extent.y - crp->extent.y;
	} else
		d += r->extent.y - crp->extent.y;

	/* bottom edge */
	if (d > 0) {
		r->extent.y -= d;
		if (p)
			p->extent.y -= d;
	}

	return (r->extent.x > 0 && r->extent.y > 0);
}

getclip(fb, bmp, crp)
	struct fbdev *fb;
	lBitmap *bmp;
	lRectangle *crp;
{
	/* limit clip rectangle to bitmap rectangle */
	if (!cliprect(crp, &bmp->rect, (lRectangle*)0))
		return (0);

	/* limit clip rectangle to frame buffer */
	if ((bmp->type == BM_FB) &&
	    !cliprect(crp, &fb->FrameRect, (lRectangle*)0))
		return (0);
	return (1);
}


clipsrc(fb, bmp)
	struct fbdev *fb;
	lBitmap *bmp;
{
	/* limit clip rectangle to frame buffer */
	if (bmp->type == BM_FB &&
	    !cliprect(&bmp->rect, &fb->FrameRect, (lRectangle*)0))
		return (0);
	return (1);
}


setrop(fb, func, pmask, fore, aux, trans, sbp, dbp)
	register struct fbdev *fb;
	register unsigned int func;
	int pmask;
	register int fore, aux;
	int trans;
	lBitmap *sbp, *dbp;
{
	register char *funcp;
	register int i;
	char tmp[4];

	/* set plane register */

	fb->Mode = 0;
	fb->Pmask = pmask;
	fb->func = func;
	fb->fore = fore;
	fb->aux = aux;
	fb->trans = trans;

	if (sbp->depth > 1)
		fb->Mode |= 2;

	if (dbp->depth > 1)
		fb->Mode |= 1;

	/* set rop function register */
	func &= 0xf;

	tmp[0] = TRANS(trans, (func & 0x0c) | (func>>2));
	tmp[1] = TRANS(trans, (func>>2) | ((func<<2) & 0x0c));
	tmp[2] = TRANS(trans, func);
	tmp[3] = TRANS(trans, (func<<2) & 0x0c | func & 3);

	funcp = fb->funcvec;
	for (i = fb->fbNplane; --i >= 0;) {
		*funcp++ = tmp[((fore & 1) << 1) | (aux & 1)];
		fore >>= 1; aux >>= 1;
	}
	return (0);
}

/*
 * bitblt within frame buffer
 */

bitblt_fb(fb, sbp, srp, dbp, dpp, crp)
	register struct fbdev *fb;
	register lBitmap *sbp;	/* source bitmap (FB) */
	lRectangle *srp;	/* source rectangle */
	lBitmap *dbp;		/* destination bitmap (FB) */
	lPoint *dpp;		/* destination point */
	lRectangle *crp;	/* clip region in destination */
{
	lRectangle sr;
	lRectangle dr;
	register int wplane, i, j;

	sr = *srp;
	dr.origin = *dpp;
	if (crp && !cliprect2(&sr, &sbp->rect, &dr, crp))
		return (0);

	fbbm_rop_init(fb, fb->funcvec);

	switch (fb->Mode) {

	case MODE_1to1:
		fb->Pmask &= 1;

	case MODE_NtoN:

		fbbm_rop_copy(fb, &sr, &dr.origin, 0, fb->Pmask);
		break;

	case MODE_1toN:
		fbbm_rop_copy(fb, &sr, &dr.origin, 1, fb->Pmask);
		break;

	case MODE_Nto1:
		wplane = 1;
		for (i = 0, j = sbp->depth; i < j; i++) {
			if (fb->Pmask & wplane) {
				fbbm_rop_copy(fb, &sr, &dr.origin, i + 1,
				    fb->Pmask >> 16);
				break;
			}
			wplane <<= 1;
		}
		break;
	default:
		return (-1);
	}
	return (0);
}

/*
 * bitblt from main memory to frame buffer
 */

bitblt_tofb(fb, sbp, srp, dbp, dpp, crp)
	register struct fbdev *fb;
	register lBitmap *sbp;	/* source bitmap (MEM) */
	lRectangle *srp;	/* source rectangle */
	lBitmap *dbp;		/* destination bitmap (FB) */
	lPoint *dpp;		/* destination point */
	lRectangle *crp;	/* clip region in destination */
{
	register unsigned p;
	register struct fb_map *smap;
	register int i, n, m;
	lRectangle sr;
	lRectangle dr;
	register int wplane;
#ifdef IPC_MRX
	extern struct fb_map rommap;
	register int pages;
#endif

	smap = (struct fb_map*)sbp->base;

	sr = *srp;
	dr.origin = *dpp;
	if (crp && !cliprect2(&sr, &sbp->rect, &dr, crp))
		return (0);
	dr.extent = sr.extent;

	/* transform source rectangle */
	sr.origin.x -= sbp->rect.origin.x;
	sr.origin.y -= sbp->rect.origin.y;

	/*
	 * check memory map specification
	 */
	p = smap->fm_offset;
#ifdef IPC_MRX
	pages = btoc(smap->fm_offset + smap->fm_count);
	rommap.fm_vaddr = fb_map_page(smap->fm_addr, pages,
		    fb->cache_off ? PG_S|PG_WP|PG_CI : PG_S|PG_WP);
	rommap.fm_offset = 0;
	smap = &rommap;
#endif

	wplane = 1;

	fbbm_rop_winit(fb);

	switch (fb->Mode) {
	case MODE_1to1:
		fbbm_rop_write(fb, smap, p, sbp->width,
			       &sr, &dr, fb->Pmask & 0x01);
		break;
	case MODE_1toN:
		fbbm_rop_write(fb, smap, p, sbp->width,
			       &sr, &dr, fb->Pmask);
		break;
	case MODE_Nto1:
		m = sbp->width * sbp->rect.extent.y;
		for (i = 0; i < sbp->depth; i++, wplane <<= 1) {
			if (fb->Pmask & wplane) {
				p += (m * i) << 1;
				fbbm_rop_write(fb, smap, p, sbp->width,
					       &sr, &dr, wplane);
				break;
			}
			wplane <<= 1;
		}
		break;
	case MODE_NtoN:
		n = min(sbp->depth, fb->fbNplane);
		m = sbp->width * sbp->rect.extent.y;
		p += (m << 1) * n;
		wplane = 1 << (n - 1);
		for (i = n; i > 0; i--) {
			/* get next plane */
			p -= m << 1;
			if (fb->Pmask & wplane)
				fbbm_rop_write(fb, smap, p, sbp->width,
					       &sr, &dr, wplane);
			/* next plane mask */
			wplane >>= 1;
		}
		break;
	default:
		return (-1);
	}
	return (0);
}

/*
 * bitblt from frame buffer to main memroy
 */

bitblt_tomem(fb, sbp, srp, dbp, dpp, crp)
	struct fbdev *fb;
	lBitmap *sbp;		/* source bitmap (FB) */
	lRectangle *srp;	/* source rectangle */
	lBitmap *dbp;		/* destination bitmap (MEM) */
	lPoint *dpp;		/* destination point */
	lRectangle *crp;	/* clip region in destination */
{
	register struct fb_map *dmap;
	register unsigned p;
	register int i, n, m;
	lRectangle sr;
	lRectangle dr;
	int plane;
#ifdef IPC_MRX
	extern struct fb_map rommap;
	register int pages;
#endif

	dmap = (struct fb_map*)dbp->base;

	sr = *srp;
	dr.origin = *dpp;
	if (crp && !cliprect2(&sr, &sbp->rect, &dr, crp))
		return (0);
	dr.extent = sr.extent;

	dr.origin.x -= dbp->rect.origin.x;
	dr.origin.y -= dbp->rect.origin.y;

	p = dmap->fm_offset;
#ifdef IPC_MRX
	pages = btoc(dmap->fm_offset + dmap->fm_count);
	rommap.fm_vaddr = fb_map_page(dmap->fm_addr, pages, PG_S);
	rommap.fm_offset = 0;
	dmap = &rommap;
#endif

	plane = 1;

/*	Wait for rop busy */

	switch (fb->Mode) {

	case MODE_1to1:
		if (fb->Pmask & plane)
			fbbm_rop_read(fb, dmap, p, dbp->width,
				      &sr, &dr, 0, 0);
		break;

	case MODE_1toN:
		m = (dbp->width * dbp->rect.extent.y) << 1;
		for (i = 0; i < dbp->depth; i++) {
			if (fb->Pmask & plane)
				fbbm_rop_read(fb, dmap, p, dbp->width,
					      &sr, &dr, 0, i);
			/* next plane */
			p += m;
			plane <<= 1;
		}
		break;

	case MODE_Nto1:
		for (i = 0; i < sbp->depth; i++, plane <<= 1) {
			if (fb->Pmask & plane) {
				fbbm_rop_read(fb, dmap, p, dbp->width,
					      &sr, &dr, i, 0);
				break;
			}
		}
		break;

	case MODE_NtoN:
		n = min(dbp->depth, fb->fbNplane);
		m = (dbp->width * dbp->rect.extent.y) << 1;
		for (i = 0; i < n; i++) {
			if (fb->Pmask & plane)
				fbbm_rop_read(fb, dmap, p, dbp->width,
					      &sr, &dr, i, i);
			/* next plane */
			p += m;
			plane <<= 1;
		}

		break;

	default:
		return (-1);
	}

	return (0);
}

bitblt_mem(fb, sbp, srp, dbp, dpp, crp)
	struct fbdev *fb;
	register lBitmap *sbp;
	lRectangle *srp;
	register lBitmap *dbp;
	lPoint *dpp;
	lRectangle *crp;
{
	register int i;
	register int plane;
	register struct fb_map *smap, *dmap;
	register unsigned int ps, pd;
	lRectangle sr;
	lRectangle dr;
#ifdef IPC_MRX
	static struct fb_map drommap;
	int spages, dpages;
#endif

	smap = (struct fb_map*)sbp->base;
	dmap = (struct fb_map*)dbp->base;

	sr = *srp;
	dr.origin = *dpp;
	if (crp && !cliprect2(&sr, &sbp->rect, &dr, crp))
		return (0);

	/* normalize source/destination coordinates */
	sr.origin.x -= sbp->rect.origin.x;
	sr.origin.y -= sbp->rect.origin.y;
	dr.origin.x -= dbp->rect.origin.x;
	dr.origin.y -= dbp->rect.origin.y;

	ps = smap->fm_offset;
	pd = dmap->fm_offset;
#ifdef IPC_MRX
	spages = btoc(smap->fm_offset + smap->fm_count);
	dpages = btoc(dmap->fm_offset + dmap->fm_count);
	rommap.fm_vaddr = fb_map_page2(smap->fm_addr, spages, PG_S|PG_WP);
	rommap.fm_offset = 0;
	drommap.fm_vaddr = fb_map_page2(dmap->fm_addr, dpages, PG_S);
	drommap.fm_offset = 0;
	smap = &rommap;
	dmap = &drommap;
#endif

	plane = 0x1;	/* plane 0 */

	switch (fb->Mode) {

	case MODE_1to1:
		if (fb->Pmask & plane) {
			mem_to_mem(fb->funcvec[0],
				   smap, ps, sbp->width, dmap, pd, dbp->width,
				   &sr, &dr.origin);
		}
		break;

	case MODE_1toN:
		for (i = 0; i < dbp->depth; i++) {
			if (fb->Pmask & plane) {
				mem_to_mem(fb->funcvec[i],
					   smap, ps, sbp->width,
					   dmap, pd, dbp->width,
					   &sr, &dr.origin);
			}
			pd += (dbp->width * dbp->rect.extent.y) << 1;
			plane <<= 1;
		}
		break;

	case MODE_Nto1:
		for (i = 0; i < sbp->depth; i++, plane <<= 1) {
			if (fb->Pmask & plane)
				break;
		}
		if (i < sbp->depth) {
			ps += (sbp->width * sbp->rect.extent.y * i) << 1;
			mem_to_mem(fb->funcvec[i],
				   smap, ps, sbp->width, dmap, pd, dbp->width,
				   &sr, &dr.origin);
		}
		break;

	case MODE_NtoN:
		for (i = 0; i < dbp->depth; i++) {
			if (fb->Pmask & plane) {
				mem_to_mem(fb->funcvec[i],
					   smap, ps, sbp->width,
					   dmap, pd, dbp->width,
					   &sr, &dr.origin);
			}
			ps += (sbp->width * sbp->rect.extent.y) << 1;
			pd += (dbp->width * dbp->rect.extent.y) << 1;
			plane <<= 1;
		}
		break;

	default:
		return (-1);
	}
#ifdef IPC_MRX
	page_unmap(rommap.fm_vaddr, spages);
	page_unmap(drommap.fm_vaddr, dpages);
#endif
	return (0);
}

bitblt_nop()