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

removed hardcoded vesa references so we can operate with any backend. fbdev 

works for initializing the screen, but input fails shortly after.
This commit is contained in:
Brent Cook 2004-04-05 02:52:35 +00:00
parent 920e6ff81b
commit b526276faa
3 changed files with 141 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hw/kdrive/neomagic/backend.c
View File

@ -66,6 +66,7 @@ backendScreenInitialize(KdScreenInfo *screen, BackendScreen *backendScreen,
#ifdef KDRIVEFBDEV #ifdef KDRIVEFBDEV
if (backendCard->type == FBDEV) { if (backendCard->type == FBDEV) {
screen->card->driver = &backendCard->priv.fbdev;
success = fbdevScreenInitialize(screen, &backendScreen->fbdev); success = fbdevScreenInitialize(screen, &backendScreen->fbdev);
screen->memory_size = backendCard->priv.fbdev.fix.smem_len; screen->memory_size = backendCard->priv.fbdev.fix.smem_len;
screen->off_screen_base = backendCard->priv.fbdev.var.yres_virtual screen->off_screen_base = backendCard->priv.fbdev.var.yres_virtual

223
hw/kdrive/neomagic/neomagic.c
View File

@ -28,45 +28,46 @@
#include <sys/io.h> #include <sys/io.h>
struct NeoChipInfo neoChips[] = { struct NeoChipInfo neoChips[] = {
{NEO_VENDOR, 0x0001, CAP_NM2070, "MagicGraph 128 (NM2070)", {NEO_VENDOR, 0x0001, CAP_NM2070, "MagicGraph 128(NM2070)",
896, 65000, 2048, 0x100, 1024, 1024, 1024}, 896, 65000, 2048, 0x100, 1024, 1024, 1024},
{NEO_VENDOR, 0x0002, CAP_NM2090, "MagicGraph 128V (NM2090)", {NEO_VENDOR, 0x0002, CAP_NM2090, "MagicGraph 128V(NM2090)",
1152, 80000, 2048, 0x100, 2048, 1024, 1024}, 1152, 80000, 2048, 0x100, 2048, 1024, 1024},
{NEO_VENDOR, 0x0003, CAP_NM2090, "MagicGraph 128ZV (NM2093)", {NEO_VENDOR, 0x0003, CAP_NM2090, "MagicGraph 128ZV(NM2093)",
1152, 80000, 2048, 0x100, 2048, 1024, 1024}, 1152, 80000, 2048, 0x100, 2048, 1024, 1024},
{NEO_VENDOR, 0x0083, CAP_NM2097, "MagicGraph 128ZV+ (NM2097)", {NEO_VENDOR, 0x0083, CAP_NM2097, "MagicGraph 128ZV+(NM2097)",
1152, 80000, 1024, 0x100, 2048, 1024, 1024}, 1152, 80000, 1024, 0x100, 2048, 1024, 1024},
{NEO_VENDOR, 0x0004, CAP_NM2097, "MagicGraph 128XD (NM2160)", {NEO_VENDOR, 0x0004, CAP_NM2097, "MagicGraph 128XD(NM2160)",
2048, 90000, 1024, 0x100, 2048, 1024, 1024}, 2048, 90000, 1024, 0x100, 2048, 1024, 1024},
{NEO_VENDOR, 0x0005, CAP_NM2200, "MagicGraph 256AV (NM2200)", {NEO_VENDOR, 0x0005, CAP_NM2200, "MagicGraph 256AV(NM2200)",
2560, 110000, 1024, 0x1000, 4096, 1280, 1024}, 2560, 110000, 1024, 0x1000, 4096, 1280, 1024},
{NEO_VENDOR, 0x0025, CAP_NM2200, "MagicGraph 256AV+ (NM2230)", {NEO_VENDOR, 0x0025, CAP_NM2200, "MagicGraph 256AV+(NM2230)",
3008, 110000, 1024, 0x1000, 4096, 1280, 1024}, 3008, 110000, 1024, 0x1000, 4096, 1280, 1024},
{NEO_VENDOR, 0x0006, CAP_NM2200, "MagicGraph 256ZX (NM2360)", {NEO_VENDOR, 0x0006, CAP_NM2200, "MagicGraph 256ZX(NM2360)",
4096, 110000, 1024, 0x1000, 4096, 1280, 1024}, 4096, 110000, 1024, 0x1000, 4096, 1280, 1024},
{NEO_VENDOR, 0x0016, CAP_NM2200, "MagicGraph 256XL+ (NM2380)", {NEO_VENDOR, 0x0016, CAP_NM2200, "MagicGraph 256XL+(NM2380)",
6144, 110000, 1024, 0x1000, 8192, 1280, 1024}, 6144, 110000, 1024, 0x1000, 8192, 1280, 1024},
{0, 0, 0, NULL}, {0, 0, 0, NULL},
}; };
static Bool static Bool
neoCardInit (KdCardInfo *card) neoCardInit(KdCardInfo *card)
{ {
ENTER();
NeoCardInfo *neoc; NeoCardInfo *neoc;
struct NeoChipInfo *chip; struct NeoChipInfo *chip;
neoc = (NeoCardInfo *) xalloc (sizeof (NeoCardInfo)); neoc =(NeoCardInfo *) xalloc(sizeof(NeoCardInfo));
if (!neoc) { if(!neoc) {
return FALSE; return FALSE;
} }
if (!backendInitialize(card, &neoc->backendCard)) { if(!backendInitialize(card, &neoc->backendCard)) {
xfree (neoc); xfree(neoc);
return FALSE; return FALSE;
} }
for (chip = neoChips; chip->name != NULL; ++chip) { for(chip = neoChips; chip->name != NULL; ++chip) {
if (chip->device == card->attr.deviceID) { if(chip->device == card->attr.deviceID) {
neoc->chip = chip; neoc->chip = chip;
break; break;
} }
@ -74,87 +75,117 @@ neoCardInit (KdCardInfo *card)
ErrorF("Using Neomagic card: %s\n", neoc->chip->name); ErrorF("Using Neomagic card: %s\n", neoc->chip->name);
neoMapReg (card, neoc); iopl(3);
neoMapReg(card, neoc);
card->driver = neoc; card->driver = neoc;
LEAVE();
return TRUE; return TRUE;
} }
static Bool static Bool
neoScreenInit (KdScreenInfo *screen) neoScreenInit(KdScreenInfo *screen)
{ {
NeoCardInfo *neoc = screen->card->driver; ENTER();
NeoScreenInfo *neos; NeoScreenInfo *neos;
neoCardInfo(screen);
int screen_size, memory; int screen_size, memory;
neos = (NeoScreenInfo *) xalloc (sizeof (NeoScreenInfo)); neos = xcalloc(sizeof(NeoScreenInfo), 1);
if (!neos) { if(neos == NULL) {
return FALSE; return FALSE;
} }
memset (neos, '\0', sizeof (NeoScreenInfo));
if (!backendScreenInitialize (screen, &neos->backendScreen, &neoc->backendCard)) { screen->driver = neos;
xfree (neos);
if(!backendScreenInitialize(screen, &neos->backendScreen, &neoc->backendCard)) {
xfree(neos);
return FALSE; return FALSE;
} }
screen->softCursor = TRUE; // no hardware color cursor available screen->softCursor = TRUE; // no hardware color cursor available
switch (neoc->backendCard.type) { switch(neoc->backendCard.type) {
case VESA: #ifdef KDRIVEFBDEV
neos->screen = neos->backendScreen.vesa.fb;
break;
case FBDEV: case FBDEV:
neos->screen = neoc->backendCard.priv.fbdev.fb; neos->screen = neoc->backendCard.priv.fbdev.fb;
break; break;
#endif
#ifdef KDRIVEVESA
case VESA:
neos->screen = neos->backendScreen.vesa.fb;
break;
#endif
default:
ErrorF("Unhandled backend, we should never get here.\n");
xfree(neos);
return FALSE;
} }
memory = neoc->chip->linearSize * 1024; memory = neoc->chip->linearSize * 1024;
screen_size = screen->fb[0].byteStride * screen->height; screen_size = screen->fb[0].byteStride * screen->height;
memory -= screen_size; memory -= screen_size;
if (memory > screen->fb[0].byteStride) { if(memory > screen->fb[0].byteStride) {
neos->off_screen = neos->screen + screen_size; neos->off_screen = neos->screen + screen_size;
neos->off_screen_size = memory; neos->off_screen_size = memory;
} else { } else {
neos->off_screen = 0; neos->off_screen = 0;
neos->off_screen_size = 0; neos->off_screen_size = 0;
} }
screen->driver = neos;
LEAVE();
return TRUE; return TRUE;
} }
static Bool static Bool
neoInitScreen (ScreenPtr pScreen) neoInitScreen(ScreenPtr pScreen)
{ {
return vesaInitScreen (pScreen); ENTER();
KdScreenPriv(pScreen);
neoCardInfo(pScreenPriv);
return neoc->backendCard.initScreen(pScreen);
LEAVE();
} }
static Bool static Bool
neoFinishInitScreen (ScreenPtr pScreen) neoFinishInitScreen(ScreenPtr pScreen)
{ {
Bool ret; KdScreenPriv(pScreen);
ret = vesaFinishInitScreen (pScreen); neoCardInfo(pScreenPriv);
return ret;
return neoc->backendCard.finishInitScreen(pScreen);
}
static Bool
neoCreateResources(ScreenPtr pScreen)
{
KdScreenPriv(pScreen);
neoCardInfo(pScreenPriv);
return neoc->backendCard.createRes(pScreen);
} }
void void
neoPreserve (KdCardInfo *card) neoPreserve(KdCardInfo *card)
{ {
vesaPreserve(card); NeoCardInfo *neoc = card->driver;
neoc->backendCard.preserve(card);
} }
CARD8 CARD8
neoGetIndex (NeoCardInfo *nvidiac, CARD16 addr, CARD8 index) neoGetIndex(NeoCardInfo *nvidiac, CARD16 addr, CARD8 index)
{ {
outb (index, addr); outb(index, addr);
return inb(addr+1); return inb(addr+1);
} }
void void
neoSetIndex (NeoCardInfo *nvidiac, CARD16 addr, CARD8 index, CARD8 val) neoSetIndex(NeoCardInfo *nvidiac, CARD16 addr, CARD8 index, CARD8 val)
{ {
outb(index, addr); outb(index, addr);
outb(val, addr+1); outb(val, addr+1);
@ -163,30 +194,29 @@ neoSetIndex (NeoCardInfo *nvidiac, CARD16 addr, CARD8 index, CARD8 val)
static void neoLock(NeoCardInfo *neoc){ static void neoLock(NeoCardInfo *neoc){
CARD8 cr11; CARD8 cr11;
neoSetIndex(neoc, 0x3ce, 0x09, 0x00); neoSetIndex(neoc, 0x3ce, 0x09, 0x00);
cr11 = neoGetIndex (neoc, 0x3d4, 0x11); cr11 = neoGetIndex(neoc, 0x3d4, 0x11);
neoSetIndex (neoc, 0x3d4, 0x11, cr11 | 0x80); neoSetIndex(neoc, 0x3d4, 0x11, cr11 | 0x80);
} }
static void neoUnlock(NeoCardInfo *neoc){ static void neoUnlock(NeoCardInfo *neoc){
CARD8 cr11; CARD8 cr11;
cr11 = neoGetIndex (neoc, 0x3d4, 0x11); cr11 = neoGetIndex(neoc, 0x3d4, 0x11);
neoSetIndex (neoc, 0x3d4, 0x11, cr11 & 0x7F); neoSetIndex(neoc, 0x3d4, 0x11, cr11 & 0x7F);
neoSetIndex(neoc, 0x3ce, 0x09, 0x26); neoSetIndex(neoc, 0x3ce, 0x09, 0x26);
} }
Bool Bool
neoMapReg (KdCardInfo *card, NeoCardInfo *neoc) neoMapReg(KdCardInfo *card, NeoCardInfo *neoc)
{ {
iopl (3);
ENTER(); ENTER();
neoc->reg_base = card->attr.address[1] & 0xFFF80000; neoc->reg_base = card->attr.address[1] & 0xFFF80000;
if (!neoc->reg_base) { if(!neoc->reg_base) {
return FALSE; return FALSE;
} }
neoc->mmio = KdMapDevice(neoc->reg_base, NEO_REG_SIZE(card)); neoc->mmio = KdMapDevice(neoc->reg_base, NEO_REG_SIZE(card));
if (!neoc->mmio) { if(!neoc->mmio) {
return FALSE; return FALSE;
} }
@ -194,97 +224,122 @@ neoMapReg (KdCardInfo *card, NeoCardInfo *neoc)
// if you see the cursor sprite them MMIO is working // if you see the cursor sprite them MMIO is working
*(((CARD32 *)neoc->mmio)+0x400) = (CARD32)8; *(((CARD32 *)neoc->mmio)+0x400) =(CARD32)8;
//neoSetIndex(neoc, 0x3ce, 0x82,8); //neoSetIndex(neoc, 0x3ce, 0x82,8);
LEAVE(); LEAVE();
return TRUE; return TRUE;
} }
void void
neoUnmapReg (KdCardInfo *card, NeoCardInfo *neoc) neoUnmapReg(KdCardInfo *card, NeoCardInfo *neoc)
{ {
ENTER(); ENTER();
if (neoc->reg_base) if(neoc->reg_base)
{ {
neoSetIndex(neoc, 0x3ce, 0x82,0); neoSetIndex(neoc, 0x3ce, 0x82,0);
KdResetMappedMode(neoc->reg_base, NEO_REG_SIZE(card), KD_MAPPED_MODE_REGISTERS); KdResetMappedMode(neoc->reg_base, NEO_REG_SIZE(card), KD_MAPPED_MODE_REGISTERS);
KdUnmapDevice ((void *)neoc->mmio, NEO_REG_SIZE(card)); KdUnmapDevice((void *)neoc->mmio, NEO_REG_SIZE(card));
neoc->reg_base = 0; neoc->reg_base = 0;
} }
LEAVE(); LEAVE();
} }
static void static void
neoSetMMIO (KdCardInfo *card, NeoCardInfo *neoc) neoSetMMIO(KdCardInfo *card, NeoCardInfo *neoc)
{ {
if (!neoc->reg_base) if(!neoc->reg_base)
neoMapReg (card, neoc); neoMapReg(card, neoc);
neoUnlock (neoc); neoUnlock(neoc);
} }
static void static void
neoResetMMIO (KdCardInfo *card, NeoCardInfo *neoc) neoResetMMIO(KdCardInfo *card, NeoCardInfo *neoc)
{ {
neoUnmapReg (card, neoc); neoUnmapReg(card, neoc);
neoLock (neoc); neoLock(neoc);
} }
Bool Bool
neoEnable (ScreenPtr pScreen) neoEnable(ScreenPtr pScreen)
{ {
KdScreenPriv(pScreen); KdScreenPriv(pScreen);
NeoCardInfo *neoc = pScreenPriv->card->driver; neoCardInfo(pScreenPriv);
if (!vesaEnable (pScreen)) if(!neoc->backendCard.enable(pScreen)) {
return FALSE; return FALSE;
neoSetMMIO (pScreenPriv->card, neoc); }
neoSetMMIO(pScreenPriv->card, neoc);
return TRUE; return TRUE;
} }
void void
neoDisable (ScreenPtr pScreen) neoDisable(ScreenPtr pScreen)
{ {
KdScreenPriv(pScreen); KdScreenPriv(pScreen);
neoCardInfo(pScreenPriv);
NeoCardInfo *neoc = pScreenPriv->card->driver; neoResetMMIO(pScreenPriv->card, neoc);
neoResetMMIO (pScreenPriv->card, neoc);
vesaDisable (pScreen); neoc->backendCard.disable(pScreen);
}
static void
neoGetColors(ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
{
KdScreenPriv(pScreen);
neoCardInfo(pScreenPriv);
neoc->backendCard.getColors(pScreen, fb, n, pdefs);
}
static void
neoPutColors(ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
{
KdScreenPriv(pScreen);
neoCardInfo(pScreenPriv);
neoc->backendCard.putColors(pScreen, fb, n, pdefs);
} }
static Bool static Bool
neoDPMS (ScreenPtr pScreen, int mode) neoDPMS(ScreenPtr pScreen, int mode)
{ {
return vesaDPMS (pScreen, mode); KdScreenPriv(pScreen);
neoCardInfo(pScreenPriv);
return neoc->backendCard.dpms(pScreen, mode);
} }
static void static void
neoRestore (KdCardInfo *card) neoRestore(KdCardInfo *card)
{ {
NeoCardInfo *neoc = card->driver; NeoCardInfo *neoc = card->driver;
neoResetMMIO (card, neoc); neoResetMMIO(card, neoc);
vesaRestore (card); neoc->backendCard.restore(card);
} }
static void static void
neoScreenFini (KdScreenInfo *screen) neoScreenFini(KdScreenInfo *screen)
{ {
NeoScreenInfo *neos = (NeoScreenInfo *) screen->driver; NeoScreenInfo *neos =(NeoScreenInfo *) screen->driver;
NeoCardInfo *neoc = screen->card->driver;
vesaScreenFini (screen); neoc->backendCard.scrfini(screen);
xfree (neos); xfree(neos);
screen->driver = 0; screen->driver = 0;
} }
static void static void
neoCardFini (KdCardInfo *card) neoCardFini(KdCardInfo *card)
{ {
NeoCardInfo *neos = card->driver; NeoCardInfo *neoc = card->driver;
neoUnmapReg (card, neos); neoUnmapReg(card, neoc);
vesaCardFini (card); neoc->backendCard.cardfini(card);
} }
#define neoCursorInit 0 // initCursor #define neoCursorInit 0 // initCursor
@ -298,7 +353,7 @@ KdCardFuncs neoFuncs = {
neoScreenInit, // scrinit neoScreenInit, // scrinit
neoInitScreen, // initScreen neoInitScreen, // initScreen
neoFinishInitScreen, // finishInitScreen neoFinishInitScreen, // finishInitScreen
vesaCreateResources, // createRes neoCreateResources, // createRes
neoPreserve, // preserve neoPreserve, // preserve
neoEnable, // enable neoEnable, // enable
neoDPMS, // dpms neoDPMS, // dpms
@ -319,6 +374,6 @@ KdCardFuncs neoFuncs = {
neoDrawDisable, // disableAccel neoDrawDisable, // disableAccel
neoDrawFini, // finiAccel neoDrawFini, // finiAccel
vesaGetColors, // getColors neoGetColors, // getColors
vesaPutColors, // putColors neoPutColors, // putColors
}; };

2
hw/kdrive/neomagic/neomagic.h
View File

@ -143,7 +143,7 @@ struct NeoChipInfo {
}; };
#define getNeoCardInfo(kd) ((NeoCardInfo *) ((kd)->card->driver)) #define getNeoCardInfo(kd) ((NeoCardInfo *) ((kd)->card->driver))
#define neoCardInfo(kd) NeoCardInfo *neoc = getNeoCardInfo(kd) #define neoCardInfo(kd) NeoCardInfo *neoc = getNeoCardInfo(kd)
typedef struct _neoScreenInfo { typedef struct _neoScreenInfo {
BackendScreen backendScreen; BackendScreen backendScreen;