Add Falcon video support. Thanks to Thomas Gerner.
This commit is contained in:
leo
parent
1e4fbda19c
commit
9c9abeb6c3
|
|
@ -1,5 +1,5 @@
|
|||
#
|
||||
# $NetBSD: ATARITT,v 1.4 1995/08/11 20:01:15 leo Exp $
|
||||
# $NetBSD: ATARITT,v 1.5 1995/08/20 18:17:09 leo Exp $
|
||||
#
|
||||
# ATARI-TT
|
||||
#
|
||||
|
|
@ -78,6 +78,7 @@ options GENERIC # Mini-root boot support
|
|||
# Atari specific kernel options:
|
||||
#
|
||||
options TT_SCSI # SCSI-support for TT only
|
||||
options TT_VIDEO # Graphics support for TT only
|
||||
|
||||
#
|
||||
# Build one kernel that can boot from any disk.
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#
|
||||
# $NetBSD: BOOT,v 1.2 1995/08/11 20:01:16 leo Exp $
|
||||
# $NetBSD: BOOT,v 1.3 1995/08/20 18:17:10 leo Exp $
|
||||
#
|
||||
# BOOT
|
||||
#
|
||||
|
|
@ -72,6 +72,8 @@ options GENERIC # Mini-root boot support
|
|||
options "ST_POOL_SIZE=22" # smallest that allows TT-HIGH
|
||||
options TT_SCSI # SCSI-support for TT
|
||||
options FALCON_SCSI # SCSI-support for Falcon
|
||||
options TT_VIDEO # Graphics support for TT
|
||||
options FALCON_VIDEO # Graphics support for FALCON
|
||||
|
||||
#
|
||||
# Build one kernel that can boot from any disk.
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#
|
||||
# $NetBSD: FALCON,v 1.1 1995/08/11 20:01:17 leo Exp $
|
||||
# $NetBSD: FALCON,v 1.2 1995/08/20 18:20:54 leo Exp $
|
||||
#
|
||||
# ATARI-FALCON
|
||||
#
|
||||
|
|
@ -64,6 +64,7 @@ options GENERIC # Mini-root boot support
|
|||
# Atari specific kernel options:
|
||||
#
|
||||
options FALCON_SCSI # SCSI-support for FACLON only
|
||||
options FALCON_VIDEO # Graphics support for FALCON
|
||||
|
||||
#
|
||||
# Build one kernel that can boot from any disk.
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#
|
||||
# $NetBSD: GENERIC,v 1.5 1995/08/11 20:01:18 leo Exp $
|
||||
# $NetBSD: GENERIC,v 1.6 1995/08/20 18:17:11 leo Exp $
|
||||
#
|
||||
# Generic atari
|
||||
#
|
||||
|
|
@ -86,6 +86,8 @@ options GENERIC # Mini-root boot support
|
|||
options "ST_POOL_SIZE=22" # smallest that allows TT-HIGH
|
||||
options TT_SCSI # SCSI-support for TT
|
||||
options FALCON_SCSI # SCSI-support for Falcon
|
||||
options TT_VIDEO # Graphics support for TT
|
||||
options FALCON_VIDEO # Graphics support for FALCON
|
||||
|
||||
#
|
||||
# Build one kernel that can boot from any disk.
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#
|
||||
# $NetBSD: files.atari,v 1.10 1995/08/11 20:01:19 leo Exp $
|
||||
# $NetBSD: files.atari,v 1.11 1995/08/20 18:17:12 leo Exp $
|
||||
#
|
||||
|
||||
maxpartitions 16
|
||||
|
|
@ -44,6 +44,8 @@ device grf at grfb {}
|
|||
file arch/atari/dev/grf.c grf needs-count
|
||||
file arch/atari/dev/ite_cc.c grf ite
|
||||
file arch/atari/dev/grfabs.c grf ite
|
||||
file arch/atari/dev/grfabs_tt.c grf ite
|
||||
file arch/atari/dev/grfabs_fal.c grf ite
|
||||
|
||||
device ite at grf
|
||||
file arch/atari/dev/ite.c ite needs-flag
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: grfabs.c,v 1.4 1995/05/21 10:54:44 leo Exp $ */
|
||||
/* $NetBSD: grfabs.c,v 1.5 1995/08/20 18:17:31 leo Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1995 Leo Weppelman.
|
||||
|
|
@ -37,6 +37,7 @@
|
|||
#include <sys/queue.h>
|
||||
#include <sys/malloc.h>
|
||||
|
||||
#include <machine/cpu.h>
|
||||
#include <machine/iomap.h>
|
||||
#include <machine/video.h>
|
||||
#include <machine/mfp.h>
|
||||
|
|
@ -46,62 +47,47 @@
|
|||
* Function decls
|
||||
*/
|
||||
static dmode_t *get_best_display_mode __P((dimen_t *, int, dmode_t *));
|
||||
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));
|
||||
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 MODES modes;
|
||||
|
||||
static dmode_t vid_modes[] = {
|
||||
{ { NULL, NULL }, "sthigh", { 640, 400 }, 1, RES_STHIGH },
|
||||
{ { NULL, NULL }, "tthigh", { 1280, 960 }, 1, RES_TTHIGH },
|
||||
{ { NULL, NULL }, "stmid", { 640, 200 }, 2, RES_STMID },
|
||||
{ { NULL, NULL }, "stlow", { 320, 200 }, 4, RES_STLOW },
|
||||
{ { NULL, NULL }, "ttmid", { 640, 480 }, 4, RES_TTMID },
|
||||
{ { NULL, NULL }, "ttlow", { 320, 480 }, 8, RES_TTLOW },
|
||||
{ { NULL, NULL }, NULL, }
|
||||
};
|
||||
/*
|
||||
* Ugh.. Stuff needed to allocate console structures before the VM-system
|
||||
* is running. There is no malloc() available at that time.
|
||||
* Decision to use these: atari_realconfig == 0
|
||||
*/
|
||||
view_t gra_con_view;
|
||||
colormap_t gra_con_cmap;
|
||||
long gra_con_colors[MAX_CENTRIES];
|
||||
|
||||
/*
|
||||
* Default colors.....
|
||||
* Currently the TT-low (256 colors) just uses 16 time the 16-color default.
|
||||
* Currently the TT-low (256 colors) just uses 16 times 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 */
|
||||
u_long gra_def_color16[16] = {
|
||||
0x00000000, /* black */
|
||||
0x00ffffff, /* white */
|
||||
0x00c0c0c0, /* light gray */
|
||||
0x00808080, /* gray */
|
||||
0x000000c0, /* blue */
|
||||
0x0000c000, /* green */
|
||||
0x0000c0c0, /* cyan */
|
||||
0x00c00000, /* red */
|
||||
0x00c000c0, /* magenta */
|
||||
0x00c0c000, /* brown */
|
||||
0x000000ff, /* light blue */
|
||||
0x0000ff00, /* light green */
|
||||
0x0000ffff, /* light cyan */
|
||||
0x00ff0000, /* light red */
|
||||
0x00ff00ff, /* light magenta */
|
||||
0x00ffff00 /* light brown */
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
@ -111,38 +97,23 @@ static u_short def_color16[16] = {
|
|||
int
|
||||
grfabs_probe()
|
||||
{
|
||||
dmode_t *dm;
|
||||
int i;
|
||||
int has_mono;
|
||||
static int inited = 0;
|
||||
static int inited = 0;
|
||||
|
||||
if(inited)
|
||||
return(1); /* Has to be done only once */
|
||||
if (inited)
|
||||
return (1); /* 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);
|
||||
#ifdef FALCON_VIDEO
|
||||
if (machineid & ATARI_FALCON)
|
||||
falcon_probe_video(&modes);
|
||||
#endif /* FALCON_VIDEO */
|
||||
#ifdef TT_VIDEO
|
||||
if (machineid & ATARI_TT)
|
||||
tt_probe_video(&modes);
|
||||
#endif /* TT_VIDEO */
|
||||
return ((modes.lh_first == NULL) ? 0 : 1);
|
||||
}
|
||||
|
||||
view_t *
|
||||
|
|
@ -151,10 +122,10 @@ dmode_t *d;
|
|||
dimen_t *dim;
|
||||
u_char depth;
|
||||
{
|
||||
if(!d)
|
||||
if (!d)
|
||||
d = get_best_display_mode(dim, depth, NULL);
|
||||
if(d)
|
||||
return(alloc_view(d, dim, depth));
|
||||
if (d)
|
||||
return ((d->grfabs_funcs->alloc_view)(d, dim, depth));
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
|
|
@ -163,61 +134,25 @@ grf_get_best_mode(dim, depth)
|
|||
dimen_t *dim;
|
||||
u_char depth;
|
||||
{
|
||||
return(get_best_display_mode(dim, depth, NULL));
|
||||
return (get_best_display_mode(dim, depth, 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;
|
||||
(v->mode->grfabs_funcs->display_view)(v);
|
||||
}
|
||||
|
||||
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;
|
||||
(v->mode->grfabs_funcs->remove_view)(v);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
(v->mode->grfabs_funcs->free_view)(v);
|
||||
}
|
||||
|
||||
int
|
||||
|
|
@ -243,9 +178,9 @@ colormap_t *cm;
|
|||
* Copy the colors
|
||||
*/
|
||||
bzero(cm->entry, cm->size * sizeof(long));
|
||||
for(i = 0; i < n; i++)
|
||||
for (i = 0; i < n; i++)
|
||||
cm->entry[i] = gcm->entry[i];
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
|
|
@ -253,83 +188,7 @@ grf_use_colormap(v, cm)
|
|||
view_t *v;
|
||||
colormap_t *cm;
|
||||
{
|
||||
dmode_t *dm;
|
||||
volatile u_short *creg;
|
||||
u_long *src;
|
||||
colormap_t *vcm;
|
||||
u_long *vcreg;
|
||||
u_short ncreg;
|
||||
int i;
|
||||
|
||||
dm = v->mode;
|
||||
vcm = v->colormap;
|
||||
|
||||
/*
|
||||
* I guess it seems reasonable to require the maps to be
|
||||
* of the same type...
|
||||
*/
|
||||
if(cm->type != vcm->type)
|
||||
return(EINVAL);
|
||||
|
||||
/*
|
||||
* First figure out where the actual colormap resides and
|
||||
* howmany colors are in it.
|
||||
*/
|
||||
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 first entry specified beyond capabilities -> error */
|
||||
if(cm->first >= ncreg)
|
||||
return(EINVAL);
|
||||
|
||||
/*
|
||||
* A little tricky, the actual colormap pointer will be NULL
|
||||
* when view is not displaying, valid otherwise.
|
||||
*/
|
||||
if(v->flags & VF_DISPLAY)
|
||||
creg = &creg[cm->first];
|
||||
else creg = NULL;
|
||||
|
||||
vcreg = &vcm->entry[cm->first];
|
||||
ncreg -= cm->first;
|
||||
if(cm->size > ncreg)
|
||||
return(EINVAL);
|
||||
ncreg = cm->size;
|
||||
|
||||
for(i = 0, src = cm->entry; i < ncreg; i++, vcreg++) {
|
||||
*vcreg = *src++;
|
||||
|
||||
/*
|
||||
* If displaying, also update actual color register.
|
||||
*/
|
||||
if(creg != NULL)
|
||||
*creg++ = CM_LTOW(*vcreg);
|
||||
}
|
||||
return(0);
|
||||
return (v->mode->grfabs_funcs->use_colormap)(v, cm);
|
||||
}
|
||||
|
||||
static dmode_t *
|
||||
|
|
@ -344,7 +203,7 @@ dmode_t *curr_mode;
|
|||
|
||||
save = NULL;
|
||||
dm = modes.lh_first;
|
||||
while(dm != NULL) {
|
||||
while (dm != NULL) {
|
||||
dx = abs(dm->size.width - dim->width);
|
||||
dy = abs(dm->size.height - dim->height);
|
||||
ct = dx + dy;
|
||||
|
|
@ -358,162 +217,12 @@ dmode_t *curr_mode;
|
|||
/*
|
||||
* Did we do better than the current mode?
|
||||
*/
|
||||
if((save != NULL) && (curr_mode != NULL)) {
|
||||
if ((save != NULL) && (curr_mode != NULL)) {
|
||||
dx = abs(curr_mode->size.width - dim->width);
|
||||
dy = abs(curr_mode->size.height - dim->height);
|
||||
ct = dx + dy;
|
||||
if(ct <= dt)
|
||||
return(NULL);
|
||||
if (ct <= dt)
|
||||
return (NULL);
|
||||
}
|
||||
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);
|
||||
if(v == NULL)
|
||||
return(NULL);
|
||||
|
||||
bm = alloc_bitmap(mode->size.width, mode->size.height, mode->depth);
|
||||
if(bm) {
|
||||
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;
|
||||
v->flags = 0;
|
||||
bcopy(dbox, &v->display, sizeof(box_t));
|
||||
}
|
||||
|
||||
/* bitmap functions */
|
||||
|
||||
static bmap_t *
|
||||
alloc_bitmap(width, height, depth)
|
||||
u_long width, height;
|
||||
u_char depth;
|
||||
{
|
||||
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;
|
||||
|
||||
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;
|
||||
break;
|
||||
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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,424 @@
|
|||
/* $NetBSD: grfabs_fal.c,v 1.1 1995/08/20 18:17:32 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.
|
||||
*/
|
||||
|
||||
#ifdef FALCON_VIDEO
|
||||
/*
|
||||
* atari abstract graphics driver: Falcon-interface
|
||||
*/
|
||||
#include <sys/param.h>
|
||||
#include <sys/queue.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/device.h>
|
||||
|
||||
#include <machine/iomap.h>
|
||||
#include <machine/video.h>
|
||||
#include <machine/mfp.h>
|
||||
#include <atari/atari/device.h>
|
||||
#include <atari/dev/grfabs_reg.h>
|
||||
|
||||
/*
|
||||
* Function decls
|
||||
*/
|
||||
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));
|
||||
static colormap_t *alloc_colormap __P((dmode_t *));
|
||||
static void free_bitmap __P((bmap_t *));
|
||||
static void falcon_display_view __P((view_t *));
|
||||
static view_t *falcon_alloc_view __P((dmode_t *, dimen_t *, u_char));
|
||||
static void falcon_free_view __P((view_t *));
|
||||
static void falcon_remove_view __P((view_t *));
|
||||
static int falcon_use_colormap __P((view_t *, colormap_t *));
|
||||
static void falcon_dedect __P((dmode_t *));
|
||||
|
||||
/*
|
||||
* Our function switch table
|
||||
*/
|
||||
struct grfabs_sw fal_vid_sw = {
|
||||
falcon_display_view,
|
||||
falcon_alloc_view,
|
||||
falcon_free_view,
|
||||
falcon_remove_view,
|
||||
falcon_use_colormap
|
||||
};
|
||||
|
||||
static dmode_t vid_modes[] = {
|
||||
{ { NULL, NULL }, "falauto",{ 0, 0 }, 0, RES_FALAUTO ,&fal_vid_sw},
|
||||
{ { NULL, NULL }, "sthigh", { 640, 400 }, 1, RES_FAL_STHIGH ,&fal_vid_sw},
|
||||
{ { NULL, NULL }, "stmid", { 640, 200 }, 2, RES_FAL_STMID ,&fal_vid_sw},
|
||||
{ { NULL, NULL }, "stlow", { 320, 200 }, 4, RES_FAL_STLOW ,&fal_vid_sw},
|
||||
{ { NULL, NULL }, "ttlow", { 320, 480 }, 8, RES_FAL_TTLOW ,&fal_vid_sw},
|
||||
{ { NULL, NULL }, "vga2", { 640, 480 }, 1, RES_VGA2 ,&fal_vid_sw},
|
||||
{ { NULL, NULL }, "vga4", { 640, 480 }, 2, RES_VGA4 ,&fal_vid_sw},
|
||||
{ { NULL, NULL }, "vga16", { 640, 480 }, 4, RES_VGA16 ,&fal_vid_sw},
|
||||
{ { NULL, NULL }, "vga256", { 640, 480 }, 8, RES_VGA256 ,&fal_vid_sw},
|
||||
{ { NULL, NULL }, "highcol",{ 320, 200 }, 16, RES_DIRECT ,&fal_vid_sw},
|
||||
{ { NULL, NULL }, NULL, }
|
||||
};
|
||||
|
||||
/*
|
||||
* XXX: called from ite console init routine.
|
||||
* Initialize list of posible video modes.
|
||||
*/
|
||||
void
|
||||
falcon_probe_video(modelp)
|
||||
MODES *modelp;
|
||||
{
|
||||
dmode_t *dm;
|
||||
int i;
|
||||
|
||||
/* Currently we support only one mode of the falcon video system.
|
||||
* This is the mode that is initialized before NetBSD starts. This
|
||||
* is possible since the bios has already done that work.
|
||||
*/
|
||||
|
||||
for (i = 0; (dm = &vid_modes[i])->name != NULL; i++) {
|
||||
if (dm->vm_reg == RES_FALAUTO) {
|
||||
falcon_dedect(dm);
|
||||
LIST_INSERT_HEAD(modelp, dm, link);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* This seems to prevent bordered screens.
|
||||
*/
|
||||
for (i=0; i < 16; i++)
|
||||
VIDEO->vd_fal_rgb[i] = CM_L2FAL(gra_def_color16[i]);
|
||||
}
|
||||
|
||||
static void
|
||||
falcon_dedect(dm)
|
||||
dmode_t *dm;
|
||||
{
|
||||
u_short falshift, stshift;
|
||||
short interlace, doublescan;
|
||||
|
||||
interlace = (VIDEO->vd_fal_ctrl & 0x2) >>1;
|
||||
doublescan = VIDEO->vd_fal_ctrl & 0x1;
|
||||
|
||||
/*
|
||||
* Calculate the depth of the screen
|
||||
*/
|
||||
|
||||
falshift = VIDEO->vd_fal_res;
|
||||
stshift = VIDEO->vd_st_res;
|
||||
|
||||
if (falshift & 0x400) /* 2 color */
|
||||
dm->depth = 1;
|
||||
else if (falshift & 0x100) /* high color, direct */
|
||||
dm->depth = 16;
|
||||
else if (falshift & 0x10) /* 256 color */
|
||||
dm->depth = 8;
|
||||
else if (stshift == 0) /* 16 color */
|
||||
dm->depth = 4;
|
||||
else if (stshift == 1) /* 4 color */
|
||||
dm->depth = 2;
|
||||
else dm->depth = 1; /* 2 color */
|
||||
|
||||
/*
|
||||
* Now calculate the screen hight
|
||||
*/
|
||||
|
||||
dm->size.height = VIDEO->vd_v_dis_end - VIDEO->vd_v_dis_beg;
|
||||
if (!interlace) dm->size.height >>=1;
|
||||
if (doublescan) dm->size.height >>=1;
|
||||
|
||||
/*
|
||||
* And the width
|
||||
*/
|
||||
|
||||
dm->size.width = VIDEO->vd_vert_wrap * 16 / dm->depth;
|
||||
}
|
||||
|
||||
static void
|
||||
falcon_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;
|
||||
|
||||
falcon_use_colormap(v, v->colormap);
|
||||
|
||||
/* XXX: should use vbl for this */
|
||||
/*
|
||||
* Falcon: here should set the videl to switch the video mode.
|
||||
* This will be added later.
|
||||
* At the moment we set only the video base.
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
static void
|
||||
falcon_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;
|
||||
}
|
||||
|
||||
static void
|
||||
falcon_free_view(v)
|
||||
view_t *v;
|
||||
{
|
||||
if (v) {
|
||||
dmode_t *md = v->mode;
|
||||
|
||||
falcon_remove_view(v);
|
||||
if (v->colormap != &gra_con_cmap)
|
||||
free(v->colormap, M_DEVBUF);
|
||||
free_bitmap(v->bitmap);
|
||||
if (v != &gra_con_view)
|
||||
free(v, M_DEVBUF);
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
falcon_use_colormap(v, cm)
|
||||
view_t *v;
|
||||
colormap_t *cm;
|
||||
{
|
||||
dmode_t *dm;
|
||||
volatile u_short *creg;
|
||||
volatile u_long *fcreg;
|
||||
u_long *src;
|
||||
colormap_t *vcm;
|
||||
u_long *vcreg;
|
||||
u_short ncreg;
|
||||
int i;
|
||||
|
||||
dm = v->mode;
|
||||
vcm = v->colormap;
|
||||
|
||||
/*
|
||||
* I guess it seems reasonable to require the maps to be
|
||||
* of the same type...
|
||||
*/
|
||||
if (cm->type != vcm->type)
|
||||
return (EINVAL);
|
||||
|
||||
/*
|
||||
* First get the colormap addresses an calculate
|
||||
* howmany colors are in it.
|
||||
*/
|
||||
if (dm->depth == 16) /* direct color, no colormap;
|
||||
but also not (yet) supported */
|
||||
return(0);
|
||||
fcreg = &VIDEO->vd_fal_rgb[0];
|
||||
creg = &VIDEO->vd_st_rgb[0];
|
||||
ncreg = 1 << dm->depth;
|
||||
|
||||
/* If first entry specified beyond capabilities -> error */
|
||||
if (cm->first >= ncreg)
|
||||
return (EINVAL);
|
||||
|
||||
/*
|
||||
* A little tricky, the actual colormap pointer will be NULL
|
||||
* when view is not displaying, valid otherwise.
|
||||
*/
|
||||
if (v->flags & VF_DISPLAY)
|
||||
creg = &creg[cm->first];
|
||||
else creg = NULL;
|
||||
|
||||
vcreg = &vcm->entry[cm->first];
|
||||
ncreg -= cm->first;
|
||||
if (cm->size > ncreg)
|
||||
return (EINVAL);
|
||||
ncreg = cm->size;
|
||||
|
||||
for (i = 0, src = cm->entry; i < ncreg; i++, vcreg++) {
|
||||
*vcreg = *src++;
|
||||
|
||||
/*
|
||||
* If displaying, also update actual color register.
|
||||
*/
|
||||
if (creg != NULL) {
|
||||
*fcreg++ = CM_L2FAL(*vcreg);
|
||||
if (i < 16 )
|
||||
*creg++ = CM_L2ST(*vcreg);
|
||||
}
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
|
||||
static view_t *
|
||||
falcon_alloc_view(mode, dim, depth)
|
||||
dmode_t *mode;
|
||||
dimen_t *dim;
|
||||
u_char depth;
|
||||
{
|
||||
view_t *v;
|
||||
bmap_t *bm;
|
||||
|
||||
if (!atari_realconfig)
|
||||
v = &gra_con_view;
|
||||
else v = malloc(sizeof(*v), M_DEVBUF, M_NOWAIT);
|
||||
if (v == NULL)
|
||||
return(NULL);
|
||||
|
||||
bm = alloc_bitmap(mode->size.width, mode->size.height, mode->depth);
|
||||
if (bm) {
|
||||
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 != &gra_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;
|
||||
v->flags = 0;
|
||||
bcopy(dbox, &v->display, sizeof(box_t));
|
||||
}
|
||||
|
||||
/* bitmap functions */
|
||||
|
||||
static bmap_t *
|
||||
alloc_bitmap(width, height, depth)
|
||||
u_long width, height;
|
||||
u_char depth;
|
||||
{
|
||||
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;
|
||||
|
||||
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;
|
||||
|
||||
if (dm->depth == 16) /* direct color, no colormap;
|
||||
not (yet) supported */
|
||||
nentries = 0;
|
||||
else
|
||||
nentries = 1 << dm->depth;
|
||||
|
||||
if (!atari_realconfig) {
|
||||
cm = &gra_con_cmap;
|
||||
cm->entry = gra_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 = 0x3f;
|
||||
|
||||
cm->first = 0;
|
||||
cm->size = nentries;
|
||||
|
||||
for (i = 0; i < nentries; i++)
|
||||
cm->entry[i] = gra_def_color16[i % 16];
|
||||
return (cm);
|
||||
}
|
||||
#endif /* FALCON_VIDEO */
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: grfabs_reg.h,v 1.3 1995/05/21 10:55:57 leo Exp $ */
|
||||
/* $NetBSD: grfabs_reg.h,v 1.4 1995/08/20 18:17:33 leo Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1995 Leo Weppelman
|
||||
|
|
@ -128,15 +128,40 @@ enum colormap_type {
|
|||
/*
|
||||
* Create a colormap entry
|
||||
*/
|
||||
#define MAKE_COLOR_ENTRY(r,g,b) (((r & 0xff)<<16)|((g & 0xff)<<8)|(b & 0xf))
|
||||
#define MAKE_COLOR_ENTRY(r,g,b) (((r & 0xff)<<16)|((g & 0xff)<<8)|(b & 0xff))
|
||||
#define MAKE_MONO_ENTRY(x) ((x) ? 1 : 0)
|
||||
#define MAKE_GREY_ENTRY(l) (l & 0xff)
|
||||
|
||||
#define CM_LTOW(v) \
|
||||
(((0x000f0000 & (v)) >> 8) | ((0x00000f00 & (v)) >> 4) | (0xf & (v)))
|
||||
#define CM_WTOL(v) \
|
||||
(((0xf00 & (v)) << 8) | ((0x0f0 & (v)) << 4) | (0xf & (v)))
|
||||
#define CM_L2TT(v) \
|
||||
(((0x00f00000 & (v)) >> 12) | ((0x0000f000 & (v)) >> 8) |\
|
||||
(0x000000f0 & (v)) >> 4)
|
||||
#define CM_TT2L(v) \
|
||||
((((0x00000f00 & (v)) * 0xff / 0xf) << 8) |\
|
||||
(((0x000000f0 & (v)) * 0xff / 0xf) << 4) |\
|
||||
(0x0000000f & (v)) * 0xff / 0xf)
|
||||
#define CM_L2FAL(v) \
|
||||
(((0x00fc0000 & (v)) << 8) | ((0x0000fc00 & (v)) << 8) |\
|
||||
(0x000000fc & (v)))
|
||||
#define CM_FAL2L(v) \
|
||||
(((((0xfc000000 & (v)) >> 10) * 0xff / 0x3f) & 0x00ff0000) |\
|
||||
((((0x00fc0000 & (v)) >> 10) * 0xff / 0x3f) & 0x0000ff00) |\
|
||||
((0x000000fc & (v)) >> 2) * 0xff / 0x3f)
|
||||
#define CM_L2ST(v) \
|
||||
(((0x00e00000 & (v)) >> 13) | ((0x0000e000 & (v)) >> 9) |\
|
||||
(0x000000e0 & (v)) >> 5)
|
||||
#define CM_ST2L(v) \
|
||||
(((((0x00000700 & (v)) * 0xff / 0x7) << 8) & 0x00ff0000) |\
|
||||
((((0x00000070 & (v)) * 0xff / 0x7) << 4) & 0x0000ff00) |\
|
||||
(0x00000007 & (v)) * 0xff / 0x7)
|
||||
|
||||
struct grfabs_sw {
|
||||
void (*display_view) __P((view_t*));
|
||||
view_t * (*alloc_view) __P((dmode_t *, dimen_t *, u_char));
|
||||
void (*free_view) __P((view_t *));
|
||||
void (*remove_view) __P((view_t *));
|
||||
int (*use_colormap) __P((view_t *, colormap_t *));
|
||||
};
|
||||
|
||||
/* display mode */
|
||||
struct display_mode {
|
||||
LIST_ENTRY(display_mode) link;
|
||||
|
|
@ -144,9 +169,15 @@ struct display_mode {
|
|||
dimen_t size; /* screen size */
|
||||
u_char depth; /* screen depth */
|
||||
u_short vm_reg; /* video mode register */
|
||||
struct grfabs_sw *grfabs_funcs; /* hardware switch table */
|
||||
view_t *current_view; /* view displaying me */
|
||||
};
|
||||
|
||||
/*
|
||||
* Definition of available graphic mode list.
|
||||
*/
|
||||
typedef LIST_HEAD(modelist, display_mode) MODES;
|
||||
|
||||
/*
|
||||
* Misc draw related macros.
|
||||
*/
|
||||
|
|
@ -158,9 +189,25 @@ struct display_mode {
|
|||
(b)->height = hh; \
|
||||
} while(0)
|
||||
|
||||
|
||||
/*
|
||||
* Common variables
|
||||
*/
|
||||
extern view_t gra_con_view;
|
||||
extern colormap_t gra_con_cmap;
|
||||
extern long gra_con_colors[MAX_CENTRIES];
|
||||
extern u_long gra_def_color16[16];
|
||||
|
||||
/*
|
||||
* Prototypes:
|
||||
*/
|
||||
#ifdef FALCON_VIDEO
|
||||
void falcon_probe_video __P((MODES *));
|
||||
#endif /* FALCON_VIDEO */
|
||||
#ifdef TT_VIDEO
|
||||
void tt_probe_video __P((MODES *));
|
||||
#endif /* TT_VIDEO */
|
||||
|
||||
view_t *grf_alloc_view __P((dmode_t *d, dimen_t *dim, u_char depth));
|
||||
dmode_t *grf_get_best_mode __P((dimen_t *dim, u_char depth));
|
||||
void grf_display_view __P((view_t *v));
|
||||
|
|
|
|||
|
|
@ -0,0 +1,402 @@
|
|||
/* $NetBSD: grfabs_tt.c,v 1.1 1995/08/20 18:17:34 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.
|
||||
*/
|
||||
|
||||
#ifdef TT_VIDEO
|
||||
/*
|
||||
* atari abstract graphics driver: TT-interface
|
||||
*/
|
||||
#include <sys/param.h>
|
||||
#include <sys/queue.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/device.h>
|
||||
|
||||
#include <machine/iomap.h>
|
||||
#include <machine/video.h>
|
||||
#include <machine/mfp.h>
|
||||
#include <atari/atari/device.h>
|
||||
#include <atari/dev/grfabs_reg.h>
|
||||
|
||||
/*
|
||||
* Function decls
|
||||
*/
|
||||
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));
|
||||
static colormap_t *alloc_colormap __P((dmode_t *));
|
||||
static void free_bitmap __P((bmap_t *));
|
||||
static void tt_display_view __P((view_t *));
|
||||
static view_t *tt_alloc_view __P((dmode_t *, dimen_t *, u_char));
|
||||
static void tt_free_view __P((view_t *));
|
||||
static void tt_remove_view __P((view_t *));
|
||||
static int tt_use_colormap __P((view_t *, colormap_t *));
|
||||
|
||||
/*
|
||||
* Our function switch table
|
||||
*/
|
||||
struct grfabs_sw tt_vid_sw = {
|
||||
tt_display_view,
|
||||
tt_alloc_view,
|
||||
tt_free_view,
|
||||
tt_remove_view,
|
||||
tt_use_colormap
|
||||
};
|
||||
|
||||
static dmode_t vid_modes[] = {
|
||||
{ { NULL, NULL }, "sthigh", { 640, 400 }, 1, RES_STHIGH, &tt_vid_sw },
|
||||
{ { NULL, NULL }, "tthigh", { 1280, 960 }, 1, RES_TTHIGH, &tt_vid_sw },
|
||||
{ { NULL, NULL }, "stmid", { 640, 200 }, 2, RES_STMID , &tt_vid_sw },
|
||||
{ { NULL, NULL }, "stlow", { 320, 200 }, 4, RES_STLOW , &tt_vid_sw },
|
||||
{ { NULL, NULL }, "ttmid", { 640, 480 }, 4, RES_TTMID , &tt_vid_sw },
|
||||
{ { NULL, NULL }, "ttlow", { 320, 480 }, 8, RES_TTLOW , &tt_vid_sw },
|
||||
{ { NULL, NULL }, NULL, }
|
||||
};
|
||||
|
||||
/*
|
||||
* XXX: called from ite console init routine.
|
||||
* Initialize list of posible video modes.
|
||||
*/
|
||||
void
|
||||
tt_probe_video(modelp)
|
||||
MODES *modelp;
|
||||
{
|
||||
dmode_t *dm;
|
||||
int i;
|
||||
int has_mono;
|
||||
|
||||
/*
|
||||
* 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;
|
||||
|
||||
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(modelp, dm, link);
|
||||
}
|
||||
|
||||
for (i=0; i < 16; i++)
|
||||
VIDEO->vd_tt_rgb[i] = CM_L2TT(gra_def_color16[i]);
|
||||
}
|
||||
|
||||
static void
|
||||
tt_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;
|
||||
|
||||
tt_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
|
||||
tt_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
|
||||
tt_free_view(v)
|
||||
view_t *v;
|
||||
{
|
||||
if(v) {
|
||||
dmode_t *md = v->mode;
|
||||
|
||||
tt_remove_view(v);
|
||||
if (v->colormap != &gra_con_cmap)
|
||||
free(v->colormap, M_DEVBUF);
|
||||
free_bitmap(v->bitmap);
|
||||
if (v != &gra_con_view)
|
||||
free(v, M_DEVBUF);
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
tt_use_colormap(v, cm)
|
||||
view_t *v;
|
||||
colormap_t *cm;
|
||||
{
|
||||
dmode_t *dm;
|
||||
volatile u_short *creg;
|
||||
u_long *src;
|
||||
colormap_t *vcm;
|
||||
u_long *vcreg;
|
||||
u_short ncreg;
|
||||
int i;
|
||||
|
||||
dm = v->mode;
|
||||
vcm = v->colormap;
|
||||
|
||||
/*
|
||||
* I guess it seems reasonable to require the maps to be
|
||||
* of the same type...
|
||||
*/
|
||||
if (cm->type != vcm->type)
|
||||
return(EINVAL);
|
||||
|
||||
/*
|
||||
* First figure out where the actual colormap resides and
|
||||
* howmany colors are in it.
|
||||
*/
|
||||
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_tt:use_colormap: wrong mode!?");
|
||||
}
|
||||
|
||||
/* If first entry specified beyond capabilities -> error */
|
||||
if (cm->first >= ncreg)
|
||||
return(EINVAL);
|
||||
|
||||
/*
|
||||
* A little tricky, the actual colormap pointer will be NULL
|
||||
* when view is not displaying, valid otherwise.
|
||||
*/
|
||||
if (v->flags & VF_DISPLAY)
|
||||
creg = &creg[cm->first];
|
||||
else creg = NULL;
|
||||
|
||||
vcreg = &vcm->entry[cm->first];
|
||||
ncreg -= cm->first;
|
||||
if (cm->size > ncreg)
|
||||
return(EINVAL);
|
||||
ncreg = cm->size;
|
||||
|
||||
for (i = 0, src = cm->entry; i < ncreg; i++, vcreg++) {
|
||||
*vcreg = *src++;
|
||||
|
||||
/*
|
||||
* If displaying, also update actual color registers.
|
||||
*/
|
||||
if (creg != NULL)
|
||||
*creg++ = CM_L2TT(*vcreg);
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
|
||||
static view_t *
|
||||
tt_alloc_view(mode, dim, depth)
|
||||
dmode_t *mode;
|
||||
dimen_t *dim;
|
||||
u_char depth;
|
||||
{
|
||||
view_t *v;
|
||||
bmap_t *bm;
|
||||
|
||||
if (!atari_realconfig)
|
||||
v = &gra_con_view;
|
||||
else v = malloc(sizeof(*v), M_DEVBUF, M_NOWAIT);
|
||||
if(v == NULL)
|
||||
return (NULL);
|
||||
|
||||
bm = alloc_bitmap(mode->size.width, mode->size.height, mode->depth);
|
||||
if (bm) {
|
||||
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 != &gra_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;
|
||||
v->flags = 0;
|
||||
bcopy(dbox, &v->display, sizeof(box_t));
|
||||
}
|
||||
|
||||
/* bitmap functions */
|
||||
|
||||
static bmap_t *
|
||||
alloc_bitmap(width, height, depth)
|
||||
u_long width, height;
|
||||
u_char depth;
|
||||
{
|
||||
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;
|
||||
|
||||
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;
|
||||
break;
|
||||
default:
|
||||
panic("grf_tt:alloc_colormap: wrong mode!?");
|
||||
}
|
||||
if (!atari_realconfig) {
|
||||
cm = &gra_con_cmap;
|
||||
cm->entry = gra_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++)
|
||||
cm->entry[i] = gra_def_color16[i % 16];
|
||||
return (cm);
|
||||
}
|
||||
#endif /* TT_VIDEO */
|
||||
Loading…
Reference in New Issue