mirror of
https://github.com/Stichting-MINIX-Research-Foundation/xsrc.git
synced 2025-09-17 08:34:40 -04:00
396 lines
10 KiB
C
396 lines
10 KiB
C
/* $NetBSD: px.h,v 1.3 2008/04/28 20:57:37 martin Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2001, 2002 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Andrew Doran.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
|
|
#include <dev/wscons/wsconsio.h>
|
|
|
|
#include <dev/tc/sticreg.h>
|
|
#include <dev/tc/sticio.h>
|
|
|
|
#include "X.h"
|
|
#include "gcstruct.h"
|
|
#include "misc.h"
|
|
#include "window.h"
|
|
#include "windowstr.h"
|
|
|
|
#define PSZ 32
|
|
|
|
#define PX_DEBUG
|
|
/*
|
|
#define PX_STATS
|
|
*/
|
|
|
|
#ifdef PX_DEBUG
|
|
#define PX_DPRINTF(x) ErrorF x
|
|
#else
|
|
#define PX_DPRINTF(x)
|
|
#endif
|
|
|
|
#if 0
|
|
#define PX_TRACE(x) ErrorF("TRACE: %s()\n", x)
|
|
#else
|
|
#define PX_TRACE(x)
|
|
#endif
|
|
|
|
#define PX_DUPBYTE(x) ((((x)&0xff)<<16) | (((x)&0xff)<<8) | ((x)&0xff))
|
|
|
|
#ifdef __alpha__
|
|
#define px_mb() __asm__ __volatile__("mb" : : : "memory")
|
|
#elif defined __mips__
|
|
/* XXX */
|
|
#define px_mb()
|
|
#else
|
|
#error No support for your architecture
|
|
#endif
|
|
|
|
/* ============================================================== */
|
|
|
|
extern int pxGCPrivateIndex;
|
|
extern int pxWindowPrivateIndex;
|
|
extern int pxScreenPrivateIndex;
|
|
|
|
#define pxGetGCPrivate(g) \
|
|
((pxPrivGCPtr)(g)->devPrivates[pxGCPrivateIndex].ptr)
|
|
#define pxGetScreenPrivate(g) \
|
|
((pxPrivScreenPtr)(g)->devPrivates[pxScreenPrivateIndex].ptr)
|
|
|
|
#define pxGetWindowPrivate(g) \
|
|
((pxPrivWinPtr)(g)->devPrivates[pxWindowPrivateIndex].ptr)
|
|
|
|
typedef struct {
|
|
u_int32_t fg;
|
|
u_int32_t bg;
|
|
u_int16_t data[16];
|
|
} pxMaskRec, *pxMaskPtr;
|
|
|
|
typedef struct {
|
|
u_int32_t *ptr;
|
|
u_int paddr;
|
|
int bufnum;
|
|
int ident;
|
|
} pxImgBuf, *pxImgBufPtr;
|
|
|
|
typedef struct pxScreenPriv {
|
|
int stampw;
|
|
int stamph;
|
|
int stamphm;
|
|
int bpp;
|
|
int realbpp;
|
|
int queueing;
|
|
int pbsel;
|
|
int ibsel;
|
|
int nbuf;
|
|
pxImgBuf ib[2];
|
|
u_int32_t *buf;
|
|
u_int buf_pa;
|
|
|
|
volatile struct stic_xcomm *sxc;
|
|
volatile struct stic_regs *stic;
|
|
volatile u_int32_t *poll;
|
|
|
|
void (*expandBuf)(void *, void *, int);
|
|
void *(*compressBuf)(void *, void *, int);
|
|
void (*tileBuf)(void *, void *, int, int, int);
|
|
|
|
int fd;
|
|
int mapfd;
|
|
size_t maplen;
|
|
Bool (*CloseScreen)(int, ScreenPtr);
|
|
} pxScreenPriv, *pxScreenPrivPtr;
|
|
|
|
typedef struct pxPrivGC {
|
|
u_int32_t umet;
|
|
int pmask;
|
|
u_int fgPixel;
|
|
u_int bgPixel;
|
|
u_int fgFill;
|
|
int type;
|
|
int fillStyle;
|
|
void (*doFillSpans)(DrawablePtr, GCPtr, struct pxPrivGC *,
|
|
BoxPtr, int, DDXPointPtr, int *);
|
|
pxMaskRec mask;
|
|
pxScreenPrivPtr sp;
|
|
} pxPrivGCRec, *pxPrivGCPtr;
|
|
|
|
typedef struct {
|
|
Bool haveMask;
|
|
pxMaskRec mask;
|
|
} pxPrivWinRec, *pxPrivWinPtr;
|
|
|
|
/* ============================================================== */
|
|
|
|
typedef struct {
|
|
u_int32_t *head;
|
|
u_int32_t *curpb;
|
|
int hdrsz;
|
|
int primcnt;
|
|
int primsz;
|
|
int maxprimcnt;
|
|
int bufnum;
|
|
int ident;
|
|
} pxPacket, *pxPacketPtr;
|
|
|
|
u_int32_t *pxPacketStart(pxScreenPrivPtr, pxPacketPtr, int, int);
|
|
static u_int32_t *pxPacketAddPrim(pxScreenPrivPtr, pxPacketPtr);
|
|
void pxPacketAddPrim0(pxScreenPrivPtr, pxPacketPtr);
|
|
void pxPacketFlush(pxScreenPrivPtr, pxPacketPtr);
|
|
void pxPacketFlushWait(pxScreenPrivPtr, pxPacketPtr);
|
|
void pxPacketWait(pxScreenPrivPtr, pxPacketPtr);
|
|
|
|
static __inline__ u_int32_t *
|
|
pxPacketAddPrim(pxScreenPrivPtr sp, pxPacketPtr pp)
|
|
{
|
|
u_int32_t *npb;
|
|
|
|
if (pp->primcnt == pp->maxprimcnt)
|
|
pxPacketAddPrim0(sp, pp);
|
|
|
|
pp->primcnt++;
|
|
npb = pp->curpb;
|
|
pp->curpb += pp->primsz;
|
|
return (npb);
|
|
}
|
|
|
|
static __inline__ pxImgBufPtr
|
|
pxAllocImgBuf(pxScreenPrivPtr sp)
|
|
{
|
|
pxImgBufPtr ib;
|
|
volatile struct stic_xcomm *sxc;
|
|
|
|
if (!sp->queueing)
|
|
return (&sp->ib[sp->ibsel ^= 1]);
|
|
|
|
sxc = sp->sxc;
|
|
for (;;) {
|
|
/* XXX Potential for stall? */
|
|
ib = &sp->ib[0];
|
|
if (sxc->sxc_done[ib->bufnum] != ib->ident)
|
|
break;
|
|
|
|
ib = &sp->ib[1];
|
|
if (sxc->sxc_done[ib->bufnum] != ib->ident)
|
|
break;
|
|
}
|
|
return (ib);
|
|
}
|
|
|
|
static __inline__ void
|
|
pxAssociateImgBuf(pxScreenPrivPtr sp, pxImgBufPtr ib, pxPacketPtr pp)
|
|
{
|
|
|
|
ib->bufnum = pp->bufnum;
|
|
ib->ident = pp->ident;
|
|
}
|
|
|
|
static __inline__ u_int32_t
|
|
pxVirtToStic(pxScreenPrivPtr sp, u_int32_t *p)
|
|
{
|
|
u_int32_t v;
|
|
|
|
v = (u_long)p - (u_long)sp->sxc + sp->buf_pa;
|
|
v = ((v & 0x00600000) << 6) | ((v & 0x001f8000) << 3) | (v & 0x7fff);
|
|
return (v);
|
|
}
|
|
|
|
static __inline__ void
|
|
pxAddLine(pxScreenPrivPtr sp, pxPacketPtr pp, int x1, int y1,
|
|
int x2, int y2)
|
|
{
|
|
u_int32_t *pb;
|
|
|
|
pb = pxPacketAddPrim(sp, pp);
|
|
pb[0] = (x1 << 19) | (y1 << 3);
|
|
pb[1] = (x2 << 19) | (y2 << 3);
|
|
}
|
|
|
|
static __inline__ void
|
|
pxAddLineC(pxScreenPrivPtr sp, pxPacketPtr pp, int x1, int y1, int x2,
|
|
int y2, int c)
|
|
{
|
|
u_int32_t *pb;
|
|
|
|
pb = pxPacketAddPrim(sp, pp);
|
|
pb[0] = (x1 << 19) | (y1 << 3);
|
|
pb[1] = (x2 << 19) | (y2 << 3);
|
|
pb[2] = c;
|
|
}
|
|
|
|
/* ============================================================== */
|
|
|
|
/*
|
|
* pxgc.c
|
|
*/
|
|
extern const int pxRopTable[16];
|
|
|
|
Bool pxCreateGC(GCPtr);
|
|
|
|
/*
|
|
* pxwindow.c
|
|
*/
|
|
Bool pxCreateWindow(WindowPtr);
|
|
Bool pxDestroyWindow(WindowPtr);
|
|
Bool pxPositionWindow(WindowPtr, int, int);
|
|
Bool pxChangeWindowAttributes(WindowPtr, unsigned long);
|
|
void pxCopyWindow(WindowPtr, DDXPointRec, RegionPtr);
|
|
void pxPaintWindowBackground(WindowPtr, RegionPtr, int);
|
|
void pxPaintWindowBorder(WindowPtr, RegionPtr, int);
|
|
|
|
/*
|
|
* pxmisc.c
|
|
*/
|
|
void pxFillBoxSolid(pxScreenPrivPtr, RegionPtr, u_int);
|
|
void pxFillBoxTiled(pxScreenPrivPtr, RegionPtr, pxMaskPtr);
|
|
Bool pxMaskFromStipple(pxScreenPrivPtr, PixmapPtr, pxMaskPtr, int, int);
|
|
Bool pxMaskFromTile(pxScreenPrivPtr, PixmapPtr, pxMaskPtr);
|
|
void pxTileBuf24r24(void *, void *, int, int, int);
|
|
void pxTileBuf8r24(void *, void *, int, int, int);
|
|
void pxTileBuf8r8(void *, void *, int, int, int);
|
|
void pxStippleBuf(PixmapPtr, u_int32_t *, int, int, u_int32_t, u_int32_t,
|
|
int, int);
|
|
void pxStippleBufOpaque(PixmapPtr, u_int32_t *, int, int, u_int32_t,
|
|
u_int32_t, int, int);
|
|
void *pxCompressBuf24to24(void *, void *, int);
|
|
void *pxCompressBuf24to8(void *, void *, int);
|
|
void pxExpandBuf24to24(void *, void *, int);
|
|
void pxExpandBuf8to8(void *, void *, int);
|
|
void pxExpandBuf8to24(void *, void *, int);
|
|
|
|
/*
|
|
* pxbitblt.c
|
|
*/
|
|
RegionPtr pxCopyArea(DrawablePtr, DrawablePtr, GCPtr, int, int, int,
|
|
int, int, int);
|
|
void pxDoBitblt(DrawablePtr, DrawablePtr, int, RegionPtr,
|
|
DDXPointPtr, unsigned long);
|
|
|
|
/*
|
|
* pxfillrct.c
|
|
*/
|
|
void pxPolyFillRect(DrawablePtr, GCPtr, int, xRectangle *);
|
|
void pxPolyFillRectS(DrawablePtr, GCPtr, int, xRectangle *);
|
|
void pxPolyFillRectSO(DrawablePtr, GCPtr, int, xRectangle *);
|
|
|
|
/*
|
|
* pxline.c
|
|
*/
|
|
void pxPolySegment(DrawablePtr, GCPtr, int, xSegment *);
|
|
void pxPolylines(DrawablePtr, GCPtr, int, int, DDXPointPtr);
|
|
void pxPolySegmentD(DrawablePtr, GCPtr, int, xSegment *);
|
|
void pxPolylinesD(DrawablePtr, GCPtr, int, int, DDXPointPtr);
|
|
|
|
/*
|
|
* pxbresd.c
|
|
*/
|
|
void pxBresD(pxScreenPrivPtr, pxPacketPtr, pxPrivGCPtr, int *,
|
|
unsigned char *, int, int *, int, int, int, int, int, int,
|
|
int, int, int, int);
|
|
|
|
/*
|
|
* pxpolypnt.c
|
|
*/
|
|
void pxPolyPoint(DrawablePtr, GCPtr, int, int, xPoint *);
|
|
|
|
/*
|
|
* pxpushpxl.c
|
|
*/
|
|
void pxSolidPP(GCPtr, PixmapPtr, DrawablePtr, int, int, int, int);
|
|
void pxSqueege(pxScreenPrivPtr, pxPacketPtr, u_int8_t *, int,
|
|
int, int, int, int, int, int, int);
|
|
void pxSqueege16(pxScreenPrivPtr, pxPacketPtr, u_int8_t *, int,
|
|
int, int, int, int, int, int, int);
|
|
|
|
/*
|
|
* pxsetsp.c
|
|
*/
|
|
void pxSetScanline(pxScreenPrivPtr, int, int, int, int, int *, int,
|
|
unsigned long);
|
|
void pxSetScanlineRaw(pxScreenPrivPtr, int, int, int, int, unsigned long,
|
|
pxImgBufPtr);
|
|
void pxSetSpans(DrawablePtr, GCPtr, char *, DDXPointPtr ppt, int *,
|
|
int, int);
|
|
|
|
/*
|
|
* pxfillsp.c
|
|
*/
|
|
void pxFillSpans(DrawablePtr, GCPtr, int, DDXPointPtr, int *, int);
|
|
|
|
void pxDoFillSpans(DrawablePtr, GCPtr, pxPrivGCPtr,
|
|
BoxPtr, int, DDXPointPtr, int *);
|
|
void pxDoFillSpansS(DrawablePtr, GCPtr, pxPrivGCPtr,
|
|
BoxPtr, int, DDXPointPtr, int *);
|
|
void pxDoFillSpansT(DrawablePtr, GCPtr, pxPrivGCPtr,
|
|
BoxPtr, int, DDXPointPtr, int *);
|
|
void pxDoFillSpansUS(DrawablePtr, GCPtr, pxPrivGCPtr,
|
|
BoxPtr, int, DDXPointPtr, int *);
|
|
|
|
/*
|
|
* pxgetsp.c
|
|
*/
|
|
void pxGetSpans(DrawablePtr, int, DDXPointPtr, int *, int, char *);
|
|
void pxGetScanlineRaw(pxScreenPrivPtr, int, int, int, pxImgBufPtr);
|
|
|
|
/*
|
|
* pxglyph.c
|
|
*/
|
|
void pxPolyTEGlyphBlt(DrawablePtr, GCPtr, int, int, unsigned int,
|
|
CharInfoPtr *, pointer);
|
|
void pxImageTEGlyphBlt(DrawablePtr, GCPtr, int, int, unsigned int,
|
|
CharInfoPtr *, pointer);
|
|
|
|
void pxPolyGlyphBlt(DrawablePtr, GCPtr, int, int, unsigned int,
|
|
CharInfoPtr *, pointer);
|
|
void pxImageGlyphBlt(DrawablePtr, GCPtr, int, int, unsigned int,
|
|
CharInfoPtr *, pointer);
|
|
|
|
void pxSlowPolyGlyphBlt(DrawablePtr, GCPtr, int, int, unsigned int,
|
|
CharInfoPtr *, pointer);
|
|
void pxSlowImageGlyphBlt(DrawablePtr, GCPtr, int, int, unsigned int,
|
|
CharInfoPtr *, pointer);
|
|
|
|
/*
|
|
* pximage.c
|
|
*/
|
|
void pxGetImage(DrawablePtr, int, int, int, int, unsigned int,
|
|
unsigned long, char *);
|
|
|
|
/*
|
|
* pxzerarc.c
|
|
*/
|
|
void pxZeroPolyArc(DrawablePtr, GCPtr, int, xArc *);
|
|
|
|
/*
|
|
* pxfillarc.c
|
|
*/
|
|
void pxPolyFillArc(DrawablePtr, GCPtr, int, xArc *);
|