git.oblomov.eu Git - linux-2.6/blob - drivers/char/drm/drm_bufs.c

   1 /**
   2  * \file drm_bufs.h
   3  * Generic buffer template
   4  *
   5  * \author Rickard E. (Rik) Faith <faith@valinux.com>
   6  * \author Gareth Hughes <gareth@valinux.com>
   7  */
   8
   9 /*
  10  * Created: Thu Nov 23 03:10:50 2000 by gareth@valinux.com
  11  *
  12  * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
  13  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  14  * All Rights Reserved.
  15  *
  16  * Permission is hereby granted, free of charge, to any person obtaining a
  17  * copy of this software and associated documentation files (the "Software"),
  18  * to deal in the Software without restriction, including without limitation
  19  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  20  * and/or sell copies of the Software, and to permit persons to whom the
  21  * Software is furnished to do so, subject to the following conditions:
  22  *
  23  * The above copyright notice and this permission notice (including the next
  24  * paragraph) shall be included in all copies or substantial portions of the
  25  * Software.
  26  *
  27  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  28  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  29  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  30  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  31  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  32  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  33  * OTHER DEALINGS IN THE SOFTWARE.
  34  */
  35
  36 #include <linux/vmalloc.h>
  37 #include "drmP.h"
  38
  39 /**
  40  * Compute size order.  Returns the exponent of the smaller power of two which
  41  * is greater or equal to given number.
  42  *
  43  * \param size size.
  44  * \return order.
  45  *
  46  * \todo Can be made faster.
  47  */
  48 int drm_order( unsigned long size )
  49 {
  50         int order;
  51         unsigned long tmp;
  52
  53         for (order = 0, tmp = size >> 1; tmp; tmp >>= 1, order++)
  54                 ;
  55
  56         if (size & (size - 1))
  57                 ++order;
  58
  59         return order;
  60 }
  61 EXPORT_SYMBOL(drm_order);
  62
  63 #ifdef CONFIG_COMPAT
  64 /*
  65  * Used to allocate 32-bit handles for _DRM_SHM regions
  66  * The 0x10000000 value is chosen to be out of the way of
  67  * FB/register and GART physical addresses.
  68  */
  69 static unsigned int map32_handle = 0x10000000;
  70 #endif
  71
  72 /**
  73  * Ioctl to specify a range of memory that is available for mapping by a non-root process.
  74  *
  75  * \param inode device inode.
  76  * \param filp file pointer.
  77  * \param cmd command.
  78  * \param arg pointer to a drm_map structure.
  79  * \return zero on success or a negative value on error.
  80  *
  81  * Adjusts the memory offset to its absolute value according to the mapping
  82  * type.  Adds the map to the map list drm_device::maplist. Adds MTRR's where
  83  * applicable and if supported by the kernel.
  84  */
  85 int drm_addmap( struct inode *inode, struct file *filp,
  86                  unsigned int cmd, unsigned long arg )
  87 {
  88         drm_file_t *priv = filp->private_data;
  89         drm_device_t *dev = priv->head->dev;
  90         drm_map_t *map;
  91         drm_map_t __user *argp = (void __user *)arg;
  92         drm_map_list_t *list;
  93
  94         if ( !(filp->f_mode & 3) ) return -EACCES; /* Require read/write */
  95
  96         map = drm_alloc( sizeof(*map), DRM_MEM_MAPS );
  97         if ( !map )
  98                 return -ENOMEM;
  99
 100         if ( copy_from_user( map, argp, sizeof(*map) ) ) {
 101                 drm_free( map, sizeof(*map), DRM_MEM_MAPS );
 102                 return -EFAULT;
 103         }
 104
 105         /* Only allow shared memory to be removable since we only keep enough
 106          * book keeping information about shared memory to allow for removal
 107          * when processes fork.
 108          */
 109         if ( (map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM ) {
 110                 drm_free( map, sizeof(*map), DRM_MEM_MAPS );
 111                 return -EINVAL;
 112         }
 113         DRM_DEBUG( "offset = 0x%08lx, size = 0x%08lx, type = %d\n",
 114                    map->offset, map->size, map->type );
 115         if ( (map->offset & (~PAGE_MASK)) || (map->size & (~PAGE_MASK)) ) {
 116                 drm_free( map, sizeof(*map), DRM_MEM_MAPS );
 117                 return -EINVAL;
 118         }
 119         map->mtrr   = -1;
 120         map->handle = NULL;
 121
 122         switch ( map->type ) {
 123         case _DRM_REGISTERS:
 124         case _DRM_FRAME_BUFFER:
 125 #if !defined(__sparc__) && !defined(__alpha__) && !defined(__ia64__)
 126                 if ( map->offset + map->size < map->offset ||
 127                      map->offset < virt_to_phys(high_memory) ) {
 128                         drm_free( map, sizeof(*map), DRM_MEM_MAPS );
 129                         return -EINVAL;
 130                 }
 131 #endif
 132 #ifdef __alpha__
 133                 map->offset += dev->hose->mem_space->start;
 134 #endif
 135                 if (drm_core_has_MTRR(dev)) {
 136                         if ( map->type == _DRM_FRAME_BUFFER ||
 137                              (map->flags & _DRM_WRITE_COMBINING) ) {
 138                                 map->mtrr = mtrr_add( map->offset, map->size,
 139                                                       MTRR_TYPE_WRCOMB, 1 );
 140                         }
 141                 }
 142                 if (map->type == _DRM_REGISTERS)
 143                         map->handle = drm_ioremap( map->offset, map->size,
 144                                                     dev );
 145                 break;
 146
 147         case _DRM_SHM:
 148                 map->handle = vmalloc_32(map->size);
 149                 DRM_DEBUG( "%lu %d %p\n",
 150                            map->size, drm_order( map->size ), map->handle );
 151                 if ( !map->handle ) {
 152                         drm_free( map, sizeof(*map), DRM_MEM_MAPS );
 153                         return -ENOMEM;
 154                 }
 155                 map->offset = (unsigned long)map->handle;
 156                 if ( map->flags & _DRM_CONTAINS_LOCK ) {
 157                         /* Prevent a 2nd X Server from creating a 2nd lock */
 158                         if (dev->lock.hw_lock != NULL) {
 159                                 vfree( map->handle );
 160                                 drm_free( map, sizeof(*map), DRM_MEM_MAPS );
 161                                 return -EBUSY;
 162                         }
 163                         dev->sigdata.lock =
 164                         dev->lock.hw_lock = map->handle; /* Pointer to lock */
 165                 }
 166                 break;
 167         case _DRM_AGP:
 168                 if (drm_core_has_AGP(dev)) {
 169 #ifdef __alpha__
 170                         map->offset += dev->hose->mem_space->start;
 171 #endif
 172                         map->offset += dev->agp->base;
 173                         map->mtrr   = dev->agp->agp_mtrr; /* for getmap */
 174                 }
 175                 break;
 176         case _DRM_SCATTER_GATHER:
 177                 if (!dev->sg) {
 178                         drm_free(map, sizeof(*map), DRM_MEM_MAPS);
 179                         return -EINVAL;
 180                 }
 181                 map->offset += dev->sg->handle;
 182                 break;
 183
 184         default:
 185                 drm_free( map, sizeof(*map), DRM_MEM_MAPS );
 186                 return -EINVAL;
 187         }
 188
 189         list = drm_alloc(sizeof(*list), DRM_MEM_MAPS);
 190         if(!list) {
 191                 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
 192                 return -EINVAL;
 193         }
 194         memset(list, 0, sizeof(*list));
 195         list->map = map;
 196
 197         down(&dev->struct_sem);
 198         list_add(&list->head, &dev->maplist->head);
 199 #ifdef CONFIG_COMPAT
 200         /* Assign a 32-bit handle for _DRM_SHM mappings */
 201         /* We do it here so that dev->struct_sem protects the increment */
 202         if (map->type == _DRM_SHM)
 203                 map->offset = map32_handle += PAGE_SIZE;
 204 #endif
 205         up(&dev->struct_sem);
 206
 207         if ( copy_to_user( argp, map, sizeof(*map) ) )
 208                 return -EFAULT;
 209         if (copy_to_user(&argp->handle, &map->offset, sizeof(map->offset)))
 210                 return -EFAULT;
 211         return 0;
 212 }
 213
 214
 215 /**
 216  * Remove a map private from list and deallocate resources if the mapping
 217  * isn't in use.
 218  *
 219  * \param inode device inode.
 220  * \param filp file pointer.
 221  * \param cmd command.
 222  * \param arg pointer to a drm_map_t structure.
 223  * \return zero on success or a negative value on error.
 224  *
 225  * Searches the map on drm_device::maplist, removes it from the list, see if
 226  * its being used, and free any associate resource (such as MTRR's) if it's not
 227  * being on use.
 228  *
 229  * \sa addmap().
 230  */
 231 int drm_rmmap(struct inode *inode, struct file *filp,
 232                unsigned int cmd, unsigned long arg)
 233 {
 234         drm_file_t      *priv   = filp->private_data;
 235         drm_device_t    *dev    = priv->head->dev;
 236         struct list_head *list;
 237         drm_map_list_t *r_list = NULL;
 238         drm_vma_entry_t *pt, *prev;
 239         drm_map_t *map;
 240         drm_map_t request;
 241         int found_maps = 0;
 242
 243         if (copy_from_user(&request, (drm_map_t __user *)arg,
 244                            sizeof(request))) {
 245                 return -EFAULT;
 246         }
 247
 248         down(&dev->struct_sem);
 249         list = &dev->maplist->head;
 250         list_for_each(list, &dev->maplist->head) {
 251                 r_list = list_entry(list, drm_map_list_t, head);
 252
 253                 if(r_list->map &&
 254                    r_list->map->offset == (unsigned long) request.handle &&
 255                    r_list->map->flags & _DRM_REMOVABLE) break;
 256         }
 257
 258         /* List has wrapped around to the head pointer, or its empty we didn't
 259          * find anything.
 260          */
 261         if(list == (&dev->maplist->head)) {
 262                 up(&dev->struct_sem);
 263                 return -EINVAL;
 264         }
 265         map = r_list->map;
 266         list_del(list);
 267         drm_free(list, sizeof(*list), DRM_MEM_MAPS);
 268
 269         for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
 270                 if (pt->vma->vm_private_data == map) found_maps++;
 271         }
 272
 273         if(!found_maps) {
 274                 switch (map->type) {
 275                 case _DRM_REGISTERS:
 276                 case _DRM_FRAME_BUFFER:
 277                   if (drm_core_has_MTRR(dev)) {
 278                                 if (map->mtrr >= 0) {
 279                                         int retcode;
 280                                         retcode = mtrr_del(map->mtrr,
 281                                                            map->offset,
 282                                                            map->size);
 283                                         DRM_DEBUG("mtrr_del = %d\n", retcode);
 284                                 }
 285                         }
 286                         drm_ioremapfree(map->handle, map->size, dev);
 287                         break;
 288                 case _DRM_SHM:
 289                         vfree(map->handle);
 290                         break;
 291                 case _DRM_AGP:
 292                 case _DRM_SCATTER_GATHER:
 293                         break;
 294                 }
 295                 drm_free(map, sizeof(*map), DRM_MEM_MAPS);
 296         }
 297         up(&dev->struct_sem);
 298         return 0;
 299 }
 300
 301 /**
 302  * Cleanup after an error on one of the addbufs() functions.
 303  *
 304  * \param entry buffer entry where the error occurred.
 305  *
 306  * Frees any pages and buffers associated with the given entry.
 307  */
 308 static void drm_cleanup_buf_error(drm_device_t *dev, drm_buf_entry_t *entry)
 309 {
 310         int i;
 311
 312         if (entry->seg_count) {
 313                 for (i = 0; i < entry->seg_count; i++) {
 314                         if (entry->seglist[i]) {
 315                                 drm_free_pages(entry->seglist[i],
 316                                                 entry->page_order,
 317                                                 DRM_MEM_DMA);
 318                         }
 319                 }
 320                 drm_free(entry->seglist,
 321                           entry->seg_count *
 322                           sizeof(*entry->seglist),
 323                           DRM_MEM_SEGS);
 324
 325                 entry->seg_count = 0;
 326         }
 327
 328         if (entry->buf_count) {
 329                 for (i = 0; i < entry->buf_count; i++) {
 330                         if (entry->buflist[i].dev_private) {
 331                                 drm_free(entry->buflist[i].dev_private,
 332                                           entry->buflist[i].dev_priv_size,
 333                                           DRM_MEM_BUFS);
 334                         }
 335                 }
 336                 drm_free(entry->buflist,
 337                           entry->buf_count *
 338                           sizeof(*entry->buflist),
 339                           DRM_MEM_BUFS);
 340
 341                 entry->buf_count = 0;
 342         }
 343 }
 344
 345 #if __OS_HAS_AGP
 346 /**
 347  * Add AGP buffers for DMA transfers (ioctl).
 348  *
 349  * \param inode device inode.
 350  * \param filp file pointer.
 351  * \param cmd command.
 352  * \param arg pointer to a drm_buf_desc_t request.
 353  * \return zero on success or a negative number on failure.
 354  *
 355  * After some sanity checks creates a drm_buf structure for each buffer and
 356  * reallocates the buffer list of the same size order to accommodate the new
 357  * buffers.
 358  */
 359 static int drm_addbufs_agp( struct inode *inode, struct file *filp,
 360                             unsigned int cmd, unsigned long arg )
 361 {
 362         drm_file_t *priv = filp->private_data;
 363         drm_device_t *dev = priv->head->dev;
 364         drm_device_dma_t *dma = dev->dma;
 365         drm_buf_desc_t request;
 366         drm_buf_entry_t *entry;
 367         drm_buf_t *buf;
 368         unsigned long offset;
 369         unsigned long agp_offset;
 370         int count;
 371         int order;
 372         int size;
 373         int alignment;
 374         int page_order;
 375         int total;
 376         int byte_count;
 377         int i;
 378         drm_buf_t **temp_buflist;
 379         drm_buf_desc_t __user *argp = (void __user *)arg;
 380
 381         if ( !dma ) return -EINVAL;
 382
 383         if ( copy_from_user( &request, argp,
 384                              sizeof(request) ) )
 385                 return -EFAULT;
 386
 387         count = request.count;
 388         order = drm_order( request.size );
 389         size = 1 << order;
 390
 391         alignment  = (request.flags & _DRM_PAGE_ALIGN)
 392                 ? PAGE_ALIGN(size) : size;
 393         page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
 394         total = PAGE_SIZE << page_order;
 395
 396         byte_count = 0;
 397         agp_offset = dev->agp->base + request.agp_start;
 398
 399         DRM_DEBUG( "count:      %d\n",  count );
 400         DRM_DEBUG( "order:      %d\n",  order );
 401         DRM_DEBUG( "size:       %d\n",  size );
 402         DRM_DEBUG( "agp_offset: %lu\n", agp_offset );
 403         DRM_DEBUG( "alignment:  %d\n",  alignment );
 404         DRM_DEBUG( "page_order: %d\n",  page_order );
 405         DRM_DEBUG( "total:      %d\n",  total );
 406
 407         if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
 408         if ( dev->queue_count ) return -EBUSY; /* Not while in use */
 409
 410         spin_lock( &dev->count_lock );
 411         if ( dev->buf_use ) {
 412                 spin_unlock( &dev->count_lock );
 413                 return -EBUSY;
 414         }
 415         atomic_inc( &dev->buf_alloc );
 416         spin_unlock( &dev->count_lock );
 417
 418         down( &dev->struct_sem );
 419         entry = &dma->bufs[order];
 420         if ( entry->buf_count ) {
 421                 up( &dev->struct_sem );
 422                 atomic_dec( &dev->buf_alloc );
 423                 return -ENOMEM; /* May only call once for each order */
 424         }
 425
 426         if (count < 0 || count > 4096) {
 427                 up( &dev->struct_sem );
 428                 atomic_dec( &dev->buf_alloc );
 429                 return -EINVAL;
 430         }
 431
 432         entry->buflist = drm_alloc( count * sizeof(*entry->buflist),
 433                                     DRM_MEM_BUFS );
 434         if ( !entry->buflist ) {
 435                 up( &dev->struct_sem );
 436                 atomic_dec( &dev->buf_alloc );
 437                 return -ENOMEM;
 438         }
 439         memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
 440
 441         entry->buf_size = size;
 442         entry->page_order = page_order;
 443
 444         offset = 0;
 445
 446         while ( entry->buf_count < count ) {
 447                 buf          = &entry->buflist[entry->buf_count];
 448                 buf->idx     = dma->buf_count + entry->buf_count;
 449                 buf->total   = alignment;
 450                 buf->order   = order;
 451                 buf->used    = 0;
 452
 453                 buf->offset  = (dma->byte_count + offset);
 454                 buf->bus_address = agp_offset + offset;
 455                 buf->address = (void *)(agp_offset + offset);
 456                 buf->next    = NULL;
 457                 buf->waiting = 0;
 458                 buf->pending = 0;
 459                 init_waitqueue_head( &buf->dma_wait );
 460                 buf->filp    = NULL;
 461
 462                 buf->dev_priv_size = dev->driver->dev_priv_size;
 463                 buf->dev_private = drm_alloc( buf->dev_priv_size,
 464                                                DRM_MEM_BUFS );
 465                 if(!buf->dev_private) {
 466                         /* Set count correctly so we free the proper amount. */
 467                         entry->buf_count = count;
 468                         drm_cleanup_buf_error(dev,entry);
 469                         up( &dev->struct_sem );
 470                         atomic_dec( &dev->buf_alloc );
 471                         return -ENOMEM;
 472                 }
 473                 memset( buf->dev_private, 0, buf->dev_priv_size );
 474
 475                 DRM_DEBUG( "buffer %d @ %p\n",
 476                            entry->buf_count, buf->address );
 477
 478                 offset += alignment;
 479                 entry->buf_count++;
 480                 byte_count += PAGE_SIZE << page_order;
 481         }
 482
 483         DRM_DEBUG( "byte_count: %d\n", byte_count );
 484
 485         temp_buflist = drm_realloc( dma->buflist,
 486                                      dma->buf_count * sizeof(*dma->buflist),
 487                                      (dma->buf_count + entry->buf_count)
 488                                      * sizeof(*dma->buflist),
 489                                      DRM_MEM_BUFS );
 490         if(!temp_buflist) {
 491                 /* Free the entry because it isn't valid */
 492                 drm_cleanup_buf_error(dev,entry);
 493                 up( &dev->struct_sem );
 494                 atomic_dec( &dev->buf_alloc );
 495                 return -ENOMEM;
 496         }
 497         dma->buflist = temp_buflist;
 498
 499         for ( i = 0 ; i < entry->buf_count ; i++ ) {
 500                 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
 501         }
 502
 503         dma->buf_count += entry->buf_count;
 504         dma->byte_count += byte_count;
 505
 506         DRM_DEBUG( "dma->buf_count : %d\n", dma->buf_count );
 507         DRM_DEBUG( "entry->buf_count : %d\n", entry->buf_count );
 508
 509         up( &dev->struct_sem );
 510
 511         request.count = entry->buf_count;
 512         request.size = size;
 513
 514         if ( copy_to_user( argp, &request, sizeof(request) ) )
 515                 return -EFAULT;
 516
 517         dma->flags = _DRM_DMA_USE_AGP;
 518
 519         atomic_dec( &dev->buf_alloc );
 520         return 0;
 521 }
 522 #endif /* __OS_HAS_AGP */
 523
 524 static int drm_addbufs_pci( struct inode *inode, struct file *filp,
 525                             unsigned int cmd, unsigned long arg )
 526 {
 527         drm_file_t *priv = filp->private_data;
 528         drm_device_t *dev = priv->head->dev;
 529         drm_device_dma_t *dma = dev->dma;
 530         drm_buf_desc_t request;
 531         int count;
 532         int order;
 533         int size;
 534         int total;
 535         int page_order;
 536         drm_buf_entry_t *entry;
 537         unsigned long page;
 538         drm_buf_t *buf;
 539         int alignment;
 540         unsigned long offset;
 541         int i;
 542         int byte_count;
 543         int page_count;
 544         unsigned long *temp_pagelist;
 545         drm_buf_t **temp_buflist;
 546         drm_buf_desc_t __user *argp = (void __user *)arg;
 547
 548         if (!drm_core_check_feature(dev, DRIVER_PCI_DMA)) return -EINVAL;
 549         if ( !dma ) return -EINVAL;
 550
 551         if ( copy_from_user( &request, argp, sizeof(request) ) )
 552                 return -EFAULT;
 553
 554         count = request.count;
 555         order = drm_order( request.size );
 556         size = 1 << order;
 557
 558         DRM_DEBUG( "count=%d, size=%d (%d), order=%d, queue_count=%d\n",
 559                    request.count, request.size, size,
 560                    order, dev->queue_count );
 561
 562         if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
 563         if ( dev->queue_count ) return -EBUSY; /* Not while in use */
 564
 565         alignment = (request.flags & _DRM_PAGE_ALIGN)
 566                 ? PAGE_ALIGN(size) : size;
 567         page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
 568         total = PAGE_SIZE << page_order;
 569
 570         spin_lock( &dev->count_lock );
 571         if ( dev->buf_use ) {
 572                 spin_unlock( &dev->count_lock );
 573                 return -EBUSY;
 574         }
 575         atomic_inc( &dev->buf_alloc );
 576         spin_unlock( &dev->count_lock );
 577
 578         down( &dev->struct_sem );
 579         entry = &dma->bufs[order];
 580         if ( entry->buf_count ) {
 581                 up( &dev->struct_sem );
 582                 atomic_dec( &dev->buf_alloc );
 583                 return -ENOMEM; /* May only call once for each order */
 584         }
 585
 586         if (count < 0 || count > 4096) {
 587                 up( &dev->struct_sem );
 588                 atomic_dec( &dev->buf_alloc );
 589                 return -EINVAL;
 590         }
 591
 592         entry->buflist = drm_alloc( count * sizeof(*entry->buflist),
 593                                     DRM_MEM_BUFS );
 594         if ( !entry->buflist ) {
 595                 up( &dev->struct_sem );
 596                 atomic_dec( &dev->buf_alloc );
 597                 return -ENOMEM;
 598         }
 599         memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
 600
 601         entry->seglist = drm_alloc( count * sizeof(*entry->seglist),
 602                                     DRM_MEM_SEGS );
 603         if ( !entry->seglist ) {
 604                 drm_free( entry->buflist,
 605                           count * sizeof(*entry->buflist),
 606                           DRM_MEM_BUFS );
 607                 up( &dev->struct_sem );
 608                 atomic_dec( &dev->buf_alloc );
 609                 return -ENOMEM;
 610         }
 611         memset( entry->seglist, 0, count * sizeof(*entry->seglist) );
 612
 613         /* Keep the original pagelist until we know all the allocations
 614          * have succeeded
 615          */
 616         temp_pagelist = drm_alloc( (dma->page_count + (count << page_order))
 617                                     * sizeof(*dma->pagelist),
 618                                     DRM_MEM_PAGES );
 619         if (!temp_pagelist) {
 620                 drm_free( entry->buflist,
 621                            count * sizeof(*entry->buflist),
 622                            DRM_MEM_BUFS );
 623                 drm_free( entry->seglist,
 624                            count * sizeof(*entry->seglist),
 625                            DRM_MEM_SEGS );
 626                 up( &dev->struct_sem );
 627                 atomic_dec( &dev->buf_alloc );
 628                 return -ENOMEM;
 629         }
 630         memcpy(temp_pagelist,
 631                dma->pagelist,
 632                dma->page_count * sizeof(*dma->pagelist));
 633         DRM_DEBUG( "pagelist: %d entries\n",
 634                    dma->page_count + (count << page_order) );
 635
 636         entry->buf_size = size;
 637         entry->page_order = page_order;
 638         byte_count = 0;
 639         page_count = 0;
 640
 641         while ( entry->buf_count < count ) {
 642                 page = drm_alloc_pages( page_order, DRM_MEM_DMA );
 643                 if ( !page ) {
 644                         /* Set count correctly so we free the proper amount. */
 645                         entry->buf_count = count;
 646                         entry->seg_count = count;
 647                         drm_cleanup_buf_error(dev, entry);
 648                         drm_free( temp_pagelist,
 649                                    (dma->page_count + (count << page_order))
 650                                    * sizeof(*dma->pagelist),
 651                                    DRM_MEM_PAGES );
 652                         up( &dev->struct_sem );
 653                         atomic_dec( &dev->buf_alloc );
 654                         return -ENOMEM;
 655                 }
 656                 entry->seglist[entry->seg_count++] = page;
 657                 for ( i = 0 ; i < (1 << page_order) ; i++ ) {
 658                         DRM_DEBUG( "page %d @ 0x%08lx\n",
 659                                    dma->page_count + page_count,
 660                                    page + PAGE_SIZE * i );
 661                         temp_pagelist[dma->page_count + page_count++]
 662                                 = page + PAGE_SIZE * i;
 663                 }
 664                 for ( offset = 0 ;
 665                       offset + size <= total && entry->buf_count < count ;
 666                       offset += alignment, ++entry->buf_count ) {
 667                         buf          = &entry->buflist[entry->buf_count];
 668                         buf->idx     = dma->buf_count + entry->buf_count;
 669                         buf->total   = alignment;
 670                         buf->order   = order;
 671                         buf->used    = 0;
 672                         buf->offset  = (dma->byte_count + byte_count + offset);
 673                         buf->address = (void *)(page + offset);
 674                         buf->next    = NULL;
 675                         buf->waiting = 0;
 676                         buf->pending = 0;
 677                         init_waitqueue_head( &buf->dma_wait );
 678                         buf->filp    = NULL;
 679
 680                         buf->dev_priv_size = dev->driver->dev_priv_size;
 681                         buf->dev_private = drm_alloc( buf->dev_priv_size,
 682                                                        DRM_MEM_BUFS );
 683                         if(!buf->dev_private) {
 684                                 /* Set count correctly so we free the proper amount. */
 685                                 entry->buf_count = count;
 686                                 entry->seg_count = count;
 687                                 drm_cleanup_buf_error(dev,entry);
 688                                 drm_free( temp_pagelist,
 689                                            (dma->page_count + (count << page_order))
 690                                            * sizeof(*dma->pagelist),
 691                                            DRM_MEM_PAGES );
 692                                 up( &dev->struct_sem );
 693                                 atomic_dec( &dev->buf_alloc );
 694                                 return -ENOMEM;
 695                         }
 696                         memset( buf->dev_private, 0, buf->dev_priv_size );
 697
 698                         DRM_DEBUG( "buffer %d @ %p\n",
 699                                    entry->buf_count, buf->address );
 700                 }
 701                 byte_count += PAGE_SIZE << page_order;
 702         }
 703
 704         temp_buflist = drm_realloc( dma->buflist,
 705                                      dma->buf_count * sizeof(*dma->buflist),
 706                                      (dma->buf_count + entry->buf_count)
 707                                      * sizeof(*dma->buflist),
 708                                      DRM_MEM_BUFS );
 709         if (!temp_buflist) {
 710                 /* Free the entry because it isn't valid */
 711                 drm_cleanup_buf_error(dev,entry);
 712                 drm_free( temp_pagelist,
 713                            (dma->page_count + (count << page_order))
 714                            * sizeof(*dma->pagelist),
 715                            DRM_MEM_PAGES );
 716                 up( &dev->struct_sem );
 717                 atomic_dec( &dev->buf_alloc );
 718                 return -ENOMEM;
 719         }
 720         dma->buflist = temp_buflist;
 721
 722         for ( i = 0 ; i < entry->buf_count ; i++ ) {
 723                 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
 724         }
 725
 726         /* No allocations failed, so now we can replace the orginal pagelist
 727          * with the new one.
 728          */
 729         if (dma->page_count) {
 730                 drm_free(dma->pagelist,
 731                           dma->page_count * sizeof(*dma->pagelist),
 732                           DRM_MEM_PAGES);
 733         }
 734         dma->pagelist = temp_pagelist;
 735
 736         dma->buf_count += entry->buf_count;
 737         dma->seg_count += entry->seg_count;
 738         dma->page_count += entry->seg_count << page_order;
 739         dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
 740
 741         up( &dev->struct_sem );
 742
 743         request.count = entry->buf_count;
 744         request.size = size;
 745
 746         if ( copy_to_user( argp, &request, sizeof(request) ) )
 747                 return -EFAULT;
 748
 749         atomic_dec( &dev->buf_alloc );
 750         return 0;
 751
 752 }
 753
 754 static int drm_addbufs_sg( struct inode *inode, struct file *filp,
 755                            unsigned int cmd, unsigned long arg )
 756 {
 757         drm_file_t *priv = filp->private_data;
 758         drm_device_t *dev = priv->head->dev;
 759         drm_device_dma_t *dma = dev->dma;
 760         drm_buf_desc_t __user *argp = (void __user *)arg;
 761         drm_buf_desc_t request;
 762         drm_buf_entry_t *entry;
 763         drm_buf_t *buf;
 764         unsigned long offset;
 765         unsigned long agp_offset;
 766         int count;
 767         int order;
 768         int size;
 769         int alignment;
 770         int page_order;
 771         int total;
 772         int byte_count;
 773         int i;
 774         drm_buf_t **temp_buflist;
 775
 776         if (!drm_core_check_feature(dev, DRIVER_SG)) return -EINVAL;
 777
 778         if ( !dma ) return -EINVAL;
 779
 780         if ( copy_from_user( &request, argp, sizeof(request) ) )
 781                 return -EFAULT;
 782
 783         count = request.count;
 784         order = drm_order( request.size );
 785         size = 1 << order;
 786
 787         alignment  = (request.flags & _DRM_PAGE_ALIGN)
 788                         ? PAGE_ALIGN(size) : size;
 789         page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
 790         total = PAGE_SIZE << page_order;
 791
 792         byte_count = 0;
 793         agp_offset = request.agp_start;
 794
 795         DRM_DEBUG( "count:      %d\n",  count );
 796         DRM_DEBUG( "order:      %d\n",  order );
 797         DRM_DEBUG( "size:       %d\n",  size );
 798         DRM_DEBUG( "agp_offset: %lu\n", agp_offset );
 799         DRM_DEBUG( "alignment:  %d\n",  alignment );
 800         DRM_DEBUG( "page_order: %d\n",  page_order );
 801         DRM_DEBUG( "total:      %d\n",  total );
 802
 803         if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
 804         if ( dev->queue_count ) return -EBUSY; /* Not while in use */
 805
 806         spin_lock( &dev->count_lock );
 807         if ( dev->buf_use ) {
 808                 spin_unlock( &dev->count_lock );
 809                 return -EBUSY;
 810         }
 811         atomic_inc( &dev->buf_alloc );
 812         spin_unlock( &dev->count_lock );
 813
 814         down( &dev->struct_sem );
 815         entry = &dma->bufs[order];
 816         if ( entry->buf_count ) {
 817                 up( &dev->struct_sem );
 818                 atomic_dec( &dev->buf_alloc );
 819                 return -ENOMEM; /* May only call once for each order */
 820         }
 821
 822         if (count < 0 || count > 4096) {
 823                 up( &dev->struct_sem );
 824                 atomic_dec( &dev->buf_alloc );
 825                 return -EINVAL;
 826         }
 827
 828         entry->buflist = drm_alloc( count * sizeof(*entry->buflist),
 829                                      DRM_MEM_BUFS );
 830         if ( !entry->buflist ) {
 831                 up( &dev->struct_sem );
 832                 atomic_dec( &dev->buf_alloc );
 833                 return -ENOMEM;
 834         }
 835         memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
 836
 837         entry->buf_size = size;
 838         entry->page_order = page_order;
 839
 840         offset = 0;
 841
 842         while ( entry->buf_count < count ) {
 843                 buf          = &entry->buflist[entry->buf_count];
 844                 buf->idx     = dma->buf_count + entry->buf_count;
 845                 buf->total   = alignment;
 846                 buf->order   = order;
 847                 buf->used    = 0;
 848
 849                 buf->offset  = (dma->byte_count + offset);
 850                 buf->bus_address = agp_offset + offset;
 851                 buf->address = (void *)(agp_offset + offset + dev->sg->handle);
 852                 buf->next    = NULL;
 853                 buf->waiting = 0;
 854                 buf->pending = 0;
 855                 init_waitqueue_head( &buf->dma_wait );
 856                 buf->filp    = NULL;
 857
 858                 buf->dev_priv_size = dev->driver->dev_priv_size;
 859                 buf->dev_private = drm_alloc( buf->dev_priv_size,
 860                                                DRM_MEM_BUFS );
 861                 if(!buf->dev_private) {
 862                         /* Set count correctly so we free the proper amount. */
 863                         entry->buf_count = count;
 864                         drm_cleanup_buf_error(dev,entry);
 865                         up( &dev->struct_sem );
 866                         atomic_dec( &dev->buf_alloc );
 867                         return -ENOMEM;
 868                 }
 869
 870                 memset( buf->dev_private, 0, buf->dev_priv_size );
 871
 872                 DRM_DEBUG( "buffer %d @ %p\n",
 873                            entry->buf_count, buf->address );
 874
 875                 offset += alignment;
 876                 entry->buf_count++;
 877                 byte_count += PAGE_SIZE << page_order;
 878         }
 879
 880         DRM_DEBUG( "byte_count: %d\n", byte_count );
 881
 882         temp_buflist = drm_realloc( dma->buflist,
 883                                      dma->buf_count * sizeof(*dma->buflist),
 884                                      (dma->buf_count + entry->buf_count)
 885                                      * sizeof(*dma->buflist),
 886                                      DRM_MEM_BUFS );
 887         if(!temp_buflist) {
 888                 /* Free the entry because it isn't valid */
 889                 drm_cleanup_buf_error(dev,entry);
 890                 up( &dev->struct_sem );
 891                 atomic_dec( &dev->buf_alloc );
 892                 return -ENOMEM;
 893         }
 894         dma->buflist = temp_buflist;
 895
 896         for ( i = 0 ; i < entry->buf_count ; i++ ) {
 897                 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
 898         }
 899
 900         dma->buf_count += entry->buf_count;
 901         dma->byte_count += byte_count;
 902
 903         DRM_DEBUG( "dma->buf_count : %d\n", dma->buf_count );
 904         DRM_DEBUG( "entry->buf_count : %d\n", entry->buf_count );
 905
 906         up( &dev->struct_sem );
 907
 908         request.count = entry->buf_count;
 909         request.size = size;
 910
 911         if ( copy_to_user( argp, &request, sizeof(request) ) )
 912                 return -EFAULT;
 913
 914         dma->flags = _DRM_DMA_USE_SG;
 915
 916         atomic_dec( &dev->buf_alloc );
 917         return 0;
 918 }
 919
 920 /**
 921  * Add buffers for DMA transfers (ioctl).
 922  *
 923  * \param inode device inode.
 924  * \param filp file pointer.
 925  * \param cmd command.
 926  * \param arg pointer to a drm_buf_desc_t request.
 927  * \return zero on success or a negative number on failure.
 928  *
 929  * According with the memory type specified in drm_buf_desc::flags and the
 930  * build options, it dispatches the call either to addbufs_agp(),
 931  * addbufs_sg() or addbufs_pci() for AGP, scatter-gather or consistent
 932  * PCI memory respectively.
 933  */
 934 int drm_addbufs( struct inode *inode, struct file *filp,
 935                   unsigned int cmd, unsigned long arg )
 936 {
 937         drm_buf_desc_t request;
 938         drm_file_t *priv = filp->private_data;
 939         drm_device_t *dev = priv->head->dev;
 940
 941         if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
 942                 return -EINVAL;
 943
 944         if ( copy_from_user( &request, (drm_buf_desc_t __user *)arg,
 945                              sizeof(request) ) )
 946                 return -EFAULT;
 947
 948 #if __OS_HAS_AGP
 949         if ( request.flags & _DRM_AGP_BUFFER )
 950                 return drm_addbufs_agp( inode, filp, cmd, arg );
 951         else
 952 #endif
 953         if ( request.flags & _DRM_SG_BUFFER )
 954                 return drm_addbufs_sg( inode, filp, cmd, arg );
 955         else
 956                 return drm_addbufs_pci( inode, filp, cmd, arg );
 957 }
 958
 959
 960 /**
 961  * Get information about the buffer mappings.
 962  *
 963  * This was originally mean for debugging purposes, or by a sophisticated
 964  * client library to determine how best to use the available buffers (e.g.,
 965  * large buffers can be used for image transfer).
 966  *
 967  * \param inode device inode.
 968  * \param filp file pointer.
 969  * \param cmd command.
 970  * \param arg pointer to a drm_buf_info structure.
 971  * \return zero on success or a negative number on failure.
 972  *
 973  * Increments drm_device::buf_use while holding the drm_device::count_lock
 974  * lock, preventing of allocating more buffers after this call. Information
 975  * about each requested buffer is then copied into user space.
 976  */
 977 int drm_infobufs( struct inode *inode, struct file *filp,
 978                    unsigned int cmd, unsigned long arg )
 979 {
 980         drm_file_t *priv = filp->private_data;
 981         drm_device_t *dev = priv->head->dev;
 982         drm_device_dma_t *dma = dev->dma;
 983         drm_buf_info_t request;
 984         drm_buf_info_t __user *argp = (void __user *)arg;
 985         int i;
 986         int count;
 987
 988         if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
 989                 return -EINVAL;
 990
 991         if ( !dma ) return -EINVAL;
 992
 993         spin_lock( &dev->count_lock );
 994         if ( atomic_read( &dev->buf_alloc ) ) {
 995                 spin_unlock( &dev->count_lock );
 996                 return -EBUSY;
 997         }
 998         ++dev->buf_use;         /* Can't allocate more after this call */
 999         spin_unlock( &dev->count_lock );
1000
1001         if ( copy_from_user( &request, argp, sizeof(request) ) )
1002                 return -EFAULT;
1003
1004         for ( i = 0, count = 0 ; i < DRM_MAX_ORDER + 1 ; i++ ) {
1005                 if ( dma->bufs[i].buf_count ) ++count;
1006         }
1007
1008         DRM_DEBUG( "count = %d\n", count );
1009
1010         if ( request.count >= count ) {
1011                 for ( i = 0, count = 0 ; i < DRM_MAX_ORDER + 1 ; i++ ) {
1012                         if ( dma->bufs[i].buf_count ) {
1013                                 drm_buf_desc_t __user *to = &request.list[count];
1014                                 drm_buf_entry_t *from = &dma->bufs[i];
1015                                 drm_freelist_t *list = &dma->bufs[i].freelist;
1016                                 if ( copy_to_user( &to->count,
1017                                                    &from->buf_count,
1018                                                    sizeof(from->buf_count) ) ||
1019                                      copy_to_user( &to->size,
1020                                                    &from->buf_size,
1021                                                    sizeof(from->buf_size) ) ||
1022                                      copy_to_user( &to->low_mark,
1023                                                    &list->low_mark,
1024                                                    sizeof(list->low_mark) ) ||
1025                                      copy_to_user( &to->high_mark,
1026                                                    &list->high_mark,
1027                                                    sizeof(list->high_mark) ) )
1028                                         return -EFAULT;
1029
1030                                 DRM_DEBUG( "%d %d %d %d %d\n",
1031                                            i,
1032                                            dma->bufs[i].buf_count,
1033                                            dma->bufs[i].buf_size,
1034                                            dma->bufs[i].freelist.low_mark,
1035                                            dma->bufs[i].freelist.high_mark );
1036                                 ++count;
1037                         }
1038                 }
1039         }
1040         request.count = count;
1041
1042         if ( copy_to_user( argp, &request, sizeof(request) ) )
1043                 return -EFAULT;
1044
1045         return 0;
1046 }
1047
1048 /**
1049  * Specifies a low and high water mark for buffer allocation
1050  *
1051  * \param inode device inode.
1052  * \param filp file pointer.
1053  * \param cmd command.
1054  * \param arg a pointer to a drm_buf_desc structure.
1055  * \return zero on success or a negative number on failure.
1056  *
1057  * Verifies that the size order is bounded between the admissible orders and
1058  * updates the respective drm_device_dma::bufs entry low and high water mark.
1059  *
1060  * \note This ioctl is deprecated and mostly never used.
1061  */
1062 int drm_markbufs( struct inode *inode, struct file *filp,
1063                    unsigned int cmd, unsigned long arg )
1064 {
1065         drm_file_t *priv = filp->private_data;
1066         drm_device_t *dev = priv->head->dev;
1067         drm_device_dma_t *dma = dev->dma;
1068         drm_buf_desc_t request;
1069         int order;
1070         drm_buf_entry_t *entry;
1071
1072         if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1073                 return -EINVAL;
1074
1075         if ( !dma ) return -EINVAL;
1076
1077         if ( copy_from_user( &request,
1078                              (drm_buf_desc_t __user *)arg,
1079                              sizeof(request) ) )
1080                 return -EFAULT;
1081
1082         DRM_DEBUG( "%d, %d, %d\n",
1083                    request.size, request.low_mark, request.high_mark );
1084         order = drm_order( request.size );
1085         if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
1086         entry = &dma->bufs[order];
1087
1088         if ( request.low_mark < 0 || request.low_mark > entry->buf_count )
1089                 return -EINVAL;
1090         if ( request.high_mark < 0 || request.high_mark > entry->buf_count )
1091                 return -EINVAL;
1092
1093         entry->freelist.low_mark  = request.low_mark;
1094         entry->freelist.high_mark = request.high_mark;
1095
1096         return 0;
1097 }
1098
1099 /**
1100  * Unreserve the buffers in list, previously reserved using drmDMA.
1101  *
1102  * \param inode device inode.
1103  * \param filp file pointer.
1104  * \param cmd command.
1105  * \param arg pointer to a drm_buf_free structure.
1106  * \return zero on success or a negative number on failure.
1107  *
1108  * Calls free_buffer() for each used buffer.
1109  * This function is primarily used for debugging.
1110  */
1111 int drm_freebufs( struct inode *inode, struct file *filp,
1112                    unsigned int cmd, unsigned long arg )
1113 {
1114         drm_file_t *priv = filp->private_data;
1115         drm_device_t *dev = priv->head->dev;
1116         drm_device_dma_t *dma = dev->dma;
1117         drm_buf_free_t request;
1118         int i;
1119         int idx;
1120         drm_buf_t *buf;
1121
1122         if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1123                 return -EINVAL;
1124
1125         if ( !dma ) return -EINVAL;
1126
1127         if ( copy_from_user( &request,
1128                              (drm_buf_free_t __user *)arg,
1129                              sizeof(request) ) )
1130                 return -EFAULT;
1131
1132         DRM_DEBUG( "%d\n", request.count );
1133         for ( i = 0 ; i < request.count ; i++ ) {
1134                 if ( copy_from_user( &idx,
1135                                      &request.list[i],
1136                                      sizeof(idx) ) )
1137                         return -EFAULT;
1138                 if ( idx < 0 || idx >= dma->buf_count ) {
1139                         DRM_ERROR( "Index %d (of %d max)\n",
1140                                    idx, dma->buf_count - 1 );
1141                         return -EINVAL;
1142                 }
1143                 buf = dma->buflist[idx];
1144                 if ( buf->filp != filp ) {
1145                         DRM_ERROR( "Process %d freeing buffer not owned\n",
1146                                    current->pid );
1147                         return -EINVAL;
1148                 }
1149                 drm_free_buffer( dev, buf );
1150         }
1151
1152         return 0;
1153 }
1154
1155 /**
1156  * Maps all of the DMA buffers into client-virtual space (ioctl).
1157  *
1158  * \param inode device inode.
1159  * \param filp file pointer.
1160  * \param cmd command.
1161  * \param arg pointer to a drm_buf_map structure.
1162  * \return zero on success or a negative number on failure.
1163  *
1164  * Maps the AGP or SG buffer region with do_mmap(), and copies information
1165  * about each buffer into user space. The PCI buffers are already mapped on the
1166  * addbufs_pci() call.
1167  */
1168 int drm_mapbufs( struct inode *inode, struct file *filp,
1169                   unsigned int cmd, unsigned long arg )
1170 {
1171         drm_file_t *priv = filp->private_data;
1172         drm_device_t *dev = priv->head->dev;
1173         drm_device_dma_t *dma = dev->dma;
1174         drm_buf_map_t __user *argp = (void __user *)arg;
1175         int retcode = 0;
1176         const int zero = 0;
1177         unsigned long virtual;
1178         unsigned long address;
1179         drm_buf_map_t request;
1180         int i;
1181
1182         if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
1183                 return -EINVAL;
1184
1185         if ( !dma ) return -EINVAL;
1186
1187         spin_lock( &dev->count_lock );
1188         if ( atomic_read( &dev->buf_alloc ) ) {
1189                 spin_unlock( &dev->count_lock );
1190                 return -EBUSY;
1191         }
1192         dev->buf_use++;         /* Can't allocate more after this call */
1193         spin_unlock( &dev->count_lock );
1194
1195         if ( copy_from_user( &request, argp, sizeof(request) ) )
1196                 return -EFAULT;
1197
1198         if ( request.count >= dma->buf_count ) {
1199                 if ((drm_core_has_AGP(dev) && (dma->flags & _DRM_DMA_USE_AGP)) ||
1200                     (drm_core_check_feature(dev, DRIVER_SG) && (dma->flags & _DRM_DMA_USE_SG)) ) {
1201                         drm_map_t *map = dev->agp_buffer_map;
1202
1203                         if ( !map ) {
1204                                 retcode = -EINVAL;
1205                                 goto done;
1206                         }
1207
1208 #if LINUX_VERSION_CODE <= 0x020402
1209                         down( &current->mm->mmap_sem );
1210 #else
1211                         down_write( &current->mm->mmap_sem );
1212 #endif
1213                         virtual = do_mmap( filp, 0, map->size,
1214                                            PROT_READ | PROT_WRITE,
1215                                            MAP_SHARED,
1216                                            (unsigned long)map->offset );
1217 #if LINUX_VERSION_CODE <= 0x020402
1218                         up( &current->mm->mmap_sem );
1219 #else
1220                         up_write( &current->mm->mmap_sem );
1221 #endif
1222                 } else {
1223 #if LINUX_VERSION_CODE <= 0x020402
1224                         down( &current->mm->mmap_sem );
1225 #else
1226                         down_write( &current->mm->mmap_sem );
1227 #endif
1228                         virtual = do_mmap( filp, 0, dma->byte_count,
1229                                            PROT_READ | PROT_WRITE,
1230                                            MAP_SHARED, 0 );
1231 #if LINUX_VERSION_CODE <= 0x020402
1232                         up( &current->mm->mmap_sem );
1233 #else
1234                         up_write( &current->mm->mmap_sem );
1235 #endif
1236                 }
1237                 if ( virtual > -1024UL ) {
1238                         /* Real error */
1239                         retcode = (signed long)virtual;
1240                         goto done;
1241                 }
1242                 request.virtual = (void __user *)virtual;
1243
1244                 for ( i = 0 ; i < dma->buf_count ; i++ ) {
1245                         if ( copy_to_user( &request.list[i].idx,
1246                                            &dma->buflist[i]->idx,
1247                                            sizeof(request.list[0].idx) ) ) {
1248                                 retcode = -EFAULT;
1249                                 goto done;
1250                         }
1251                         if ( copy_to_user( &request.list[i].total,
1252                                            &dma->buflist[i]->total,
1253                                            sizeof(request.list[0].total) ) ) {
1254                                 retcode = -EFAULT;
1255                                 goto done;
1256                         }
1257                         if ( copy_to_user( &request.list[i].used,
1258                                            &zero,
1259                                            sizeof(zero) ) ) {
1260                                 retcode = -EFAULT;
1261                                 goto done;
1262                         }
1263                         address = virtual + dma->buflist[i]->offset; /* *** */
1264                         if ( copy_to_user( &request.list[i].address,
1265                                            &address,
1266                                            sizeof(address) ) ) {
1267                                 retcode = -EFAULT;
1268                                 goto done;
1269                         }
1270                 }
1271         }
1272  done:
1273         request.count = dma->buf_count;
1274         DRM_DEBUG( "%d buffers, retcode = %d\n", request.count, retcode );
1275
1276         if ( copy_to_user( argp, &request, sizeof(request) ) )
1277                 return -EFAULT;
1278
1279         return retcode;
1280 }
1281