int GGIMesa_fbdev_setmode(ggi_visual *vis, ggi_mode *mode)
{
int err;
if ((err = ggiCheckMode(vis, mode)) != 0) {
return err;
}
GGIMESADPRINT_CORE("display-fbdev-mesa: setmode %dx%d#%dx%dF%d[0x%02x]\n",
mode->visible.x, mode->visible.y,
mode->virt.x, mode->virt.y,
mode->frames, mode->graphtype);
memcpy(LIBGGI_MODE(vis), mode, sizeof(ggi_mode));
/* Now actually set the mode */
err = do_setmode(vis);
if (err != 0) {
return err;
}
GGIMESADPRINT_CORE("display-fbdev-mesa: setmode success.\n");
return 0;
}
int GGI_lcd823_setmode(struct ggi_visual *vis, ggi_mode *mode)
{
int err;
if ((err = ggiCheckMode(vis, mode)) != 0) {
return err;
}
if (LIBGGI_PAL(vis)->clut.data) {
free(LIBGGI_PAL(vis)->clut.data);
LIBGGI_PAL(vis)->clut.data = NULL;
}
if (LIBGGI_PAL(vis)->priv) {
free(LIBGGI_PAL(vis)->priv);
LIBGGI_PAL(vis)->priv = NULL;
}
_GGI_lcd823_free_dbs(vis);
memcpy(LIBGGI_MODE(vis), mode, sizeof(ggi_mode));
/* Now actually set the mode */
err = do_setmode(vis);
if (err != 0) {
return err;
}
/* Reset panning and frames */
vis->d_frame_num = vis->origin_x = vis->origin_y = 0;
return 0;
}
int GGI_palemu_setmode(struct ggi_visual *vis, ggi_mode *mode)
{
ggi_palemu_priv *priv = PALEMU_PRIV(vis);
int err;
DPRINT_MODE("display-palemu: setmode %dx%d#%dx%dF%d[0x%02x]\n",
mode->visible.x, mode->visible.y,
mode->virt.x, mode->virt.y,
mode->frames, mode->graphtype);
MANSYNC_ignore(vis);
if ((err = ggiCheckMode(vis->instance.stem, mode)) != 0) {
return err;
}
_ggiZapMode(vis, 0);
*LIBGGI_MODE(vis) = *mode;
priv->parent_mode.visible = mode->visible;
priv->parent_mode.virt = mode->virt;
priv->parent_mode.dpp = mode->dpp;
priv->parent_mode.size = mode->size;
priv->parent_mode.frames = 1;
if ((err = do_setmode(vis)) != 0) {
DPRINT_MODE("display-palemu: setmode failed (%d).\n", err);
return err;
}
priv->squish.x = mode->visible.x / target_width;
priv->squish.y = mode->visible.y / target_height;
DPRINT_MODE("display-palemu: Attempting to setmode on parent "
"visual...\n");
if (priv->target == PALEMU_TARGET) {
err = _ggi_palemu_Open(vis);
} else {
err = _ggi_monotext_Open(vis);
}
if (err != 0) {
return err;
}
/* Initialize palette */
ggiSetColorfulPalette(vis->instance.stem);
MANSYNC_SETFLAGS(vis, LIBGGI_FLAGS(vis));
MANSYNC_cont(vis);
DPRINT_MODE("display-palemu: setmode succeeded.\n");
return 0;
}
static void perf_CHECK(TeleUser *u, TeleEvent *ev)
{
TeleCmdOpenData *d = (TeleCmdOpenData *) ev->data;
ggi_mode mode;
T_Long reply_sequence;
int err;
/* get target to check mode */
mode.graphtype = (ggi_graphtype) d->graphtype;
mode.frames = (uint32_t) d->frames;
mode.visible.x = (int16_t) d->visible.width;
mode.visible.y = (int16_t) d->visible.height;
mode.virt.x = (int16_t) d->virt.width;
mode.virt.y = (int16_t) d->virt.height;
mode.size.x = (int16_t) d->size.width;
mode.size.y = (int16_t) d->size.height;
mode.dpp.x = (int16_t) d->dot.width;
mode.dpp.y = (int16_t) d->dot.height;
d->error = ggiCheckMode(vis, &mode);
/* send result back to client */
reply_sequence = ev->sequence;
tserver_new_event(u, ev, TELE_CMD_CHECK,
sizeof(TeleCmdOpenData), 0);
ev->sequence = reply_sequence;
d->graphtype = (T_Long) mode.graphtype;
d->frames = (T_Long) mode.frames;
d->visible.width = (T_Long) mode.visible.x;
d->visible.height = (T_Long) mode.visible.y;
d->virt.width = (T_Long) mode.virt.x;
d->virt.height = (T_Long) mode.virt.y;
d->size.width = (T_Long) mode.size.x;
d->size.height = (T_Long) mode.size.y;
d->dot.width = (T_Long) mode.dpp.x;
d->dot.height = (T_Long) mode.dpp.y;
err = tserver_write(u, ev);
if (err == TELE_ERROR_SHUTDOWN) {
/* Client has gone away */
close_connection(1);
return;
}
}
static int query_format(uint32_t format)
{
ggi_mode mode;
uint32_t vfcap;
vfcap = VFCAP_CSP_SUPPORTED
| VFCAP_CSP_SUPPORTED_BY_HW
| VFCAP_ACCEPT_STRIDE;
if ((!vo_depthonscreen || !vo_dbpp) && ggi_conf.vis) {
if (ggiGetMode(ggi_conf.vis, &mode) == 0) {
vo_depthonscreen = GT_DEPTH(mode.graphtype);
vo_dbpp = GT_SIZE(mode.graphtype);
}
if (GT_SCHEME(mode.graphtype) == GT_AUTO) {
ggiCheckMode(ggi_conf.vis, &mode);
}
if (GT_SCHEME(mode.graphtype) != GT_TRUECOLOR) {
mode.graphtype = GT_32BIT;
vo_depthonscreen = GT_DEPTH(mode.graphtype);
vo_dbpp = GT_SIZE(mode.graphtype);
}
}
if ((IMGFMT_IS_BGR(format) && (IMGFMT_BGR_DEPTH(format) == vo_dbpp)) ||
(IMGFMT_IS_RGB(format) && (IMGFMT_RGB_DEPTH(format) == vo_dbpp)))
{
return vfcap;
}
if (IMGFMT_IS_BGR(format) || IMGFMT_IS_RGB(format)) {
set_graphtype(format, &mode);
if (ggiCheckMode(ggi_conf.drawvis, &mode) < 0) {
return 0;
} else {
return vfcap;
}
}
return (0);
}
int GGI_vcsa_setmode(struct ggi_visual *vis, ggi_mode *mode)
{
char libname[GGI_MAX_APILEN], libargs[GGI_MAX_APILEN];
int err, id;
if ((err = ggiCheckMode(vis->instance.stem, mode)) != 0) {
return err;
}
DPRINT_MODE("display-vcsa: setmode %dx%d#%dx%dF%d[0x%02x]\n",
mode->visible.x, mode->visible.y,
mode->virt.x, mode->virt.y,
mode->frames, mode->graphtype);
memcpy(LIBGGI_MODE(vis), mode, sizeof(ggi_mode));
_ggiZapMode(vis, 0);
/* load API libraries */
for (id=1; GGI_vcsa_getapi(vis, id, libname, libargs) == 0; id++) {
err = _ggiOpenDL(vis, libggi->config, libname, libargs, NULL);
if (err) {
fprintf(stderr,"display-vcsa: Error opening the "
"%s (%s) library.\n", libname, libargs);
return GGI_EFATAL;
}
DPRINT_LIBS("Success in loading %s (%s)\n", libname, libargs);
}
/* setup drawing primitives */
vis->opdraw->putpixel_nc = GGI_vcsa_putpixel_nc;
vis->opdraw->getpixel_nc = GGI_vcsa_getpixel_nc;
vis->opdraw->putc = GGI_vcsa_putc;
vis->opdraw->puts = GGI_vcsa_puts;
vis->opdraw->getcharsize = GGI_vcsa_getcharsize;
vis->opdraw->drawhline_nc = GGI_vcsa_drawhline_nc;
vis->opdraw->puthline = GGI_vcsa_puthline;
vis->opdraw->gethline = GGI_vcsa_gethline;
vis->opcolor->mapcolor = GGI_vcsa_mapcolor;
vis->opcolor->unmappixel = GGI_vcsa_unmappixel;
/* indicate API change */
ggiIndicateChange(vis->instance.stem, GGI_CHG_APILIST);
DPRINT_MODE("display-vcsa: setmode Success.\n");
return 0;
}
int GGI_trueemu_setmode(struct ggi_visual *vis, ggi_mode *mode)
{
ggi_trueemu_priv *priv = TRUEEMU_PRIV(vis);
int err;
DPRINT_MODE("display-trueemu: setmode %dx%d#%dx%dF%d[0x%02x]\n",
mode->visible.x, mode->visible.y,
mode->virt.x, mode->virt.y,
mode->frames, mode->graphtype);
MANSYNC_ignore(vis);
if ((err = ggiCheckMode(vis->instance.stem, mode)) != 0) {
return err;
}
_ggiZapMode(vis, 0);
*LIBGGI_MODE(vis) = *mode;
priv->mode.visible = mode->visible;
priv->mode.virt = mode->virt;
priv->mode.dpp = mode->dpp;
priv->mode.size = mode->size;
priv->mode.frames = 1;
if ((err = do_setmode(vis)) != 0) {
DPRINT_MODE("display-trueemu: setmode failed (%d).\n", err);
return err;
}
DPRINT_MODE("display-trueemu: Attempting to setmode on parent "
"visual...\n");
if ((err = _ggi_trueemu_Open(vis)) != 0) {
return err;
}
MANSYNC_SETFLAGS(vis, LIBGGI_FLAGS(vis));
MANSYNC_cont(vis);
DPRINT_MODE("display-trueemu: setmode succeeded.\n");
return 0;
}
static void testcase8(const char *desc)
{
int err;
ggi_visual_t vis;
ggi_mode mode;
printteststart(__FILE__, __PRETTY_FUNCTION__, EXPECTED2PASS, desc);
if (dontrun) return;
err = ggiInit();
printassert(err == GGI_OK, "ggiInit failed with %i\n", err);
vis = ggiOpen(NULL);
printassert(vis != NULL, "ggiOpen() failed\n");
mode.virt.x = mode.virt.y = GGI_AUTO;
mode.visible.x = mode.visible.y = GGI_AUTO;
mode.frames = GGI_AUTO;
mode.graphtype = GT_AUTO;
mode.dpp.x = mode.dpp.y = 1;
mode.size.x = -19493;
mode.size.y = 31831;
/* Get the default mode */
ggiCheckMode(vis, &mode);
err = ggiSetMode(vis, &mode);
if (err != GGI_OK) {
printfailure("ggiSetMode() failed even though ggiCheckMode() was called!\n");
ggiClose(vis);
ggiExit();
return;
}
ggiClose(vis);
ggiExit();
printsuccess();
return;
}
static int config(uint32_t width, uint32_t height, uint32_t d_width,
uint32_t d_height, uint32_t flags, char *title,
uint32_t format)
{
ggi_mode mode = {
1, /* frames */
{width, height}, /* visible */
{GGI_AUTO, GGI_AUTO}, /* virt */
{GGI_AUTO, GGI_AUTO}, /* size */
GT_AUTO, /* graphtype */
{GGI_AUTO, GGI_AUTO} /* dots per pixel */
};
set_graphtype(format, &mode);
#if 0
printf("[ggi] mode: ");
ggiPrintMode(&mode);
printf("\n");
#endif
ggiCheckMode(ggi_conf.vis, &mode);
if (ggiSetMode(ggi_conf.vis, &mode) < 0) {
mp_msg(MSGT_VO, MSGL_ERR, "[ggi] unable to set display mode\n");
return (-1);
}
if (ggiGetMode(ggi_conf.vis, &mode) < 0) {
mp_msg(MSGT_VO, MSGL_ERR, "[ggi] unable to get display mode\n");
return (-1);
}
if ((mode.graphtype == GT_INVALID)
|| (mode.graphtype == GT_AUTO))
{
mp_msg(MSGT_VO, MSGL_ERR, "[ggi] not supported depth/bpp\n");
return (-1);
}
#if 0
printf("[ggi] mode: ");
ggiPrintMode(&mode);
printf("\n");
#endif
#ifdef HAVE_GGIWMH
ggiWmhSetTitle(ggi_conf.vis, title);
if (vo_ontop) window_ontop();
#endif
ggiSetFlags(ggi_conf.vis, GGIFLAG_ASYNC);
if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
ggiSetColorfulPalette(ggi_conf.vis);
if (GT_SCHEME(mode.graphtype) != GT_TRUECOLOR) {
ggi_mode drawmode;
ggi_conf.drawvis = ggiOpen("display-memory", NULL);
if (ggi_conf.drawvis == NULL) {
mp_msg(MSGT_VO, MSGL_ERR,
"[ggi] unable to get backbuffer for conversion\n");
return -1;
}
memcpy(&drawmode, &mode, sizeof(ggi_mode));
drawmode.graphtype = GT_32BIT;
drawmode.size.x = GGI_AUTO;
drawmode.size.y = GGI_AUTO;
ggiCheckMode(ggi_conf.drawvis, &drawmode);
if (ggiSetMode(ggi_conf.drawvis, &drawmode) < 0) {
mp_msg(MSGT_VO, MSGL_ERR,
"[ggi] unable to set backbuffer mode\n");
return -1;
}
mode.graphtype = drawmode.graphtype;
ggiSetFlags(ggi_conf.drawvis, GGIFLAG_ASYNC);
}
vo_depthonscreen = GT_DEPTH(mode.graphtype);
vo_screenwidth = mode.virt.x;
vo_screenheight = mode.virt.y;
vo_dwidth = width;
vo_dheight = height;
vo_dbpp = GT_SIZE(mode.graphtype);
/* calculate top, left corner */
vo_dx = (vo_screenwidth - vo_dwidth) / 2;
vo_dy = (vo_screenheight - vo_dheight) / 2;
ggi_conf.srcwidth = width;
ggi_conf.srcheight = height;
ggi_conf.srcformat = format;
ggi_conf.voflags = flags;
if (IMGFMT_IS_RGB(ggi_conf.srcformat)) {
ggi_conf.srcdepth = IMGFMT_RGB_DEPTH(ggi_conf.srcformat);
} else if (IMGFMT_IS_BGR(ggi_conf.srcformat)) {
ggi_conf.srcdepth = IMGFMT_BGR_DEPTH(ggi_conf.srcformat);
} else {
mp_msg(MSGT_VO, MSGL_FATAL, "[ggi] Unknown image format: %s\n",
vo_format_name(ggi_conf.srcformat));
return (-1);
}
mp_msg(MSGT_VO, MSGL_INFO, "[ggi] input: %dx%dx%d, output: %dx%dx%d\n",
ggi_conf.srcwidth, ggi_conf.srcheight, ggi_conf.srcdepth,
mode.virt.x, mode.virt.y, vo_dbpp);
ggi_conf.srcbpp = (ggi_conf.srcdepth + 7) / 8;
ggi_conf.flushregion.x1 = vo_dx;
ggi_conf.flushregion.y1 = vo_dy;
ggi_conf.flushregion.x2 = vo_dwidth;
ggi_conf.flushregion.y2 = vo_dheight;
return (0);
}
static void testcase1(const char *desc)
{
int ret;
ggi_visual_t vis;
ggi_mode mode;
ggi_pixel pixel_color;
ggi_color color_color;
#if 0
unsigned int j, size;
const ggi_directbuffer *dbuf = NULL;
#endif
color_color.r = 0x0000;
color_color.g = 0xffff;
color_color.b = 0xffff;
printteststart(__FILE__, __PRETTY_FUNCTION__, EXPECTED2PASS, desc);
if (dontrun) return;
vis = ggNewStem(libggi, NULL);
if (vis == NULL) {
printfailure("Couldn't create stem for %s", DISPLAYSTR);
return;
}
ret = ggiOpen(vis, DISPLAYSTR, NULL);
if (ret != 0) {
printfailure("Couldn't open %s", DISPLAYSTR);
return;
}
#if 0
/* Here, XGGI would switch to async mode,
* if there were a place to hook in ggiFlush()
*/
ggiSetFlags(vis, GGIFLAG_ASYNC);
#endif
/* Now check, if mansync is actually running
* - note, we are in sync mode here.
*/
/* stop mansync. If it runs as it should,
* we don't fail with an assertion here */
ret = MANSYNC_stop(STEM_API_DATA(vis, libggi, struct ggi_visual*));
if (ret != 0) {
printfailure("BUG: mansync not running - forgot to call "
"MANSYNC_start(vis) right after MANSYNC_init(vis)?\n");
goto exit_testcase;
}
/* now restart it */
ret = MANSYNC_start(STEM_API_DATA(vis, libggi, struct ggi_visual*));
if (ret != 0) {
printfailure("BUG: mansync couldn't be relaunched\n");
goto exit_testcase;
}
ggiParseMode("", &mode);
ggiCheckMode(vis, &mode);
ret = ggiSetMode(vis, &mode);
if (ret != GGI_OK) {
printfailure("expected return value: \"%i\"\n"
"actual return value: \"%i\"\n",
GGI_OK, ret);
goto exit_testcase;
}
/* Disable directbuffer as this is not required to
* perform the test
*/
#if 0
ret = -1;
size = GT_SIZE(mode.graphtype);
for (j = 0;
(dbuf = ggiDBGetBuffer(vis, j)) != NULL;
j++)
{
if ((dbuf->type & GGI_DB_SIMPLE_PLB)
&& ((8*dbuf->buffer.plb.stride) % size) == 0)
{
/* found */
ret = GGI_OK;
break;
}
}
if (ret != GGI_OK) {
printfailure("This mode and target has no suitable DirectBuffer\n");
goto exit_testcase;
}
if (ggiResourceAcquire(dbuf->resource,
GGI_ACTYPE_WRITE | GGI_ACTYPE_READ)
!= 0)
{
printfailure("Unable to acquire DirectBuffer\n");
goto exit_testcase;
}
#endif
/* ... and now draw something.
*/
pixel_color = ggiMapColor(vis, &color_color);
ggiSetGCForeground(vis, pixel_color);
ggiFillscreen(vis);
#if 0
ggiResourceRelease(dbuf->resource);
#endif
exit_testcase:
ggDelStem(vis);
printsuccess();
return;
}
SDL_Surface *GGI_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
{
ggi_mode mode =
{
1,
{ GGI_AUTO, GGI_AUTO },
{ GGI_AUTO, GGI_AUTO },
{ 0, 0 },
GT_AUTO,
{ GGI_AUTO, GGI_AUTO }
};
const ggi_directbuffer *db;
ggi_color pal[256];
int err;
fprintf(stderr, "GGI_SetVideoMode()\n");
mode.visible.x = mode.virt.x = width;
mode.visible.y = mode.virt.y = height;
/* Translate requested SDL bit depth into a GGI mode */
switch (bpp)
{
case 1: mode.graphtype = GT_1BIT; break;
case 2: mode.graphtype = GT_2BIT; break;
case 4: mode.graphtype = GT_4BIT; break;
case 8: mode.graphtype = GT_8BIT; break;
case 15: mode.graphtype = GT_15BIT; break;
case 16: mode.graphtype = GT_16BIT; break;
case 24: mode.graphtype = GT_24BIT; break;
case 32: mode.graphtype = GT_32BIT; break;
default:
SDL_SetError("Unknown SDL bit depth, using GT_AUTO....\n");
mode.graphtype = GT_AUTO;
}
/* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */
ggiCheckMode(VIS, &mode);
/* At this point we should have a valid mode - try to set it */
err = ggiSetMode(VIS, &mode);
/* If we couldn't set _any_ modes, something is very wrong */
if (err)
{
SDL_SetError("Can't set a mode!\n");
ggiClose(VIS);
ggiExit();
GGI_VideoQuit(NULL);
}
/* Set a palette for palletized modes */
if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
{
ggiSetColorfulPalette(VIS);
ggiGetPalette(VIS, 0, 1 << bpp, pal);
}
db = ggiDBGetBuffer(VIS, 0);
/* Set up the new mode framebuffer */
current->flags = (SDL_FULLSCREEN | SDL_HWSURFACE);
current->w = mode.virt.x;
current->h = mode.virt.y;
current->pitch = db->buffer.plb.stride;
current->pixels = db->read;
/* Set the blit function */
this->UpdateRects = GGI_DirectUpdate;
/* We're done */
return(current);
}
int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat)
{
ggi_mode mode =
{
1,
{ GGI_AUTO, GGI_AUTO },
{ GGI_AUTO, GGI_AUTO },
{ 0, 0 },
GT_AUTO,
{ GGI_AUTO, GGI_AUTO }
};
struct private_hwdata *priv;
ggi_color pal[256], map[256];
const ggi_directbuffer *db;
int err, num_bufs;
ggi_pixel white, black;
priv = SDL_malloc(sizeof(struct private_hwdata));
if (priv == NULL)
{
SDL_SetError("Unhandled GGI mode type!\n");
GGI_VideoQuit(NULL);
}
if (ggiInit() != 0)
{
SDL_SetError("Unable to initialize GGI!\n");
GGI_VideoQuit(NULL);
}
VIS = ggiOpen(NULL);
if (VIS == NULL)
{
SDL_SetError("Unable to open default GGI visual!\n");
ggiExit();
GGI_VideoQuit(NULL);
}
ggiSetFlags(VIS, GGIFLAG_ASYNC);
/* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */
ggiCheckMode(VIS, &mode);
/* At this point we should have a valid mode - try to set it */
err = ggiSetMode(VIS, &mode);
/* If we couldn't set _any_ modes, something is very wrong */
if (err)
{
SDL_SetError("Can't set a mode!\n");
ggiClose(VIS);
ggiExit();
GGI_VideoQuit(NULL);
}
/* Determine the current screen size */
this->info.current_w = mode.virt.x;
this->info.current_h = mode.virt.y;
/* Set a palette for palletized modes */
if (GT_SCHEME(mode.graphtype) == GT_PALETTE)
{
ggiSetColorfulPalette(VIS);
ggiGetPalette(VIS, 0, 1 << vformat->BitsPerPixel, pal);
}
/* Now we try to get the DirectBuffer info, which determines whether
* SDL can access hardware surfaces directly. */
num_bufs = ggiDBGetNumBuffers(VIS);
if (num_bufs > 0)
{
db = ggiDBGetBuffer(VIS, 0); /* Only handle one DB for now */
vformat->BitsPerPixel = db->buffer.plb.pixelformat->depth;
vformat->Rmask = db->buffer.plb.pixelformat->red_mask;
vformat->Gmask = db->buffer.plb.pixelformat->green_mask;
vformat->Bmask = db->buffer.plb.pixelformat->blue_mask;
/* Fill in our hardware acceleration capabilities */
this->info.wm_available = 0;
this->info.hw_available = 1;
this->info.video_mem = db->buffer.plb.stride * mode.virt.y;
}
video_mode.x = 0;
video_mode.y = 0;
video_mode.w = mode.virt.x;
video_mode.h = mode.virt.y;
SDL_modelist[((vformat->BitsPerPixel + 7) / 8) - 1] = &video_mode;
/* We're done! */
return(0);
}
static int GGIopen(struct ggi_visual *vis, struct ggi_dlhandle *dlh,
const char *args, void *argptr, uint32_t_t_t *dlret)
{
ggi_mode mode;
void *memptr=NULL;
suid_hook *priv;
int x, err = GGI_ENOMEM;
LIBGGI_GC(vis) = malloc(sizeof(ggi_gc));
if (LIBGGI_GC(vis) == NULL) {
return GGI_ENOMEM;
}
priv = LIBGGI_PRIVATE(vis) = malloc(sizeof(suid_hook));
if (priv == NULL) {
goto out_freegc;
}
priv->is_up=0;
priv->dev_mem=_suidtarget_dev_mem=-1;
priv->mmap_length=0;
/* Open GII for input */
vis->input = giiOpen("input-linux-kbd", NULL);
if (vis->input == NULL) {
fprintf(stderr, "display-suidkgi: Couldn't open kbd.\n");
goto out_freepriv;
}
/* Has mode management */
vis->opdisplay->getmode=GGI_suidkgi_getmode;
vis->opdisplay->setmode=GGI_suidkgi_setmode;
vis->opdisplay->checkmode=GGI_suidkgi_checkmode;
vis->opdisplay->flush=GGI_suidkgi_flush;
vis->opdisplay->kgicommand=GGI_suidkgi_kgicommand;
vis->opdisplay->setflags=GGI_suidkgi_setflags;
vis->opdraw->setorigin=GGI_suidkgi_setorigin;
vis->w_frame = malloc(sizeof(ggi_directbuffer)); /* FIXME ! */
vis->r_frame = malloc(sizeof(ggi_directbuffer)); /* FIXME ! */
LIBGGI_CURWRITE(vis)=NULL;
LIBGGI_CURREAD(vis)=NULL;
if (iopl(3)) {perror("iopl");exit(2); }
DPRINT("IOPL is here.\n");
if (-1 == (priv->dev_mem = _suidtarget_dev_mem = open("/dev/mem",O_RDWR))) { perror("opening /dev/mem");exit(3); }
memptr=mmap(NULL,64*1024,PROT_READ|PROT_WRITE,MAP_SHARED,priv->dev_mem,0xa0000);
DPRINT("Have mmap at %p.\n",memptr);
/* law_base=0xf3000000; */
if (suidkgi_init_module()) {DPRINT("Init has failed. Tough luck.\n");exit(1); }
DPRINT("Init was o.k.\n");
signal(SIGSEGV,get_killed);
signal(SIGINT,get_killed);
signal(SIGTERM,get_killed);
priv->is_up=1;
#if 1
/* Not sure, if this is needed, but ... */
mode.frames=1;
mode.graphtype=GT_TEXT16;
mode.visible.x=mode.virt.x=80;
mode.visible.y=mode.virt.y=25;
mode.dpp.x = 8;mode.dpp.y =16;
x=GGI_suidkgi_checkmode(vis,&mode);
DPRINT("TESTMODE1 says %d.\n",x);
x=GGI_suidkgi_setmode(vis,&mode);
DPRINT("SETMODE1 says %d.\n",x);
#endif
#undef TESTING_THE_SUID_TARGET
#ifdef TESTING_THE_SUID_TARGET
#ifdef GoneByeBye
for(x=0;x<480;x++)
{
GGI_suidkgi_setsplitline(vis, x);
ggUSleep(100000);
}
#endif
mode.frames=1;
mode.graphtype=GT_8BIT;
mode.visible.x=mode.virt.x=320;
mode.visible.y=mode.virt.y=200;
mode.dpp.x =mode.dpp.y =1;
x=ggiCheckMode(vis,&mode);
DPRINT("TESTMODE3 says %d.\n",x);
x=ggiSetMode(vis,&mode);
DPRINT("SETMODE3 says %d.\n",x);
sleep(1);
{ int y;
for(y=0;y<200;y++)
{
for(x=0;x<320;x++)
{
*((unsigned char *)memptr+x+y*320)=x+y;
}
ggUSleep(1);
}
}
sleep(1);
mode.frames=1;
mode.graphtype=GT_TEXT16;
mode.visible.x=mode.virt.x=80;
mode.visible.y=mode.virt.y=25;
mode.dpp.x = 8;mode.dpp.y =16;
x=GGI_suidkgi_checkmode(vis,&mode);
DPRINT("TESTMODE4 says %d.\n",x);
x=GGI_suidkgi_setmode(vis,&mode);
DPRINT("SETMODE4 says %d.\n",x);
sleep(1);
suidkgi_cleanup_module();
DPRINT("Cleanup went well.\n");
close(priv->dev_mem);
exit(1);
#endif
*dlret = GGI_DL_OPDISPLAY|GGI_DL_OPDRAW;
return 0;
out_freepriv:
free(priv);
out_freegc:
free(LIBGGI_GC(vis);
return err;
}
static void testcase4(const char *desc)
{
int err;
ggi_visual_t vis;
ggi_mode mode;
ggi_coord size;
printteststart(__FILE__, __PRETTY_FUNCTION__, EXPECTED2PASS, desc);
if (dontrun) return;
err = ggiInit();
printassert(err == GGI_OK, "ggiInit failed with %i\n", err);
vis = ggiOpen(NULL);
printassert(vis != NULL, "ggiOpen() failed\n");
err = ggiCheckSimpleMode(
vis, GGI_AUTO, GGI_AUTO, GGI_AUTO, GT_AUTO, &mode);
printassert(err == GGI_OK, "ggiCheckSimpleMode: can't find a mode\n");
if(err != GGI_OK) {
ggiClose(vis);
ggiExit();
printsuccess();
return;
}
printassert(mode.size.x != GGI_AUTO && mode.size.y != GGI_AUTO,
"physical size is apparently not supported\n");
if(mode.size.x == GGI_AUTO || mode.size.y == GGI_AUTO) {
ggiClose(vis);
ggiExit();
printsuccess();
return;
}
/* Clear out all but the physical size */
mode.frames = GGI_AUTO;
mode.visible.x = GGI_AUTO;
mode.visible.y = GGI_AUTO;
mode.virt.x = GGI_AUTO;
mode.virt.y = GGI_AUTO;
mode.graphtype = GT_AUTO;
mode.dpp.x = GGI_AUTO;
mode.dpp.y = GGI_AUTO;
size = mode.size;
/* This mode should be there */
err = ggiCheckMode(vis, &mode);
ggiClose(vis);
ggiExit();
if (err != GGI_OK) {
printfailure("ggiCheckMode: expected return value: GGI_OK\n"
"actual return value: %i\n", err);
return;
}
if (mode.size.x != size.x) {
printfailure(
"ggiCheckMode: size.x: expected return value: %i\n"
"actual return value: %i\n",
size.x, mode.size.x);
return;
}
if (mode.size.y != size.y) {
printfailure(
"ggiCheckMode: size.y: expected return value: %i\n"
"actual return value: %i\n",
size.y, mode.size.y);
return;
}
printsuccess();
}
int GGI_palemu_checkmode(struct ggi_visual *vis, ggi_mode *mode)
{
ggi_palemu_priv *priv = PALEMU_PRIV(vis);
ggi_mode par_mode;
int tmperr, err = 0;
DPRINT_MODE("display-palemu: checkmode %dx%d#%dx%dF%d[0x%02x]\n",
mode->visible.x, mode->visible.y,
mode->virt.x, mode->virt.y,
mode->frames, mode->graphtype);
/* Handle graphtype */
if (GT_SCHEME(mode->graphtype) == GT_AUTO) {
GT_SETSCHEME(mode->graphtype, GT_PALETTE);
}
mode->graphtype = _GGIhandle_gtauto(mode->graphtype);
if (GT_SCHEME(mode->graphtype) != GT_PALETTE) {
GT_SETSCHEME(mode->graphtype, GT_PALETTE);
err = -1;
}
if (GT_DEPTH(mode->graphtype) > 8) {
GT_SETDEPTH(mode->graphtype, 8);
err = -1;
}
if (GT_SIZE(mode->graphtype) != GT_DEPTH(mode->graphtype)) {
GT_SETSIZE(mode->graphtype, GT_DEPTH(mode->graphtype));
err = -1;
}
/* Handle geometry */
if (mode->visible.x == GGI_AUTO) {
mode->visible.x = priv->parent_defmode.visible.x;
}
if (mode->visible.y == GGI_AUTO) {
mode->visible.y = priv->parent_defmode.visible.y;
}
if (mode->virt.x == GGI_AUTO) {
mode->virt.x = priv->parent_defmode.virt.x;
}
if (mode->virt.y == GGI_AUTO) {
mode->virt.y = priv->parent_defmode.virt.y;
}
if (mode->dpp.x == GGI_AUTO) {
mode->dpp.x = priv->parent_defmode.dpp.x;
}
if (mode->dpp.y == GGI_AUTO) {
mode->dpp.y = priv->parent_defmode.dpp.y;
}
if (mode->size.x == GGI_AUTO) {
mode->size.x = priv->parent_defmode.size.x;
}
if (mode->size.y == GGI_AUTO) {
mode->size.y = priv->parent_defmode.size.y;
}
if (mode->frames == GGI_AUTO) {
mode->frames = 1;
}
/* Now check mode against the parent target (letting the parent
* target handle any remaining GT_AUTO and GGI_AUTO values).
*/
par_mode = *mode;
par_mode.graphtype = priv->parent_defmode.graphtype;
tmperr = ggiCheckMode(priv->parent, &par_mode);
if (tmperr) err = tmperr;
mode->visible = par_mode.visible;
mode->virt = par_mode.virt;
mode->dpp = par_mode.dpp;
mode->size = par_mode.size;
/* When the parent is palettized, we must limit the
* resulting depth to be <= the parent depth.
*/
if ((GT_SCHEME(par_mode.graphtype) == GT_PALETTE) &&
(GT_DEPTH(par_mode.graphtype) <
GT_DEPTH(mode->graphtype))) {
GT_SETDEPTH(mode->graphtype,
GT_DEPTH(par_mode.graphtype));
GT_SETSIZE(mode->graphtype,
GT_DEPTH(par_mode.graphtype));
err = -1;
}
DPRINT_MODE("display-palemu: result %d %dx%d#%dx%dF%d[0x%02x]\n",
err, mode->visible.x, mode->visible.y,
mode->virt.x, mode->virt.y,
mode->frames, mode->graphtype);
return err;
}
int GGI_trueemu_checkmode(struct ggi_visual *vis, ggi_mode *mode)
{
ggi_trueemu_priv *priv = TRUEEMU_PRIV(vis);
ggi_mode par_mode;
int tmperr, err = 0;
DPRINT_MODE("display-trueemu: checkmode %dx%d#%dx%dF%d[0x%02x]\n",
mode->visible.x, mode->visible.y,
mode->virt.x, mode->virt.y,
mode->frames, mode->graphtype);
/* Handle graphtype */
if (GT_SCHEME(mode->graphtype) == GT_AUTO) {
GT_SETSCHEME(mode->graphtype, GT_TRUECOLOR);
}
mode->graphtype = _GGIhandle_gtauto(mode->graphtype);
if (GT_SCHEME(mode->graphtype) != GT_TRUECOLOR) {
GT_SETSCHEME(mode->graphtype, GT_TRUECOLOR);
err = -1;
}
if (GT_DEPTH(mode->graphtype) != 24) {
GT_SETDEPTH(mode->graphtype, 24);
err = -1;
}
if ((GT_SIZE(mode->graphtype) != GT_DEPTH(mode->graphtype)) &&
(GT_SIZE(mode->graphtype) != 32)) {
GT_SETSIZE(mode->graphtype, GT_DEPTH(mode->graphtype));
err = -1;
}
/* Handle geometry */
if (mode->visible.x == GGI_AUTO) {
mode->visible.x = priv->mode.visible.x;
}
if (mode->visible.y == GGI_AUTO) {
mode->visible.y = priv->mode.visible.y;
}
if (mode->virt.x == GGI_AUTO) {
mode->virt.x = priv->mode.virt.x;
}
if (mode->virt.y == GGI_AUTO) {
mode->virt.y = priv->mode.virt.y;
}
if (mode->dpp.x == GGI_AUTO) {
mode->dpp.x = priv->mode.dpp.x;
}
if (mode->dpp.y == GGI_AUTO) {
mode->dpp.y = priv->mode.dpp.y;
}
if (mode->size.x == GGI_AUTO) {
mode->size.x = priv->mode.size.x;
}
if (mode->size.y == GGI_AUTO) {
mode->size.y = priv->mode.size.y;
}
if (mode->frames == GGI_AUTO) {
mode->frames = 1;
}
/* Now let the parent target have it's say in the checkmode
* process. It can deal with any remaining GGI_AUTO or GT_AUTO
* values that came from priv->mode.
*/
par_mode = *mode;
par_mode.graphtype = priv->mode.graphtype;
tmperr = ggiCheckMode(priv->parent, &par_mode);
if (tmperr) err = tmperr;
mode->visible = par_mode.visible;
mode->virt = par_mode.virt;
mode->dpp = par_mode.dpp;
mode->size = par_mode.size;
DPRINT_MODE("display-trueemu: upgraded to %dx%d#%dx%dF%d[0x%02x]\n",
mode->visible.x, mode->visible.y,
mode->virt.x, mode->virt.y,
mode->frames, mode->graphtype);
return err;
}
