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

1443 lines
39 KiB
C
Raw Blame History

/* $NetBSD: grf_rt.c,v 1.24 1996/03/17 01:17:18 thorpej Exp $ */
/*
* Copyright (c) 1993 Markus Wild
* Copyright (c) 1993 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.
*/
#include "grfrt.h"
#if NGRFRT > 0
/* Graphics routines for the Retina board,
using the NCR 77C22E+ VGA controller. */
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/device.h>
#include <machine/cpu.h>
#include <amiga/amiga/device.h>
#include <amiga/dev/zbusvar.h>
#include <amiga/dev/grfioctl.h>
#include <amiga/dev/grfvar.h>
#include <amiga/dev/grf_rtreg.h>
int rt_ioctl __P((struct grf_softc *gp, u_long, void *));
/*
* marked true early so that retina_cnprobe() can tell if we are alive.
*/
int retina_inited;
/*
* This driver for the MacroSystem Retina board was only possible,
* because MacroSystem provided information about the pecularities
* of the board. THANKS! Competition in Europe among gfx board
* manufacturers is rather tough, so Lutz Vieweg, who wrote the
* initial driver, has made an agreement with MS not to document
* the driver source (see also his comment below).
* -> ALL comments after
* -> "/* -------------- START OF CODE -------------- * /"
* -> have been added by myself (mw) from studying the publically
* -> available "NCR 77C22E+" Data Manual
*/
/*
* This code offers low-level routines to access the Retina graphics-board
* manufactured by MS MacroSystem GmbH from within NetBSD for the Amiga.
*
* Thanks to MacroSystem for providing me with the neccessary information
* to create theese routines. The sparse documentation of this code
* results from the agreements between MS and me.
*/
extern unsigned char kernel_font_8x8_width, kernel_font_8x8_height;
extern unsigned char kernel_font_8x8_lo, kernel_font_8x8_hi;
extern unsigned char kernel_font_8x8[];
#define MDF_DBL 1
#define MDF_LACE 2
#define MDF_CLKDIV2 4
/* standard-palette definition */
unsigned char NCRStdPalette[16*3] = {
/* R G B */
0, 0, 0,
192,192,192,
128, 0, 0,
0,128, 0,
0, 0,128,
128,128, 0,
0,128,128,
128, 0,128,
64, 64, 64, /* the higher 8 colors have more intensity for */
255,255,255, /* compatibility with standard attributes */
255, 0, 0,
0,255, 0,
0, 0,255,
255,255, 0,
0,255,255,
255, 0,255
};
/* The following structures are examples for monitor-definitions. To make one
of your own, first use "DefineMonitor" and create the 8-bit monitor-mode of
your dreams. Then save it, and make a structure from the values provided in
the file DefineMonitor stored - the labels in the comment above the
structure definition show where to put what value.
Then you'll need to adapt your monitor-definition to the font you want to
use. Be FX the width of the font, then the following modifications have to
be applied to your values:
HBS = (HBS * 4) / FX
HSS = (HSS * 4) / FX
HSE = (HSE * 4) / FX
HBE = (HBE * 4) / FX
HT = (HT * 4) / FX
Make sure your maximum width (MW) and height (MH) are even multiples of
the fonts' width and height.
*/
#if 0
/* horizontal 31.5 kHz */
/* FQ FLG MW MH HBS HSS HSE HBE HT VBS VSS VSE VBE VT */
struct MonDef MON_640_512_60 = { 50000000, 28, 640, 512, 81, 86, 93, 98, 95, 513, 513, 521, 535, 535,
/* Depth, PAL, TX, TY, XY,FontX, FontY, FontData, FLo, Fhi */
4, NCRStdPalette, 80, 64, 5120, 8, 8, kernel_font_8x8, 32, 255};
struct MonDef MON_640_480_62_G = { 50000000, 4, 640, 480, 161,171,184,196,195, 481, 484, 492, 502, 502,
8, NCRStdPalette,640,480, 5120, 8, 8, kernel_font_8x8, 32, 255};
/* Enter higher values here ^ ^ for panning! */
/* horizontal 38kHz */
struct MonDef MON_768_600_60 = { 75000000, 28, 768, 600, 97, 99,107,120,117, 601, 615, 625, 638, 638,
4, NCRStdPalette, 96, 75, 7200, 8, 8, kernel_font_8x8, 32, 255};
/* horizontal 64kHz */
struct MonDef MON_768_600_80 = { 50000000, 24, 768, 600, 97,104,112,122,119, 601, 606, 616, 628, 628,
4, NCRStdPalette, 96, 75, 7200, 8, 8, kernel_font_8x8, 32, 255};
struct MonDef MON_1024_768_80 = { 90000000, 24, 1024, 768, 129,130,141,172,169, 769, 770, 783, 804, 804,
4, NCRStdPalette,128, 96, 12288, 8, 8, kernel_font_8x8, 32, 255};
/* FQ FLG MW MH HBS HSS HSE HBE HT VBS VSS VSE VBE VT */
struct MonDef MON_1024_768_80_G = { 90000000, 0, 1024, 768, 257,258,280,344,343, 769, 770, 783, 804, 804,
8, NCRStdPalette, 1024, 768, 12288, 8, 8, kernel_font_8x8, 32, 255};
struct MonDef MON_1024_1024_59= { 90000000, 24, 1024,1024, 129,130,141,173,170,1025,1059,1076,1087,1087,
4, NCRStdPalette,128, 128, 16384, 8, 8, kernel_font_8x8, 32, 255};
/* WARNING: THE FOLLOWING MONITOR MODES EXCEED THE 90-MHz LIMIT THE PROCESSOR
HAS BEEN SPECIFIED FOR. USE AT YOUR OWN RISK (AND THINK ABOUT
MOUNTING SOME COOLING DEVICE AT THE PROCESSOR AND RAMDAC)! */
struct MonDef MON_1280_1024_60= {110000000, 24, 1280,1024, 161,162,176,211,208,1025,1026,1043,1073,1073,
4, NCRStdPalette,160, 128, 20480, 8, 8, kernel_font_8x8, 32, 255};
struct MonDef MON_1280_1024_60_G= {110000000, 0, 1280,1024, 321,322,349,422,421,1025,1026,1043,1073,1073,
8, NCRStdPalette,1280,1024, 20480, 8, 8, kernel_font_8x8, 32, 255};
/* horizontal 75kHz */
struct MonDef MON_1280_1024_69= {120000000, 24, 1280,1024, 161,162,175,200,197,1025,1026,1043,1073,1073,
4, NCRStdPalette,160, 128, 20480, 8, 8, kernel_font_8x8, 32, 255};
#else
struct MonDef monitor_defs[] = {
/* horizontal 31.5 kHz */
{ 50000000, 28, 640, 512, 81, 86, 93, 98, 95, 513, 513, 521, 535, 535,
4, NCRStdPalette, 80, 64, 5120, 8, 8, kernel_font_8x8, 32, 255},
/* horizontal 38kHz */
{ 75000000, 28, 768, 600, 97, 99,107,120,117, 601, 615, 625, 638, 638,
4, NCRStdPalette, 96, 75, 7200, 8, 8, kernel_font_8x8, 32, 255},
/* horizontal 64kHz */
{ 50000000, 24, 768, 600, 97,104,112,122,119, 601, 606, 616, 628, 628,
4, NCRStdPalette, 96, 75, 7200, 8, 8, kernel_font_8x8, 32, 255},
{ 90000000, 24, 1024, 768, 129,130,141,172,169, 769, 770, 783, 804, 804,
4, NCRStdPalette,128, 96, 12288, 8, 8, kernel_font_8x8, 32, 255},
/* GFX modes */
/* horizontal 31.5 kHz */
{ 50000000, 4, 640, 480, 161,171,184,196,195, 481, 484, 492, 502, 502,
8, NCRStdPalette,640, 480, 5120, 8, 8, kernel_font_8x8, 32, 255},
/* horizontal 64kHz */
{ 90000000, 0, 1024, 768, 257,258,280,344,343, 769, 770, 783, 804, 804,
8, NCRStdPalette, 1024, 768, 12288, 8, 8, kernel_font_8x8, 32, 255},
/* WARNING: THE FOLLOWING MONITOR MODES EXCEED THE 90-MHz LIMIT THE PROCESSOR
HAS BEEN SPECIFIED FOR. USE AT YOUR OWN RISK (AND THINK ABOUT
MOUNTING SOME COOLING DEVICE AT THE PROCESSOR AND RAMDAC)! */
{110000000, 0, 1280,1024, 321,322,349,422,421,1025,1026,1043,1073,1073,
8, NCRStdPalette,1280,1024, 20480, 8, 8, kernel_font_8x8, 32, 255},
};
static const char *monitor_descr[] = {
"80x64 (640x512) 31.5kHz",
"96x75 (768x600) 38kHz",
"96x75 (768x600) 64kHz",
"128x96 (1024x768) 64kHz",
"GFX (640x480) 31.5kHz",
"GFX (1024x768) 64kHz",
"GFX (1280x1024) 64kHz ***EXCEEDS CHIP LIMIT!!!***",
};
int retina_mon_max = sizeof (monitor_defs)/sizeof (monitor_defs[0]);
/* patchable */
int retina_default_mon = 0;
int retina_default_gfx = 4;
#endif
static struct MonDef *current_mon;
/* -------------- START OF CODE -------------- */
static const long FQTab[16] =
{ 25175000, 28322000, 36000000, 65000000,
44900000, 50000000, 80000000, 75000000,
56644000, 63000000, 72000000, 130000000,
90000000, 100000000, 110000000, 120000000 };
/*--------------------------------------------------*/
/*--------------------------------------------------*/
#if 0
static struct MonDef *default_monitor = &DEFAULT_MONDEF;
#endif
/*
* used to query the retina to see if its alive (?)
*/
int
retina_alive(mdp)
struct MonDef *mdp;
{
short clksel;
for (clksel = 15; clksel; clksel--) {
if (FQTab[clksel] == mdp->FQ)
break;
}
if (clksel < 0)
return(0);
if (mdp->DEP != 4)
return(1);
if (mdp->FX == 4 || (mdp->FX >= 7 && mdp->FX <= 16))
return(1);
return(0);
}
static int
rt_load_mon(gp, md)
struct grf_softc *gp;
struct MonDef *md;
{
struct grfinfo *gi = &gp->g_display;
volatile unsigned char *ba;
volatile unsigned char *fb;
short FW, clksel, HDE, VDE;
for (clksel = 15; clksel; clksel--) {
if (FQTab[clksel] == md->FQ) break;
}
if (clksel < 0)
return(0);
ba = gp->g_regkva;;
fb = gp->g_fbkva;
FW = 0;
if (md->DEP == 4) {
switch (md->FX) {
case 4:
FW = 0;
break;
case 7:
FW = 1;
break;
case 8:
FW = 2;
break;
case 9:
FW = 3;
break;
case 10:
FW = 4;
break;
case 11:
FW = 5;
break;
case 12:
FW = 6;
break;
case 13:
FW = 7;
break;
case 14:
FW = 8;
break;
case 15:
FW = 9;
break;
case 16:
FW = 11;
break;
default:
return(0);
break;
};
}
if (md->DEP == 4) HDE = (md->MW+md->FX-1)/md->FX;
else HDE = (md->MW+3)/4;
VDE = md->MH-1;
/* hmm... */
fb[0x8000] = 0;
/* enable extension registers */
WSeq (ba, SEQ_ID_EXTENDED_ENABLE, 0x05);
#if 0
/* program the clock oscillator */
vgaw (ba, GREG_MISC_OUTPUT_W, 0xe3 | ((clksel & 3) * 0x04));
vgaw (ba, GREG_FEATURE_CONTROL_W, 0x00);
/* XXXX according to the NCR specs, this register should be set to 1
XXXX before doing the MISC_OUTPUT setting and CLOCKING_MODE
XXXX setting. */
WSeq (ba, SEQ_ID_RESET, 0x03);
WSeq (ba, SEQ_ID_CLOCKING_MODE, 0x01 | ((md->FLG & MDF_CLKDIV2)/ MDF_CLKDIV2 * 8));
WSeq (ba, SEQ_ID_MAP_MASK, 0x0f);
WSeq (ba, SEQ_ID_CHAR_MAP_SELECT, 0x00);
/* odd/even write select + extended memory */
WSeq (ba, SEQ_ID_MEMORY_MODE, 0x06);
/* XXXX I think this order of setting RESET is wrong... */
WSeq (ba, SEQ_ID_RESET, 0x01);
WSeq (ba, SEQ_ID_RESET, 0x03);
#else
WSeq (ba, SEQ_ID_RESET, 0x01);
/* set font width + rest of clocks */
WSeq (ba, SEQ_ID_EXT_CLOCK_MODE, 0x30 | (FW & 0x0f) | ((clksel & 4) / 4 * 0x40) );
/* another clock bit, plus hw stuff */
WSeq (ba, SEQ_ID_MISC_FEATURE_SEL, 0xf4 | (clksel & 8) );
/* program the clock oscillator */
vgaw (ba, GREG_MISC_OUTPUT_W, 0xe3 | ((clksel & 3) * 0x04));
vgaw (ba, GREG_FEATURE_CONTROL_W, 0x00);
WSeq (ba, SEQ_ID_CLOCKING_MODE, 0x01 | ((md->FLG & MDF_CLKDIV2)/ MDF_CLKDIV2 * 8));
WSeq (ba, SEQ_ID_MAP_MASK, 0x0f);
WSeq (ba, SEQ_ID_CHAR_MAP_SELECT, 0x00);
/* odd/even write select + extended memory */
WSeq (ba, SEQ_ID_MEMORY_MODE, 0x06);
WSeq (ba, SEQ_ID_RESET, 0x03);
#endif
/* monochrome cursor */
WSeq (ba, SEQ_ID_CURSOR_CONTROL, 0x00);
/* bank0 */
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, 0x00);
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, 0x00);
WSeq (ba, SEQ_ID_DISP_OFF_HI , 0x00);
WSeq (ba, SEQ_ID_DISP_OFF_LO , 0x00);
/* bank0 */
WSeq (ba, SEQ_ID_SEC_HOST_OFF_HI, 0x00);
WSeq (ba, SEQ_ID_SEC_HOST_OFF_LO, 0x00);
/* 1M-chips + ena SEC + ena EMem + rw PrimA0/rw Sec/B0 */
WSeq (ba, SEQ_ID_EXTENDED_MEM_ENA, 0x3 | 0x4 | 0x10 | 0x40);
#if 0
/* set font width + rest of clocks */
WSeq (ba, SEQ_ID_EXT_CLOCK_MODE, 0x30 | (FW & 0x0f) | ((clksel & 4) / 4 * 0x40) );
#endif
if (md->DEP == 4) {
/* no ext-chain4 + no host-addr-bit-16 */
WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR, 0x00);
/* no packed/nibble + no 256bit gfx format */
WSeq (ba, SEQ_ID_EXT_PIXEL_CNTL, 0x00);
}
else {
WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR, 0x02);
/* 256bit gfx format */
WSeq (ba, SEQ_ID_EXT_PIXEL_CNTL, 0x01);
}
/* AT-interface */
WSeq (ba, SEQ_ID_BUS_WIDTH_FEEDB, 0x06);
/* see fg/bg color expansion */
WSeq (ba, SEQ_ID_COLOR_EXP_WFG, 0x01);
WSeq (ba, SEQ_ID_COLOR_EXP_WBG, 0x00);
WSeq (ba, SEQ_ID_EXT_RW_CONTROL, 0x00);
#if 0
/* another clock bit, plus hw stuff */
WSeq (ba, SEQ_ID_MISC_FEATURE_SEL, 0xf4 | (clksel & 8) );
#endif
/* don't tristate PCLK and PIX */
WSeq (ba, SEQ_ID_COLOR_KEY_CNTL, 0x40 );
/* reset CRC circuit */
WSeq (ba, SEQ_ID_CRC_CONTROL, 0x00 );
/* set RAS/CAS swap */
WSeq (ba, SEQ_ID_PERF_SELECT, 0x20);
WCrt (ba, CRT_ID_END_VER_RETR, (md->VSE & 0xf ) | 0x20);
WCrt (ba, CRT_ID_HOR_TOTAL, md->HT & 0xff);
WCrt (ba, CRT_ID_HOR_DISP_ENA_END, (HDE-1) & 0xff);
WCrt (ba, CRT_ID_START_HOR_BLANK, md->HBS & 0xff);
WCrt (ba, CRT_ID_END_HOR_BLANK, (md->HBE & 0x1f) | 0x80);
WCrt (ba, CRT_ID_START_HOR_RETR, md->HSS & 0xff);
WCrt (ba, CRT_ID_END_HOR_RETR, (md->HSE & 0x1f) | ((md->HBE & 0x20)/ 0x20 * 0x80));
WCrt (ba, CRT_ID_VER_TOTAL, (md->VT & 0xff));
WCrt (ba, CRT_ID_OVERFLOW, (( (md->VSS & 0x200) / 0x200 * 0x80)
| ((VDE & 0x200) / 0x200 * 0x40)
| ((md->VT & 0x200) / 0x200 * 0x20)
| 0x10
| ((md->VBS & 0x100) / 0x100 * 8 )
| ((md->VSS & 0x100) / 0x100 * 4 )
| ((VDE & 0x100) / 0x100 * 2 )
| ((md->VT & 0x100) / 0x100 )));
WCrt (ba, CRT_ID_PRESET_ROW_SCAN, 0x00);
if (md->DEP == 4) {
WCrt (ba, CRT_ID_MAX_SCAN_LINE, (( (md->FLG & MDF_DBL)/ MDF_DBL * 0x80)
| 0x40
| ((md->VBS & 0x200)/0x200 * 0x20)
| ((md->FY-1) & 0x1f)));
}
else {
WCrt (ba, CRT_ID_MAX_SCAN_LINE, (( (md->FLG & MDF_DBL)/ MDF_DBL * 0x80)
| 0x40
| ((md->VBS & 0x200)/0x200 * 0x20)
| (0 & 0x1f)));
}
WCrt (ba, CRT_ID_CURSOR_START, (md->FY & 0x1f) - 2);
WCrt (ba, CRT_ID_CURSOR_END, (md->FY & 0x1f) - 1);
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_START_VER_RETR, md->VSS & 0xff);
WCrt (ba, CRT_ID_END_VER_RETR, (md->VSE & 0x0f) | 0x80 | 0x20);
WCrt (ba, CRT_ID_VER_DISP_ENA_END, VDE & 0xff);
if (md->DEP == 4)
WCrt (ba, CRT_ID_OFFSET, (HDE / 2) & 0xff);
else
WCrt (ba, CRT_ID_OFFSET, (md->TX / 8) & 0xff);
WCrt (ba, CRT_ID_UNDERLINE_LOC, (md->FY-1) & 0x1f);
WCrt (ba, CRT_ID_START_VER_BLANK, md->VBS & 0xff);
WCrt (ba, CRT_ID_END_VER_BLANK, md->VBE & 0xff);
/* byte mode + wrap + select row scan counter + cms */
WCrt (ba, CRT_ID_MODE_CONTROL, 0xe3);
WCrt (ba, CRT_ID_LINE_COMPARE, 0xff);
/* enable extended end bits + those bits */
WCrt (ba, CRT_ID_EXT_HOR_TIMING1, ( 0x20
| ((md->FLG & MDF_LACE) / MDF_LACE * 0x10)
| ((md->HT & 0x100) / 0x100 * 0x01)
| (((HDE-1) & 0x100) / 0x100 * 0x02)
| ((md->HBS & 0x100) / 0x100 * 0x04)
| ((md->HSS & 0x100) / 0x100 * 0x08)));
if (md->DEP == 4)
WCrt (ba, CRT_ID_EXT_START_ADDR, (((HDE / 2) & 0x100)/0x100 * 16));
else
WCrt (ba, CRT_ID_EXT_START_ADDR, (((md->TX / 8) & 0x100)/0x100 * 16));
WCrt (ba, CRT_ID_EXT_HOR_TIMING2, ( ((md->HT & 0x200)/ 0x200 * 0x01)
| (((HDE-1) & 0x200)/ 0x200 * 0x02)
| ((md->HBS & 0x200)/ 0x200 * 0x04)
| ((md->HSS & 0x200)/ 0x200 * 0x08)
| ((md->HBE & 0xc0) / 0x40 * 0x10)
| ((md->HSE & 0x60) / 0x20 * 0x40)));
WCrt (ba, CRT_ID_EXT_VER_TIMING, ( ((md->VSE & 0x10) / 0x10 * 0x80)
| ((md->VBE & 0x300)/ 0x100 * 0x20)
| 0x10
| ((md->VSS & 0x400)/ 0x400 * 0x08)
| ((md->VBS & 0x400)/ 0x400 * 0x04)
| ((VDE & 0x400)/ 0x400 * 0x02)
| ((md->VT & 0x400)/ 0x400 * 0x01)));
WGfx (ba, GCT_ID_SET_RESET, 0x00);
WGfx (ba, GCT_ID_ENABLE_SET_RESET, 0x00);
WGfx (ba, GCT_ID_COLOR_COMPARE, 0x00);
WGfx (ba, GCT_ID_DATA_ROTATE, 0x00);
WGfx (ba, GCT_ID_READ_MAP_SELECT, 0x00);
WGfx (ba, GCT_ID_GRAPHICS_MODE, 0x00);
if (md->DEP == 4)
WGfx (ba, GCT_ID_MISC, 0x04);
else
WGfx (ba, GCT_ID_MISC, 0x05);
WGfx (ba, GCT_ID_COLOR_XCARE, 0xff);
WGfx (ba, GCT_ID_BITMASK, 0xff);
/* reset the Attribute Controller flipflop */
vgar (ba, GREG_STATUS1_R);
WAttr (ba, ACT_ID_PALETTE0, 0x00);
WAttr (ba, ACT_ID_PALETTE1, 0x01);
WAttr (ba, ACT_ID_PALETTE2, 0x02);
WAttr (ba, ACT_ID_PALETTE3, 0x03);
WAttr (ba, ACT_ID_PALETTE4, 0x04);
WAttr (ba, ACT_ID_PALETTE5, 0x05);
WAttr (ba, ACT_ID_PALETTE6, 0x06);
WAttr (ba, ACT_ID_PALETTE7, 0x07);
WAttr (ba, ACT_ID_PALETTE8, 0x08);
WAttr (ba, ACT_ID_PALETTE9, 0x09);
WAttr (ba, ACT_ID_PALETTE10, 0x0a);
WAttr (ba, ACT_ID_PALETTE11, 0x0b);
WAttr (ba, ACT_ID_PALETTE12, 0x0c);
WAttr (ba, ACT_ID_PALETTE13, 0x0d);
WAttr (ba, ACT_ID_PALETTE14, 0x0e);
WAttr (ba, ACT_ID_PALETTE15, 0x0f);
vgar (ba, GREG_STATUS1_R);
if (md->DEP == 4)
WAttr (ba, ACT_ID_ATTR_MODE_CNTL, 0x08);
else
WAttr (ba, ACT_ID_ATTR_MODE_CNTL, 0x09);
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);
vgar (ba, GREG_STATUS1_R);
/* I have *NO* idea what strobing reg-0x20 might do... */
vgaw (ba, ACT_ADDRESS_W, 0x20);
if (md->DEP == 4)
WCrt (ba, CRT_ID_MAX_SCAN_LINE, ( ((md->FLG & MDF_DBL)/ MDF_DBL * 0x80)
| 0x40
| ((md->VBS & 0x200)/0x200 * 0x20)
| ((md->FY-1) & 0x1f)));
else
WCrt (ba, CRT_ID_MAX_SCAN_LINE, ( ((md->FLG & MDF_DBL)/ MDF_DBL * 0x80)
| 0x40
| ((md->VBS & 0x200)/0x200 * 0x20)
| (0 & 0x1f)));
/* not it's time for guessing... */
vgaw (ba, VDAC_REG_D, 0x02);
/* if this does what I think it does, it selects DAC
register 0, and writes the palette in subsequent
registers, thus it works similar to the WD33C93
select/data mechanism */
vgaw (ba, VDAC_REG_SELECT, 0x00);
{
short x = 15;
const unsigned char * col = md->PAL;
do {
vgaw (ba, VDAC_REG_DATA, *col++);
vgaw (ba, VDAC_REG_DATA, *col++);
vgaw (ba, VDAC_REG_DATA, *col++);
} while (x--);
if (md->DEP != 4) {
short x = 256-17;
unsigned char col = 16;
do {
vgaw(ba, VDAC_REG_DATA, col);
vgaw(ba, VDAC_REG_DATA, col);
vgaw(ba, VDAC_REG_DATA, col);
col++;
} while (x--);
}
}
/* now load the font into maps 2 (and 3 for fonts wider than 8 pixels) */
if (md->DEP == 4) {
/* first set the whole font memory to a test-pattern, so we
can see if something that shouldn't be drawn IS drawn.. */
{
volatile unsigned char * c = fb;
long x;
Map(2);
for (x = 0; x < 65536; x++) {
*c++ = (x & 1)? 0xaa : 0x55;
}
}
{
volatile unsigned char * c = fb;
long x;
Map(3);
for (x = 0; x < 65536; x++) {
*c++ = (x & 1)? 0xaa : 0x55;
}
}
{
/* ok, now position at first defined character, and
copy over the images */
volatile unsigned char * c = fb + md->FLo * 32;
const unsigned char * f = md->FData;
unsigned short z;
Map(2);
for (z = md->FLo; z <= md->FHi; z++) {
short y = md->FY-1;
if (md->FX > 8){
do {
*c++ = *f;
f += 2;
} while (y--);
}
else {
do {
*c++ = *f++;
} while (y--);
}
c += 32-md->FY;
}
if (md->FX > 8) {
unsigned short z;
Map(3);
c = fb + md->FLo*32;
f = md->FData+1;
for (z = md->FLo; z <= md->FHi; z++) {
short y = md->FY-1;
do {
*c++ = *f;
f += 2;
} while (y--);
c += 32-md->FY;
}
}
}
}
/* select map 0 */
WGfx (ba, GCT_ID_READ_MAP_SELECT, 0);
if (md->DEP == 4)
/* allow writes into maps 0 and 1 */
WSeq (ba, SEQ_ID_MAP_MASK, 3);
else
/* allow writes into all maps */
WSeq (ba, SEQ_ID_MAP_MASK, 0x0f);
/* select extended chain4 addressing:
!A0/!A1 map 0 character to be displayed
!A1/ A1 map 1 attribute of that character
A0/!A1 map 2 not used (masked out, ignored)
A0/ A1 map 3 not used (masked out, ignored) */
WSeq (ba, SEQ_ID_EXT_VIDEO_ADDR, RSeq(ba, SEQ_ID_EXT_VIDEO_ADDR) | 0x02);
if (md->DEP == 4) {
/* position in display memory */
unsigned short * c = (unsigned short *) fb;
/* fill with blank, white on black */
const unsigned short fill_val = 0x2010;
short x = md->XY;
do {
*c = fill_val;
c += 2; } while (x--);
/* I won't comment this :-)) */
c = (unsigned short *) fb;
c += (md->TX-6)*2;
{
unsigned short init_msg[6] = {0x520a, 0x450b, 0x540c, 0x490d, 0x4e0e, 0x410f};
unsigned short * f = init_msg;
x = 5;
do {
*c = *f++;
c += 2;
} while (x--);
}
}
else if (md->DEP == 8) {
/* could clear the gfx screen here, but that's what the X server does anyway */
;
}
gp->g_data = (caddr_t)md;
gi->gd_regaddr = (caddr_t)ztwopa(ba);
gi->gd_regsize = 64*1024;
gi->gd_fbaddr = (caddr_t)ztwopa(fb);
#ifdef BANKEDDEVPAGER
gi->gd_fbsize = 4*1024*1024; /* XXX */
gi->gd_bank_size = 64*1024;
#else
gi->gd_fbsize = 64*1024; /* larger, but that's whats mappable */
#endif
gi->gd_colors = 1 << md->DEP;
gi->gd_planes = md->DEP;
gi->gd_fbwidth = md->MW;
gi->gd_fbheight = md->MH;
gi->gd_fbx = 0;
gi->gd_fby = 0;
gi->gd_dwidth = md->TX * md->FX;
gi->gd_dheight = md->TY * md->FY;
gi->gd_dx = 0;
gi->gd_dy = 0;
/* initialized, works, return 1 */
return(1);
}
int rt_mode __P((struct grf_softc *, int, void *, int , int));
void grfrtattach __P((struct device *, struct device *, void *));
int grfrtprint __P((void *, char *));
int grfrtmatch __P((struct device *, void *, void *));
struct cfattach grfrt_ca = {
sizeof(struct grf_softc), grfrtmatch, grfrtattach
};
struct cfdriver grfrt_cd = {
NULL, "grfrt", DV_DULL, NULL, 0
};
/*
* only used in console init
*/
static struct cfdata *cfdata;
/*
* we make sure to only init things once. this is somewhat
* tricky regarding the console.
*/
int
grfrtmatch(pdp, match, auxp)
struct device *pdp;
void *match, *auxp;
{
struct cfdata *cfp = match;
#ifdef RETINACONSOLE
static int rtconunit = -1;
#endif
struct zbus_args *zap;
zap = auxp;
/*
* allow only one retina console
*/
if (amiga_realconfig == 0)
#ifdef RETINACONSOLE
if (rtconunit != -1)
#endif
return(0);
/*
* check that this is a retina board.
*/
if (zap->manid != 18260 || zap->prodid != 6)
return(0);
#ifdef RETINACONSOLE
if (amiga_realconfig == 0 || rtconunit != cfp->cf_unit) {
#endif
if ((unsigned)retina_default_mon >= retina_mon_max ||
monitor_defs[retina_default_mon].DEP == 8)
retina_default_mon = 0;
current_mon = monitor_defs + retina_default_mon;
if (retina_alive(current_mon) == 0)
return(0);
#ifdef RETINACONSOLE
if (amiga_realconfig == 0) {
rtconunit = cfp->cf_unit;
cfdata = cfp;
}
}
#endif
return(1);
}
/*
* attach to the grfbus (zbus)
*/
void
grfrtattach(pdp, dp, auxp)
struct device *pdp, *dp;
void *auxp;
{
static struct grf_softc congrf;
static int coninited;
struct zbus_args *zap;
struct grf_softc *gp;
zap = auxp;
if (dp == NULL)
gp = &congrf;
else
gp = (struct grf_softc *)dp;
if (dp != NULL && congrf.g_regkva != 0) {
/*
* we inited earlier just copy the info
* take care not to copy the device struct though.
*/
bcopy(&congrf.g_display, &gp->g_display,
(char *)&gp[1] - (char *)&gp->g_display);
} else {
gp->g_regkva = (volatile caddr_t)zap->va;
gp->g_fbkva = (volatile caddr_t)zap->va + 64 * 1024;
gp->g_unit = GRF_RETINAII_UNIT;
gp->g_flags = GF_ALIVE;
gp->g_mode = rt_mode;
gp->g_conpri = grfrt_cnprobe();
grfrt_iteinit(gp);
(void)rt_load_mon(gp, current_mon);
}
if (dp != NULL)
printf("\n");
/*
* attach grf
*/
amiga_config_found(cfdata, &gp->g_device, gp, grfrtprint);
}
int
grfrtprint(auxp, pnp)
void *auxp;
char *pnp;
{
if (pnp)
printf("grf%d at %s", ((struct grf_softc *)auxp)->g_unit,
pnp);
return(UNCONF);
}
static int
rt_getvmode (gp, vm)
struct grf_softc *gp;
struct grfvideo_mode *vm;
{
struct MonDef *md;
if (vm->mode_num && vm->mode_num > retina_mon_max)
return EINVAL;
if (! vm->mode_num)
vm->mode_num = (current_mon - monitor_defs) + 1;
md = monitor_defs + (vm->mode_num - 1);
strncpy (vm->mode_descr, monitor_descr + (vm->mode_num - 1),
sizeof (vm->mode_descr));
vm->pixel_clock = md->FQ;
vm->disp_width = md->MW;
vm->disp_height = md->MH;
vm->depth = md->DEP;
/*
* From observation of the monitor definition table above, I guess that
* the horizontal timings are in units of longwords. Hence, I get the
* pixels by multiplication with 32 and division by the depth.
* The text modes, apparently marked by depth == 4, are even more wierd.
* According to a comment above, they are computed from a depth==8 mode
* (thats for us: * 32 / 8) by applying another factor of 4 / font width.
* Reverse applying the latter formula most of the constants cancel
* themselves and we are left with a nice (* font width).
* That is, internal timings are in units of longwords for graphics
* modes, or in units of characters widths for text modes.
* We better don't WRITE modes until this has been real live checked.
* - Ignatios Souvatzis
*/
if (md->DEP == 4) {
vm->hblank_start = md->HBS * 32 / md->DEP;
vm->hblank_stop = md->HBE * 32 / md->DEP;
vm->hsync_start = md->HSS * 32 / md->DEP;
vm->hsync_stop = md->HSE * 32 / md->DEP;
vm->htotal = md->HT * 32 / md->DEP;
} else {
vm->hblank_start = md->HBS * md->FX;
vm->hblank_stop = md->HBE * md->FX;
vm->hsync_start = md->HSS * md->FX;
vm->hsync_stop = md->HSE * md->FX;
vm->htotal = md->HT * md->FX;
}
vm->vblank_start = md->VBS;
vm->vblank_stop = md->VBE;
vm->vsync_start = md->VSS;
vm->vsync_stop = md->VSE;
vm->vtotal = md->VT;
return 0;
}
static int
rt_setvmode (gp, mode, txtonly)
struct grf_softc *gp;
unsigned mode;
int txtonly;
{
struct MonDef *md;
int error;
if (!mode || mode > retina_mon_max)
return EINVAL;
if (txtonly && monitor_defs[mode-1].DEP == 8)
return EINVAL;
current_mon = monitor_defs + (mode - 1);
error = rt_load_mon (gp, current_mon) ? 0 : EINVAL;
return error;
}
/*
* Change the mode of the display.
* Return a UNIX error number or 0 for success.
*/
int
rt_mode(gp, cmd, arg, a2, a3)
struct grf_softc *gp;
int cmd;
void *arg;
int a2, a3;
{
/* implement these later... */
switch (cmd)
{
case GM_GRFON:
rt_setvmode (gp, retina_default_gfx + 1, 0);
return 0;
case GM_GRFOFF:
rt_setvmode (gp, retina_default_mon + 1, 0);
return 0;
case GM_GRFCONFIG:
return 0;
case GM_GRFGETVMODE:
return rt_getvmode (gp, (struct grfvideo_mode *) arg);
case GM_GRFSETVMODE:
return rt_setvmode (gp, *(unsigned *) arg, 1);
case GM_GRFGETNUMVM:
*(int *)arg = retina_mon_max;
return 0;
#ifdef BANKEDDEVPAGER
case GM_GRFGETBANK:
*(int *)arg = rt_getbank (gp, a2, a3);
return 0;
case GM_GRFGETCURBANK:
*(int *)arg = rt_getcurbank (gp);
return 0;
case GM_GRFSETBANK:
return rt_setbank (gp, arg);
#endif
case GM_GRFIOCTL:
return rt_ioctl (gp, (u_long)arg, (void *)a2);
default:
break;
}
return EINVAL;
}
int
rt_ioctl (gp, cmd, data)
register struct grf_softc *gp;
u_long cmd;
void *data;
{
switch (cmd)
{
case GRFIOCGSPRITEPOS:
return rt_getspritepos (gp, (struct grf_position *) data);
case GRFIOCSSPRITEPOS:
return rt_setspritepos (gp, (struct grf_position *) data);
case GRFIOCSSPRITEINF:
return rt_setspriteinfo (gp, (struct grf_spriteinfo *) data);
case GRFIOCGSPRITEINF:
return rt_getspriteinfo (gp, (struct grf_spriteinfo *) data);
case GRFIOCGSPRITEMAX:
return rt_getspritemax (gp, (struct grf_position *) data);
case GRFIOCGETCMAP:
return rt_getcmap (gp, (struct grf_colormap *) data);
case GRFIOCPUTCMAP:
return rt_putcmap (gp, (struct grf_colormap *) data);
case GRFIOCBITBLT:
return rt_bitblt (gp, (struct grf_bitblt *) data);
}
return EINVAL;
}
#ifdef BANKEDDEVPAGER
/* Retina banks can overlap. Don't use this information (yet?), and
only switch 64k sized banks. */
int
rt_getbank (gp, offs, prot)
struct grf_softc *gp;
off_t offs;
int prot;
{
/* XXX */
if (offs < 0 || offs >= 4*1024*1024)
return -1;
else
return offs >> 16;
}
int
rt_getcurbank (gp)
struct grf_softc *gp;
{
struct grfinfo *gi = &gp->g_display;
volatile unsigned char *ba;
int bank;
ba = gp->g_regkva;
bank = RSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO) | (RSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI) << 8);
/* bank register is multiple of 64 byte, make this multiple of 64k */
bank >>= 10;
return bank;
}
int
rt_setbank (gp, bank)
struct grf_softc *gp;
int bank;
{
volatile unsigned char *ba;
ba = gp->g_regkva;
/* bank register is multiple of 64 byte, make this multiple of 64k */
bank <<= 10;
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, (unsigned char) bank);
bank >>= 8;
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, (unsigned char) bank);
return 0;
}
#endif
int
rt_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_REG_SELECT, cmap->index);
x = cmap->count - 1;
rp = red + cmap->index;
gp = green + cmap->index;
bp = blue + cmap->index;
do
{
*rp++ = vgar (ba, VDAC_REG_DATA);
*gp++ = vgar (ba, VDAC_REG_DATA);
*bp++ = vgar (ba, VDAC_REG_DATA);
}
while (x--);
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
rt_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_REG_SELECT, cmap->index);
x = cmap->count - 1;
rp = red + cmap->index;
gp = green + cmap->index;
bp = blue + cmap->index;
do
{
vgaw (ba, VDAC_REG_DATA, *rp++);
vgaw (ba, VDAC_REG_DATA, *gp++);
vgaw (ba, VDAC_REG_DATA, *bp++);
}
while (x--);
return 0;
}
else
return error;
}
int
rt_getspritepos (gp, pos)
struct grf_softc *gp;
struct grf_position *pos;
{
volatile unsigned char *ba;
ba = gp->g_regkva;
pos->x = vgar (ba, SEQ_ID_CURSOR_X_LOC_LO) | (vgar (ba, SEQ_ID_CURSOR_X_LOC_HI) << 8);
pos->y = vgar (ba, SEQ_ID_CURSOR_Y_LOC_LO) | (vgar (ba, SEQ_ID_CURSOR_Y_LOC_HI) << 8);
return 0;
}
int
rt_setspritepos (gp, pos)
struct grf_softc *gp;
struct grf_position *pos;
{
volatile unsigned char *ba;
ba = gp->g_regkva;
vgaw (ba, SEQ_ID_CURSOR_X_LOC_LO, pos->x & 0xff);
vgaw (ba, SEQ_ID_CURSOR_X_LOC_HI, (pos->x >> 8) & 0x07);
vgaw (ba, SEQ_ID_CURSOR_Y_LOC_LO, pos->y & 0xff);
vgaw (ba, SEQ_ID_CURSOR_Y_LOC_HI, (pos->y >> 8) & 0x07);
return 0;
}
/* assume an at least 2M retina (XXX), sprite is last in memory.
According to the bogus docs, the cursor can be at most 128 lines
in height, and the x-hostspot can be placed at most at pos 31,
this gives width of a long */
#define SPRITE_ADDR (2*1024*1024 - 128*4)
int
rt_getspriteinfo (gp, info)
struct grf_softc *gp;
struct grf_spriteinfo *info;
{
volatile unsigned char *ba, *fb;
ba = gp->g_regkva;
fb = gp->g_fbkva;
if (info->set & GRFSPRSET_ENABLE)
info->enable = vgar (ba, SEQ_ID_CURSOR_CONTROL) & 0x01;
if (info->set & GRFSPRSET_POS)
rt_getspritepos (gp, &info->pos);
if (info->set & GRFSPRSET_HOT)
{
info->hot.x = vgar (ba, SEQ_ID_CURSOR_X_INDEX) & 0x1f;
info->hot.y = vgar (ba, SEQ_ID_CURSOR_Y_INDEX) & 0x7f;
}
if (info->set & GRFSPRSET_CMAP)
{
struct grf_colormap cmap;
int index;
cmap.index = 0;
cmap.count = 256;
rt_getcmap (gp, &cmap);
index = vgar (ba, SEQ_ID_CURSOR_COLOR0);
info->cmap.red[0] = cmap.red[index];
info->cmap.green[0] = cmap.green[index];
info->cmap.blue[0] = cmap.blue[index];
index = vgar (ba, SEQ_ID_CURSOR_COLOR1);
info->cmap.red[1] = cmap.red[index];
info->cmap.green[1] = cmap.green[index];
info->cmap.blue[1] = cmap.blue[index];
}
if (info->set & GRFSPRSET_SHAPE)
{
int saved_bank_lo = RSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO);
int saved_bank_hi = RSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI);
int last_bank = SPRITE_ADDR >> 6;
int last_bank_lo = last_bank & 0xff;
int last_bank_hi = last_bank >> 8;
u_char mask;
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, last_bank_lo);
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, last_bank_hi);
copyout (fb, info->image, 128*4);
mask = RSeq (ba, SEQ_ID_CURSOR_PIXELMASK);
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, saved_bank_lo);
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, saved_bank_hi);
copyout (&mask, info->mask, 1);
info->size.x = 32; /* ??? */
info->size.y = (RSeq (ba, SEQ_ID_CURSOR_CONTROL) & 6) << 4;
}
}
int
rt_setspriteinfo (gp, info)
struct grf_softc *gp;
struct grf_spriteinfo *info;
{
volatile unsigned char *ba, *fb;
u_char control;
ba = gp->g_regkva;
fb = gp->g_fbkva;
control = vgar (ba, SEQ_ID_CURSOR_CONTROL);
if (info->set & GRFSPRSET_ENABLE)
{
if (info->enable)
control |= 1;
else
control &= ~1;
vgaw (ba, SEQ_ID_CURSOR_CONTROL, control);
}
if (info->set & GRFSPRSET_POS)
rt_setspritepos (gp, &info->pos);
if (info->set & GRFSPRSET_HOT)
{
vgaw (ba, SEQ_ID_CURSOR_X_INDEX, info->hot.x & 0x1f);
vgaw (ba, SEQ_ID_CURSOR_Y_INDEX, info->hot.y & 0x7f);
}
if (info->set & GRFSPRSET_CMAP)
{
/* hey cheat a bit here.. XXX */
vgaw (ba, SEQ_ID_CURSOR_COLOR0, 0);
vgaw (ba, SEQ_ID_CURSOR_COLOR1, 1);
}
if (info->set & GRFSPRSET_SHAPE)
{
int saved_bank_lo = RSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO);
int saved_bank_hi = RSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI);
int last_bank = SPRITE_ADDR >> 6;
int last_bank_lo = last_bank & 0xff;
int last_bank_hi = last_bank >> 8;
u_char mask;
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, last_bank_lo);
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, last_bank_hi);
copyin (info->image, fb, 128*4);
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, saved_bank_lo);
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, saved_bank_hi);
copyin (info->mask, &mask, 1);
WSeq (ba, SEQ_ID_CURSOR_PIXELMASK, mask);
/* info->size.x = 32; *//* ??? */
info->size.y = (RSeq (ba, SEQ_ID_CURSOR_CONTROL) & 6) << 4;
control = (control & ~6) | ((info->size.y >> 4) & 6);
vgaw (ba, SEQ_ID_CURSOR_CONTROL, control);
/* sick intel bull-addressing.. */
WSeq (ba, SEQ_ID_CURSOR_STORE_LO, SPRITE_ADDR & 0x0f);
WSeq (ba, SEQ_ID_CURSOR_STORE_HI, 0);
WSeq (ba, SEQ_ID_CURSOR_ST_OFF_LO, (SPRITE_ADDR >> 4) & 0xff);
WSeq (ba, SEQ_ID_CURSOR_ST_OFF_HI, ((SPRITE_ADDR >> 4) >> 8) & 0xff);
}
return 0;
}
int
rt_getspritemax (gp, pos)
struct grf_softc *gp;
struct grf_position *pos;
{
pos->x = 32;
pos->y = 128;
return 0;
}
/*
* !!! THIS AREA UNDER CONSTRUCTION !!!
*/
int
rt_bitblt (gp, bb)
struct grf_softc *gp;
struct grf_bitblt *bb;
{
return EINVAL;
#if 0
volatile unsigned char *ba, *fb;
u_char control;
u_char saved_bank_lo;
u_char saved_bank_hi;
u_char src_bank_lo, src_bank_hi;
u_char dst_bank_lo, dst_bank_hi;
u_long src_offset, dst_offset;
u_short src_bank, dst_bank;
u_char *srcp, *dstp;
short x, y;
u_long tot;
ba = gp->g_regkva;
fb = gp->g_fbkva;
saved_bank_lo = RSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO);
saved_bank_hi = RSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI);
/* for now, only GRFBBcopy is supported, and only for depth 8. No
clipping is performed, either... */
if (bb->op != GRFBBcopy && gp->g_display.gd_planes != 8)
return EINVAL;
src_offset = op->src_x + op->src_y * gp->g_display.gd_fbwidth;
dst_offset = op->dst_x + op->dst_y * gp->g_display.gd_fbwidth;
tot = op->w * op->h;
/* set write mode 1, "[...] data in the read latches is written
to memory during CPU memory write cycles. [...]" */
WGfx (ba, GCT_ID_GRAPHICS_MODE, (RGfx(ba, GCT_ID_GRAPHICS_MODE) & 0xfc) | 1);
/* write to primary, read from secondary */
WSeq (ba, SEQ_ID_EXTENDED_MEM_ENA, (RSeq(ba, SEQ_ID_EXTENDED_MEM_ENA) & 0x1f) | 0 );
if (src_offset < dst_offset)
{
/* start at end */
src_offset += tot;
dst_offset += tot;
}
src_bank_lo = (src_offset >> 6) & 0xff;
src_bank_hi = (src_offset >> 14) & 0xff;
dst_bank_lo = (dst_offset >> 6) & 0xff;
dst_bank_hi = (dst_offset >> 14) & 0xff;
while (tot)
{
WSeq (ba, SEQ_ID_SEC_HOST_OFF_LO, src_bank_lo);
WSeq (ba, SEQ_ID_SEC_HOST_OFF_HI, src_bank_hi);
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_LO, dst_bank_lo);
WSeq (ba, SEQ_ID_PRIM_HOST_OFF_HI, dst_bank_hi);
if (src_offset < dst_offset)
{
}
else
{
}
}
#endif
}
#endif /* NGRF */
Reference in New Issue View Git Blame Copy Permalink