frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

KDrive: Delete rafts of unused code 

Most of this stuff was gone with the last real hardware drivers that
used it.  Au revoir.
This commit is contained in:
Daniel Stone 2008-07-17 20:45:01 +03:00
parent ad7a7ae290
commit 6c7c0ffeb7
14 changed files with 0 additions and 1131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
hw/kdrive/Kdrive.tmpl
View File

@ -1,17 +0,0 @@
XCOMM $RCSId: xc/programs/Xserver/hw/kdrive/Kdrive.tmpl,v 1.3tsi Exp $
#include <Server.tmpl>
#if BuildRender
RENDERINCS=-I$(KDRIVE)/../../render
#endif
#if BuildRandR
RANDRINCS=-I$(KDRIVE)/../../randr
#endif
KDINCS = -I$(KDRIVE) -I$(XBUILDINCDIR) -I$(FONTINCSRC) \
-I$(KDRIVE)/../../fb -I$(KDRIVE)/../../mi -I$(KDRIVE)/../../Xext \
-I$(KDRIVE)/../../miext/shadow -I$(KDRIVE)/../../miext/layer \
-I$(KDRIVE)/../../include -I$(KDRIVE)/../../os \
-I$(EXTINCSRC) -I$(XINCLUDESRC) $(RENDERINCS) $(RANDRINCS)

2
hw/kdrive/ephyr/ephyr.c
View File

@ -526,8 +526,6 @@ ephyrRandRSetConfig (ScreenPtr pScreen,
scrpriv->randr = KdAddRotation (screen->randr, randr);
KdOffscreenSwapOut (screen->pScreen);
ephyrUnmapFramebuffer (screen);
screen->width = newwidth;

2
hw/kdrive/fake/fake.c
View File

@ -324,8 +324,6 @@ fakeRandRSetConfig (ScreenPtr pScreen,
scrpriv->randr = KdAddRotation (screen->randr, randr);
KdOffscreenSwapOut (screen->pScreen);
fakeUnmapFramebuffer (screen);
if (!fakeMapFramebuffer (screen))

2
hw/kdrive/fbdev/fbdev.c
View File

@ -529,8 +529,6 @@ fbdevRandRSetConfig (ScreenPtr pScreen,
scrpriv->randr = KdAddRotation (screen->randr, randr);
KdOffscreenSwapOut (screen->pScreen);
fbdevUnmapFramebuffer (screen);
if (!fbdevMapFramebuffer (screen))

3
hw/kdrive/src/Makefile.am
View File

@ -29,10 +29,7 @@ libkdrive_a_SOURCES = \
kkeymap.c \
kmap.c \
kmode.c \
knoop.c \
koffscreen.c \
kshadow.c \
ktest.c \
$(KDRIVE_XV_SOURCES) \
$(KDRIVE_HW_SOURCES) \
$(top_srcdir)/mi/miinitext.c

8
hw/kdrive/src/kdrive.c
View File

@ -208,7 +208,6 @@ KdDisableScreen (ScreenPtr pScreen)
if (!pScreenPriv->closed)
KdSetRootClip (pScreen, FALSE);
KdDisableColormap (pScreen);
KdOffscreenSwapOut (pScreen);
if (!pScreenPriv->screen->dumb && pScreenPriv->card->cfuncs->disableAccel)
(*pScreenPriv->card->cfuncs->disableAccel) (pScreen);
if (!pScreenPriv->screen->softCursor && pScreenPriv->card->cfuncs->disableCursor)
@ -285,7 +284,6 @@ KdEnableScreen (ScreenPtr pScreen)
pScreenPriv->enabled = TRUE;
pScreenPriv->dpmsState = KD_DPMS_NORMAL;
pScreenPriv->card->selected = pScreenPriv->screen->mynum;
KdOffscreenSwapIn (pScreen);
if (!pScreenPriv->screen->softCursor && pScreenPriv->card->cfuncs->enableCursor)
(*pScreenPriv->card->cfuncs->enableCursor) (pScreen);
if (!pScreenPriv->screen->dumb && pScreenPriv->card->cfuncs->enableAccel)
@ -796,9 +794,6 @@ KdCloseScreen (int index, ScreenPtr pScreen)
else
ret = TRUE;
if (screen->off_screen_base < screen->memory_size)
KdOffscreenFini (pScreen);
if (pScreenPriv->dpmsState != KD_DPMS_NORMAL)
(*card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL);
@ -1097,9 +1092,6 @@ KdScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
if (!screen->dumb && card->cfuncs->initAccel)
if (!(*card->cfuncs->initAccel) (pScreen))
screen->dumb = TRUE;
if (screen->off_screen_base < screen->memory_size)
KdOffscreenInit (pScreen);
#ifdef PSEUDO8
(void) p8Init (pScreen, PSEUDO8_USE_DEFAULT);

140
hw/kdrive/src/kdrive.h
View File

@ -114,30 +114,6 @@ typedef struct _KdFrameBuffer {
void *closure;
} KdFrameBuffer;
typedef struct _KdOffscreenArea KdOffscreenArea;
typedef void (*KdOffscreenSaveProc) (ScreenPtr pScreen, KdOffscreenArea *area);
typedef enum _KdOffscreenState {
KdOffscreenAvail,
KdOffscreenRemovable,
KdOffscreenLocked,
} KdOffscreenState;
struct _KdOffscreenArea {
int offset;
int save_offset;
int size;
int score;
pointer privData;
KdOffscreenSaveProc save;
KdOffscreenState state;
KdOffscreenArea *next;
};
#define RR_Rotate_All (RR_Rotate_0|RR_Rotate_90|RR_Rotate_180|RR_Rotate_270)
#define RR_Reflect_All (RR_Reflect_X|RR_Reflect_Y)
@ -205,8 +181,6 @@ typedef struct {
int bytesPerPixel[KD_MAX_FB];
int dpmsState;
KdOffscreenArea *off_screen_areas;
ColormapPtr pInstalledmap[KD_MAX_FB]; /* current colormap */
xColorItem systemPalette[KD_MAX_PSEUDO_SIZE];/* saved windows colors */
@ -401,90 +375,6 @@ typedef struct _KdPointerMatrix {
int matrix[2][3];
} KdPointerMatrix;
typedef struct _KaaTrapezoid {
float tl, tr, ty;
float bl, br, by;
} KaaTrapezoid;
typedef struct _KaaScreenInfo {
int offsetAlign;
int pitchAlign;
int flags;
int (*markSync) (ScreenPtr pScreen);
void (*waitMarker) (ScreenPtr pScreen, int marker);
Bool (*PrepareSolid) (PixmapPtr pPixmap,
int alu,
Pixel planemask,
Pixel fg);
void (*Solid) (int x1, int y1, int x2, int y2);
void (*DoneSolid) (void);
Bool (*PrepareCopy) (PixmapPtr pSrcPixmap,
PixmapPtr pDstPixmap,
Bool upsidedown,
Bool reverse,
int alu,
Pixel planemask);
void (*Copy) (int srcX,
int srcY,
int dstX,
int dstY,
int width,
int height);
void (*DoneCopy) (void);
Bool (*PrepareBlend) (int op,
PicturePtr pSrcPicture,
PicturePtr pDstPicture,
PixmapPtr pSrc,
PixmapPtr pDst);
void (*Blend) (int srcX,
int srcY,
int dstX,
int dstY,
int width,
int height);
void (*DoneBlend) (void);
Bool (*CheckComposite) (int op,
PicturePtr pSrcPicture,
PicturePtr pMaskPicture,
PicturePtr pDstPicture);
Bool (*PrepareComposite) (int op,
PicturePtr pSrcPicture,
PicturePtr pMaskPicture,
PicturePtr pDstPicture,
PixmapPtr pSrc,
PixmapPtr pMask,
PixmapPtr pDst);
void (*Composite) (int srcX,
int srcY,
int maskX,
int maskY,
int dstX,
int dstY,
int width,
int height);
void (*DoneComposite) (void);
Bool (*PrepareTrapezoids) (PicturePtr pDstPicture,
PixmapPtr pDst);
void (*Trapezoids) (KaaTrapezoid *traps,
int ntraps);
void (*DoneTrapezoids) (void);
Bool (*UploadToScreen) (PixmapPtr pDst,
char *src,
int src_pitch);
Bool (*UploadToScratch) (PixmapPtr pSrc,
PixmapPtr pDst);
} KaaScreenInfoRec, *KaaScreenInfoPtr;
#define KAA_OFFSCREEN_PIXMAPS (1 << 0)
#define KAA_OFFSCREEN_ALIGN_POT (1 << 1)
/*
* This is the only completely portable way to
* compute this info.
@ -821,36 +711,6 @@ KdShadowSet (ScreenPtr pScreen, int randr, ShadowUpdateProc update, ShadowWindow
void
KdShadowUnset (ScreenPtr pScreen);
/* ktest.c */
Bool
KdFrameBufferValid (CARD8 *base, int size);
int
KdFrameBufferSize (CARD8 *base, int max);
/* koffscreen.c */
Bool
KdOffscreenInit (ScreenPtr pScreen);
KdOffscreenArea *
KdOffscreenAlloc (ScreenPtr pScreen, int size, int align,
Bool locked,
KdOffscreenSaveProc save,
pointer privData);
KdOffscreenArea *
KdOffscreenFree (ScreenPtr pScreen, KdOffscreenArea *area);
void
KdOffscreenSwapOut (ScreenPtr pScreen);
void
KdOffscreenSwapIn (ScreenPtr pScreen);
void
KdOffscreenFini (ScreenPtr pScreen);
/* function prototypes to be implemented by the drivers */
void
InitCard (char *name);

199
hw/kdrive/src/kloadmap.c
View File

@ -1,199 +0,0 @@
/*
* Copyright © 1999 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifdef HAVE_CONFIG_H
#include <kdrive-config.h>
#endif
#include "kdrive.h"
#ifdef WINDOWS
#define KM_BUF 1024
#define KM_EOF -1
typedef struct _km_file {
HANDLE handle;
char buf[KM_BUF];
char *bufptr;
DWORD remain;
} km_file;
int
km_fill (km_file *kf)
{
BOOL r;
NCD_DEBUG ((DEBUG_INIT, "km_fill"));
r = ReadFile (kf->handle, kf->buf, KM_BUF,
&kf->remain, NULL);
NCD_DEBUG ((DEBUG_INIT, "Got %d", kf->remain));
if (!r || !kf->remain)
return KM_EOF;
kf->bufptr = kf->buf;
--kf->remain;
return *kf->bufptr++;
}
#define km_getchar(kf) ((kf)->remain-- ? *kf->bufptr++ : km_fill (kf))
#else
#define km_getchar(kf) getc(kf)
#endif
BOOL
km_word (km_file *kf, char *buf, int len)
{
int c;
for (;;)
{
switch (c = km_getchar (kf)) {
case KM_EOF:
return FALSE;
case ' ':
case '\t':
case '\n':
case '\r':
continue;
}
break;
}
len--;
while (len--)
{
*buf++ = c;
switch (c = km_getchar (kf)) {
case KM_EOF:
case ' ':
case '\t':
case '\n':
case '\r':
*buf++ = '\0';
return TRUE;
}
}
return FALSE;
}
BOOL
km_int (km_file *kf, int *r)
{
char word[64];
if (km_word (kf, word, sizeof (word)))
{
*r = strtol (word, NULL, 0);
return TRUE;
}
return FALSE;
}
WCHAR *winKbdExtensions[] = {
L".xku",
L".xkb"
};
#define NUM_KBD_EXTENSIONS (sizeof (winKbdExtensions) / sizeof (winKbdExtensions[0]))
BOOL
winLoadKeymap (void)
{
WCHAR file[32 + KL_NAMELENGTH];
WCHAR name[KL_NAMELENGTH];
HKL layout;
km_file kf;
int width;
BOOL ret;
KeySym *m;
int scancode;
int w;
int e;
layout = GetKeyboardLayout (0);
/*
* Pre-build 46 versions of ThinSTAR software return 0
* for all layouts
*/
if (!layout)
return FALSE;
NCD_DEBUG ((DEBUG_INIT, "Keyboard layout 0x%x", layout));
for (e = 0; e < NUM_KBD_EXTENSIONS; e++)
{
wstrcpy (file, L"\\Storage Card\\");
wsprintf (name, TEXT("%08x"), layout);
wstrcat (file, name);
wstrcat (file, winKbdExtensions[e]);
NCD_DEBUG ((DEBUG_INIT, "Loading keymap from %S", file));
kf.handle = CreateFile (file,
GENERIC_READ,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (kf.handle != INVALID_HANDLE_VALUE)
break;
}
if (kf.handle == INVALID_HANDLE_VALUE)
{
NCD_DEBUG ((DEBUG_INIT, "No such file"));
return FALSE;
}
ret = FALSE;
kf.remain = 0;
/*
* Keymap format:
*
* flags (optional)
* width
* keycode -> keysym array (num_keycodes * width)
*/
if (!km_int (&kf, &width))
goto bail1;
if (width & KEYMAP_FLAGS)
{
CEKeymapFlags = (unsigned long) width;
if (!km_int (&kf, &width))
goto bail1;
}
else
CEKeymapFlags = 0;
if (width > MAX_WIDTH)
goto bail1;
NCD_DEBUG ((DEBUG_INIT, "Keymap width %d flags 0x%x",
width, CEKeymapFlags));
m = CEKeymap;
for (scancode = MIN_SCANCODE; scancode <= MAX_SCANCODE; scancode++)
{
for (w = 0; w < width; w++)
{
if (!km_int (&kf, m))
break;
m++;
}
if (w != width)
break;
}
CEKeySyms.mapWidth = width;
ret = TRUE;
bail1:
CloseHandle (kf.handle);
return ret;
}

251
hw/kdrive/src/knoop.c
View File

@ -1,251 +0,0 @@
/*
* Copyright © 1999 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/*
* GC ops that don't do anything
*/
#ifdef HAVE_CONFIG_H
#include <kdrive-config.h>
#endif
#include "kdrive.h"
#include <gcstruct.h>
typedef void (* typeFillSpans)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*nInit*/,
DDXPointPtr /*pptInit*/,
int * /*pwidthInit*/,
int /*fSorted*/
);
typedef void (* typeSetSpans)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
char * /*psrc*/,
DDXPointPtr /*ppt*/,
int * /*pwidth*/,
int /*nspans*/,
int /*fSorted*/
);
typedef void (* typePutImage)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*depth*/,
int /*x*/,
int /*y*/,
int /*w*/,
int /*h*/,
int /*leftPad*/,
int /*format*/,
char * /*pBits*/
);
typedef RegionPtr (* typeCopyArea)(
DrawablePtr /*pSrc*/,
DrawablePtr /*pDst*/,
GCPtr /*pGC*/,
int /*srcx*/,
int /*srcy*/,
int /*w*/,
int /*h*/,
int /*dstx*/,
int /*dsty*/
);
typedef RegionPtr (* typeCopyPlane)(
DrawablePtr /*pSrcDrawable*/,
DrawablePtr /*pDstDrawable*/,
GCPtr /*pGC*/,
int /*srcx*/,
int /*srcy*/,
int /*width*/,
int /*height*/,
int /*dstx*/,
int /*dsty*/,
unsigned long /*bitPlane*/
);
typedef void (* typePolyPoint)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*mode*/,
int /*npt*/,
DDXPointPtr /*pptInit*/
);
typedef void (* typePolylines)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*mode*/,
int /*npt*/,
DDXPointPtr /*pptInit*/
);
typedef void (* typePolySegment)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*nseg*/,
xSegment * /*pSegs*/
);
typedef void (* typePolyRectangle)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*nrects*/,
xRectangle * /*pRects*/
);
typedef void (* typePolyArc)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*narcs*/,
xArc * /*parcs*/
);
typedef void (* typeFillPolygon)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*shape*/,
int /*mode*/,
int /*count*/,
DDXPointPtr /*pPts*/
);
typedef void (* typePolyFillRect)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*nrectFill*/,
xRectangle * /*prectInit*/
);
typedef void (* typePolyFillArc)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*narcs*/,
xArc * /*parcs*/
);
typedef int (* typePolyText8)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*x*/,
int /*y*/,
int /*count*/,
char * /*chars*/
);
typedef int (* typePolyText16)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*x*/,
int /*y*/,
int /*count*/,
unsigned short * /*chars*/
);
typedef void (* typeImageText8)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*x*/,
int /*y*/,
int /*count*/,
char * /*chars*/
);
typedef void (* typeImageText16)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*x*/,
int /*y*/,
int /*count*/,
unsigned short * /*chars*/
);
typedef void (* typeImageGlyphBlt)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*x*/,
int /*y*/,
unsigned int /*nglyph*/,
CharInfoPtr * /*ppci*/,
pointer /*pglyphBase*/
);
typedef void (* typePolyGlyphBlt)(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,
int /*x*/,
int /*y*/,
unsigned int /*nglyph*/,
CharInfoPtr * /*ppci*/,
pointer /*pglyphBase*/
);
typedef void (* typePushPixels)(
GCPtr /*pGC*/,
PixmapPtr /*pBitMap*/,
DrawablePtr /*pDst*/,
int /*w*/,
int /*h*/,
int /*x*/,
int /*y*/
);
static RegionPtr
KdNoopCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,
int srcx, int srcy, int width, int height, int dstx, int dsty)
{
return NullRegion;
}
static RegionPtr
KdNoopCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC,
int srcx, int srcy, int width, int height,
int dstx, int dsty, unsigned long bitPlane)
{
return NullRegion;
}
GCOps kdNoopOps = {
(typeFillSpans) NoopDDA, /* fill spans */
(typeSetSpans) NoopDDA, /* set spans */
(typePutImage) NoopDDA, /* put image */
KdNoopCopyArea, /* copy area */
KdNoopCopyPlane, /* copy plane */
(typePolyPoint) NoopDDA, /* poly point */
(typePolylines) NoopDDA, /* poly lines */
(typePolySegment) NoopDDA, /* poly segment */
(typePolyRectangle) NoopDDA, /* poly rectangle */
(typePolyArc) NoopDDA, /* poly arc */
(typeFillPolygon) NoopDDA, /* fill polygon */
(typePolyFillRect) NoopDDA, /* poly fillrect */
(typePolyFillArc) NoopDDA, /* poly fillarc */
(typePolyText8) NoopDDA, /* text 8 */
(typePolyText16) NoopDDA, /* text 16 */
(typeImageText8) NoopDDA, /* itext 8 */
(typeImageText16) NoopDDA, /* itext 16 */
(typePolyGlyphBlt) NoopDDA, /* glyph blt */
(typeImageGlyphBlt) NoopDDA, /* iglyph blt */
(typePushPixels) NoopDDA, /* push pixels */
};

351
hw/kdrive/src/koffscreen.c
View File

@ -1,351 +0,0 @@
/*
* Copyright © 2003 Anders Carlsson
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Anders Carlsson not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Anders Carlsson makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* ANDERS CARLSSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL ANDERS CARLSSON BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifdef HAVE_CONFIG_H
#include <kdrive-config.h>
#endif
#include "kdrive.h"
#define DEBUG_OFFSCREEN 0
#if DEBUG_OFFSCREEN
#define DBG_OFFSCREEN(a) ErrorF a
#else
#define DBG_OFFSCREEN(a)
#endif
#if DEBUG_OFFSCREEN
static void
KdOffscreenValidate (ScreenPtr pScreen)
{
KdScreenPriv (pScreen);
KdOffscreenArea *prev = 0, *area;
assert (pScreenPriv->screen->off_screen_areas->area.offset == 0);
for (area = pScreenPriv->off_screen_areas; area; area = area->next)
{
if (prev)
assert (prev->offset + prev->size == area->offset);
prev = area;
}
assert (prev->offset + prev->size == pScreenPriv->screen->memory_size);
}
#else
#define KdOffscreenValidate(s)
#endif
static KdOffscreenArea *
KdOffscreenKickOut (ScreenPtr pScreen, KdOffscreenArea *area)
{
if (area->save)
(*area->save) (pScreen, area);
return KdOffscreenFree (pScreen, area);
}
KdOffscreenArea *
KdOffscreenAlloc (ScreenPtr pScreen, int size, int align,
Bool locked,
KdOffscreenSaveProc save,
pointer privData)
{
KdOffscreenArea *area, *begin, *best;
KdScreenPriv (pScreen);
int tmp, real_size = 0, best_score;
KdOffscreenValidate (pScreen);
if (!align)
align = 1;
if (!size)
{
DBG_OFFSCREEN (("Alloc 0x%x -> EMPTY\n", size));
return NULL;
}
/* throw out requests that cannot fit */
if (size > (pScreenPriv->screen->memory_size - pScreenPriv->screen->off_screen_base))
{
DBG_OFFSCREEN (("Alloc 0x%x -> TOBIG\n", size));
return NULL;
}
/* Try to find a free space that'll fit. */
for (area = pScreenPriv->off_screen_areas; area; area = area->next)
{
/* skip allocated areas */
if (area->state != KdOffscreenAvail)
continue;
/* adjust size to match alignment requirement */
real_size = size;
tmp = area->offset % align;
if (tmp)
real_size += (align - tmp);
/* does it fit? */
if (real_size <= area->size)
break;
}
if (!area)
{
/*
* Kick out existing users to make space.
*
* First, locate a region which can hold the desired object.
*/
/* prev points at the first object to boot */
best = NULL;
best_score = MAXINT;
for (begin = pScreenPriv->off_screen_areas; begin != NULL;
begin = begin->next)
{
int avail, score;
KdOffscreenArea *scan;
if (begin->state == KdOffscreenLocked)
continue;
/* adjust size to match alignment requirement */
real_size = size;
tmp = begin->offset % align;
if (tmp)
real_size += (align - tmp);
avail = 0;
score = 0;
/* now see if we can make room here, and how "costly" it'll be. */
for (scan = begin; scan != NULL; scan = scan->next)
{
if (scan->state == KdOffscreenLocked) {
/* Can't make room here, start after this locked area. */
begin = scan->next;
break;
}
/* Score should only be non-zero for KdOffscreenRemovable */
score += scan->score;
avail += scan->size;
if (avail >= real_size)
break;
}
/* Is it the best option we've found so far? */
if (avail >= real_size && score < best_score) {
best = begin;
best_score = score;
}
}
area = best;
if (!area)
{
DBG_OFFSCREEN (("Alloc 0x%x -> NOSPACE\n", size));
/* Could not allocate memory */
KdOffscreenValidate (pScreen);
return NULL;
}
/* adjust size to match alignment requirement */
real_size = size;
tmp = begin->offset % align;
if (tmp)
real_size += (align - tmp);
/*
* Kick out first area if in use
*/
if (area->state != KdOffscreenAvail)
area = KdOffscreenKickOut (pScreen, area);
/*
* Now get the system to merge the other needed areas together
*/
while (area->size < real_size)
{
assert (area->next && area->next->state == KdOffscreenRemovable);
(void) KdOffscreenKickOut (pScreen, area->next);
}
}
/* save extra space in new area */
if (real_size < area->size)
{
KdOffscreenArea *new_area = xalloc (sizeof (KdOffscreenArea));
if (!new_area)
return NULL;
new_area->offset = area->offset + real_size;
new_area->size = area->size - real_size;
new_area->state = KdOffscreenAvail;
new_area->save = 0;
new_area->score = 0;
new_area->next = area->next;
area->next = new_area;
area->size = real_size;
}
/*
* Mark this area as in use
*/
if (locked)
area->state = KdOffscreenLocked;
else
area->state = KdOffscreenRemovable;
area->privData = privData;
area->save = save;
area->score = 0;
area->save_offset = area->offset;
{
int tmp = area->offset % align;
if (tmp)
area->offset += (align - tmp);
}
KdOffscreenValidate (pScreen);
DBG_OFFSCREEN (("Alloc 0x%x -> 0x%x\n", size, area->offset));
return area;
}
void
KdOffscreenSwapOut (ScreenPtr pScreen)
{
KdScreenPriv (pScreen);
KdOffscreenValidate (pScreen);
/* loop until a single free area spans the space */
for (;;)
{
KdOffscreenArea *area = pScreenPriv->off_screen_areas;
if (!area)
break;
if (area->state == KdOffscreenAvail)
{
area = area->next;
if (!area)
break;
}
assert (area->state != KdOffscreenAvail);
(void) KdOffscreenKickOut (pScreen, area);
KdOffscreenValidate (pScreen);
}
KdOffscreenValidate (pScreen);
KdOffscreenFini (pScreen);
}
void
KdOffscreenSwapIn (ScreenPtr pScreen)
{
KdOffscreenInit (pScreen);
}
/* merge the next free area into this one */
static void
KdOffscreenMerge (KdOffscreenArea *area)
{
KdOffscreenArea *next = area->next;
/* account for space */
area->size += next->size;
/* frob pointer */
area->next = next->next;
xfree (next);
}
KdOffscreenArea *
KdOffscreenFree (ScreenPtr pScreen, KdOffscreenArea *area)
{
KdScreenPriv(pScreen);
KdOffscreenArea *next = area->next;
KdOffscreenArea *prev;
DBG_OFFSCREEN (("Free 0x%x -> 0x%x\n", area->size, area->offset));
KdOffscreenValidate (pScreen);
area->state = KdOffscreenAvail;
area->save = 0;
area->offset = area->save_offset;
area->score = 0;
/*
* Find previous area
*/
if (area == pScreenPriv->off_screen_areas)
prev = 0;
else
for (prev = pScreenPriv->off_screen_areas; prev; prev = prev->next)
if (prev->next == area)
break;
/* link with next area if free */
if (next && next->state == KdOffscreenAvail)
KdOffscreenMerge (area);
/* link with prev area if free */
if (prev && prev->state == KdOffscreenAvail)
{
area = prev;
KdOffscreenMerge (area);
}
KdOffscreenValidate (pScreen);
return area;
}
Bool
KdOffscreenInit (ScreenPtr pScreen)
{
KdScreenPriv (pScreen);
KdOffscreenArea *area;
/* Allocate a big free area */
area = xalloc (sizeof (KdOffscreenArea));
if (!area)
return FALSE;
area->state = KdOffscreenAvail;
area->offset = pScreenPriv->screen->off_screen_base;
area->size = pScreenPriv->screen->memory_size - area->offset;
area->save = 0;
area->next = NULL;
area->score = 0;
/* Add it to the free areas */
pScreenPriv->off_screen_areas = area;
KdOffscreenValidate (pScreen);
return TRUE;
}
void
KdOffscreenFini (ScreenPtr pScreen)
{
KdScreenPriv (pScreen);
KdOffscreenArea *area;
/* just free all of the area records */
while ((area = pScreenPriv->off_screen_areas))
{
pScreenPriv->off_screen_areas = area->next;
xfree (area);
}
}

76
hw/kdrive/src/ktest.c
View File

@ -1,76 +0,0 @@
/*
* Copyright © 1999 Keith Packard
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#ifdef HAVE_CONFIG_H
#include <kdrive-config.h>
#endif
#include "kdrive.h"
static CARD8 memoryPatterns[] = { 0xff, 0x00, 0x5a, 0xa5, 0xaa, 0x55 };
#define NUM_PATTERNS (sizeof (memoryPatterns) / sizeof (memoryPatterns[0]))
Bool
KdFrameBufferValid (CARD8 *base, int size)
{
volatile CARD8 *b = (volatile CARD8 *) base;
CARD8 save, test, compare;
int i, j;
b = base + (size - 1);
save = *b;
for (i = 0; i < NUM_PATTERNS; i++)
{
test = memoryPatterns[i];
*b = test;
for (j = 0; j < 1000; j++)
{
compare = *b;
if (compare != test)
return FALSE;
}
}
*b = save;
return TRUE;
}
int
KdFrameBufferSize (CARD8 *base, int max)
{
int min, cur;
min = 0;
while (min + 1 < max)
{
cur = (max + min) / 2;
if (KdFrameBufferValid (base, cur))
min = cur;
else
max = cur;
}
if (KdFrameBufferValid (base, max))
return max;
else
return min;
}

41
hw/kdrive/src/kxv.c
View File

@ -1728,47 +1728,6 @@ KdXVQueryImageAttributes(
}
/**************** Offscreen surface stuff *******************/
typedef struct {
KdOffscreenImagePtr images;
int num;
} OffscreenImageRec;
static OffscreenImageRec OffscreenImages[MAXSCREENS];
static Bool offscreenInited = FALSE;
Bool
KdXVRegisterOffscreenImages(
ScreenPtr pScreen,
KdOffscreenImagePtr images,
int num
){
if(!offscreenInited) {
bzero(OffscreenImages, sizeof(OffscreenImages[MAXSCREENS]));
offscreenInited = TRUE;
}
OffscreenImages[pScreen->myNum].num = num;
OffscreenImages[pScreen->myNum].images = images;
return TRUE;
}
KdOffscreenImagePtr
KdXVQueryOffscreenImages(
ScreenPtr pScreen,
int *num
){
if(!offscreenInited) {
*num = 0;
return NULL;
}
*num = OffscreenImages[pScreen->myNum].num;
return OffscreenImages[pScreen->myNum].images;
}
/**************** Common video manipulation functions *******************/
void

37
hw/kdrive/src/kxv.h
View File

@ -186,30 +186,6 @@ typedef struct {
QueryImageAttributesFuncPtr QueryImageAttributes;
} KdVideoAdaptorRec, *KdVideoAdaptorPtr;
typedef struct {
KdImagePtr image;
int flags;
int (*alloc_surface)(KdScreenInfo * screen,
int id,
unsigned short width,
unsigned short height,
KdSurfacePtr surface);
int (*free_surface)(KdSurfacePtr surface);
int (*display) (KdSurfacePtr surface,
short vid_x, short vid_y,
short drw_x, short drw_y,
short vid_w, short vid_h,
short drw_w, short drw_h,
RegionPtr clipBoxes);
int (*stop) (KdSurfacePtr surface);
int (*getAttribute) (KdScreenInfo * screen, Atom attr, INT32 *value);
int (*setAttribute) (KdScreenInfo * screen, Atom attr, INT32 value);
int max_width;
int max_height;
int num_attributes;
KdAttributePtr attributes;
} KdOffscreenImageRec, *KdOffscreenImagePtr;
Bool
KdXVScreenInit(
ScreenPtr pScreen,
@ -231,19 +207,6 @@ KdXVListGenericAdaptors(
KdVideoAdaptorPtr **Adaptors
);
Bool
KdXVRegisterOffscreenImages(
ScreenPtr pScreen,
KdOffscreenImagePtr images,
int num
);
KdOffscreenImagePtr
KdXVQueryOffscreenImages(
ScreenPtr pScreen,
int *num
);
void
KdXVCopyPackedData(KdScreenInfo *screen, CARD8 *src, CARD8 *dst, int randr,
int srcPitch, int dstPitch, int srcW, int srcH, int top, int left,

2
hw/kdrive/vesa/vesa.c
View File

@ -1226,8 +1226,6 @@ vesaRandRSetConfig (ScreenPtr pScreen,
break;
}
KdOffscreenSwapOut (screen->pScreen);
vesaUnmapFramebuffer (screen);
if (!vesaComputeFramebufferMapping (screen))