root/dev/ic/bt485.c

DEFINITIONS

1. bt485_funcs
2. bt485_register
3. bt485_cninit
4. bt485_init
5. bt485_set_cmap
6. bt485_get_cmap
7. bt485_set_cursor
8. bt485_get_cursor
9. bt485_set_curpos
10. bt485_get_curpos
11. bt485_get_curmax
12. bt485_wr_i
13. bt485_rd_i
14. bt485_update
15. bt485_update_curpos

    1 /* $OpenBSD: bt485.c,v 1.12 2002/11/09 22:51:48 miod Exp $ */
    2 /* $NetBSD: bt485.c,v 1.2 2000/04/02 18:55:01 nathanw Exp $ */
    4 /*
    5  * Copyright (c) 1995, 1996 Carnegie-Mellon University.
    6  * All rights reserved.
    7  *
    8  * Author: Chris G. Demetriou
    9  *
   10  * Permission to use, copy, modify and distribute this software and
   11  * its documentation is hereby granted, provided that both the copyright
   12  * notice and this permission notice appear in all copies of the
   13  * software, derivative works or modified versions, and any portions
   14  * thereof, and that both notices appear in supporting documentation.
   15  *
   16  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   17  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
   18  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   19  *
   20  * Carnegie Mellon requests users of this software to return to
   21  *
   22  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   23  *  School of Computer Science
   24  *  Carnegie Mellon University
   25  *  Pittsburgh PA 15213-3890
   26  *
   27  * any improvements or extensions that they make and grant Carnegie the
   28  * rights to redistribute these changes.
   29  */
   31  /* This code was derived from and originally located in sys/dev/pci/
   32   *      NetBSD: tga_bt485.c,v 1.4 1999/03/24 05:51:21 mrg Exp 
   33   */
   35 #include <sys/param.h>
   36 #include <sys/systm.h>
   37 #include <sys/device.h>
   38 #include <sys/buf.h>
   39 #include <sys/kernel.h>
   40 #include <sys/malloc.h>
   42 #include <uvm/uvm_extern.h>
   44 #include <dev/pci/pcivar.h>
   45 #include <dev/ic/bt485reg.h>
   46 #include <dev/ic/bt485var.h>
   47 #include <dev/ic/ramdac.h>
   49 #include <dev/wscons/wsconsio.h>
   50 #include <dev/wscons/wsdisplayvar.h>
   51 #include <dev/rasops/rasops.h>
   53 /*
   54  * Functions exported via the RAMDAC configuration table.
   55  */
   56 void    bt485_init(struct ramdac_cookie *);
   57 int     bt485_set_cmap(struct ramdac_cookie *,
   58             struct wsdisplay_cmap *);
   59 int     bt485_get_cmap(struct ramdac_cookie *,
   60             struct wsdisplay_cmap *);
   61 int     bt485_set_cursor(struct ramdac_cookie *,
   62             struct wsdisplay_cursor *);
   63 int     bt485_get_cursor(struct ramdac_cookie *,
   64             struct wsdisplay_cursor *);
   65 int     bt485_set_curpos(struct ramdac_cookie *,
   66             struct wsdisplay_curpos *);
   67 int     bt485_get_curpos(struct ramdac_cookie *,
   68             struct wsdisplay_curpos *);
   69 int     bt485_get_curmax(struct ramdac_cookie *,
   70             struct wsdisplay_curpos *);
   72 /* XXX const */
   73 struct ramdac_funcs bt485_funcsstruct = {
   74         "Bt485",
bt485_register,
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 */
NULL,                   /* no dot clock to set */
   88 };
   90 /*
   91  * Private data.
   92  */
   93 struct bt485data {
   94         void            *cookie;        /* This is what is passed
   95                                          * around, and is probably
   96                                          * struct tga_devconfig *
   97                                          */
   99         int             (*ramdac_sched_update)(void *, void (*)(void *));
  100         void            (*ramdac_wr)(void *, u_int, u_int8_t);
u_int8_t        (*ramdac_rd)(void *, u_int);
  103         int     changed;                        /* what changed; see below */
  104         int     curenb;                         /* cursor enabled */
  105         struct wsdisplay_curpos curpos;         /* current cursor position */
  106         struct wsdisplay_curpos curhot;         /* cursor hotspot */
  107         char curcmap_r[2];                      /* cursor colormap */
  108         char curcmap_g[2];
  109         char curcmap_b[2];
  110         struct wsdisplay_curpos cursize;        /* current cursor size */
  111         char curimage[512];                     /* cursor image data */
  112         char curmask[512];                      /* cursor mask data */
  113         char cmap_r[256];                               /* colormap */
  114         char cmap_g[256];
  115         char cmap_b[256];
  116 };
  118 #define DATA_ENB_CHANGED        0x01    /* cursor enable changed */
  119 #define DATA_CURCMAP_CHANGED    0x02    /* cursor colormap changed */
  120 #define DATA_CURSHAPE_CHANGED   0x04    /* cursor size, image, mask changed */
  121 #define DATA_CMAP_CHANGED       0x08    /* colormap changed */
  122 #define DATA_ALL_CHANGED        0x0f
  124 #define CURSOR_MAX_SIZE         64
  126 /*
  127  * Internal functions.
  128  */
  129 inline void     bt485_wr_i(struct bt485data *, u_int8_t, u_int8_t);
  130 inline u_int8_t bt485_rd_i(struct bt485data *, u_int8_t);
  131 void    bt485_update(void *);
  132 void    bt485_update_curpos(struct bt485data *);
  134 /*****************************************************************************/
  136 /*
  137  * Functions exported via the RAMDAC configuration table.
  138  */
  140 struct ramdac_funcs *
bt485_funcs(void)
  142 {
  143         return &bt485_funcsstruct;
  144 }
  146 struct ramdac_cookie *
bt485_register(v, sched_update, wr, rd)
  148         void *v;
  149         int (*sched_update)(void *, void (*)(void *));
  150         void (*wr)(void *, u_int, u_int8_t);
u_int8_t (*rd)(void *, u_int);
  152 {
  153         struct bt485data *data;
  154         /*
  155          * XXX -- comment out of date.  rcd.
  156          * If we should allocate a new private info struct, do so.
  157          * Otherwise, use the one we have (if it's there), or
  158          * use the temporary one on the stack.
  159          */
data = malloc(sizeof *data, M_DEVBUF, M_WAITOK);
  161         /* XXX -- if !data */
data->cookie = v;
data->ramdac_sched_update = sched_update;
data->ramdac_wr = wr;
data->ramdac_rd = rd;
  166         return (struct ramdac_cookie *)data;
  167 }
  169 /*
  170  * This function exists solely to provide a means to init
  171  * the RAMDAC without first registering.  It is useful for
  172  * initializing the console early on.
  173  */
  174 void
bt485_cninit(v, sched_update, wr, rd)
  176         void *v;
  177         int (*sched_update)(void *, void (*)(void *));
  178         void (*wr)(void *, u_int, u_int8_t);
u_int8_t (*rd)(void *, u_int);
  180 {
  181         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);
  187 }
  189 void
bt485_init(rc)
  191         struct ramdac_cookie *rc;
  192 {
u_int8_t regval;
  194         struct bt485data *data = (struct bt485data *)rc;
  195         int i;
  197         /*
  198          * Init the BT485 for normal operation.
  199          */
  201         /*
  202          * Allow indirect register access.  (Actually, this is
  203          * already enabled.  In fact, if it is _disabled_, for
  204          * some reason the monitor appears to lose sync!!! (?!?!)
  205          */
regval = data->ramdac_rd(data->cookie, BT485_REG_COMMAND_0);
regval |= 0x80;
  208         /*
  209          * Set the RAMDAC to 8 bit resolution, rather than 6 bit
  210          * resolution.
  211          */
regval |= 0x02;
data->ramdac_wr(data->cookie, BT485_REG_COMMAND_0, regval);
  215         /* Set the RAMDAC to 8BPP (no interestion options). */
data->ramdac_wr(data->cookie, BT485_REG_COMMAND_1, 0x40);
  218         /* 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);
  224         /* 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);
  230         /* Set the Pixel Mask to something useful */
data->ramdac_wr(data->cookie, BT485_REG_PIXMASK, 0xff);
  233         /*
  234          * Initalize the RAMDAC info struct to hold all of our
  235          * data, and fill it in.
  236          */
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 */
  243         /* 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;
  247         /* initial cursor data: 64x64 block of white. */
data->cursize.x = data->cursize.y = 64;
  249         for (i = 0; i < 512; i++)
data->curimage[i] = data->curmask[i] = 0xff;
  252         /* Initial colormap: 0 is black, everything else is white */
data->cmap_r[0] = data->cmap_g[0] = data->cmap_b[0] = 0;
  254         for (i = 0; i < 256; i++) {
data->cmap_r[i] = rasops_cmap[3*i + 0];
data->cmap_g[i] = rasops_cmap[3*i + 1];
data->cmap_b[i] = rasops_cmap[3*i + 2];
  258         }
bt485_update((void *)data);
  261 }
  263 int
bt485_set_cmap(rc, cmapp)
  265         struct ramdac_cookie *rc;
  266         struct wsdisplay_cmap *cmapp;
  267 {
  268         struct bt485data *data = (struct bt485data *)rc;
u_int count, index;
  270         int s, error;
  272 #ifdef DIAGNOSTIC
  273         if (rc == NULL)
panic("bt485_set_cmap: rc");
  275         if (cmapp == NULL)
panic("bt485_set_cmap: cmapp");
  277 #endif
index = cmapp->index;
count = cmapp->count;
  281         if (index >= 256 || count > 256 - index)
  282                 return (EINVAL);
s = spltty();
  286         if ((error = copyin(cmapp->red, &data->cmap_r[index], count)) != 0) {
splx(s);
  288                 return (error);
  289         }
  290         if ((error = copyin(cmapp->green, &data->cmap_g[index], count)) != 0) {
splx(s);
  292                 return (error);
  293         }
  294         if ((error = copyin(cmapp->blue, &data->cmap_b[index], count)) != 0) {
splx(s);
  296                 return (error);
  297         }
data->changed |= DATA_CMAP_CHANGED;
data->ramdac_sched_update(data->cookie, bt485_update);
  302 #ifdef __alpha__
alpha_mb();
  304 #endif
splx(s);
  307         return (0);
  308 }
  310 int
bt485_get_cmap(rc, cmapp)
  312         struct ramdac_cookie *rc;
  313         struct wsdisplay_cmap *cmapp;
  314 {
  315         struct bt485data *data = (struct bt485data *)rc;
u_int count, index;
  317         int error;
  319         if (cmapp->index >= 256 || cmapp->count > 256 - cmapp->index)
  320                 return (EINVAL);
count = cmapp->count;
index = cmapp->index;
error = copyout(&data->cmap_r[index], cmapp->red, count);
  326         if (error)
  327                 return (error);
error = copyout(&data->cmap_g[index], cmapp->green, count);
  329         if (error)
  330                 return (error);
error = copyout(&data->cmap_b[index], cmapp->blue, count);
  332         return (error);
  333 }
  335 int
bt485_set_cursor(rc, cursorp)
  337         struct ramdac_cookie *rc;
  338         struct wsdisplay_cursor *cursorp;
  339 {
  340         struct bt485data *data = (struct bt485data *)rc;
u_int count, index;
  342         int error;
  343         int v, s;
v = cursorp->which;
  347         /*
  348          * For DOCMAP and DOSHAPE, verify that parameters are OK
  349          * before we do anything that we can't recover from.
  350          */
  351         if (v & WSDISPLAY_CURSOR_DOCMAP) {
index = cursorp->cmap.index;
count = cursorp->cmap.count;
  354                 if (index >= 2 || count > 2 - index)
  355                         return (EINVAL);
  356         }
  357         if (v & WSDISPLAY_CURSOR_DOSHAPE) {
  358                 if ((u_int)cursorp->size.x > CURSOR_MAX_SIZE ||
  359                     (u_int)cursorp->size.y > CURSOR_MAX_SIZE)
  360                         return (EINVAL);
  361         }
  363         if (v & (WSDISPLAY_CURSOR_DOPOS | WSDISPLAY_CURSOR_DOCUR)) {
  364                 if (v & WSDISPLAY_CURSOR_DOPOS)
data->curpos = cursorp->pos;
  366                 if (v & WSDISPLAY_CURSOR_DOCUR)
data->curhot = cursorp->hot;
bt485_update_curpos(data);
  369         }
s = spltty();
  373         /* Parameters are OK; perform the requested operations. */
  374         if (v & WSDISPLAY_CURSOR_DOCUR) {
data->curenb = cursorp->enable;
data->changed |= DATA_ENB_CHANGED;
  377         }
  378         if (v & WSDISPLAY_CURSOR_DOCMAP) {
index = cursorp->cmap.index;
count = cursorp->cmap.count;
  381                 if ((error = copyin(cursorp->cmap.red,
  382                     &data->curcmap_r[index], count)) != 0) {
splx(s);
  384                         return (error);
  385                 }
  386                 if ((error = copyin(cursorp->cmap.green,
  387                     &data->curcmap_g[index], count)) != 0) {
splx(s);
  389                         return (error);
  390                 }
  391                 if ((error = copyin(cursorp->cmap.blue,
  392                     &data->curcmap_b[index], count)) != 0) {
splx(s);
  394                         return (error);
  395                 }
data->changed |= DATA_CURCMAP_CHANGED;
  397         }
  398         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);
  403                 if ((error = copyin(cursorp->image, data->curimage,
count)) != 0) {
splx(s);
  406                         return (error);
  407                 }
  408                 if ((error = copyin(cursorp->mask, data->curmask,
count)) != 0) {
splx(s);
  411                         return (error);
  412                 }
data->changed |= DATA_CURSHAPE_CHANGED;
  414         }
  416         if (data->changed)
data->ramdac_sched_update(data->cookie, bt485_update);
splx(s);
  420         return (0);
  421 }
  423 int
bt485_get_cursor(rc, cursorp)
  425         struct ramdac_cookie *rc;
  426         struct wsdisplay_cursor *cursorp;
  427 {
  428         struct bt485data *data = (struct bt485data *)rc;
  429         int error, count;
  431         /* 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;
  440         if (cursorp->cmap.red != NULL) {
error = copyout(data->curcmap_r, cursorp->cmap.red, 2);
  442                 if (error)
  443                         return (error);
  444         }
  445         if (cursorp->cmap.green != NULL) {
error = copyout(data->curcmap_g, cursorp->cmap.green, 2);
  447                 if (error)
  448                         return (error);
  449         }
  450         if (cursorp->cmap.blue != NULL) {
error = copyout(data->curcmap_b, cursorp->cmap.blue, 2);
  452                 if (error)
  453                         return (error);
  454         }
cursorp->size = data->cursize;  /* DOSHAPE */
  457         if (cursorp->image != NULL) {
count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
error = copyout(data->curimage, cursorp->image, count);
  460                 if (error)
  461                         return (error);
error = copyout(data->curmask, cursorp->mask, count);
  463                 if (error)
  464                         return (error);
  465         }
  467         return (0);
  468 }
  470 int
bt485_set_curpos(rc, curposp)
  472         struct ramdac_cookie *rc;
  473         struct wsdisplay_curpos *curposp;
  474 {
  475         struct bt485data *data = (struct bt485data *)rc;
data->curpos = *curposp;
bt485_update_curpos(data);
  480         return (0);
  481 }
  483 int
bt485_get_curpos(rc, curposp)
  485         struct ramdac_cookie *rc;
  486         struct wsdisplay_curpos *curposp;
  487 {
  488         struct bt485data *data = (struct bt485data *)rc;
  490         *curposp = data->curpos;
  491         return (0);
  492 }
  494 int
bt485_get_curmax(rc, curposp)
  496         struct ramdac_cookie *rc;
  497         struct wsdisplay_curpos *curposp;
  498 {
curposp->x = curposp->y = CURSOR_MAX_SIZE;
  501         return (0);
  502 }
  504 /*****************************************************************************/
  506 /*
  507  * Internal functions.
  508  */
  510 inline void
bt485_wr_i(data, ireg, val)
  512         struct bt485data *data;
u_int8_t ireg;
u_int8_t val;
  515 {
data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, ireg);
data->ramdac_wr(data->cookie, BT485_REG_EXTENDED, val);
  518 }
  520 inline u_int8_t
bt485_rd_i(data, ireg)
  522         struct bt485data *data;
u_int8_t ireg;
  524 {
data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, ireg);
  526         return (data->ramdac_rd(data->cookie, BT485_REG_EXTENDED));
  527 }
  529 void
bt485_update(vp)
  531         void *vp;
  532 {
  533         struct bt485data *data = vp;
u_int8_t regval;
  535         int count, i, v;
v = data->changed;
data->changed = 0;
  540         if (v & DATA_ENB_CHANGED) {
regval = data->ramdac_rd(data->cookie, BT485_REG_COMMAND_2);
  542                 if (data->curenb)
regval |= 0x01;
  544                 else
regval &= ~0x03;
data->ramdac_wr(data->cookie, BT485_REG_COMMAND_2, regval);
  547         }
  549         if (v & DATA_CURCMAP_CHANGED) {
  550                 /* addr[9:0] assumed to be 0 */
  551                 /* set addr[7:0] to 1 */
data->ramdac_wr(data->cookie, BT485_REG_COC_WRADDR, 0x01);
  554                 /* spit out the cursor data */
  555                 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]);
  562                 }
  563         }
  565         if (v & DATA_CURSHAPE_CHANGED) {
count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
  568                 /*
  569                  * Write the cursor image data:
  570                  *      set addr[9:8] to 0,
  571                  *      set addr[7:0] to 0,
  572                  *      spit it all out.
  573                  */
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);
  578                 for (i = 0; i < count; i++)
data->ramdac_wr(data->cookie, BT485_REG_CURSOR_RAM,
data->curimage[i]);
  582                 /*
  583                  * Write the cursor mask data:
  584                  *      set addr[9:8] to 2,
  585                  *      set addr[7:0] to 0,
  586                  *      spit it all out.
  587                  */
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);
  592                 for (i = 0; i < count; i++)
data->ramdac_wr(data->cookie, BT485_REG_CURSOR_RAM,
data->curmask[i]);
  596                 /* 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);
  600         }
  602         if (v & DATA_CMAP_CHANGED) {
  603                 /* addr[9:0] assumed to be 0 */
  604                 /* set addr[7:0] to 0 */
data->ramdac_wr(data->cookie, BT485_REG_PCRAM_WRADDR, 0x00);
  607                 /* spit out the cursor data */
  608                 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]);
  615                 }
  616         }
  617 }
  619 void
bt485_update_curpos(data)
  621         struct bt485data *data;
  622 {
  623         void *cookie = data->cookie;
  624         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);
  636 }