xorg-server-1.4/hw/kdrive/neomagic/neomagic.c

   1 /*
   2  *
   3  * Copyright © 2004 Franco Catrin
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and its
   6  * documentation for any purpose is hereby granted without fee, provided that
   7  * the above copyright notice appear in all copies and that both that
   8  * copyright notice and this permission notice appear in supporting
   9  * documentation, and that the name of Franco Catrin not be used in
  10  * advertising or publicity pertaining to distribution of the software without
  11  * specific, written prior permission.  Franco Catrin makes no
  12  * representations about the suitability of this software for any purpose.  It
  13  * is provided "as is" without express or implied warranty.
  14  *
  15  * FRANCO CATRIN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  17  * EVENT SHALL FRANCO CATRIN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  18  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  19  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  20  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  21  * PERFORMANCE OF THIS SOFTWARE.
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <kdrive-config.h>
  26 #endif
  27 #include "neomagic.h"
  28 #include <sys/io.h>
  29
  30 struct NeoChipInfo neoChips[] = {
  31     {NEO_VENDOR, 0x0001, CAP_NM2070, "MagicGraph 128(NM2070)",
  32      896, 65000, 2048, 0x100, 1024, 1024, 1024},
  33     {NEO_VENDOR, 0x0002, CAP_NM2090, "MagicGraph 128V(NM2090)",
  34      1152, 80000, 2048, 0x100, 2048, 1024, 1024},
  35     {NEO_VENDOR, 0x0003, CAP_NM2090, "MagicGraph 128ZV(NM2093)",
  36      1152, 80000, 2048, 0x100, 2048, 1024, 1024},
  37     {NEO_VENDOR, 0x0083, CAP_NM2097, "MagicGraph 128ZV+(NM2097)",
  38      1152, 80000, 1024, 0x100, 2048, 1024, 1024},
  39     {NEO_VENDOR, 0x0004, CAP_NM2097, "MagicGraph 128XD(NM2160)",
  40      2048, 90000, 1024, 0x100, 2048, 1024, 1024},
  41     {NEO_VENDOR, 0x0005, CAP_NM2200, "MagicGraph 256AV(NM2200)",
  42      2560, 110000, 1024, 0x1000, 4096, 1280, 1024},
  43     {NEO_VENDOR, 0x0025, CAP_NM2200, "MagicGraph 256AV+(NM2230)",
  44      3008, 110000, 1024, 0x1000, 4096, 1280, 1024},
  45     {NEO_VENDOR, 0x0006, CAP_NM2200, "MagicGraph 256ZX(NM2360)",
  46      4096, 110000, 1024, 0x1000, 4096, 1280, 1024},
  47     {NEO_VENDOR, 0x0016, CAP_NM2200, "MagicGraph 256XL+(NM2380)",
  48      6144, 110000, 1024, 0x1000, 8192, 1280, 1024},
  49     {0, 0, 0, NULL},
  50 };
  51
  52 static Bool
  53 neoCardInit(KdCardInfo *card)
  54 {
  55     NeoCardInfo    *neoc;
  56     struct NeoChipInfo *chip;
  57
  58     neoc =(NeoCardInfo *) xalloc(sizeof(NeoCardInfo));
  59     if(!neoc) {
  60         return FALSE;
  61     }
  62
  63     if(!vesaInitialize(card, &neoc->backendCard)) {
  64         xfree(neoc);
  65         return FALSE;
  66     }
  67
  68     for(chip = neoChips; chip->name != NULL; ++chip) {
  69         if(chip->device == card->attr.deviceID) {
  70             neoc->chip = chip;
  71             break;
  72         }
  73     }
  74
  75     ErrorF("Using Neomagic card: %s\n", neoc->chip->name);
  76
  77     neoMapReg(card, neoc);
  78
  79     card->driver = neoc;
  80
  81     return TRUE;
  82 }
  83
  84 static Bool
  85 neoScreenInit(KdScreenInfo *screen)
  86 {
  87     NeoScreenInfo *neos;
  88     int screen_size, memory;
  89
  90     neos = xcalloc(sizeof(NeoScreenInfo), 1);
  91     if(neos == NULL) {
  92         return FALSE;
  93     }
  94
  95         memset (neos, '\0', sizeof (NeoScreenInfo));
  96
  97
  98     if(!vesaScreenInitialize(screen, &neos->backendScreen)) {
  99         xfree(neos);
 100         return FALSE;
 101     }
 102
 103     screen->softCursor = TRUE;    // no hardware color cursor available
 104
 105         neos->screen = neos->backendScreen.fb;
 106
 107         memory = neos->backendScreen.fb_size;
 108     screen_size = screen->fb[0].byteStride * screen->height;
 109     memory -= screen_size;
 110
 111     if(memory > screen->fb[0].byteStride) {
 112         neos->off_screen = neos->screen + screen_size;
 113         neos->off_screen_size = memory;
 114     } else {
 115         neos->off_screen = 0;
 116         neos->off_screen_size = 0;
 117     }
 118
 119     screen->driver = neos;
 120
 121     return TRUE;
 122 }
 123
 124 static Bool
 125 neoInitScreen(ScreenPtr pScreen)
 126 {
 127     return vesaInitScreen(pScreen);
 128 }
 129
 130 static Bool
 131 neoFinishInitScreen(ScreenPtr pScreen)
 132 {
 133     return vesaFinishInitScreen(pScreen);
 134 }
 135
 136 static Bool
 137 neoCreateResources(ScreenPtr pScreen)
 138 {
 139     return vesaCreateResources(pScreen);
 140 }
 141
 142 void
 143 neoPreserve(KdCardInfo *card)
 144 {
 145         vesaPreserve(card);
 146 }
 147
 148 CARD8
 149 neoGetIndex(NeoCardInfo *nvidiac, CARD16 addr,  CARD8 index)
 150 {
 151     outb(index, addr);
 152
 153     return inb(addr+1);
 154 }
 155
 156 void
 157 neoSetIndex(NeoCardInfo *nvidiac, CARD16 addr,  CARD8 index, CARD8 val)
 158 {
 159     outb(index, addr);
 160     outb(val, addr+1);
 161 }
 162
 163 static void neoLock(NeoCardInfo *neoc){
 164     CARD8 cr11;
 165     neoSetIndex(neoc, 0x3ce,  0x09, 0x00);
 166     neoSetIndex(neoc, 0x3ce,  0x11, 0x0); // disable MMIO and linear mode
 167     cr11 = neoGetIndex(neoc, 0x3d4, 0x11);
 168     neoSetIndex(neoc, 0x3d4, 0x11, cr11 | 0x80);
 169 }
 170
 171 static void neoUnlock(NeoCardInfo *neoc){
 172     CARD8 cr11;
 173     cr11 = neoGetIndex(neoc, 0x3d4, 0x11);
 174     neoSetIndex(neoc, 0x3d4, 0x11, cr11 & 0x7F);
 175     neoSetIndex(neoc, 0x3ce,  0x09, 0x26);
 176     neoSetIndex(neoc, 0x3ce,  0x11, 0xc0); // enable MMIO and linear mode
 177 }
 178
 179
 180 Bool
 181 neoMapReg(KdCardInfo *card, NeoCardInfo *neoc)
 182 {
 183     neoc->reg_base = card->attr.address[1] & 0xFFF80000;
 184     if(!neoc->reg_base) {
 185         return FALSE;
 186     }
 187
 188     neoc->mmio = KdMapDevice(neoc->reg_base, NEO_REG_SIZE(card));
 189     if(!neoc->mmio) {
 190         return FALSE;
 191     }
 192
 193     KdSetMappedMode(neoc->reg_base, NEO_REG_SIZE(card), KD_MAPPED_MODE_REGISTERS);
 194
 195     return TRUE;
 196 }
 197
 198 void
 199 neoUnmapReg(KdCardInfo *card, NeoCardInfo *neoc)
 200 {
 201     if(neoc->reg_base)
 202     {
 203         neoSetIndex(neoc, 0x3ce, 0x82,0);
 204         KdResetMappedMode(neoc->reg_base, NEO_REG_SIZE(card), KD_MAPPED_MODE_REGISTERS);
 205         KdUnmapDevice((void *)neoc->mmio, NEO_REG_SIZE(card));
 206         neoc->reg_base = 0;
 207     }
 208 }
 209
 210 static void
 211 neoSetMMIO(KdCardInfo *card, NeoCardInfo *neoc)
 212 {
 213     if(!neoc->reg_base)
 214         neoMapReg(card, neoc);
 215         neoUnlock(neoc);
 216 }
 217
 218 static void
 219 neoResetMMIO(KdCardInfo *card, NeoCardInfo *neoc)
 220 {
 221     neoUnmapReg(card, neoc);
 222     neoLock(neoc);
 223 }
 224
 225
 226 Bool
 227 neoEnable(ScreenPtr pScreen)
 228 {
 229     KdScreenPriv(pScreen);
 230     neoCardInfo(pScreenPriv);
 231
 232     if(!vesaEnable(pScreen)) {
 233         return FALSE;
 234     }
 235
 236     neoSetMMIO(pScreenPriv->card, neoc);
 237     return TRUE;
 238 }
 239
 240 void
 241 neoDisable(ScreenPtr pScreen)
 242 {
 243     KdScreenPriv(pScreen);
 244     neoCardInfo(pScreenPriv);
 245
 246     neoResetMMIO(pScreenPriv->card, neoc);
 247
 248     vesaDisable(pScreen);
 249 }
 250
 251 static void
 252 neoGetColors(ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
 253 {
 254     vesaGetColors(pScreen, fb, n, pdefs);
 255 }
 256
 257 static void
 258 neoPutColors(ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
 259 {
 260     vesaPutColors(pScreen, fb, n, pdefs);
 261 }
 262
 263 static Bool
 264 neoDPMS(ScreenPtr pScreen, int mode)
 265 {
 266     return vesaDPMS(pScreen, mode);
 267 }
 268
 269 static void
 270 neoRestore(KdCardInfo *card)
 271 {
 272     NeoCardInfo *neoc = card->driver;
 273
 274     neoResetMMIO(card, neoc);
 275     vesaRestore(card);
 276 }
 277
 278 static void
 279 neoScreenFini(KdScreenInfo *screen)
 280 {
 281     NeoScreenInfo *neos =(NeoScreenInfo *) screen->driver;
 282
 283     vesaScreenFini(screen);
 284     xfree(neos);
 285     screen->driver = 0;
 286 }
 287
 288 static void
 289 neoCardFini(KdCardInfo *card)
 290 {
 291     NeoCardInfo *neoc = card->driver;
 292
 293         neoUnmapReg(card, neoc);
 294         vesaCardFini(card);
 295 }
 296
 297 #define neoCursorInit 0       // initCursor
 298 #define neoCursorEnable 0     // enableCursor
 299 #define neoCursorDisable 0    // disableCursor
 300 #define neoCursorFini 0       // finiCursor */
 301 #define neoRecolorCursor 0    // recolorCursor */
 302 //#define     neoDrawInit 0              // initAccel
 303 //#define     neoDrawEnable 0            // enableAccel
 304 //#define     neoDrawSync 0          // syncAccel
 305 //#define     neoDrawDisable 0          // disableAccel
 306 //#define     neoDrawFini 0             // finiAccel
 307
 308 KdCardFuncs    neoFuncs = {
 309     neoCardInit,              // cardinit
 310     neoScreenInit,            // scrinit
 311     neoInitScreen,            // initScreen
 312     neoFinishInitScreen,      // finishInitScreen
 313     neoCreateResources,       // createRes
 314     neoPreserve,              // preserve
 315     neoEnable,                // enable
 316     neoDPMS,                  // dpms
 317     neoDisable,               // disable
 318     neoRestore,               // restore
 319     neoScreenFini,            // scrfini
 320     neoCardFini,              // cardfini
 321
 322     neoCursorInit,            // initCursor
 323     neoCursorEnable,          // enableCursor
 324     neoCursorDisable,         // disableCursor
 325     neoCursorFini,            // finiCursor
 326     neoRecolorCursor,         // recolorCursor
 327
 328     neoDrawInit,              // initAccel
 329     neoDrawEnable,            // enableAccel
 330     neoDrawDisable,           // disableAccel
 331     neoDrawFini,              // finiAccel
 332
 333     neoGetColors,             // getColors
 334     neoPutColors,             // putColors
 335 };