fb_sub.c

早期freebsd实现

		regcmd->srcBitmap.depth = 1;
		regcmd->destBitmap.depth = 1;
		pmask = regcmd->planemask;
		if (mode == 2) {	/* N to 1 */
			regcmd->fore_color = 0xff;
			regcmd->aux_color = 0;
			for (i = 0; i < cmd->srcBitmap.depth; i++)
				if (pmask & (1 << i))
					break;
			if (i >= cmd->srcBitmap.depth)
				return 0;
			regcmd->srcBitmap.base += (lens >> 1) * i;
			error = dobitblt(fbp, &regcmd->srcBitmap,
					      &regcmd->destBitmap);
			return error;
		} else if (mode == 1) {	/* 1 to N */
			for (i = 0; i < cmd->srcBitmap.depth; i++) {
				if (error = dobitblt(fbp, &regcmd->srcBitmap,
							  &regcmd->destBitmap))
					return error;
				regcmd->planemask >>= 1;
				regcmd->fore_color >>= 1;
				regcmd->aux_color >>= 1;
				regcmd->destBitmap.base += lend >> 1;
			}
			return 0;
		} else {		/* N to N */
			regcmd->fore_color = 0xff;
			regcmd->aux_color = 0;
			for (i = 0; i < cmd->srcBitmap.depth; i++) {
				if (error = dobitblt(fbp, &regcmd->srcBitmap,
							  &regcmd->destBitmap))
					return error;
				regcmd->srcBitmap.base += lens >> 1;
				regcmd->destBitmap.base += lend >> 1;
				regcmd->planemask >>= 1;
			}
			return 0;
		}
		break;

	default:
		return EINVAL;
	}

	return error;
}

fbbitblt(fbp, cmd)
	struct fbreg *fbp;
	register sBitblt *cmd;
{
	lBitblt lcmd;
	register lBitblt *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->srcBitmap.type = cmd->srcBitmap.type;
	lcmdp->srcBitmap.depth = cmd->srcBitmap.depth;
	lcmdp->srcBitmap.width = cmd->srcBitmap.width;
	lcmdp->srcBitmap.rect.origin.x = cmd->srcBitmap.rect.origin.x;
	lcmdp->srcBitmap.rect.origin.y = cmd->srcBitmap.rect.origin.y;
	lcmdp->srcBitmap.rect.extent.x = cmd->srcBitmap.rect.extent.x;
	lcmdp->srcBitmap.rect.extent.y = cmd->srcBitmap.rect.extent.y;
	lcmdp->srcBitmap.base = cmd->srcBitmap.base;
	lcmdp->srcRect.origin.x = cmd->srcRect.origin.x;
	lcmdp->srcRect.origin.y = cmd->srcRect.origin.y;
	lcmdp->srcRect.extent.x = cmd->srcRect.extent.x;
	lcmdp->srcRect.extent.y = cmd->srcRect.extent.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->destPoint.x = cmd->destPoint.x;
	lcmdp->destPoint.y = cmd->destPoint.y;
	return (fbnbitblt(fbp, lcmdp));
}

procbatchbitblt(fbp, mode, cmd)
	struct fbreg *fbp;
	int mode;
	register lBatchBitblt *cmd;
{
	register lBatchBitblt *regcmd;
	register int len, lens, lend;
	register int i;
	int pmask;
	int error = 0;

	regcmd = &fbp->fb_batchbitblt;
	/* process batch bitblt command */
	switch (BLTTYPE(regcmd->srcBitmap.type, regcmd->destBitmap.type)) {
	case BLTTYPE(BM_FB, BM_FB):
	case BLTTYPE(BM_0, BM_FB):
	case BLTTYPE(BM_1, BM_FB):
		fbdolock();
		fbstart(fbp, cmd->nSrcDest);
		fbunlock();
		break;

	case BLTTYPE(BM_FB, BM_MEM):
	case BLTTYPE(BM_0, BM_MEM):
	case BLTTYPE(BM_1, BM_MEM):
		len = cmd->destBitmap.width * cmd->destBitmap.rect.extent.y << 1;
		if (len * cmd->destBitmap.depth <= FB_MAX_IO) {
			error = dobitblt(fbp, &regcmd->srcBitmap,
					      &regcmd->destBitmap);
			return error;
		}

		/* bitblt each plane */
		regcmd->destBitmap.depth = 1;
		pmask = regcmd->planemask;
		for (i = 0; i < cmd->destBitmap.depth; i++) {
			if (mode == 3)	/* N to N */
				regcmd->planemask = pmask & (1 << i);

			if (error = dobitblt(fbp, &regcmd->srcBitmap,
						  &regcmd->destBitmap))
				return error;

			regcmd->destBitmap.base += len >> 1;
			if (mode == 1) {	/* N to N */
				regcmd->planemask >>= 1;
				regcmd->fore_color >>= 1;
				regcmd->aux_color >>= 1;
			}
		}
		break;

	case BLTTYPE(BM_MEM, BM_FB):
		len = cmd->srcBitmap.width * cmd->srcBitmap.rect.extent.y << 1;

		if (len * cmd->srcBitmap.depth <= FB_MAX_IO) {
			error = dobitblt(fbp, &regcmd->srcBitmap,
					      &regcmd->destBitmap);
			return error;
		}

		/* bitblt each plane */
		regcmd->srcBitmap.depth = 1;
		pmask = regcmd->planemask;
		regcmd->fore_color = 0xff;
		regcmd->aux_color = 0;
		if (mode == 2) {	/* N to 1 */
			for (i = 0; i < cmd->srcBitmap.depth; i++)
				if (pmask & (1 << i))
					break;
			if (i >= cmd->srcBitmap.depth)
				return 0;
			regcmd->srcBitmap.base += (len >> 1) * i;
			error = dobitblt(fbp, &regcmd->srcBitmap,
					      &regcmd->destBitmap);
			return error;
		}
		/* else (N to N) */
		for (i = 0; i < cmd->srcBitmap.depth; i++) {
			regcmd->planemask = pmask & (1 << i);
			if (error = dobitblt(fbp, &regcmd->srcBitmap,
						  &regcmd->destBitmap))
				return error;
			regcmd->srcBitmap.base += len >> 1;
			regcmd->planemask >>= 1;
		}
		return 0;

	case BLTTYPE(BM_MEM, BM_MEM):
		lens = cmd->srcBitmap.width * cmd->srcBitmap.rect.extent.y << 1;
		lend = cmd->destBitmap.width * cmd->destBitmap.rect.extent.y << 1;
		if (lens * cmd->srcBitmap.depth <= FB_MAX_IO &&
		    lend * cmd->destBitmap.depth <= FB_MAX_IO) {
			error = dobitblt(fbp, &regcmd->srcBitmap,
					      &regcmd->destBitmap);
			return error;
		}

		regcmd->srcBitmap.depth = 1;
		regcmd->destBitmap.depth = 1;
		pmask = regcmd->planemask;
		if (mode == 2) {	/* N to 1 */
			regcmd->fore_color = 0xff;
			regcmd->aux_color = 0;
			for (i = 0; i < cmd->srcBitmap.depth; i++)
				if (pmask & (1 << i))
					break;
			if (i >= cmd->srcBitmap.depth)
				return 0;
			regcmd->srcBitmap.base += (lens >> 1) * i;
			error = dobitblt(fbp, &regcmd->srcBitmap,
					      &regcmd->destBitmap);
			return error;
		} else if (mode == 1) {	/* 1 to N */
			for (i = 0; i < cmd->srcBitmap.depth; i++) {
				if (error = dobitblt(fbp, &regcmd->srcBitmap,
							  &regcmd->destBitmap))
					return error;
				regcmd->planemask >>= 1;
				regcmd->fore_color >>= 1;
				regcmd->aux_color >>= 1;
				regcmd->destBitmap.base += lend >> 1;
			}
			return 0;
		} else {		/* N to N */
			regcmd->fore_color = 0xff;
			regcmd->aux_color = 0;
			for (i = 0; i < cmd->srcBitmap.depth; i++) {
				if (error = dobitblt(fbp, &regcmd->srcBitmap,
							  &regcmd->destBitmap))
					return error;
				regcmd->srcBitmap.base += lens >> 1;
				regcmd->destBitmap.base += lend >> 1;
				regcmd->planemask >>= 1;
			}
			return 0;
		}
		break;

	default:
		return EINVAL;
	}

	return error;
}

fbnbatchbitblt(fbp, cmd, seg)
	register struct fbreg *fbp;
	register lBatchBitblt *cmd;
	int seg;
{
	register int error;
	register int mode;
	register int len;

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

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

	fbinitlock();
	fbp->fb_command = FB_CBATCHBITBLT;
	fbp->fb_batchbitblt = *cmd;

	if (error = checkbitmap(&cmd->srcBitmap))
		return error;
	if (error = checkbitmap(&cmd->destBitmap))
		return error;
	if ((mode = checkdepth(&cmd->srcBitmap, &cmd->destBitmap)) < 0)
		return EINVAL;

#ifdef CPU_SINGLE
	if ((len = cmd->nSrcDest * sizeof(lSrcDest)) <= 0)
		return EINVAL;
	if (error = fblockmem((caddr_t)cmd->srcDestList,
			      len, B_WRITE, fbmap + 2, seg))
		return error;
	fbp->fb_batchbitblt.srcDestList = (lSrcDest *)ipc_phys(fbmap + 2);
	error = procbatchbitblt(fbp, mode, cmd);
#else
	fbp->fb_batchbitblt.srcDestList = (lSrcDest*)ipc_phys(srcdestlist);
	while(cmd->nSrcDest > 0) {
		len = min(cmd->nSrcDest, (MAX_SIZE / sizeof(lSrcDest)));
		error = COPYIN((caddr_t)cmd->srcDestList, (caddr_t)srcdestlist,
				len * sizeof(lSrcDest), seg);
		if (error)
			return error;
		cmd->nSrcDest -= len;
		cmd->srcDestList += len;
		fbp->fb_batchbitblt.nSrcDest = len;

		if (error = procbatchbitblt(fbp, mode, cmd))
			return error;
	}
#endif /* CPU_DOUBLE */
	return error;
}

fbbatchbitblt(fbp, cmd)
	struct fbreg *fbp;
	register sBatchBitblt *cmd;
{
	lBatchBitblt lcmd;
	register lBatchBitblt *lcmdp;
	static lSrcDest ls[100];
	register lSrcDest *lp;
	register sSrcDest *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->srcBitmap.type = cmd->srcBitmap.type;
	lcmdp->srcBitmap.depth = cmd->srcBitmap.depth;
	lcmdp->srcBitmap.width = cmd->srcBitmap.width;
	lcmdp->srcBitmap.rect.origin.x = cmd->srcBitmap.rect.origin.x;
	lcmdp->srcBitmap.rect.origin.y = cmd->srcBitmap.rect.origin.y;
	lcmdp->srcBitmap.rect.extent.x = cmd->srcBitmap.rect.extent.x;
	lcmdp->srcBitmap.rect.extent.y = cmd->srcBitmap.rect.extent.y;
	lcmdp->srcBitmap.base = cmd->srcBitmap.base;
	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->srcDestList = ls;
	sp = (sSrcDest *)cmd->srcDestList;
	while (cmd->nSrcDest) {
		lcmdp->nSrcDest = ns = min(cmd->nSrcDest, 100);
		cmd->nSrcDest -= ns;
		lp = ls;
		while (ns-- > 0) {
			int error;
			sSrcDest tmp;

			error = copyin((caddr_t)sp, (caddr_t)&tmp, sizeof(tmp));
			if (error)
				return (error);
			lp->srcRect.origin.x = tmp.srcRect.origin.x;
			lp->srcRect.origin.y = tmp.srcRect.origin.y;
			lp->srcRect.extent.x = tmp.srcRect.extent.x;
			lp->srcRect.extent.y = tmp.srcRect.extent.y;
			lp->destPoint.x = tmp.destPoint.x;
			lp->destPoint.y = tmp.destPoint.y;
			lp++;
			sp++;
		}
		fbnbatchbitblt(fbp, lcmdp, UIO_SYSSPACE);
	}
}

fbntilebitblt(fbp, cmd)
	register struct fbreg *fbp;
	register lTileBitblt *cmd;
{
	register lTileBitblt *regcmd;
	register int len, lens, lend;
	register int i;
	int mode;
	int pmask;
	int error;
	int blttype = BLTTYPE(cmd->ptnBitmap.type, cmd->destBitmap.type);

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

	if (error = checkbitmap(&cmd->ptnBitmap))
		return error;
	if (error = checkbitmap(&cmd->destBitmap))
		return error;
	if ((mode = checkdepth(&cmd->ptnBitmap, &cmd->destBitmap)) < 0)
		return EINVAL;

	fbp->fb_command = FB_CTILEBITBLT;
	fbp->fb_tilebitblt = *cmd;
	regcmd = &fbp->fb_tilebitblt;

	/* process bitblt command */
	switch (blttype) {
	case BLTTYPE(BM_FB, BM_FB):
	case BLTTYPE(BM_0, BM_FB):
	case BLTTYPE(BM_1, BM_FB):
		fbstart(fbp, 0);
		break;

	case BLTTYPE(BM_FB, BM_MEM):
	case BLTTYPE(BM_0, BM_MEM):
	case BLTTYPE(BM_1, BM_MEM):
		len = cmd->destBitmap.width * cmd->destBitmap.rect.extent.y << 1;
		if (len * cmd->destBitmap.depth <= FB_MAX_IO) {
			error = dobitblt(fbp, &regcmd->ptnBitmap,
					      &regcmd->destBitmap);
			return error;
		}

		/* bitblt each plane */
		regcmd->destBitmap.depth = 1;
		pmask = regcmd->planemask;
		for (i = 0; i < cmd->destBitmap.depth; i++) {
			if (mode == 3)	/* N to N */
				regcmd->planemask = pmask & (1 << i);

			if (error = dobitblt(fbp, &regcmd->ptnBitmap,
						  &regcmd->destBitmap))
				return error;

			regcmd->destBitmap.base += len >> 1;
			if (mode == 1) {	/* N to N */
				regcmd->planemask >>= 1;
				regcmd->fore_color >>= 1;
				regcmd->aux_color >>= 1;
			}
		}
		break;

	case BLTTYPE(BM_MEM, BM_FB):
		len = cmd->ptnBitmap.width * cmd->ptnBitmap.rect.extent.y << 1;

		if (len * cmd->ptnBitmap.depth <= FB_MAX_IO) {
			error = dobitblt(fbp, &regcmd->ptnBitmap,
					      &regcmd->destBitmap);
			return error;
		}

		/* bitblt each plane */
		regcmd->ptnBitmap.depth = 1;
		pmask = regcmd->planemask;
		regcmd->fore_color = 0xff;
		regcmd->aux_color = 0;
		if (mode == 2) {	/* N to 1 */
			for (i = 0; i < cmd->ptnBitmap.depth; i++)
				if (pmask & (1 << i))
					break;
			if (i >= cmd->ptnBitmap.depth)
				return 0;
			regcmd->ptnBitmap.base += (len >> 1) * i;
			error = dobitblt(fbp, &regcmd->ptnBitmap,
					      &regcmd->destBitmap);
			return error;
		}
		/* else (N to N) */
		for (i = 0; i < cmd->ptnBitmap.depth; i++) {
			regcmd->planemask = pmask & (1 << i);
			if (error = dobitblt(fbp, &regcmd->ptnBitmap,
						  &regcmd->destBitmap))
				return error;
			regcmd->ptnBitmap.base += len >> 1;
			regcmd->planemask >>= 1;
		}
		return 0;

	case BLTTYPE(BM_MEM, BM_MEM):
		lens = cmd->ptnBitmap.width * cmd->ptnBitmap.rect.extent.y << 1;
		lend = cmd->destBitmap.width * cmd->destBitmap.rect.extent.y << 1;
		if (lens * cmd->ptnBitmap.depth <= FB_MAX_IO &&
		    lend * cmd->destBitmap.depth <= FB_MAX_IO) {
			error = dobitblt(fbp, &regcmd->ptnBitmap,
					      &regcmd->destBitmap);
			return error;
		}

		regcmd->ptnBitmap.depth = 1;
		regcmd->destBitmap.depth = 1;
		pmask = regcmd->planemask;
		if (mode == 2) {	/* N to 1 */
			regcmd->fore_color = 0xff;
			regcmd->aux_color = 0;
			for (i = 0; i < cmd->ptnBitmap.depth; i++)
				if (pmask & (1 << i))
					break;
			if (i >= cmd->ptnBitmap.depth)
				return 0;
			regcmd->ptnBitmap.base += (lens >> 1) * i;
			error = dobitblt(fbp, &regcmd->ptnBitmap,
					      &regcmd->destBitmap);
			return error;
		} else if (mode == 1) {	/* 1 to N */
			for (i = 0; i < cmd->ptnBitmap.depth; i++) {
				if (error = dobitblt(fbp, &regcmd->ptnBitmap,
							  &regcmd->destBitmap))
					return error;
				regcmd->planemask >>= 1;
				regcmd->fore_color >>= 1;
				regcmd->aux_color >>= 1;
				regcmd->destBitmap.base += lend >> 1;
			}
			return 0;
		} else {		/* N to N */
			for (i = 0; i < cmd->ptnBitmap.depth; i++) {
				if (error = dobitblt(fbp, &regcmd->ptnBitmap,
							  &regcmd->destBitmap))
					return error;
				regcmd->ptnBitmap.base += lens >> 1;
				regcmd->destBitmap.base += lend >> 1;
				regcmd->planemask >>= 1;
			}
			return 0;