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

   1 /*
   2  * Copyright © 2004 Ralph Thomas
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of Ralph Thomas not be used in
   9  * advertising or publicity pertaining to distribution of the software without
  10  * specific, written prior permission.  Ralph Thomas makes no
  11  * representations about the suitability of this software for any purpose.  It
  12  * is provided "as is" without express or implied warranty.
  13  *
  14  * RALPH THOMAS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL RALPH THOMAS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  20  * PERFORMANCE OF THIS SOFTWARE.
  21  */
  22 /*
  23 ** VIA CLE266 driver
  24 ** Copyright 2004 (C) Ralph Thomas <ralpht@gmail.com>
  25 **
  26 ** http://www.viatech.com.tw/
  27 */
  28
  29 #include "via.h"
  30 #include "viadraw.h"
  31
  32 /*
  33 ** viaCardInit( KdCardInfo* card )
  34 **
  35 ** Description:
  36 **      Create card specific structures, map chip registers and initialize the
  37 **      VESA driver. We make the VESA driver do boring stuff for us, like set
  38 **      up a framebuffer and program a mode.
  39 **
  40 ** Parameters:
  41 **      card            Information stucture for the card we want to bring up.
  42 **                      It should be a VIA card.
  43 **
  44 ** Return:
  45 **      TRUE            Initialization went ok.
  46 **      FALSE           Initialization failed.
  47 */
  48 static Bool
  49 viaCardInit( KdCardInfo* card ) {
  50         ViaCardInfo*    viac;
  51
  52         viac = (ViaCardInfo*) xalloc( sizeof( ViaCardInfo ) );
  53         if( !viac ) return FALSE;
  54         memset( viac, '\0', sizeof( ViaCardInfo ) );
  55
  56
  57         viaMapReg( card, viac );
  58
  59         if( !vesaInitialize( card, &viac->vesa ) ) {
  60                 xfree( viac );
  61                 return FALSE;
  62         }
  63
  64         card->driver = viac;
  65
  66         return TRUE;
  67 }
  68
  69 /*
  70 ** Bool viaScreenInit( KdScreenInfo* screen )
  71 **
  72 ** Description:
  73 **      Initialize a single screen, described by the screen parameter.
  74 **      This is where fairly low-level screen related things get setup,
  75 **      such as video mode and resolution. Currently that all gets
  76 **      handed off to the VESA driver.
  77 **
  78 ** Parameters:
  79 **      screen  Information structure for the screen to enable.
  80 **
  81 ** Return:
  82 **      TRUE    Screen was initialized successfully
  83 **      FALSE   Screen initialization failed
  84 */
  85 static Bool
  86 viaScreenInit( KdScreenInfo* screen ) {
  87         ViaCardInfo*    viac = screen->card->driver;
  88         ViaScreenInfo*  vias;
  89
  90         vias = (ViaScreenInfo*) xalloc( sizeof( ViaScreenInfo ) );
  91         if( !vias ) return FALSE;
  92         memset( vias, '\0', sizeof( ViaScreenInfo ) );
  93
  94         if( !vesaScreenInitialize( screen, &vias->vesa ) ) {
  95                 xfree( vias );
  96                 return FALSE;
  97         }
  98
  99         /*
 100         ** XXX: What does this do?
 101         */
 102         if( !viac->mapBase )
 103                 screen->dumb = TRUE;
 104         if( vias->vesa.mapping != VESA_LINEAR )
 105                 screen->dumb = TRUE;
 106
 107         screen->driver = vias;
 108         return TRUE;
 109 }
 110
 111 /*
 112 ** Bool viaInitScreen( ScreenPtr pScreen )
 113 **
 114 ** Description:
 115 **      High level screen initialization occurs here. We could register XV
 116 **      adaptors, etc, here.
 117 **
 118 ** Arguments:
 119 **      pScreen         X screen information
 120 **
 121 ** Return:
 122 **      TRUE    Initialization was successful,
 123 **      FALSE   Initialization failed.
 124 */
 125 static Bool
 126 viaInitScreen( ScreenPtr pScreen ) {
 127         return vesaInitScreen( pScreen );
 128 }
 129
 130 /*
 131 ** Bool viaFinishInitScreen
 132 **
 133 ** Description:
 134 **      Finish up any high-level screen initialization. Per-Screen extension
 135 **      initialization can be done here.
 136 **
 137 ** Arguments:
 138 **      pScreen         X screen information
 139 **
 140 ** Return:
 141 **      TRUE    Initialization was successful.
 142 **      FALSE   Initialization failed.
 143 */
 144 static Bool
 145 viaFinishInitScreen( ScreenPtr pScreen ) {
 146         return vesaFinishInitScreen( pScreen );
 147 }
 148
 149 /*
 150 ** Bool viaCreateResources( ScreenPtr pScreen )
 151 **
 152 ** Description:
 153 **      Do any screen specific configuration.
 154 **
 155 ** Arguments:
 156 **      pScreen         X screen information
 157 **
 158 ** Return:
 159 **      TRUE    configuration was successful.
 160 **      FALSE   configuration failed.
 161 */
 162 static Bool
 163 viaCreateResources( ScreenPtr pScreen ) {
 164         return vesaCreateResources( pScreen );
 165 }
 166
 167 /*
 168 ** void viaPreserve( KdCardInfo* card )
 169 **
 170 ** Description:
 171 **      Save the current state of the chip, so that it can be restored by
 172 **      viaRestore at a later time.
 173 **
 174 ** Arguments:
 175 **      card    Information structure for the chip we want to preserve the
 176 **              state of.
 177 **
 178 ** Return:
 179 **      None.
 180 **
 181 ** See Also:
 182 **      viaRestore
 183 */
 184 static void
 185 viaPreserve( KdCardInfo* card ) {
 186         vesaPreserve( card );
 187 }
 188
 189 /*
 190 ** void viaRestore( KdCardInfo* card )
 191 **
 192 ** Description:
 193 **      Restore the previous state of the chip, as saved by viaPreserve
 194 **      earlier.
 195 **
 196 ** Arguments:
 197 **      card    Information structure for the chip we want to restore the
 198 **              state of.
 199 **
 200 ** Return:
 201 **      None.
 202 **
 203 ** See Also:
 204 **      viaPreserve
 205 */
 206 static void viaRestore( KdCardInfo* card ) {
 207         ViaCardInfo* viac = card->driver;
 208
 209         viaResetMMIO( card, viac );
 210         vesaRestore( card );
 211 }
 212
 213 /*
 214 ** Bool viaEnable( ScreenPtr pScreen )
 215 **
 216 ** Description:
 217 **      This is where we set the card up for drawing the specified screen, e.g.:
 218 **      set the mode and mmap the framebuffer.
 219 **
 220 ** Arguments:
 221 **      pScreen         X screen information
 222 **
 223 ** Return:
 224 **      TRUE    the screen was enabled
 225 **      FALSE   the screen could not be enabled
 226 */
 227 static Bool
 228 viaEnable( ScreenPtr pScreen ) {
 229         KdScreenPriv( pScreen );
 230         ViaCardInfo* viac = pScreenPriv->card->driver;
 231
 232         if( !vesaEnable( pScreen ) ) return FALSE;
 233
 234         viaSetMMIO( pScreenPriv->card, viac );
 235
 236         if( !viac->mapBase ) {
 237                 ErrorF( "Could not map CLE266 graphics registers" );
 238                 return FALSE;
 239         }
 240
 241         return TRUE;
 242 }
 243
 244 /*
 245 ** void viaDisable( ScreenPtr pScreen )
 246 **
 247 ** Description:
 248 **      Shut down drawing: save some state and unmap the framebuffer.
 249 **
 250 ** Arguments:
 251 **      pScreen         X screen information
 252 **
 253 ** Return:
 254 **      None.
 255 */
 256 static void
 257 viaDisable( ScreenPtr pScreen ) {
 258         KdScreenPriv( pScreen );
 259         ViaCardInfo* viac = pScreenPriv->card->driver;
 260
 261         viaResetMMIO( pScreenPriv->card, viac );
 262         vesaDisable( pScreen );
 263 }
 264
 265 /*
 266 ** void viaScreenFini( KdScreenInfo* screen )
 267 **
 268 ** Description:
 269 **      Release memory and resources allocated by viaScreenInit.
 270 **
 271 ** Arguments:
 272 **      screen          Information structure for the screen to release.
 273 **
 274 ** Return:
 275 **      None.
 276 **
 277 ** See Also:
 278 **      viaScreenInit
 279 */
 280 static void
 281 viaScreenFini( KdScreenInfo* screen ) {
 282         ViaScreenInfo* vias = screen->driver;
 283
 284         vesaScreenFini( screen );
 285         xfree( vias );
 286         screen->driver = 0;
 287 }
 288
 289 /*
 290 ** void viaCardFini( KdCardInfo* card )
 291 **
 292 ** Description:
 293 **      Release memory and resources allocated by viaCardInit.
 294 **
 295 ** Arguments:
 296 **      card            Information structure for the chip to release.
 297 **
 298 ** Return:
 299 **      None.
 300 **
 301 ** See Also:
 302 **      viaCardInit
 303 */
 304 static void
 305 viaCardFini( KdCardInfo* card ) {
 306         ViaCardInfo* viac = card->driver;
 307
 308         viaUnmapReg( card, viac );
 309         vesaCardFini( card );
 310         xfree( viac );
 311 }
 312
 313 /*
 314 ** void viaSetMMIO( KdCardInfo* card, ViaCardInfo* viac )
 315 **
 316 ** Description:
 317 **      Map the card's registers, if they're not already
 318 **      mapped.
 319 **
 320 ** Arguments:
 321 **      card    generic chip information
 322 **      viac    VIA-driver specific chip information
 323 **
 324 ** Return:
 325 **      None.
 326 */
 327 void viaSetMMIO( KdCardInfo* card, ViaCardInfo* viac ) {
 328         if( !viac->mapBase ) viaMapReg( card, viac );
 329 }
 330
 331 /*
 332 ** void viaResetMMIO( KdCardInfo* card, ViaCardInfo* viac )
 333 **
 334 ** Description:
 335 **      Unmap chip's registers.
 336 **
 337 ** Arguments:
 338 **      card    generic chip information
 339 **      viac    VIA-driver specific chip information
 340 **
 341 ** Return:
 342 **      None.
 343 */
 344 void viaResetMMIO( KdCardInfo* card, ViaCardInfo* viac ) {
 345         viaUnmapReg( card, viac );
 346 }
 347
 348 /*
 349 ** Bool viaMapReg( KdCardInfo* card, ViaCardInfo* viac )
 350 **
 351 ** Description:
 352 **      Map the chip's registers into our address space.
 353 **
 354 ** Arguments:
 355 **      card    the card information
 356 **      viac    the VIA-driver specific card information
 357 **
 358 ** Return:
 359 **      TRUE    the registers were succesfully mapped
 360 **      FALSE   the registers could not be mapped
 361 */
 362 Bool
 363 viaMapReg( KdCardInfo* card, ViaCardInfo* viac ) {
 364         viac->mapBase = (VOL8*) KdMapDevice( VIA_REG_BASE( card ),
 365                                              VIA_REG_SIZE( card ) );
 366
 367         if( !viac->mapBase ) {
 368                 ErrorF( "Couldn't allocate viac->mapBase\n" );
 369                 return FALSE;
 370         }
 371
 372         KdSetMappedMode( VIA_REG_BASE( card ), VIA_REG_SIZE( card ),
 373                          KD_MAPPED_MODE_REGISTERS );
 374
 375         /*
 376         ** Enable extended IO space
 377         */
 378         VGAOUT8( 0x3C4, 0x10 );
 379         VGAOUT8( 0x3C5, 0x01 );
 380
 381         return TRUE;
 382 }
 383
 384 /*
 385 ** void viaUnmapReg( KdCardInfo* card, ViaCardInfo* viac )
 386 **
 387 ** Description:
 388 **      Unmap the the chip's registers.
 389 **
 390 ** Arguments:
 391 **      card    the card information
 392 **      viac    the VIA-driver specific card information
 393 **
 394 ** Return:
 395 **      None.
 396 */
 397 void
 398 viaUnmapReg( KdCardInfo* card, ViaCardInfo* viac ) {
 399         if( !viac->mapBase ) return;
 400
 401         KdResetMappedMode( VIA_REG_BASE( card ), VIA_REG_SIZE( card ),
 402                            KD_MAPPED_MODE_REGISTERS );
 403         KdUnmapDevice( (void*) viac->mapBase, VIA_REG_SIZE( card ) );
 404         viac->mapBase = 0;
 405 }
 406
 407 KdCardFuncs viaFuncs = {
 408         viaCardInit,            /* cardinit */
 409         viaScreenInit,          /* scrinit */
 410         viaInitScreen,          /* initScreen */
 411         viaFinishInitScreen,    /* finishInitScreen */
 412         viaCreateResources,     /* createRes */
 413         viaPreserve,            /* preserve */
 414         viaEnable,              /* enable */
 415         vesaDPMS,               /* dpms */
 416         viaDisable,             /* disable */
 417         viaRestore,             /* restore */
 418         viaScreenFini,          /* scrfini */
 419         viaCardFini,            /* cardfini */
 420
 421         0,                      /* initCursor */
 422         0,                      /* enableCursor */
 423         0,                      /* disableCursor */
 424         0,                      /* finiCursor */
 425         0,                      /* recolorCursor */
 426
 427         viaDrawInit,            /* initAccel */
 428         viaDrawEnable,          /* enableAccel */
 429         viaDrawDisable,         /* disableAccel */
 430         viaDrawFini,            /* finiAccel */
 431
 432         vesaGetColors,          /* getColors */
 433         vesaPutColors,          /* putColors */
 434 };
 435