1 /* drm_bufs.h -- Generic buffer template -*- linux-c -*-
2 * Created: Thu Nov 23 03:10:50 2000 by gareth@valinux.com
4 * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
5 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
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:
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
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.
28 * Rickard E. (Rik) Faith <faith@valinux.com>
29 * Gareth Hughes <gareth@valinux.com>
32 #include <linux/vmalloc.h>
35 #ifndef __HAVE_PCI_DMA
36 #define __HAVE_PCI_DMA 0
43 #ifndef DRIVER_BUF_PRIV_T
44 #define DRIVER_BUF_PRIV_T u32
46 #ifndef DRIVER_AGP_BUFFERS_MAP
47 #if __HAVE_AGP && __HAVE_DMA
48 #error "You must define DRIVER_AGP_BUFFERS_MAP()"
50 #define DRIVER_AGP_BUFFERS_MAP( dev ) NULL
55 * Compute order. Can be made faster.
57 int DRM(order)( unsigned long size )
62 for ( order = 0, tmp = size ; tmp >>= 1 ; ++order );
64 if ( size & ~(1 << order) )
70 int DRM(addmap)( struct inode *inode, struct file *filp,
71 unsigned int cmd, unsigned long arg )
73 drm_file_t *priv = filp->private_data;
74 drm_device_t *dev = priv->dev;
78 if ( !(filp->f_mode & 3) ) return -EACCES; /* Require read/write */
80 map = DRM(alloc)( sizeof(*map), DRM_MEM_MAPS );
84 if ( copy_from_user( map, (drm_map_t *)arg, sizeof(*map) ) ) {
85 DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
89 /* Only allow shared memory to be removable since we only keep enough
90 * book keeping information about shared memory to allow for removal
91 * when processes fork.
93 if ( (map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM ) {
94 DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
97 DRM_DEBUG( "offset = 0x%08lx, size = 0x%08lx, type = %d\n",
98 map->offset, map->size, map->type );
99 if ( (map->offset & (~PAGE_MASK)) || (map->size & (~PAGE_MASK)) ) {
100 DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
106 switch ( map->type ) {
108 case _DRM_FRAME_BUFFER:
109 #if !defined(__sparc__) && !defined(__alpha__) && !defined(__ia64__)
110 if ( map->offset + map->size < map->offset ||
111 map->offset < virt_to_phys(high_memory) ) {
112 DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
117 map->offset += dev->hose->mem_space->start;
119 #if __REALLY_HAVE_MTRR
120 if ( map->type == _DRM_FRAME_BUFFER ||
121 (map->flags & _DRM_WRITE_COMBINING) ) {
122 map->mtrr = mtrr_add( map->offset, map->size,
123 MTRR_TYPE_WRCOMB, 1 );
126 map->handle = DRM(ioremap)( map->offset, map->size );
130 map->handle = vmalloc_32(map->size);
131 DRM_DEBUG( "%lu %d %p\n",
132 map->size, DRM(order)( map->size ), map->handle );
133 if ( !map->handle ) {
134 DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
137 map->offset = (unsigned long)map->handle;
138 if ( map->flags & _DRM_CONTAINS_LOCK ) {
140 dev->lock.hw_lock = map->handle; /* Pointer to lock */
143 #if __REALLY_HAVE_AGP
146 map->offset += dev->hose->mem_space->start;
148 map->offset += dev->agp->base;
149 map->mtrr = dev->agp->agp_mtrr; /* for getmap */
152 case _DRM_SCATTER_GATHER:
154 DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
157 map->offset += dev->sg->handle;
161 DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
165 list = DRM(alloc)(sizeof(*list), DRM_MEM_MAPS);
167 DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
170 memset(list, 0, sizeof(*list));
173 down(&dev->struct_sem);
174 list_add(&list->head, &dev->maplist->head);
175 up(&dev->struct_sem);
177 if ( copy_to_user( (drm_map_t *)arg, map, sizeof(*map) ) )
179 if ( map->type != _DRM_SHM ) {
180 if ( copy_to_user( &((drm_map_t *)arg)->handle,
182 sizeof(map->offset) ) )
189 /* Remove a map private from list and deallocate resources if the mapping
193 int DRM(rmmap)(struct inode *inode, struct file *filp,
194 unsigned int cmd, unsigned long arg)
196 drm_file_t *priv = filp->private_data;
197 drm_device_t *dev = priv->dev;
198 struct list_head *list;
199 drm_map_list_t *r_list = NULL;
200 drm_vma_entry_t *pt, *prev;
205 if (copy_from_user(&request, (drm_map_t *)arg,
210 down(&dev->struct_sem);
211 list = &dev->maplist->head;
212 list_for_each(list, &dev->maplist->head) {
213 r_list = list_entry(list, drm_map_list_t, head);
216 r_list->map->handle == request.handle &&
217 r_list->map->flags & _DRM_REMOVABLE) break;
220 /* List has wrapped around to the head pointer, or its empty we didn't
223 if(list == (&dev->maplist->head)) {
224 up(&dev->struct_sem);
229 DRM(free)(list, sizeof(*list), DRM_MEM_MAPS);
231 for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
232 if (pt->vma->vm_private_data == map) found_maps++;
238 case _DRM_FRAME_BUFFER:
239 #if __REALLY_HAVE_MTRR
240 if (map->mtrr >= 0) {
242 retcode = mtrr_del(map->mtrr,
245 DRM_DEBUG("mtrr_del = %d\n", retcode);
248 DRM(ioremapfree)(map->handle, map->size);
254 case _DRM_SCATTER_GATHER:
257 DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
259 up(&dev->struct_sem);
266 static void DRM(cleanup_buf_error)(drm_buf_entry_t *entry)
270 if (entry->seg_count) {
271 for (i = 0; i < entry->seg_count; i++) {
272 if (entry->seglist[i]) {
273 DRM(free_pages)(entry->seglist[i],
278 DRM(free)(entry->seglist,
280 sizeof(*entry->seglist),
283 entry->seg_count = 0;
286 if (entry->buf_count) {
287 for (i = 0; i < entry->buf_count; i++) {
288 if (entry->buflist[i].dev_private) {
289 DRM(free)(entry->buflist[i].dev_private,
290 entry->buflist[i].dev_priv_size,
294 DRM(free)(entry->buflist,
296 sizeof(*entry->buflist),
299 #if __HAVE_DMA_FREELIST
300 DRM(freelist_destroy)(&entry->freelist);
303 entry->buf_count = 0;
307 #if __REALLY_HAVE_AGP
308 int DRM(addbufs_agp)( struct inode *inode, struct file *filp,
309 unsigned int cmd, unsigned long arg )
311 drm_file_t *priv = filp->private_data;
312 drm_device_t *dev = priv->dev;
313 drm_device_dma_t *dma = dev->dma;
314 drm_buf_desc_t request;
315 drm_buf_entry_t *entry;
317 unsigned long offset;
318 unsigned long agp_offset;
327 drm_buf_t **temp_buflist;
329 if ( !dma ) return -EINVAL;
331 if ( copy_from_user( &request, (drm_buf_desc_t *)arg,
335 count = request.count;
336 order = DRM(order)( request.size );
339 alignment = (request.flags & _DRM_PAGE_ALIGN)
340 ? PAGE_ALIGN(size) : size;
341 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
342 total = PAGE_SIZE << page_order;
345 agp_offset = dev->agp->base + request.agp_start;
347 DRM_DEBUG( "count: %d\n", count );
348 DRM_DEBUG( "order: %d\n", order );
349 DRM_DEBUG( "size: %d\n", size );
350 DRM_DEBUG( "agp_offset: %lu\n", agp_offset );
351 DRM_DEBUG( "alignment: %d\n", alignment );
352 DRM_DEBUG( "page_order: %d\n", page_order );
353 DRM_DEBUG( "total: %d\n", total );
355 if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
356 if ( dev->queue_count ) return -EBUSY; /* Not while in use */
358 spin_lock( &dev->count_lock );
359 if ( dev->buf_use ) {
360 spin_unlock( &dev->count_lock );
363 atomic_inc( &dev->buf_alloc );
364 spin_unlock( &dev->count_lock );
366 down( &dev->struct_sem );
367 entry = &dma->bufs[order];
368 if ( entry->buf_count ) {
369 up( &dev->struct_sem );
370 atomic_dec( &dev->buf_alloc );
371 return -ENOMEM; /* May only call once for each order */
374 if (count < 0 || count > 4096) {
375 up( &dev->struct_sem );
376 atomic_dec( &dev->buf_alloc );
380 entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
382 if ( !entry->buflist ) {
383 up( &dev->struct_sem );
384 atomic_dec( &dev->buf_alloc );
387 memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
389 entry->buf_size = size;
390 entry->page_order = page_order;
394 while ( entry->buf_count < count ) {
395 buf = &entry->buflist[entry->buf_count];
396 buf->idx = dma->buf_count + entry->buf_count;
397 buf->total = alignment;
401 buf->offset = (dma->byte_count + offset);
402 buf->bus_address = agp_offset + offset;
403 buf->address = (void *)(agp_offset + offset);
407 init_waitqueue_head( &buf->dma_wait );
410 buf->dev_priv_size = sizeof(DRIVER_BUF_PRIV_T);
411 buf->dev_private = DRM(alloc)( sizeof(DRIVER_BUF_PRIV_T),
413 if(!buf->dev_private) {
414 /* Set count correctly so we free the proper amount. */
415 entry->buf_count = count;
416 DRM(cleanup_buf_error)(entry);
417 up( &dev->struct_sem );
418 atomic_dec( &dev->buf_alloc );
421 memset( buf->dev_private, 0, buf->dev_priv_size );
423 DRM_DEBUG( "buffer %d @ %p\n",
424 entry->buf_count, buf->address );
428 byte_count += PAGE_SIZE << page_order;
431 DRM_DEBUG( "byte_count: %d\n", byte_count );
433 temp_buflist = DRM(realloc)( dma->buflist,
434 dma->buf_count * sizeof(*dma->buflist),
435 (dma->buf_count + entry->buf_count)
436 * sizeof(*dma->buflist),
439 /* Free the entry because it isn't valid */
440 DRM(cleanup_buf_error)(entry);
441 up( &dev->struct_sem );
442 atomic_dec( &dev->buf_alloc );
445 dma->buflist = temp_buflist;
447 for ( i = 0 ; i < entry->buf_count ; i++ ) {
448 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
451 dma->buf_count += entry->buf_count;
452 dma->byte_count += byte_count;
454 DRM_DEBUG( "dma->buf_count : %d\n", dma->buf_count );
455 DRM_DEBUG( "entry->buf_count : %d\n", entry->buf_count );
457 #if __HAVE_DMA_FREELIST
458 DRM(freelist_create)( &entry->freelist, entry->buf_count );
459 for ( i = 0 ; i < entry->buf_count ; i++ ) {
460 DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
463 up( &dev->struct_sem );
465 request.count = entry->buf_count;
468 if ( copy_to_user( (drm_buf_desc_t *)arg, &request, sizeof(request) ) )
471 dma->flags = _DRM_DMA_USE_AGP;
473 atomic_dec( &dev->buf_alloc );
476 #endif /* __REALLY_HAVE_AGP */
479 int DRM(addbufs_pci)( struct inode *inode, struct file *filp,
480 unsigned int cmd, unsigned long arg )
482 drm_file_t *priv = filp->private_data;
483 drm_device_t *dev = priv->dev;
484 drm_device_dma_t *dma = dev->dma;
485 drm_buf_desc_t request;
491 drm_buf_entry_t *entry;
495 unsigned long offset;
499 unsigned long *temp_pagelist;
500 drm_buf_t **temp_buflist;
502 if ( !dma ) return -EINVAL;
504 if ( copy_from_user( &request, (drm_buf_desc_t *)arg,
508 count = request.count;
509 order = DRM(order)( request.size );
512 DRM_DEBUG( "count=%d, size=%d (%d), order=%d, queue_count=%d\n",
513 request.count, request.size, size,
514 order, dev->queue_count );
516 if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
517 if ( dev->queue_count ) return -EBUSY; /* Not while in use */
519 alignment = (request.flags & _DRM_PAGE_ALIGN)
520 ? PAGE_ALIGN(size) : size;
521 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
522 total = PAGE_SIZE << page_order;
524 spin_lock( &dev->count_lock );
525 if ( dev->buf_use ) {
526 spin_unlock( &dev->count_lock );
529 atomic_inc( &dev->buf_alloc );
530 spin_unlock( &dev->count_lock );
532 down( &dev->struct_sem );
533 entry = &dma->bufs[order];
534 if ( entry->buf_count ) {
535 up( &dev->struct_sem );
536 atomic_dec( &dev->buf_alloc );
537 return -ENOMEM; /* May only call once for each order */
540 if (count < 0 || count > 4096) {
541 up( &dev->struct_sem );
542 atomic_dec( &dev->buf_alloc );
546 entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
548 if ( !entry->buflist ) {
549 up( &dev->struct_sem );
550 atomic_dec( &dev->buf_alloc );
553 memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
555 entry->seglist = DRM(alloc)( count * sizeof(*entry->seglist),
557 if ( !entry->seglist ) {
558 DRM(free)( entry->buflist,
559 count * sizeof(*entry->buflist),
561 up( &dev->struct_sem );
562 atomic_dec( &dev->buf_alloc );
565 memset( entry->seglist, 0, count * sizeof(*entry->seglist) );
567 /* Keep the original pagelist until we know all the allocations
570 temp_pagelist = DRM(alloc)( (dma->page_count + (count << page_order))
571 * sizeof(*dma->pagelist),
573 if (!temp_pagelist) {
574 DRM(free)( entry->buflist,
575 count * sizeof(*entry->buflist),
577 DRM(free)( entry->seglist,
578 count * sizeof(*entry->seglist),
580 up( &dev->struct_sem );
581 atomic_dec( &dev->buf_alloc );
584 memcpy(temp_pagelist,
586 dma->page_count * sizeof(*dma->pagelist));
587 DRM_DEBUG( "pagelist: %d entries\n",
588 dma->page_count + (count << page_order) );
590 entry->buf_size = size;
591 entry->page_order = page_order;
595 while ( entry->buf_count < count ) {
596 page = DRM(alloc_pages)( page_order, DRM_MEM_DMA );
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)(entry);
602 DRM(free)( temp_pagelist,
603 (dma->page_count + (count << page_order))
604 * sizeof(*dma->pagelist),
606 up( &dev->struct_sem );
607 atomic_dec( &dev->buf_alloc );
610 entry->seglist[entry->seg_count++] = page;
611 for ( i = 0 ; i < (1 << page_order) ; i++ ) {
612 DRM_DEBUG( "page %d @ 0x%08lx\n",
613 dma->page_count + page_count,
614 page + PAGE_SIZE * i );
615 temp_pagelist[dma->page_count + page_count++]
616 = page + PAGE_SIZE * i;
619 offset + size <= total && entry->buf_count < count ;
620 offset += alignment, ++entry->buf_count ) {
621 buf = &entry->buflist[entry->buf_count];
622 buf->idx = dma->buf_count + entry->buf_count;
623 buf->total = alignment;
626 buf->offset = (dma->byte_count + byte_count + offset);
627 buf->address = (void *)(page + offset);
631 init_waitqueue_head( &buf->dma_wait );
634 buf->dev_priv_size = sizeof(DRIVER_BUF_PRIV_T);
635 buf->dev_private = DRM(alloc)( sizeof(DRIVER_BUF_PRIV_T),
637 if(!buf->dev_private) {
638 /* Set count correctly so we free the proper amount. */
639 entry->buf_count = count;
640 entry->seg_count = count;
641 DRM(cleanup_buf_error)(entry);
642 DRM(free)( temp_pagelist,
643 (dma->page_count + (count << page_order))
644 * sizeof(*dma->pagelist),
646 up( &dev->struct_sem );
647 atomic_dec( &dev->buf_alloc );
650 memset( buf->dev_private, 0, buf->dev_priv_size );
652 DRM_DEBUG( "buffer %d @ %p\n",
653 entry->buf_count, buf->address );
655 byte_count += PAGE_SIZE << page_order;
658 temp_buflist = DRM(realloc)( dma->buflist,
659 dma->buf_count * sizeof(*dma->buflist),
660 (dma->buf_count + entry->buf_count)
661 * sizeof(*dma->buflist),
664 /* Free the entry because it isn't valid */
665 DRM(cleanup_buf_error)(entry);
666 DRM(free)( temp_pagelist,
667 (dma->page_count + (count << page_order))
668 * sizeof(*dma->pagelist),
670 up( &dev->struct_sem );
671 atomic_dec( &dev->buf_alloc );
674 dma->buflist = temp_buflist;
676 for ( i = 0 ; i < entry->buf_count ; i++ ) {
677 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
680 /* No allocations failed, so now we can replace the orginal pagelist
683 if (dma->page_count) {
684 DRM(free)(dma->pagelist,
685 dma->page_count * sizeof(*dma->pagelist),
688 dma->pagelist = temp_pagelist;
690 dma->buf_count += entry->buf_count;
691 dma->seg_count += entry->seg_count;
692 dma->page_count += entry->seg_count << page_order;
693 dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
695 #if __HAVE_DMA_FREELIST
696 DRM(freelist_create)( &entry->freelist, entry->buf_count );
697 for ( i = 0 ; i < entry->buf_count ; i++ ) {
698 DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
701 up( &dev->struct_sem );
703 request.count = entry->buf_count;
706 if ( copy_to_user( (drm_buf_desc_t *)arg, &request, sizeof(request) ) )
709 atomic_dec( &dev->buf_alloc );
713 #endif /* __HAVE_PCI_DMA */
716 int DRM(addbufs_sg)( struct inode *inode, struct file *filp,
717 unsigned int cmd, unsigned long arg )
719 drm_file_t *priv = filp->private_data;
720 drm_device_t *dev = priv->dev;
721 drm_device_dma_t *dma = dev->dma;
722 drm_buf_desc_t request;
723 drm_buf_entry_t *entry;
725 unsigned long offset;
726 unsigned long agp_offset;
735 drm_buf_t **temp_buflist;
737 if ( !dma ) return -EINVAL;
739 if ( copy_from_user( &request, (drm_buf_desc_t *)arg,
743 count = request.count;
744 order = DRM(order)( request.size );
747 alignment = (request.flags & _DRM_PAGE_ALIGN)
748 ? PAGE_ALIGN(size) : size;
749 page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
750 total = PAGE_SIZE << page_order;
753 agp_offset = request.agp_start;
755 DRM_DEBUG( "count: %d\n", count );
756 DRM_DEBUG( "order: %d\n", order );
757 DRM_DEBUG( "size: %d\n", size );
758 DRM_DEBUG( "agp_offset: %lu\n", agp_offset );
759 DRM_DEBUG( "alignment: %d\n", alignment );
760 DRM_DEBUG( "page_order: %d\n", page_order );
761 DRM_DEBUG( "total: %d\n", total );
763 if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
764 if ( dev->queue_count ) return -EBUSY; /* Not while in use */
766 spin_lock( &dev->count_lock );
767 if ( dev->buf_use ) {
768 spin_unlock( &dev->count_lock );
771 atomic_inc( &dev->buf_alloc );
772 spin_unlock( &dev->count_lock );
774 down( &dev->struct_sem );
775 entry = &dma->bufs[order];
776 if ( entry->buf_count ) {
777 up( &dev->struct_sem );
778 atomic_dec( &dev->buf_alloc );
779 return -ENOMEM; /* May only call once for each order */
782 if (count < 0 || count > 4096) {
783 up( &dev->struct_sem );
784 atomic_dec( &dev->buf_alloc );
788 entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
790 if ( !entry->buflist ) {
791 up( &dev->struct_sem );
792 atomic_dec( &dev->buf_alloc );
795 memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
797 entry->buf_size = size;
798 entry->page_order = page_order;
802 while ( entry->buf_count < count ) {
803 buf = &entry->buflist[entry->buf_count];
804 buf->idx = dma->buf_count + entry->buf_count;
805 buf->total = alignment;
809 buf->offset = (dma->byte_count + offset);
810 buf->bus_address = agp_offset + offset;
811 buf->address = (void *)(agp_offset + offset + dev->sg->handle);
815 init_waitqueue_head( &buf->dma_wait );
818 buf->dev_priv_size = sizeof(DRIVER_BUF_PRIV_T);
819 buf->dev_private = DRM(alloc)( sizeof(DRIVER_BUF_PRIV_T),
821 if(!buf->dev_private) {
822 /* Set count correctly so we free the proper amount. */
823 entry->buf_count = count;
824 DRM(cleanup_buf_error)(entry);
825 up( &dev->struct_sem );
826 atomic_dec( &dev->buf_alloc );
830 memset( buf->dev_private, 0, buf->dev_priv_size );
832 DRM_DEBUG( "buffer %d @ %p\n",
833 entry->buf_count, buf->address );
837 byte_count += PAGE_SIZE << page_order;
840 DRM_DEBUG( "byte_count: %d\n", byte_count );
842 temp_buflist = DRM(realloc)( dma->buflist,
843 dma->buf_count * sizeof(*dma->buflist),
844 (dma->buf_count + entry->buf_count)
845 * sizeof(*dma->buflist),
848 /* Free the entry because it isn't valid */
849 DRM(cleanup_buf_error)(entry);
850 up( &dev->struct_sem );
851 atomic_dec( &dev->buf_alloc );
854 dma->buflist = temp_buflist;
856 for ( i = 0 ; i < entry->buf_count ; i++ ) {
857 dma->buflist[i + dma->buf_count] = &entry->buflist[i];
860 dma->buf_count += entry->buf_count;
861 dma->byte_count += byte_count;
863 DRM_DEBUG( "dma->buf_count : %d\n", dma->buf_count );
864 DRM_DEBUG( "entry->buf_count : %d\n", entry->buf_count );
866 #if __HAVE_DMA_FREELIST
867 DRM(freelist_create)( &entry->freelist, entry->buf_count );
868 for ( i = 0 ; i < entry->buf_count ; i++ ) {
869 DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
872 up( &dev->struct_sem );
874 request.count = entry->buf_count;
877 if ( copy_to_user( (drm_buf_desc_t *)arg, &request, sizeof(request) ) )
880 dma->flags = _DRM_DMA_USE_SG;
882 atomic_dec( &dev->buf_alloc );
885 #endif /* __HAVE_SG */
887 int DRM(addbufs)( struct inode *inode, struct file *filp,
888 unsigned int cmd, unsigned long arg )
890 drm_buf_desc_t request;
892 if ( copy_from_user( &request, (drm_buf_desc_t *)arg,
896 #if __REALLY_HAVE_AGP
897 if ( request.flags & _DRM_AGP_BUFFER )
898 return DRM(addbufs_agp)( inode, filp, cmd, arg );
902 if ( request.flags & _DRM_SG_BUFFER )
903 return DRM(addbufs_sg)( inode, filp, cmd, arg );
907 return DRM(addbufs_pci)( inode, filp, cmd, arg );
913 int DRM(infobufs)( struct inode *inode, struct file *filp,
914 unsigned int cmd, unsigned long arg )
916 drm_file_t *priv = filp->private_data;
917 drm_device_t *dev = priv->dev;
918 drm_device_dma_t *dma = dev->dma;
919 drm_buf_info_t request;
923 if ( !dma ) return -EINVAL;
925 spin_lock( &dev->count_lock );
926 if ( atomic_read( &dev->buf_alloc ) ) {
927 spin_unlock( &dev->count_lock );
930 ++dev->buf_use; /* Can't allocate more after this call */
931 spin_unlock( &dev->count_lock );
933 if ( copy_from_user( &request,
934 (drm_buf_info_t *)arg,
938 for ( i = 0, count = 0 ; i < DRM_MAX_ORDER + 1 ; i++ ) {
939 if ( dma->bufs[i].buf_count ) ++count;
942 DRM_DEBUG( "count = %d\n", count );
944 if ( request.count >= count ) {
945 for ( i = 0, count = 0 ; i < DRM_MAX_ORDER + 1 ; i++ ) {
946 if ( dma->bufs[i].buf_count ) {
947 drm_buf_desc_t *to = &request.list[count];
948 drm_buf_entry_t *from = &dma->bufs[i];
949 drm_freelist_t *list = &dma->bufs[i].freelist;
950 if ( copy_to_user( &to->count,
952 sizeof(from->buf_count) ) ||
953 copy_to_user( &to->size,
955 sizeof(from->buf_size) ) ||
956 copy_to_user( &to->low_mark,
958 sizeof(list->low_mark) ) ||
959 copy_to_user( &to->high_mark,
961 sizeof(list->high_mark) ) )
964 DRM_DEBUG( "%d %d %d %d %d\n",
966 dma->bufs[i].buf_count,
967 dma->bufs[i].buf_size,
968 dma->bufs[i].freelist.low_mark,
969 dma->bufs[i].freelist.high_mark );
974 request.count = count;
976 if ( copy_to_user( (drm_buf_info_t *)arg,
984 int DRM(markbufs)( struct inode *inode, struct file *filp,
985 unsigned int cmd, unsigned long arg )
987 drm_file_t *priv = filp->private_data;
988 drm_device_t *dev = priv->dev;
989 drm_device_dma_t *dma = dev->dma;
990 drm_buf_desc_t request;
992 drm_buf_entry_t *entry;
994 if ( !dma ) return -EINVAL;
996 if ( copy_from_user( &request,
997 (drm_buf_desc_t *)arg,
1001 DRM_DEBUG( "%d, %d, %d\n",
1002 request.size, request.low_mark, request.high_mark );
1003 order = DRM(order)( request.size );
1004 if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER ) return -EINVAL;
1005 entry = &dma->bufs[order];
1007 if ( request.low_mark < 0 || request.low_mark > entry->buf_count )
1009 if ( request.high_mark < 0 || request.high_mark > entry->buf_count )
1012 entry->freelist.low_mark = request.low_mark;
1013 entry->freelist.high_mark = request.high_mark;
1018 int DRM(freebufs)( struct inode *inode, struct file *filp,
1019 unsigned int cmd, unsigned long arg )
1021 drm_file_t *priv = filp->private_data;
1022 drm_device_t *dev = priv->dev;
1023 drm_device_dma_t *dma = dev->dma;
1024 drm_buf_free_t request;
1029 if ( !dma ) return -EINVAL;
1031 if ( copy_from_user( &request,
1032 (drm_buf_free_t *)arg,
1036 DRM_DEBUG( "%d\n", request.count );
1037 for ( i = 0 ; i < request.count ; i++ ) {
1038 if ( copy_from_user( &idx,
1042 if ( idx < 0 || idx >= dma->buf_count ) {
1043 DRM_ERROR( "Index %d (of %d max)\n",
1044 idx, dma->buf_count - 1 );
1047 buf = dma->buflist[idx];
1048 if ( buf->filp != filp ) {
1049 DRM_ERROR( "Process %d freeing buffer not owned\n",
1053 DRM(free_buffer)( dev, buf );
1059 int DRM(mapbufs)( struct inode *inode, struct file *filp,
1060 unsigned int cmd, unsigned long arg )
1062 drm_file_t *priv = filp->private_data;
1063 drm_device_t *dev = priv->dev;
1064 drm_device_dma_t *dma = dev->dma;
1067 unsigned long virtual;
1068 unsigned long address;
1069 drm_buf_map_t request;
1072 if ( !dma ) return -EINVAL;
1074 spin_lock( &dev->count_lock );
1075 if ( atomic_read( &dev->buf_alloc ) ) {
1076 spin_unlock( &dev->count_lock );
1079 dev->buf_use++; /* Can't allocate more after this call */
1080 spin_unlock( &dev->count_lock );
1082 if ( copy_from_user( &request, (drm_buf_map_t *)arg,
1086 if ( request.count >= dma->buf_count ) {
1087 if ( (__HAVE_AGP && (dma->flags & _DRM_DMA_USE_AGP)) ||
1088 (__HAVE_SG && (dma->flags & _DRM_DMA_USE_SG)) ) {
1089 drm_map_t *map = DRIVER_AGP_BUFFERS_MAP( dev );
1096 #if LINUX_VERSION_CODE <= 0x020402
1097 down( ¤t->mm->mmap_sem );
1099 down_write( ¤t->mm->mmap_sem );
1101 virtual = do_mmap( filp, 0, map->size,
1102 PROT_READ | PROT_WRITE,
1104 (unsigned long)map->offset );
1105 #if LINUX_VERSION_CODE <= 0x020402
1106 up( ¤t->mm->mmap_sem );
1108 up_write( ¤t->mm->mmap_sem );
1111 #if LINUX_VERSION_CODE <= 0x020402
1112 down( ¤t->mm->mmap_sem );
1114 down_write( ¤t->mm->mmap_sem );
1116 virtual = do_mmap( filp, 0, dma->byte_count,
1117 PROT_READ | PROT_WRITE,
1119 #if LINUX_VERSION_CODE <= 0x020402
1120 up( ¤t->mm->mmap_sem );
1122 up_write( ¤t->mm->mmap_sem );
1125 if ( virtual > -1024UL ) {
1127 retcode = (signed long)virtual;
1130 request.virtual = (void *)virtual;
1132 for ( i = 0 ; i < dma->buf_count ; i++ ) {
1133 if ( copy_to_user( &request.list[i].idx,
1134 &dma->buflist[i]->idx,
1135 sizeof(request.list[0].idx) ) ) {
1139 if ( copy_to_user( &request.list[i].total,
1140 &dma->buflist[i]->total,
1141 sizeof(request.list[0].total) ) ) {
1145 if ( copy_to_user( &request.list[i].used,
1151 address = virtual + dma->buflist[i]->offset; /* *** */
1152 if ( copy_to_user( &request.list[i].address,
1154 sizeof(address) ) ) {
1161 request.count = dma->buf_count;
1162 DRM_DEBUG( "%d buffers, retcode = %d\n", request.count, retcode );
1164 if ( copy_to_user( (drm_buf_map_t *)arg, &request, sizeof(request) ) )
1170 #endif /* __HAVE_DMA */