bsd-core/drm_bufs.c

   1 /* drm_bufs.h -- Generic buffer template -*- linux-c -*-
   2  * Created: Thu Nov 23 03:10:50 2000 by gareth@valinux.com
   3  */
   4 /*-
   5  * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
   6  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
   7  * All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the next
  17  * paragraph) shall be included in all copies or substantial portions of the
  18  * Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  24  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  25  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  26  * OTHER DEALINGS IN THE SOFTWARE.
  27  *
  28  * Authors:
  29  *    Rickard E. (Rik) Faith <faith@valinux.com>
  30  *    Gareth Hughes <gareth@valinux.com>
  31  *
  32  */
  33
  34 #include "drmP.h"
  35
  36 /*
  37  * Compute order.  Can be made faster.
  38  */
  39 int drm_order(unsigned long size)
  40 {
  41         int order;
  42         unsigned long tmp;
  43
  44         for ( order = 0, tmp = size ; tmp >>= 1 ; ++order );
  45
  46         if ( size & ~(1 << order) )
  47                 ++order;
  48
  49         return order;
  50 }
  51
  52 unsigned long drm_get_resource_start(drm_device_t *dev, unsigned int resource)
  53 {
  54         struct resource *bsr;
  55         unsigned long offset;
  56
  57         resource = resource * 4 + 0x10;
  58
  59         bsr = bus_alloc_resource_any(dev->device, SYS_RES_MEMORY, &resource,
  60             RF_ACTIVE | RF_SHAREABLE);
  61         if (bsr == NULL) {
  62                 DRM_ERROR("Couldn't find resource 0x%x\n", resource);
  63                 return 0;
  64         }
  65
  66         offset = rman_get_start(bsr);
  67
  68         bus_release_resource(dev->device, SYS_RES_MEMORY, resource, bsr);
  69
  70         return offset;
  71 }
  72
  73 unsigned long drm_get_resource_len(drm_device_t *dev, unsigned int resource)
  74 {
  75         struct resource *bsr;
  76         unsigned long len;
  77
  78         resource = resource * 4 + 0x10;
  79
  80         bsr = bus_alloc_resource_any(dev->device, SYS_RES_MEMORY, &resource,
  81             RF_ACTIVE | RF_SHAREABLE);
  82         if (bsr == NULL) {
  83                 DRM_ERROR("Couldn't find resource 0x%x\n", resource);
  84                 return ENOMEM;
  85         }
  86
  87         len = rman_get_size(bsr);
  88
  89         bus_release_resource(dev->device, SYS_RES_MEMORY, resource, bsr);
  90
  91         return len;
  92 }
  93
  94 int drm_initmap(drm_device_t *dev, unsigned long start, unsigned long len,
  95                 unsigned int resource, int type, int flags)
  96 {
  97         drm_local_map_t *map;
  98         struct resource *bsr;
  99
 100         if (type != _DRM_REGISTERS && type != _DRM_FRAME_BUFFER)
 101                 return EINVAL;
 102         if (len == 0)
 103                 return EINVAL;
 104
 105         map = malloc(sizeof(*map), M_DRM, M_ZERO | M_NOWAIT);
 106         if (map == NULL)
 107                 return ENOMEM;
 108
 109         map->rid = resource * 4 + 0x10;
 110         bsr = bus_alloc_resource_any(dev->device, SYS_RES_MEMORY, &map->rid,
 111             RF_ACTIVE | RF_SHAREABLE);
 112         if (bsr == NULL) {
 113                 DRM_ERROR("Couldn't allocate %s resource\n",
 114                     ((type == _DRM_REGISTERS) ? "mmio" : "framebuffer"));
 115                 free(map, M_DRM);
 116                 return ENOMEM;
 117         }
 118
 119         map->kernel_owned = 1;
 120         map->type = type;
 121         map->flags = flags;
 122         map->bsr = bsr;
 123         map->bst = rman_get_bustag(bsr);
 124         map->bsh = rman_get_bushandle(bsr);
 125         map->offset = start;
 126         map->size = len;
 127
 128         if (type == _DRM_REGISTERS)
 129                 map->handle = rman_get_virtual(bsr);
 130
 131         DRM_DEBUG("initmap %d,0x%x@0x%lx/0x%lx\n", map->type, map->flags,
 132             map->offset, map->size);
 133
 134         if (map->flags & _DRM_WRITE_COMBINING) {
 135                 int err;
 136
 137                 err = drm_mtrr_add(map->offset, map->size, DRM_MTRR_WC);
 138                 if (err == 0)
 139                         map->mtrr = 1;
 140         }
 141
 142         DRM_LOCK();
 143         TAILQ_INSERT_TAIL(&dev->maplist, map, link);
 144         DRM_UNLOCK();
 145
 146         return 0;
 147 }
 148
 149 int drm_addmap(DRM_IOCTL_ARGS)
 150 {
 151         DRM_DEVICE;
 152         drm_map_t request;
 153         drm_local_map_t *map;
 154         dma_addr_t bus_addr;
 155
 156         if (!(dev->flags & (FREAD|FWRITE)))
 157                 return DRM_ERR(EACCES); /* Require read/write */
 158
 159         DRM_COPY_FROM_USER_IOCTL( request, (drm_map_t *)data, sizeof(drm_map_t) );
 160
 161         /* Only allow shared memory to be removable since we only keep enough
 162          * book keeping information about shared memory to allow for removal
 163          * when processes fork.
 164          */
 165         if ((request.flags & _DRM_REMOVABLE) && request.type != _DRM_SHM)
 166                 return EINVAL;
 167         if ((request.offset & PAGE_MASK) || (request.size & PAGE_MASK))
 168                 return EINVAL;
 169         if (request.offset + request.size < request.offset)
 170                 return EINVAL;
 171
 172         DRM_DEBUG("offset = 0x%08lx, size = 0x%08lx, type = %d\n",
 173             request.offset, request.size, request.type);
 174
 175         /* Check if this is just another version of a kernel-allocated map, and
 176          * just hand that back if so.
 177          */
 178         if (request.type == _DRM_REGISTERS || request.type == _DRM_FRAME_BUFFER)
 179         {
 180                 DRM_LOCK();
 181                 TAILQ_FOREACH(map, &dev->maplist, link) {
 182                         if (map->kernel_owned && map->type == request.type &&
 183                             map->offset == request.offset) {
 184                                 /* XXX: this size setting is questionable. */
 185                                 map->size = request.size;
 186                                 DRM_DEBUG("Found kernel map %d\n", request.type);
 187                                 goto done;
 188                         }
 189                 }
 190                 DRM_UNLOCK();
 191         }
 192
 193         /* Allocate a new map structure, fill it in, and do any type-specific
 194          * initialization necessary.
 195          */
 196         map = malloc(sizeof(*map), M_DRM, M_ZERO | M_NOWAIT);
 197         if ( !map )
 198                 return DRM_ERR(ENOMEM);
 199
 200         map->offset = request.offset;
 201         map->size = request.size;
 202         map->type = request.type;
 203         map->flags = request.flags;
 204
 205         switch ( map->type ) {
 206         case _DRM_REGISTERS:
 207                 map->handle = drm_ioremap(dev, map);
 208                 if (!(map->flags & _DRM_WRITE_COMBINING))
 209                         break;
 210                 /* FALLTHROUGH */
 211         case _DRM_FRAME_BUFFER:
 212                 if (drm_mtrr_add(map->offset, map->size, DRM_MTRR_WC) == 0)
 213                         map->mtrr = 1;
 214                 break;
 215         case _DRM_SHM:
 216                 map->handle = malloc(map->size, M_DRM, M_NOWAIT);
 217                 DRM_DEBUG( "%lu %d %p\n",
 218                            map->size, drm_order(map->size), map->handle );
 219                 if ( !map->handle ) {
 220                         free(map, M_DRM);
 221                         return DRM_ERR(ENOMEM);
 222                 }
 223                 map->offset = (unsigned long)map->handle;
 224                 if ( map->flags & _DRM_CONTAINS_LOCK ) {
 225                         /* Prevent a 2nd X Server from creating a 2nd lock */
 226                         DRM_LOCK();
 227                         if (dev->lock.hw_lock != NULL) {
 228                                 DRM_UNLOCK();
 229                                 free(map->handle, M_DRM);
 230                                 free(map, M_DRM);
 231                                 return DRM_ERR(EBUSY);
 232                         }
 233                         dev->lock.hw_lock = map->handle; /* Pointer to lock */
 234                         DRM_UNLOCK();
 235                 }
 236                 break;
 237         case _DRM_AGP:
 238                 map->offset += dev->agp->base;
 239                 map->mtrr   = dev->agp->mtrr; /* for getmap */
 240                 break;
 241         case _DRM_SCATTER_GATHER:
 242                 if (!dev->sg) {
 243                         free(map, M_DRM);
 244                         return DRM_ERR(EINVAL);
 245                 }
 246                 map->offset = map->offset + dev->sg->handle;
 247                 break;
 248         case _DRM_CONSISTENT:
 249                 map->handle = drm_pci_alloc(dev, map->size, map->size,
 250                     0xfffffffful, &bus_addr);
 251                 if (map->handle == NULL) {
 252                         free(map, M_DRM);
 253                         return ENOMEM;
 254                 }
 255                 map->offset = (unsigned long)bus_addr;
 256                 break;
 257         default:
 258                 free(map, M_DRM);
 259                 return DRM_ERR(EINVAL);
 260         }
 261
 262         DRM_LOCK();
 263         TAILQ_INSERT_TAIL(&dev->maplist, map, link);
 264
 265 done:
 266         /* Jumped to, with lock held, when a kernel map is found. */
 267         request.offset = map->offset;
 268         request.size = map->size;
 269         request.type = map->type;
 270         request.flags = map->flags;
 271         request.mtrr   = map->mtrr;
 272         request.handle = map->handle;
 273         DRM_UNLOCK();
 274
 275         DRM_DEBUG("Added map %d 0x%lx/0x%lx\n", request.type, request.offset, request.size);
 276
 277         if ( request.type != _DRM_SHM ) {
 278                 request.handle = (void *)request.offset;
 279         }
 280
 281         DRM_COPY_TO_USER_IOCTL( (drm_map_t *)data, request, sizeof(drm_map_t) );
 282
 283         return 0;
 284 }
 285
 286 void drm_remove_map(drm_device_t *dev, drm_local_map_t *map)
 287 {
 288         DRM_SPINLOCK_ASSERT(&dev->dev_lock);
 289
 290         TAILQ_REMOVE(&dev->maplist, map, link);
 291
 292         switch (map->type) {
 293         case _DRM_REGISTERS:
 294                 if (map->bsr == NULL)
 295                         drm_ioremapfree(map);
 296                 /* FALLTHROUGH */
 297         case _DRM_FRAME_BUFFER:
 298                 if (map->mtrr) {
 299                         int __unused retcode;
 300
 301                         retcode = drm_mtrr_del(map->offset, map->size,
 302                             DRM_MTRR_WC);
 303                         DRM_DEBUG("mtrr_del = %d\n", retcode);
 304                 }
 305                 break;
 306         case _DRM_SHM:
 307                 free(map->handle, M_DRM);
 308                 break;
 309         case _DRM_AGP:
 310         case _DRM_SCATTER_GATHER:
 311                 break;
 312         case _DRM_CONSISTENT:
 313                 drm_pci_free(dev, map->size, map->handle, map->offset);
 314                 break;
 315         }
 316
 317         if (map->bsr != NULL) {
 318                 bus_release_resource(dev->device, SYS_RES_MEMORY, map->rid,
 319                     map->bsr);
 320         }
 321
 322         free(map, M_DRM);
 323 }
 324
 325 /* Remove a map private from list and deallocate resources if the mapping
 326  * isn't in use.
 327  */
 328
 329 int drm_rmmap(DRM_IOCTL_ARGS)
 330 {
 331         DRM_DEVICE;
 332         drm_local_map_t *map;
 333         drm_map_t request;
 334
 335         DRM_COPY_FROM_USER_IOCTL( request, (drm_map_t *)data, sizeof(request) );
 336
 337         DRM_LOCK();
 338         TAILQ_FOREACH(map, &dev->maplist, link) {
 339                 if (map->handle == request.handle &&
 340                     map->flags & _DRM_REMOVABLE)
 341                         break;
 342         }
 343
 344         /* No match found. */
 345         if (map == NULL) {
 346                 DRM_UNLOCK();
 347                 return DRM_ERR(EINVAL);
 348         }
 349
 350         drm_remove_map(dev, map);
 351
 352         DRM_UNLOCK();
 353
 354         return 0;
 355 }
 356
 357
 358 static void drm_cleanup_buf_error(drm_device_t *dev, drm_buf_entry_t *entry)
 359 {
 360         int i;
 361
 362         if (entry->seg_count) {
 363                 for (i = 0; i < entry->seg_count; i++) {
 364                         drm_pci_free(dev, entry->buf_size,
 365                             (void *)entry->seglist[i],
 366                             entry->seglist_bus[i]);
 367                 }
 368                 free(entry->seglist, M_DRM);
 369                 free(entry->seglist_bus, M_DRM);
 370
 371                 entry->seg_count = 0;
 372         }
 373
 374         if (entry->buf_count) {
 375                 for (i = 0; i < entry->buf_count; i++) {
 376                         free(entry->buflist[i].dev_private, M_DRM);
 377                 }
 378                 free(entry->buflist, M_DRM);
 379
 380                 entry->buf_count = 0;
 381         }
 382 }
 383
 384 static int drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
 385 {
 386         drm_device_dma_t *dma = dev->dma;
 387         drm_buf_entry_t *entry;
 388         drm_buf_t *buf;
 389         unsigned long offset;
 390         unsigned long agp_offset;
 391         int count;
 392         int order;
 393         int size;
 394         int alignment;
 395         int page_order;
 396         int total;
 397         int byte_count;
 398         int i;
 399         drm_buf_t **temp_buflist;
 400
 401         count = request->count;
 402         order = drm_order(request->size);
 403         size = 1 << order;
 404
 405         alignment  = (request->flags & _DRM_PAGE_ALIGN)
 406                 ? round_page(size) : size;
 407         page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
 408         total = PAGE_SIZE << page_order;
 409
 410         byte_count = 0;
 411         agp_offset = dev->agp->base + request->agp_start;
 412
 413         DRM_DEBUG( "count:      %d\n",  count );
 414         DRM_DEBUG( "order:      %d\n",  order );
 415         DRM_DEBUG( "size:       %d\n",  size );
 416         DRM_DEBUG( "agp_offset: 0x%lx\n", agp_offset );
 417         DRM_DEBUG( "alignment:  %d\n",  alignment );
 418         DRM_DEBUG( "page_order: %d\n",  page_order );
 419         DRM_DEBUG( "total:      %d\n",  total );
 420
 421         entry = &dma->bufs[order];
 422
 423         entry->buflist = malloc(count * sizeof(*entry->buflist), M_DRM,
 424             M_NOWAIT | M_ZERO);
 425         if ( !entry->buflist ) {
 426                 return DRM_ERR(ENOMEM);
 427         }
 428
 429         entry->buf_size = size;
 430         entry->page_order = page_order;
 431
 432         offset = 0;
 433
 434         while ( entry->buf_count < count ) {
 435                 buf          = &entry->buflist[entry->buf_count];
 436                 buf->idx     = dma->buf_count + entry->buf_count;
 437                 buf->total   = alignment;
 438                 buf->order   = order;
 439                 buf->used    = 0;
 440
 441                 buf->offset  = (dma->byte_count + offset);
 442                 buf->bus_address = agp_offset + offset;
 443                 buf->address = (void *)(agp_offset + offset);
 444                 buf->next    = NULL;
 445                 buf->pending = 0;
 446                 buf->filp    = NULL;
 447
 448                 buf->dev_priv_size = dev->dev_priv_size;
 449                 buf->dev_private = malloc(buf->dev_priv_size, M_DRM,
 450                     M_NOWAIT | M_ZERO);
 451                 if (buf->dev_private == NULL) {
 452                         /* Set count correctly so we free the proper amount. */
 453                         entry->buf_count = count;
 454                         drm_cleanup_buf_error(dev, entry);
 455                         return DRM_ERR(ENOMEM);
 456                 }
 457
 458                 offset += alignment;
 459                 entry->buf_count++;
 460                 byte_count += PAGE_SIZE << page_order;
 461         }
 462
 463         DRM_DEBUG( "byte_count: %d\n", byte_count );
 464
 465         temp_buflist = realloc(dma->buflist,
 466             (dma->buf_count + entry->buf_count) * sizeof(*dma->buflist), M_DRM,
 467             M_NOWAIT);
 468         if (temp_buflist == NULL) {
 469                 /* Free the entry because it isn't valid */
 470                 drm_cleanup_buf_error(dev, entry);
 471                 return DRM_ERR(ENOMEM);
 472         }
 473         dma->buflist = temp_buflist;
 474
 475         for ( i = 0 ; i < entry->buf_count ; i++ ) {
 476                 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
 477         }
 478
 479         dma->buf_count += entry->buf_count;
 480         dma->byte_count += byte_count;
 481
 482         DRM_DEBUG( "dma->buf_count : %d\n", dma->buf_count );
 483         DRM_DEBUG( "entry->buf_count : %d\n", entry->buf_count );
 484
 485         request->count = entry->buf_count;
 486         request->size = size;
 487
 488         dma->flags = _DRM_DMA_USE_AGP;
 489
 490         return 0;
 491 }
 492
 493 static int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
 494 {
 495         drm_device_dma_t *dma = dev->dma;
 496         int count;
 497         int order;
 498         int size;
 499         int total;
 500         int page_order;
 501         drm_buf_entry_t *entry;
 502         vm_offset_t vaddr;
 503         drm_buf_t *buf;
 504         int alignment;
 505         unsigned long offset;
 506         int i;
 507         int byte_count;
 508         int page_count;
 509         unsigned long *temp_pagelist;
 510         drm_buf_t **temp_buflist;
 511         dma_addr_t bus_addr;
 512
 513         count = request->count;
 514         order = drm_order(request->size);
 515         size = 1 << order;
 516
 517         DRM_DEBUG( "count=%d, size=%d (%d), order=%d\n",
 518                    request->count, request->size, size, order );
 519
 520         alignment = (request->flags & _DRM_PAGE_ALIGN)
 521                 ? round_page(size) : size;
 522         page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
 523         total = PAGE_SIZE << page_order;
 524
 525         entry = &dma->bufs[order];
 526
 527         entry->buflist = malloc(count * sizeof(*entry->buflist), M_DRM,
 528             M_NOWAIT | M_ZERO);
 529         entry->seglist = malloc(count * sizeof(*entry->seglist), M_DRM,
 530             M_NOWAIT | M_ZERO);
 531         entry->seglist_bus = malloc(count * sizeof(*entry->seglist_bus), M_DRM,
 532             M_NOWAIT | M_ZERO);
 533
 534         /* Keep the original pagelist until we know all the allocations
 535          * have succeeded
 536          */
 537         temp_pagelist = malloc((dma->page_count + (count << page_order)) *
 538             sizeof(*dma->pagelist), M_DRM, M_NOWAIT);
 539
 540         if (entry->buflist == NULL || entry->seglist == NULL ||
 541             entry->seglist_bus == NULL || temp_pagelist == NULL) {
 542                 free(entry->buflist, M_DRM);
 543                 free(entry->seglist, M_DRM);
 544                 free(entry->seglist_bus, M_DRM);
 545                 return DRM_ERR(ENOMEM);
 546         }
 547
 548         memcpy(temp_pagelist, dma->pagelist, dma->page_count *
 549             sizeof(*dma->pagelist));
 550
 551         DRM_DEBUG( "pagelist: %d entries\n",
 552                    dma->page_count + (count << page_order) );
 553
 554         entry->buf_size = size;
 555         entry->page_order = page_order;
 556         byte_count = 0;
 557         page_count = 0;
 558
 559         while ( entry->buf_count < count ) {
 560                 vaddr = (vm_offset_t)drm_pci_alloc(dev, size, alignment,
 561                     0xfffffffful, &bus_addr);
 562                 if (vaddr == 0) {
 563                         /* Set count correctly so we free the proper amount. */
 564                         entry->buf_count = count;
 565                         entry->seg_count = count;
 566                         drm_cleanup_buf_error(dev, entry);
 567                         free(temp_pagelist, M_DRM);
 568                         return DRM_ERR(ENOMEM);
 569                 }
 570
 571                 entry->seglist_bus[entry->seg_count] = bus_addr;
 572                 entry->seglist[entry->seg_count++] = vaddr;
 573                 for ( i = 0 ; i < (1 << page_order) ; i++ ) {
 574                         DRM_DEBUG( "page %d @ 0x%08lx\n",
 575                                    dma->page_count + page_count,
 576                                    (long)vaddr + PAGE_SIZE * i );
 577                         temp_pagelist[dma->page_count + page_count++] =
 578                             vaddr + PAGE_SIZE * i;
 579                 }
 580                 for ( offset = 0 ;
 581                       offset + size <= total && entry->buf_count < count ;
 582                       offset += alignment, ++entry->buf_count ) {
 583                         buf          = &entry->buflist[entry->buf_count];
 584                         buf->idx     = dma->buf_count + entry->buf_count;
 585                         buf->total   = alignment;
 586                         buf->order   = order;
 587                         buf->used    = 0;
 588                         buf->offset  = (dma->byte_count + byte_count + offset);
 589                         buf->address = (void *)(vaddr + offset);
 590                         buf->bus_address = bus_addr + offset;
 591                         buf->next    = NULL;
 592                         buf->pending = 0;
 593                         buf->filp    = NULL;
 594
 595                         buf->dev_priv_size = dev->dev_priv_size;
 596                         buf->dev_private = malloc(buf->dev_priv_size, M_DRM,
 597                             M_NOWAIT | M_ZERO);
 598                         if (buf->dev_private == NULL) {
 599                                 /* Set count correctly so we free the proper amount. */
 600                                 entry->buf_count = count;
 601                                 entry->seg_count = count;
 602                                 drm_cleanup_buf_error(dev, entry);
 603                                 free(temp_pagelist, M_DRM);
 604                                 return DRM_ERR(ENOMEM);
 605                         }
 606
 607                         DRM_DEBUG( "buffer %d @ %p\n",
 608                                    entry->buf_count, buf->address );
 609                 }
 610                 byte_count += PAGE_SIZE << page_order;
 611         }
 612
 613         temp_buflist = realloc(dma->buflist,
 614             (dma->buf_count + entry->buf_count) * sizeof(*dma->buflist), M_DRM,
 615             M_NOWAIT);
 616         if (temp_buflist == NULL) {
 617                 /* Free the entry because it isn't valid */
 618                 drm_cleanup_buf_error(dev, entry);
 619                 free(temp_pagelist, M_DRM);
 620                 return DRM_ERR(ENOMEM);
 621         }
 622         dma->buflist = temp_buflist;
 623
 624         for ( i = 0 ; i < entry->buf_count ; i++ ) {
 625                 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
 626         }
 627
 628         /* No allocations failed, so now we can replace the orginal pagelist
 629          * with the new one.
 630          */
 631         free(dma->pagelist, M_DRM);
 632         dma->pagelist = temp_pagelist;
 633
 634         dma->buf_count += entry->buf_count;
 635         dma->seg_count += entry->seg_count;
 636         dma->page_count += entry->seg_count << page_order;
 637         dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
 638
 639         request->count = entry->buf_count;
 640         request->size = size;
 641
 642         return 0;
 643
 644 }
 645
 646 static int drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
 647 {
 648         drm_device_dma_t *dma = dev->dma;
 649         drm_buf_entry_t *entry;
 650         drm_buf_t *buf;
 651         unsigned long offset;
 652         unsigned long agp_offset;
 653         int count;
 654         int order;
 655         int size;
 656         int alignment;
 657         int page_order;
 658         int total;
 659         int byte_count;
 660         int i;
 661         drm_buf_t **temp_buflist;
 662
 663         count = request->count;
 664         order = drm_order(request->size);
 665         size = 1 << order;
 666
 667         alignment  = (request->flags & _DRM_PAGE_ALIGN)
 668                 ? round_page(size) : size;
 669         page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
 670         total = PAGE_SIZE << page_order;
 671
 672         byte_count = 0;
 673         agp_offset = request->agp_start;
 674
 675         DRM_DEBUG( "count:      %d\n",  count );
 676         DRM_DEBUG( "order:      %d\n",  order );
 677         DRM_DEBUG( "size:       %d\n",  size );
 678         DRM_DEBUG( "agp_offset: %ld\n", agp_offset );
 679         DRM_DEBUG( "alignment:  %d\n",  alignment );
 680         DRM_DEBUG( "page_order: %d\n",  page_order );
 681         DRM_DEBUG( "total:      %d\n",  total );
 682
 683         entry = &dma->bufs[order];
 684
 685         entry->buflist = malloc(count * sizeof(*entry->buflist), M_DRM,
 686             M_NOWAIT | M_ZERO);
 687         if (entry->buflist == NULL)
 688                 return DRM_ERR(ENOMEM);
 689
 690         entry->buf_size = size;
 691         entry->page_order = page_order;
 692
 693         offset = 0;
 694
 695         while ( entry->buf_count < count ) {
 696                 buf          = &entry->buflist[entry->buf_count];
 697                 buf->idx     = dma->buf_count + entry->buf_count;
 698                 buf->total   = alignment;
 699                 buf->order   = order;
 700                 buf->used    = 0;
 701
 702                 buf->offset  = (dma->byte_count + offset);
 703                 buf->bus_address = agp_offset + offset;
 704                 buf->address = (void *)(agp_offset + offset + dev->sg->handle);
 705                 buf->next    = NULL;
 706                 buf->pending = 0;
 707                 buf->filp    = NULL;
 708
 709                 buf->dev_priv_size = dev->dev_priv_size;
 710                 buf->dev_private = malloc(buf->dev_priv_size, M_DRM,
 711                     M_NOWAIT | M_ZERO);
 712                 if (buf->dev_private == NULL) {
 713                         /* Set count correctly so we free the proper amount. */
 714                         entry->buf_count = count;
 715                         drm_cleanup_buf_error(dev, entry);
 716                         return DRM_ERR(ENOMEM);
 717                 }
 718
 719                 DRM_DEBUG( "buffer %d @ %p\n",
 720                            entry->buf_count, buf->address );
 721
 722                 offset += alignment;
 723                 entry->buf_count++;
 724                 byte_count += PAGE_SIZE << page_order;
 725         }
 726
 727         DRM_DEBUG( "byte_count: %d\n", byte_count );
 728
 729         temp_buflist = realloc(dma->buflist,
 730             (dma->buf_count + entry->buf_count) * sizeof(*dma->buflist), M_DRM,
 731             M_NOWAIT);
 732         if (temp_buflist == NULL) {
 733                 /* Free the entry because it isn't valid */
 734                 drm_cleanup_buf_error(dev, entry);
 735                 return DRM_ERR(ENOMEM);
 736         }
 737         dma->buflist = temp_buflist;
 738
 739         for ( i = 0 ; i < entry->buf_count ; i++ ) {
 740                 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
 741         }
 742
 743         dma->buf_count += entry->buf_count;
 744         dma->byte_count += byte_count;
 745
 746         DRM_DEBUG( "dma->buf_count : %d\n", dma->buf_count );
 747         DRM_DEBUG( "entry->buf_count : %d\n", entry->buf_count );
 748
 749         request->count = entry->buf_count;
 750         request->size = size;
 751
 752         dma->flags = _DRM_DMA_USE_SG;
 753
 754         return 0;
 755 }
 756
 757 int drm_addbufs(DRM_IOCTL_ARGS)
 758 {
 759         DRM_DEVICE;
 760         drm_buf_desc_t request;
 761         int err;
 762         int order;
 763
 764         DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
 765
 766         if (request.count < 0 || request.count > 4096)
 767                 return DRM_ERR(EINVAL);
 768
 769         order = drm_order(request.size);
 770         if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
 771                 return DRM_ERR(EINVAL);
 772
 773         DRM_SPINLOCK(&dev->dma_lock);
 774         /* No more allocations after first buffer-using ioctl. */
 775         if (dev->buf_use != 0) {
 776                 DRM_SPINUNLOCK(&dev->dma_lock);
 777                 return DRM_ERR(EBUSY);
 778         }
 779         /* No more than one allocation per order */
 780         if (dev->dma->bufs[order].buf_count != 0) {
 781                 DRM_SPINUNLOCK(&dev->dma_lock);
 782                 return DRM_ERR(ENOMEM);
 783         }
 784
 785         if ( request.flags & _DRM_AGP_BUFFER )
 786                 err = drm_addbufs_agp(dev, &request);
 787         else
 788         if ( request.flags & _DRM_SG_BUFFER )
 789                 err = drm_addbufs_sg(dev, &request);
 790         else
 791                 err = drm_addbufs_pci(dev, &request);
 792         DRM_SPINUNLOCK(&dev->dma_lock);
 793
 794         DRM_COPY_TO_USER_IOCTL((drm_buf_desc_t *)data, request, sizeof(request));
 795
 796         return err;
 797 }
 798
 799 int drm_infobufs(DRM_IOCTL_ARGS)
 800 {
 801         DRM_DEVICE;
 802         drm_device_dma_t *dma = dev->dma;
 803         drm_buf_info_t request;
 804         int i;
 805         int count;
 806         int retcode = 0;
 807
 808         DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_info_t *)data, sizeof(request) );
 809
 810         DRM_SPINLOCK(&dev->dma_lock);
 811         ++dev->buf_use;         /* Can't allocate more after this call */
 812         DRM_SPINUNLOCK(&dev->dma_lock);
 813
 814         for ( i = 0, count = 0 ; i < DRM_MAX_ORDER + 1 ; i++ ) {
 815                 if ( dma->bufs[i].buf_count ) ++count;
 816         }
 817
 818         DRM_DEBUG( "count = %d\n", count );
 819
 820         if ( request.count >= count ) {
 821                 for ( i = 0, count = 0 ; i < DRM_MAX_ORDER + 1 ; i++ ) {
 822                         if ( dma->bufs[i].buf_count ) {
 823                                 drm_buf_desc_t from;
 824
 825                                 from.count = dma->bufs[i].buf_count;
 826                                 from.size = dma->bufs[i].buf_size;
 827                                 from.low_mark = dma->bufs[i].freelist.low_mark;
 828                                 from.high_mark = dma->bufs[i].freelist.high_mark;
 829
 830                                 if (DRM_COPY_TO_USER(&request.list[count], &from,
 831                                     sizeof(drm_buf_desc_t)) != 0) {
 832                                         retcode = DRM_ERR(EFAULT);
 833                                         break;
 834                                 }
 835
 836                                 DRM_DEBUG( "%d %d %d %d %d\n",
 837                                            i,
 838                                            dma->bufs[i].buf_count,
 839                                            dma->bufs[i].buf_size,
 840                                            dma->bufs[i].freelist.low_mark,
 841                                            dma->bufs[i].freelist.high_mark );
 842                                 ++count;
 843                         }
 844                 }
 845         }
 846         request.count = count;
 847
 848         DRM_COPY_TO_USER_IOCTL( (drm_buf_info_t *)data, request, sizeof(request) );
 849
 850         return retcode;
 851 }
 852
 853 int drm_markbufs(DRM_IOCTL_ARGS)
 854 {
 855         DRM_DEVICE;
 856         drm_device_dma_t *dma = dev->dma;
 857         drm_buf_desc_t request;
 858         int order;
 859
 860         DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
 861
 862         DRM_DEBUG( "%d, %d, %d\n",
 863                    request.size, request.low_mark, request.high_mark );
 864
 865
 866         order = drm_order(request.size);
 867         if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ||
 868             request.low_mark < 0 || request.high_mark < 0) {
 869                 return DRM_ERR(EINVAL);
 870         }
 871
 872         DRM_SPINLOCK(&dev->dma_lock);
 873         if (request.low_mark > dma->bufs[order].buf_count ||
 874             request.high_mark > dma->bufs[order].buf_count) {
 875                 return DRM_ERR(EINVAL);
 876         }
 877
 878         dma->bufs[order].freelist.low_mark  = request.low_mark;
 879         dma->bufs[order].freelist.high_mark = request.high_mark;
 880         DRM_SPINUNLOCK(&dev->dma_lock);
 881
 882         return 0;
 883 }
 884
 885 int drm_freebufs(DRM_IOCTL_ARGS)
 886 {
 887         DRM_DEVICE;
 888         drm_device_dma_t *dma = dev->dma;
 889         drm_buf_free_t request;
 890         int i;
 891         int idx;
 892         drm_buf_t *buf;
 893         int retcode = 0;
 894
 895         DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_free_t *)data, sizeof(request) );
 896
 897         DRM_DEBUG( "%d\n", request.count );
 898
 899         DRM_SPINLOCK(&dev->dma_lock);
 900         for ( i = 0 ; i < request.count ; i++ ) {
 901                 if (DRM_COPY_FROM_USER(&idx, &request.list[i], sizeof(idx))) {
 902                         retcode = DRM_ERR(EFAULT);
 903                         break;
 904                 }
 905                 if ( idx < 0 || idx >= dma->buf_count ) {
 906                         DRM_ERROR( "Index %d (of %d max)\n",
 907                                    idx, dma->buf_count - 1 );
 908                         retcode = DRM_ERR(EINVAL);
 909                         break;
 910                 }
 911                 buf = dma->buflist[idx];
 912                 if ( buf->filp != filp ) {
 913                         DRM_ERROR("Process %d freeing buffer not owned\n",
 914                                    DRM_CURRENTPID);
 915                         retcode = DRM_ERR(EINVAL);
 916                         break;
 917                 }
 918                 drm_free_buffer(dev, buf);
 919         }
 920         DRM_SPINUNLOCK(&dev->dma_lock);
 921
 922         return retcode;
 923 }
 924
 925 int drm_mapbufs(DRM_IOCTL_ARGS)
 926 {
 927         DRM_DEVICE;
 928         drm_device_dma_t *dma = dev->dma;
 929         int retcode = 0;
 930         const int zero = 0;
 931         vm_offset_t address;
 932         struct vmspace *vms;
 933 #ifdef __FreeBSD__
 934         vm_ooffset_t foff;
 935         vm_size_t size;
 936         vm_offset_t vaddr;
 937 #elif defined(__NetBSD__) || defined(__OpenBSD__)
 938         struct vnode *vn;
 939         vm_size_t size;
 940         vaddr_t vaddr;
 941 #endif /* __NetBSD__ || __OpenBSD__ */
 942
 943         drm_buf_map_t request;
 944         int i;
 945
 946         DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_map_t *)data, sizeof(request) );
 947
 948 #if defined(__NetBSD__) || defined(__OpenBSD__)
 949         if (!vfinddev(kdev, VCHR, &vn))
 950                 return 0;       /* FIXME: Shouldn't this be EINVAL or something? */
 951 #endif /* __NetBSD__ || __OpenBSD */
 952
 953 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
 954         vms = p->td_proc->p_vmspace;
 955 #else
 956         vms = p->p_vmspace;
 957 #endif
 958
 959         DRM_SPINLOCK(&dev->dma_lock);
 960         dev->buf_use++;         /* Can't allocate more after this call */
 961         DRM_SPINUNLOCK(&dev->dma_lock);
 962
 963         if (request.count < dma->buf_count)
 964                 goto done;
 965
 966         if ((dev->use_agp && (dma->flags & _DRM_DMA_USE_AGP)) ||
 967             (dev->use_sg && (dma->flags & _DRM_DMA_USE_SG))) {
 968                 drm_local_map_t *map = dev->agp_buffer_map;
 969
 970                 if (map == NULL) {
 971                         retcode = EINVAL;
 972                         goto done;
 973                 }
 974                 size = round_page(map->size);
 975                 foff = map->offset;
 976         } else {
 977                 size = round_page(dma->byte_count),
 978                 foff = 0;
 979         }
 980
 981 #ifdef __FreeBSD__
 982         vaddr = round_page((vm_offset_t)vms->vm_daddr + MAXDSIZ);
 983 #if __FreeBSD_version >= 600023
 984         retcode = vm_mmap(&vms->vm_map, &vaddr, size, PROT_READ | PROT_WRITE,
 985             VM_PROT_ALL, MAP_SHARED, OBJT_DEVICE, kdev, foff );
 986 #else
 987         retcode = vm_mmap(&vms->vm_map, &vaddr, size, PROT_READ | PROT_WRITE,
 988             VM_PROT_ALL, MAP_SHARED, SLIST_FIRST(&kdev->si_hlist), foff );
 989 #endif
 990 #elif defined(__NetBSD__) || defined(__OpenBSD__)
 991         vaddr = round_page((vaddr_t)vms->vm_daddr + MAXDSIZ);
 992         retcode = uvm_mmap(&vms->vm_map, &vaddr, size,
 993             UVM_PROT_READ | UVM_PROT_WRITE, UVM_PROT_ALL, MAP_SHARED,
 994             &vn->v_uobj, foff, p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur);
 995 #endif /* __NetBSD__ || __OpenBSD */
 996         if (retcode)
 997                 goto done;
 998
 999         request.virtual = (void *)vaddr;
1000
1001         for ( i = 0 ; i < dma->buf_count ; i++ ) {
1002                 if (DRM_COPY_TO_USER(&request.list[i].idx,
1003                     &dma->buflist[i]->idx, sizeof(request.list[0].idx))) {
1004                         retcode = EFAULT;
1005                         goto done;
1006                 }
1007                 if (DRM_COPY_TO_USER(&request.list[i].total,
1008                     &dma->buflist[i]->total, sizeof(request.list[0].total))) {
1009                         retcode = EFAULT;
1010                         goto done;
1011                 }
1012                 if (DRM_COPY_TO_USER(&request.list[i].used, &zero,
1013                     sizeof(zero))) {
1014                         retcode = EFAULT;
1015                         goto done;
1016                 }
1017                 address = vaddr + dma->buflist[i]->offset; /* *** */
1018                 if (DRM_COPY_TO_USER(&request.list[i].address, &address,
1019                     sizeof(address))) {
1020                         retcode = EFAULT;
1021                         goto done;
1022                 }
1023         }
1024
1025  done:
1026         request.count = dma->buf_count;
1027
1028         DRM_DEBUG( "%d buffers, retcode = %d\n", request.count, retcode );
1029
1030         DRM_COPY_TO_USER_IOCTL((drm_buf_map_t *)data, request, sizeof(request));
1031
1032         return DRM_ERR(retcode);
1033 }