fb_start.c

早期freebsd实现

{
	return (0);
}

/*
 * bitblt from '0' bitmap to frame buffer
 */

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

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

	switch (fb->Mode) {

	case MODE_1to1:
	case MODE_Nto1:
		fb->Pmask &= 1;
		break;
	case MODE_1toN:
	case MODE_NtoN:
		break;

	default:
		return (-1);
	}

	/*
	 * write data into ROP data register
	 */

	fbbm_rop_cinit(fb, fb->Pmask, 0);
	fbbm_rop_clear(fb, &dr);

	return (0);
}

/*
 * bitblt from '1' bitmap to frame buffer
 */

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

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

	switch (fb->Mode) {

	case MODE_1to1:
	case MODE_Nto1:
		/* plane mask set */
		fb->Pmask &= 0x1;
		break;

	case MODE_1toN:
	case MODE_NtoN:
		break;

	default:
		return (-1);
	}

	/*
	 * write data into ROP data register
	 */

	fbbm_rop_cinit(fb, fb->Pmask, 1);
	fbbm_rop_clear(fb, &dr);

	return (0);
}

#ifndef CPU_DOUBLE
/*
 * bitblt from '0' bitmap to main memory
 */

bitblt_0tomem(fb, sbp, srp, dbp, dpp, crp)
	register struct fbdev *fb;
	lBitmap *sbp;		/* source bitmap (0) */
	lRectangle *srp;	/* source rectangle */
	register lBitmap *dbp;	/* destination bitmap (MEM) */
	lPoint *dpp;		/* destination point */
	lRectangle *crp;	/* clip region in destination */
{
	register struct fb_map *dmap;
	register unsigned int p;
	register int i, j;
	register int plane;
	lRectangle sr;
	lRectangle dr;
	int skip;

	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;

	plane = 0x1;

	switch (fb->Mode) {

	case MODE_1to1:
		if (fb->Pmask & plane)
			mem_clear(fb->funcvec[0], dmap, p, dbp->width, &dr, 0);
		break;

	case MODE_1toN:
	case MODE_NtoN:
		skip = (dbp->width * dbp->rect.extent.y) << 1;
		for (i = 0, j = dbp->depth; i < j; i++) {
			if (fb->Pmask & plane)
				mem_clear(fb->funcvec[i], dmap, p, dbp->width,
				    &dr, 0);
			/* next plane */
			p += skip;
			plane <<= 1;
		}
		break;

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

	default:
		return (1);
	}

	return (0);
}

/*
 * bitblt from '1' bitmap to main memory
 */

bitblt_1tomem(fb, sbp, srp, dbp, dpp, crp)
	register struct fbdev *fb;
	lBitmap *sbp;		/* source bitmap (1) */
	lRectangle *srp;	/* source rectangle */
	register 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, j;
	register int plane;
	lRectangle sr;
	lRectangle dr;
	int skip;

	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;

	plane = 0x1;

	switch (fb->Mode) {

	case MODE_1to1:
		if (fb->Pmask & plane)
			mem_clear(fb->funcvec[0], dmap, p, dbp->width, &dr, 1);
		break;

	case MODE_1toN:
	case MODE_NtoN:
		skip = (dbp->width * dbp->rect.extent.y) << 1;
		for (i = 0, j = dbp->depth; i < j; i++) {
			if (fb->Pmask & plane)
				mem_clear(fb->funcvec[i], dmap, p, dbp->width,
				    &dr, 1);
			/* next plane */
			p += skip;
			plane <<= 1;
		}
		break;

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

	default:
		return (1);
	}

	return (0);
}
#endif /* !CPU_DOUBLE */

int
(*sel_ropfunc(stype, dtype))()
	int stype;	/* source bitmap type */
	int dtype;	/* dest bitmap type */
{
	if (dtype == BM_0)
		return (bitblt_nop);
	if (dtype == BM_1)
		return (bitblt_nop);

#ifdef CPU_DOUBLE
	switch (stype) {
	case BM_FB:
		return (dtype == BM_FB) ? bitblt_fb : bitblt_tomem;
		break;

	case BM_MEM:
		return (dtype == BM_FB) ? bitblt_tofb : bitblt_mem;
		break;

	case BM_0:
		return (dtype == BM_FB) ? bitblt_0tofb : bitblt_nop;
		break;
	case BM_1:
		return (dtype == BM_FB) ? bitblt_1tofb : bitblt_nop;
		break;
	}
#else /* CPU_DOUBLE */
	switch (stype) {
	case BM_FB:
		return (dtype == BM_FB) ? bitblt_fb : bitblt_tomem;
		break;

	case BM_MEM:
		return (dtype == BM_FB) ? bitblt_tofb : bitblt_mem;
		break;

	case BM_0:
		return (dtype == BM_FB) ? bitblt_0tofb : bitblt_0tomem;
		break;
	case BM_1:
		return (dtype == BM_FB) ? bitblt_1tofb : bitblt_1tomem;
		break;
	}
#endif /* CPU_DOUBLE */

	return (bitblt_nop);
}

bitbltcmd(fb, cmd)
	register struct fbdev *fb;
	register lBitblt *cmd;
{
	lRectangle cr;
	int ret;

	cr = cmd->destClip;

	if (!getclip(fb, &cmd->destBitmap, &cr))
		return (0);
	if (!clipsrc(fb, &cmd->srcBitmap))
		return (0);

	if (setrop(fb, cmd->func, cmd->planemask, cmd->fore_color, cmd->aux_color,
		cmd->transp, &cmd->srcBitmap, &cmd->destBitmap) < 0)
		return (FB_RERROR);

	cursorCheck(fb, cmd->srcBitmap.type, &cmd->srcRect,
			cmd->destBitmap.type, &cr);

	ret = (*sel_ropfunc(cmd->srcBitmap.type, cmd->destBitmap.type))
	    (fb, &cmd->srcBitmap, &cmd->srcRect, &cmd->destBitmap, &cmd->destPoint, &cr);

	cursorOn(fb);

	return (FB_ROK);
}

static
batch_bitblt_01tofb(fb, sbp, clip, sdp, n, sw)
	register struct fbdev *fb;
	lBitmap *sbp;	/* source bitmap (MEM) */
	register lRectangle *clip;
	register lSrcDest *sdp;
	register int n;
	int sw;
{
	register void (*rop_clear)();
	lRectangle *srect = &sbp->rect;

	switch (fb->Mode) {

	case MODE_1to1:
	case MODE_Nto1:
		fb->Pmask &= 1;
		break;

	case MODE_1toN:
	case MODE_NtoN:
		break;

	default:
		return (FB_RERROR);
	}
	fbbm_rop_cinit(fb, fb->Pmask, sw);
	rop_clear = fb->fbbm_op->fb_rop_clear;
	while (--n >= 0) {
		lRectangle sr;
		lRectangle dr;

		sr = sdp->srcRect;
		dr.origin = sdp->destPoint;
		if (cliprect2(&sr, srect, &dr, clip))
			(*rop_clear)(fb, &dr);
		sdp++;
	}
	return (FB_ROK);
}

static
batch_bitblt_fb(fb, sbp, clip, sdp, n)
	register struct fbdev *fb;
	register lBitmap *sbp;
	register lRectangle *clip;
	register lSrcDest *sdp;
	register int n;
{
	register int wplane, i, j;
	lRectangle sr;
	lRectangle dr;

	fbbm_rop_init(fb, fb->funcvec);
	switch (fb->Mode) {

	case MODE_1to1:
		fb->Pmask &= 1;
		while (--n >= 0) {
			sr = sdp->srcRect;
			dr.origin = sdp->destPoint;
			if (cliprect2(&sr, &sbp->rect, &dr, clip))
				fbbm_rop_copy(fb, &sr, &dr.origin, 0, fb->Pmask);
			sdp++;
		}
		break;

	case MODE_NtoN:
		while (--n >= 0) {
			sr = sdp->srcRect;
			dr.origin = sdp->destPoint;
			if (cliprect2(&sr, &sbp->rect, &dr, clip))
				fbbm_rop_copy(fb, &sr, &dr.origin, 0, fb->Pmask);
			sdp++;
		}
		break;

	case MODE_1toN:
		while (--n >= 0) {
			sr = sdp->srcRect;
			dr.origin = sdp->destPoint;
			if (cliprect2(&sr, &sbp->rect, &dr, clip))
				fbbm_rop_copy(fb, &sr, &dr.origin, 1, fb->Pmask);
			sdp++;
		}
		break;

	case MODE_Nto1:
		for (; --n >= 0; sdp++) {
			sr = sdp->srcRect;
			dr.origin = sdp->destPoint;
			if (!cliprect2(&sr, &sbp->rect, &dr, clip))
				continue;
			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 (FB_RERROR);
	}
}

static
batch_bitblt_tofb(fb, sbp, dbp, crp, sdp, n)
	register struct fbdev *fb;
	register lBitmap *sbp;	/* source bitmap (MEM) */
	lBitmap *dbp;		/* destination bitmap (FB) */
	lRectangle *crp;	/* clip region in destination */
	register lSrcDest *sdp;
	register int n;
{
	register unsigned p;
	register struct fb_map *smap;
	register int i, j, m;
	lRectangle sr;
	lRectangle dr;
	register int wplane;
#ifdef IPC_MRX
	extern struct fb_map rommap;
	register int pages;
#endif

	fbbm_rop_winit(fb);
	while (--n >= 0) {
		sr = sdp->srcRect;
		dr.origin = sdp->destPoint;
		if (crp && !cliprect2(&sr, &sbp->rect, &dr, crp)) {
			sdp++;
			continue;
		}
		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
		 */
		smap = (struct fb_map*)sbp->base;
		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;

		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:
			j = min(sbp->depth, fb->fbNplane);
			m = sbp->width * sbp->rect.extent.y;
			p += (m << 1) * j;
			wplane = 1 << (j - 1);
			for (i = j; 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);
		}
		sdp++;
	}
	return (0);
}

batchbitbltcmd(fb, cmd)
	register struct fbdev *fb;
	register lBatchBitblt *cmd;
{
	register int n;
	register lSrcDest *sdp;
	register int (*blt)();
	lRectangle cr;
#ifdef CPU_SINGLE
	struct fb_map *map;
	unsigned int p;
#endif
	int error;

	if (setrop(fb, cmd->func, cmd->planemask,
	    cmd->fore_color, cmd->aux_color,
	    cmd->transp, &cmd->srcBitmap, &cmd->destBitmap) < 0)
		return (FB_RERROR);

	cr = cmd->destClip;

	if (!getclip(fb, &cmd->destBitmap, &cr))
		return (FB_ROK);
	if (!clipsrc(fb, &cmd->srcBitmap))
		return (0);
#ifdef CPU_SINGLE
	map = (struct fb_map *)(cmd->srcDestList);
	p = map->fm_offset;
	sdp = (lSrcDest *)TypeAt(map, p);
#else
	sdp = cmd->srcDestList;
#endif
	n = cmd->nSrcDest;

	cursorCheck(fb, cmd->srcBitmap.type, &cmd->srcBitmap.rect,
	    cmd->destBitmap.type, &cr);

	blt = sel_ropfunc(cmd->srcBitmap.type, cmd->destBitmap.type);
	if (blt == bitblt_0tofb || blt == bitblt_1tofb) {
		if (error =
		    batch_bitblt_01tofb(fb, &cmd->srcBitmap, &cr, sdp, n,
		    blt == bitblt_1tofb)) {
			cursorOn(fb);
			return (error);
		}
	} else if (blt == bitblt_fb) {
		if (error =
		    batch_bitblt_fb(fb, &cmd->srcBitmap, &cr, sdp, n)) {
			cursorOn(fb);
			return (error);
		}
	} else if (blt == bitblt_tofb) {
		if (error =
		    batch_bitblt_tofb(fb, &cmd->srcBitmap, &cmd->destBitmap,
		    &cr, sdp, n)) {
			cursorOn(fb);
			return (error);
		}
	} else
		while (--n >= 0) {
			if ((*blt)(fb, &cmd->srcBitmap, &sdp->srcRect,
			    &cmd->destBitmap, &sdp->destPoint, &cr) < 0) {
				cursorOn(fb);
				return (FB_RERROR);
			}
			PRE_EMPT;
			sdp++;
		}
	cursorOn(fb);
	return (FB_ROK);
}

tilebitbltcmd(fb, cmd)
	struct fbdev *fb;
	register lTileBitblt *cmd;
{
	lRectangle trect, rect, prect;
	lPoint dp;
	register int dx;
	int dy;
	register int offx, offy;
	register int xlen, ylen;
	int first;
	register int (*blt)();
	int t;

	rect = cmd->destRect;
	prect = cmd->ptnRect;

	if (prect.extent.x <= 0 || prect.extent.y <= 0)
		return;

	if (cmd->ptnBitmap.type == BM_FB &&
		!cliprect(&cmd->ptnBitmap.rect, &fb->FrameRect, (lRectangle*)0))
		return;

	/* clip pattern rectangle */
	if (!cliprect(&prect, &cmd->ptnBitmap.rect, (lRectangle *)0))
		return;

	if (!getclip(fb, &cmd->destBitmap, &cmd->destClip)) return;

	if (!cliprect(&rect, &cmd->destClip, (lRectangle *)0))
		return;

	if (setrop(fb, cmd->func, cmd->planemask, cmd->fore_color, cmd->aux_color,
		cmd->transp, &cmd->ptnBitmap, &cmd->destBitmap) < 0)
		return (FB_RERROR);

	blt = sel_ropfunc(cmd->ptnBitmap.type, cmd->destBitmap.type);

	offx = MOD(rect.origin.x - cmd->refPoint.x, prect.extent.x, t);
	offy = MOD(rect.origin.y - cmd->refPoint.y, prect.extent.y, t);

	dp = rect.origin;

	trect.origin.x = prect.origin.x + offx;
	trect.origin.y = prect.origin.y + offy;

	dy = rect.extent.y;

	cursorCheck(fb, cmd->ptnBitmap.type, &prect, cmd->destBitmap.type, &rect);

	first = 1;