/* $NetBSD: grfabs.c,v 1.2 1995/03/28 06:35:40 leo Exp $ */ /* * Copyright (c) 1995 Leo Weppelman. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Leo Weppelman. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * atari abstract graphics driver. */ #include #include #include #include #include #include #include /* * Function decls */ static dmode_t *get_best_display_mode __P((int, int, int)); static view_t *alloc_view __P((dmode_t *, dimen_t *, u_char)); static void init_view __P((view_t *, bmap_t *, dmode_t *, box_t *)); static bmap_t *alloc_bitmap __P((u_long, u_long, u_char, int)); static void free_bitmap __P((bmap_t *)); static colormap_t *alloc_colormap __P((dmode_t *)); /* * Ugh.. Stuff needed to allocate console structures before the VM-system * is running. There is no malloc() available at that time. */ extern int atari_realconfig; /* 0 -> no malloc */ static view_t con_view; static colormap_t con_cmap; static long con_colors[MAX_CENTRIES]; /* * List of available graphic modes */ static LIST_HEAD(modelist, display_mode) modes; static dmode_t vid_modes[] = { { { NULL, NULL }, "stlow", { 320, 200 }, 4, RES_STLOW }, { { NULL, NULL }, "stmid", { 640, 200 }, 2, RES_STMID }, { { NULL, NULL }, "sthigh", { 640, 400 }, 1, RES_STHIGH }, { { NULL, NULL }, "ttlow", { 320, 480 }, 8, RES_TTLOW }, { { NULL, NULL }, "ttmid", { 640, 480 }, 4, RES_TTMID }, { { NULL, NULL }, "tthigh", { 1280, 960 }, 1, RES_TTHIGH }, { { NULL, NULL }, NULL, } }; /* * Default colors..... * Currently the TT-low (256 colors) just uses 16 time the 16-color default. * If you have a sensible 256 scale, feel free to add..... * The first 2 colors in all maps are {black,white}, so ite (text) displays * are initially readable. Also, this enables me to supply only 1 map. The * 4 color mode uses the first four entries of the 16 color mode thus giving * a gray scale display. (Maybe we can add an intensity bit to the ite...) */ static u_short def_color16[16] = { 0x000, /* black */ 0xfff, /* white */ 0xccc, /* light gray */ 0x888, /* gray */ 0x00c, /* blue */ 0x0c0, /* green */ 0x0cc, /* cyan */ 0xc00, /* red */ 0xc0c, /* magenta */ 0xcc0, /* brown */ 0x00f, /* light blue */ 0x0f0, /* light green */ 0x0ff, /* light cyan */ 0xf00, /* light red */ 0xf0f, /* light magenta */ 0xff0 /* light brown */ }; /* * XXX: called from ite console init routine. * Initialize list of posible video modes. */ int grfabs_probe() { dmode_t *dm; int i; int has_mono; static int inited = 0; if(inited) return; /* Has to be done only once */ inited++; /* * First find out what kind of monitor is attached. Dma-sound * should be off because the 'sound-done' and 'monochrome-detect' * are xor-ed together. I think that shutting it down here is the * wrong place. */ has_mono = (MFP->mf_gpip & IA_MONO) == 0; LIST_INIT(&modes); for(i = 0; (dm = &vid_modes[i])->name != NULL; i++) { if(has_mono && (dm->vm_reg != RES_TTHIGH)) continue; if(!has_mono && (dm->vm_reg == RES_TTHIGH)) continue; LIST_INSERT_HEAD(&modes, dm, link); } /* * This seems to prevent bordered screens. */ for(i=0; i < 16; i++) VIDEO->vd_tt_rgb[i] = def_color16[i]; return(1); } view_t * grf_alloc_view(d, dim, depth) dmode_t *d; dimen_t *dim; u_char depth; { if(!d) d = get_best_display_mode(dim->width, dim->height, depth); if(d) return(alloc_view(d, dim, depth)); return(NULL); } void grf_display_view(v) view_t *v; { dmode_t *dm = v->mode; bmap_t *bm = v->bitmap; if(dm->current_view) { /* * Mark current view for this mode as no longer displayed */ dm->current_view->flags &= ~VF_DISPLAY; } dm->current_view = v; v->flags |= VF_DISPLAY; grf_use_colormap(v, v->colormap); /* XXX: should use vbl for this */ VIDEO->vd_tt_res = dm->vm_reg; VIDEO->vd_raml = (u_long)bm->hw_address & 0xff; VIDEO->vd_ramm = ((u_long)bm->hw_address >> 8) & 0xff; VIDEO->vd_ramh = ((u_long)bm->hw_address >> 16) & 0xff; } void grf_remove_view(v) view_t *v; { dmode_t *mode = v->mode; if(mode->current_view == v) { #if 0 if(v->flags & VF_DISPLAY) panic("Cannot shutdown display\n"); /* XXX */ #endif mode->current_view = NULL; } v->flags &= ~VF_DISPLAY; } void grf_free_view(v) view_t *v; { if(v) { dmode_t *md = v->mode; grf_remove_view(v); if(v->colormap != &con_cmap) free(v->colormap, M_DEVBUF); free_bitmap(v->bitmap); if(v != &con_view) free(v, M_DEVBUF); } } int grf_get_colormap(v, cm) view_t *v; colormap_t *cm; { colormap_t *gcm; int i, n; bzero(cm->entry, cm->size * sizeof(long)); gcm = v->colormap; n = cm->size < gcm->size ? cm->size : gcm->size; for(i = 0; i < n; i++) cm->entry[i] = gcm->entry[i]; return(0); } int grf_use_colormap(v, cm) view_t *v; colormap_t *cm; { dmode_t *dm; volatile u_short *creg; long *src; u_short ncreg; int i; dm = v->mode; switch(dm->vm_reg) { case RES_STLOW: creg = &VIDEO->vd_tt_rgb[0]; ncreg = 16; break; case RES_STMID: creg = &VIDEO->vd_tt_rgb[0]; ncreg = 4; break; case RES_STHIGH: creg = &VIDEO->vd_tt_rgb[254]; ncreg = 2; break; case RES_TTLOW: creg = &VIDEO->vd_tt_rgb[0]; ncreg = 256; break; case RES_TTMID: creg = &VIDEO->vd_tt_rgb[0]; ncreg = 16; break; case RES_TTHIGH: return(0); /* No colors */ default: panic("grf_get_colormap: wrong mode!?"); } if(cm->first >= ncreg) return(EINVAL); creg = &creg[cm->first]; ncreg -= cm->first; if(cm->size > ncreg) return(EINVAL); ncreg = cm->size; for(i = 0, src = cm->entry; i < ncreg; i++) { register long val = *src++; *creg++ = CM_LTOW(val); } return(0); } static dmode_t * get_best_display_mode(width, height, depth) int width, height, depth; { dmode_t *save; dmode_t *dm; long dt, dx, dy, ct; save = NULL; dm = modes.lh_first; while(dm != NULL) { if(depth > dm->depth) { dm = dm->link.le_next; continue; } else if(width > dm->size.width || height > dm->size.height) { dm = dm->link.le_next; continue; } else if (width < dm->size.width || height < dm->size.height) { dm = dm->link.le_next; continue; } dx = abs(dm->size.width - width); dy = abs(dm->size.height - height); ct = dx + dy; if (ct < dt || save == NULL) { save = dm; dt = ct; } dm = dm->link.le_next; } return (save); } static view_t * alloc_view(mode, dim, depth) dmode_t *mode; dimen_t *dim; u_char depth; { view_t *v; bmap_t *bm; if(!atari_realconfig) v = &con_view; else v = malloc(sizeof(*v), M_DEVBUF, M_NOWAIT); bm = alloc_bitmap(mode->size.width, mode->size.height, mode->depth, 1); if(bm) { int i; box_t box; v->colormap = alloc_colormap(mode); if(v->colormap) { INIT_BOX(&box,0,0,mode->size.width,mode->size.height); init_view(v, bm, mode, &box); return(v); } free_bitmap(bm); } if(v != &con_view) free(v, M_DEVBUF); return (NULL); } static void init_view(v, bm, mode, dbox) view_t *v; bmap_t *bm; dmode_t *mode; box_t *dbox; { v->bitmap = bm; v->mode = mode; bcopy(dbox, &v->display, sizeof(box_t)); } /* bitmap functions */ static bmap_t * alloc_bitmap(width, height, depth, clear) u_long width, height; u_char depth; int clear; { int i; u_long total_size, bm_size; void *hw_address; bmap_t *bm; /* * Sigh, it seems for mapping to work we need the bitplane data to * 1: be aligned on a page boundry. * 2: be n pages large. * * why? because the user gets a page aligned address, if this is before * your allocation, too bad. Also it seems that the mapping routines * do not watch to closely to the allowable length. so if you go over * n pages by less than another page, the user gets to write all over * the entire page. Since you did not allocate up to a page boundry * (or more) the user writes into someone elses memory. -ch */ bm_size = atari_round_page((width * height * depth) / NBBY); total_size = bm_size + sizeof(bmap_t) + NBPG; if((bm = (bmap_t*)alloc_stmem(total_size, &hw_address)) == NULL) return(NULL); bm->plane = (u_char*)bm + sizeof(bmap_t); bm->plane = (u_char*)atari_round_page(bm->plane); bm->hw_address = (u_char*)hw_address + sizeof(bmap_t); bm->hw_address = (u_char*)atari_round_page(bm->hw_address); bm->bytes_per_row = (width * depth) / NBBY; bm->rows = height; bm->depth = depth; if(clear) bzero(bm->plane, bm_size); return(bm); } static void free_bitmap(bm) bmap_t *bm; { if(bm) free_stmem(bm); } static colormap_t * alloc_colormap(dm) dmode_t *dm; { int nentries, i; colormap_t *cm; u_char type = CM_COLOR; switch(dm->vm_reg) { case RES_STLOW: case RES_TTMID: nentries = 16; break; case RES_STMID: nentries = 4; break; case RES_STHIGH: nentries = 2; break; case RES_TTLOW: nentries = 256; break; case RES_TTHIGH: type = CM_MONO; nentries = 0; default: panic("grf:alloc_colormap: wrong mode!?"); } if(!atari_realconfig) { cm = &con_cmap; cm->entry = con_colors; } else { int size; size = sizeof(*cm) + (nentries * sizeof(cm->entry[0])); cm = malloc(size, M_DEVBUF, M_NOWAIT); if(cm == NULL) return(NULL); cm->entry = (long *)&cm[1]; } if((cm->type = type) == CM_COLOR) cm->red_mask = cm->green_mask = cm->blue_mask = 0xf; cm->first = 0; cm->size = nentries; for(i = 0; i < nentries; i++) { register short val = def_color16[i % 16]; cm->entry[i] = CM_WTOL(val); } return(cm); }