linux/i810_dma.c

   1 /* i810_dma.c -- DMA support for the i810 -*- 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: Rickard E. (Rik) Faith <faith@valinux.com>
  28  *          Jeff Hartmann <jhartmann@valinux.com>
  29  *          Keith Whitwell <keithw@valinux.com>
  30  *
  31  */
  32
  33 #define __NO_VERSION__
  34 #include "i810.h"
  35 #include "drmP.h"
  36 #include "i810_drv.h"
  37 #include <linux/interrupt.h>    /* For task queue support */
  38
  39 /* in case we don't have a 2.3.99-pre6 kernel or later: */
  40 #ifndef VM_DONTCOPY
  41 #define VM_DONTCOPY 0
  42 #endif
  43
  44 #define I810_BUF_FREE           2
  45 #define I810_BUF_CLIENT         1
  46 #define I810_BUF_HARDWARE       0
  47
  48 #define I810_BUF_UNMAPPED 0
  49 #define I810_BUF_MAPPED   1
  50
  51 #define RING_LOCALS     unsigned int outring, ringmask; volatile char *virt;
  52
  53 #define BEGIN_LP_RING(n) do {                           \
  54         if (I810_VERBOSE)                               \
  55                 DRM_DEBUG("BEGIN_LP_RING(%d) in %s\n",  \
  56                           n, __FUNCTION__);             \
  57         if (dev_priv->ring.space < n*4)                 \
  58                 i810_wait_ring(dev, n*4);               \
  59         dev_priv->ring.space -= n*4;                    \
  60         outring = dev_priv->ring.tail;                  \
  61         ringmask = dev_priv->ring.tail_mask;            \
  62         virt = dev_priv->ring.virtual_start;            \
  63 } while (0)
  64
  65 #define ADVANCE_LP_RING() do {                                  \
  66         if (I810_VERBOSE) DRM_DEBUG("ADVANCE_LP_RING\n");       \
  67         dev_priv->ring.tail = outring;                          \
  68         I810_WRITE(LP_RING + RING_TAIL, outring);               \
  69 } while(0)
  70
  71 #define OUT_RING(n) do {                                                \
  72         if (I810_VERBOSE) DRM_DEBUG("   OUT_RING %x\n", (int)(n));      \
  73         *(volatile unsigned int *)(virt + outring) = n;                 \
  74         outring += 4;                                                   \
  75         outring &= ringmask;                                            \
  76 } while (0);
  77
  78 static inline void i810_print_status_page(drm_device_t *dev)
  79 {
  80         drm_device_dma_t *dma = dev->dma;
  81         drm_i810_private_t *dev_priv = dev->dev_private;
  82         u32 *temp = (u32 *)dev_priv->hw_status_page;
  83         int i;
  84
  85         DRM_DEBUG(  "hw_status: Interrupt Status : %x\n", temp[0]);
  86         DRM_DEBUG(  "hw_status: LpRing Head ptr : %x\n", temp[1]);
  87         DRM_DEBUG(  "hw_status: IRing Head ptr : %x\n", temp[2]);
  88         DRM_DEBUG(  "hw_status: Reserved : %x\n", temp[3]);
  89         DRM_DEBUG(  "hw_status: Driver Counter : %d\n", temp[5]);
  90         for(i = 6; i < dma->buf_count + 6; i++) {
  91                 DRM_DEBUG( "buffer status idx : %d used: %d\n", i - 6, temp[i]);
  92         }
  93 }
  94
  95 static drm_buf_t *i810_freelist_get(drm_device_t *dev)
  96 {
  97         drm_device_dma_t *dma = dev->dma;
  98         int              i;
  99         int              used;
 100
 101         /* Linear search might not be the best solution */
 102
 103         for (i = 0; i < dma->buf_count; i++) {
 104                 drm_buf_t *buf = dma->buflist[ i ];
 105                 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 106                 /* In use is already a pointer */
 107                 used = cmpxchg(buf_priv->in_use, I810_BUF_FREE,
 108                                I810_BUF_CLIENT);
 109                 if(used == I810_BUF_FREE) {
 110                         return buf;
 111                 }
 112         }
 113         return NULL;
 114 }
 115
 116 /* This should only be called if the buffer is not sent to the hardware
 117  * yet, the hardware updates in use for us once its on the ring buffer.
 118  */
 119
 120 static int i810_freelist_put(drm_device_t *dev, drm_buf_t *buf)
 121 {
 122         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 123         int used;
 124
 125         /* In use is already a pointer */
 126         used = cmpxchg(buf_priv->in_use, I810_BUF_CLIENT, I810_BUF_FREE);
 127         if(used != I810_BUF_CLIENT) {
 128                 DRM_ERROR("Freeing buffer thats not in use : %d\n", buf->idx);
 129                 return -EINVAL;
 130         }
 131
 132         return 0;
 133 }
 134
 135 static struct file_operations i810_buffer_fops = {
 136         open:    DRM(open),
 137         flush:   DRM(flush),
 138         release: DRM(release),
 139         ioctl:   DRM(ioctl),
 140         mmap:    i810_mmap_buffers,
 141         read:    DRM(read),
 142         fasync:  DRM(fasync),
 143         poll:    DRM(poll),
 144 };
 145
 146 int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
 147 {
 148         drm_file_t          *priv         = filp->private_data;
 149         drm_device_t        *dev;
 150         drm_i810_private_t  *dev_priv;
 151         drm_buf_t           *buf;
 152         drm_i810_buf_priv_t *buf_priv;
 153
 154         lock_kernel();
 155         dev      = priv->dev;
 156         dev_priv = dev->dev_private;
 157         buf      = dev_priv->mmap_buffer;
 158         buf_priv = buf->dev_private;
 159
 160         vma->vm_flags |= (VM_IO | VM_DONTCOPY);
 161         vma->vm_file = filp;
 162
 163         buf_priv->currently_mapped = I810_BUF_MAPPED;
 164         unlock_kernel();
 165
 166         if (remap_page_range(vma->vm_start,
 167                              VM_OFFSET(vma),
 168                              vma->vm_end - vma->vm_start,
 169                              vma->vm_page_prot)) return -EAGAIN;
 170         return 0;
 171 }
 172
 173 static int i810_map_buffer(drm_buf_t *buf, struct file *filp)
 174 {
 175         drm_file_t        *priv   = filp->private_data;
 176         drm_device_t      *dev    = priv->dev;
 177         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 178         drm_i810_private_t *dev_priv = dev->dev_private;
 179         struct file_operations *old_fops;
 180         int retcode = 0;
 181
 182         if(buf_priv->currently_mapped == I810_BUF_MAPPED) return -EINVAL;
 183
 184         if(VM_DONTCOPY != 0) {
 185                 down(&current->mm->mmap_sem);
 186                 old_fops = filp->f_op;
 187                 filp->f_op = &i810_buffer_fops;
 188                 dev_priv->mmap_buffer = buf;
 189                 buf_priv->virtual = (void *)do_mmap(filp, 0, buf->total,
 190                                                     PROT_READ|PROT_WRITE,
 191                                                     MAP_SHARED,
 192                                                     buf->bus_address);
 193                 dev_priv->mmap_buffer = NULL;
 194                 filp->f_op = old_fops;
 195                 if ((unsigned long)buf_priv->virtual > -1024UL) {
 196                         /* Real error */
 197                         DRM_DEBUG("mmap error\n");
 198                         retcode = (signed int)buf_priv->virtual;
 199                         buf_priv->virtual = 0;
 200                 }
 201                 up(&current->mm->mmap_sem);
 202         } else {
 203                 buf_priv->virtual = buf_priv->kernel_virtual;
 204                 buf_priv->currently_mapped = I810_BUF_MAPPED;
 205         }
 206         return retcode;
 207 }
 208
 209 static int i810_unmap_buffer(drm_buf_t *buf)
 210 {
 211         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 212         int retcode = 0;
 213
 214         if(VM_DONTCOPY != 0) {
 215                 if(buf_priv->currently_mapped != I810_BUF_MAPPED)
 216                         return -EINVAL;
 217                 down(&current->mm->mmap_sem);
 218 #if LINUX_VERSION_CODE < 0x020399
 219                 retcode = do_munmap((unsigned long)buf_priv->virtual,
 220                                     (size_t) buf->total);
 221 #else
 222                 retcode = do_munmap(current->mm,
 223                                     (unsigned long)buf_priv->virtual,
 224                                     (size_t) buf->total);
 225 #endif
 226                 up(&current->mm->mmap_sem);
 227         }
 228         buf_priv->currently_mapped = I810_BUF_UNMAPPED;
 229         buf_priv->virtual = 0;
 230
 231         return retcode;
 232 }
 233
 234 static int i810_dma_get_buffer(drm_device_t *dev, drm_i810_dma_t *d,
 235                                struct file *filp)
 236 {
 237         drm_file_t        *priv   = filp->private_data;
 238         drm_buf_t         *buf;
 239         drm_i810_buf_priv_t *buf_priv;
 240         int retcode = 0;
 241
 242         buf = i810_freelist_get(dev);
 243         if (!buf) {
 244                 retcode = -ENOMEM;
 245                 DRM_DEBUG("retcode=%d\n", retcode);
 246                 return retcode;
 247         }
 248
 249         retcode = i810_map_buffer(buf, filp);
 250         if(retcode) {
 251                 i810_freelist_put(dev, buf);
 252                 DRM_DEBUG("mapbuf failed, retcode %d\n", retcode);
 253                 return retcode;
 254         }
 255         buf->pid     = priv->pid;
 256         buf_priv = buf->dev_private;
 257         d->granted = 1;
 258         d->request_idx = buf->idx;
 259         d->request_size = buf->total;
 260         d->virtual = buf_priv->virtual;
 261
 262         return retcode;
 263 }
 264
 265 static unsigned long i810_alloc_page(drm_device_t *dev)
 266 {
 267         unsigned long address;
 268
 269         address = __get_free_page(GFP_KERNEL);
 270         if(address == 0UL)
 271                 return 0;
 272
 273         atomic_inc(&virt_to_page(address)->count);
 274         set_bit(PG_locked, &virt_to_page(address)->flags);
 275
 276         return address;
 277 }
 278
 279 static void i810_free_page(drm_device_t *dev, unsigned long page)
 280 {
 281         if(page == 0UL)
 282                 return;
 283
 284         atomic_dec(&virt_to_page(page)->count);
 285         clear_bit(PG_locked, &virt_to_page(page)->flags);
 286         wake_up(&virt_to_page(page)->wait);
 287         free_page(page);
 288         return;
 289 }
 290
 291 static int i810_dma_cleanup(drm_device_t *dev)
 292 {
 293         drm_device_dma_t *dma = dev->dma;
 294
 295         if(dev->dev_private) {
 296                 int i;
 297                 drm_i810_private_t *dev_priv =
 298                         (drm_i810_private_t *) dev->dev_private;
 299
 300                 if(dev_priv->ring.virtual_start) {
 301                         DRM(ioremapfree)((void *) dev_priv->ring.virtual_start,
 302                                          dev_priv->ring.Size);
 303                 }
 304                 if(dev_priv->hw_status_page != 0UL) {
 305                         i810_free_page(dev, dev_priv->hw_status_page);
 306                         /* Need to rewrite hardware status page */
 307                         I810_WRITE(0x02080, 0x1ffff000);
 308                 }
 309                 DRM(free)(dev->dev_private, sizeof(drm_i810_private_t),
 310                          DRM_MEM_DRIVER);
 311                 dev->dev_private = NULL;
 312
 313                 for (i = 0; i < dma->buf_count; i++) {
 314                         drm_buf_t *buf = dma->buflist[ i ];
 315                         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 316                         DRM(ioremapfree)(buf_priv->kernel_virtual, buf->total);
 317                 }
 318         }
 319         return 0;
 320 }
 321
 322 static int i810_wait_ring(drm_device_t *dev, int n)
 323 {
 324         drm_i810_private_t *dev_priv = dev->dev_private;
 325         drm_i810_ring_buffer_t *ring = &(dev_priv->ring);
 326         int iters = 0;
 327         unsigned long end;
 328         unsigned int last_head = I810_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
 329
 330         end = jiffies + (HZ*3);
 331         while (ring->space < n) {
 332                 int i;
 333
 334                 ring->head = I810_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
 335                 ring->space = ring->head - (ring->tail+8);
 336                 if (ring->space < 0) ring->space += ring->Size;
 337
 338                 if (ring->head != last_head)
 339                    end = jiffies + (HZ*3);
 340
 341                 iters++;
 342                 if((signed)(end - jiffies) <= 0) {
 343                         DRM_ERROR("space: %d wanted %d\n", ring->space, n);
 344                         DRM_ERROR("lockup\n");
 345                         goto out_wait_ring;
 346                 }
 347
 348                 for (i = 0 ; i < 2000 ; i++) ;
 349         }
 350
 351 out_wait_ring:
 352         return iters;
 353 }
 354
 355 static void i810_kernel_lost_context(drm_device_t *dev)
 356 {
 357         drm_i810_private_t *dev_priv = dev->dev_private;
 358         drm_i810_ring_buffer_t *ring = &(dev_priv->ring);
 359
 360         ring->head = I810_READ(LP_RING + RING_HEAD) & HEAD_ADDR;
 361         ring->tail = I810_READ(LP_RING + RING_TAIL);
 362         ring->space = ring->head - (ring->tail+8);
 363         if (ring->space < 0) ring->space += ring->Size;
 364 }
 365
 366 static int i810_freelist_init(drm_device_t *dev)
 367 {
 368         drm_device_dma_t *dma = dev->dma;
 369         drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
 370         int my_idx = 24;
 371         u32 *hw_status = (u32 *)(dev_priv->hw_status_page + my_idx);
 372         int i;
 373
 374         if(dma->buf_count > 1019) {
 375                 /* Not enough space in the status page for the freelist */
 376                 return -EINVAL;
 377         }
 378
 379         for (i = 0; i < dma->buf_count; i++) {
 380                 drm_buf_t *buf = dma->buflist[ i ];
 381                 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 382
 383                 buf_priv->in_use = hw_status++;
 384                 buf_priv->my_use_idx = my_idx;
 385                 my_idx += 4;
 386
 387                 *buf_priv->in_use = I810_BUF_FREE;
 388
 389                 buf_priv->kernel_virtual = DRM(ioremap)(buf->bus_address,
 390                                                         buf->total);
 391         }
 392         return 0;
 393 }
 394
 395 static int i810_dma_initialize(drm_device_t *dev,
 396                                drm_i810_private_t *dev_priv,
 397                                drm_i810_init_t *init)
 398 {
 399         drm_map_t *sarea_map;
 400
 401         dev->dev_private = (void *) dev_priv;
 402         memset(dev_priv, 0, sizeof(drm_i810_private_t));
 403
 404         if (init->ring_map_idx >= dev->map_count ||
 405             init->buffer_map_idx >= dev->map_count) {
 406                 i810_dma_cleanup(dev);
 407                 DRM_ERROR("ring_map or buffer_map are invalid\n");
 408                 return -EINVAL;
 409         }
 410
 411         dev_priv->ring_map_idx = init->ring_map_idx;
 412         dev_priv->buffer_map_idx = init->buffer_map_idx;
 413         sarea_map = dev->maplist[0];
 414         dev_priv->sarea_priv = (drm_i810_sarea_t *)
 415                 ((u8 *)sarea_map->handle +
 416                  init->sarea_priv_offset);
 417
 418         atomic_set(&dev_priv->flush_done, 0);
 419         init_waitqueue_head(&dev_priv->flush_queue);
 420
 421         dev_priv->ring.Start = init->ring_start;
 422         dev_priv->ring.End = init->ring_end;
 423         dev_priv->ring.Size = init->ring_size;
 424
 425         dev_priv->ring.virtual_start = DRM(ioremap)(dev->agp->base +
 426                                                     init->ring_start,
 427                                                     init->ring_size);
 428
 429         dev_priv->ring.tail_mask = dev_priv->ring.Size - 1;
 430
 431         if (dev_priv->ring.virtual_start == NULL) {
 432                 i810_dma_cleanup(dev);
 433                 DRM_ERROR("can not ioremap virtual address for"
 434                           " ring buffer\n");
 435                 return -ENOMEM;
 436         }
 437
 438         dev_priv->w = init->w;
 439         dev_priv->h = init->h;
 440         dev_priv->pitch = init->pitch;
 441         dev_priv->back_offset = init->back_offset;
 442         dev_priv->depth_offset = init->depth_offset;
 443
 444         dev_priv->front_di1 = init->front_offset | init->pitch_bits;
 445         dev_priv->back_di1 = init->back_offset | init->pitch_bits;
 446         dev_priv->zi1 = init->depth_offset | init->pitch_bits;
 447
 448
 449         /* Program Hardware Status Page */
 450         dev_priv->hw_status_page = i810_alloc_page(dev);
 451         memset((void *) dev_priv->hw_status_page, 0, PAGE_SIZE);
 452         if(dev_priv->hw_status_page == 0UL) {
 453                 i810_dma_cleanup(dev);
 454                 DRM_ERROR("Can not allocate hardware status page\n");
 455                 return -ENOMEM;
 456         }
 457         DRM_DEBUG("hw status page @ %lx\n", dev_priv->hw_status_page);
 458
 459         I810_WRITE(0x02080, virt_to_bus((void *)dev_priv->hw_status_page));
 460         DRM_DEBUG("Enabled hardware status page\n");
 461
 462         /* Now we need to init our freelist */
 463         if(i810_freelist_init(dev) != 0) {
 464                 i810_dma_cleanup(dev);
 465                 DRM_ERROR("Not enough space in the status page for"
 466                           " the freelist\n");
 467                 return -ENOMEM;
 468         }
 469         return 0;
 470 }
 471
 472 int i810_dma_init(struct inode *inode, struct file *filp,
 473                   unsigned int cmd, unsigned long arg)
 474 {
 475         drm_file_t *priv = filp->private_data;
 476         drm_device_t *dev = priv->dev;
 477         drm_i810_private_t *dev_priv;
 478         drm_i810_init_t init;
 479         int retcode = 0;
 480
 481         if (copy_from_user(&init, (drm_i810_init_t *)arg, sizeof(init)))
 482                 return -EFAULT;
 483
 484         switch(init.func) {
 485                 case I810_INIT_DMA:
 486                         dev_priv = DRM(alloc)(sizeof(drm_i810_private_t),
 487                                              DRM_MEM_DRIVER);
 488                         if(dev_priv == NULL) return -ENOMEM;
 489                         retcode = i810_dma_initialize(dev, dev_priv, &init);
 490                 break;
 491                 case I810_CLEANUP_DMA:
 492                         retcode = i810_dma_cleanup(dev);
 493                 break;
 494                 default:
 495                         retcode = -EINVAL;
 496                 break;
 497         }
 498
 499         return retcode;
 500 }
 501
 502
 503
 504 /* Most efficient way to verify state for the i810 is as it is
 505  * emitted.  Non-conformant state is silently dropped.
 506  *
 507  * Use 'volatile' & local var tmp to force the emitted values to be
 508  * identical to the verified ones.
 509  */
 510 static void i810EmitContextVerified( drm_device_t *dev,
 511                                      volatile unsigned int *code )
 512 {
 513         drm_i810_private_t *dev_priv = dev->dev_private;
 514         int i, j = 0;
 515         unsigned int tmp;
 516         RING_LOCALS;
 517
 518         BEGIN_LP_RING( I810_CTX_SETUP_SIZE );
 519
 520         OUT_RING( GFX_OP_COLOR_FACTOR );
 521         OUT_RING( code[I810_CTXREG_CF1] );
 522
 523         OUT_RING( GFX_OP_STIPPLE );
 524         OUT_RING( code[I810_CTXREG_ST1] );
 525
 526         for ( i = 4 ; i < I810_CTX_SETUP_SIZE ; i++ ) {
 527                 tmp = code[i];
 528
 529                 if ((tmp & (7<<29)) == (3<<29) &&
 530                     (tmp & (0x1f<<24)) < (0x1d<<24))
 531                 {
 532                         OUT_RING( tmp );
 533                         j++;
 534                 }
 535         }
 536
 537         if (j & 1)
 538                 OUT_RING( 0 );
 539
 540         ADVANCE_LP_RING();
 541 }
 542
 543 static void i810EmitTexVerified( drm_device_t *dev,
 544                                  volatile unsigned int *code )
 545 {
 546         drm_i810_private_t *dev_priv = dev->dev_private;
 547         int i, j = 0;
 548         unsigned int tmp;
 549         RING_LOCALS;
 550
 551         BEGIN_LP_RING( I810_TEX_SETUP_SIZE );
 552
 553         OUT_RING( GFX_OP_MAP_INFO );
 554         OUT_RING( code[I810_TEXREG_MI1] );
 555         OUT_RING( code[I810_TEXREG_MI2] );
 556         OUT_RING( code[I810_TEXREG_MI3] );
 557
 558         for ( i = 4 ; i < I810_TEX_SETUP_SIZE ; i++ ) {
 559                 tmp = code[i];
 560
 561                 if ((tmp & (7<<29)) == (3<<29) &&
 562                     (tmp & (0x1f<<24)) < (0x1d<<24))
 563                 {
 564                         OUT_RING( tmp );
 565                         j++;
 566                 }
 567         }
 568
 569         if (j & 1)
 570                 OUT_RING( 0 );
 571
 572         ADVANCE_LP_RING();
 573 }
 574
 575
 576 /* Need to do some additional checking when setting the dest buffer.
 577  */
 578 static void i810EmitDestVerified( drm_device_t *dev,
 579                                   volatile unsigned int *code )
 580 {
 581         drm_i810_private_t *dev_priv = dev->dev_private;
 582         unsigned int tmp;
 583         RING_LOCALS;
 584
 585         BEGIN_LP_RING( I810_DEST_SETUP_SIZE + 2 );
 586
 587         tmp = code[I810_DESTREG_DI1];
 588         if (tmp == dev_priv->front_di1 || tmp == dev_priv->back_di1) {
 589                 OUT_RING( CMD_OP_DESTBUFFER_INFO );
 590                 OUT_RING( tmp );
 591         } else
 592            DRM_DEBUG("bad di1 %x (allow %x or %x)\n",
 593                      tmp, dev_priv->front_di1, dev_priv->back_di1);
 594
 595         /* invarient:
 596          */
 597         OUT_RING( CMD_OP_Z_BUFFER_INFO );
 598         OUT_RING( dev_priv->zi1 );
 599
 600         OUT_RING( GFX_OP_DESTBUFFER_VARS );
 601         OUT_RING( code[I810_DESTREG_DV1] );
 602
 603         OUT_RING( GFX_OP_DRAWRECT_INFO );
 604         OUT_RING( code[I810_DESTREG_DR1] );
 605         OUT_RING( code[I810_DESTREG_DR2] );
 606         OUT_RING( code[I810_DESTREG_DR3] );
 607         OUT_RING( code[I810_DESTREG_DR4] );
 608         OUT_RING( 0 );
 609
 610         ADVANCE_LP_RING();
 611 }
 612
 613
 614
 615 static void i810EmitState( drm_device_t *dev )
 616 {
 617         drm_i810_private_t *dev_priv = dev->dev_private;
 618         drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
 619         unsigned int dirty = sarea_priv->dirty;
 620
 621         if (dirty & I810_UPLOAD_BUFFERS) {
 622                 i810EmitDestVerified( dev, sarea_priv->BufferState );
 623                 sarea_priv->dirty &= ~I810_UPLOAD_BUFFERS;
 624         }
 625
 626         if (dirty & I810_UPLOAD_CTX) {
 627                 i810EmitContextVerified( dev, sarea_priv->ContextState );
 628                 sarea_priv->dirty &= ~I810_UPLOAD_CTX;
 629         }
 630
 631         if (dirty & I810_UPLOAD_TEX0) {
 632                 i810EmitTexVerified( dev, sarea_priv->TexState[0] );
 633                 sarea_priv->dirty &= ~I810_UPLOAD_TEX0;
 634         }
 635
 636         if (dirty & I810_UPLOAD_TEX1) {
 637                 i810EmitTexVerified( dev, sarea_priv->TexState[1] );
 638                 sarea_priv->dirty &= ~I810_UPLOAD_TEX1;
 639         }
 640 }
 641
 642
 643
 644 /* need to verify
 645  */
 646 static void i810_dma_dispatch_clear( drm_device_t *dev, int flags,
 647                                      unsigned int clear_color,
 648                                      unsigned int clear_zval )
 649 {
 650         drm_i810_private_t *dev_priv = dev->dev_private;
 651         drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
 652         int nbox = sarea_priv->nbox;
 653         drm_clip_rect_t *pbox = sarea_priv->boxes;
 654         int pitch = dev_priv->pitch;
 655         int cpp = 2;
 656         int i;
 657         RING_LOCALS;
 658
 659         i810_kernel_lost_context(dev);
 660
 661         if (nbox > I810_NR_SAREA_CLIPRECTS)
 662                 nbox = I810_NR_SAREA_CLIPRECTS;
 663
 664         for (i = 0 ; i < nbox ; i++, pbox++) {
 665                 unsigned int x = pbox->x1;
 666                 unsigned int y = pbox->y1;
 667                 unsigned int width = (pbox->x2 - x) * cpp;
 668                 unsigned int height = pbox->y2 - y;
 669                 unsigned int start = y * pitch + x * cpp;
 670
 671                 if (pbox->x1 > pbox->x2 ||
 672                     pbox->y1 > pbox->y2 ||
 673                     pbox->x2 > dev_priv->w ||
 674                     pbox->y2 > dev_priv->h)
 675                         continue;
 676
 677                 if ( flags & I810_FRONT ) {
 678                         DRM_DEBUG("clear front\n");
 679                         BEGIN_LP_RING( 6 );
 680                         OUT_RING( BR00_BITBLT_CLIENT |
 681                                   BR00_OP_COLOR_BLT | 0x3 );
 682                         OUT_RING( BR13_SOLID_PATTERN | (0xF0 << 16) | pitch );
 683                         OUT_RING( (height << 16) | width );
 684                         OUT_RING( start );
 685                         OUT_RING( clear_color );
 686                         OUT_RING( 0 );
 687                         ADVANCE_LP_RING();
 688                 }
 689
 690                 if ( flags & I810_BACK ) {
 691                         DRM_DEBUG("clear back\n");
 692                         BEGIN_LP_RING( 6 );
 693                         OUT_RING( BR00_BITBLT_CLIENT |
 694                                   BR00_OP_COLOR_BLT | 0x3 );
 695                         OUT_RING( BR13_SOLID_PATTERN | (0xF0 << 16) | pitch );
 696                         OUT_RING( (height << 16) | width );
 697                         OUT_RING( dev_priv->back_offset + start );
 698                         OUT_RING( clear_color );
 699                         OUT_RING( 0 );
 700                         ADVANCE_LP_RING();
 701                 }
 702
 703                 if ( flags & I810_DEPTH ) {
 704                         DRM_DEBUG("clear depth\n");
 705                         BEGIN_LP_RING( 6 );
 706                         OUT_RING( BR00_BITBLT_CLIENT |
 707                                   BR00_OP_COLOR_BLT | 0x3 );
 708                         OUT_RING( BR13_SOLID_PATTERN | (0xF0 << 16) | pitch );
 709                         OUT_RING( (height << 16) | width );
 710                         OUT_RING( dev_priv->depth_offset + start );
 711                         OUT_RING( clear_zval );
 712                         OUT_RING( 0 );
 713                         ADVANCE_LP_RING();
 714                 }
 715         }
 716 }
 717
 718 static void i810_dma_dispatch_swap( drm_device_t *dev )
 719 {
 720         drm_i810_private_t *dev_priv = dev->dev_private;
 721         drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
 722         int nbox = sarea_priv->nbox;
 723         drm_clip_rect_t *pbox = sarea_priv->boxes;
 724         int pitch = dev_priv->pitch;
 725         int cpp = 2;
 726         int ofs = dev_priv->back_offset;
 727         int i;
 728         RING_LOCALS;
 729
 730         DRM_DEBUG("swapbuffers\n");
 731
 732         i810_kernel_lost_context(dev);
 733
 734         if (nbox > I810_NR_SAREA_CLIPRECTS)
 735                 nbox = I810_NR_SAREA_CLIPRECTS;
 736
 737         for (i = 0 ; i < nbox; i++, pbox++)
 738         {
 739                 unsigned int w = pbox->x2 - pbox->x1;
 740                 unsigned int h = pbox->y2 - pbox->y1;
 741                 unsigned int dst = pbox->x1*cpp + pbox->y1*pitch;
 742                 unsigned int start = ofs + dst;
 743
 744                 if (pbox->x1 > pbox->x2 ||
 745                     pbox->y1 > pbox->y2 ||
 746                     pbox->x2 > dev_priv->w ||
 747                     pbox->y2 > dev_priv->h)
 748                         continue;
 749
 750                 DRM_DEBUG("dispatch swap %d,%d-%d,%d!\n",
 751                           pbox[i].x1, pbox[i].y1,
 752                           pbox[i].x2, pbox[i].y2);
 753
 754                 BEGIN_LP_RING( 6 );
 755                 OUT_RING( BR00_BITBLT_CLIENT | BR00_OP_SRC_COPY_BLT | 0x4 );
 756                 OUT_RING( pitch | (0xCC << 16));
 757                 OUT_RING( (h << 16) | (w * cpp));
 758                 OUT_RING( dst );
 759                 OUT_RING( pitch );
 760                 OUT_RING( start );
 761                 ADVANCE_LP_RING();
 762         }
 763 }
 764
 765
 766 static void i810_dma_dispatch_vertex(drm_device_t *dev,
 767                                      drm_buf_t *buf,
 768                                      int discard,
 769                                      int used)
 770 {
 771         drm_i810_private_t *dev_priv = dev->dev_private;
 772         drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 773         drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
 774         drm_clip_rect_t *box = sarea_priv->boxes;
 775         int nbox = sarea_priv->nbox;
 776         unsigned long address = (unsigned long)buf->bus_address;
 777         unsigned long start = address - dev->agp->base;
 778         int i = 0, u;
 779         RING_LOCALS;
 780
 781         i810_kernel_lost_context(dev);
 782
 783         if (nbox > I810_NR_SAREA_CLIPRECTS)
 784                 nbox = I810_NR_SAREA_CLIPRECTS;
 785
 786         if (discard) {
 787                 u = cmpxchg(buf_priv->in_use, I810_BUF_CLIENT,
 788                             I810_BUF_HARDWARE);
 789                 if(u != I810_BUF_CLIENT) {
 790                         DRM_DEBUG("xxxx 2\n");
 791                 }
 792         }
 793
 794         if (used > 4*1024)
 795                 used = 0;
 796
 797         if (sarea_priv->dirty)
 798            i810EmitState( dev );
 799
 800         DRM_DEBUG("dispatch vertex addr 0x%lx, used 0x%x nbox %d\n",
 801                   address, used, nbox);
 802
 803         dev_priv->counter++;
 804         DRM_DEBUG(  "dispatch counter : %ld\n", dev_priv->counter);
 805         DRM_DEBUG(  "i810_dma_dispatch\n");
 806         DRM_DEBUG(  "start : %lx\n", start);
 807         DRM_DEBUG(  "used : %d\n", used);
 808         DRM_DEBUG(  "start + used - 4 : %ld\n", start + used - 4);
 809
 810         if (buf_priv->currently_mapped == I810_BUF_MAPPED) {
 811                 *(u32 *)buf_priv->virtual = (GFX_OP_PRIMITIVE |
 812                                              sarea_priv->vertex_prim |
 813                                              ((used/4)-2));
 814
 815                 if (used & 4) {
 816                         *(u32 *)((u32)buf_priv->virtual + used) = 0;
 817                         used += 4;
 818                 }
 819
 820                 i810_unmap_buffer(buf);
 821         }
 822
 823         if (used) {
 824                 do {
 825                         if (i < nbox) {
 826                                 BEGIN_LP_RING(4);
 827                                 OUT_RING( GFX_OP_SCISSOR | SC_UPDATE_SCISSOR |
 828                                           SC_ENABLE );
 829                                 OUT_RING( GFX_OP_SCISSOR_INFO );
 830                                 OUT_RING( box[i].x1 | (box[i].y1<<16) );
 831                                 OUT_RING( (box[i].x2-1) | ((box[i].y2-1)<<16) );
 832                                 ADVANCE_LP_RING();
 833                         }
 834
 835                         BEGIN_LP_RING(4);
 836                         OUT_RING( CMD_OP_BATCH_BUFFER );
 837                         OUT_RING( start | BB1_PROTECTED );
 838                         OUT_RING( start + used - 4 );
 839                         OUT_RING( 0 );
 840                         ADVANCE_LP_RING();
 841
 842                 } while (++i < nbox);
 843         }
 844
 845         BEGIN_LP_RING(10);
 846         OUT_RING( CMD_STORE_DWORD_IDX );
 847         OUT_RING( 20 );
 848         OUT_RING( dev_priv->counter );
 849         OUT_RING( 0 );
 850
 851         if (discard) {
 852                 OUT_RING( CMD_STORE_DWORD_IDX );
 853                 OUT_RING( buf_priv->my_use_idx );
 854                 OUT_RING( I810_BUF_FREE );
 855                 OUT_RING( 0 );
 856         }
 857
 858         OUT_RING( CMD_REPORT_HEAD );
 859         OUT_RING( 0 );
 860         ADVANCE_LP_RING();
 861 }
 862
 863
 864 /* Interrupts are only for flushing */
 865 void i810_dma_service(int irq, void *device, struct pt_regs *regs)
 866 {
 867         drm_device_t     *dev = (drm_device_t *)device;
 868         u16 temp;
 869
 870         atomic_inc(&dev->counts[_DRM_STAT_IRQ]);
 871         temp = I810_READ16(I810REG_INT_IDENTITY_R);
 872         temp = temp & ~(0x6000);
 873         if(temp != 0) I810_WRITE16(I810REG_INT_IDENTITY_R,
 874                                    temp); /* Clear all interrupts */
 875         else
 876            return;
 877
 878         queue_task(&dev->tq, &tq_immediate);
 879         mark_bh(IMMEDIATE_BH);
 880 }
 881
 882 void i810_dma_immediate_bh(void *device)
 883 {
 884         drm_device_t *dev = (drm_device_t *) device;
 885         drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
 886
 887         atomic_set(&dev_priv->flush_done, 1);
 888         wake_up_interruptible(&dev_priv->flush_queue);
 889 }
 890
 891 static inline void i810_dma_emit_flush(drm_device_t *dev)
 892 {
 893         drm_i810_private_t *dev_priv = dev->dev_private;
 894         RING_LOCALS;
 895
 896         i810_kernel_lost_context(dev);
 897
 898         BEGIN_LP_RING(2);
 899         OUT_RING( CMD_REPORT_HEAD );
 900         OUT_RING( GFX_OP_USER_INTERRUPT );
 901         ADVANCE_LP_RING();
 902
 903 /*      i810_wait_ring( dev, dev_priv->ring.Size - 8 ); */
 904 /*      atomic_set(&dev_priv->flush_done, 1); */
 905 /*      wake_up_interruptible(&dev_priv->flush_queue); */
 906 }
 907
 908 static inline void i810_dma_quiescent_emit(drm_device_t *dev)
 909 {
 910         drm_i810_private_t *dev_priv = dev->dev_private;
 911         RING_LOCALS;
 912
 913         i810_kernel_lost_context(dev);
 914
 915         BEGIN_LP_RING(4);
 916         OUT_RING( INST_PARSER_CLIENT | INST_OP_FLUSH | INST_FLUSH_MAP_CACHE );
 917         OUT_RING( CMD_REPORT_HEAD );
 918         OUT_RING( 0 );
 919         OUT_RING( GFX_OP_USER_INTERRUPT );
 920         ADVANCE_LP_RING();
 921
 922 /*      i810_wait_ring( dev, dev_priv->ring.Size - 8 ); */
 923 /*      atomic_set(&dev_priv->flush_done, 1); */
 924 /*      wake_up_interruptible(&dev_priv->flush_queue); */
 925 }
 926
 927 void i810_dma_quiescent(drm_device_t *dev)
 928 {
 929         DECLARE_WAITQUEUE(entry, current);
 930         drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
 931         unsigned long end;
 932
 933         if(dev_priv == NULL) {
 934                 return;
 935         }
 936         atomic_set(&dev_priv->flush_done, 0);
 937         add_wait_queue(&dev_priv->flush_queue, &entry);
 938         end = jiffies + (HZ*3);
 939
 940         for (;;) {
 941                 current->state = TASK_INTERRUPTIBLE;
 942                 i810_dma_quiescent_emit(dev);
 943                 if (atomic_read(&dev_priv->flush_done) == 1) break;
 944                 if((signed)(end - jiffies) <= 0) {
 945                         DRM_ERROR("lockup\n");
 946                         break;
 947                 }
 948                 schedule_timeout(HZ*3);
 949                 if (signal_pending(current)) {
 950                         break;
 951                 }
 952         }
 953
 954         current->state = TASK_RUNNING;
 955         remove_wait_queue(&dev_priv->flush_queue, &entry);
 956
 957         return;
 958 }
 959
 960 static int i810_flush_queue(drm_device_t *dev)
 961 {
 962         DECLARE_WAITQUEUE(entry, current);
 963         drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
 964         drm_device_dma_t *dma = dev->dma;
 965         unsigned long end;
 966         int i, ret = 0;
 967
 968         if(dev_priv == NULL) {
 969                 return 0;
 970         }
 971         atomic_set(&dev_priv->flush_done, 0);
 972         add_wait_queue(&dev_priv->flush_queue, &entry);
 973         end = jiffies + (HZ*3);
 974         for (;;) {
 975                 current->state = TASK_INTERRUPTIBLE;
 976                 i810_dma_emit_flush(dev);
 977                 if (atomic_read(&dev_priv->flush_done) == 1) break;
 978                 if((signed)(end - jiffies) <= 0) {
 979                         DRM_ERROR("lockup\n");
 980                         break;
 981                 }
 982                 schedule_timeout(HZ*3);
 983                 if (signal_pending(current)) {
 984                         ret = -EINTR; /* Can't restart */
 985                         break;
 986                 }
 987         }
 988
 989         current->state = TASK_RUNNING;
 990         remove_wait_queue(&dev_priv->flush_queue, &entry);
 991
 992
 993         for (i = 0; i < dma->buf_count; i++) {
 994                 drm_buf_t *buf = dma->buflist[ i ];
 995                 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
 996
 997                 int used = cmpxchg(buf_priv->in_use, I810_BUF_HARDWARE,
 998                                    I810_BUF_FREE);
 999
1000                 if (used == I810_BUF_HARDWARE)
1001                         DRM_DEBUG("reclaimed from HARDWARE\n");
1002                 if (used == I810_BUF_CLIENT)
1003                         DRM_DEBUG("still on client HARDWARE\n");
1004         }
1005
1006         return ret;
1007 }
1008
1009 /* Must be called with the lock held */
1010 void i810_reclaim_buffers(drm_device_t *dev, pid_t pid)
1011 {
1012         drm_device_dma_t *dma = dev->dma;
1013         int              i;
1014
1015         if (!dma) return;
1016         if (!dev->dev_private) return;
1017         if (!dma->buflist) return;
1018
1019         i810_flush_queue(dev);
1020
1021         for (i = 0; i < dma->buf_count; i++) {
1022                 drm_buf_t *buf = dma->buflist[ i ];
1023                 drm_i810_buf_priv_t *buf_priv = buf->dev_private;
1024
1025                 if (buf->pid == pid && buf_priv) {
1026                         int used = cmpxchg(buf_priv->in_use, I810_BUF_CLIENT,
1027                                            I810_BUF_FREE);
1028
1029                         if (used == I810_BUF_CLIENT)
1030                                 DRM_DEBUG("reclaimed from client\n");
1031                         if(buf_priv->currently_mapped == I810_BUF_MAPPED)
1032                                 buf_priv->currently_mapped = I810_BUF_UNMAPPED;
1033                 }
1034         }
1035 }
1036
1037 int i810_flush_ioctl(struct inode *inode, struct file *filp,
1038                      unsigned int cmd, unsigned long arg)
1039 {
1040         drm_file_t        *priv   = filp->private_data;
1041         drm_device_t      *dev    = priv->dev;
1042
1043         DRM_DEBUG("i810_flush_ioctl\n");
1044         if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
1045                 DRM_ERROR("i810_flush_ioctl called without lock held\n");
1046                 return -EINVAL;
1047         }
1048
1049         i810_flush_queue(dev);
1050         return 0;
1051 }
1052
1053
1054 int i810_dma_vertex(struct inode *inode, struct file *filp,
1055                unsigned int cmd, unsigned long arg)
1056 {
1057         drm_file_t *priv = filp->private_data;
1058         drm_device_t *dev = priv->dev;
1059         drm_device_dma_t *dma = dev->dma;
1060         drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
1061         u32 *hw_status = (u32 *)dev_priv->hw_status_page;
1062         drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
1063                                         dev_priv->sarea_priv;
1064         drm_i810_vertex_t vertex;
1065
1066         if (copy_from_user(&vertex, (drm_i810_vertex_t *)arg, sizeof(vertex)))
1067                 return -EFAULT;
1068
1069         if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
1070                 DRM_ERROR("i810_dma_vertex called without lock held\n");
1071                 return -EINVAL;
1072         }
1073
1074         DRM_DEBUG("i810 dma vertex, idx %d used %d discard %d\n",
1075                   vertex.idx, vertex.used, vertex.discard);
1076
1077         i810_dma_dispatch_vertex( dev,
1078                                   dma->buflist[ vertex.idx ],
1079                                   vertex.discard, vertex.used );
1080
1081         atomic_add(vertex.used, &dev->counts[_DRM_STAT_SECONDARY]);
1082         atomic_inc(&dev->counts[_DRM_STAT_DMA]);
1083         sarea_priv->last_enqueue = dev_priv->counter-1;
1084         sarea_priv->last_dispatch = (int) hw_status[5];
1085
1086         return 0;
1087 }
1088
1089
1090
1091 int i810_clear_bufs(struct inode *inode, struct file *filp,
1092                    unsigned int cmd, unsigned long arg)
1093 {
1094         drm_file_t *priv = filp->private_data;
1095         drm_device_t *dev = priv->dev;
1096         drm_i810_clear_t clear;
1097
1098         if (copy_from_user(&clear, (drm_i810_clear_t *)arg, sizeof(clear)))
1099                 return -EFAULT;
1100
1101         if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
1102                 DRM_ERROR("i810_clear_bufs called without lock held\n");
1103                 return -EINVAL;
1104         }
1105
1106         i810_dma_dispatch_clear( dev, clear.flags,
1107                                  clear.clear_color,
1108                                  clear.clear_depth );
1109         return 0;
1110 }
1111
1112 int i810_swap_bufs(struct inode *inode, struct file *filp,
1113                   unsigned int cmd, unsigned long arg)
1114 {
1115         drm_file_t *priv = filp->private_data;
1116         drm_device_t *dev = priv->dev;
1117
1118         DRM_DEBUG("i810_swap_bufs\n");
1119
1120         if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
1121                 DRM_ERROR("i810_swap_buf called without lock held\n");
1122                 return -EINVAL;
1123         }
1124
1125         i810_dma_dispatch_swap( dev );
1126         return 0;
1127 }
1128
1129 int i810_getage(struct inode *inode, struct file *filp, unsigned int cmd,
1130                 unsigned long arg)
1131 {
1132         drm_file_t        *priv     = filp->private_data;
1133         drm_device_t      *dev      = priv->dev;
1134         drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
1135         u32 *hw_status = (u32 *)dev_priv->hw_status_page;
1136         drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
1137                                         dev_priv->sarea_priv;
1138
1139         sarea_priv->last_dispatch = (int) hw_status[5];
1140         return 0;
1141 }
1142
1143 int i810_getbuf(struct inode *inode, struct file *filp, unsigned int cmd,
1144                 unsigned long arg)
1145 {
1146         drm_file_t        *priv     = filp->private_data;
1147         drm_device_t      *dev      = priv->dev;
1148         int               retcode   = 0;
1149         drm_i810_dma_t    d;
1150         drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
1151         u32 *hw_status = (u32 *)dev_priv->hw_status_page;
1152         drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
1153                                         dev_priv->sarea_priv;
1154
1155         DRM_DEBUG("getbuf\n");
1156         if (copy_from_user(&d, (drm_i810_dma_t *)arg, sizeof(d)))
1157                 return -EFAULT;
1158
1159         if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
1160                 DRM_ERROR("i810_dma called without lock held\n");
1161                 return -EINVAL;
1162         }
1163
1164         d.granted = 0;
1165
1166         retcode = i810_dma_get_buffer(dev, &d, filp);
1167
1168         DRM_DEBUG("i810_dma: %d returning %d, granted = %d\n",
1169                   current->pid, retcode, d.granted);
1170
1171         if (copy_to_user((drm_dma_t *)arg, &d, sizeof(d)))
1172                 return -EFAULT;
1173         sarea_priv->last_dispatch = (int) hw_status[5];
1174
1175         return retcode;
1176 }
1177
1178 int i810_copybuf(struct inode *inode, struct file *filp, unsigned int cmd,
1179                 unsigned long arg)
1180 {
1181         drm_file_t        *priv     = filp->private_data;
1182         drm_device_t      *dev      = priv->dev;
1183         drm_i810_copy_t   d;
1184         drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
1185         u32 *hw_status = (u32 *)dev_priv->hw_status_page;
1186         drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
1187                                         dev_priv->sarea_priv;
1188         drm_buf_t *buf;
1189         drm_i810_buf_priv_t *buf_priv;
1190         drm_device_dma_t *dma = dev->dma;
1191
1192         if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
1193                 DRM_ERROR("i810_dma called without lock held\n");
1194                 return -EINVAL;
1195         }
1196
1197         if (copy_from_user(&d, (drm_i810_copy_t *)arg, sizeof(d)))
1198                 return -EFAULT;
1199
1200         if(d.idx > dma->buf_count) return -EINVAL;
1201         buf = dma->buflist[ d.idx ];
1202         buf_priv = buf->dev_private;
1203         if (buf_priv->currently_mapped != I810_BUF_MAPPED) return -EPERM;
1204
1205         if (copy_from_user(buf_priv->virtual, d.address, d.used))
1206                 return -EFAULT;
1207
1208         sarea_priv->last_dispatch = (int) hw_status[5];
1209
1210         return 0;
1211 }
1212
1213 int i810_docopy(struct inode *inode, struct file *filp, unsigned int cmd,
1214                 unsigned long arg)
1215 {
1216         if(VM_DONTCOPY == 0) return 1;
1217         return 0;
1218 }