bsd/mga/mga_dma.c

   1 /* mga_dma.c -- DMA support for mga g200/g400 -*- linux-c -*-
   2  * Created: Mon Dec 13 01:50:01 1999 by jhartmann@precisioninsight.com
   3  *
   4  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
   5  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the next
  16  * paragraph) shall be included in all copies or substantial portions of the
  17  * Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  23  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  24  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  25  * DEALINGS IN THE SOFTWARE.
  26  *
  27  * Authors:
  28  *    Rickard E. (Rik) Faith <faith@valinux.com>
  29  *    Jeff Hartmann <jhartmann@valinux.com>
  30  *    Keith Whitwell <keithw@valinux.com>
  31  *
  32  * Rewritten by:
  33  *    Gareth Hughes <gareth@valinux.com>
  34  */
  35
  36 #define __NO_VERSION__
  37 #include "mga.h"
  38 #include "drmP.h"
  39 #include "drm.h"
  40 #include "mga_drm.h"
  41 #include "mga_drv.h"
  42
  43
  44 #define MGA_DEFAULT_USEC_TIMEOUT        10000
  45 #define MGA_FREELIST_DEBUG              0
  46
  47
  48 /* ================================================================
  49  * Engine control
  50  */
  51
  52 int mga_do_wait_for_idle( drm_mga_private_t *dev_priv )
  53 {
  54         u32 status = 0;
  55         int i;
  56         DRM_DEBUG( "%s\n", __FUNCTION__ );
  57
  58         for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
  59                 status = MGA_READ( MGA_STATUS ) & MGA_ENGINE_IDLE_MASK;
  60                 if ( status == MGA_ENDPRDMASTS ) {
  61                         MGA_WRITE8( MGA_CRTC_INDEX, 0 );
  62                         return 0;
  63                 }
  64                 DRM_OS_DELAY( 1 );
  65         }
  66
  67 #if MGA_DMA_DEBUG
  68         DRM_ERROR( "failed!\n" );
  69         DRM_INFO( "   status=0x%08x\n", status );
  70 #endif
  71         DRM_OS_RETURN(EBUSY);
  72 }
  73
  74 int mga_do_dma_idle( drm_mga_private_t *dev_priv )
  75 {
  76         u32 status = 0;
  77         int i;
  78         DRM_DEBUG( "%s\n", __FUNCTION__ );
  79
  80         for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
  81                 status = MGA_READ( MGA_STATUS ) & MGA_DMA_IDLE_MASK;
  82                 if ( status == MGA_ENDPRDMASTS ) return 0;
  83                 DRM_OS_DELAY( 1 );
  84         }
  85
  86 #if MGA_DMA_DEBUG
  87         DRM_ERROR( "failed! status=0x%08x\n", status );
  88 #endif
  89         DRM_OS_RETURN(EBUSY);
  90 }
  91
  92 int mga_do_dma_reset( drm_mga_private_t *dev_priv )
  93 {
  94         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
  95         drm_mga_primary_buffer_t *primary = &dev_priv->prim;
  96
  97         DRM_DEBUG( "%s\n", __FUNCTION__ );
  98
  99         /* The primary DMA stream should look like new right about now.
 100          */
 101         primary->tail = 0;
 102         primary->space = primary->size;
 103         primary->last_flush = 0;
 104
 105         sarea_priv->last_wrap = 0;
 106
 107         /* FIXME: Reset counters, buffer ages etc...
 108          */
 109
 110         /* FIXME: What else do we need to reinitialize?  WARP stuff?
 111          */
 112
 113         return 0;
 114 }
 115
 116 int mga_do_engine_reset( drm_mga_private_t *dev_priv )
 117 {
 118         DRM_DEBUG( "%s\n", __FUNCTION__ );
 119
 120         /* Okay, so we've completely screwed up and locked the engine.
 121          * How about we clean up after ourselves?
 122          */
 123         MGA_WRITE( MGA_RST, MGA_SOFTRESET );
 124         DRM_OS_DELAY( 15 );             /* Wait at least 10 usecs */
 125         MGA_WRITE( MGA_RST, 0 );
 126
 127         /* Initialize the registers that get clobbered by the soft
 128          * reset.  Many of the core register values survive a reset,
 129          * but the drawing registers are basically all gone.
 130          *
 131          * 3D clients should probably die after calling this.  The X
 132          * server should reset the engine state to known values.
 133          */
 134 #if 0
 135         MGA_WRITE( MGA_PRIMPTR,
 136                    virt_to_bus((void *)dev_priv->prim.status_page) |
 137                    MGA_PRIMPTREN0 |
 138                    MGA_PRIMPTREN1 );
 139 #endif
 140
 141         MGA_WRITE( MGA_ICLEAR, MGA_SOFTRAPICLR );
 142         MGA_WRITE( MGA_IEN,    MGA_SOFTRAPIEN );
 143
 144         /* The primary DMA stream should look like new right about now.
 145          */
 146         mga_do_dma_reset( dev_priv );
 147
 148         /* This bad boy will never fail.
 149          */
 150         return 0;
 151 }
 152
 153
 154 /* ================================================================
 155  * Primary DMA stream
 156  */
 157
 158 void mga_do_dma_flush( drm_mga_private_t *dev_priv )
 159 {
 160         drm_mga_primary_buffer_t *primary = &dev_priv->prim;
 161         u32 head, tail;
 162         DMA_LOCALS;
 163         DRM_DEBUG( "%s:\n", __FUNCTION__ );
 164
 165         if ( primary->tail == primary->last_flush ) {
 166                 DRM_DEBUG( "   bailing out...\n" );
 167                 return;
 168         }
 169
 170         tail = primary->tail + dev_priv->primary->offset;
 171
 172         /* We need to pad the stream between flushes, as the card
 173          * actually (partially?) reads the first of these commands.
 174          * See page 4-16 in the G400 manual, middle of the page or so.
 175          */
 176         BEGIN_DMA( 1 );
 177
 178         DMA_BLOCK( MGA_DMAPAD,  0x00000000,
 179                    MGA_DMAPAD,  0x00000000,
 180                    MGA_DMAPAD,  0x00000000,
 181                    MGA_DMAPAD,  0x00000000 );
 182
 183         ADVANCE_DMA();
 184
 185         primary->last_flush = primary->tail;
 186
 187         head = MGA_READ( MGA_PRIMADDRESS );
 188
 189         if ( head <= tail ) {
 190                 primary->space = primary->size - primary->tail;
 191         } else {
 192                 primary->space = head - tail;
 193         }
 194
 195         DRM_DEBUG( "   head = 0x%06lx\n", head - dev_priv->primary->offset );
 196         DRM_DEBUG( "   tail = 0x%06lx\n", tail - dev_priv->primary->offset );
 197         DRM_DEBUG( "  space = 0x%06x\n", primary->space );
 198
 199         mga_flush_write_combine();
 200         MGA_WRITE( MGA_PRIMEND, tail | MGA_PAGPXFER );
 201
 202         DRM_DEBUG( "%s: done.\n", __FUNCTION__ );
 203 }
 204
 205 void mga_do_dma_wrap_start( drm_mga_private_t *dev_priv )
 206 {
 207         drm_mga_primary_buffer_t *primary = &dev_priv->prim;
 208         u32 head, tail;
 209         DMA_LOCALS;
 210         DRM_DEBUG( "%s:\n", __FUNCTION__ );
 211
 212         BEGIN_DMA_WRAP();
 213
 214         DMA_BLOCK( MGA_DMAPAD,  0x00000000,
 215                    MGA_DMAPAD,  0x00000000,
 216                    MGA_DMAPAD,  0x00000000,
 217                    MGA_DMAPAD,  0x00000000 );
 218
 219         ADVANCE_DMA();
 220
 221         tail = primary->tail + dev_priv->primary->offset;
 222
 223         primary->tail = 0;
 224         primary->last_flush = 0;
 225         primary->last_wrap++;
 226
 227         head = MGA_READ( MGA_PRIMADDRESS );
 228
 229         if ( head == dev_priv->primary->offset ) {
 230                 primary->space = primary->size;
 231         } else {
 232                 primary->space = head - dev_priv->primary->offset;
 233         }
 234
 235         DRM_DEBUG( "   head = 0x%06lx\n",
 236                   head - dev_priv->primary->offset );
 237         DRM_DEBUG( "   tail = 0x%06x\n", primary->tail );
 238         DRM_DEBUG( "   wrap = %d\n", primary->last_wrap );
 239         DRM_DEBUG( "  space = 0x%06x\n", primary->space );
 240
 241         mga_flush_write_combine();
 242         MGA_WRITE( MGA_PRIMEND, tail | MGA_PAGPXFER );
 243
 244         set_bit( 0, &primary->wrapped );
 245         DRM_DEBUG( "%s: done.\n", __FUNCTION__ );
 246 }
 247
 248 void mga_do_dma_wrap_end( drm_mga_private_t *dev_priv )
 249 {
 250         drm_mga_primary_buffer_t *primary = &dev_priv->prim;
 251         drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
 252         u32 head = dev_priv->primary->offset;
 253         DRM_DEBUG( "%s:\n", __FUNCTION__ );
 254
 255         sarea_priv->last_wrap++;
 256         DRM_DEBUG( "   wrap = %d\n", sarea_priv->last_wrap );
 257
 258         mga_flush_write_combine();
 259         MGA_WRITE( MGA_PRIMADDRESS, head | MGA_DMA_GENERAL );
 260
 261         clear_bit( 0, &primary->wrapped );
 262         DRM_DEBUG( "%s: done.\n", __FUNCTION__ );
 263 }
 264
 265
 266 /* ================================================================
 267  * Freelist management
 268  */
 269
 270 #define MGA_BUFFER_USED         ~0
 271 #define MGA_BUFFER_FREE         0
 272
 273 #if MGA_FREELIST_DEBUG
 274 static void mga_freelist_print( drm_device_t *dev )
 275 {
 276         drm_mga_private_t *dev_priv = dev->dev_private;
 277         drm_mga_freelist_t *entry;
 278
 279         DRM_INFO( "\n" );
 280         DRM_INFO( "current dispatch: last=0x%x done=0x%x\n",
 281                   dev_priv->sarea_priv->last_dispatch,
 282                   (unsigned int)(MGA_READ( MGA_PRIMADDRESS ) -
 283                                  dev_priv->primary->offset) );
 284         DRM_INFO( "current freelist:\n" );
 285
 286         for ( entry = dev_priv->head->next ; entry ; entry = entry->next ) {
 287                 DRM_INFO( "   %p   idx=%2d  age=0x%x 0x%06lx\n",
 288                           entry, entry->buf->idx, entry->age.head,
 289                           entry->age.head - dev_priv->primary->offset );
 290         }
 291         DRM_INFO( "\n" );
 292 }
 293 #endif
 294
 295 static int mga_freelist_init( drm_device_t *dev, drm_mga_private_t *dev_priv )
 296 {
 297         drm_device_dma_t *dma = dev->dma;
 298         drm_buf_t *buf;
 299         drm_mga_buf_priv_t *buf_priv;
 300         drm_mga_freelist_t *entry;
 301         int i;
 302         DRM_DEBUG( "%s: count=%d\n",
 303                    __FUNCTION__, dma->buf_count );
 304
 305         dev_priv->head = DRM(alloc)( sizeof(drm_mga_freelist_t),
 306                                      DRM_MEM_DRIVER );
 307         if ( dev_priv->head == NULL )
 308                 DRM_OS_RETURN(ENOMEM);
 309
 310         memset( dev_priv->head, 0, sizeof(drm_mga_freelist_t) );
 311         SET_AGE( &dev_priv->head->age, MGA_BUFFER_USED, 0 );
 312
 313         for ( i = 0 ; i < dma->buf_count ; i++ ) {
 314                 buf = dma->buflist[i];
 315                 buf_priv = buf->dev_private;
 316
 317                 entry = DRM(alloc)( sizeof(drm_mga_freelist_t),
 318                                     DRM_MEM_DRIVER );
 319                 if ( entry == NULL )
 320                         DRM_OS_RETURN(ENOMEM);
 321
 322                 memset( entry, 0, sizeof(drm_mga_freelist_t) );
 323
 324                 entry->next = dev_priv->head->next;
 325                 entry->prev = dev_priv->head;
 326                 SET_AGE( &entry->age, MGA_BUFFER_FREE, 0 );
 327                 entry->buf = buf;
 328
 329                 if ( dev_priv->head->next != NULL )
 330                         dev_priv->head->next->prev = entry;
 331                 if ( entry->next == NULL )
 332                         dev_priv->tail = entry;
 333
 334                 buf_priv->list_entry = entry;
 335                 buf_priv->discard = 0;
 336                 buf_priv->dispatched = 0;
 337
 338                 dev_priv->head->next = entry;
 339         }
 340
 341         return 0;
 342 }
 343
 344 static void mga_freelist_cleanup( drm_device_t *dev )
 345 {
 346         drm_mga_private_t *dev_priv = dev->dev_private;
 347         drm_mga_freelist_t *entry;
 348         drm_mga_freelist_t *next;
 349         DRM_DEBUG( "%s\n", __FUNCTION__ );
 350
 351         entry = dev_priv->head;
 352         while ( entry ) {
 353                 next = entry->next;
 354                 DRM(free)( entry, sizeof(drm_mga_freelist_t), DRM_MEM_DRIVER );
 355                 entry = next;
 356         }
 357
 358         dev_priv->head = dev_priv->tail = NULL;
 359 }
 360
 361 #if 0
 362 /* FIXME: Still needed?
 363  */
 364 static void mga_freelist_reset( drm_device_t *dev )
 365 {
 366         drm_device_dma_t *dma = dev->dma;
 367         drm_buf_t *buf;
 368         drm_mga_buf_priv_t *buf_priv;
 369         int i;
 370
 371         for ( i = 0 ; i < dma->buf_count ; i++ ) {
 372                 buf = dma->buflist[i];
 373                 buf_priv = buf->dev_private;
 374                 SET_AGE( &buf_priv->list_entry->age,
 375                          MGA_BUFFER_FREE, 0 );
 376         }
 377 }
 378 #endif
 379
 380 static drm_buf_t *mga_freelist_get( drm_device_t *dev )
 381 {
 382         drm_mga_private_t *dev_priv = dev->dev_private;
 383         drm_mga_freelist_t *next;
 384         drm_mga_freelist_t *prev;
 385         drm_mga_freelist_t *tail = dev_priv->tail;
 386         u32 head, wrap;
 387         DRM_DEBUG( "%s:\n", __FUNCTION__ );
 388
 389         head = MGA_READ( MGA_PRIMADDRESS );
 390         wrap = dev_priv->sarea_priv->last_wrap;
 391
 392         DRM_DEBUG( "   tail=0x%06lx %d\n",
 393                    tail->age.head ?
 394                    tail->age.head - dev_priv->primary->offset : 0,
 395                    tail->age.wrap );
 396         DRM_DEBUG( "   head=0x%06lx %d\n",
 397                    head - dev_priv->primary->offset, wrap );
 398
 399         if ( TEST_AGE( &tail->age, head, wrap ) ) {
 400                 prev = dev_priv->tail->prev;
 401                 next = dev_priv->tail;
 402                 prev->next = NULL;
 403                 next->prev = next->next = NULL;
 404                 dev_priv->tail = prev;
 405                 SET_AGE( &next->age, MGA_BUFFER_USED, 0 );
 406                 return next->buf;
 407         }
 408
 409         DRM_DEBUG( "returning NULL!\n" );
 410         return NULL;
 411 }
 412
 413 int mga_freelist_put( drm_device_t *dev, drm_buf_t *buf )
 414 {
 415         drm_mga_private_t *dev_priv = dev->dev_private;
 416         drm_mga_buf_priv_t *buf_priv = buf->dev_private;
 417         drm_mga_freelist_t *head, *entry, *prev;
 418
 419         DRM_DEBUG( "%s: age=0x%06lx wrap=%d\n",
 420                    __FUNCTION__,
 421                    buf_priv->list_entry->age.head -
 422                    dev_priv->primary->offset,
 423                    buf_priv->list_entry->age.wrap );
 424
 425         entry = buf_priv->list_entry;
 426         head = dev_priv->head;
 427
 428         if ( buf_priv->list_entry->age.head == MGA_BUFFER_USED ) {
 429                 SET_AGE( &entry->age, MGA_BUFFER_FREE, 0 );
 430                 prev = dev_priv->tail;
 431                 prev->next = entry;
 432                 entry->prev = prev;
 433                 entry->next = NULL;
 434         } else {
 435                 prev = head->next;
 436                 head->next = entry;
 437                 prev->prev = entry;
 438                 entry->prev = head;
 439                 entry->next = prev;
 440         }
 441
 442         return 0;
 443 }
 444
 445
 446 /* ================================================================
 447  * DMA initialization, cleanup
 448  */
 449
 450 static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
 451 {
 452         drm_mga_private_t *dev_priv;
 453         drm_map_list_entry_t *listentry;
 454         int ret;
 455         DRM_DEBUG( "%s\n", __FUNCTION__ );
 456
 457         dev_priv = DRM(alloc)( sizeof(drm_mga_private_t), DRM_MEM_DRIVER );
 458         if ( !dev_priv )
 459                 DRM_OS_RETURN(ENOMEM);
 460
 461         memset( dev_priv, 0, sizeof(drm_mga_private_t) );
 462
 463         dev_priv->chipset = init->chipset;
 464
 465         dev_priv->usec_timeout = MGA_DEFAULT_USEC_TIMEOUT;
 466
 467         if ( init->sgram ) {
 468                 dev_priv->clear_cmd = MGA_DWGCTL_CLEAR | MGA_ATYPE_BLK;
 469         } else {
 470                 dev_priv->clear_cmd = MGA_DWGCTL_CLEAR | MGA_ATYPE_RSTR;
 471         }
 472         dev_priv->maccess       = init->maccess;
 473
 474         dev_priv->fb_cpp        = init->fb_cpp;
 475         dev_priv->front_offset  = init->front_offset;
 476         dev_priv->front_pitch   = init->front_pitch;
 477         dev_priv->back_offset   = init->back_offset;
 478         dev_priv->back_pitch    = init->back_pitch;
 479
 480         dev_priv->depth_cpp     = init->depth_cpp;
 481         dev_priv->depth_offset  = init->depth_offset;
 482         dev_priv->depth_pitch   = init->depth_pitch;
 483
 484         /* FIXME: Need to support AGP textures...
 485          */
 486         dev_priv->texture_offset = init->texture_offset[0];
 487         dev_priv->texture_size = init->texture_size[0];
 488
 489         TAILQ_FOREACH(listentry, dev->maplist, link) {
 490                 drm_map_t *map = listentry->map;
 491                 if (map->type == _DRM_SHM &&
 492                         map->flags & _DRM_CONTAINS_LOCK) {
 493                         dev_priv->sarea = map;
 494                         break;
 495                 }
 496         }
 497
 498         if(!dev_priv->sarea) {
 499                 DRM_ERROR( "failed to find sarea!\n" );
 500                 /* Assign dev_private so we can do cleanup. */
 501                 dev->dev_private = (void *)dev_priv;
 502                 mga_do_cleanup_dma( dev );
 503                 DRM_OS_RETURN(EINVAL);
 504         }
 505
 506
 507         DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
 508         if(!dev_priv->fb) {
 509                 DRM_ERROR( "failed to find framebuffer!\n" );
 510                 /* Assign dev_private so we can do cleanup. */
 511                 dev->dev_private = (void *)dev_priv;
 512                 mga_do_cleanup_dma( dev );
 513                 DRM_OS_RETURN(EINVAL);
 514         }
 515         DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
 516         if(!dev_priv->mmio) {
 517                 DRM_ERROR( "failed to find mmio region!\n" );
 518                 /* Assign dev_private so we can do cleanup. */
 519                 dev->dev_private = (void *)dev_priv;
 520                 mga_do_cleanup_dma( dev );
 521                 DRM_OS_RETURN(EINVAL);
 522         }
 523         DRM_FIND_MAP( dev_priv->status, init->status_offset );
 524         if(!dev_priv->status) {
 525                 DRM_ERROR( "failed to find status page!\n" );
 526                 /* Assign dev_private so we can do cleanup. */
 527                 dev->dev_private = (void *)dev_priv;
 528                 mga_do_cleanup_dma( dev );
 529                 DRM_OS_RETURN(EINVAL);
 530         }
 531         DRM_FIND_MAP( dev_priv->warp, init->warp_offset );
 532         if(!dev_priv->warp) {
 533                 DRM_ERROR( "failed to find warp microcode region!\n" );
 534                 /* Assign dev_private so we can do cleanup. */
 535                 dev->dev_private = (void *)dev_priv;
 536                 mga_do_cleanup_dma( dev );
 537                 DRM_OS_RETURN(EINVAL);
 538         }
 539         DRM_FIND_MAP( dev_priv->primary, init->primary_offset );
 540         if(!dev_priv->primary) {
 541                 DRM_ERROR( "failed to find primary dma region!\n" );
 542                 /* Assign dev_private so we can do cleanup. */
 543                 dev->dev_private = (void *)dev_priv;
 544                 mga_do_cleanup_dma( dev );
 545                 DRM_OS_RETURN(EINVAL);
 546         }
 547         DRM_FIND_MAP( dev_priv->buffers, init->buffers_offset );
 548         if(!dev_priv->buffers) {
 549                 DRM_ERROR( "failed to find dma buffer region!\n" );
 550                 /* Assign dev_private so we can do cleanup. */
 551                 dev->dev_private = (void *)dev_priv;
 552                 mga_do_cleanup_dma( dev );
 553                 DRM_OS_RETURN(EINVAL);
 554         }
 555
 556         dev_priv->sarea_priv =
 557                 (drm_mga_sarea_t *)((u8 *)dev_priv->sarea->handle +
 558                                     init->sarea_priv_offset);
 559
 560         DRM_IOREMAP( dev_priv->warp );
 561         DRM_IOREMAP( dev_priv->primary );
 562         DRM_IOREMAP( dev_priv->buffers );
 563
 564         if(!dev_priv->warp->handle ||
 565            !dev_priv->primary->handle ||
 566            !dev_priv->buffers->handle ) {
 567                 DRM_ERROR( "failed to ioremap agp regions!\n" );
 568                 /* Assign dev_private so we can do cleanup. */
 569                 dev->dev_private = (void *)dev_priv;
 570                 mga_do_cleanup_dma( dev );
 571                 DRM_OS_RETURN(ENOMEM);
 572         }
 573
 574         ret = mga_warp_install_microcode( dev_priv );
 575         if ( ret < 0 ) {
 576                 DRM_ERROR( "failed to install WARP ucode!\n" );
 577                 /* Assign dev_private so we can do cleanup. */
 578                 dev->dev_private = (void *)dev_priv;
 579                 mga_do_cleanup_dma( dev );
 580                 DRM_OS_RETURN(ret);
 581         }
 582
 583         ret = mga_warp_init( dev_priv );
 584         if ( ret < 0 ) {
 585                 DRM_ERROR( "failed to init WARP engine!\n" );
 586                 /* Assign dev_private so we can do cleanup. */
 587                 dev->dev_private = (void *)dev_priv;
 588                 mga_do_cleanup_dma( dev );
 589                 DRM_OS_RETURN(ret);
 590         }
 591
 592         dev_priv->prim.status = (u32 *)dev_priv->status->handle;
 593
 594         mga_do_wait_for_idle( dev_priv );
 595
 596         /* Init the primary DMA registers.
 597          */
 598         MGA_WRITE( MGA_PRIMADDRESS,
 599                    dev_priv->primary->offset | MGA_DMA_GENERAL );
 600 #if 0
 601         MGA_WRITE( MGA_PRIMPTR,
 602                    virt_to_bus((void *)dev_priv->prim.status) |
 603                    MGA_PRIMPTREN0 |     /* Soft trap, SECEND, SETUPEND */
 604                    MGA_PRIMPTREN1 );    /* DWGSYNC */
 605 #endif
 606
 607         dev_priv->prim.start = (u8 *)dev_priv->primary->handle;
 608         dev_priv->prim.end = ((u8 *)dev_priv->primary->handle
 609                               + dev_priv->primary->size);
 610         dev_priv->prim.size = dev_priv->primary->size;
 611
 612         dev_priv->prim.tail = 0;
 613         dev_priv->prim.space = dev_priv->prim.size;
 614         dev_priv->prim.wrapped = 0;
 615
 616         dev_priv->prim.last_flush = 0;
 617         dev_priv->prim.last_wrap = 0;
 618
 619         dev_priv->prim.high_mark = 256 * DMA_BLOCK_SIZE;
 620
 621
 622         dev_priv->prim.status[0] = dev_priv->primary->offset;
 623         dev_priv->prim.status[1] = 0;
 624
 625         dev_priv->sarea_priv->last_wrap = 0;
 626         dev_priv->sarea_priv->last_frame.head = 0;
 627         dev_priv->sarea_priv->last_frame.wrap = 0;
 628
 629         if ( mga_freelist_init( dev, dev_priv ) < 0 ) {
 630                 DRM_ERROR( "could not initialize freelist\n" );
 631                 /* Assign dev_private so we can do cleanup. */
 632                 dev->dev_private = (void *)dev_priv;
 633                 mga_do_cleanup_dma( dev );
 634                 DRM_OS_RETURN(ENOMEM);
 635         }
 636
 637         /* Make dev_private visable to others. */
 638         dev->dev_private = (void *)dev_priv;
 639         return 0;
 640 }
 641
 642 int mga_do_cleanup_dma( drm_device_t *dev )
 643 {
 644         DRM_DEBUG( "%s\n", __FUNCTION__ );
 645
 646         if ( dev->dev_private ) {
 647                 drm_mga_private_t *dev_priv = dev->dev_private;
 648
 649                 DRM_IOREMAPFREE( dev_priv->warp );
 650                 DRM_IOREMAPFREE( dev_priv->primary );
 651                 DRM_IOREMAPFREE( dev_priv->buffers );
 652
 653                 if ( dev_priv->head != NULL ) {
 654                         mga_freelist_cleanup( dev );
 655                 }
 656
 657                 DRM(free)( dev->dev_private, sizeof(drm_mga_private_t),
 658                            DRM_MEM_DRIVER );
 659                 dev->dev_private = NULL;
 660         }
 661
 662         return 0;
 663 }
 664
 665 int mga_dma_init( DRM_OS_IOCTL )
 666 {
 667         DRM_OS_DEVICE;
 668         drm_mga_init_t init;
 669
 670         DRM_OS_KRNFROMUSR( init, (drm_mga_init_t *) data, sizeof(init) );
 671
 672         switch ( init.func ) {
 673         case MGA_INIT_DMA:
 674                 return mga_do_init_dma( dev, &init );
 675         case MGA_CLEANUP_DMA:
 676                 return mga_do_cleanup_dma( dev );
 677         }
 678
 679         DRM_OS_RETURN( EINVAL );
 680 }
 681
 682
 683 /* ================================================================
 684  * Primary DMA stream management
 685  */
 686
 687 int mga_dma_flush( DRM_OS_IOCTL )
 688 {
 689         DRM_OS_DEVICE;
 690         drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
 691         drm_lock_t lock;
 692
 693         LOCK_TEST_WITH_RETURN( dev );
 694
 695         DRM_OS_KRNFROMUSR( lock, (drm_lock_t *) data, sizeof(lock) );
 696
 697         DRM_DEBUG( "%s: %s%s%s\n",
 698                    __FUNCTION__,
 699                    (lock.flags & _DRM_LOCK_FLUSH) ?     "flush, " : "",
 700                    (lock.flags & _DRM_LOCK_FLUSH_ALL) ? "flush all, " : "",
 701                    (lock.flags & _DRM_LOCK_QUIESCENT) ? "idle, " : "" );
 702
 703         WRAP_WAIT_WITH_RETURN( dev_priv );
 704
 705         if ( lock.flags & (_DRM_LOCK_FLUSH | _DRM_LOCK_FLUSH_ALL) ) {
 706                 mga_do_dma_flush( dev_priv );
 707         }
 708
 709         if ( lock.flags & _DRM_LOCK_QUIESCENT ) {
 710 #if MGA_DMA_DEBUG
 711                 int ret = mga_do_wait_for_idle( dev_priv );
 712                 if ( ret )
 713                         DRM_INFO( __FUNCTION__": -EBUSY\n" );
 714                 return ret;
 715 #else
 716                 return mga_do_wait_for_idle( dev_priv );
 717 #endif
 718         } else {
 719                 return 0;
 720         }
 721 }
 722
 723 int mga_dma_reset( DRM_OS_IOCTL )
 724 {
 725         DRM_OS_DEVICE;
 726         drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
 727
 728         LOCK_TEST_WITH_RETURN( dev );
 729
 730         return mga_do_dma_reset( dev_priv );
 731 }
 732
 733
 734 /* ================================================================
 735  * DMA buffer management
 736  */
 737
 738 #if 0
 739 static int mga_dma_get_buffers( drm_device_t *dev, drm_dma_t *d )
 740 {
 741         drm_buf_t *buf;
 742         int i;
 743
 744         for ( i = d->granted_count ; i < d->request_count ; i++ ) {
 745                 buf = mga_freelist_get( dev );
 746                 if ( !buf )
 747                         DRM_OS_RETURN( EAGAIN );
 748
 749                 buf->pid = current->pid;
 750
 751                 if ( DRM_OS_COPYTOUSR( &d->request_indices[i],
 752                                    &buf->idx, sizeof(buf->idx) ) )
 753                         DRM_OS_RETURN( EFAULT );
 754                 if ( DRM_OS_COPYTOUSR( &d->request_sizes[i],
 755                                    &buf->total, sizeof(buf->total) ) )
 756                         DRM_OS_RETURN( EFAULT );
 757
 758                 d->granted_count++;
 759         }
 760         return 0;
 761 }
 762 #endif /* 0 */
 763
 764 int mga_dma_buffers( DRM_OS_IOCTL )
 765 {
 766         DRM_OS_DEVICE;
 767         drm_device_dma_t *dma = dev->dma;
 768         drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
 769         drm_dma_t d;
 770         drm_buf_t *buf;
 771         int i;
 772         int ret = 0;
 773
 774         LOCK_TEST_WITH_RETURN( dev );
 775
 776         DRM_OS_KRNFROMUSR( d, (drm_dma_t *) data, sizeof(d) );
 777
 778         /* Please don't send us buffers.
 779          */
 780         if ( d.send_count != 0 ) {
 781                 DRM_ERROR( "Process %d trying to send %d buffers via drmDMA\n",
 782                            DRM_OS_CURRENTPID, d.send_count );
 783                 DRM_OS_RETURN( EINVAL );
 784         }
 785
 786         /* We'll send you buffers.
 787          */
 788         if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
 789                 DRM_ERROR( "Process %d trying to get %d buffers (of %d max)\n",
 790                            DRM_OS_CURRENTPID, d.request_count, dma->buf_count );
 791                 DRM_OS_RETURN( EINVAL );
 792         }
 793
 794         WRAP_TEST_WITH_RETURN( dev_priv );
 795
 796         d.granted_count = 0;
 797
 798         if ( d.request_count ) {
 799                 for ( i = d.granted_count ; i < d.request_count ; i++ ) {
 800                         buf = mga_freelist_get( dev );
 801                         if ( !buf )
 802                                 DRM_OS_RETURN( EAGAIN );
 803
 804                         buf->pid = DRM_OS_CURRENTPID;
 805
 806                         if ( DRM_OS_COPYTOUSR( &d.request_indices[i],
 807                                            &buf->idx, sizeof(buf->idx) ) )
 808                                 DRM_OS_RETURN( EFAULT );
 809                         if ( DRM_OS_COPYTOUSR( &d.request_sizes[i],
 810                                            &buf->total, sizeof(buf->total) ) )
 811                                 DRM_OS_RETURN( EFAULT );
 812
 813                         d.granted_count++;
 814                 }
 815                 ret = 0;
 816         }
 817
 818         DRM_OS_KRNTOUSR( (drm_dma_t *) data, d, sizeof(d) );
 819
 820         return ret;
 821 }