fb_sub.c

早期freebsd实现

		}
		break;

	default:
		return EINVAL;
	}
	return error;
}

fbtilebitblt(fbp, cmd)
	struct fbreg *fbp;
	register sTileBitblt *cmd;
{
	lTileBitblt lcmd;
	register lTileBitblt *lcmdp;

	lcmdp = &lcmd;

	lcmdp->func = cmd->func;
	lcmdp->transp = cmd->transp;
	lcmdp->fore_color = cmd->fore_color;
	lcmdp->aux_color = cmd->aux_color;
	lcmdp->planemask = cmd->planemask;
	lcmdp->ptnBitmap.type = cmd->ptnBitmap.type;
	lcmdp->ptnBitmap.depth = cmd->ptnBitmap.depth;
	lcmdp->ptnBitmap.width = cmd->ptnBitmap.width;
	lcmdp->ptnBitmap.rect.origin.x = cmd->ptnBitmap.rect.origin.x;
	lcmdp->ptnBitmap.rect.origin.y = cmd->ptnBitmap.rect.origin.y;
	lcmdp->ptnBitmap.rect.extent.x = cmd->ptnBitmap.rect.extent.x;
	lcmdp->ptnBitmap.rect.extent.y = cmd->ptnBitmap.rect.extent.y;
	lcmdp->ptnBitmap.base = cmd->ptnBitmap.base;
	lcmdp->ptnRect.origin.x = cmd->ptnRect.origin.x;
	lcmdp->ptnRect.origin.y = cmd->ptnRect.origin.y;
	lcmdp->ptnRect.extent.x = cmd->ptnRect.extent.x;
	lcmdp->ptnRect.extent.y = cmd->ptnRect.extent.y;
	lcmdp->refPoint.x = cmd->refPoint.x;
	lcmdp->refPoint.y = cmd->refPoint.y;
	lcmdp->destBitmap.type = cmd->destBitmap.type;
	lcmdp->destBitmap.depth = cmd->destBitmap.depth;
	lcmdp->destBitmap.width = cmd->destBitmap.width;
	lcmdp->destBitmap.rect.origin.x = cmd->destBitmap.rect.origin.x;
	lcmdp->destBitmap.rect.origin.y = cmd->destBitmap.rect.origin.y;
	lcmdp->destBitmap.rect.extent.x = cmd->destBitmap.rect.extent.x;
	lcmdp->destBitmap.rect.extent.y = cmd->destBitmap.rect.extent.y;
	lcmdp->destBitmap.base = cmd->destBitmap.base;
	lcmdp->destClip.origin.x = cmd->destClip.origin.x;
	lcmdp->destClip.origin.y = cmd->destClip.origin.y;
	lcmdp->destClip.extent.x = cmd->destClip.extent.x;
	lcmdp->destClip.extent.y = cmd->destClip.extent.y;
	lcmdp->destRect.origin.x = cmd->destRect.origin.x;
	lcmdp->destRect.origin.y = cmd->destRect.origin.y;
	lcmdp->destRect.extent.x = cmd->destRect.extent.x;
	lcmdp->destRect.extent.y = cmd->destRect.extent.y;
	return (fbntilebitblt(fbp, lcmdp));
}

/* ARGSUSED */
fbbitblt3(fbp, cmd)
	struct fbreg *fbp;
	sBitblt3 *cmd;
{
	return ENXIO;
}

/* ARGSUSED */
fbnbitblt3(fbp, cmd)
	struct fbreg *fbp;
	lBitblt3 *cmd;
{
	return ENXIO;
}

fbnpolyline(fbp, cmd, dj, seg)
	struct fbreg *fbp;
	register lPrimLine *cmd;
	int dj;			/* if not zero, disjoint polyline */
	int seg;
{
	register int error = 0;
	register int len;

#ifdef CPU_DOUBLE
	if(cmd->drawBM.type == BM_MEM) {
		return(mfbnpolyline(fbp, cmd, dj, seg));
		/* NOTREACHED */
	}
#endif

	fbinitlock();
	fbp->fb_command = dj ? FB_CDJPOLYLINE : FB_CPOLYLINE;
	fbp->fb_polyline = *cmd;

	if ((cmd->np & 1) && dj)
		return EINVAL;

#ifdef CPU_SINGLE
	if (error = fblocksbitmap(&fbp->fb_polyline.drawBM, B_READ, fbmap))
		return error;
	if ((len = cmd->np * sizeof(lPoint)) <= 0)
		return EINVAL;
	error = fblockmem((caddr_t)cmd->plist, len, B_WRITE, fbmap + 1, seg);
	if (error)
		return error;
	fbp->fb_polyline.plist = (lPoint *)ipc_phys(fbmap + 1);

	fbdolock();
	fbstart(fbp, 1);
	fbunlock();
#else /* CPU_SINGLE */
	fbp->fb_polyline.plist = (lPoint *)ipc_phys(srcdestlist);
	while (cmd->np > 0) {
		len = min(cmd->np, ((MAX_SIZE / sizeof(lPoint)) & ~1));
		fbp->fb_polyline.np = len;
		if (error = COPYIN((caddr_t)cmd->plist, (caddr_t)srcdestlist,
				   len * sizeof(lPoint), seg)) {
			return error;
		}
		cmd->np -= len;
		cmd->plist += len;

		if (fbp->fb_polyline.drawBM.type == BM_MEM) {
			if (error = fblocksbitmap(&fbp->fb_polyline.drawBM,
						  B_READ, fbmap)) {
				return error;
			}
			fbdolock();
			fbstart(fbp, 1);
			fbunlock();
		} else if (cmd->np)
			fbstart(fbp, 1);
		else
			fbstart(fbp, 0);
		if (!dj && cmd->np) {
			cmd->np++;
			cmd->plist--;
		}
	}
#endif /* CPU_SINGLE */
	return error;
}

fbpolyline(fbp, cmd, dj)
	struct fbreg *fbp;
	register sPrimLine *cmd;
	int dj;
{
	lPrimLine lcmd;
	register lPrimLine *lcmdp;
	static lPoint 	pl[100];
	register lPoint *lp;
	register sPoint *sp;
	register int	np;

	lcmdp = &lcmd;

	lcmdp->func = cmd->func;
	lcmdp->transp = cmd->transp;
	lcmdp->fore_color = cmd->fore_color;
	lcmdp->aux_color = cmd->aux_color;
	lcmdp->planemask = cmd->planemask;
	lcmdp->drawBM.type = cmd->drawBM.type;
	lcmdp->drawBM.depth = cmd->drawBM.depth;
	lcmdp->drawBM.width = cmd->drawBM.width;
	lcmdp->drawBM.rect.origin.x = cmd->drawBM.rect.origin.x;
	lcmdp->drawBM.rect.origin.y = cmd->drawBM.rect.origin.y;
	lcmdp->drawBM.rect.extent.x = cmd->drawBM.rect.extent.x;
	lcmdp->drawBM.rect.extent.y = cmd->drawBM.rect.extent.y;
	lcmdp->drawBM.base = cmd->drawBM.base;
	lcmdp->clip.origin.x = cmd->clip.origin.x;
	lcmdp->clip.origin.y = cmd->clip.origin.y;
	lcmdp->clip.extent.x = cmd->clip.extent.x;
	lcmdp->clip.extent.y = cmd->clip.extent.y;
	lcmdp->lptn = cmd->lptn;
	lcmdp->dlpf = cmd->dlpf;
	lcmdp->plist = pl;
	sp = (sPoint *)cmd->plist;
	while (cmd->np) {
		lcmdp->np = np = min(cmd->np, 100);
		cmd->np -= np;
		lp = pl;
		while (np-- > 0) {
			int error;
			sPoint tmp;

			if (error = copyin((caddr_t)sp, (caddr_t)&tmp, sizeof (tmp)))
				return (error);
			lp->x = tmp.x;
			lp->y = tmp.y;
			lp++;
			sp++;
		}
		fbnpolyline(fbp, lcmdp, dj, UIO_SYSSPACE);
	}
}

fbnfillscan(fbp, cmd, seg)
	struct fbreg *fbp;
	register lPrimFill *cmd;
	int seg;
{
	register int error;
	register int len;

#ifdef CPU_DOUBLE
	int blttype = BLTTYPE(cmd->ptnBM.type, cmd->drawBM.type);

	if ((blttype == BLTTYPE(BM_MEM, BM_MEM)) ||
	    (blttype == BLTTYPE(BM_0, BM_MEM)) ||
	    (blttype == BLTTYPE(BM_1, BM_MEM))) {
		return(mfbnfillscan(fbp, cmd, seg));
		/* NOTREACHED */
	}
#endif

	fbinitlock();
	fbp->fb_command = FB_CFILLSCAN;
	fbp->fb_fillscan = *cmd;

#ifdef CPU_SINGLE
	if (error = fblocksbitmap(&fbp->fb_fillscan.ptnBM, B_WRITE, fbmap))
		return error;
	if (error = fblocksbitmap(&fbp->fb_fillscan.drawBM, B_READ, fbmap + 1))
		return error;
	if ((len = cmd->nscan * sizeof(lScanl)) <= 0)
		return EINVAL;
	if (error = fblockmem(cmd->scan, len, B_WRITE, fbmap + 2, seg))
		return error;
	fbp->fb_fillscan.scan = (lScanl *)ipc_phys(fbmap + 2);

	fbdolock();
	fbstart(fbp, 1);
	fbunlock();
#else /* CPU_SINGLE */
	fbp->fb_fillscan.scan = (lScanl *)ipc_phys(srcdestlist);
	while (cmd->nscan > 0) {
		len = min(cmd->nscan, (MAX_SIZE / sizeof(lScanl)));
		fbp->fb_fillscan.nscan = len;
		if (error = COPYIN((caddr_t)cmd->scan, (caddr_t)srcdestlist,
				   len * sizeof(lScanl), seg)) {
			return error;
		}
		cmd->nscan -= len;
		cmd->scan += len;
		if (fbp->fb_fillscan.ptnBM.type == BM_MEM ||
		    fbp->fb_fillscan.drawBM.type == BM_MEM) {

			if (error = fblocksbitmap(&fbp->fb_fillscan.ptnBM,
						  B_WRITE, fbmap)) {
				return error;
			}
			if (error = fblocksbitmap(&fbp->fb_fillscan.drawBM,
						  B_READ, fbmap + 1)) {
				return error;
			}

			fbdolock();
			fbstart(fbp, 1);
			fbunlock();
		} else if (cmd->nscan)
			fbstart(fbp, 1);
		else
			fbstart(fbp, 0);
	}
#endif /* CPU_SINGLE */
	return error;
}

fbfillscan(fbp, cmd)
	struct fbreg *fbp;
	register sPrimFill *cmd;
{
	lPrimFill lcmd;
	register lPrimFill *lcmdp;
	static lScanl	ls[100];
	register lScanl	*lp;
	register sScanl	*sp;
	register int	ns;

	lcmdp = &lcmd;
	lcmdp->func = cmd->func;
	lcmdp->transp = cmd->transp;
	lcmdp->fore_color = cmd->fore_color;
	lcmdp->aux_color = cmd->aux_color;
	lcmdp->planemask = cmd->planemask;
	lcmdp->refPoint.x = cmd->refPoint.x;
	lcmdp->refPoint.y = cmd->refPoint.y;
	lcmdp->ptnRect.origin.x = cmd->ptnRect.origin.x;
	lcmdp->ptnRect.origin.y = cmd->ptnRect.origin.y;
	lcmdp->ptnRect.extent.x = cmd->ptnRect.extent.x;
	lcmdp->ptnRect.extent.y = cmd->ptnRect.extent.y;
	lcmdp->ptnBM.type = cmd->ptnBM.type;
	lcmdp->ptnBM.depth = cmd->ptnBM.depth;
	lcmdp->ptnBM.width = cmd->ptnBM.width;
	lcmdp->ptnBM.rect.origin.x = cmd->ptnBM.rect.origin.x;
	lcmdp->ptnBM.rect.origin.y = cmd->ptnBM.rect.origin.y;
	lcmdp->ptnBM.rect.extent.x = cmd->ptnBM.rect.extent.x;
	lcmdp->ptnBM.rect.extent.y = cmd->ptnBM.rect.extent.y;
	lcmdp->ptnBM.base = cmd->ptnBM.base;
	lcmdp->drawBM.type = cmd->drawBM.type;
	lcmdp->drawBM.depth = cmd->drawBM.depth;
	lcmdp->drawBM.width = cmd->drawBM.width;
	lcmdp->drawBM.rect.origin.x = cmd->drawBM.rect.origin.x;
	lcmdp->drawBM.rect.origin.y = cmd->drawBM.rect.origin.y;
	lcmdp->drawBM.rect.extent.x = cmd->drawBM.rect.extent.x;
	lcmdp->drawBM.rect.extent.y = cmd->drawBM.rect.extent.y;
	lcmdp->drawBM.base = cmd->drawBM.base;
	lcmdp->clip.origin.x = cmd->clip.origin.x;
	lcmdp->clip.origin.y = cmd->clip.origin.y;
	lcmdp->clip.extent.x = cmd->clip.extent.x;
	lcmdp->clip.extent.y = cmd->clip.extent.y;
	lcmdp->scan = ls;
	sp = (sScanl *)cmd->scan;
	while (cmd->nscan) {
		lcmdp->nscan = ns = min(cmd->nscan, 100);
		cmd->nscan -= ns;
		lp = ls;
		while (ns-- > 0) {
			int error;
			sScanl tmp;

			if (error = copyin((caddr_t)sp, (caddr_t)&tmp, sizeof (tmp)))
				return (error);
			lp->x0 = tmp.x0;
			lp->x1 = tmp.x1;
			lp->y = tmp.y;
			lp++;
			sp++;
		}
		fbnfillscan(fbp, lcmdp, UIO_SYSSPACE);
	}
}

fbnrectangle(fbp, cmd)
	struct fbreg *fbp;
	register lPrimRect *cmd;
{
	register int error = 0;

#ifdef CPU_DOUBLE
	int blttype = BLTTYPE(cmd->ptnBM.type, cmd->drawBM.type);

	if ((blttype == BLTTYPE(BM_MEM, BM_MEM)) ||
	    (blttype == BLTTYPE(BM_0, BM_MEM)) ||
	    (blttype == BLTTYPE(BM_1, BM_MEM))) {
		return(mfbnrectangle(fbp, cmd));
		/* NOTREACHED */
	}
#endif /* CPU_DOUBLE */

	fbinitlock();
	fbp->fb_command = FB_CRECTANGLE;
	fbp->fb_rectangle = *cmd;

	if (error = fblocksbitmap(&fbp->fb_rectangle.drawBM, B_READ, fbmap))
		return error;
	if (error = fblocksbitmap(&fbp->fb_rectangle.ptnBM, B_WRITE, fbmap + 1))
		return error;

	if (fbp->fb_rectangle.drawBM.type == BM_MEM ||
	    fbp->fb_rectangle.ptnBM.type == BM_MEM) {
		fbdolock();
		fbstart(fbp, 1);
		fbunlock();
	} else {
		fbstart(fbp, 0);
	}

	return error;
}

fbrectangle(fbp, cmd)
	struct fbreg *fbp;
	register sPrimRect *cmd;
{
	lPrimRect lcmd;
	register lPrimRect *lcmdp;

	lcmdp = &lcmd;

	lcmdp->func = cmd->func;
	lcmdp->transp = cmd->transp;
	lcmdp->fore_color = cmd->fore_color;
	lcmdp->aux_color = cmd->aux_color;
	lcmdp->planemask = cmd->planemask;
	lcmdp->rect.origin.x = cmd->rect.origin.x;
	lcmdp->rect.origin.y = cmd->rect.origin.y;
	lcmdp->rect.extent.x = cmd->rect.extent.x;
	lcmdp->rect.extent.y = cmd->rect.extent.y;
	lcmdp->refPoint.x = cmd->refPoint.x;
	lcmdp->refPoint.y = cmd->refPoint.y;
	lcmdp->ptnRect.origin.x = cmd->ptnRect.origin.x;
	lcmdp->ptnRect.origin.y = cmd->ptnRect.origin.y;
	lcmdp->ptnRect.extent.x = cmd->ptnRect.extent.x;
	lcmdp->ptnRect.extent.y = cmd->ptnRect.extent.y;
	lcmdp->ptnBM.type = cmd->ptnBM.type;
	lcmdp->ptnBM.depth = cmd->ptnBM.depth;
	lcmdp->ptnBM.width = cmd->ptnBM.width;
	lcmdp->ptnBM.rect.origin.x = cmd->ptnBM.rect.origin.x;
	lcmdp->ptnBM.rect.origin.y = cmd->ptnBM.rect.origin.y;
	lcmdp->ptnBM.rect.extent.x = cmd->ptnBM.rect.extent.x;
	lcmdp->ptnBM.rect.extent.y = cmd->ptnBM.rect.extent.y;
	lcmdp->ptnBM.base = cmd->ptnBM.base;
	lcmdp->drawBM.type = cmd->drawBM.type;
	lcmdp->drawBM.depth = cmd->drawBM.depth;
	lcmdp->drawBM.width = cmd->drawBM.width;
	lcmdp->drawBM.rect.origin.x = cmd->drawBM.rect.origin.x;
	lcmdp->drawBM.rect.origin.y = cmd->drawBM.rect.origin.y;
	lcmdp->drawBM.rect.extent.x = cmd->drawBM.rect.extent.x;
	lcmdp->drawBM.rect.extent.y = cmd->drawBM.rect.extent.y;
	lcmdp->drawBM.base = cmd->drawBM.base;
	lcmdp->clip.origin.x = cmd->clip.origin.x;
	lcmdp->clip.origin.y = cmd->clip.origin.y;
	lcmdp->clip.extent.x = cmd->clip.extent.x;
	lcmdp->clip.extent.y = cmd->clip.extent.y;
	return (fbnrectangle(fbp, lcmdp));
}

fbnpolymarker(fbp, cmd, seg)
	register struct fbreg *fbp;
	register lPrimMarker *cmd;
	int seg;
{
	register int error;
	register int len;

#ifdef CPU_DOUBLE
	int blttype = BLTTYPE(cmd->ptnBM.type, cmd->drawBM.type);

	if ((blttype == BLTTYPE(BM_MEM, BM_MEM)) ||
	    (blttype == BLTTYPE(BM_0, BM_MEM)) ||
	    (blttype == BLTTYPE(BM_1, BM_MEM))) {
		return(mfbnpolymarker(fbp, cmd, seg));
		/* NOTREACHED */
	}
#endif /* CPU_DOUBLE */

	fbinitlock();
	fbp->fb_command = FB_CPOLYMARKER;
	fbp->fb_polymarker = *cmd;

#ifdef CPU_SINGLE
	if (error = fblocksbitmap(&fbp->fb_polymarker.ptnBM, B_WRITE, fbmap))
		return error;
	if (error = fblocksbitmap(&fbp->fb_polymarker.drawBM, B_READ, fbmap+1))
		return error;
	if ((len = cmd->np * sizeof(lPoint)) <= 0)
		return EINVAL;
	if (error = fblockmem(cmd->plist, len, B_WRITE, fbmap + 2, seg))
		return error;
	fbp->fb_polymarker.plist = (lPoint *)ipc_phys(fbmap + 2);

	fbdolock();
	fbstart(fbp, 1);
	fbunlock();
#else /* CPU_SINGLE */
	fbp->fb_polymarker.plist = (lPoint *)ipc_phys(srcdestlist);
	while (cmd->np > 0) {
		len = min(cmd->np, (MAX_SIZE / sizeof(lPoint)));
		fbp->fb_polymarker.np = len;
		if (error = COPYIN((caddr_t)cmd->plist, (caddr_t)srcdestlist,
				   len * sizeof(lPoint), seg)) {
			return error;
		}
		cmd->np -= len;
		cmd->plist += len;

		if (fbp->fb_polymarker.ptnBM.type == BM_MEM ||
		    fbp->fb_polymarker.drawBM.type == BM_MEM) {

			if (error = fblocksbitmap(&fbp->fb_polymarker.ptnBM,
						  B_WRITE, fbmap)) {
				return error;
			}
			if (error = fblocksbitmap(&fbp->fb_polymarker.drawBM,
						  B_READ, fbmap + 1)) {
				return error;
			}

			fbdolock();
			fbstart(fbp, 1);
			fbunlock();
		} else if (cmd->np)
			fbstart(fbp, 1);
		else
			fbstart(fbp, 0);
	}
#endif /* CPU_SINGLE */
	return error;
}

fbpolymarker(fbp, cmd)
	struct fbreg *fbp;
	register sPrimMarker *cmd;
{
	lPrimMarker lcmd;
	register lPrimMarker *lcmdp;
	static lPoint pl[100];
	register lPoint *lp;
	register sPoint *sp;
	register int np;

	lcmdp = &lcmd;
	lcmdp->func = cmd->func;
	lcmdp->transp = cmd->transp;
	lcmdp->fore_color = cmd->fore_color;
	lcmdp->aux_color = cmd->aux_color;
	lcmdp->planemask = cmd->planemask;
	lcmdp->ptnRect.origin.x = cmd->ptnRect.origin.x;
	lcmdp->ptnRect.origin.y = cmd->ptnRect.origin.y;
	lcmdp->ptnRect.extent.x = cmd->ptnRect.extent.x;
	lcmdp->ptnRect.extent.y = cmd->ptnRect.extent.y;