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; }