xref: /xsrc/external/mit/xf86-video-suntcx/dist/src/tcx_accel.c

/*
 * TCX framebuffer - hardware acceleration.
 *
 * Copyright (C) 2009 Michael Lorenz
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * MICHAEL LORENZ BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

/* $NetBSD: tcx_accel.c,v 1.10 2016/09/23 20:50:54 macallan Exp $ */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <sys/types.h>

#include "tcx.h"

#ifdef DEBUG
#define ENTER xf86Msg(X_ERROR, "%s\n", __func__)
#define LEAVE xf86Msg(X_ERROR, "%s done\n", __func__)
#else
#define ENTER
#define LEAVE
#endif

static void
TcxWaitMarker(ScreenPtr pScreenInfo, int Marker)
{
    ENTER;
    /* do nothing */
}

static int
TcxMarkSync(ScreenPtr pScreenInfo)
{
    ENTER;
    return 0;
}

static Bool
TcxPrepareCopy
(
    PixmapPtr pSrcPixmap,
    PixmapPtr pDstPixmap,
    int       xdir,
    int       ydir,
    int       alu,
    Pixel     planemask
)
{
    ScrnInfoPtr pScreenInfo = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
    TcxPtr pTcx = GET_TCX_FROM_SCRN(pScreenInfo);

    ENTER;
    /* weed out the cases we can't accelerate */
#ifdef DEBUG
    xf86Msg(X_ERROR, "alu: %d mask %08x\n", alu, planemask);
#endif
    if (alu != GXcopy)
    	return FALSE;
    if ((planemask != 0xffffffff) && (planemask != 0x00ffffff))
	return FALSE;

    pTcx->xdir = xdir;
    pTcx->ydir = ydir;
    pTcx->srcoff = exaGetPixmapOffset(pSrcPixmap) >> pTcx->pitchshift;
    pTcx->srcpitch = exaGetPixmapPitch(pSrcPixmap) >> pTcx->pitchshift;
    LEAVE;
    return TRUE;
}

static void
TcxCopy
(
    PixmapPtr pDstPixmap,
    int       srcX,
    int       srcY,
    int       dstX,
    int       dstY,
    int       w,
    int       h
)
{
    ScrnInfoPtr pScreenInfo = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
    TcxPtr pTcx = GET_TCX_FROM_SCRN(pScreenInfo);
    volatile uint64_t cmd, lcmd;
    int line, col, leftover, src, dst, xsteps, sstep, dstep, dpitch, x, xoff;
    int doff;

    ENTER;
    leftover = w & 0x1f;
    if (leftover > 0)
	    lcmd = 0x3000000000000000LL | (leftover - 1) << 24;


    doff = exaGetPixmapOffset(pDstPixmap) >> pTcx->pitchshift;
    dpitch = exaGetPixmapPitch(pDstPixmap) >> pTcx->pitchshift;
    src = srcX + srcY * pTcx->srcpitch + pTcx->srcoff;
    dst = dstX + dstY * dpitch + doff;

    if (pTcx->ydir < 0) {
	src += (h - 1) * pTcx->srcpitch;
	dst += (h - 1) * dpitch;
	sstep = 0 - pTcx->srcpitch;
	dstep = 0 - dpitch;
    } else {
	sstep = pTcx->srcpitch;
	dstep = dpitch;
    }

    xsteps = w >> 5;

    if ((pTcx->xdir > 0) || (w < 33)) {
	for (line = 0; line < h; line++) {
	    x = xsteps;
	    xoff = 0;
	    while (x > 0) {
		cmd = 0x300000001f000000LL | (uint64_t)(src + xoff);
		pTcx->rblit[dst + xoff] = cmd;
		xoff += 32;
		x--;
	    }
	    if (leftover > 0) {
		cmd = lcmd | (uint64_t)(src + xoff);
		pTcx->rblit[dst + xoff] = cmd;
	    }
	    src += sstep;
	    dst += dstep;
	}
    } else {
	/* same thing but right to left */
	for (line = 0; line < h; line++) {
	    x = xsteps;
	    xoff = xsteps << 5;
	    if (leftover > 0) {
		cmd = lcmd | (uint64_t)(src + xoff);
		pTcx->rblit[dst + xoff] = cmd;
	    }
	    xoff -= 32;
	    while (x > 0) {
		cmd = 0x300000001f000000LL | (uint64_t)(src + xoff);
		pTcx->rblit[dst + xoff] = cmd;
		xoff -= 32;
		x--;
	    }
	    src += sstep;
	    dst += dstep;
	}
    }
    LEAVE;
}

static void
TcxDoneCopy(PixmapPtr pDstPixmap)
{
    ENTER;
    LEAVE;
}

static Bool
TcxPrepareSolid(
    PixmapPtr pPixmap,
    int alu,
    Pixel planemask,
    Pixel fg)
{
    ScrnInfoPtr pScreenInfo = xf86Screens[pPixmap->drawable.pScreen->myNum];
    TcxPtr pTcx = GET_TCX_FROM_SCRN(pScreenInfo);
    uint32_t hwfg;

    ENTER;

    /* weed out the cases we can't accelerate */
    if (pTcx->HasStipROP) {
    	hwfg = alu << 28;
    } else if (alu == GXcopy) {
        hwfg = 0x30000000;
    } else
    	return FALSE;

    if ((planemask != 0xffffffff) && (planemask != 0x00ffffff))
	return FALSE;
    if (exaGetPixmapOffset(pPixmap) != 0)
	return FALSE;
    pTcx->fg = (fg & 0x00ffffff);
    /* set colour space ID if we're in 24bit mode */
    if (pTcx->pitchshift != 0)
    	hwfg |= 0x03000000;
    pTcx->fg |= hwfg;
#ifdef DEBUG
    xf86Msg(X_ERROR, "fg: %08x\n", hwfg);
#endif
    LEAVE;
    return TRUE;
}

static void
TcxSolid(
    PixmapPtr pPixmap,
    int x1,
    int y1,
    int x2,
    int y2)
{
    ScrnInfoPtr pScreenInfo = xf86Screens[pPixmap->drawable.pScreen->myNum];
    TcxPtr pTcx = GET_TCX_FROM_SCRN(pScreenInfo);
    int dpitch, dst, line, fullsteps, i;
    volatile uint64_t cmd, rcmd, lcmd, tmpl;
    uint32_t pmask;

    dpitch = exaGetPixmapPitch(pPixmap) >> pTcx->pitchshift;
    dst = x1 + y1 * dpitch;

    tmpl = ((uint64_t)pTcx->fg) << 32;

    /*
     * thanks to the funky architecture of the tcx's stipple 'engine' we have
     * to deal with two different cases:
     * - the whole width of the rectangle fits into a single 32 pixel aligned
     *   unit of 32 pixels
     * - the first and the last 32bit unit may or may not contain less than
     *   32 pixels
     */
    x2 -= 1;
    if ((x1 & 0xffe0) == (x2 & 0xffe0)) {
	/* the whole width fits in one 32 pixel write */

	/* first zero out pixels on the right */
	pmask = 0xffffffff << (31 - (x2 & 0x1f));
	/* then mask out pixels on the left */
	pmask &= (0xffffffff >> (x1 & 0x1f));
#ifdef DEBUG
	xf86Msg(X_ERROR, "%d %d %08x %d %d\n", x1, x2, pmask, y1, y2);
#endif
	cmd = tmpl | (uint64_t)pmask;
	dst &= 0xffffffe0;
	for (line = y1; line < y2; line++) {
	    pTcx->rstip[dst] = cmd;
	    dst += dpitch;
	}
    } else {
	/* at least two writes per line */
	pmask = 0xffffffff << (31 - (x2 & 0x1f));
	rcmd = tmpl | (uint64_t)pmask;
	pmask = 0xffffffff >> (x1 & 0x1f);
	lcmd = tmpl | (uint64_t)pmask;
	cmd = tmpl | 0xffffffffLL;
	dst &= 0xffffffe0;
	fullsteps = ((x2 >> 5) - (x1 >> 5));
#ifdef DEBUG
	xf86Msg(X_ERROR, "%d %d %08x %d %d\n", x1, x2, pmask, y1, y2);
	xf86Msg(X_ERROR, "fullsteps: %d\n", fullsteps);
#endif
	fullsteps = fullsteps << 5;
	for (line = y1; line < y2; line++) {
	    pTcx->rstip[dst] = lcmd;
	    for (i = 32; i < fullsteps; i+= 32)
		pTcx->rstip[dst + i] = cmd;
	    pTcx->rstip[dst + i] = rcmd;
	    dst += dpitch;
	}
    }
}

/*
 * Memcpy-based UTS.
 */
static Bool
TcxUploadToScreen(PixmapPtr pDst, int x, int y, int w, int h,
    char *src, int src_pitch)
{
    ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
    TcxPtr pTcx       = GET_TCX_FROM_SCRN(pScrn);
    char  *dst        = pTcx->fb + exaGetPixmapOffset(pDst);
    int    dst_pitch  = exaGetPixmapPitch(pDst);

    int bpp    = pDst->drawable.bitsPerPixel;
    int cpp    = (bpp + 7) / 8;
    int wBytes = w * cpp;

    ENTER;
    dst += (x * cpp) + (y * dst_pitch);

    while (h--) {
        memcpy(dst, src, wBytes);
        src += src_pitch;
        dst += dst_pitch;
    }
    LEAVE;
    return TRUE;
}

/*
 * Memcpy-based DFS.
 */
static Bool
TcxDownloadFromScreen(PixmapPtr pSrc, int x, int y, int w, int h,
    char *dst, int dst_pitch)
{
    ScrnInfoPtr pScrn = xf86Screens[pSrc->drawable.pScreen->myNum];
    TcxPtr pTcx       = GET_TCX_FROM_SCRN(pScrn);
    char  *src        = pTcx->fb + exaGetPixmapOffset(pSrc);
    int    src_pitch  = exaGetPixmapPitch(pSrc);

    int bpp    = pSrc->drawable.bitsPerPixel;
    int cpp    = (bpp + 7) / 8;
    int wBytes = w * cpp;

    ENTER;
    src += (x * cpp) + (y * src_pitch);

    while (h--) {
        memcpy(dst, src, wBytes);
        src += src_pitch;
        dst += dst_pitch;
    }
    LEAVE;
    return TRUE;
}

Bool
TcxInitAccel(ScreenPtr pScreen)
{
    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
    TcxPtr pTcx = GET_TCX_FROM_SCRN(pScrn);
    ExaDriverPtr pExa;

    pExa = exaDriverAlloc();
    if (!pExa)
        return FALSE;

    pTcx->pExa = pExa;

    pExa->exa_major = EXA_VERSION_MAJOR;
    pExa->exa_minor = EXA_VERSION_MINOR;

    /*
     * The S24 can display both 8 and 24bit data at the same time, and in
     * 24bit we can choose between gamma corrected and direct. No idea how that
     * would map to EXA - we'd have to pick the right framebuffer to draw into
     * and Solid() would need to know what kind of pixels to write
     */
    pExa->memoryBase = pTcx->fb;
    if (pScrn->depth == 8) {
	pExa->memorySize = pTcx->vramsize;
	pExa->offScreenBase = pTcx->psdp->width * pTcx->psdp->height;
	pExa->pixmapOffsetAlign = 1;
	pExa->pixmapPitchAlign = 1;
    } else {
	pExa->memorySize = 1024 * 1024 * 4;
	pExa->offScreenBase = pTcx->psdp->width * pTcx->psdp->height * 4;
	pExa->pixmapOffsetAlign = 4;
	pExa->pixmapPitchAlign = 4;
    }

    pExa->flags = EXA_OFFSCREEN_PIXMAPS;

    pExa->maxX = 2048;
    pExa->maxY = 2048;	/* dummy, available VRAM is the limit */

    pExa->MarkSync = TcxMarkSync;
    pExa->WaitMarker = TcxWaitMarker;

    pExa->PrepareSolid = TcxPrepareSolid;
    pExa->Solid = TcxSolid;
    pExa->DoneSolid = TcxDoneCopy;

    pExa->PrepareCopy = TcxPrepareCopy;
    pExa->Copy = TcxCopy;
    pExa->DoneCopy = TcxDoneCopy;

    /* EXA hits more optimized paths when it does not have to fallback because
     * of missing UTS/DFS, hook memcpy-based UTS/DFS.
     */
    pExa->UploadToScreen = TcxUploadToScreen;
    pExa->DownloadFromScreen = TcxDownloadFromScreen;

    return exaDriverInit(pScreen, pExa);
}