Beispiel #1
0
static int
GGI_helper_x_shm_setup(struct ggi_helper *helper,
			const char *args, void *argptr)
{
	ggi_x_priv *priv;
	int major, minor;
	Bool pixmaps;

	DPRINT_LIBS("GGI_helper_x_shm_setup(%p, %s, %p) called\n",
		helper, args, argptr);

	priv = GGIX_PRIV(helper->visual);

	if (XShmQueryExtension(priv->disp) != True)
		return GGI_ENOFUNC;
	if (XShmQueryVersion(priv->disp, &major, &minor, &pixmaps) != True)
		return GGI_ENOFUNC;

	DPRINT_LIBS("X: MIT-SHM: SHM version %i.%i %s pixmap support\n",
		major, minor, pixmaps ? "with" : "without");

	priv->createfb = _ggi_xshm_create_ximage;
	priv->freefb = _ggi_xshm_free_ximage;

	return GGI_OK;
}
Beispiel #2
0
static int
GII_save_close(gii_input *inp)
{
	save_priv *priv = inp->priv;

	DPRINT_LIBS("GII_save_close(%p) called\n", inp);

	fflush(priv->output);
	
	switch (priv->type) {
	case FIL:
		fclose(priv->output);
		break;
	case PIPE:
		pclose(priv->output);
		break;
	default: 
		break;
	}
	free(priv);

	DPRINT_LIBS("GII_save_close done\n");

	return 0;
}
Beispiel #3
0
static int GIIdlinit(struct gii_input *inp, const char *args, void *argptr,
		     const char *target) {
	struct target * t;
	
	for(t = _targets; t->target != NULL; t++) {
		if(!strcmp(t->target, target)) {
			DPRINT_LIBS("- try to launch builtin target \"%s\"\n", target);
			return t->func(inp, args, argptr, target);
		}
	}
	
	DPRINT_LIBS("! unknown builtin target \"%s\"\n", target);
	return GGI_ENOTFOUND;
}
Beispiel #4
0
int GIIdl_linux_evdev(gii_input * inp, const char *args, void *argptr)
{
	const char *devname = "/dev/input/event0";
	gii_levdev_priv *priv;
	int fd;

	DPRINT_LIBS("Linux evdev starting.\n");

	if (args && *args)
		devname = args;

	fd = open(devname, O_RDONLY);
	if (fd < 0)
		return GGI_ENODEVICE;

	priv = malloc(sizeof(*priv));
	if (priv == NULL) {
		close(fd);
		return GGI_ENOMEM;
	}

	if (_giiRegisterDevice(inp, &priv->devinfo, &priv->valinfo[0]) == 0) {
		free(priv);
		close(fd);
		return GGI_ENOMEM;
	}


	inp->GIIsendevent = GIIsendevent;
	inp->GIIeventpoll = GII_levdev_poll;
	inp->GIIclose = GIIclose;

	inp->targetcan = emAll;
	inp->curreventmask = emAll;

	inp->maxfd = fd + 1;
	FD_SET(fd, &inp->fdset);

	priv->fd = fd;
	priv->eof = 0;

	inp->priv = priv;

	init_devinfo(inp);
	send_devinfo(inp);

	DPRINT_LIBS("Linux evdev up.\n");

	return 0;
}
Beispiel #5
0
static int
GII_save_handler(gii_input *inp, gii_event *event)
{
	save_priv *priv = inp->priv;
	DPRINT_LIBS("filter-save handler,priv=%p file=%p\n",
		    priv,priv->output);
	
	fwrite(event, event->any.size, 1, priv->output);
	
	return 0;
}
Beispiel #6
0
static int GII_quartz_close(gii_input *inp)
{
	quartz_priv *priv = QUARTZ_PRIV(inp);

	QuartzExit(priv);
	free(priv);

	DPRINT_LIBS("exit ok.\n");

	return 0;
}	/* GII_quartz_close */
Beispiel #7
0
int GIIdl_filter_save(gii_input *inp, const char *args, void *argptr)
{
	save_priv   *priv;

	DPRINT_LIBS("filter-save init(%p, \"%s\") called\n", inp,
		    args ? args : "");

	priv = malloc(sizeof(save_priv));
	if (priv == NULL) return GGI_ENOMEM;

	priv->output = stdout;
	priv->type = STDOUT;
	
	if (args && *args != '\0') {
		if (*args=='|') {
			fflush(stdout);
			fflush(stderr);
			priv->output = popen(args+1, "wb");
			priv->type = PIPE;
		} else {
			priv->output = fopen(args, "wb");
			priv->type = FIL;
		}
		if (priv->output == NULL) {
			fprintf(stderr, "filter-save: unable to open %s\n",
				args);
			free(priv);
			return GGI_ENODEVICE;
		}
	}

	inp->priv       = priv;
	inp->GIIhandler = GII_save_handler;
	inp->GIIclose   = GII_save_close;
	
	DPRINT_LIBS("filter-save fully up, priv=%p file=%p\n",
		    priv,priv->output);
	
	return 0;
}
Beispiel #8
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;
}
Beispiel #9
0
static void
GGI_helper_x_dbe_finish(struct ggi_helper *helper)
{
#if 0
	ggi_x_priv *priv = GGIX_PRIV(helper->visual);
	XdbeBackBuffer backBuffer;

	/* Deallocate back buffer */
	if(!XdbeDeallocateBackBufferName(priv->disp, priv->drawable)) {
		DPRINT_LIBS("X: DOUBLE-BUFFER: Unable to deallocate back buffer.\n");
		return GGI_EFATAL;
	}
#endif
}
Beispiel #10
0
int GGI_X_fillscreen_draw(ggi_visual *vis)
{
	ggi_x_priv *priv;
	XGCValues gcValue;
	GC gc;
	priv = GGIX_PRIV(vis);

	DPRINT("X_fillscreen_draw enter!\n");

	GGI_X_LOCK_XLIB(vis);
	
	/* XXX: What is priv->gc ?  is it appropriate to use that here? */
	gcValue.foreground = LIBGGI_GC(vis)->fg_color;
	gcValue.background = LIBGGI_GC(vis)->fg_color;
	gcValue.function   = GXcopy;
	gc = XCreateGC( priv->disp, priv->drawable,
	 		GCForeground | GCBackground | GCFunction, &gcValue);

	if (LIBGGI_GC(vis)->cliptl.x > 0
	    || LIBGGI_GC(vis)->cliptl.y > 0
	    || LIBGGI_GC(vis)->clipbr.x < LIBGGI_VIRTX(vis)
	    || LIBGGI_GC(vis)->clipbr.y < LIBGGI_VIRTY(vis)) {
		int y;
		/* Note: GGI_X_WRITE_Y is a macro that makes use
		 * of the value stored in y. */
		y = LIBGGI_GC(vis)->cliptl.y;
		y = GGI_X_WRITE_Y;

		/* CLIPSIZE macro is defined above in 
		 * GGI_X_fillscreen_slave_draw() */
		XFillRectangle(priv->disp, priv->drawable, 
			gc, 
		        LIBGGI_GC(vis)->cliptl.x, y,
			CLIPSIZE(x),
			CLIPSIZE(y)
			);
	} else {
		XFillRectangle(priv->disp, priv->drawable, 
			gc, 0, 0, LIBGGI_VIRTX(vis), LIBGGI_VIRTY(vis) );
	}
	GGI_X_MAYBE_SYNC(vis);
	GGI_X_UNLOCK_XLIB(vis);

	DPRINT_LIBS("X_fillscreen_draw exit!\n");
	return 0;
}
Beispiel #11
0
static int
GGI_helper_x_dbe_setup(struct ggi_helper *helper,
			const char *args, void *argptr)
{
	ggi_x_priv *priv = GGIX_PRIV(helper->visual);
	int major_version, minor_version;
	Status rc;

	/* Check if DBE is present before initialising */
	rc = XdbeQueryExtension(priv->disp, &major_version, &minor_version);
	if (rc != True) return GGI_ENOFUNC;

	DPRINT_LIBS("X: DOUBLE-BUFFER: DBE version %i.%i\n",
			major_version, minor_version);

	return GGI_OK;
}
Beispiel #12
0
static void
GGI_helper_x_shm_finish(struct ggi_helper *helper)
{
	ggi_x_priv *priv;

	DPRINT_LIBS("GGI_helper_x_shm_teardown(%p) called\n",
		helper);

	priv = GGIX_PRIV(helper->visual);

	if (priv && priv->freefb) {
		priv->freefb(helper->visual);
		priv->freefb = NULL;
	}

	return;
}
Beispiel #13
0
static int do_setmode(struct ggi_visual *vis)
{
	char libname[GGI_MAX_APILEN], libargs[GGI_MAX_APILEN];
	ggi_graphtype gt;
	int err, id;

	err = do_mmap(vis); 
	if (err) return err;

	_ggiZapMode(vis, 0);
	for (id=1; GGI_lcd823_getapi(vis, id, libname, libargs) == 0; id++) {
		if (_ggiOpenDL(vis, libggi->config, libname, libargs, NULL) != 0) {
			fprintf(stderr,"display-lcd823: Error opening the "
				"%s (%s) library.\n", libname, libargs);
			return GGI_EFATAL;
		}

		DPRINT_LIBS("Success in loading %s (%s)\n",
			       libname, libargs);
	}

	/* Set up palette */
	gt = LIBGGI_GT(vis);
	if ((GT_SCHEME(gt) == GT_PALETTE) || (GT_SCHEME(gt) == GT_TEXT)) {
	    	int nocols = 1 << GT_DEPTH(gt);

		LIBGGI_PAL(vis)->clut.size = nocols;
		LIBGGI_PAL(vis)->clut.data = _ggi_malloc(nocols * sizeof(ggi_color));
		LIBGGI_PAL(vis)->priv = _ggi_malloc(256 * sizeof(uint16_t));
		LIBGGI_PAL(vis)->setPalette  = GGI_lcd823_setPalette;
		LIBGGI_PAL(vis)->getPrivSize = GGI_lcd823_getPrivSize;
		/* Initialize palette */
		ggiSetColorfulPalette(vis);
	}

	ggiIndicateChange(vis, GGI_CHG_APILIST);

	DPRINT_MODE("display-lcd823: do_setmode SUCCESS\n");

	return 0;
}
Beispiel #14
0
static int GGI_DBE_create_window_drawable (struct ggi_visual *vis)
{
	ggi_x_priv *priv = GGIX_PRIV(vis);
	XdbeBackBuffer  backBuffer;

	if(priv->win == None)
		return GGI_ENODEVICE;

	priv->drawable = priv->win;

	/* Allocate back buffer */
	backBuffer = XdbeAllocateBackBufferName(priv->disp, 
			priv->win, XdbeUntouched);

	if (backBuffer != None) {
		priv->drawable = backBuffer;
		
	} else { 
		DPRINT_LIBS("X: DOUBLE-BUFFER: Back buffer allocation failed\n");
		return GGI_EFATAL;
	}
      
	return 0;
}
Beispiel #15
0
static void * _builtins_get(void * _, const char *symbol) {
	if(!strcmp(symbol, GII_DLINIT_SYM))
		return (void *)GIIdlinit;
	DPRINT_LIBS("! builtin symbol '%s' not found\n",symbol);
	return NULL;
}
Beispiel #16
0
static int GGIopen(ggi_visual *vis, struct ggi_dlhandle *dlh,
		   const char *args, void *argptr, uint32_t *dlret)
{
	ggi_fbdev_priv *fbdevpriv = FBDEV_PRIV(vis);
	struct m2164w_priv *priv;
	unsigned long usedmemend;
	size_t fontlen;
	int pixbytes;
	int fd = LIBGGI_FD(vis);
	int i;

	if (GT_SIZE(LIBGGI_GT(vis)) % 8 != 0 ||
	    GT_SIZE(LIBGGI_GT(vis)) > 32 ||
	    GT_SIZE(LIBGGI_GT(vis)) < 8) {
		/* Unsupported mode */
		return GGI_ENOFUNC;
	}
	pixbytes = GT_ByPP(LIBGGI_GT(vis));

	priv = malloc(sizeof(struct m2164w_priv));
	if (priv == NULL) {
		return GGI_ENOMEM;
	}

	fbdevpriv->mmioaddr = mmap(NULL, fbdevpriv->orig_fix.mmio_len,
				   PROT_READ | PROT_WRITE, MAP_SHARED,
				   fd, (signed)fbdevpriv->orig_fix.smem_len);
	if (fbdevpriv->mmioaddr == MAP_FAILED) {
		/* Can't mmap() MMIO region - bail out */
		DPRINT_LIBS("mga-2164w: Unable to map MMIO region: %s\n"
			       "          fd: %d, len: %ld, offset: %ld\n",
			       strerror(errno), fd,
			       fbdevpriv->orig_fix.mmio_len,
			       fbdevpriv->orig_fix.smem_len);
		fbdevpriv->mmioaddr = NULL;
		free(priv);
		return GGI_ENODEVICE;
	}

	DPRINT_MISC("mga-2164w: Mapped MMIO region at %p\n",
		       fbdevpriv->mmioaddr);

	/* Set up DirectBuffers */
	for (i=0; i < LIBGGI_MODE(vis)->frames; i++) {
		ggi_directbuffer *buf = LIBGGI_APPBUFS(vis)[i];
		ggi_resource *res;
		
		res = malloc(sizeof(ggi_resource));
		if (res == NULL) {
			do_cleanup(vis);
			return GGI_ENOMEM;
		}
		buf->resource = res;
		buf->resource->acquire = m2164w_acquire;
		buf->resource->release = m2164w_release;
		buf->resource->self = buf;
		buf->resource->priv = vis;
		buf->resource->count = 0;
		buf->resource->curactype = 0;
	}

	priv->drawboxcmd
		= BOP_COPY | SHFTZERO | SGNZERO | ARZERO | SOLID | OP_TRAP;
	if (pixbytes != 3) {
		switch (fbdevpriv->orig_fix.accel) {	
		case FB_ACCEL_MATROX_MGA2064W:
		case FB_ACCEL_MATROX_MGA1064SG:
		case FB_ACCEL_MATROX_MGA2164W:
		case FB_ACCEL_MATROX_MGA2164W_AGP:
			/* Use block mode */
			priv->drawboxcmd |= ATYPE_BLK;
			break;
		default:
			/* For now - assume SDRAM for other cards */
			break;
		}
	}
	priv->dwgctl = 0;
	priv->oldfgcol = LIBGGI_GC(vis)->fg_color - 1;
	priv->oldbgcol = LIBGGI_GC(vis)->bg_color - 1;
	priv->oldtl.x = -1;
	priv->oldtl.y = -1;
	priv->oldbr.x = -1;
	priv->oldbr.y = -1;
	priv->oldyadd = -1;
	priv->curopmode = priv->origopmode = mga_in16(fbdevpriv->mmioaddr, OPMODE);
	/* Use the 7k Pseudo-DMA window */
	priv->dmaaddr = (void*)fbdevpriv->mmioaddr;
	priv->dma_len = 0x1c00;

	vis->needidleaccel = 1;
	fbdevpriv->idleaccel = m2164w_idleaccel;

	/* Accelerate fonts if possible */
	priv->font = (uint8_t *)(font);
	usedmemend = LIBGGI_MODE(vis)->frames *
		fbdevpriv->fix.line_length * LIBGGI_VIRTY(vis);
	fontlen = 256*8;
	priv->fontoffset = fbdevpriv->orig_fix.smem_len - fontlen;
	priv->fontoffset &= ~127; /* Align */
	DPRINT_MISC("mga-2164w: usedmemend: %ld, fontoffset: %ld\n",
		       usedmemend, priv->fontoffset);
	if (usedmemend <= priv->fontoffset) {
		memcpy((uint8_t*)fbdevpriv->fb_ptr + priv->fontoffset,
		       font, fontlen);
		priv->fontoffset *= 8; /* In bits */
		priv->charadd = FWIDTH*FHEIGHT;
		vis->opdraw->putc = GGI_m2164w_fastputc;
		vis->opdraw->puts = GGI_m2164w_fastputs;
		DPRINT_MISC("mga-2164w: Using fast chars\n");
	} else {
		priv->fontoffset = 0;
		vis->opdraw->putc = GGI_m2164w_putc;
		vis->opdraw->puts = GGI_m2164w_puts;
		DPRINT_MISC("mga-2164w: Using slow chars\n");
	}

	/* Save previous function pointers */
	priv->crossblit = vis->opdraw->crossblit;

	/* Initialize function pointers */
	vis->opdraw->getcharsize= GGI_m2164w_getcharsize;
	vis->opdraw->drawhline = GGI_m2164w_drawhline;
	vis->opdraw->drawvline = GGI_m2164w_drawvline;
	vis->opdraw->drawline = GGI_m2164w_drawline;
	vis->opdraw->drawbox = GGI_m2164w_drawbox;
	vis->opdraw->copybox = GGI_m2164w_copybox;
	vis->opdraw->fillscreen = GGI_m2164w_fillscreen;
	/* The crossblit in linear-* is faster on truecolor modes! */
	if (GT_SCHEME(LIBGGI_GT(vis)) == GT_PALETTE ||
	    GT_SCHEME(LIBGGI_GT(vis)) == GT_STATIC_PALETTE) {
		vis->opdraw->crossblit = GGI_m2164w_crossblit;
	}

	FBDEV_PRIV(vis)->accelpriv = priv;

	/* Register cleanup handler */
	ggRegisterCleanup((ggcleanup_func *)do_cleanup, vis);

	*dlret = GGI_DL_OPDRAW;
	return 0;
}