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