root/dev/ic/ibm561.c

DEFINITIONS

1. ibm561_funcs
2. ibm561_register
3. ibm561_cninit
4. ibm561_init
5. ibm561_set_cmap
6. ibm561_get_cmap
7. ibm561_set_cursor
8. ibm561_get_cursor
9. ibm561_set_curpos
10. ibm561_get_curpos
11. ibm561_get_curmax
12. ibm561_set_dotclock
13. ibm561_update
14. ibm561_load_cmap
15. ibm561_load_dotclock
16. ibm561_regcont10bit
17. ibm561_regbegin
18. ibm561_regcont
19. ibm561_regwr

    1 /* $NetBSD: ibm561.c,v 1.1 2001/12/12 07:46:48 elric Exp $ */
    2 /* $OpenBSD: ibm561.c,v 1.4 2006/07/16 21:50:58 miod Exp $ */
    4 /*-
    5  * Copyright (c) 2001 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Roland C. Dowdeswell of Ponte, Inc.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *      This product includes software developed by the NetBSD
   22  *      Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/device.h>
   43 #include <sys/buf.h>
   44 #include <sys/kernel.h>
   45 #include <sys/malloc.h>
   47 #include <uvm/uvm_extern.h>
   49 #include <dev/pci/pcivar.h>
   50 #include <dev/ic/ibm561reg.h>
   51 #include <dev/ic/ibm561var.h>
   52 #include <dev/ic/ramdac.h>
   54 #include <dev/wscons/wsconsio.h>
   56 /*
   57  * Functions exported via the RAMDAC configuration table.
   58  */
   59 void    ibm561_init(struct ramdac_cookie *);
   60 int     ibm561_set_cmap(struct ramdac_cookie *,
   61             struct wsdisplay_cmap *);
   62 int     ibm561_get_cmap(struct ramdac_cookie *,
   63             struct wsdisplay_cmap *);
   64 int     ibm561_set_cursor(struct ramdac_cookie *,
   65             struct wsdisplay_cursor *);
   66 int     ibm561_get_cursor(struct ramdac_cookie *,
   67             struct wsdisplay_cursor *);
   68 int     ibm561_set_curpos(struct ramdac_cookie *,
   69             struct wsdisplay_curpos *);
   70 int     ibm561_get_curpos(struct ramdac_cookie *,
   71             struct wsdisplay_curpos *);
   72 int     ibm561_get_curmax(struct ramdac_cookie *,
   73             struct wsdisplay_curpos *);
   74 int     ibm561_set_dotclock(struct ramdac_cookie *,
   75             unsigned);
   77 /* XXX const */
   78 struct ramdac_funcs ibm561_funcsstruct = {
   79         "IBM561",
ibm561_register,
ibm561_init,
ibm561_set_cmap,
ibm561_get_cmap,
ibm561_set_cursor,
ibm561_get_cursor,
ibm561_set_curpos,
ibm561_get_curpos,
ibm561_get_curmax,
NULL,                   /* check_curcmap; not needed */
NULL,                   /* set_curcmap; not needed */
NULL,                   /* get_curcmap; not needed */
ibm561_set_dotclock, 
   93 };
   95 /*
   96  * Private data.
   97  */
   98 struct ibm561data {
   99         void            *cookie;
  101         int             (*ramdac_sched_update)(void *, void (*)(void *));
  102         void            (*ramdac_wr)(void *, u_int, u_int8_t);
u_int8_t        (*ramdac_rd)(void *, u_int);
  105 #define CHANGED_CURCMAP         0x0001  /* cursor cmap */
  106 #define CHANGED_CMAP            0x0002  /* color map */
  107 #define CHANGED_WTYPE           0x0004  /* window types */
  108 #define CHANGED_DOTCLOCK        0x0008  /* dot clock */
  109 #define CHANGED_ALL             0x000f  /* or of all above */
u_int8_t        changed;
  112         /* dotclock parameters */
u_int8_t        vco_div;
u_int8_t        pll_ref;
u_int8_t        div_dotclock;
  117         /* colormaps et al. */
u_int8_t        curcmap_r[2];
u_int8_t        curcmap_g[2];
u_int8_t        curcmap_b[2];
u_int8_t        cmap_r[IBM561_NCMAP_ENTRIES];
u_int8_t        cmap_g[IBM561_NCMAP_ENTRIES];
u_int8_t        cmap_b[IBM561_NCMAP_ENTRIES];
u_int16_t       gamma_r[IBM561_NGAMMA_ENTRIES];
u_int16_t       gamma_g[IBM561_NGAMMA_ENTRIES];
u_int16_t       gamma_b[IBM561_NGAMMA_ENTRIES];
u_int16_t       wtype[IBM561_NWTYPES];
  131 };
  133 /*
  134  * private functions
  135  */
  136 void    ibm561_update(void *);
  137 static void ibm561_load_cmap(struct ibm561data *);
  138 static void ibm561_load_dotclock(struct ibm561data *);
  139 static void ibm561_regbegin(struct ibm561data *, u_int16_t);
  140 static void ibm561_regcont(struct ibm561data *, u_int16_t, u_int8_t);
  141 static void ibm561_regcont10bit(struct ibm561data *, u_int16_t, u_int16_t);
  142 static void ibm561_regwr(struct ibm561data *, u_int16_t, u_int8_t);
  144 struct ramdac_funcs *
ibm561_funcs(void)
  146 {
  147         return &ibm561_funcsstruct;
  148 }
  150 struct ibm561data ibm561_console_data;
  152 struct ramdac_cookie *
ibm561_register(v, sched_update, wr, rd)
  154         void *v;
  155         int (*sched_update)(void *, void (*)(void *));
  156         void (*wr)(void *, u_int, u_int8_t);
u_int8_t (*rd)(void *, u_int);
  158 {
  159         struct ibm561data *data;
  161         if (ibm561_console_data.cookie == NULL) {
data = malloc(sizeof *data, M_DEVBUF, M_WAITOK);
bzero(data, sizeof *data);
  164         } else
data = &ibm561_console_data;
data->cookie = v;
data->ramdac_sched_update = sched_update;
data->ramdac_wr = wr;
data->ramdac_rd = rd;
  170         return (struct ramdac_cookie *)data;
  171 }
  173 /*
  174  * This function exists solely to provide a means to init
  175  * the RAMDAC without first registering.  It is useful for
  176  * initializing the console early on.
  177  */
  179 void
ibm561_cninit(v, sched_update, wr, rd, dotclock)
  181         void *v;
  182         int (*sched_update)(void *, void (*)(void *));
  183         void (*wr)(void *, u_int, u_int8_t);
u_int8_t (*rd)(void *, u_int);
u_int dotclock;
  186 {
  187         struct ibm561data *data = &ibm561_console_data;
data->cookie = v;
data->ramdac_sched_update = sched_update;
data->ramdac_wr = wr;
data->ramdac_rd = rd;
ibm561_set_dotclock((struct ramdac_cookie *)data, dotclock);
ibm561_init((struct ramdac_cookie *)data);
  194 }
  196 void
ibm561_init(rc)
  198         struct ramdac_cookie *rc;
  199 {
  200         struct  ibm561data *data = (struct ibm561data *)rc;
  201         int     i;
  203         /* XXX this is _essential_ */
ibm561_load_dotclock(data);
  207         /* XXXrcd: bunch of magic of which I have no current clue */
ibm561_regwr(data, IBM561_CONFIG_REG1, 0x2a);
ibm561_regwr(data, IBM561_CONFIG_REG3, 0x41);
ibm561_regwr(data, IBM561_CONFIG_REG4, 0x20);
  212         /* initialize the card a bit */
ibm561_regwr(data, IBM561_SYNC_CNTL, 0x1);
ibm561_regwr(data, IBM561_CONFIG_REG2, 0x19);
ibm561_regwr(data, IBM561_CONFIG_REG1, 0x2a);
ibm561_regwr(data, IBM561_CONFIG_REG4, 0x20);
ibm561_regbegin(data, IBM561_WAT_SEG_REG);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regbegin(data, IBM561_CHROMAKEY0);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regwr(data, IBM561_CURS_CNTL_REG, 0x00); /* XXX off? */
  232         /* cursor `hot spot' registers */
ibm561_regbegin(data, IBM561_HOTSPOT_REG);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regcont(data, IBM561_CMD, 0xff);
ibm561_regcont(data, IBM561_CMD, 0x00);
ibm561_regcont(data, IBM561_CMD, 0xff);
ibm561_regcont(data, IBM561_CMD, 0x00);
  241         /* VRAM Mask Registers (diagnostics) */
ibm561_regbegin(data, IBM561_VRAM_MASK_REG);
ibm561_regcont(data, IBM561_CMD, 0xff);
ibm561_regcont(data, IBM561_CMD, 0xff);
ibm561_regcont(data, IBM561_CMD, 0xff);
ibm561_regcont(data, IBM561_CMD, 0xff);
ibm561_regcont(data, IBM561_CMD, 0xff);
ibm561_regcont(data, IBM561_CMD, 0xff);
ibm561_regcont(data, IBM561_CMD, 0xff);
  251         /* let's set up some decent default colour maps and gammas */
  252         for (i=0; i < IBM561_NCMAP_ENTRIES; i++)
data->cmap_r[i] = data->cmap_g[i] = data->cmap_b[i] = 0xff;
data->cmap_r[0]   = data->cmap_g[0]   = data->cmap_b[0]   = 0x00;
data->cmap_r[256] = data->cmap_g[256] = data->cmap_b[256] = 0x00;
data->cmap_r[512] = data->cmap_g[512] = data->cmap_b[512] = 0x00;
data->cmap_r[768] = data->cmap_g[768] = data->cmap_b[768] = 0x00;
data->gamma_r[0] = data->gamma_g[0] = data->gamma_b[0] = 0x00;
  260         for (i=0; i < IBM561_NGAMMA_ENTRIES; i++)
data->gamma_r[i] = data->gamma_g[i] = data->gamma_b[i] = 0xff;
  263         for (i=0; i < IBM561_NWTYPES; i++)
data->wtype[i] = 0x0036;
data->wtype[1] = 0x0028;
  267         /* the last step: */
data->changed = CHANGED_ALL;
data->ramdac_sched_update(data->cookie, ibm561_update);
  270 }
  272 int
ibm561_set_cmap(rc, cmapp)
  274         struct ramdac_cookie *rc;
  275         struct wsdisplay_cmap *cmapp;
  276 {
  277         struct ibm561data *data = (struct ibm561data *)rc;
u_int count, index;
  279         int error;
  280         int s;
index = cmapp->index;
count = cmapp->count;
  285         if (index >= IBM561_NCMAP_ENTRIES ||
count > IBM561_NCMAP_ENTRIES - index)
  287                 return (EINVAL);
s = spltty();
  290         if ((error = copyin(cmapp->red, &data->cmap_r[index], count)) != 0) {
splx(s);
  292                 return (error);
  293         }
  294         if ((error = copyin(cmapp->green, &data->cmap_g[index], count)) != 0) {
splx(s);
  296                 return (error);
  297         }
  298         if ((error = copyin(cmapp->blue, &data->cmap_b[index], count)) != 0) {
splx(s);
  300                 return (error);
  301         }
data->changed |= CHANGED_CMAP;
data->ramdac_sched_update(data->cookie, ibm561_update);
splx(s);
  305         return (0);
  306 }
  308 int
ibm561_get_cmap(rc, cmapp)
  310         struct ramdac_cookie *rc;
  311         struct wsdisplay_cmap *cmapp;
  312 {
  313         struct ibm561data *data = (struct ibm561data *)rc;
u_int count, index;
  315         int error;
  317         if (cmapp->index >= IBM561_NCMAP_ENTRIES ||
cmapp->count > IBM561_NCMAP_ENTRIES - cmapp->index)
  319                 return (EINVAL);
count = cmapp->count;
index = cmapp->index;
error = copyout(&data->cmap_r[index], cmapp->red, count);
  323         if (error)
  324                 return (error);
error = copyout(&data->cmap_g[index], cmapp->green, count);
  326         if (error)
  327                 return (error);
error = copyout(&data->cmap_b[index], cmapp->blue, count);
  329         return (error);
  330 }
  332 /*
  333  * XXX:
  334  *  I am leaving these functions returning EINVAL, as they are
  335  *  not strictly necessary for the correct functioning of the
  336  *  card and in fact are not used on the other TGA variants, except
  337  *  they are exported via ioctl(2) to userland, which does not in
  338  *  fact use them.
  339  */
  341 int
ibm561_set_cursor(rc, cursorp)
  343         struct ramdac_cookie *rc;
  344         struct wsdisplay_cursor *cursorp;
  345 {
  346         return EINVAL;
  347 }
  349 int
ibm561_get_cursor(rc, cursorp)
  351         struct ramdac_cookie *rc;
  352         struct wsdisplay_cursor *cursorp;
  353 {
  354         return EINVAL;
  355 }
  357 int
ibm561_set_curpos(rc, curposp)
  359         struct ramdac_cookie *rc;
  360         struct wsdisplay_curpos *curposp;
  361 {
  362         return EINVAL;
  363 }
  365 int
ibm561_get_curpos(rc, curposp)
  367         struct ramdac_cookie *rc;
  368         struct wsdisplay_curpos *curposp;
  369 {
  370         return EINVAL;
  371 }
  373 int
ibm561_get_curmax(rc, curposp)
  375         struct ramdac_cookie *rc;
  376         struct wsdisplay_curpos *curposp;
  377 {
  378         return EINVAL;
  379 }
  381 int
ibm561_set_dotclock(rc, dotclock)
  383         struct ramdac_cookie *rc;
  384         unsigned dotclock;
  385 {
  386         struct ibm561data *data = (struct ibm561data *)rc;
  388         /* XXXrcd:  a couple of these are a little hazy, vis a vis
  389          *          check 175MHz and 202MHz, which are wrong...
  390          */
  391         switch (dotclock) {
  392         case  25175000: data->vco_div = 0x3e; data->pll_ref = 0x09; break;
  393         case  31500000: data->vco_div = 0x17; data->pll_ref = 0x05; break;
  394         case  40000000: data->vco_div = 0x42; data->pll_ref = 0x06; break;
  395         case  50000000: data->vco_div = 0x45; data->pll_ref = 0x05; break;
  396         case  65000000: data->vco_div = 0xac; data->pll_ref = 0x0c; break;
  397         case  69000000: data->vco_div = 0xa9; data->pll_ref = 0x0b; break;
  398         case  74000000: data->vco_div = 0x9c; data->pll_ref = 0x09; break;
  399         case  75000000: data->vco_div = 0x93; data->pll_ref = 0x08; break;
  400         case 103994000: data->vco_div = 0x96; data->pll_ref = 0x06; break;
  401         case 108180000: data->vco_div = 0xb8; data->pll_ref = 0x08; break;
  402         case 110000000: data->vco_div = 0xba; data->pll_ref = 0x08; break;
  403         case 119840000: data->vco_div = 0x82; data->pll_ref = 0x04; break;
  404         case 130808000: data->vco_div = 0xc8; data->pll_ref = 0x08; break;
  405         case 135000000: data->vco_div = 0xc1; data->pll_ref = 0x07; break;
  406         case 175000000: data->vco_div = 0xe2; data->pll_ref = 0x07; break;
  407         case 202500000: data->vco_div = 0xe2; data->pll_ref = 0x07; break;
  408         default:
  409                 return EINVAL;
  410         }
data->div_dotclock = 0xb0;
data->changed |= CHANGED_DOTCLOCK;
  414         return 0;
  415 }
  417 /*
  418  * Internal Functions
  419  */
  421 void
ibm561_update(vp)
  423         void *vp;
  424 {
  425         struct ibm561data *data = (struct ibm561data *)vp;
  426         int     i;
  428         /* XXX see comment above ibm561_cninit() */
  429         if (!data)
data = &ibm561_console_data;
  432         if (data->changed & CHANGED_WTYPE) {
ibm561_regbegin(data, IBM561_FB_WINTYPE);
  434                 for (i=0; i < IBM561_NWTYPES; i++)
ibm561_regcont10bit(data, IBM561_CMD_FB_WAT, data->wtype[i]);
  437                 /* XXXrcd:  quick hack here for AUX FB table */
ibm561_regbegin(data, IBM561_AUXFB_WINTYPE);
  439                 for (i=0; i < IBM561_NWTYPES; i++)
ibm561_regcont(data, IBM561_CMD, 0x04);
  442                 /* XXXrcd:  quick hack here for OL WAT table */
ibm561_regbegin(data, IBM561_OL_WINTYPE);
  444                 for (i=0; i < IBM561_NWTYPES; i++)
ibm561_regcont10bit(data, IBM561_CMD_FB_WAT, 0x0231);
  447                 /* XXXrcd:  quick hack here for AUX OL WAT table */
ibm561_regbegin(data, IBM561_AUXOL_WINTYPE);
  449                 for (i=0; i < IBM561_NWTYPES; i++)
ibm561_regcont(data, IBM561_CMD, 0x0c);
  451         }
  453         if (data->changed & CHANGED_CMAP)
ibm561_load_cmap(data);
  456         /* XXX:  I am not sure in what situations it is safe to
  457          *       change the dotclock---hope this is good.
  458          */
  459         if (data->changed & CHANGED_DOTCLOCK)
ibm561_load_dotclock(data);
  461 }
  463 static void
ibm561_load_cmap(struct ibm561data *data)
  465 {
  466         int     i;
ibm561_regbegin(data, IBM561_CMAP_TABLE);
  469         for (i=0; i < IBM561_NCMAP_ENTRIES; i++) {
ibm561_regcont(data, IBM561_CMD_CMAP, data->cmap_r[i]);
ibm561_regcont(data, IBM561_CMD_CMAP, data->cmap_g[i]);
ibm561_regcont(data, IBM561_CMD_CMAP, data->cmap_b[i]);
  473         }
ibm561_regbegin(data, IBM561_RED_GAMMA_TABLE);
  476         for (i=0; i < 256; i++)
ibm561_regcont10bit(data, IBM561_CMD_GAMMA, data->gamma_r[i]);
ibm561_regbegin(data, IBM561_GREEN_GAMMA_TABLE);
  480         for (i=1; i < 256; i++)
ibm561_regcont10bit(data, IBM561_CMD_GAMMA, data->gamma_g[i]);
ibm561_regbegin(data, IBM561_BLUE_GAMMA_TABLE);
  484         for (i=1; i < 256; i++)
ibm561_regcont10bit(data, IBM561_CMD_GAMMA, data->gamma_b[i]);
  487 }
  489 static void
ibm561_load_dotclock(struct ibm561data *data)
  491 {
  492         /* XXX
  493          * we should probably be more pro-active here, but it shouldn't
  494          * actually happen...
  495          */
  496         if (!data->vco_div || !data->pll_ref || ! data->div_dotclock) {
panic("ibm561_load_dotclock: called uninitialized");
  498         }
ibm561_regwr(data, IBM561_PLL_VCO_DIV,  data->vco_div);
ibm561_regwr(data, IBM561_PLL_REF_REG, data->pll_ref);
ibm561_regwr(data, IBM561_DIV_DOTCLCK, data->div_dotclock);
  503 }
  505 static void
ibm561_regcont10bit(struct ibm561data *data, u_int16_t reg, u_int16_t val)
  507 {
data->ramdac_wr(data->cookie, IBM561_CMD_GAMMA, (val >> 2) & 0xff);
data->ramdac_wr(data->cookie, IBM561_CMD_GAMMA, (val & 0x3) << 6);
  510 }
  512 static void
ibm561_regbegin(struct ibm561data *data, u_int16_t reg)
  514 {
data->ramdac_wr(data->cookie, IBM561_ADDR_LOW, reg & 0xff);
data->ramdac_wr(data->cookie, IBM561_ADDR_HIGH, (reg >> 8) & 0xff);
  517 }
  519 static void
ibm561_regcont(struct ibm561data *data, u_int16_t reg, u_int8_t val)
  521 {
data->ramdac_wr(data->cookie, reg, val);
  523 }
  525 static void
ibm561_regwr(struct ibm561data *data, u_int16_t reg, u_int8_t val)
  527 {
ibm561_regbegin(data, reg);
ibm561_regcont(data, IBM561_CMD, val);
  530 }