Graphics card independant Bt485 code, derived from dev/pci/tga_bt485.c.
This commit is contained in:
elric
parent
c4019af322
commit
b16807c51a
|
|
@ -0,0 +1,599 @@
|
|||
/* $NetBSD: bt485.c,v 1.1 2000/03/04 10:25:57 elric Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1995, 1996 Carnegie-Mellon University.
|
||||
* All rights reserved.
|
||||
*
|
||||
* Author: Chris G. Demetriou
|
||||
*
|
||||
* Permission to use, copy, modify and distribute this software and
|
||||
* its documentation is hereby granted, provided that both the copyright
|
||||
* notice and this permission notice appear in all copies of the
|
||||
* software, derivative works or modified versions, and any portions
|
||||
* thereof, and that both notices appear in supporting documentation.
|
||||
*
|
||||
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
|
||||
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
|
||||
* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
|
||||
*
|
||||
* Carnegie Mellon requests users of this software to return to
|
||||
*
|
||||
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
|
||||
* School of Computer Science
|
||||
* Carnegie Mellon University
|
||||
* Pittsburgh PA 15213-3890
|
||||
*
|
||||
* any improvements or extensions that they make and grant Carnegie the
|
||||
* rights to redistribute these changes.
|
||||
*/
|
||||
|
||||
/* This code was derived from and originally located in sys/dev/pci/
|
||||
* NetBSD: tga_bt485.c,v 1.4 1999/03/24 05:51:21 mrg Exp
|
||||
*/
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/device.h>
|
||||
#include <sys/buf.h>
|
||||
#include <sys/kernel.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <vm/vm.h>
|
||||
|
||||
#include <dev/pci/pcivar.h>
|
||||
#include <dev/ic/bt485reg.h>
|
||||
#include <dev/ic/bt485var.h>
|
||||
#include <dev/ic/ramdac.h>
|
||||
|
||||
#include <dev/wscons/wsconsio.h>
|
||||
|
||||
/*
|
||||
* Functions exported via the RAMDAC configuration table.
|
||||
*/
|
||||
void bt485_init __P((struct ramdac_cookie *));
|
||||
int bt485_set_cmap __P((struct ramdac_cookie *,
|
||||
struct wsdisplay_cmap *));
|
||||
int bt485_get_cmap __P((struct ramdac_cookie *,
|
||||
struct wsdisplay_cmap *));
|
||||
int bt485_set_cursor __P((struct ramdac_cookie *,
|
||||
struct wsdisplay_cursor *));
|
||||
int bt485_get_cursor __P((struct ramdac_cookie *,
|
||||
struct wsdisplay_cursor *));
|
||||
int bt485_set_curpos __P((struct ramdac_cookie *,
|
||||
struct wsdisplay_curpos *));
|
||||
int bt485_get_curpos __P((struct ramdac_cookie *,
|
||||
struct wsdisplay_curpos *));
|
||||
int bt485_get_curmax __P((struct ramdac_cookie *,
|
||||
struct wsdisplay_curpos *));
|
||||
|
||||
/* XXX const */
|
||||
struct ramdac_funcs bt485_funcsstruct = {
|
||||
"Bt485",
|
||||
bt485_init,
|
||||
bt485_set_cmap,
|
||||
bt485_get_cmap,
|
||||
bt485_set_cursor,
|
||||
bt485_get_cursor,
|
||||
bt485_set_curpos,
|
||||
bt485_get_curpos,
|
||||
bt485_get_curmax,
|
||||
NULL, /* check_curcmap; not needed */
|
||||
NULL, /* set_curcmap; not needed */
|
||||
NULL, /* get_curcmap; not needed */
|
||||
};
|
||||
|
||||
/*
|
||||
* Private data.
|
||||
*/
|
||||
struct bt485data {
|
||||
void *cookie; /* This is what is passed
|
||||
* around, and is probably
|
||||
* struct tga_devconfig *
|
||||
*/
|
||||
|
||||
int (*ramdac_sched_update) __P((void *, void (*)(void *)));
|
||||
void (*ramdac_wr) __P((void *, u_int, u_int8_t));
|
||||
u_int8_t (*ramdac_rd) __P((void *, u_int));
|
||||
|
||||
int changed; /* what changed; see below */
|
||||
int curenb; /* cursor enabled */
|
||||
struct wsdisplay_curpos curpos; /* current cursor position */
|
||||
struct wsdisplay_curpos curhot; /* cursor hotspot */
|
||||
char curcmap_r[2]; /* cursor colormap */
|
||||
char curcmap_g[2];
|
||||
char curcmap_b[2];
|
||||
struct wsdisplay_curpos cursize; /* current cursor size */
|
||||
char curimage[512]; /* cursor image data */
|
||||
char curmask[512]; /* cursor mask data */
|
||||
char cmap_r[256]; /* colormap */
|
||||
char cmap_g[256];
|
||||
char cmap_b[256];
|
||||
};
|
||||
|
||||
#define DATA_ENB_CHANGED 0x01 /* cursor enable changed */
|
||||
#define DATA_CURCMAP_CHANGED 0x02 /* cursor colormap changed */
|
||||
#define DATA_CURSHAPE_CHANGED 0x04 /* cursor size, image, mask changed */
|
||||
#define DATA_CMAP_CHANGED 0x08 /* colormap changed */
|
||||
#define DATA_ALL_CHANGED 0x0f
|
||||
|
||||
#define CURSOR_MAX_SIZE 64
|
||||
|
||||
/*
|
||||
* Internal functions.
|
||||
*/
|
||||
inline void bt485_wr_i __P((struct bt485data *, u_int8_t, u_int8_t));
|
||||
inline u_int8_t bt485_rd_i __P((struct bt485data *, u_int8_t));
|
||||
void bt485_update __P((void *));
|
||||
void bt485_update_curpos __P((struct bt485data *));
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
/*
|
||||
* Functions exported via the RAMDAC configuration table.
|
||||
*/
|
||||
|
||||
struct ramdac_funcs *
|
||||
bt485_funcs(void)
|
||||
{
|
||||
return &bt485_funcsstruct;
|
||||
}
|
||||
|
||||
struct ramdac_cookie *
|
||||
bt485_register(v, sched_update, wr, rd)
|
||||
void *v;
|
||||
int (*sched_update)(void *, void (*)(void *));
|
||||
void (*wr)(void *, u_int, u_int8_t);
|
||||
u_int8_t (*rd)(void *, u_int);
|
||||
{
|
||||
struct bt485data *data;
|
||||
/*
|
||||
* XXX -- comment out of date. rcd.
|
||||
* If we should allocate a new private info struct, do so.
|
||||
* Otherwise, use the one we have (if it's there), or
|
||||
* use the temporary one on the stack.
|
||||
*/
|
||||
data = malloc(sizeof *data, M_DEVBUF, M_WAITOK);
|
||||
/* XXX -- if !data */
|
||||
data->cookie = v;
|
||||
data->ramdac_sched_update = sched_update;
|
||||
data->ramdac_wr = wr;
|
||||
data->ramdac_rd = rd;
|
||||
return (struct ramdac_cookie *)data;
|
||||
}
|
||||
|
||||
/*
|
||||
* This function exists solely to provide a means to init
|
||||
* the RAMDAC without first registering. It is useful for
|
||||
* initializing the console early on.
|
||||
*/
|
||||
void
|
||||
bt485_cninit(v, sched_update, wr, rd)
|
||||
void *v;
|
||||
int (*sched_update)(void *, void (*)(void *));
|
||||
void (*wr)(void *, u_int, u_int8_t);
|
||||
u_int8_t (*rd)(void *, u_int);
|
||||
{
|
||||
struct bt485data tmp, *data = &tmp;
|
||||
data->cookie = v;
|
||||
data->ramdac_sched_update = sched_update;
|
||||
data->ramdac_wr = wr;
|
||||
data->ramdac_rd = rd;
|
||||
bt485_init((struct ramdac_cookie *)data);
|
||||
}
|
||||
|
||||
void
|
||||
bt485_init(rc)
|
||||
struct ramdac_cookie *rc;
|
||||
{
|
||||
u_int8_t regval;
|
||||
struct bt485data *data = (struct bt485data *)rc;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* Init the BT485 for normal operation.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Allow indirect register access. (Actually, this is
|
||||
* already enabled. In fact, if it is _disabled_, for
|
||||
* some reason the monitor appears to lose sync!!! (?!?!)
|
||||
*/
|
||||
regval = data->ramdac_rd(data->cookie, BT485_REG_COMMAND_0);
|
||||
regval |= 0x80;
|
||||
/*
|
||||
* Set the RAMDAC to 8 bit resolution, rather than 6 bit
|
||||
* resolution.
|
||||
*/
|
||||
regval |= 0x02;
|
||||
data->ramdac_wr(data->cookie, BT485_REG_COMMAND_0, regval);
|
||||
|
||||
/* Set the RAMDAC to 8BPP (no interestion options). */
|
||||
data->ramdac_wr(data->cookie, BT485_REG_COMMAND_1, 0x40);
|
||||
|
||||
/* Disable the cursor (for now) */
|
||||
regval = data->ramdac_rd(data->cookie, BT485_REG_COMMAND_2);
|
||||
regval &= ~0x03;
|
||||
regval |= 0x24;
|
||||
data->ramdac_wr(data->cookie, BT485_REG_COMMAND_2, regval);
|
||||
|
||||
/* Use a 64x64x2 cursor */
|
||||
regval = bt485_rd_i(data, BT485_IREG_COMMAND_3);
|
||||
regval |= 0x04;
|
||||
regval |= 0x08;
|
||||
bt485_wr_i(data, BT485_IREG_COMMAND_3, regval);
|
||||
|
||||
/* Set the Pixel Mask to something useful */
|
||||
data->ramdac_wr(data->cookie, BT485_REG_PIXMASK, 0xff);
|
||||
|
||||
/*
|
||||
* Initalize the RAMDAC info struct to hold all of our
|
||||
* data, and fill it in.
|
||||
*/
|
||||
data->changed = DATA_ALL_CHANGED;
|
||||
|
||||
data->curenb = 0; /* cursor disabled */
|
||||
data->curpos.x = data->curpos.y = 0; /* right now at 0,0 */
|
||||
data->curhot.x = data->curhot.y = 0; /* hot spot at 0,0 */
|
||||
|
||||
/* initial cursor colormap: 0 is black, 1 is white */
|
||||
data->curcmap_r[0] = data->curcmap_g[0] = data->curcmap_b[0] = 0;
|
||||
data->curcmap_r[1] = data->curcmap_g[1] = data->curcmap_b[1] = 0xff;
|
||||
|
||||
/* initial cursor data: 64x64 block of white. */
|
||||
data->cursize.x = data->cursize.y = 64;
|
||||
for (i = 0; i < 512; i++)
|
||||
data->curimage[i] = data->curmask[i] = 0xff;
|
||||
|
||||
/* Initial colormap: 0 is black, everything else is white */
|
||||
data->cmap_r[0] = data->cmap_g[0] = data->cmap_b[0] = 0;
|
||||
for (i = 1; i < 256; i++)
|
||||
data->cmap_r[i] = data->cmap_g[i] = data->cmap_b[i] = 255;
|
||||
|
||||
bt485_update((void *)data);
|
||||
}
|
||||
|
||||
int
|
||||
bt485_set_cmap(rc, cmapp)
|
||||
struct ramdac_cookie *rc;
|
||||
struct wsdisplay_cmap *cmapp;
|
||||
{
|
||||
struct bt485data *data = (struct bt485data *)rc;
|
||||
int count, index, s;
|
||||
|
||||
if ((u_int)cmapp->index >= 256 ||
|
||||
((u_int)cmapp->index + (u_int)cmapp->count) > 256)
|
||||
return (EINVAL);
|
||||
if (!uvm_useracc(cmapp->red, cmapp->count, B_READ) ||
|
||||
!uvm_useracc(cmapp->green, cmapp->count, B_READ) ||
|
||||
!uvm_useracc(cmapp->blue, cmapp->count, B_READ))
|
||||
return (EFAULT);
|
||||
|
||||
s = spltty();
|
||||
|
||||
index = cmapp->index;
|
||||
count = cmapp->count;
|
||||
copyin(cmapp->red, &data->cmap_r[index], count);
|
||||
copyin(cmapp->green, &data->cmap_g[index], count);
|
||||
copyin(cmapp->blue, &data->cmap_b[index], count);
|
||||
|
||||
data->changed |= DATA_CMAP_CHANGED;
|
||||
|
||||
data->ramdac_sched_update(data->cookie, bt485_update);
|
||||
splx(s);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
bt485_get_cmap(rc, cmapp)
|
||||
struct ramdac_cookie *rc;
|
||||
struct wsdisplay_cmap *cmapp;
|
||||
{
|
||||
struct bt485data *data = (struct bt485data *)rc;
|
||||
int error, count, index;
|
||||
|
||||
if ((u_int)cmapp->index >= 256 ||
|
||||
((u_int)cmapp->index + (u_int)cmapp->count) > 256)
|
||||
return (EINVAL);
|
||||
|
||||
count = cmapp->count;
|
||||
index = cmapp->index;
|
||||
|
||||
error = copyout(&data->cmap_r[index], cmapp->red, count);
|
||||
if (error)
|
||||
return (error);
|
||||
error = copyout(&data->cmap_g[index], cmapp->green, count);
|
||||
if (error)
|
||||
return (error);
|
||||
error = copyout(&data->cmap_b[index], cmapp->blue, count);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
bt485_set_cursor(rc, cursorp)
|
||||
struct ramdac_cookie *rc;
|
||||
struct wsdisplay_cursor *cursorp;
|
||||
{
|
||||
struct bt485data *data = (struct bt485data *)rc;
|
||||
int count, index, v, s;
|
||||
|
||||
v = cursorp->which;
|
||||
|
||||
/*
|
||||
* For DOCMAP and DOSHAPE, verify that parameters are OK
|
||||
* before we do anything that we can't recover from.
|
||||
*/
|
||||
if (v & WSDISPLAY_CURSOR_DOCMAP) {
|
||||
if ((u_int)cursorp->cmap.index > 2 ||
|
||||
((u_int)cursorp->cmap.index +
|
||||
(u_int)cursorp->cmap.count) > 2)
|
||||
return (EINVAL);
|
||||
count = cursorp->cmap.count;
|
||||
if (!uvm_useracc(cursorp->cmap.red, count, B_READ) ||
|
||||
!uvm_useracc(cursorp->cmap.green, count, B_READ) ||
|
||||
!uvm_useracc(cursorp->cmap.blue, count, B_READ))
|
||||
return (EFAULT);
|
||||
}
|
||||
if (v & WSDISPLAY_CURSOR_DOSHAPE) {
|
||||
if ((u_int)cursorp->size.x > CURSOR_MAX_SIZE ||
|
||||
(u_int)cursorp->size.y > CURSOR_MAX_SIZE)
|
||||
return (EINVAL);
|
||||
count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
|
||||
if (!uvm_useracc(cursorp->image, count, B_READ) ||
|
||||
!uvm_useracc(cursorp->mask, count, B_READ))
|
||||
return (EFAULT);
|
||||
}
|
||||
|
||||
if (v & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOCUR)) {
|
||||
if (v & WSDISPLAY_CURSOR_DOPOS)
|
||||
data->curpos = cursorp->pos;
|
||||
if (v & WSDISPLAY_CURSOR_DOCUR)
|
||||
data->curhot = cursorp->hot;
|
||||
bt485_update_curpos(data);
|
||||
}
|
||||
|
||||
s = spltty();
|
||||
|
||||
/* Parameters are OK; perform the requested operations. */
|
||||
if (v & WSDISPLAY_CURSOR_DOCUR) {
|
||||
data->curenb = cursorp->enable;
|
||||
data->changed |= DATA_ENB_CHANGED;
|
||||
}
|
||||
if (v & WSDISPLAY_CURSOR_DOCMAP) {
|
||||
count = cursorp->cmap.count;
|
||||
index = cursorp->cmap.index;
|
||||
copyin(cursorp->cmap.red, &data->curcmap_r[index], count);
|
||||
copyin(cursorp->cmap.green, &data->curcmap_g[index], count);
|
||||
copyin(cursorp->cmap.blue, &data->curcmap_b[index], count);
|
||||
data->changed |= DATA_CURCMAP_CHANGED;
|
||||
}
|
||||
if (v & WSDISPLAY_CURSOR_DOSHAPE) {
|
||||
data->cursize = cursorp->size;
|
||||
count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
|
||||
bzero(data->curimage, sizeof data->curimage);
|
||||
bzero(data->curmask, sizeof data->curmask);
|
||||
copyin(cursorp->image, data->curimage, count); /* can't fail */
|
||||
copyin(cursorp->mask, data->curmask, count); /* can't fail */
|
||||
data->changed |= DATA_CURSHAPE_CHANGED;
|
||||
}
|
||||
|
||||
if (data->changed)
|
||||
data->ramdac_sched_update(data->cookie, bt485_update);
|
||||
splx(s);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
bt485_get_cursor(rc, cursorp)
|
||||
struct ramdac_cookie *rc;
|
||||
struct wsdisplay_cursor *cursorp;
|
||||
{
|
||||
struct bt485data *data = (struct bt485data *)rc;
|
||||
int error, count;
|
||||
|
||||
/* we return everything they want */
|
||||
cursorp->which = WSDISPLAY_CURSOR_DOALL;
|
||||
|
||||
cursorp->enable = data->curenb; /* DOCUR */
|
||||
cursorp->pos = data->curpos; /* DOPOS */
|
||||
cursorp->hot = data->curhot; /* DOHOT */
|
||||
|
||||
cursorp->cmap.index = 0; /* DOCMAP */
|
||||
cursorp->cmap.count = 2;
|
||||
if (cursorp->cmap.red != NULL) {
|
||||
error = copyout(data->curcmap_r, cursorp->cmap.red, 2);
|
||||
if (error)
|
||||
return (error);
|
||||
}
|
||||
if (cursorp->cmap.green != NULL) {
|
||||
error = copyout(data->curcmap_g, cursorp->cmap.green, 2);
|
||||
if (error)
|
||||
return (error);
|
||||
}
|
||||
if (cursorp->cmap.blue != NULL) {
|
||||
error = copyout(data->curcmap_b, cursorp->cmap.blue, 2);
|
||||
if (error)
|
||||
return (error);
|
||||
}
|
||||
|
||||
cursorp->size = data->cursize; /* DOSHAPE */
|
||||
if (cursorp->image != NULL) {
|
||||
count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
|
||||
error = copyout(data->curimage, cursorp->image, count);
|
||||
if (error)
|
||||
return (error);
|
||||
error = copyout(data->curmask, cursorp->mask, count);
|
||||
if (error)
|
||||
return (error);
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
bt485_set_curpos(rc, curposp)
|
||||
struct ramdac_cookie *rc;
|
||||
struct wsdisplay_curpos *curposp;
|
||||
{
|
||||
struct bt485data *data = (struct bt485data *)rc;
|
||||
|
||||
data->curpos = *curposp;
|
||||
bt485_update_curpos(data);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
bt485_get_curpos(rc, curposp)
|
||||
struct ramdac_cookie *rc;
|
||||
struct wsdisplay_curpos *curposp;
|
||||
{
|
||||
struct bt485data *data = (struct bt485data *)rc;
|
||||
|
||||
*curposp = data->curpos;
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
bt485_get_curmax(rc, curposp)
|
||||
struct ramdac_cookie *rc;
|
||||
struct wsdisplay_curpos *curposp;
|
||||
{
|
||||
|
||||
curposp->x = curposp->y = CURSOR_MAX_SIZE;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
/*
|
||||
* Internal functions.
|
||||
*/
|
||||
|
||||
inline void
|
||||
bt485_wr_i(data, ireg, val)
|
||||
struct bt485data *data;
|
||||
u_int8_t ireg;
|
||||
u_int8_t val;
|
||||
{
|
||||
data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, ireg);
|
||||
data->ramdac_wr(data->cookie, BT485_REG_EXTENDED, val);
|
||||
}
|
||||
|
||||
inline u_int8_t
|
||||
bt485_rd_i(data, ireg)
|
||||
struct bt485data *data;
|
||||
u_int8_t ireg;
|
||||
{
|
||||
data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, ireg);
|
||||
return (data->ramdac_rd(data->cookie, BT485_REG_EXTENDED));
|
||||
}
|
||||
|
||||
void
|
||||
bt485_update(vp)
|
||||
void *vp;
|
||||
{
|
||||
struct bt485data *data = vp;
|
||||
u_int8_t regval;
|
||||
int count, i, v;
|
||||
|
||||
v = data->changed;
|
||||
data->changed = 0;
|
||||
|
||||
if (v & DATA_ENB_CHANGED) {
|
||||
regval = data->ramdac_rd(data->cookie, BT485_REG_COMMAND_2);
|
||||
if (data->curenb)
|
||||
regval |= 0x01;
|
||||
else
|
||||
regval &= ~0x03;
|
||||
data->ramdac_wr(data->cookie, BT485_REG_COMMAND_2, regval);
|
||||
}
|
||||
|
||||
if (v & DATA_CURCMAP_CHANGED) {
|
||||
/* addr[9:0] assumed to be 0 */
|
||||
/* set addr[7:0] to 1 */
|
||||
data->ramdac_wr(data->cookie, BT485_REG_COC_WRADDR, 0x01);
|
||||
|
||||
/* spit out the cursor data */
|
||||
for (i = 0; i < 2; i++) {
|
||||
data->ramdac_wr(data->cookie, BT485_REG_COCDATA,
|
||||
data->curcmap_r[i]);
|
||||
data->ramdac_wr(data->cookie, BT485_REG_COCDATA,
|
||||
data->curcmap_g[i]);
|
||||
data->ramdac_wr(data->cookie, BT485_REG_COCDATA,
|
||||
data->curcmap_b[i]);
|
||||
}
|
||||
}
|
||||
|
||||
if (v & DATA_CURSHAPE_CHANGED) {
|
||||
count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
|
||||
|
||||
/*
|
||||
* Write the cursor image data:
|
||||
* set addr[9:8] to 0,
|
||||
* set addr[7:0] to 0,
|
||||
* spit it all out.
|
||||
*/
|
||||
regval = bt485_rd_i(data, BT485_IREG_COMMAND_3);
|
||||
regval &= ~0x03;
|
||||
bt485_wr_i(data, BT485_IREG_COMMAND_3, regval);
|
||||
data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, 0);
|
||||
for (i = 0; i < count; i++)
|
||||
data->ramdac_wr(data->cookie, BT485_REG_CURSOR_RAM,
|
||||
data->curimage[i]);
|
||||
|
||||
/*
|
||||
* Write the cursor mask data:
|
||||
* set addr[9:8] to 2,
|
||||
* set addr[7:0] to 0,
|
||||
* spit it all out.
|
||||
*/
|
||||
regval = bt485_rd_i(data, BT485_IREG_COMMAND_3);
|
||||
regval &= ~0x03; regval |= 0x02;
|
||||
bt485_wr_i(data, BT485_IREG_COMMAND_3, regval);
|
||||
data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, 0);
|
||||
for (i = 0; i < count; i++)
|
||||
data->ramdac_wr(data->cookie, BT485_REG_CURSOR_RAM,
|
||||
data->curmask[i]);
|
||||
|
||||
/* set addr[9:0] back to 0 */
|
||||
regval = bt485_rd_i(data, BT485_IREG_COMMAND_3);
|
||||
regval &= ~0x03;
|
||||
bt485_wr_i(data, BT485_IREG_COMMAND_3, regval);
|
||||
}
|
||||
|
||||
if (v & DATA_CMAP_CHANGED) {
|
||||
/* addr[9:0] assumed to be 0 */
|
||||
/* set addr[7:0] to 0 */
|
||||
data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, 0x00);
|
||||
|
||||
/* spit out the cursor data */
|
||||
for (i = 0; i < 256; i++) {
|
||||
data->ramdac_wr(data->cookie, BT485_REG_PALETTE,
|
||||
data->cmap_r[i]);
|
||||
data->ramdac_wr(data->cookie, BT485_REG_PALETTE,
|
||||
data->cmap_g[i]);
|
||||
data->ramdac_wr(data->cookie, BT485_REG_PALETTE,
|
||||
data->cmap_b[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
bt485_update_curpos(data)
|
||||
struct bt485data *data;
|
||||
{
|
||||
void *cookie = data->cookie;
|
||||
int s, x, y;
|
||||
|
||||
s = spltty();
|
||||
|
||||
x = data->curpos.x + CURSOR_MAX_SIZE - data->curhot.x;
|
||||
y = data->curpos.y + CURSOR_MAX_SIZE - data->curhot.y;
|
||||
data->ramdac_wr(cookie, BT485_REG_CURSOR_X_LOW, x & 0xff);
|
||||
data->ramdac_wr(cookie, BT485_REG_CURSOR_X_HIGH, (x >> 8) & 0x0f);
|
||||
data->ramdac_wr(cookie, BT485_REG_CURSOR_Y_LOW, y & 0xff);
|
||||
data->ramdac_wr(cookie, BT485_REG_CURSOR_Y_HIGH, (y >> 8) & 0x0f);
|
||||
|
||||
splx(s);
|
||||
}
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
/* $NetBSD: bt485var.h,v 1.1 2000/03/04 10:25:57 elric Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1998, 1999 The NetBSD Foundation, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to The NetBSD Foundation
|
||||
* by Roland C. Dowdeswell.
|
||||
*
|
||||
* 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 the NetBSD
|
||||
* Foundation, Inc. and its contributors.
|
||||
* 4. Neither the name of The NetBSD Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
||||
* ``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 FOUNDATION OR CONTRIBUTORS
|
||||
* 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.
|
||||
*/
|
||||
|
||||
|
||||
struct ramdac_funcs *bt485_funcs(void);
|
||||
struct ramdac_cookie *bt485_register __P((void *,
|
||||
int (*)(void *, void (*)(void *)),
|
||||
void (*)(void *, u_int, u_int8_t),
|
||||
u_int8_t (*)(void *, u_int)));
|
||||
void bt485_cninit __P((void *,
|
||||
int (*)(void *, void (*)(void *)),
|
||||
void (*)(void *, u_int, u_int8_t),
|
||||
u_int8_t (*)(void *, u_int)));
|
||||
Loading…
Reference in New Issue