Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
2937872ca5
NetBSD/sys/arch/amiga/dev/grf_cl.c

1118 lines
26 KiB
C
Raw Blame History

/*
* Copyright (c) 1995 Ezra Story
* Copyright (c) 1995 Kari Mettinen
* Copyright (c) 1994 Markus Wild
* Copyright (c) 1994 Lutz Vieweg
* 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 Lutz Vieweg.
* 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 GRF_CL5426
/*
* Graphics routines for Cirrus CL GD 5426 boards,
*
* This code offers low-level routines to access Cirrus Cl GD 5426
* graphics-boards from within NetBSD for the Amiga.
* No warranties for any kind of function at all - this
* code may crash your hardware and scratch your harddisk. Use at your
* own risk. Freely distributable.
*
* Modified for Cirrus CL GD 5426 from
* Lutz Vieweg's retina driver by Kari Mettinen 08/94
* Contributions by Ill, ScottE, MiL
* Extensively hacked and rewritten by Ezra Story (Ezy) 01/95
*
* Thanks to Village Tronic Marketing Gmbh for providing me with
* a Picasso-II board.
* Thanks for Integrated Electronics Oy Ab for providing me with
* Cirrus CL GD 542x family documentation.
*
* TODO:
* Mouse support
* Blitter support
*
*/
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <machine/cpu.h>
#include <dev/cons.h>
#include <amiga/amiga/device.h>
#include <amiga/dev/grfioctl.h>
#include <amiga/dev/grfvar.h>
#include <amiga/dev/grf_clreg.h>
#include <amiga/dev/zbusvar.h>
static int cl_mondefok __P((struct grfvideo_mode *mdp));
static void cl_boardinit();
static void CompFQ __P((u_int fq, u_char *num, u_char *denom));
static int cl_getvmode __P((struct grf_softc *gp, struct grfvideo_mode *vm));
static int cl_setvmode __P((struct grf_softc *gp, unsigned int mode));
static int cl_toggle __P((struct grf_softc *gp,unsigned short));
static int cl_getcmap __P((struct grf_softc *gfp, struct grf_colormap *cmap));
static int cl_putcmap __P((struct grf_softc *gfp, struct grf_colormap *cmap));
static void cl_off __P((struct grf_softc *gp));
static void cl_inittextmode __P((struct grf_softc *gp));
static int cl_ioctl __P((register struct grf_softc *gp, int cmd, void *data));
void grfclattach __P((struct device *, struct device *, void *));
int grfclprint __P((void *, char *));
int grfclmatch __P((struct device *, struct cfdata *, void *));
void memset __P((unsigned char *d, unsigned char c, int l));
/* Graphics display definitions.
* These are filled by 'grfconfig' using GRFIOCSETMON.
*/
#define monitor_def_max 8
static struct grfvideo_mode monitor_def[8] = {
{0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}
};
static struct grfvideo_mode *monitor_current = &monitor_def[0];
/* Patchable maximum pixel clock */
unsigned long cl_maxpixelclock = 115000000;
/* Console display definition.
* Default hardcoded text mode. This grf_cl is set up to
* use one text mode only, and this is it. You may use
* grfconfig to change the mode after boot.
*/
/* Console font */
#ifdef KFONT_8X11
#define CIRRUSFONT kernel_font_8x11
#define CIRRUSFONTY 11
#else
#define CIRRUSFONT kernel_font_8x8
#define CIRRUSFONTY 8
#endif
extern unsigned char CIRRUSFONT[];
struct grfcltext_mode clconsole_mode = {
{255, "", 25200000, 640, 480, 4, 80, 94, 99, 100, 100, 481, 490,
498, 522, 522},
8, CIRRUSFONTY, 80, 480/CIRRUSFONTY, CIRRUSFONT, 32, 255
};
/* Console colors */
unsigned char clconscolors[3][3] = { /* background, foreground, hilite */
{0,0x40,0x50}, {152,152,152}, {255,255,255}
};
int cltype = 0; /* Picasso, Spectrum or Piccolo */
unsigned char pass_toggle; /* passthru status tracker */
/* because all 5426-boards have 2 configdev entries, one for
* framebuffer mem and the other for regs, we have to hold onto
* the pointers globally until we match on both. This and 'cltype'
* are the primary obsticles to multiple board support, but if you
* have multiple boards you have bigger problems than grf_cl.
*/
static void *cl_fbaddr = 0; /* framebuffer */
static void *cl_regaddr = 0; /* registers */
static int cl_fbsize; /* framebuffer size */
/* standard driver stuff */
struct cfdriver grfclcd = {
NULL, "grfcl", (cfmatch_t)grfclmatch, grfclattach,
DV_DULL, sizeof(struct grf_softc), NULL, 0
};
static struct cfdata *cfdata;
int
grfclmatch(pdp, cfp, auxp)
struct device *pdp;
struct cfdata *cfp;
void *auxp;
{
struct zbus_args *zap;
static int regprod, fbprod;
zap = auxp;
#ifndef CL5426CONSOLE
if (amiga_realconfig == 0)
return(0);
#endif
/* Grab the first board we encounter as the preferred one.
* This will allow one board to work in a multiple 5426 board
* system, but not multiple boards at the same time.
*/
if (cltype == 0) {
switch (zap->manid) {
case PICASSO:
regprod = 12;
fbprod = 11;
break;
case SPECTRUM:
regprod = 2;
fbprod = 1;
break;
case PICCOLO:
regprod = 6;
fbprod = 5;
break;
default:
return(0);
}
cltype = zap->manid;
} else {
if (cltype != zap->manid) {
return(0);
}
}
/* Configure either registers or framebuffer in any order
*/
if (zap->prodid == regprod)
cl_regaddr = zap->va;
else if (zap->prodid == fbprod) {
cl_fbaddr = zap->va;
cl_fbsize = zap->size;
} else {
printf("grfcl: Bad product id\n");
return(0);
}
#ifdef CL5426CONSOLE
if (amiga_realconfig == 0) {
cfdata = cfp;
}
#endif
return(1);
}
void
grfclattach(pdp, dp, auxp)
struct device *pdp, *dp;
void *auxp;
{
static struct grf_softc congrf;
struct zbus_args *zap;
struct grf_softc *gp;
int x;
static char attachflag = 0;
zap = auxp;
printf("\n");
/* make sure both halves have matched */
if (!cl_regaddr || !cl_fbaddr)
return;
/* do all that messy console/grf stuff */
if (dp == NULL)
gp = &congrf;
else
gp = (struct grf_softc *)dp;
if (dp != NULL && congrf.g_regkva != 0) {
/*
* inited earlier, just copy (not device struct)
*/
bcopy(&congrf.g_display, &gp->g_display,
(char *)&gp[1] - (char *)&gp->g_display);
} else {
gp->g_regkva = (volatile caddr_t)cl_regaddr;
gp->g_fbkva = (volatile caddr_t)cl_fbaddr;
gp->g_unit = GRF_CL5426_UNIT;
gp->g_mode = cl_mode;
gp->g_conpri = grfcl_cnprobe();
gp->g_flags = GF_ALIVE;
/* wakeup the board */
cl_boardinit(gp);
#ifdef CL5426CONSOLE
grfcl_iteinit(gp);
(void)cl_load_mon(gp, &clconsole_mode);
#endif
}
/*
* attach grf (once)
*/
if (amiga_config_found(cfdata, &gp->g_device, gp, grfclprint)) {
attachflag = 1;
printf("grfcl: %dMB ", cl_fbsize/0x100000);
switch (cltype) {
case PICASSO:
printf("Picasso II");
break;
case SPECTRUM:
printf("Spectrum");
break;
case PICCOLO:
printf("Piccolo");
break;
}
printf(" being used\n");
} else {
if (!attachflag)
printf("grfcl unattached!!\n");
}
}
int
grfclprint(auxp, pnp)
void *auxp;
char *pnp;
{
if (pnp)
printf("ite at %s: ", pnp);
return(UNCONF);
}
void
cl_boardinit(gp)
struct grf_softc *gp;
{
unsigned char *ba = gp->g_regkva;
int x;
void *bah;
/* wakeup board and flip passthru OFF */
RegWakeup(ba);
RegOnpass(ba);
vgaw(ba, 0x46e8, 0x16);
vgaw(ba, 0x102, 1);
vgaw(ba, 0x46e8, 0x0e);
vgaw(ba, 0x3c3, 1);
/* setup initial unchanging parameters */
WSeq(ba, SEQ_ID_CLOCKING_MODE, 0x21); /* 8 dot - display off */
vgaw(ba, GREG_MISC_OUTPUT_W, 0xe1); /* mem disable */
WGfx(ba, GCT_ID_OFFSET_1, 0xec); /* magic cookie */
WSeq(ba, SEQ_ID_UNLOCK_EXT, 0x12); /* yum! cookies! */
WSeq(ba, SEQ_ID_DRAM_CNTL, 0xb0);
WSeq(ba, SEQ_ID_RESET, 0x03);
WSeq(ba, SEQ_ID_MAP_MASK, 0xff);
WSeq(ba, SEQ_ID_CHAR_MAP_SELECT, 0x00);
WSeq(ba, SEQ_ID_MEMORY_MODE, 0x0e); /* a or 6? */
WSeq(ba, SEQ_ID_EXT_SEQ_MODE, (cltype == PICASSO) ? 0x20 : 0x80);
WSeq(ba, SEQ_ID_EEPROM_CNTL, 0x00);
WSeq(ba, SEQ_ID_PERF_TUNE, 0x0a);
WSeq(ba, SEQ_ID_SIG_CNTL, 0x02);
WSeq(ba, SEQ_ID_MCLK_SELECT, 0x22);
WCrt(ba, CRT_ID_PRESET_ROW_SCAN, 0x00);
WCrt(ba, CRT_ID_CURSOR_START, 0x00);
WCrt(ba, CRT_ID_CURSOR_END, 0x08);
WCrt(ba, CRT_ID_START_ADDR_HIGH, 0x00);
WCrt(ba, CRT_ID_START_ADDR_LOW, 0x00);
WCrt(ba, CRT_ID_CURSOR_LOC_HIGH, 0x00);
WCrt(ba, CRT_ID_CURSOR_LOC_LOW, 0x00);
WCrt(ba, CRT_ID_UNDERLINE_LOC, 0x07);
WCrt(ba, CRT_ID_MODE_CONTROL, 0xa3); /* c3 */
WCrt(ba, CRT_ID_LINE_COMPARE, 0xff); /* ff */
WCrt(ba, CRT_ID_EXT_DISP_CNTL, 0x22);
WSeq(ba, SEQ_ID_CURSOR_STORE, 0x00);
WGfx(ba, GCT_ID_SET_RESET, 0x00);
WGfx(ba, GCT_ID_ENABLE_SET_RESET, 0x00);
WGfx(ba, GCT_ID_DATA_ROTATE, 0x00);
WGfx(ba, GCT_ID_READ_MAP_SELECT, 0x00);
WGfx(ba, GCT_ID_GRAPHICS_MODE, 0x00);
WGfx(ba, GCT_ID_MISC, 0x01);
WGfx(ba, GCT_ID_COLOR_XCARE, 0x0f);
WGfx(ba, GCT_ID_BITMASK, 0xff);
WGfx(ba, GCT_ID_MODE_EXT, 0x28);
for (x=0; x< 0x10; x++)
WAttr(ba, x, x);
WAttr(ba, ACT_ID_ATTR_MODE_CNTL, 0x01);
WAttr(ba, ACT_ID_OVERSCAN_COLOR, 0x00);
WAttr(ba, ACT_ID_COLOR_PLANE_ENA, 0x0f);
WAttr(ba, ACT_ID_HOR_PEL_PANNING, 0x00);
WAttr(ba, ACT_ID_COLOR_SELECT, 0x00);
delay(200000);
WAttr(ba, 0x34, 0x00);
delay(200000);
vgaw(ba, VDAC_MASK, 0xff);
delay(200000);
vgaw(ba, GREG_MISC_OUTPUT_W, 0xe3); /* c3 */
WGfx(ba, GCT_ID_BLT_STAT_START, 0x40);
WGfx(ba, GCT_ID_BLT_STAT_START, 0x00);
/* colors initially set to greyscale */
vgaw(ba, VDAC_ADDRESS_W, 0);
for (x = 255; x >= 0 ; x--) {
vgaw(ba, VDAC_DATA, x);
vgaw(ba, VDAC_DATA, x);
vgaw(ba, VDAC_DATA, x);
}
}
int
cl_getvmode(gp, vm)
struct grf_softc *gp;
struct grfvideo_mode *vm;
{
struct grfvideo_mode *gv;
#ifdef CL5426CONSOLE
/* Handle grabbing console mode */
if (vm->mode_num == 255) {
bcopy(&clconsole_mode, vm, sizeof(struct grfvideo_mode));
/* XXX so grfconfig can tell us the correct text
* dimensions.
*/
vm->depth = clconsole_mode.fy;
return(0);
}
#endif
if (vm->mode_num && vm->mode_num > monitor_def_max)
return(EINVAL);
if (!vm->mode_num)
vm->mode_num = (monitor_current - monitor_def) + 1;
gv = monitor_def + (vm->mode_num - 1);
if (gv->mode_num == 0)
return(EINVAL);
bcopy(gv, vm, sizeof(struct grfvideo_mode));
return(0);
}
int
cl_setvmode(gp, mode)
struct grf_softc *gp;
unsigned mode;
{
struct grfvideo_mode *gv;
if (!mode || (mode > monitor_def_max) ||
monitor_def[mode-1].mode_num == 0)
return(EINVAL);
monitor_current = monitor_def + (mode - 1);
return(0);
}
void
cl_off(gp)
struct grf_softc *gp;
{
char *ba = gp->g_regkva;
/* we'll put the pass-through on for cc ite and set Full Bandwidth
* bit on just in case it didn't work...but then it doesn't matter
* does it? =)
*/
RegOnpass(ba);
WSeq(ba, SEQ_ID_CLOCKING_MODE, 0x21);
}
/*
* Change the mode of the display.
* Return a UNIX error number or 0 for success.
*/
cl_mode(gp, cmd, arg, a2, a3)
register struct grf_softc *gp;
int cmd;
void *arg;
int a2, a3;
{
int error;
switch (cmd) {
case GM_GRFON:
error = cl_load_mon (gp,
(struct grfcltext_mode *) monitor_current) ? 0 : EINVAL;
return(error);
case GM_GRFOFF:
#ifndef CL5426CONSOLE
cl_off(gp);
#else
cl_load_mon(gp, &clconsole_mode);
#endif
return(0);
case GM_GRFCONFIG:
return(0);
case GM_GRFGETVMODE:
return(cl_getvmode (gp, (struct grfvideo_mode *) arg));
case GM_GRFSETVMODE:
error = cl_setvmode (gp, *(unsigned *) arg);
if (!error && (gp->g_flags & GF_GRFON))
cl_load_mon(gp,
(struct grfcltext_mode *) monitor_current);
return(error);
case GM_GRFGETNUMVM:
*(int *)arg = monitor_def_max;
return(0);
case GM_GRFIOCTL:
return(cl_ioctl (gp, (int) arg, (caddr_t) a2));
default:
break;
}
return(EINVAL);
}
int
cl_ioctl (gp, cmd, data)
register struct grf_softc *gp;
int cmd;
void *data;
{
switch (cmd) {
case GRFIOCGSPRITEPOS:
case GRFIOCSSPRITEPOS:
case GRFIOCSSPRITEINF:
case GRFIOCGSPRITEINF:
case GRFIOCGSPRITEMAX:
break;
case GRFIOCGETCMAP:
return(cl_getcmap (gp, (struct grf_colormap *) data));
case GRFIOCPUTCMAP:
return(cl_putcmap (gp, (struct grf_colormap *) data));
case GRFIOCBITBLT:
break;
case GRFTOGGLE:
return(cl_toggle (gp,0));
case GRFIOCSETMON:
return(cl_setmonitor (gp, (struct grfvideo_mode *)data));
}
return(EINVAL);
}
int
cl_setmonitor(gp, gv)
struct grf_softc *gp;
struct grfvideo_mode *gv;
{
struct grfvideo_mode *md;
unsigned long maxpix;
#ifdef CL5426CONSOLE
/* handle interactive setting of console mode */
if (gv->mode_num == 255 && gv->depth == 4) {
bcopy(gv, &clconsole_mode.gv, sizeof(struct grfvideo_mode));
clconsole_mode.rows = gv->disp_height / clconsole_mode.fy;
clconsole_mode.cols = gv->disp_width / clconsole_mode.fx;
if (!(gp->g_flags & GF_GRFON))
cl_load_mon(gp, &clconsole_mode);
ite_reinit(gp->g_itedev);
return(0);
}
#endif
/* text mode not valid for other than console */
if (gv->depth == 4)
return(EINVAL);
if (!gv->mode_num || gv->mode_num > monitor_def_max)
return(EINVAL);
if ((gv->depth == 24 && (gv->pixel_clock*3) > cl_maxpixelclock) ||
(gv->pixel_clock > cl_maxpixelclock))
return(EINVAL);
md = monitor_def + (gv->mode_num-1);
bcopy(gv, md, sizeof(struct grfvideo_mode));
return(0);
}
int
cl_getcmap (gfp, cmap)
struct grf_softc *gfp;
struct grf_colormap *cmap;
{
volatile unsigned char *ba;
u_char red[256], green[256], blue[256], *rp, *gp, *bp;
short x;
int error;
if (cmap->count == 0 || cmap->index >= 256)
return 0;
if (cmap->index + cmap->count > 256)
cmap->count = 256 - cmap->index;
ba = gfp->g_regkva;
/* first read colors out of the chip, then copyout to userspace */
vgaw (ba, VDAC_ADDRESS_W, cmap->index);
x = cmap->count - 1;
/* Some sort 'o Magic. Spectrum has some changes on the board to speed
* up 15 and 16Bit modes. They can access these modes with easy-to-programm
* rgbrgbrgb instead of rrrgggbbb. Side effect: when in 8Bit mode, rgb
* is swapped to bgr. I wonder if we need to check for 8Bit though, ill
*/
switch (cltype) {
case SPECTRUM:
case PICCOLO:
rp = blue + cmap->index;
gp = green + cmap->index;
bp = red + cmap->index;
break;
case PICASSO:
rp = red + cmap->index;
gp = green + cmap->index;
bp = blue + cmap->index;
break;
}
do {
*rp++ = vgar (ba, VDAC_DATA) << 2;
*gp++ = vgar (ba, VDAC_DATA) << 2;
*bp++ = vgar (ba, VDAC_DATA) << 2;
} while (x-- > 0);
if (!(error = copyout (red + cmap->index, cmap->red, cmap->count))
&& !(error = copyout (green + cmap->index, cmap->green, cmap->count))
&& !(error = copyout (blue + cmap->index, cmap->blue, cmap->count)))
return(0);
return(error);
}
int
cl_putcmap (gfp, cmap)
struct grf_softc *gfp;
struct grf_colormap *cmap;
{
volatile unsigned char *ba;
u_char red[256], green[256], blue[256], *rp, *gp, *bp;
short x;
int error;
if (cmap->count == 0 || cmap->index >= 256)
return(0);
if (cmap->index + cmap->count > 256)
cmap->count = 256 - cmap->index;
/* first copy the colors into kernelspace */
if (!(error = copyin (cmap->red, red + cmap->index, cmap->count))
&& !(error = copyin (cmap->green, green + cmap->index, cmap->count))
&& !(error = copyin (cmap->blue, blue + cmap->index, cmap->count))) {
ba = gfp->g_regkva;
vgaw (ba, VDAC_ADDRESS_W, cmap->index);
x = cmap->count - 1;
switch (cltype) {
case SPECTRUM:
case PICCOLO:
rp = blue + cmap->index;
gp = green + cmap->index;
bp = red + cmap->index;
break;
case PICASSO:
rp = red + cmap->index;
gp = green + cmap->index;
bp = blue + cmap->index;
break;
}
do {
vgaw (ba, VDAC_DATA, *rp++ >> 2);
vgaw (ba, VDAC_DATA, *gp++ >> 2);
vgaw (ba, VDAC_DATA, *bp++ >> 2);
} while (x-- > 0);
return(0);
}
else
return(error);
}
int
cl_toggle(gp,wopp)
struct grf_softc *gp;
unsigned short wopp; /* don't need that one yet, ill */
{
volatile unsigned char *ba;
ba = gp->g_regkva;
if (pass_toggle) {
RegOffpass(ba);
} else {
/* This was in the original.. is it needed? */
if (cltype == PICASSO || cltype == PICCOLO)
RegWakeup(ba);
RegOnpass(ba);
}
return(0);
}
static void
CompFQ(fq,num,denom)
u_int fq;
u_char *num;
u_char *denom;
{
#define OSC 14318180
/* OK, here's what we're doing here:
*
* OSC * NUMERATOR
* VCLK = ------------------- Hz
* DENOMINATOR * (1+P)
*
* so we're given VCLK and we should give out some useful
* values....
*
* NUMERATOR is 6 bits wide
* DENOMINATOR is 5 bits wide with bit P in the same char as bit 0.
*
* We run through all the possible combinations and
* return the values which deviate the least from the chosen frequency.
*
*/
#define OSC 14318180
#define count(n,d,p) ((OSC * n)/(d * (1+p)))
unsigned char n, d, p, minn, mind, minp;
unsigned long err, minerr;
/*
numer = 0x00 - 0x7f (7 bit!)
denom = 0x00 - 0x1f (1) 0x20 - 0x3e (even)
*/
/* find lowest error in 6144 iterations.
*/
minerr = fq;
minn = 0;
mind = 0;
p = 0;
for (d=1; d < 0x20; d++) {
for (n=1; n < 0x80; n++) {
err = abs(count(n, d, p) - fq);
if (err < minerr) {
minerr = err;
minn = n;
mind = d;
minp = p;
}
}
if (d == 0x1f && p == 0) {
p = 1;
d = 0x0f;
}
}
*num = minn;
*denom = (mind << 1) | minp;
if (minerr > 500000)
printf("Warning: CompFQ minimum error = %d\n", minerr);
return;
}
int
cl_mondefok(mdp)
struct grfvideo_mode *mdp;
{
if (mdp->mode_num == 0 || (mdp->depth == 24 ?
mdp->pixel_clock * 3 : mdp->pixel_clock) > cl_maxpixelclock)
return(0);
switch(mdp->depth) {
case 1:
case 4:
case 8:
case 15:
case 16:
case 24:
return(1);
default:
return(0);
}
}
int
cl_load_mon(gp, md)
struct grf_softc *gp;
struct grfcltext_mode *md;
{
struct grfvideo_mode *gv;
struct grfinfo *gi;
volatile unsigned char *ba;
volatile unsigned char *fb;
unsigned char num0,denom0;
unsigned short HT,HDE,HBS,HBE,HSS,HSE,VDE,VBS,VBE,VSS,VSE,VT;
char LACE, DBLSCAN, TEXT;
unsigned short clkdiv, clksel;
int uplim, lowlim;
/* identity */
gv = &md->gv;
TEXT = (gv->depth == 4);
if (!cl_mondefok(gv)) {
printf("mondef not ok\n");
return(0);
}
ba = gp->g_regkva;
fb = gp->g_fbkva;
/* provide all needed information in grf device-independant
* locations
*/
gp->g_data = (caddr_t) gv;
gi = &gp->g_display;
gi->gd_regaddr = (caddr_t) ztwopa (ba);
gi->gd_regsize = 64*1024;
gi->gd_fbaddr = (caddr_t) kvtop (fb);
gi->gd_fbsize = cl_fbsize;
gi->gd_colors = 1 << gv->depth;
gi->gd_planes = gv->depth;
gi->gd_fbwidth = gv->disp_width;
gi->gd_fbheight = gv->disp_height;
gi->gd_fbx = 0;
gi->gd_fby = 0;
if (TEXT) {
gi->gd_dwidth = md->fx * md->cols;
gi->gd_dheight = md->fy * md->rows;
} else {
gi->gd_dwidth = gv->disp_width;
gi->gd_dheight = gv->disp_height;
}
gi->gd_dx = 0;
gi->gd_dy = 0;
/* get display mode parameters */
HBS = gv->hblank_start;
HBE = gv->hblank_stop;
HSS = gv->hsync_start;
HSE = gv->hsync_stop;
HT = gv->htotal;
VBS = gv->vblank_start;
VSS = gv->vsync_start;
VSE = gv->vsync_stop;
VBE = gv->vblank_stop;
VT = gv->vtotal;
if (TEXT)
HDE = ((gv->disp_width+md->fx-1)/md->fx) - 1;
else
HDE = (gv->disp_width+3)/8 - 1; /*HBS;*/
VDE = gv->disp_height-1;
/* figure out whether lace or dblscan is needed */
uplim = gv->disp_height + (gv->disp_height / 4);
lowlim = gv->disp_height - (gv->disp_height / 4);
LACE = (((VT*2) > lowlim) && ((VT*2) < uplim)) ? 1 : 0;
DBLSCAN = (((VT/2) > lowlim) && ((VT/2) < uplim)) ? 1 : 0;
/* adjustments */
if (LACE)
VDE /= 2;
WSeq(ba, SEQ_ID_MEMORY_MODE, (TEXT || (gv->depth == 1)) ? 0x06 : 0x0e);
WSeq(ba, SEQ_ID_DRAM_CNTL, (TEXT || (gv->depth == 1)) ? 0x90 : 0xb0);
WGfx(ba, GCT_ID_READ_MAP_SELECT, 0x00);
WSeq(ba, SEQ_ID_MAP_MASK, (gv->depth == 1) ? 0x01 : 0xff);
WSeq(ba, SEQ_ID_CHAR_MAP_SELECT, 0x00);
/* Set clock */
CompFQ((gv->depth == 24) ? gv->pixel_clock*3 : gv->pixel_clock,
&num0, &denom0);
WSeq(ba, SEQ_ID_VCLK_0_NUM, num0);
WSeq(ba, SEQ_ID_VCLK_0_DENOM, denom0);
/* load display parameters into board */
WCrt(ba, CRT_ID_HOR_TOTAL, HT);
WCrt(ba, CRT_ID_HOR_DISP_ENA_END, ((HDE >= HBS) ? HBS-1 : HDE));
WCrt(ba, CRT_ID_START_HOR_BLANK, HBS);
WCrt(ba, CRT_ID_END_HOR_BLANK, (HBE & 0x1f) | 0x80); /* | 0x80? */
WCrt(ba, CRT_ID_START_HOR_RETR, HSS);
WCrt(ba, CRT_ID_END_HOR_RETR,
(HSE & 0x1f) |
((HBE & 0x20) ? 0x80 : 0x00) );
WCrt(ba, CRT_ID_VER_TOTAL, VT);
WCrt(ba, CRT_ID_OVERFLOW,
0x10 |
((VT & 0x100) ? 0x01 : 0x00) |
((VDE & 0x100) ? 0x02 : 0x00) |
((VSS & 0x100) ? 0x04 : 0x00) |
((VBS & 0x100) ? 0x08 : 0x00) |
((VT & 0x200) ? 0x20 : 0x00) |
((VDE & 0x200) ? 0x40 : 0x00) |
((VSS & 0x200) ? 0x80 : 0x00) );
WCrt(ba, CRT_ID_CHAR_HEIGHT,
0x40 | /* TEXT ? 0x00 ??? */
(DBLSCAN ? 0x80 : 0x00) |
((VBS & 0x200) ? 0x20 : 0x00) |
(TEXT ? ((md->fy-1) & 0x1f) : 0x00));
WCrt(ba, CRT_ID_MODE_CONTROL,
((TEXT || (gv->depth == 1)) ? 0xc3 : 0xa3));
/* text cursor */
if (TEXT) {
#if 0
WCrt(ba, CRT_ID_CURSOR_START, (md->fy & 0x1f) - 2);
WCrt(ba, CRT_ID_CURSOR_END, (md->fy & 0x1f) - 1);
#else
WCrt(ba, CRT_ID_CURSOR_START, 0x00);
WCrt(ba, CRT_ID_CURSOR_END, md->fy & 0x1f);
#endif
WCrt(ba, CRT_ID_UNDERLINE_LOC, md->fy-1 & 0x1f);
WCrt(ba, CRT_ID_CURSOR_LOC_HIGH, 0x00);
WCrt(ba, CRT_ID_CURSOR_LOC_LOW, 0x00);
}
WCrt(ba, CRT_ID_START_ADDR_HIGH, 0x00);
WCrt(ba, CRT_ID_START_ADDR_LOW, 0x00);
WCrt(ba, CRT_ID_START_VER_RETR, VSS);
WCrt(ba, CRT_ID_END_VER_RETR, (VSE & 0x0f) | 0x30);
WCrt(ba, CRT_ID_VER_DISP_ENA_END, VDE);
WCrt(ba, CRT_ID_START_VER_BLANK, VBS);
WCrt(ba, CRT_ID_END_VER_BLANK, VBE);
WCrt(ba, CRT_ID_LINE_COMPARE, 0xff);
WCrt(ba, CRT_ID_LACE_END, HT/2); /* MW/16 */
WCrt(ba, CRT_ID_LACE_CNTL,
(LACE ? 0x01 : 0x00) |
((HBE & 0x40) ? 0x10 : 0x00) |
((HBE & 0x80) ? 0x20 : 0x00) |
((VBE & 0x100) ? 0x40 : 0x00) |
((VBE & 0x200) ? 0x80 : 0x00) );
/* depth dependent stuff */
switch (gv->depth) {
case 1:
case 4:
case 8:
clkdiv = 0;
break;
case 15:
case 16:
clkdiv = 3;
break;
case 24:
clkdiv = 2;
break;
}
WGfx(ba, GCT_ID_GRAPHICS_MODE,
((TEXT || (gv->depth == 1)) ? 0x00 : 0x40));
WGfx(ba, GCT_ID_MISC, (TEXT ? 0x04 : 0x01));
WSeq(ba, SEQ_ID_EXT_SEQ_MODE,
((TEXT || (gv->depth == 1)) ? 0x00 : 0x01) |
((cltype == PICASSO) ? 0x20: 0x80) |
(clkdiv << 1) );
delay(200000);
vgaw(ba, VDAC_MASK, 0xff);
delay(200000);
vgar(ba, VDAC_MASK);
delay(200000);
vgar(ba, VDAC_MASK);
delay(200000);
vgar(ba, VDAC_MASK);
delay(200000);
vgar(ba, VDAC_MASK);
delay(200000);
switch (gv->depth) {
case 1:
case 4: /* text */
vgaw(ba, VDAC_MASK, 0);
HDE = gv->disp_width / 16;
break;
case 8:
vgaw(ba, VDAC_MASK, 0);
HDE = gv->disp_width / 8;
break;
case 15:
vgaw(ba, VDAC_MASK, 0xd0);
HDE = gv->disp_width / 4;
break;
case 16:
vgaw(ba, VDAC_MASK, 0xc1);
HDE = gv->disp_width / 4;
break;
case 24:
vgaw(ba, VDAC_MASK, 0xc5);
HDE = (gv->disp_width / 8) * 3;
break;
}
delay(200000);
WCrt(ba, CRT_ID_OFFSET, HDE);
WCrt(ba, CRT_ID_EXT_DISP_CNTL,
((TEXT && gv->pixel_clock > 29000000) ? 0x40 : 0x00) |
0x22 |
((HDE > 0xff) ? 0x10 : 0x00)); /* text? */
delay(200000);
WAttr(ba, ACT_ID_ATTR_MODE_CNTL, (TEXT ? 0x0a : 0x01));
delay(200000);
WAttr(ba, 0x20 | ACT_ID_COLOR_PLANE_ENA,
(gv->depth == 1) ? 0x01 : 0x0f);
delay(200000);
/* text initialization */
if (TEXT) {
cl_inittextmode(gp);
}
WSeq(ba, SEQ_ID_CURSOR_ATTR, 0x14);
WSeq(ba, SEQ_ID_CLOCKING_MODE, 0x01);
/* Pass-through */
RegOffpass(ba);
return(1);
}
void
cl_inittextmode(gp)
struct grf_softc *gp;
{
struct grfcltext_mode *tm = (struct grfcltext_mode *)gp->g_data;
volatile unsigned char *ba = gp->g_regkva;
unsigned char *fb = gp->g_fbkva;
unsigned char *c, *f, y;
unsigned short z;
/* load text font into beginning of display memory.
* Each character cell is 32 bytes long (enough for
* 4 planes)
*/
SetTextPlane(ba, 0x02);
c = (unsigned char *)(fb);
f = tm->fdata;
for (z = 0; z < tm->fdstart; z++, c+=(32-tm->fy))
for (y=0; y < tm->fy; y++)
*c++ = 0;
for (; z <= tm->fdend; z++, c+=(32-tm->fy))
for (y=0; y < tm->fy; y++)
*c++ = *f++;
for (; z < 256; z++, c+=(32-tm->fy))
for (y=0; y < tm->fy; y++)
*c++ = 0;
/* clear out text/attr planes (three screens worth) */
SetTextPlane(ba, 0x01);
memset(fb, 0x07, tm->cols*tm->rows*3);
SetTextPlane(ba, 0x00);
memset(fb, 0x20, tm->cols*tm->rows*3);
/* print out a little init msg */
c = (unsigned char *)(fb) + (tm->cols-16);
strcpy(c, "CIRRUS");
c[6] = 0x20;
/* set colors (B&W) */
vgaw(ba, VDAC_ADDRESS_W, 0);
for (z=0; z<256; z++) {
unsigned char r, g, b;
y = (z & 1) ? ((z > 7) ? 2 : 1) : 0;
if (cltype == PICASSO) {
r = clconscolors[y][0];
g = clconscolors[y][1];
b = clconscolors[y][2];
} else {
b = clconscolors[y][0];
g = clconscolors[y][1];
r = clconscolors[y][2];
}
vgaw(ba, VDAC_DATA, r >> 2);
vgaw(ba, VDAC_DATA, g >> 2);
vgaw(ba, VDAC_DATA, b >> 2);
}
}
void
memset(d, c, l)
unsigned char *d;
unsigned char c;
int l;
{
for(; l>0; l--)
*d++ = c;
}
#endif /* GRF_CL5426 */
Reference in New Issue View Git Blame Copy Permalink