The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/pc/vgargb524.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 #include "u.h"
    2 #include "../port/lib.h"
    3 #include "mem.h"
    4 #include "dat.h"
    5 #include "fns.h"
    6 #include "io.h"
    7 #include "../port/error.h"
    8 
    9 #define Image   IMAGE
   10 #include <draw.h>
   11 #include <memdraw.h>
   12 #include <cursor.h>
   13 #include "screen.h"
   14 
   15 /*
   16  * IBM RGB524.
   17  * 170/220MHz High Performance Palette DAC.
   18  *
   19  * Assumes hooked up to an S3 Vision96[48].
   20  */
   21 enum {
   22         IndexLo         = 0x00,
   23         IndexHi         = 0x01,
   24         Data            = 0x02,
   25         IndexCtl        = 0x03,
   26 };
   27 
   28 enum {                                          /* index registers */
   29         CursorCtl       = 0x30,
   30         CursorXLo       = 0x31,
   31         CursorXHi       = 0x32,
   32         CursorYLo       = 0x33,
   33         CursorYHi       = 0x34,
   34         CursorHotX      = 0x35,
   35         CursorHotY      = 0x36,
   36 
   37         CursorR1        = 0x40,
   38         CursorG1        = 0x41,
   39         CursorB1        = 0x42,
   40         CursorR2        = 0x43,
   41         CursorG2        = 0x44,
   42         CursorB2        = 0x45,
   43         CursorR3        = 0x46,
   44         CursorG3        = 0x47,
   45         CursorB3        = 0x48,
   46 
   47         CursorArray     = 0x100,
   48 };
   49 
   50 /*
   51  * Lower 2-bits of indirect DAC register
   52  * addressing.
   53  */
   54 static ushort dacxreg[4] = {
   55         PaddrW, Pdata, Pixmask, PaddrR
   56 };
   57 
   58 static uchar
   59 rgb524setrs2(void)
   60 {
   61         uchar rs2;
   62 
   63         rs2 = vgaxi(Crtx, 0x55);
   64         vgaxo(Crtx, 0x55, (rs2 & 0xFC)|0x01);
   65 
   66         return rs2;
   67 }
   68 
   69 static void
   70 rgb524xo(int index, uchar data)
   71 {
   72         vgao(dacxreg[IndexLo], index & 0xFF);
   73         vgao(dacxreg[IndexHi], (index>>8) & 0xFF);
   74         vgao(dacxreg[Data], data);
   75 }
   76 
   77 static void
   78 rgb524disable(VGAscr*)
   79 {
   80         uchar rs2;
   81 
   82         rs2 = rgb524setrs2();
   83         rgb524xo(CursorCtl, 0x00);
   84         vgaxo(Crtx, 0x55, rs2);
   85 }
   86 
   87 static void
   88 rgb524enable(VGAscr*)
   89 {
   90         uchar rs2;
   91 
   92         rs2 = rgb524setrs2();
   93 
   94         /*
   95          * Make sure cursor is off by initialising the cursor
   96          * control to defaults.
   97          */
   98         rgb524xo(CursorCtl, 0x00);
   99 
  100         /*
  101          * Cursor colour 1 (white),
  102          * cursor colour 2 (black).
  103          */
  104         rgb524xo(CursorR1, Pwhite); rgb524xo(CursorG1, Pwhite); rgb524xo(CursorB1, Pwhite);
  105         rgb524xo(CursorR2, Pblack); rgb524xo(CursorG2, Pblack); rgb524xo(CursorB2, Pblack);
  106 
  107         /*
  108          * Enable the cursor, 32x32, mode 2.
  109          */
  110         rgb524xo(CursorCtl, 0x23);
  111 
  112         vgaxo(Crtx, 0x55, rs2);
  113 }
  114 
  115 static void
  116 rgb524load(VGAscr*, Cursor* curs)
  117 {
  118         uchar p, p0, p1, rs2;
  119         int x, y;
  120 
  121         rs2 = rgb524setrs2();
  122 
  123         /*
  124          * Make sure cursor is off by initialising the cursor
  125          * control to defaults.
  126          */
  127         rgb524xo(CursorCtl, 0x00);
  128 
  129         /*
  130          * Set auto-increment mode for index-register addressing
  131          * and initialise the cursor array index.
  132          */
  133         vgao(dacxreg[IndexCtl], 0x01);
  134         vgao(dacxreg[IndexLo], CursorArray & 0xFF);
  135         vgao(dacxreg[IndexHi], (CursorArray>>8) & 0xFF);
  136 
  137         /*
  138          * Initialise the 32x32 cursor RAM array. There are 2 planes,
  139          * p0 and p1. Data is written 4 pixels per byte, with p1 the
  140          * MS bit of each pixel.
  141          * The cursor is set in X-Windows mode which gives the following
  142          * truth table:
  143          *      p1 p0   colour
  144          *       0  0   underlying pixel colour
  145          *       0  1   underlying pixel colour
  146          *       1  0   cursor colour 1
  147          *       1  1   cursor colour 2
  148          * Put the cursor into the top-left of the 32x32 array.
  149          */
  150         for(y = 0; y < 32; y++){
  151                 for(x = 0; x < 32/8; x++){
  152                         if(x < 16/8 && y < 16){
  153                                 p0 = curs->clr[x+y*2];
  154                                 p1 = curs->set[x+y*2];
  155 
  156                                 p = 0x00;
  157                                 if(p1 & 0x80)
  158                                         p |= 0xC0;
  159                                 else if(p0 & 0x80)
  160                                         p |= 0x80;
  161                                 if(p1 & 0x40)
  162                                         p |= 0x30;
  163                                 else if(p0 & 0x40)
  164                                         p |= 0x20;
  165                                 if(p1 & 0x20)
  166                                         p |= 0x0C;
  167                                 else if(p0 & 0x20)
  168                                         p |= 0x08;
  169                                 if(p1 & 0x10)
  170                                         p |= 0x03;
  171                                 else if(p0 & 0x10)
  172                                         p |= 0x02;
  173                                 vgao(dacxreg[Data], p);
  174 
  175                                 p = 0x00;
  176                                 if(p1 & 0x08)
  177                                         p |= 0xC0;
  178                                 else if(p0 & 0x08)
  179                                         p |= 0x80;
  180                                 if(p1 & 0x04)
  181                                         p |= 0x30;
  182                                 else if(p0 & 0x04)
  183                                         p |= 0x20;
  184                                 if(p1 & 0x02)
  185                                         p |= 0x0C;
  186                                 else if(p0 & 0x02)
  187                                         p |= 0x08;
  188                                 if(p1 & 0x01)
  189                                         p |= 0x03;
  190                                 else if(p0 & 0x01)
  191                                         p |= 0x02;
  192                                 vgao(dacxreg[Data], p);
  193                         }
  194                         else{
  195                                 vgao(dacxreg[Data], 0x00);
  196                                 vgao(dacxreg[Data], 0x00);
  197                         }
  198                 }
  199         }
  200 
  201         /*
  202          * Initialise the cursor hotpoint,
  203          * enable the cursor and restore state.
  204          */
  205         rgb524xo(CursorHotX, -curs->offset.x);
  206         rgb524xo(CursorHotY, -curs->offset.y);
  207 
  208         rgb524xo(CursorCtl, 0x23);
  209 
  210         vgaxo(Crtx, 0x55, rs2);
  211 }
  212 
  213 static int
  214 rgb524move(VGAscr*, Point p)
  215 {
  216         uchar rs2;
  217 
  218         rs2 = rgb524setrs2();
  219 
  220         rgb524xo(CursorXLo, p.x & 0xFF);
  221         rgb524xo(CursorXHi, (p.x>>8) & 0x0F);
  222         rgb524xo(CursorYLo, p.y & 0xFF);
  223         rgb524xo(CursorYHi, (p.y>>8) & 0x0F);
  224 
  225         vgaxo(Crtx, 0x55, rs2);
  226 
  227         return 0;
  228 }
  229 
  230 VGAcur vgargb524cur = {
  231         "rgb524hwgc",
  232 
  233         rgb524enable,
  234         rgb524disable,
  235         rgb524load,
  236         rgb524move,
  237 };

Cache object: dd1790894ef221b6cac08fd21ae0b027


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.