int GGI_vgl_getapi(ggi_visual *vis, int num, char *apiname, char *arguments)
{
struct vgl_priv *priv = VGL_PRIV(vis);
*arguments = '\0';
switch(num) {
case 0:
strcpy(apiname, "display-vgl");
return 0;
case 1:
strcpy(apiname, "generic-stubs");
return 0;
case 2:
strcpy(apiname, "generic-color");
return 0;
case 3:
if (!priv->vgl_use_db)
break;
if (GT_SCHEME(LIBGGI_GT(vis)) == GT_TEXT) {
sprintf(apiname, "generic-text-%d",
GT_SIZE(LIBGGI_GT(vis)));
} else {
sprintf(apiname, "generic-linear-%d%s",
GT_SIZE(LIBGGI_GT(vis)),
(LIBGGI_GT(vis) & GT_SUB_HIGHBIT_RIGHT)
? "-r" : "");
}
return 0;
default:
break;
}
return GGI_ENOMATCH;
}
int GGI_trueemu_getapi(struct ggi_visual *vis, int num, char *apiname, char *arguments)
{
*arguments = '\0';
switch(num) {
case 0: strcpy(apiname, "display-trueemu");
return 0;
case 1: strcpy(apiname, "generic-stubs");
return 0;
case 2: snprintf(apiname, GGI_MAX_APILEN,
"generic-linear-%"PRIu32"%s",
GT_SIZE(LIBGGI_GT(vis)),
(LIBGGI_GT(vis) & GT_SUB_HIGHBIT_RIGHT) ? "-r" : "");
return 0;
case 3: strcpy(apiname, "generic-color");
return 0;
case 4: strcpy(apiname, "generic-pseudo-stubs");
snprintf(arguments, GGI_MAX_APILEN,
"%p", (void *)TRUEEMU_PRIV(vis)->parent);
return 0;
}
return GGI_ENOMATCH;
}
static int GGIopen(struct ggi_visual *vis, struct ggi_dlhandle *dlh,
const char *args, void *argptr, uint32_t *dlret)
{
int err;
DPRINT("generic-ramdac: Init.\n");
vis->palette = malloc(256*sizeof(ggi_color));
if (vis->palette == NULL) return GGI_ENOMEM;
if ((GT_SCHEME(LIBGGI_GT(vis)) != GT_TRUECOLOR) &&
(GT_DEPTH(LIBGGI_GT(vis)) > 8))
{
fprintf(stderr, "generic-ramdac: too many colors (%d)\n",
1 << GT_DEPTH(LIBGGI_GT(vis)));
return GGI_ENOMATCH;
}
err = _ggiSendKGICommand(vis, (int)RAMDAC_GETCLUT, vis->palette);
if (err < 0) {
fprintf(stderr,"generic-ramdac: Can't get default colormap\n");
return GGI_ENODEVICE;
}
#if 0 /* rely on generic-color */
vis->opcolor->getpalvec=GGI_ramdac_getpalvec;
#endif
vis->opcolor->setpalvec=GGI_ramdac_setpalvec;
*dlret = GGI_DL_OPCOLOR;
return 0;
}
int GGI_lcd823_getapi(struct ggi_visual *vis, int num, char *apiname, char *arguments)
{
int size = GT_SIZE(LIBGGI_GT(vis));
*arguments = '\0';
switch(num) {
case 0: strcpy(apiname, "display-lcd823");
return 0;
case 1: strcpy(apiname, "generic-stubs");
return 0;
case 2: strcpy(apiname, "generic-color");
return 0;
case 3:
if (GT_SCHEME(LIBGGI_GT(vis)) == GT_TEXT) {
snprintf(apiname, GGI_MAX_APILEN,
"generic-text-%d", size);
return 0;
}
snprintf(apiname, GGI_MAX_APILEN,
"generic-linear-%d", size);
return 0;
}
return GGI_ENOMATCH;
}
static int do_dbstuff(struct ggi_visual *vis)
{
ggi_palemu_priv *priv = PALEMU_PRIV(vis);
int i;
/* allocate memory */
priv->frame_size = LIBGGI_FB_SIZE(LIBGGI_MODE(vis));
priv->fb_size = priv->frame_size * LIBGGI_MODE(vis)->frames;
priv->fb_ptr = malloc((size_t)priv->fb_size);
DPRINT_MODE("display-palemu: fb=%p size=%d frame=%d\n",
priv->fb_ptr, priv->fb_size, priv->frame_size);
if (priv->fb_ptr == NULL) {
fprintf(stderr, "display-palemu: Out of memory.\n");
return GGI_ENOMEM;
}
/* clear all frames */
memset(priv->fb_ptr, 0, (size_t)priv->fb_size);
/* set up pixel format */
memset(LIBGGI_PIXFMT(vis), 0, sizeof(ggi_pixelformat));
setup_pixfmt(LIBGGI_PIXFMT(vis), LIBGGI_GT(vis));
_ggi_build_pixfmt(LIBGGI_PIXFMT(vis));
/* set up direct buffers */
for (i=0; i < LIBGGI_MODE(vis)->frames; i++) {
ggi_directbuffer *buf;
_ggi_db_add_buffer(LIBGGI_PRIVLIST(vis), _ggi_db_get_new());
buf = LIBGGI_PRIVBUFS(vis)[i];
buf->frame = i;
buf->type = GGI_DB_NORMAL | GGI_DB_SIMPLE_PLB;
buf->read = (char *) priv->fb_ptr + i * priv->frame_size;
buf->write = buf->read;
buf->layout = blPixelLinearBuffer;
buf->buffer.plb.stride =
GT_ByPPP(LIBGGI_VIRTX(vis), LIBGGI_GT(vis));
buf->buffer.plb.pixelformat = LIBGGI_PIXFMT(vis);
}
/* Set up palette */
if (LIBGGI_PAL(vis)->clut.data) {
free(LIBGGI_PAL(vis)->clut.data);
LIBGGI_PAL(vis)->clut.data = NULL;
}
if (GT_SCHEME(LIBGGI_GT(vis)) == GT_PALETTE) {
LIBGGI_PAL(vis)->clut.data = _ggi_malloc((1 << GT_DEPTH(LIBGGI_GT(vis))) *
sizeof(ggi_color));
LIBGGI_PAL(vis)->clut.size = 1 << GT_DEPTH(LIBGGI_GT(vis));
}
return 0;
}
static int GGIopen(struct ggi_visual *vis, struct ggi_dlhandle *dlh,
const char *args, void *argptr, uint32_t *dlret)
{
/* Color mapping
*/
if (GT_SUBSCHEME(LIBGGI_GT(vis)) & GT_SUB_PACKED_GETPUT) {
vis->opcolor->packcolors = GGI_lin1r_packcolors;
vis->opcolor->unpackpixels = GGI_lin1r_unpackpixels;
}
/* Frame handling
*/
vis->opdraw->setreadframe = _ggi_default_setreadframe;
vis->opdraw->setwriteframe = _ggi_default_setwriteframe;
/* Generic drawing
*/
vis->opdraw->putc = GGI_lin1r_putc;
if (vis->needidleaccel) {
vis->opdraw->putpixel_nc = GGI_lin1r_putpixel_nca;
vis->opdraw->putpixel = GGI_lin1r_putpixela;
vis->opdraw->drawpixel_nc = GGI_lin1r_drawpixel_nca;
vis->opdraw->drawpixel = GGI_lin1r_drawpixela;
vis->opdraw->getpixel_nc = GGI_lin1r_getpixel_nca;
} else {
vis->opdraw->putpixel_nc = GGI_lin1r_putpixel_nc;
vis->opdraw->putpixel = GGI_lin1r_putpixel;
vis->opdraw->drawpixel_nc = GGI_lin1r_drawpixel_nc;
vis->opdraw->drawpixel = GGI_lin1r_drawpixel;
vis->opdraw->getpixel_nc = GGI_lin1r_getpixel_nc;
}
vis->opdraw->drawhline = GGI_lin1r_drawhline;
vis->opdraw->drawhline_nc = GGI_lin1r_drawhline_nc;
vis->opdraw->drawvline = GGI_lin1r_drawvline;
vis->opdraw->drawvline_nc = GGI_lin1r_drawvline_nc;
if (GT_SUBSCHEME(LIBGGI_GT(vis)) & GT_SUB_PACKED_GETPUT) {
vis->opdraw->puthline = GGI_lin1r_packed_puthline;
vis->opdraw->gethline = GGI_lin1r_packed_gethline;
vis->opdraw->putvline = GGI_lin1r_packed_putvline;
vis->opdraw->getvline = GGI_lin1r_packed_getvline;
}
else {
vis->opdraw->puthline = GGI_lin1r_unpacked_puthline;
vis->opdraw->gethline = GGI_lin1r_unpacked_gethline;
vis->opdraw->putvline = GGI_lin1r_unpacked_putvline;
vis->opdraw->getvline = GGI_lin1r_unpacked_getvline;
}
*dlret = GGI_DL_OPCOLOR | GGI_DL_OPDRAW;
return 0;
}
int GGI_libkgi_getapi(struct ggi_visual *vis, int num, char *apiname, char *arguments)
{
*arguments = '\0';
switch(num) {
case 0:
snprintf(apiname, GGI_MAX_APILEN, "display-libkgi");
fprintf(stderr, "libkgi getapi returned %s\n", apiname);
return 0;
case 1:
snprintf(apiname, GGI_MAX_APILEN, "display-libkgi-%s",
LIBKGI_PRIV(vis)->suggest);
fprintf(stderr, "libkgi getapi returned %s\n", apiname);
return 0;
case 2:
strcpy(apiname, "generic-stubs");
fprintf(stderr, "libkgi getapi returned %s\n", apiname);
return 0;
case 3:
snprintf(apiname, GGI_MAX_APILEN,
"generic-linear-%d",GT_DEPTH(LIBGGI_GT(vis)));
fprintf(stderr, "libkgi getapi returned %s\n", apiname);
return 0;
case 4: strcpy(apiname, "generic-color");
fprintf(stderr, "libkgi getapi returned %s\n", apiname);
return 0;
}
return GGI_ENOMATCH;
}
/* Zeros out the palette/gamma entries. Called before changing modes. */
void GGI_fbdev_color0(ggi_visual *vis)
{
if (LIBGGI_PAL(vis)->clut.data == NULL) return; /* New visual. */
vis->opcolor->setpalvec(vis, 0, 1 << GT_DEPTH(LIBGGI_GT(vis)),
LIBGGI_PAL(vis)->clut.data);
vis->opcolor->setgammamap(vis, 0, vis->gamma->len,
LIBGGI_PAL(vis)->clut.data);
}
int GGI_palemu_getapi(struct ggi_visual *vis, int num, char *apiname, char *arguments)
{
ggi_palemu_priv *priv = PALEMU_PRIV(vis);
*arguments = '\0';
switch(num) {
case 0:
if (priv->target == PALEMU_TARGET)
strcpy(apiname, "display-palemu");
else
strcpy(apiname, "display-monotext");
return 0;
case 1:
strcpy(apiname, "generic-stubs");
return 0;
case 2:
snprintf(apiname, GGI_MAX_APILEN,
"generic-linear-%"PRIu32"%s",
GT_DEPTH(LIBGGI_GT(vis)),
(LIBGGI_GT(vis) & GT_SUB_HIGHBIT_RIGHT) ? "-r" : "");
return 0;
case 3:
strcpy(apiname, "generic-color");
return 0;
case 4:
strcpy(apiname, "generic-pseudo-stubs");
snprintf(arguments, GGI_MAX_APILEN,
"%p", (void *)PALEMU_PRIV(vis)->parent);
return 0;
}
return GGI_ENOMATCH;
}
int
GGI_ipl2_getpixel_nc(struct ggi_visual *vis, int x, int y, ggi_pixel *pixel)
{
ggi_pixel col = 0;
uint16_t *dest = PIXEL_RADDR(vis, x, y);
uint16_t shift = 15 - (x & 15);
int i, depth = GT_DEPTH(LIBGGI_GT(vis));
for (i=0; i < depth; i++) {
col |= ((*dest++ >> shift) & 1) << i;
}
*pixel = col;
return 0;
}
int
GGI_kgi_setPalette(struct ggi_visual *vis, size_t start, size_t len, const ggi_color *colormap)
{
kgic_ilut_set_request_t ilut;
size_t nocols = 1 << GT_DEPTH(LIBGGI_GT(vis));
APP_ASSERT(colormap != NULL,
"GGI_kgi_setPalette() - colormap == NULL");
DPRINT_COLOR("display-kgi: SetPalVec(%d,%d)\n", start, len);
if (start == (size_t)GGI_PALETTE_DONTCARE) {
start = 0;
}
if ((start < 0) || (len < 0) || (start+len > nocols)) {
return GGI_ENOSPACE;
}
memcpy(LIBGGI_PAL(vis)->clut.data, colormap, len*sizeof(ggi_color));
ilut.image = 0;
ilut.resource = 0;
ilut.lut = 0;
ilut.idx = start;
ilut.cnt = len;
ilut.am = KGI_AM_COLORS;
ilut.data = (kgi_u16_t *)KGI_PRIV(vis);
for (start = 0; len > 0; start++, colormap++, len--) {
ilut.data[start*3] = colormap->r;
ilut.data[start*3 + 1] = colormap->g;
ilut.data[start*3 + 2] = colormap->b;
}
if(kgiSetIlut(&KGI_CTX(vis), &ilut) != KGI_EOK) {
DPRINT_COLOR("display-kgi: PUTCMAP failed.");
return -1;
}
return 0;
}
int GGI_ipl2_putpixel_nc(struct ggi_visual *vis, int x, int y, ggi_pixel col)
{
uint16_t *dest = PIXEL_WADDR(vis, x, y);
uint16_t mask = 0x8000 >> (x & 15);
int i;
for (i=GT_DEPTH(LIBGGI_GT(vis)); i > 0; i--) {
if (col & 1) {
*dest++ |= mask;
} else {
*dest++ &= ~mask;
}
col >>= 1;
}
return 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;
}
int GGI_ilbm_getpixel(ggi_visual *vis, int x, int y, ggi_pixel *pixel)
{
ggi_pixel col = 0;
uint16_t *dest = PIXEL_RADDR(vis, x, y);
uint16_t shift = 15 - (x & 15);
int plane_add = LIBGGI_R_PLAN(vis).next_plane / 2;
int i, depth = GT_DEPTH(LIBGGI_GT(vis));
for (i=0; i < depth; i++) {
col |= ((*dest >> shift) & 1) << i;
dest += plane_add;
}
*pixel = col;
return 0;
}
int GGI_ilbm_putpixel_nc(ggi_visual *vis, int x, int y, ggi_pixel col)
{
uint16_t *dest = PIXEL_WADDR(vis, x, y);
uint16_t mask = 0x8000 >> (x & 15);
int plane_add = LIBGGI_W_PLAN(vis).next_plane / 2;
int i;
for (i=GT_DEPTH(LIBGGI_GT(vis)); i > 0; i--) {
if (col & 1) {
*dest |= mask;
} else {
*dest &= ~mask;
}
col >>= 1; dest += plane_add;
}
return 0;
}
static int do_mmap(struct ggi_visual *vis)
{
ggi_lcd823_priv *priv = LCD823_PRIV(vis);
ggi_graphtype gt = LIBGGI_GT(vis);
int xres_in_bytes = XRES;
int i;
/* Clear framebuffer */
memset(priv->fb_ptr, 0, priv->fb_size);
/* Set up pixel format */
memset(LIBGGI_PIXFMT(vis), 0, sizeof(ggi_pixelformat));
LIBGGI_PIXFMT(vis)->size = GT_SIZE(gt);
LIBGGI_PIXFMT(vis)->depth = GT_DEPTH(gt);
LIBGGI_PIXFMT(vis)->clut_mask = (1 << GT_DEPTH(gt)) - 1;
_ggi_build_pixfmt(LIBGGI_PIXFMT(vis));
/* Set up DirectBuffers */
for (i=0; i < LIBGGI_MODE(vis)->frames; i++) {
ggi_directbuffer *buf;
_ggi_db_add_buffer(LIBGGI_APPLIST(vis), _ggi_db_get_new());
buf = LIBGGI_APPBUFS(vis)[i];
buf->frame = i;
buf->type = GGI_DB_NORMAL;
buf->read = (uint8_t *) priv->fb_ptr + i * priv->frame_size;
buf->write = buf->read;
buf->type |= GGI_DB_SIMPLE_PLB;
buf->layout = blPixelLinearBuffer;
buf->buffer.plb.stride = xres_in_bytes;
buf->buffer.plb.pixelformat = LIBGGI_PIXFMT(vis);
}
return 0;
}
int
GGI_vnc_trle(ggi_vnc_client *client, ggi_rect *update)
{
struct trle_ctx_t *ctx = client->trle_ctx;
struct ggi_visual *cvis;
const ggi_directbuffer *db;
ggi_graphtype gt;
int bpp;
int cbpp;
int count;
unsigned char *buf;
unsigned char *header;
int xtiles, ytiles;
unsigned char *work;
int lower = 1;
int tile_param;
tile_func *tile;
int xt, yt;
int xs, ys;
int xs_last, ys_last;
int stride;
ggi_rect vupdate;
int d_frame_num;
DPRINT("trle update %dx%d - %dx%d\n",
update->tl.x, update->tl.y,
update->br.x, update->br.y);
cvis = GGI_vnc_encode_init(client, update, &vupdate, &d_frame_num);
gt = LIBGGI_GT(cvis);
bpp = GT_ByPP(gt);
if (bpp == 4) {
ggi_pixel mask =
LIBGGI_PIXFMT(cvis)->red_mask |
LIBGGI_PIXFMT(cvis)->green_mask |
LIBGGI_PIXFMT(cvis)->blue_mask;
if (!(mask & 0xff000000))
cbpp = 3;
else if (!(mask & 0xff)) {
lower = 0;
cbpp = 3;
}
else
cbpp = 4;
}
else
cbpp = bpp;
count = ggi_rect_width(&vupdate) * ggi_rect_height(&vupdate);
xtiles = (ggi_rect_width(&vupdate) + 15) / 16;
ytiles = (ggi_rect_height(&vupdate) + 15) / 16;
GGI_vnc_buf_reserve(&client->wbuf, client->wbuf.size + 12
+ xtiles * ytiles + count * cbpp);
header = &client->wbuf.buf[client->wbuf.size];
insert_header(header, &update->tl, &vupdate, 15); /* trle */
client->wbuf.size += 12;
work = &client->wbuf.buf[client->wbuf.size];
buf = work;
db = ggiDBGetBuffer(cvis->instance.stem, d_frame_num);
ggiResourceAcquire(db->resource, GGI_ACTYPE_READ);
if (bpp == 1) {
tile_param = 0;
tile = tile_8;
}
else if (bpp == 2) {
tile_param = client->reverse_endian;
tile = tile_16;
}
else if (cbpp == 3 && !client->reverse_endian) {
tile_param = lower;
tile = tile_24;
}
else if (cbpp == 3) {
tile_param = lower;
tile = tile_rev_24;
}
else {
tile_param = client->reverse_endian;
tile = tile_32;
}
stride = LIBGGI_VIRTX(cvis);
ys_last = ggi_rect_height(&vupdate) & 0xf;
if (!ys_last)
ys_last = 16;
xs_last = ggi_rect_width(&vupdate) & 0xf;
if (!xs_last)
xs_last = 16;
ys = 16;
for (yt = 0; yt < ytiles; ++yt) {
if (yt == ytiles - 1)
ys = ys_last;
xs = 16;
for (xt = 0; xt < xtiles; ++xt) {
if (xt == xtiles - 1)
xs = xs_last;
tile(ctx, &buf, (uint8_t *)db->read +
((vupdate.tl.y + 16 * yt) * stride +
vupdate.tl.x + 16 * xt) * bpp,
xs, ys, stride, tile_param);
}
}
ggiResourceRelease(db->resource);
client->wbuf.size += buf - work;
return 1;
}
int GGI_kgi_radeon_putvline_3d(ggi_visual *vis, int x, int y, int h, const void *buf)
{
int wb, w32;
radeon_context_t *ctx;
struct {
cce_type3_header_t h;
cce_se_se_vtx_fmt_t vfmt;
cce_se_se_vf_cntl_t vctl;
/* TODO: this wrongly assumes float is 32 bit everywhere. */
float v1x, v1y, v1s, v1t; /* v1z; */
float v2x, v2y, v2s, v2t; /* v2z; */
float v3x, v3y, v3s, v3t; /* v3z; */
} packet;
struct {
cce_type0_header_t h;
uint32_t txoffset;
} offsetpkt;
ctx = RADEON_CONTEXT(vis);
wb = GT_ByPP(LIBGGI_GT(vis)) * h;
w32 = ((wb + 31) / 32) * 32;
if (ctx->ctx_loaded != RADEON_PUT_CTX) {
ctx->put_ctx.tex_size.usize = w32 / GT_ByPP(LIBGGI_GT(vis));
ctx->put_ctx.tex_size.vsize = 1;
ctx->put_ctx.txpitch.txpitch = (w32/32) - 1;
RADEON_RESTORE_CTX(vis, RADEON_PUT_CTX);
} else {
struct {
cce_type0_header_t h;
pp_tex_size_t tex_size;
pp_txpitch_t txpitch;
} packet2;
memset(&packet2, 0, sizeof(packet2));
packet2.h.base_index = PP_TEX_SIZE_1 >> 2;
packet2.h.count = 1;
packet2.tex_size.usize = w32 / GT_ByPP(LIBGGI_GT(vis));
packet2.tex_size.vsize = 1;
packet2.txpitch.txpitch = (w32/32) - 1;
RADEON_RESTORE_CTX(vis, RADEON_BASE_CTX);
RADEON_WRITEPACKET(vis, packet2);
ctx->ctx_loaded = RADEON_PUT_CTX;
}
memset(&packet, 0, sizeof(packet));
packet.h.it_opcode = CCE_IT_OPCODE_3D_DRAW_IMMD;
packet.h.count = 13;
packet.h.type = 3;
packet.vfmt.st0 = 1;
packet.vfmt.z = 0 /* 1 */;
packet.vctl.num_vertices = 3;
packet.vctl.en_maos = 1;
packet.vctl.fmt_mode = 1;
packet.vctl.prim_walk = 3; /* Vertex data follows in packet. */
packet.vctl.prim_type = 8; /* Rectangle list */
packet.v1x = packet.v3x = x;
packet.v2x = x + 1;
packet.v1y = packet.v2y = y;
packet.v3y = y + h;
packet.v1s = packet.v2s = 0;
packet.v3s = h;
packet.v1t = packet.v3t = 1;
packet.v2t = 0;
memset(&offsetpkt, 0, sizeof(offsetpkt));
offsetpkt.h.base_index = PP_TXOFFSET_1 >> 2;
if ((KGI_PRIV(vis)->swatch_size - ctx->swatch_inuse) < w32) {
/* idleaccel */
ctx->swatch_inuse = 0;
}
offsetpkt.txoffset =
(uint32_t)KGI_PRIV(vis)->swatch_gp + ctx->swatch_inuse;
RADEON_WRITEPACKET(vis, offsetpkt);
memcpy(KGI_PRIV(vis)->swatch + ctx->swatch_inuse,
(char *)buf, wb);
RADEON_WRITEPACKET(vis, packet);
if (!(LIBGGI_FLAGS(vis) & GGIFLAG_ASYNC)) RADEON_FLUSH(vis);
return 0;
}
int _ggi_x_createfb(struct ggi_visual *vis)
{
char target[GGI_MAX_APILEN];
ggi_mode tm;
ggi_x_priv *priv;
int err, i;
err = GGI_OK;
priv = GGIX_PRIV(vis);
DPRINT_MODE("_ggi_x_createfb(%p) called\n", vis);
DPRINT("viidx = %i\n", priv->viidx);
_ggi_x_freefb(vis);
DPRINT_MODE("Creating vanilla XImage client-side buffer\n");
priv->fb = calloc(1, GT_ByPPP(LIBGGI_VIRTX(vis),LIBGGI_GT(vis))
* LIBGGI_VIRTY(vis) * LIBGGI_MODE(vis)->frames);
if (priv->fb == NULL) {
DPRINT("_ggi_x_createfb: XImage buffer allocation failed.\n");
err = GGI_ENOMEM;
goto err0;
}
/* We assume LIBGGI_MODE(vis) structure has already been filled out */
memcpy(&tm, LIBGGI_MODE(vis), sizeof(ggi_mode));
/* Make sure we do not fail due to physical size constraints,
* which are meaningless on a memory visual.
*/
tm.size.x = tm.size.y = GGI_AUTO;
i = 0;
memset(target, '\0', sizeof(target));
i += snprintf(target, sizeof(target),
"display-memory:-noblank:-pixfmt=");
_ggi_build_pixfmtstr(vis, target + i, sizeof(target) - i, 1);
i = strlen(target);
snprintf(target + i, sizeof(target) - i, ":-physz=%i,%i:pointer",
LIBGGI_MODE(vis)->size.x, LIBGGI_MODE(vis)->size.y);
err = _ggi_openslave(vis, target, &tm);
if (err)
goto err1;
priv->ximage = _ggi_x_create_ximage( vis, (char*)priv->fb,
LIBGGI_VIRTX(vis),
LIBGGI_VIRTY(vis) );
if (priv->ximage == NULL) {
DPRINT("_ggi_x_createfb: _ggi_x_create_ximage() failed\n");
err = GGI_ENOMEM;
goto err1;
}
err = _ggi_create_dbs(vis);
if (err)
goto err1;
DPRINT_MODE("X: XImage %p and slave visual %p share buffer at %p\n",
priv->ximage, priv->slave, priv->fb);
return GGI_OK;
err1:
_ggi_x_freefb(vis);
err0:
return err;
}
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;
}
int GGI_3dlabs_pm2_puthline(struct ggi_visual *vis, int x, int y, int w,
const void *buf)
{
struct _3dlabs_pm2_priv *priv = PM2_PRIV(vis);
volatile uint8_t *mmioaddr = FBDEV_PRIV(vis)->mmioaddr;
int yadd = vis->w_frame_num * LIBGGI_VIRTY(vis);
int count;
#if 0
uint32_t srcwidth;
#endif
const uint8_t *src;
const uint32_t *srcp;
uint32_t *dest;
/* 0 width not OK */
if (w == 0) return 0;
DPRINT_DRAW("puthline(%p, %i,%i, %i, %p) entered\n",
vis, x, y, w, buf);
y += yadd;
#if 0
if (LIBGGI_GT(vis) & GT_SUB_PACKED_GETPUT) {
srcwidth = GT_ByPPP(w, LIBGGI_GT(vis));
} else {
srcwidth = w * GT_ByPP(LIBGGI_GT(vis));
}
#endif
pm2_gcupdate(mmioaddr, priv, LIBGGI_MODE(vis), LIBGGI_GC(vis),
yadd);
pm2_waitfifo(mmioaddr, 6);
/* Setting for Image download from Host */
pm2_out32(mmioaddr, priv->pprod, PM2R_FB_READ_MODE);
pm2_out32(mmioaddr, UNIT_ENABLE, PM2R_FB_WRITE_MODE);
pm2_out32(mmioaddr, UNIT_DISABLE, PM2R_COLOR_DDA_MODE);
pm2_loadcoord(mmioaddr, x,y, w, 1);
pm2_out32(mmioaddr,
PM2F_RENDER_RECTANGLE | PM2F_RENDER_XPOSITIVE
| PM2F_RENDER_YPOSITIVE | PM2F_RENDER_SYNC_ON_HOST,
PM2R_RENDER);
src = (const uint8_t *)buf;
dest = (uint32_t *)((volatile uint8_t *)
(mmioaddr + PM2R_OUT_FIFO + 4));
count = w;
srcp = (const uint32_t *)src;
while (count >= priv->fifosize) {
pm2_waitfifo(mmioaddr, priv->fifosize);
/* 0x0155 is the TAG for FBSourceData */
pm2_out32(mmioaddr,
((priv->fifosize - 2) << 16) | 0x0155,
PM2R_OUT_FIFO);
pm2_move32(dest, srcp, priv->fifosize - 1);
count -= priv->fifosize - 1;
srcp += priv->fifosize - 1;
}
if (count) {
pm2_waitfifo(mmioaddr, count + 1);
pm2_out32(mmioaddr,
((count - 1) << 16) | 0x0155,
PM2R_OUT_FIFO);
pm2_move32(dest, srcp, count);
}
/* Re-enable fb readmode when done */
pm2_waitfifo(mmioaddr, 2);
pm2_out32(mmioaddr, 0, PM2R_WAIT_FOR_COMPLETION);
priv->oldfgcol = ~priv->oldfgcol;
vis->accelactive = 1;
return 0;
}
static int GGIopen(ggi_visual *vis, struct ggi_dlhandle *dlh,
const char *args, void *argptr, uint32_t *dlret)
{
ggi_accel_t *accel;
Gx00_context_t *ctx;
/* NB: The accel engine is resource 2 (1 is the ILOAD aperture,
** 0 the framebuffer) */
if (!(accel = KGI_PRIV(vis)->map_accel(vis, 2, 0,
GX00_BUFFER_SIZE_ORDER, GX00_BUFFER_NUM, 0)))
return GGI_ENODEVICE;
if (!(ctx = (Gx00_context_t*)malloc(sizeof(*ctx))))
return GGI_ENOMEM;
/* setup the accel_priv data structures */
KGI_ACCEL_PRIV(vis) = ctx;
memset(ctx, 0, sizeof(*ctx));
ctx->accel = accel;
ctx->hwgc_mask = 0; /* TODO: Should use -1 instead? */
/* setup the DMA buffers */
GX00_INIT(vis);
/* Initializes the pitch */
GX00_WRITE_REG(vis, LIBGGI_VIRTX(vis), PITCH);
/* Initializes the MACCESS fields */
{
uint32_t maccess = MACCESS_ZWIDTH_ZW16; /* NB: no fogging */
switch (GT_ByPP(LIBGGI_GT(vis))) {
case 1:
maccess |= MACCESS_PWIDTH_PW8;
break;
case 2:
maccess |= MACCESS_PWIDTH_PW16;
if (LIBGGI_GT(vis) == GT_15BIT)
maccess |= MACCESS_DIT555;
/* else: GT_16BIT */
break;
case 4:
maccess |= MACCESS_PWIDTH_PW32;
break;
case 3:
maccess |= MACCESS_PWIDTH_PW24;
break;
default:
ggiPanic("Unknown depth size!");
break;
}
/* TODO: check? -- ortalo: maccess |= MACCESS_NODITHER; */
GX00_WRITE_REG(vis, maccess, MACCESS);
}
/* Initializes the destination origin */
GX00_WRITE_REG(vis, 0x0, DSTORG);
/* Initializes the old-style destination origin */
GX00_WRITE_REG(vis, 0x0, YDSTORG);
/* Initializes the plane mask */
GX00_WRITE_REG(vis, 0xFFFFFFFF, PLNWT);
#if 0 /* Maybe not needed? TODO: Check in libggi if clipping is initialized */
/* Initializes the clipping to max */
GX00_WRITE_REG(vis, 0 |
(((LIBGGI_X(vis) - 1) << CXBNDRY_CXRIGHT_SHIFT)
& CXBNDRY_CXRIGHT_MASK),
CXBNDRY);
GX00_WRITE_REG(vis, 0, YTOP);
GX00_WRITE_REG(vis, (LIBGGI_Y(vis) - 1) * LIBGGI_VIRTX(vis),
YBOT);
#endif
vis->opdisplay->idleaccel = GGI_kgi_Gx00_idleaccel;
vis->opdisplay->flush = GGI_kgi_Gx00_flush;
vis->opgc->gcchanged = GGI_kgi_Gx00_gcchanged;
vis->opdraw->drawhline_nc = GGI_kgi_Gx00_drawhline_nc;
vis->opdraw->drawhline = GGI_kgi_Gx00_drawhline;
vis->opdraw->drawvline_nc = GGI_kgi_Gx00_drawvline_nc;
vis->opdraw->drawvline = GGI_kgi_Gx00_drawvline;
vis->opdraw->drawbox = GGI_kgi_Gx00_drawbox;
vis->opdraw->fillscreen = GGI_kgi_Gx00_fillscreen;
vis->opdraw->drawline = GGI_kgi_Gx00_drawline;
vis->opdraw->copybox = GGI_kgi_Gx00_copybox;
/* bugs on the G400
*/
vis->opdraw->getcharsize = GGI_kgi_Gx00_getcharsize;
vis->opdraw->putc = GGI_kgi_Gx00_putc;
/* The generic puts uses putc, so...
vis->opdraw->puts = GGI_kgi_Gx00_puts;
*/
vis->needidleaccel = 1;
vis->accelactive = 0;
*dlret = GGI_DL_OPDRAW | GGI_DL_OPGC;
return 0;
}
