root/dev/ic/bt463.c

DEFINITIONS

1. bt463_funcs
2. bt463_register
3. bt463_cninit
4. bt463_init
5. bt463_set_cmap
6. bt463_get_cmap
7. bt463_check_curcmap
8. bt463_set_curcmap
9. bt463_get_curcmap
10. bt463_store
11. bt463_readback
12. bt463_debug
13. bt463_copyback
14. bt463_wraddr
15. bt463_update
16. bt463_set_cursor
17. bt463_get_cursor
18. bt463_set_curpos
19. bt463_get_curpos
20. bt463_get_curmax

    1 /* $OpenBSD: bt463.c,v 1.10 2002/11/09 22:51:48 miod Exp $ */
    2 /* $NetBSD: bt463.c,v 1.2 2000/06/13 17:21:06 nathanw Exp $ */
    4 /*-
    5  * Copyright (c) 1998 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
   10  * NASA Ames Research Center.
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above copyright
   18  *    notice, this list of conditions and the following disclaimer in the
   19  *    documentation and/or other materials provided with the distribution.
   20  * 3. All advertising materials mentioning features or use of this software
   21  *    must display the following acknowledgement:
   22  *      This product includes software developed by the NetBSD
   23  *      Foundation, Inc. and its contributors.
   24  * 4. Neither the name of The NetBSD Foundation nor the names of its
   25  *    contributors may be used to endorse or promote products derived
   26  *    from this software without specific prior written permission.
   27  *
   28  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   29  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   30  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   31  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   32  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   38  * POSSIBILITY OF SUCH DAMAGE.
   39  */
   41 /*
   42  * Copyright (c) 1995, 1996 Carnegie-Mellon University.
   43  * All rights reserved.
   44  *
   45  * Author: Chris G. Demetriou
   46  *
   47  * Permission to use, copy, modify and distribute this software and
   48  * its documentation is hereby granted, provided that both the copyright
   49  * notice and this permission notice appear in all copies of the
   50  * software, derivative works or modified versions, and any portions
   51  * thereof, and that both notices appear in supporting documentation.
   52  *
   53  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   54  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
   55  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   56  *
   57  * Carnegie Mellon requests users of this software to return to
   58  *
   59  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   60  *  School of Computer Science
   61  *  Carnegie Mellon University
   62  *  Pittsburgh PA 15213-3890
   63  *
   64  * any improvements or extensions that they make and grant Carnegie the
   65  * rights to redistribute these changes.
   66  */
   68  /* This code was derived from and originally located in sys/dev/pci/
   69   *      NetBSD: tga_bt463.c,v 1.5 2000/03/04 10:27:59 elric Exp 
   70   */
   72 #include <sys/param.h>
   73 #include <sys/systm.h>
   74 #include <sys/device.h>
   75 #include <sys/buf.h>
   76 #include <sys/kernel.h>
   77 #include <sys/malloc.h>
   79 #include <uvm/uvm_extern.h>
   81 #include <dev/pci/pcivar.h>
   82 #include <dev/pci/tgareg.h>
   83 #include <dev/pci/tgavar.h>
   84 #include <dev/ic/bt463reg.h>
   85 #include <dev/ic/bt463var.h>
   87 #include <dev/wscons/wsconsio.h>
   89 /*
   90  * Functions exported via the RAMDAC configuration table.
   91  */
   92 void    bt463_init(struct ramdac_cookie *);
   93 int     bt463_set_cmap(struct ramdac_cookie *,
   94             struct wsdisplay_cmap *);
   95 int     bt463_get_cmap(struct ramdac_cookie *,
   96             struct wsdisplay_cmap *);
   97 int     bt463_set_cursor(struct ramdac_cookie *,
   98             struct wsdisplay_cursor *);
   99 int     bt463_get_cursor(struct ramdac_cookie *,
  100             struct wsdisplay_cursor *);
  101 int     bt463_set_curpos(struct ramdac_cookie *,
  102             struct wsdisplay_curpos *);
  103 int     bt463_get_curpos(struct ramdac_cookie *,
  104             struct wsdisplay_curpos *);
  105 int     bt463_get_curmax(struct ramdac_cookie *,
  106             struct wsdisplay_curpos *);
  107 int     bt463_check_curcmap(struct ramdac_cookie *,
  108             struct wsdisplay_cursor *cursorp);
  109 void    bt463_set_curcmap(struct ramdac_cookie *,
  110             struct wsdisplay_cursor *cursorp);
  111 int     bt463_get_curcmap(struct ramdac_cookie *,
  112             struct wsdisplay_cursor *cursorp);
  114 #ifdef BT463_DEBUG
  115 int bt463_store(void *);
  116 int bt463_debug(void *);
  117 int bt463_readback(void *);
  118 void    bt463_copyback(void *);
  119 #endif
  121 struct ramdac_funcs bt463_funcsstruct = {
  122         "Bt463",
bt463_register,
bt463_init,
bt463_set_cmap,
bt463_get_cmap,
bt463_set_cursor,
bt463_get_cursor,
bt463_set_curpos,
bt463_get_curpos,
bt463_get_curmax,
bt463_check_curcmap,
bt463_set_curcmap,
bt463_get_curcmap,
NULL,
  136 };
  138 /*
  139  * Private data.
  140  */
  141 struct bt463data {
  142         void            *cookie;        /* This is what is passed
  143                                          * around, and is probably
  144                                          * struct tga_devconfig *
  145                                          */
  147         int             (*ramdac_sched_update)(void *, void (*)(void *));
  148         void            (*ramdac_wr)(void *, u_int, u_int8_t);
u_int8_t        (*ramdac_rd)(void *, u_int);
  151         int     changed;                        /* what changed; see below */
  152         char curcmap_r[2];                      /* cursor colormap */
  153         char curcmap_g[2];
  154         char curcmap_b[2];
  155         char cmap_r[BT463_NCMAP_ENTRIES];       /* colormap */
  156         char cmap_g[BT463_NCMAP_ENTRIES];
  157         char cmap_b[BT463_NCMAP_ENTRIES];
  158         int window_type[16]; /* 16 24-bit window type table entries */
  159 };
  161 /* When we're doing console initialization, there's no
  162  * way to get our cookie back to the video card's softc
  163  * before we call sched_update. So we stash it here, 
  164  * and bt463_update will look for it here first.
  165  */
  166 static struct bt463data *console_data;
  169 #define BTWREG(data, addr, val) do { bt463_wraddr((data), (addr)); \
  170         (data)->ramdac_wr((data)->cookie, BT463_REG_IREG_DATA, (val)); } while (0)
  171 #define BTWNREG(data, val) (data)->ramdac_wr((data)->cookie, \
BT463_REG_IREG_DATA, (val))
  173 #define BTRREG(data, addr) (bt463_wraddr((data), (addr)), \
  174         (data)->ramdac_rd((data)->cookie, BT463_REG_IREG_DATA))
  175 #define BTRNREG(data) ((data)->ramdac_rd((data)->cookie, BT463_REG_IREG_DATA))
  177 #define DATA_CURCMAP_CHANGED    0x01    /* cursor colormap changed */
  178 #define DATA_CMAP_CHANGED       0x02    /* colormap changed */
  179 #define DATA_WTYPE_CHANGED      0x04    /* window type table changed */
  180 #define DATA_ALL_CHANGED        0x07
  182 /*
  183  * Internal functions.
  184  */
  185 inline void bt463_wraddr(struct bt463data *, u_int16_t);
  187 void    bt463_update(void *);
  190 /*****************************************************************************/
  192 /*
  193  * Functions exported via the RAMDAC configuration table.
  194  */
  196 struct ramdac_funcs *
bt463_funcs(void)
  198 {
  199         return &bt463_funcsstruct;
  200 }
  202 struct ramdac_cookie *
bt463_register(v, sched_update, wr, rd)
  204         void *v;
  205         int (*sched_update)(void *, void (*)(void *));
  206         void (*wr)(void *, u_int, u_int8_t);
u_int8_t (*rd)(void *, u_int);
  208 {
  209         struct bt463data *data;
  210         /*
  211          * XXX -- comment out of date.  rcd.
  212          * If we should allocate a new private info struct, do so.
  213          * Otherwise, use the one we have (if it's there), or
  214          * use the temporary one on the stack.
  215          */
data = malloc(sizeof *data, M_DEVBUF, M_WAITOK);
  217         /* XXX -- if !data */
data->cookie = v;
data->ramdac_sched_update = sched_update;
data->ramdac_wr = wr;
data->ramdac_rd = rd;
  222         return (struct ramdac_cookie *)data;
  223 }
  225 /*
  226  * This function exists solely to provide a means to init
  227  * the RAMDAC without first registering.  It is useful for
  228  * initializing the console early on.
  229  */
  230 void
bt463_cninit(v, sched_update, wr, rd)
  232         void *v;
  233         int (*sched_update)(void *, void (*)(void *));
  234         void (*wr)(void *, u_int, u_int8_t);
u_int8_t (*rd)(void *, u_int);
  236 {
  237         struct bt463data tmp, *data = &tmp;
data->cookie = v;
data->ramdac_sched_update = sched_update;
data->ramdac_wr = wr;
data->ramdac_rd = rd;
  242         /* Set up console_data so that when bt463_update is called back,
  243          * it can use the right information.
  244          */
console_data = data;
bt463_init((struct ramdac_cookie *)data);
console_data = NULL;
  248 }
  250 void
bt463_init(rc)
  252         struct ramdac_cookie *rc;
  253 {
  254         struct bt463data *data = (struct bt463data *)rc;
  256         int i;
  258         /*
  259          * Init the BT463 for normal operation.
  260          */
  263         /*
  264          * Setup:
  265          * reg 0: 4:1 multiplexing, 25/75 blink.
  266          * reg 1: Overlay mapping: mapped to common palette, 
  267          *        14 window type entries, 24-plane configuration mode,
  268          *        4 overlay planes, underlays disabled, no cursor. 
  269          * reg 2: sync-on-green enabled, pedestal enabled.
  270          */
BTWREG(data, BT463_IREG_COMMAND_0, 0x40);
BTWREG(data, BT463_IREG_COMMAND_1, 0x48);
BTWREG(data, BT463_IREG_COMMAND_2, 0xC0);
  276         /*
  277          * Initialize the read mask.
  278          */
bt463_wraddr(data, BT463_IREG_READ_MASK_P0_P7);
  280         for (i = 0; i < 4; i++)
BTWNREG(data, 0xff);
  283         /*
  284          * Initialize the blink mask.
  285          */
bt463_wraddr(data, BT463_IREG_BLINK_MASK_P0_P7);
  287         for (i = 0; i < 4; i++)
BTWNREG(data, 0);
  291         /*
  292          * Clear test register
  293          */
BTWREG(data, BT463_IREG_TEST, 0);
  296         /*
  297          * Initalize the RAMDAC info struct to hold all of our
  298          * data, and fill it in.
  299          */
data->changed = DATA_ALL_CHANGED;
  302         /* 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;
  306         /* Initial colormap: 0 is black, everything else is white */
data->cmap_r[0] = data->cmap_g[0] = data->cmap_b[0] = 0;
  308         for (i = 1; 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];
  312         }
  314         /* Initialize the window type table:
  315          *
  316          * Entry 0: 24-plane truecolor, overlays enabled, bypassed.
  317          *
  318          *  Lookup table bypass:      yes (    1 << 23 & 0x800000)  800000
  319          *  Colormap address:       0x000 (0x000 << 17 & 0x7e0000)       0 
  320          *  Overlay mask:             0xf (  0xf << 13 & 0x01e000)   1e000
  321          *  Overlay location:    P<27:24> (    0 << 12 & 0x001000)       0
  322          *  Display mode:       Truecolor (    0 <<  9 & 0x000e00)     000
  323          *  Number of planes:           8 (    8 <<  5 & 0x0001e0)     100
  324          *  Plane shift:                0 (    0 <<  0 & 0x00001f)       0
  325          *                                                        --------
  326          *                                                        0x81e100
  327          */       
data->window_type[0] = 0x81e100;
  330         /* Entry 1: 8-plane pseudocolor in the bottom 8 bits, 
  331          *          overlays enabled, colormap starting at 0. 
  332          *
  333          *  Lookup table bypass:       no (    0 << 23 & 0x800000)       0
  334          *  Colormap address:       0x000 (0x000 << 17 & 0x7e0000)       0 
  335          *  Overlay mask:             0xf (  0xf << 13 & 0x01e000) 0x1e000
  336          *  Overlay location:    P<27:24> (    0 << 12 & 0x001000)       0
  337          *  Display mode:     Pseudocolor (    1 <<  9 & 0x000e00)   0x200
  338          *  Number of planes:           8 (    8 <<  5 & 0x0001e0)   0x100
  339          *  Plane shift:               16 ( 0x10 <<  0 & 0x00001f)      10
  340          *                                                        --------
  341          *                                                        0x01e310
  342          */       
data->window_type[1] = 0x01e310;
  345         /* The colormap interface to the world only supports one colormap, 
  346          * so having an entry for the 'alternate' colormap in the bt463 
  347          * probably isn't useful.
  348          */
  350         /* Fill the remaining table entries with clones of entry 0 until we 
  351          * figure out a better use for them.
  352          */
  354         for (i = 2; i < BT463_NWTYPE_ENTRIES; i++) {
data->window_type[i] = 0x81e100;
  356         }
data->ramdac_sched_update(data->cookie, bt463_update);
  360 }
  362 int
bt463_set_cmap(rc, cmapp)
  364         struct ramdac_cookie *rc;
  365         struct wsdisplay_cmap *cmapp;
  366 {
  367         struct bt463data *data = (struct bt463data *)rc;
u_int count, index;
  369         int s, error;
index = cmapp->index;
count = cmapp->count;
  374         if (index >= BT463_NCMAP_ENTRIES || count > BT463_NCMAP_ENTRIES - index)
  375                 return (EINVAL);
s = spltty();
  379         if ((error = copyin(cmapp->red, &data->cmap_r[index], count)) != 0) {
splx(s);
  381                 return (error);
  382         }
  383         if ((error = copyin(cmapp->green, &data->cmap_g[index], count)) != 0) {
splx(s);
  385                 return (error);
  386         }
  387         if ((error = copyin(cmapp->blue, &data->cmap_b[index], count)) != 0) {
splx(s);
  389                 return (error);
  390         }
data->changed |= DATA_CMAP_CHANGED;
data->ramdac_sched_update(data->cookie, bt463_update);
splx(s);
  397         return (0);
  398 }
  400 int
bt463_get_cmap(rc, cmapp)
  402         struct ramdac_cookie *rc;
  403         struct wsdisplay_cmap *cmapp;
  404 {
  405         struct bt463data *data = (struct bt463data *)rc;
u_int count, index;
  407         int error;
count = cmapp->count;
index = cmapp->index;
  412         if (index >= BT463_NCMAP_ENTRIES || count > BT463_NCMAP_ENTRIES - index)
  413                 return (EINVAL);
error = copyout(&data->cmap_r[index], cmapp->red, count);
  416         if (error)
  417                 return (error);
error = copyout(&data->cmap_g[index], cmapp->green, count);
  419         if (error)
  420                 return (error);
error = copyout(&data->cmap_b[index], cmapp->blue, count);
  422         return (error);
  423 }
  425 int
bt463_check_curcmap(rc, cursorp)
  427         struct ramdac_cookie *rc;
  428         struct wsdisplay_cursor *cursorp;
  429 {
u_int index, count;
u_int8_t spare[2];
  432         int error;
index = cursorp->cmap.index;
count = cursorp->cmap.count;
  437         if (index >= 2 || count > 2 - index)
  438                 return (EINVAL);
  440         if ((error = copyin(&cursorp->cmap.red, &spare, count)) != 0)
  441                 return (error);
  442         if ((error = copyin(&cursorp->cmap.green, &spare, count)) != 0)
  443                 return (error);
  444         if ((error = copyin(&cursorp->cmap.blue, &spare, count)) != 0)
  445                 return (error);
  447         return (0);
  448 }
  450 void
bt463_set_curcmap(rc, cursorp)
  452         struct ramdac_cookie *rc;
  453         struct wsdisplay_cursor *cursorp;
  454 {
  455         struct bt463data *data = (struct bt463data *)rc;
  456         int count, index;
  458         /* can't fail; parameters have already been checked. */
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;
data->ramdac_sched_update(data->cookie, bt463_update);
  466 }
  468 int
bt463_get_curcmap(rc, cursorp)
  470         struct ramdac_cookie *rc;
  471         struct wsdisplay_cursor *cursorp;
  472 {
  473         struct bt463data *data = (struct bt463data *)rc;
  474         int error;
cursorp->cmap.index = 0;        /* DOCMAP */
cursorp->cmap.count = 2;
  478         if (cursorp->cmap.red != NULL) {
error = copyout(data->curcmap_r, cursorp->cmap.red, 2);
  480                 if (error)
  481                         return (error);
  482         }
  483         if (cursorp->cmap.green != NULL) {
error = copyout(data->curcmap_g, cursorp->cmap.green, 2);
  485                 if (error)
  486                         return (error);
  487         }
  488         if (cursorp->cmap.blue != NULL) {
error = copyout(data->curcmap_b, cursorp->cmap.blue, 2);
  490                 if (error)
  491                         return (error);
  492         }
  493         return (0);
  494 }
  497 /*****************************************************************************/
  499 /*
  500  * Internal functions.
  501  */
  503 #ifdef BT463_DEBUG
  504 int bt463_store(void *v)
  505 {
  506         struct bt463data *data = (struct bt463data *)v; 
data->changed = DATA_ALL_CHANGED;
data->ramdac_sched_update(data->cookie, bt463_update);
printf("Scheduled bt463 store\n");
  512         return 0;
  513 }
  516 int bt463_readback(void *v)
  517 {
  518         struct bt463data *data = (struct bt463data *)v; 
data->ramdac_sched_update(data->cookie, bt463_copyback);
printf("Scheduled bt463 copyback\n");
  522         return 0;
  523 }
  525 int
bt463_debug(v)
  527         void *v;
  528 {
  529         struct bt463data *data = (struct bt463data *)v;
  530         int i;
u_int8_t val;
printf("BT463 main regs:\n");
  534         for (i = 0x200; i < 0x20F; i ++) {
val = BTRREG(data, i);
printf("  $%04x %02x\n", i, val);
  537         }
printf("BT463 revision register:\n");
val = BTRREG(data, 0x220);
printf("  $%04x %02x\n", 0x220, val);
printf("BT463 window type table (from softc):\n");
  545         for (i = 0; i < BT463_NWTYPE_ENTRIES; i++) {
printf("%02x %06x\n", i, data->window_type[i]);
  547         }
  549         return 0;
  550 }
  552 void 
bt463_copyback(p)
  554          void *p;
  555 {
  556         struct bt463data *data = (struct bt463data *)p;
  557         int i;
  559                 for (i = 0; i < BT463_NWTYPE_ENTRIES; i++) {
bt463_wraddr(data, BT463_IREG_WINDOW_TYPE_TABLE + i);
data->window_type[i] = (BTRNREG(data) & 0xff);        /* B0-7   */
data->window_type[i] |= (BTRNREG(data) & 0xff) << 8;  /* B8-15  */
data->window_type[i] |= (BTRNREG(data) & 0xff) << 16; /* B16-23 */
  564                 }
  565 }
  566 #endif
  568 inline void
bt463_wraddr(data, ireg)
  570         struct bt463data *data;
u_int16_t ireg;
  572 {
data->ramdac_wr(data->cookie, BT463_REG_ADDR_LOW, ireg & 0xff);
data->ramdac_wr(data->cookie, BT463_REG_ADDR_HIGH, (ireg >> 8) & 0xff);
  575 }
  577 void
bt463_update(p)
  579         void *p;
  580 {
  581         struct bt463data *data = (struct bt463data *)p;
  582         int i, v;
  584         if (console_data != NULL) {
  585                 /* The cookie passed in from sched_update is incorrect. Use the
  586                  * right one.
  587                  */
data = console_data;
  589         }
v = data->changed;
  593         /* The Bt463 won't accept window type data except during a blanking
  594          * interval, so we do this early in the interrupt.
  595          * Blanking the screen might also be a good idea, but it can cause 
  596          * unpleasant flashing and is hard to do from this side of the
  597          * ramdac interface.
  598          */
  599         if (v & DATA_WTYPE_CHANGED) {
  600                 /* spit out the window type data */
  601                 for (i = 0; i < BT463_NWTYPE_ENTRIES; i++) {
bt463_wraddr(data, BT463_IREG_WINDOW_TYPE_TABLE + i);
BTWNREG(data, (data->window_type[i]) & 0xff);       /* B0-7   */
BTWNREG(data, (data->window_type[i] >> 8) & 0xff);  /* B8-15   */
BTWNREG(data, (data->window_type[i] >> 16) & 0xff); /* B16-23  */
  606                 }
  607         }
  609         if (v & DATA_CURCMAP_CHANGED) {
bt463_wraddr(data, BT463_IREG_CURSOR_COLOR_0);
  611                 /* spit out the cursor data */
  612                 for (i = 0; i < 2; i++) {
BTWNREG(data, data->curcmap_r[i]);
BTWNREG(data, data->curcmap_g[i]);
BTWNREG(data, data->curcmap_b[i]);
  616                 }
  617         }
  619         if (v & DATA_CMAP_CHANGED) {
bt463_wraddr(data, BT463_IREG_CPALETTE_RAM);
  621                 /* spit out the colormap data */
  622                 for (i = 0; i < BT463_NCMAP_ENTRIES; i++) {
data->ramdac_wr(data->cookie, BT463_REG_CMAP_DATA, 
data->cmap_r[i]);
data->ramdac_wr(data->cookie, BT463_REG_CMAP_DATA, 
data->cmap_g[i]);
data->ramdac_wr(data->cookie, BT463_REG_CMAP_DATA, 
data->cmap_b[i]);
  629                 }
  630         }
data->changed = 0;
  633 }
  635 int     bt463_set_cursor (rc, cur)
  636         struct ramdac_cookie *rc;
  637         struct wsdisplay_cursor *cur;
  638 {
  639         struct bt463data *data = (struct bt463data *)rc;
  640         return tga_builtin_set_cursor(data->cookie, cur);
  641 }
  643 int     bt463_get_cursor (rc, cur)
  644         struct ramdac_cookie *rc;
  645         struct wsdisplay_cursor *cur;
  646 {
  647         struct bt463data *data = (struct bt463data *)rc;
  648         return tga_builtin_get_cursor(data->cookie, cur);
  649 }
  651 int     bt463_set_curpos (rc, cur)
  652         struct ramdac_cookie *rc;
  653         struct wsdisplay_curpos *cur;
  654 {
  655         struct bt463data *data = (struct bt463data *)rc;
  656         return tga_builtin_set_curpos(data->cookie, cur);
  657 }
  659 int     bt463_get_curpos (rc, cur)
  660         struct ramdac_cookie *rc;
  661         struct wsdisplay_curpos *cur;
  662 {
  663         struct bt463data *data = (struct bt463data *)rc;
  664         return tga_builtin_get_curpos(data->cookie, cur);
  665 }
  667 int     bt463_get_curmax (rc, cur)
  668         struct ramdac_cookie *rc;
  669         struct wsdisplay_curpos *cur;
  670 {
  671         struct bt463data *data = (struct bt463data *)rc;
  672         return tga_builtin_get_curmax(data->cookie, cur);
  673 }