fdo-mirrors/mesa-drm
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/drm.git synced 2026-05-06 08:18:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

os-independent interface name changes (mostly DRM_OS_* -> DRM_)

Browse source 
Suggested by: keithw
This commit is contained in:
Eric Anholt 2002-06-27 22:41:08 +00:00
parent 54fca81696
commit 563bc3158d
64 changed files with 2369 additions and 2379 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
bsd-core/ati_pcigart.c
View file

@ -122,7 +122,7 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
ret = 1;
DRM_OS_READMEMORYBARRIER();
DRM_READMEMORYBARRIER();
done:
*addr = address;

14
bsd-core/drmP.h
View file

@ -243,8 +243,8 @@ typedef struct drm_waitlist {
drm_buf_t **rp; /* Read pointer */
drm_buf_t **wp; /* Write pointer */
drm_buf_t **end; /* End pointer */
DRM_OS_SPINTYPE read_lock;
DRM_OS_SPINTYPE write_lock;
DRM_SPINTYPE read_lock;
DRM_SPINTYPE write_lock;
} drm_waitlist_t;
typedef struct drm_freelist {
@ -256,7 +256,7 @@ typedef struct drm_freelist {
int low_mark; /* Low water mark */
int high_mark; /* High water mark */
atomic_t wfh; /* If waiting for high mark */
DRM_OS_SPINTYPE lock;
DRM_SPINTYPE lock;
} drm_freelist_t;
typedef struct drm_buf_entry {
@ -410,7 +410,7 @@ struct drm_device {
int writable; /* Opened with FWRITE */
/* Locks */
DRM_OS_SPINTYPE count_lock; /* For inuse, open_count, buf_use */
DRM_SPINTYPE count_lock; /* For inuse, open_count, buf_use */
struct lock dev_lock; /* For others */
/* Usage Counters */
int open_count; /* Outstanding files open */
@ -510,7 +510,7 @@ extern int DRM(add_magic)(drm_device_t *dev, drm_file_t *priv,
extern int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic);
/* Driver support (drm_drv.h) */
extern int DRM(version)( DRM_OS_IOCTL );
extern int DRM(version)( DRM_IOCTL_ARGS );
extern int DRM(write_string)(drm_device_t *dev, const char *s);
/* Memory management support (drm_memory.h) */
@ -578,9 +578,9 @@ extern int DRM(dma_get_buffers)(drm_device_t *dev, drm_dma_t *dma);
#if __HAVE_DMA_IRQ
extern int DRM(irq_install)( drm_device_t *dev, int irq );
extern int DRM(irq_uninstall)( drm_device_t *dev );
extern void DRM(dma_service)( DRM_OS_IRQ_ARGS );
extern void DRM(dma_service)( DRM_IRQ_ARGS );
#if __HAVE_DMA_IRQ_BH
extern void DRM(dma_immediate_bh)( DRM_OS_TASKQUEUE_ARGS );
extern void DRM(dma_immediate_bh)( DRM_TASKQUEUE_ARGS );
#endif
#endif
#if DRM_DMA_HISTOGRAM

44
bsd-core/drm_agpsupport.c
View file

@ -31,9 +31,9 @@
#include "drmP.h"
int DRM(agp_info)(DRM_OS_IOCTL)
int DRM(agp_info)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
struct agp_info *kern;
drm_agp_info_t info;
@ -55,9 +55,9 @@ int DRM(agp_info)(DRM_OS_IOCTL)
return 0;
}
int DRM(agp_acquire)(DRM_OS_IOCTL)
int DRM(agp_acquire)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
int retcode;
if (!dev->agp || dev->agp->acquired) return EINVAL;
@ -67,9 +67,9 @@ int DRM(agp_acquire)(DRM_OS_IOCTL)
return 0;
}
int DRM(agp_release)(DRM_OS_IOCTL)
int DRM(agp_release)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
if (!dev->agp || !dev->agp->acquired)
return EINVAL;
@ -83,14 +83,14 @@ void DRM(agp_do_release)(void)
{
device_t agpdev;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (agpdev)
agp_release(agpdev);
}
int DRM(agp_enable)(DRM_OS_IOCTL)
int DRM(agp_enable)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_agp_mode_t mode;
if (!dev->agp || !dev->agp->acquired) return EINVAL;
@ -104,9 +104,9 @@ int DRM(agp_enable)(DRM_OS_IOCTL)
return 0;
}
int DRM(agp_alloc)(DRM_OS_IOCTL)
int DRM(agp_alloc)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_agp_buffer_t request;
drm_agp_mem_t *entry;
void *handle;
@ -159,9 +159,9 @@ static drm_agp_mem_t * DRM(agp_lookup_entry)(drm_device_t *dev, void *handle)
return NULL;
}
int DRM(agp_unbind)(DRM_OS_IOCTL)
int DRM(agp_unbind)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_agp_binding_t request;
drm_agp_mem_t *entry;
int retcode;
@ -181,9 +181,9 @@ int DRM(agp_unbind)(DRM_OS_IOCTL)
return retcode;
}
int DRM(agp_bind)(DRM_OS_IOCTL)
int DRM(agp_bind)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_agp_binding_t request;
drm_agp_mem_t *entry;
int retcode;
@ -203,9 +203,9 @@ int DRM(agp_bind)(DRM_OS_IOCTL)
return 0;
}
int DRM(agp_free)(DRM_OS_IOCTL)
int DRM(agp_free)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_agp_buffer_t request;
drm_agp_mem_t *entry;
@ -229,7 +229,7 @@ drm_agp_head_t *DRM(agp_init)(void)
drm_agp_head_t *head = NULL;
int agp_available = 1;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev)
agp_available = 0;
@ -278,7 +278,7 @@ agp_memory *DRM(agp_allocate_memory)(size_t pages, u32 type)
{
device_t agpdev;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev)
return NULL;
@ -289,7 +289,7 @@ int DRM(agp_free_memory)(agp_memory *handle)
{
device_t agpdev;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return 0;
@ -301,7 +301,7 @@ int DRM(agp_bind_memory)(agp_memory *handle, off_t start)
{
device_t agpdev;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return EINVAL;
@ -312,7 +312,7 @@ int DRM(agp_unbind_memory)(agp_memory *handle)
{
device_t agpdev;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return EINVAL;

42
bsd-core/drm_auth.c
View file

@ -42,14 +42,14 @@ static drm_file_t *DRM(find_file)(drm_device_t *dev, drm_magic_t magic)
drm_magic_entry_t *pt;
int hash = DRM(hash_magic)(magic);
DRM_OS_LOCK;
DRM_LOCK;
for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
if (pt->magic == magic) {
retval = pt->priv;
break;
}
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return retval;
}
@ -62,13 +62,13 @@ int DRM(add_magic)(drm_device_t *dev, drm_file_t *priv, drm_magic_t magic)
hash = DRM(hash_magic)(magic);
entry = (drm_magic_entry_t*) DRM(alloc)(sizeof(*entry), DRM_MEM_MAGIC);
if (!entry) DRM_OS_RETURN(ENOMEM);
if (!entry) return DRM_ERR(ENOMEM);
memset(entry, 0, sizeof(*entry));
entry->magic = magic;
entry->priv = priv;
entry->next = NULL;
DRM_OS_LOCK;
DRM_LOCK;
if (dev->magiclist[hash].tail) {
dev->magiclist[hash].tail->next = entry;
dev->magiclist[hash].tail = entry;
@ -76,7 +76,7 @@ int DRM(add_magic)(drm_device_t *dev, drm_file_t *priv, drm_magic_t magic)
dev->magiclist[hash].head = entry;
dev->magiclist[hash].tail = entry;
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
@ -90,7 +90,7 @@ int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic)
DRM_DEBUG("%d\n", magic);
hash = DRM(hash_magic)(magic);
DRM_OS_LOCK;
DRM_LOCK;
for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
if (pt->magic == magic) {
if (dev->magiclist[hash].head == pt) {
@ -102,27 +102,27 @@ int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic)
if (prev) {
prev->next = pt->next;
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM(free)(pt, sizeof(*pt), DRM_MEM_MAGIC);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
int DRM(getmagic)(DRM_OS_IOCTL)
int DRM(getmagic)(DRM_IOCTL_ARGS)
{
static drm_magic_t sequence = 0;
drm_auth_t auth;
static DRM_OS_SPINTYPE lock;
static DRM_SPINTYPE lock;
static int first = 1;
DRM_OS_DEVICE;
DRM_OS_PRIV;
DRM_DEVICE;
DRM_PRIV;
if (first) {
DRM_OS_SPININIT(lock, "drm getmagic");
DRM_SPININIT(lock, "drm getmagic");
first = 0;
}
@ -131,10 +131,10 @@ int DRM(getmagic)(DRM_OS_IOCTL)
auth.magic = priv->magic;
} else {
do {
DRM_OS_SPINLOCK(&lock);
DRM_SPINLOCK(&lock);
if (!sequence) ++sequence; /* reserve 0 */
auth.magic = sequence++;
DRM_OS_SPINUNLOCK(&lock);
DRM_SPINUNLOCK(&lock);
} while (DRM(find_file)(dev, auth.magic));
priv->magic = auth.magic;
DRM(add_magic)(dev, priv, auth.magic);
@ -142,18 +142,18 @@ int DRM(getmagic)(DRM_OS_IOCTL)
DRM_DEBUG("%u\n", auth.magic);
DRM_OS_KRNTOUSR((drm_auth_t *)data, auth, sizeof(auth));
DRM_COPY_TO_USER_IOCTL((drm_auth_t *)data, auth, sizeof(auth));
return 0;
}
int DRM(authmagic)(DRM_OS_IOCTL)
int DRM(authmagic)(DRM_IOCTL_ARGS)
{
drm_auth_t auth;
drm_file_t *file;
DRM_OS_DEVICE;
DRM_DEVICE;
DRM_OS_KRNFROMUSR(auth, (drm_auth_t *)data, sizeof(auth));
DRM_COPY_FROM_USER_IOCTL(auth, (drm_auth_t *)data, sizeof(auth));
DRM_DEBUG("%u\n", auth.magic);
if ((file = DRM(find_file)(dev, auth.magic))) {
@ -161,5 +161,5 @@ int DRM(authmagic)(DRM_OS_IOCTL)
DRM(remove_magic)(dev, auth.magic);
return 0;
}
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}

274
bsd-core/drm_bufs.c
View file

@ -66,18 +66,18 @@ int DRM(order)( unsigned long size )
return order;
}
int DRM(addmap)( DRM_OS_IOCTL )
int DRM(addmap)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_map_t *map;
drm_map_list_entry_t *list;
if (!(dev->flags & (FREAD|FWRITE)))
DRM_OS_RETURN(EACCES); /* Require read/write */
return DRM_ERR(EACCES); /* Require read/write */
map = (drm_map_t *) DRM(alloc)( sizeof(*map), DRM_MEM_MAPS );
if ( !map )
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
*map = *(drm_map_t *)data;
@ -87,13 +87,13 @@ int DRM(addmap)( DRM_OS_IOCTL )
*/
if ( (map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM ) {
DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_DEBUG( "offset = 0x%08lx, size = 0x%08lx, type = %d\n",
map->offset, map->size, map->type );
if ( (map->offset & PAGE_MASK) || (map->size & PAGE_MASK) ) {
DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
map->mtrr = -1;
map->handle = 0;
@ -105,7 +105,7 @@ int DRM(addmap)( DRM_OS_IOCTL )
if ( map->offset + map->size < map->offset
) {
DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
#endif
#ifdef __alpha__
@ -148,7 +148,7 @@ int DRM(addmap)( DRM_OS_IOCTL )
map->size, DRM(order)( map->size ), map->handle );
if ( !map->handle ) {
DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
map->offset = (unsigned long)map->handle;
if ( map->flags & _DRM_CONTAINS_LOCK ) {
@ -167,27 +167,27 @@ int DRM(addmap)( DRM_OS_IOCTL )
case _DRM_SCATTER_GATHER:
if (!dev->sg) {
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
map->offset = map->offset + dev->sg->handle;
break;
default:
DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
list = DRM(alloc)(sizeof(*list), DRM_MEM_MAPS);
if(!list) {
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
memset(list, 0, sizeof(*list));
list->map = map;
DRM_OS_LOCK;
DRM_LOCK;
TAILQ_INSERT_TAIL(dev->maplist, list, link);
DRM_OS_UNLOCK;
DRM_UNLOCK;
*(drm_map_t *)data = *map;
@ -202,17 +202,17 @@ int DRM(addmap)( DRM_OS_IOCTL )
* isn't in use.
*/
int DRM(rmmap)( DRM_OS_IOCTL )
int DRM(rmmap)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_map_list_entry_t *list;
drm_map_t *map;
drm_map_t request;
int found_maps = 0;
DRM_OS_KRNFROMUSR( request, (drm_map_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_map_t *)data, sizeof(request) );
DRM_OS_LOCK;
DRM_LOCK;
TAILQ_FOREACH(list, dev->maplist, link) {
map = list->map;
if(map->handle == request.handle &&
@ -223,8 +223,8 @@ int DRM(rmmap)( DRM_OS_IOCTL )
* find anything.
*/
if(list == NULL) {
DRM_OS_UNLOCK;
DRM_OS_RETURN(EINVAL);
DRM_UNLOCK;
return DRM_ERR(EINVAL);
}
TAILQ_REMOVE(dev->maplist, list, link);
DRM(free)(list, sizeof(*list), DRM_MEM_MAPS);
@ -270,7 +270,7 @@ int DRM(rmmap)( DRM_OS_IOCTL )
}
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
@ -317,9 +317,9 @@ static void DRM(cleanup_buf_error)(drm_buf_entry_t *entry)
}
#if __REALLY_HAVE_AGP
int DRM(addbufs_agp)( DRM_OS_IOCTL )
int DRM(addbufs_agp)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_desc_t request;
drm_buf_entry_t *entry;
@ -336,9 +336,9 @@ int DRM(addbufs_agp)( DRM_OS_IOCTL )
int i;
drm_buf_t **temp_buflist;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_KRNFROMUSR( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
count = request.count;
order = DRM(order)( request.size );
@ -361,38 +361,38 @@ int DRM(addbufs_agp)( DRM_OS_IOCTL )
DRM_DEBUG( "total: %d\n", total );
if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
if ( dev->queue_count )
DRM_OS_RETURN(EBUSY); /* Not while in use */
return DRM_ERR(EBUSY); /* Not while in use */
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( dev->buf_use ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
atomic_inc( &dev->buf_alloc );
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_LOCK;
DRM_LOCK;
entry = &dma->bufs[order];
if ( entry->buf_count ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM); /* May only call once for each order */
return DRM_ERR(ENOMEM); /* May only call once for each order */
}
if (count < 0 || count > 4096) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
DRM_MEM_BUFS );
if ( !entry->buflist ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
@ -449,9 +449,9 @@ int DRM(addbufs_agp)( DRM_OS_IOCTL )
if(!temp_buflist) {
/* Free the entry because it isn't valid */
DRM(cleanup_buf_error)(entry);
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
dma->buflist = temp_buflist;
@ -471,12 +471,12 @@ int DRM(addbufs_agp)( DRM_OS_IOCTL )
DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
}
#endif
DRM_OS_UNLOCK;
DRM_UNLOCK;
request.count = entry->buf_count;
request.size = size;
DRM_OS_KRNTOUSR( (drm_buf_desc_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_buf_desc_t *)data, request, sizeof(request) );
dma->flags = _DRM_DMA_USE_AGP;
@ -486,9 +486,9 @@ int DRM(addbufs_agp)( DRM_OS_IOCTL )
#endif /* __REALLY_HAVE_AGP */
#if __HAVE_PCI_DMA
int DRM(addbufs_pci)( DRM_OS_IOCTL )
int DRM(addbufs_pci)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_desc_t request;
int count;
@ -507,9 +507,9 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
unsigned long *temp_pagelist;
drm_buf_t **temp_buflist;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_KRNFROMUSR( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
count = request.count;
order = DRM(order)( request.size );
@ -520,43 +520,43 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
order, dev->queue_count );
if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
if ( dev->queue_count )
DRM_OS_RETURN(EBUSY); /* Not while in use */
return DRM_ERR(EBUSY); /* Not while in use */
alignment = (request.flags & _DRM_PAGE_ALIGN)
? round_page(size) : size;
page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
total = PAGE_SIZE << page_order;
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( dev->buf_use ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
atomic_inc( &dev->buf_alloc );
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_LOCK;
DRM_LOCK;
entry = &dma->bufs[order];
if ( entry->buf_count ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM); /* May only call once for each order */
return DRM_ERR(ENOMEM); /* May only call once for each order */
}
if (count < 0 || count > 4096) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
DRM_MEM_BUFS );
if ( !entry->buflist ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
@ -566,9 +566,9 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
DRM(free)( entry->buflist,
count * sizeof(*entry->buflist),
DRM_MEM_BUFS );
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( entry->seglist, 0, count * sizeof(*entry->seglist) );
@ -584,9 +584,9 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
DRM(free)( entry->seglist,
count * sizeof(*entry->seglist),
DRM_MEM_SEGS );
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
dma->pagelist = temp_pagelist;
@ -644,9 +644,9 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
if(!temp_buflist) {
/* Free the entry because it isn't valid */
DRM(cleanup_buf_error)(entry);
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
dma->buflist = temp_buflist;
@ -665,12 +665,12 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
}
#endif
DRM_OS_UNLOCK;
DRM_UNLOCK;
request.count = entry->buf_count;
request.size = size;
DRM_OS_KRNTOUSR( (drm_buf_desc_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_buf_desc_t *)data, request, sizeof(request) );
atomic_dec( &dev->buf_alloc );
return 0;
@ -679,9 +679,9 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
#endif /* __HAVE_PCI_DMA */
#if __REALLY_HAVE_SG
int DRM(addbufs_sg)( DRM_OS_IOCTL )
int DRM(addbufs_sg)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_desc_t request;
drm_buf_entry_t *entry;
@ -698,9 +698,9 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
int i;
drm_buf_t **temp_buflist;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_KRNFROMUSR( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
count = request.count;
order = DRM(order)( request.size );
@ -723,37 +723,37 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
DRM_DEBUG( "total: %d\n", total );
if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER )
DRM_OS_RETURN(EINVAL);
if ( dev->queue_count ) DRM_OS_RETURN(EBUSY); /* Not while in use */
return DRM_ERR(EINVAL);
if ( dev->queue_count ) return DRM_ERR(EBUSY); /* Not while in use */
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( dev->buf_use ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
atomic_inc( &dev->buf_alloc );
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_LOCK;
DRM_LOCK;
entry = &dma->bufs[order];
if ( entry->buf_count ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM); /* May only call once for each order */
return DRM_ERR(ENOMEM); /* May only call once for each order */
}
if (count < 0 || count > 4096) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
DRM_MEM_BUFS );
if ( !entry->buflist ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
@ -785,9 +785,9 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
/* Set count correctly so we free the proper amount. */
entry->buf_count = count;
DRM(cleanup_buf_error)(entry);
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( buf->dev_private, 0, buf->dev_priv_size );
@ -816,9 +816,9 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
if(!temp_buflist) {
/* Free the entry because it isn't valid */
DRM(cleanup_buf_error)(entry);
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
dma->buflist = temp_buflist;
@ -838,12 +838,12 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
}
#endif
DRM_OS_UNLOCK;
DRM_UNLOCK;
request.count = entry->buf_count;
request.size = size;
DRM_OS_KRNTOUSR( (drm_buf_desc_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_buf_desc_t *)data, request, sizeof(request) );
dma->flags = _DRM_DMA_USE_SG;
@ -852,11 +852,11 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
}
#endif /* __REALLY_HAVE_SG */
int DRM(addbufs)( DRM_OS_IOCTL )
int DRM(addbufs)( DRM_IOCTL_ARGS )
{
drm_buf_desc_t request;
DRM_OS_KRNFROMUSR( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
#if __REALLY_HAVE_AGP
if ( request.flags & _DRM_AGP_BUFFER )
@ -871,29 +871,29 @@ int DRM(addbufs)( DRM_OS_IOCTL )
#if __HAVE_PCI_DMA
return DRM(addbufs_pci)( kdev, cmd, data, flags, p );
#else
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
#endif
}
int DRM(infobufs)( DRM_OS_IOCTL )
int DRM(infobufs)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_info_t request;
int i;
int count;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( atomic_read( &dev->buf_alloc ) ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
++dev->buf_use; /* Can't allocate more after this call */
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_KRNFROMUSR( request, (drm_buf_info_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_info_t *)data, sizeof(request) );
for ( i = 0, count = 0 ; i < DRM_MAX_ORDER + 1 ; i++ ) {
if ( dma->bufs[i].buf_count ) ++count;
@ -907,19 +907,19 @@ int DRM(infobufs)( DRM_OS_IOCTL )
drm_buf_desc_t *to = &request.list[count];
drm_buf_entry_t *from = &dma->bufs[i];
drm_freelist_t *list = &dma->bufs[i].freelist;
if ( DRM_OS_COPYTOUSR( &to->count,
if ( DRM_COPY_TO_USER( &to->count,
&from->buf_count,
sizeof(from->buf_count) ) ||
DRM_OS_COPYTOUSR( &to->size,
DRM_COPY_TO_USER( &to->size,
&from->buf_size,
sizeof(from->buf_size) ) ||
DRM_OS_COPYTOUSR( &to->low_mark,
DRM_COPY_TO_USER( &to->low_mark,
&list->low_mark,
sizeof(list->low_mark) ) ||
DRM_OS_COPYTOUSR( &to->high_mark,
DRM_COPY_TO_USER( &to->high_mark,
&list->high_mark,
sizeof(list->high_mark) ) )
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
DRM_DEBUG( "%d %d %d %d %d\n",
i,
@ -933,34 +933,34 @@ int DRM(infobufs)( DRM_OS_IOCTL )
}
request.count = count;
DRM_OS_KRNTOUSR( (drm_buf_info_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_buf_info_t *)data, request, sizeof(request) );
return 0;
}
int DRM(markbufs)( DRM_OS_IOCTL )
int DRM(markbufs)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_desc_t request;
int order;
drm_buf_entry_t *entry;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_KRNFROMUSR( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_DEBUG( "%d, %d, %d\n",
request.size, request.low_mark, request.high_mark );
order = DRM(order)( request.size );
if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
entry = &dma->bufs[order];
if ( request.low_mark < 0 || request.low_mark > entry->buf_count )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
if ( request.high_mark < 0 || request.high_mark > entry->buf_count )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
entry->freelist.low_mark = request.low_mark;
entry->freelist.high_mark = request.high_mark;
@ -968,35 +968,35 @@ int DRM(markbufs)( DRM_OS_IOCTL )
return 0;
}
int DRM(freebufs)( DRM_OS_IOCTL )
int DRM(freebufs)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_free_t request;
int i;
int idx;
drm_buf_t *buf;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_KRNFROMUSR( request, (drm_buf_free_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_free_t *)data, sizeof(request) );
DRM_DEBUG( "%d\n", request.count );
for ( i = 0 ; i < request.count ; i++ ) {
if ( DRM_OS_COPYFROMUSR( &idx,
if ( DRM_COPY_FROM_USER( &idx,
&request.list[i],
sizeof(idx) ) )
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
if ( idx < 0 || idx >= dma->buf_count ) {
DRM_ERROR( "Index %d (of %d max)\n",
idx, dma->buf_count - 1 );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
buf = dma->buflist[idx];
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "Process %d freeing buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
DRM_OS_RETURN(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
DRM(free_buffer)( dev, buf );
}
@ -1004,9 +1004,9 @@ int DRM(freebufs)( DRM_OS_IOCTL )
return 0;
}
int DRM(mapbufs)( DRM_OS_IOCTL )
int DRM(mapbufs)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
int retcode = 0;
const int zero = 0;
@ -1025,17 +1025,17 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
drm_buf_map_t request;
int i;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( atomic_read( &dev->buf_alloc ) ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
dev->buf_use++; /* Can't allocate more after this call */
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_KRNFROMUSR( request, (drm_buf_map_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_map_t *)data, sizeof(request) );
#ifdef __NetBSD__
if(!vfinddev(kdev, VCHR, &vn))
@ -1097,26 +1097,26 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
request.virtual = (void *)virtual;
for ( i = 0 ; i < dma->buf_count ; i++ ) {
if ( DRM_OS_COPYTOUSR( &request.list[i].idx,
if ( DRM_COPY_TO_USER( &request.list[i].idx,
&dma->buflist[i]->idx,
sizeof(request.list[0].idx) ) ) {
retcode = EFAULT;
goto done;
}
if ( DRM_OS_COPYTOUSR( &request.list[i].total,
if ( DRM_COPY_TO_USER( &request.list[i].total,
&dma->buflist[i]->total,
sizeof(request.list[0].total) ) ) {
retcode = EFAULT;
goto done;
}
if ( DRM_OS_COPYTOUSR( &request.list[i].used,
if ( DRM_COPY_TO_USER( &request.list[i].used,
&zero,
sizeof(zero) ) ) {
retcode = EFAULT;
goto done;
}
address = virtual + dma->buflist[i]->offset; /* *** */
if ( DRM_OS_COPYTOUSR( &request.list[i].address,
if ( DRM_COPY_TO_USER( &request.list[i].address,
&address,
sizeof(address) ) ) {
retcode = EFAULT;
@ -1129,9 +1129,9 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
DRM_DEBUG( "%d buffers, retcode = %d\n", request.count, retcode );
DRM_OS_KRNTOUSR( (drm_buf_map_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_buf_map_t *)data, request, sizeof(request) );
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
#endif /* __HAVE_DMA */

188
bsd-core/drm_context.c
View file

@ -43,10 +43,10 @@ void DRM(ctxbitmap_free)( drm_device_t *dev, int ctx_handle )
if ( !dev->ctx_bitmap ) goto failed;
if ( ctx_handle < DRM_MAX_CTXBITMAP ) {
DRM_OS_LOCK;
DRM_LOCK;
clear_bit( ctx_handle, dev->ctx_bitmap );
dev->context_sareas[ctx_handle] = NULL;
DRM_OS_UNLOCK;
DRM_UNLOCK;
return;
}
failed:
@ -61,7 +61,7 @@ int DRM(ctxbitmap_next)( drm_device_t *dev )
if(!dev->ctx_bitmap) return -1;
DRM_OS_LOCK;
DRM_LOCK;
bit = find_first_zero_bit( dev->ctx_bitmap, DRM_MAX_CTXBITMAP );
if ( bit < DRM_MAX_CTXBITMAP ) {
set_bit( bit, dev->ctx_bitmap );
@ -79,7 +79,7 @@ int DRM(ctxbitmap_next)( drm_device_t *dev )
DRM_MEM_MAPS);
if(!ctx_sareas) {
clear_bit(bit, dev->ctx_bitmap);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return -1;
}
dev->context_sareas = ctx_sareas;
@ -92,16 +92,16 @@ int DRM(ctxbitmap_next)( drm_device_t *dev )
DRM_MEM_MAPS);
if(!dev->context_sareas) {
clear_bit(bit, dev->ctx_bitmap);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return -1;
}
dev->context_sareas[bit] = NULL;
}
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return bit;
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return -1;
}
@ -110,17 +110,17 @@ int DRM(ctxbitmap_init)( drm_device_t *dev )
int i;
int temp;
DRM_OS_LOCK;
DRM_LOCK;
dev->ctx_bitmap = (atomic_t *) DRM(alloc)( PAGE_SIZE,
DRM_MEM_CTXBITMAP );
if ( dev->ctx_bitmap == NULL ) {
DRM_OS_UNLOCK;
DRM_OS_RETURN(ENOMEM);
DRM_UNLOCK;
return DRM_ERR(ENOMEM);
}
memset( (void *)dev->ctx_bitmap, 0, PAGE_SIZE );
dev->context_sareas = NULL;
dev->max_context = -1;
DRM_OS_UNLOCK;
DRM_UNLOCK;
for ( i = 0 ; i < DRM_RESERVED_CONTEXTS ; i++ ) {
temp = DRM(ctxbitmap_next)( dev );
@ -132,55 +132,55 @@ int DRM(ctxbitmap_init)( drm_device_t *dev )
void DRM(ctxbitmap_cleanup)( drm_device_t *dev )
{
DRM_OS_LOCK;
DRM_LOCK;
if( dev->context_sareas ) DRM(free)( dev->context_sareas,
sizeof(*dev->context_sareas) *
dev->max_context,
DRM_MEM_MAPS );
DRM(free)( (void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP );
DRM_OS_UNLOCK;
DRM_UNLOCK;
}
/* ================================================================
* Per Context SAREA Support
*/
int DRM(getsareactx)( DRM_OS_IOCTL )
int DRM(getsareactx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_priv_map_t request;
drm_map_t *map;
DRM_OS_KRNFROMUSR( request, (drm_ctx_priv_map_t *)data,
DRM_COPY_FROM_USER_IOCTL( request, (drm_ctx_priv_map_t *)data,
sizeof(request) );
DRM_OS_LOCK;
DRM_LOCK;
if (dev->max_context < 0 || request.ctx_id >= (unsigned) dev->max_context) {
DRM_OS_UNLOCK;
DRM_OS_RETURN(EINVAL);
DRM_UNLOCK;
return DRM_ERR(EINVAL);
}
map = dev->context_sareas[request.ctx_id];
DRM_OS_UNLOCK;
DRM_UNLOCK;
request.handle = map->handle;
DRM_OS_KRNTOUSR( (drm_ctx_priv_map_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_priv_map_t *)data, request, sizeof(request) );
return 0;
}
int DRM(setsareactx)( DRM_OS_IOCTL )
int DRM(setsareactx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_priv_map_t request;
drm_map_t *map = NULL;
drm_map_list_entry_t *list;
DRM_OS_KRNFROMUSR( request, (drm_ctx_priv_map_t *)data,
DRM_COPY_FROM_USER_IOCTL( request, (drm_ctx_priv_map_t *)data,
sizeof(request) );
DRM_OS_LOCK;
DRM_LOCK;
TAILQ_FOREACH(list, dev->maplist, link) {
map=list->map;
if(map->handle == request.handle)
@ -188,8 +188,8 @@ int DRM(setsareactx)( DRM_OS_IOCTL )
}
bad:
DRM_OS_UNLOCK;
return DRM_OS_ERR(EINVAL);
DRM_UNLOCK;
return DRM_ERR(EINVAL);
found:
map = list->map;
@ -199,7 +199,7 @@ found:
if (request.ctx_id >= (unsigned) dev->max_context)
goto bad;
dev->context_sareas[request.ctx_id] = map;
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
@ -213,7 +213,7 @@ int DRM(context_switch)( drm_device_t *dev, int old, int new )
if ( test_and_set_bit( 0, &dev->context_flag ) ) {
DRM_ERROR( "Reentering -- FIXME\n" );
DRM_OS_RETURN(EBUSY);
return DRM_ERR(EBUSY);
}
#if __HAVE_DMA_HISTOGRAM
@ -255,41 +255,41 @@ int DRM(context_switch_complete)( drm_device_t *dev, int new )
#endif
clear_bit( 0, &dev->context_flag );
DRM_OS_WAKEUP( (void *)&dev->context_wait );
DRM_WAKEUP( (void *)&dev->context_wait );
return 0;
}
int DRM(resctx)( DRM_OS_IOCTL )
int DRM(resctx)( DRM_IOCTL_ARGS )
{
drm_ctx_res_t res;
drm_ctx_t ctx;
int i;
DRM_OS_KRNFROMUSR( res, (drm_ctx_res_t *)data, sizeof(res) );
DRM_COPY_FROM_USER_IOCTL( res, (drm_ctx_res_t *)data, sizeof(res) );
if ( res.count >= DRM_RESERVED_CONTEXTS ) {
memset( &ctx, 0, sizeof(ctx) );
for ( i = 0 ; i < DRM_RESERVED_CONTEXTS ; i++ ) {
ctx.handle = i;
if ( DRM_OS_COPYTOUSR( &res.contexts[i],
if ( DRM_COPY_TO_USER( &res.contexts[i],
&i, sizeof(i) ) )
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
}
}
res.count = DRM_RESERVED_CONTEXTS;
DRM_OS_KRNTOUSR( (drm_ctx_res_t *)data, res, sizeof(res) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_res_t *)data, res, sizeof(res) );
return 0;
}
int DRM(addctx)( DRM_OS_IOCTL )
int DRM(addctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
ctx.handle = DRM(ctxbitmap_next)( dev );
if ( ctx.handle == DRM_KERNEL_CONTEXT ) {
@ -300,51 +300,51 @@ int DRM(addctx)( DRM_OS_IOCTL )
if ( ctx.handle == -1 ) {
DRM_DEBUG( "Not enough free contexts.\n" );
/* Should this return -EBUSY instead? */
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
DRM_OS_KRNTOUSR( (drm_ctx_t *)data, ctx, sizeof(ctx) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_t *)data, ctx, sizeof(ctx) );
return 0;
}
int DRM(modctx)( DRM_OS_IOCTL )
int DRM(modctx)( DRM_IOCTL_ARGS )
{
/* This does nothing */
return 0;
}
int DRM(getctx)( DRM_OS_IOCTL )
int DRM(getctx)( DRM_IOCTL_ARGS )
{
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
/* This is 0, because we don't handle any context flags */
ctx.flags = 0;
DRM_OS_KRNTOUSR( (drm_ctx_t *)data, ctx, sizeof(ctx) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_t *)data, ctx, sizeof(ctx) );
return 0;
}
int DRM(switchctx)( DRM_OS_IOCTL )
int DRM(switchctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG( "%d\n", ctx.handle );
return DRM(context_switch)( dev, dev->last_context, ctx.handle );
}
int DRM(newctx)( DRM_OS_IOCTL )
int DRM(newctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG( "%d\n", ctx.handle );
DRM(context_switch_complete)( dev, ctx.handle );
@ -352,12 +352,12 @@ int DRM(newctx)( DRM_OS_IOCTL )
return 0;
}
int DRM(rmctx)( DRM_OS_IOCTL )
int DRM(rmctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG( "%d\n", ctx.handle );
if ( ctx.handle != DRM_KERNEL_CONTEXT ) {
@ -386,7 +386,7 @@ int DRM(context_switch)(drm_device_t *dev, int old, int new)
if (test_and_set_bit(0, &dev->context_flag)) {
DRM_ERROR("Reentering -- FIXME\n");
DRM_OS_RETURN(EBUSY);
return DRM_ERR(EBUSY);
}
#if __HAVE_DMA_HISTOGRAM
@ -397,7 +397,7 @@ int DRM(context_switch)(drm_device_t *dev, int old, int new)
if (new >= dev->queue_count) {
clear_bit(0, &dev->context_flag);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (new == dev->last_context) {
@ -410,7 +410,7 @@ int DRM(context_switch)(drm_device_t *dev, int old, int new)
if (atomic_read(&q->use_count) == 1) {
atomic_dec(&q->use_count);
clear_bit(0, &dev->context_flag);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (DRM(flags) & DRM_FLAG_NOCTX) {
@ -449,7 +449,7 @@ int DRM(context_switch_complete)(drm_device_t *dev, int new)
#endif
clear_bit(0, &dev->context_flag);
DRM_OS_WAKEUP_INT(&dev->context_wait);
DRM_WAKEUP_INT(&dev->context_wait);
return 0;
}
@ -513,7 +513,7 @@ static int DRM(alloc_queue)(drm_device_t *dev)
atomic_dec(&dev->queuelist[i]->use_count);
}
/* Allocate a new queue */
DRM_OS_LOCK;
DRM_LOCK;
queue = gamma_alloc(sizeof(*queue), DRM_MEM_QUEUES);
memset(queue, 0, sizeof(*queue));
@ -531,19 +531,19 @@ static int DRM(alloc_queue)(drm_device_t *dev)
newslots,
DRM_MEM_QUEUES);
if (!dev->queuelist) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM_DEBUG("out of memory\n");
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
}
dev->queuelist[dev->queue_count-1] = queue;
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM_DEBUG("%d (new)\n", dev->queue_count - 1);
return dev->queue_count - 1;
}
int DRM(resctx)( DRM_OS_IOCTL )
int DRM(resctx)( DRM_IOCTL_ARGS )
{
drm_ctx_res_t res;
drm_ctx_t ctx;
@ -551,31 +551,31 @@ int DRM(resctx)( DRM_OS_IOCTL )
DRM_DEBUG("%d\n", DRM_RESERVED_CONTEXTS);
DRM_OS_KRNFROMUSR( res, (drm_ctx_res_t *)data, sizeof(res) );
DRM_COPY_FROM_USER_IOCTL( res, (drm_ctx_res_t *)data, sizeof(res) );
if (res.count >= DRM_RESERVED_CONTEXTS) {
memset(&ctx, 0, sizeof(ctx));
for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
ctx.handle = i;
if (DRM_OS_COPYTOUSR(&res.contexts[i],
if (DRM_COPY_TO_USER(&res.contexts[i],
&i,
sizeof(i)))
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
}
}
res.count = DRM_RESERVED_CONTEXTS;
DRM_OS_KRNTOUSR( (drm_ctx_res_t *)data, res, sizeof(res) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_res_t *)data, res, sizeof(res) );
return 0;
}
int DRM(addctx)( DRM_OS_IOCTL )
int DRM(addctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
if ((ctx.handle = DRM(alloc_queue)(dev)) == DRM_KERNEL_CONTEXT) {
/* Init kernel's context and get a new one. */
@ -585,35 +585,35 @@ int DRM(addctx)( DRM_OS_IOCTL )
DRM(init_queue)(dev, dev->queuelist[ctx.handle], &ctx);
DRM_DEBUG("%d\n", ctx.handle);
DRM_OS_KRNTOUSR( (drm_ctx_t *)data, ctx, sizeof(ctx) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_t *)data, ctx, sizeof(ctx) );
return 0;
}
int DRM(modctx)( DRM_OS_IOCTL )
int DRM(modctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
drm_queue_t *q;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG("%d\n", ctx.handle);
if (ctx.handle < 0 || ctx.handle >= dev->queue_count)
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
q = dev->queuelist[ctx.handle];
atomic_inc(&q->use_count);
if (atomic_read(&q->use_count) == 1) {
/* No longer in use */
atomic_dec(&q->use_count);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (DRM_BUFCOUNT(&q->waitlist)) {
atomic_dec(&q->use_count);
DRM_OS_RETURN(EBUSY);
return DRM_ERR(EBUSY);
}
q->flags = ctx.flags;
@ -622,52 +622,52 @@ int DRM(modctx)( DRM_OS_IOCTL )
return 0;
}
int DRM(getctx)( DRM_OS_IOCTL )
int DRM(getctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
drm_queue_t *q;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG("%d\n", ctx.handle);
if (ctx.handle >= dev->queue_count)
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
q = dev->queuelist[ctx.handle];
atomic_inc(&q->use_count);
if (atomic_read(&q->use_count) == 1) {
/* No longer in use */
atomic_dec(&q->use_count);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
ctx.flags = q->flags;
atomic_dec(&q->use_count);
DRM_OS_KRNTOUSR( (drm_ctx_t *)data, ctx, sizeof(ctx) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_t *)data, ctx, sizeof(ctx) );
return 0;
}
int DRM(switchctx)( DRM_OS_IOCTL )
int DRM(switchctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG("%d\n", ctx.handle);
return DRM(context_switch)(dev, dev->last_context, ctx.handle);
}
int DRM(newctx)( DRM_OS_IOCTL )
int DRM(newctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG("%d\n", ctx.handle);
DRM(context_switch_complete)(dev, ctx.handle);
@ -675,25 +675,25 @@ int DRM(newctx)( DRM_OS_IOCTL )
return 0;
}
int DRM(rmctx)( DRM_OS_IOCTL )
int DRM(rmctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
drm_queue_t *q;
drm_buf_t *buf;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG("%d\n", ctx.handle);
if (ctx.handle >= dev->queue_count) DRM_OS_RETURN(EINVAL);
if (ctx.handle >= dev->queue_count) return DRM_ERR(EINVAL);
q = dev->queuelist[ctx.handle];
atomic_inc(&q->use_count);
if (atomic_read(&q->use_count) == 1) {
/* No longer in use */
atomic_dec(&q->use_count);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
atomic_inc(&q->finalization); /* Mark queue in finalization state */
@ -716,7 +716,7 @@ int DRM(rmctx)( DRM_OS_IOCTL )
/* Wakeup blocked processes */
wakeup( &q->block_read );
wakeup( &q->block_write );
DRM_OS_WAKEUP_INT( &q->flush_queue );
DRM_WAKEUP_INT( &q->flush_queue );
/* Finalization over. Queue is made
available when both use_count and
finalization become 0, which won't

66
bsd-core/drm_dma.c
View file

@ -55,7 +55,7 @@ int DRM(dma_setup)( drm_device_t *dev )
dev->dma = DRM(alloc)( sizeof(*dev->dma), DRM_MEM_DRIVER );
if ( !dev->dma )
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev->dma, 0, sizeof(*dev->dma) );
@ -244,7 +244,7 @@ void DRM(clear_next_buffer)(drm_device_t *dev)
dma->next_buffer = NULL;
if (dma->next_queue && !DRM_BUFCOUNT(&dma->next_queue->waitlist)) {
DRM_OS_WAKEUP_INT(&dma->next_queue->flush_queue);
DRM_WAKEUP_INT(&dma->next_queue->flush_queue);
}
dma->next_queue = NULL;
}
@ -336,7 +336,7 @@ int DRM(dma_enqueue)(drm_device_t *dev, drm_dma_t *d)
if (!_DRM_LOCK_IS_HELD(context)) {
DRM_ERROR("No lock held during \"while locked\""
" request\n");
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (d->context != _DRM_LOCKING_CONTEXT(context)
&& _DRM_LOCKING_CONTEXT(context) != DRM_KERNEL_CONTEXT) {
@ -344,7 +344,7 @@ int DRM(dma_enqueue)(drm_device_t *dev, drm_dma_t *d)
" \"while locked\" request\n",
_DRM_LOCKING_CONTEXT(context),
d->context);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
q = dev->queuelist[DRM_KERNEL_CONTEXT];
while_locked = 1;
@ -374,19 +374,19 @@ int DRM(dma_enqueue)(drm_device_t *dev, drm_dma_t *d)
atomic_dec(&q->use_count);
DRM_ERROR("Index %d (of %d max)\n",
d->send_indices[i], dma->buf_count - 1);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
buf = dma->buflist[ idx ];
if (buf->pid != DRM_OS_CURRENTPID) {
if (buf->pid != DRM_CURRENTPID) {
atomic_dec(&q->use_count);
DRM_ERROR("Process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid);
DRM_OS_RETURN(EINVAL);
DRM_CURRENTPID, buf->pid);
return DRM_ERR(EINVAL);
}
if (buf->list != DRM_LIST_NONE) {
atomic_dec(&q->use_count);
DRM_ERROR("Process %d using buffer %d on list %d\n",
DRM_OS_CURRENTPID, buf->idx, buf->list);
DRM_CURRENTPID, buf->idx, buf->list);
}
buf->used = d->send_sizes[i];
buf->while_locked = while_locked;
@ -399,14 +399,14 @@ int DRM(dma_enqueue)(drm_device_t *dev, drm_dma_t *d)
DRM_ERROR("Queueing pending buffer:"
" buffer %d, offset %d\n",
d->send_indices[i], i);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (buf->waiting) {
atomic_dec(&q->use_count);
DRM_ERROR("Queueing waiting buffer:"
" buffer %d, offset %d\n",
d->send_indices[i], i);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
buf->waiting = 1;
if (atomic_read(&q->use_count) == 1
@ -440,16 +440,16 @@ static int DRM(dma_get_buffers_of_order)(drm_device_t *dev, drm_dma_t *d,
buf->waiting,
buf->pending);
}
buf->pid = DRM_OS_CURRENTPID;
if (DRM_OS_COPYTOUSR(&d->request_indices[i],
buf->pid = DRM_CURRENTPID;
if (DRM_COPY_TO_USER(&d->request_indices[i],
&buf->idx,
sizeof(buf->idx)))
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
if (DRM_OS_COPYTOUSR(&d->request_sizes[i],
if (DRM_COPY_TO_USER(&d->request_sizes[i],
&buf->total,
sizeof(buf->total)))
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
++d->granted_count;
}
@ -507,15 +507,15 @@ int DRM(irq_install)( drm_device_t *dev, int irq )
int retcode;
if ( !irq )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
DRM_OS_LOCK;
DRM_LOCK;
if ( dev->irq ) {
DRM_OS_UNLOCK;
DRM_OS_RETURN(EBUSY);
DRM_UNLOCK;
return DRM_ERR(EBUSY);
}
dev->irq = irq;
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM_DEBUG( "%s: irq=%d\n", __FUNCTION__, irq );
@ -544,10 +544,10 @@ int DRM(irq_install)( drm_device_t *dev, int irq )
retcode = bus_setup_intr(dev->device, dev->irqr, INTR_TYPE_TTY,
DRM(dma_service), dev, &dev->irqh);
if ( retcode ) {
DRM_OS_LOCK;
DRM_LOCK;
bus_release_resource(dev->device, SYS_RES_IRQ, 0, dev->irqr);
dev->irq = 0;
DRM_OS_UNLOCK;
DRM_UNLOCK;
return retcode;
}
@ -561,13 +561,13 @@ int DRM(irq_uninstall)( drm_device_t *dev )
{
int irq;
DRM_OS_LOCK;
DRM_LOCK;
irq = dev->irq;
dev->irq = 0;
DRM_OS_UNLOCK;
DRM_UNLOCK;
if ( !irq )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
DRM_DEBUG( "%s: irq=%d\n", __FUNCTION__, irq );
@ -579,12 +579,12 @@ int DRM(irq_uninstall)( drm_device_t *dev )
return 0;
}
int DRM(control)( DRM_OS_IOCTL )
int DRM(control)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_control_t ctl;
DRM_OS_KRNFROMUSR( ctl, (drm_control_t *) data, sizeof(ctl) );
DRM_COPY_FROM_USER_IOCTL( ctl, (drm_control_t *) data, sizeof(ctl) );
switch ( ctl.func ) {
case DRM_INST_HANDLER:
@ -592,24 +592,24 @@ int DRM(control)( DRM_OS_IOCTL )
case DRM_UNINST_HANDLER:
return DRM(irq_uninstall)( dev );
default:
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
}
#else
int DRM(control)( DRM_OS_IOCTL )
int DRM(control)( DRM_IOCTL_ARGS )
{
drm_control_t ctl;
DRM_OS_KRNFROMUSR( ctl, (drm_control_t *) data, sizeof(ctl) );
DRM_COPY_FROM_USER_IOCTL( ctl, (drm_control_t *) data, sizeof(ctl) );
switch ( ctl.func ) {
case DRM_INST_HANDLER:
case DRM_UNINST_HANDLER:
return 0;
default:
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
}

6
bsd-core/drm_drawable.c
View file

@ -31,19 +31,19 @@
#include "drmP.h"
int DRM(adddraw)( DRM_OS_IOCTL )
int DRM(adddraw)( DRM_IOCTL_ARGS )
{
drm_draw_t draw;
draw.handle = 0; /* NOOP */
DRM_DEBUG("%d\n", draw.handle);
DRM_OS_KRNTOUSR( (drm_draw_t *)data, draw, sizeof(draw) );
DRM_COPY_TO_USER_IOCTL( (drm_draw_t *)data, draw, sizeof(draw) );
return 0;
}
int DRM(rmdraw)( DRM_OS_IOCTL )
int DRM(rmdraw)( DRM_IOCTL_ARGS )
{
return 0; /* NOOP */
}

106
bsd-core/drm_drv.c
View file

@ -426,7 +426,7 @@ static int DRM(setup)( drm_device_t *dev )
dev->maplist = DRM(alloc)(sizeof(*dev->maplist),
DRM_MEM_MAPS);
if(dev->maplist == NULL) DRM_OS_RETURN(ENOMEM);
if(dev->maplist == NULL) return DRM_ERR(ENOMEM);
memset(dev->maplist, 0, sizeof(*dev->maplist));
TAILQ_INIT(dev->maplist);
dev->map_count = 0;
@ -495,7 +495,7 @@ static int DRM(takedown)( drm_device_t *dev )
if ( dev->irq ) DRM(irq_uninstall)( dev );
#endif
DRM_OS_LOCK;
DRM_LOCK;
callout_stop( &dev->timer );
if ( dev->devname ) {
@ -580,7 +580,7 @@ static int DRM(takedown)( drm_device_t *dev )
/*mtrrmap.owner = p->p_pid;*/
/* XXX: Use curproc here? */
retcode = mtrr_set( &mtrrmap, &one,
DRM_OS_CURPROC, MTRR_GETSET_KERNEL);
DRM_CURPROC, MTRR_GETSET_KERNEL);
#endif
DRM_DEBUG( "mtrr_del=%d\n", retcode );
}
@ -643,9 +643,9 @@ static int DRM(takedown)( drm_device_t *dev )
if ( dev->lock.hw_lock ) {
dev->lock.hw_lock = NULL; /* SHM removed */
dev->lock.pid = 0;
DRM_OS_WAKEUP_INT((void *)&dev->lock.lock_queue);
DRM_WAKEUP_INT((void *)&dev->lock.lock_queue);
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
@ -684,7 +684,7 @@ static int DRM(init)( drm_device_t *dev )
#elif defined(__NetBSD__)
unit = minor(dev->device.dv_unit);
#endif
DRM_OS_SPININIT(dev->count_lock, "drm device");
DRM_SPININIT(dev->count_lock, "drm device");
lockinit(&dev->dev_lock, PZERO, "drmlk", 0, 0);
dev->name = DRIVER_NAME;
DRM(mem_init)();
@ -701,7 +701,7 @@ static int DRM(init)( drm_device_t *dev )
destroy_dev(dev->devnode);
#endif
DRM(takedown)( dev );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
#endif /* __MUST_HAVE_AGP */
#if __REALLY_HAVE_MTRR
@ -813,20 +813,20 @@ static void DRM(cleanup)(drm_device_t *dev)
}
int DRM(version)( DRM_OS_IOCTL )
int DRM(version)( DRM_IOCTL_ARGS )
{
drm_version_t version;
int len;
DRM_OS_KRNFROMUSR( version, (drm_version_t *)data, sizeof(version) );
DRM_COPY_FROM_USER_IOCTL( version, (drm_version_t *)data, sizeof(version) );
#define DRM_COPY( name, value ) \
len = strlen( value ); \
if ( len > name##_len ) len = name##_len; \
name##_len = strlen( value ); \
if ( len && name ) { \
if ( DRM_OS_COPYTOUSR( name, value, len ) ) \
DRM_OS_RETURN(EFAULT); \
if ( DRM_COPY_TO_USER( name, value, len ) ) \
return DRM_ERR(EFAULT); \
}
version.version_major = DRIVER_MAJOR;
@ -837,12 +837,12 @@ int DRM(version)( DRM_OS_IOCTL )
DRM_COPY( version.date, DRIVER_DATE );
DRM_COPY( version.desc, DRIVER_DESC );
DRM_OS_KRNTOUSR( (drm_version_t *)data, version, sizeof(version) );
DRM_COPY_TO_USER_IOCTL( (drm_version_t *)data, version, sizeof(version) );
return 0;
}
int DRM(open)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
int DRM(open)(dev_t kdev, int flags, int fmt, DRM_STRUCTPROC *p)
{
drm_device_t *dev = NULL;
int retcode = 0;
@ -858,13 +858,13 @@ int DRM(open)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
if ( !retcode ) {
atomic_inc( &dev->counts[_DRM_STAT_OPENS] );
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( !dev->open_count++ ) {
retcode = DRM(setup)( dev );
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
return retcode;
}
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
}
#ifdef __FreeBSD__
device_unbusy(dev->device);
@ -873,10 +873,10 @@ int DRM(open)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
return retcode;
}
int DRM(close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
int DRM(close)(dev_t kdev, int flags, int fmt, DRM_STRUCTPROC *p)
{
drm_file_t *priv;
DRM_OS_DEVICE;
DRM_DEVICE;
int retcode = 0;
DRM_DEBUG( "open_count = %d\n", dev->open_count );
@ -894,16 +894,16 @@ int DRM(close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
#ifdef __FreeBSD__
DRM_DEBUG( "pid = %d, device = 0x%lx, open_count = %d\n",
DRM_OS_CURRENTPID, (long)dev->device, dev->open_count );
DRM_CURRENTPID, (long)dev->device, dev->open_count );
#elif defined(__NetBSD__)
DRM_DEBUG( "pid = %d, device = 0x%lx, open_count = %d\n",
DRM_OS_CURRENTPID, (long)&dev->device, dev->open_count);
DRM_CURRENTPID, (long)&dev->device, dev->open_count);
#endif
if (dev->lock.hw_lock && _DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)
&& dev->lock.pid == DRM_OS_CURRENTPID) {
&& dev->lock.pid == DRM_CURRENTPID) {
DRM_DEBUG("Process %d dead, freeing lock for context %d\n",
DRM_OS_CURRENTPID,
DRM_CURRENTPID,
_DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
#if HAVE_DRIVER_RELEASE
DRIVER_RELEASE();
@ -962,7 +962,7 @@ int DRM(close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
dev->buf_pgid = 0;
#endif /* __NetBSD__ */
DRM_OS_LOCK;
DRM_LOCK;
priv = DRM(find_file_by_proc)(dev, p);
if (priv) {
priv->refs--;
@ -970,7 +970,7 @@ int DRM(close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
TAILQ_REMOVE(&dev->files, priv, link);
}
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM(free)( priv, sizeof(*priv), DRM_MEM_FILES );
@ -979,36 +979,36 @@ int DRM(close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
*/
atomic_inc( &dev->counts[_DRM_STAT_CLOSES] );
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( !--dev->open_count ) {
if ( atomic_read( &dev->ioctl_count ) || dev->blocked ) {
DRM_ERROR( "Device busy: %ld %d\n",
(unsigned long)atomic_read( &dev->ioctl_count ),
dev->blocked );
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
return DRM(takedown)( dev );
}
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
#ifdef __FreeBSD__
device_unbusy(dev->device);
#endif
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
/* DRM(ioctl) is called whenever a process performs an ioctl on /dev/drm.
*/
int DRM(ioctl)( DRM_OS_IOCTL )
int DRM(ioctl)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
int retcode = 0;
drm_ioctl_desc_t *ioctl;
d_ioctl_t *func;
int nr = DRM_IOCTL_NR(cmd);
DRM_OS_PRIV;
DRM_PRIV;
atomic_inc( &dev->ioctl_count );
atomic_inc( &dev->counts[_DRM_STAT_IOCTLS] );
@ -1016,10 +1016,10 @@ int DRM(ioctl)( DRM_OS_IOCTL )
#ifdef __FreeBSD__
DRM_DEBUG( "pid=%d, cmd=0x%02lx, nr=0x%02x, dev 0x%lx, auth=%d\n",
DRM_OS_CURRENTPID, cmd, nr, (long)dev->device, priv->authenticated );
DRM_CURRENTPID, cmd, nr, (long)dev->device, priv->authenticated );
#elif defined(__NetBSD__)
DRM_DEBUG( "pid=%d, cmd=0x%02lx, nr=0x%02x, dev 0x%lx, auth=%d\n",
DRM_OS_CURRENTPID, cmd, nr, (long)&dev->device, priv->authenticated );
DRM_CURRENTPID, cmd, nr, (long)&dev->device, priv->authenticated );
#endif
switch (cmd) {
@ -1064,7 +1064,7 @@ int DRM(ioctl)( DRM_OS_IOCTL )
if ( !func ) {
DRM_DEBUG( "no function\n" );
retcode = EINVAL;
} else if ( ( ioctl->root_only && DRM_OS_SUSER(p) )
} else if ( ( ioctl->root_only && DRM_SUSER(p) )
|| ( ioctl->auth_needed && !priv->authenticated ) ) {
retcode = EACCES;
} else {
@ -1073,12 +1073,12 @@ int DRM(ioctl)( DRM_OS_IOCTL )
}
atomic_dec( &dev->ioctl_count );
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
int DRM(lock)( DRM_OS_IOCTL )
int DRM(lock)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_lock_t lock;
int ret = 0;
#if __HAVE_MULTIPLE_DMA_QUEUES
@ -1090,24 +1090,24 @@ int DRM(lock)( DRM_OS_IOCTL )
dev->lck_start = start = get_cycles();
#endif
DRM_OS_KRNFROMUSR( lock, (drm_lock_t *)data, sizeof(lock) );
DRM_COPY_FROM_USER_IOCTL( lock, (drm_lock_t *)data, sizeof(lock) );
if ( lock.context == DRM_KERNEL_CONTEXT ) {
DRM_ERROR( "Process %d using kernel context %d\n",
DRM_OS_CURRENTPID, lock.context );
DRM_OS_RETURN(EINVAL);
DRM_CURRENTPID, lock.context );
return DRM_ERR(EINVAL);
}
DRM_DEBUG( "%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
lock.context, DRM_OS_CURRENTPID,
lock.context, DRM_CURRENTPID,
dev->lock.hw_lock->lock, lock.flags );
#if __HAVE_DMA_QUEUE
if ( lock.context < 0 )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
#elif __HAVE_MULTIPLE_DMA_QUEUES
if ( lock.context < 0 || lock.context >= dev->queue_count )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
q = dev->queuelist[lock.context];
#endif
@ -1123,7 +1123,7 @@ int DRM(lock)( DRM_OS_IOCTL )
}
if ( DRM(lock_take)( &dev->lock.hw_lock->lock,
lock.context ) ) {
dev->lock.pid = DRM_OS_CURRENTPID;
dev->lock.pid = DRM_CURRENTPID;
dev->lock.lock_time = jiffies;
atomic_inc( &dev->counts[_DRM_STAT_LOCKS] );
break; /* Got lock */
@ -1169,21 +1169,21 @@ int DRM(lock)( DRM_OS_IOCTL )
atomic_inc(&dev->histo.lacq[DRM(histogram_slot)(get_cycles()-start)]);
#endif
DRM_OS_RETURN(ret);
return DRM_ERR(ret);
}
int DRM(unlock)( DRM_OS_IOCTL )
int DRM(unlock)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_lock_t lock;
DRM_OS_KRNFROMUSR( lock, (drm_lock_t *)data, sizeof(lock) ) ;
DRM_COPY_FROM_USER_IOCTL( lock, (drm_lock_t *)data, sizeof(lock) ) ;
if ( lock.context == DRM_KERNEL_CONTEXT ) {
DRM_ERROR( "Process %d using kernel context %d\n",
DRM_OS_CURRENTPID, lock.context );
DRM_OS_RETURN(EINVAL);
DRM_CURRENTPID, lock.context );
return DRM_ERR(EINVAL);
}
atomic_inc( &dev->counts[_DRM_STAT_UNLOCKS] );
@ -1236,7 +1236,7 @@ SYSUNINIT(DRM( unregister), SI_SUB_KLD, SI_ORDER_MIDDLE, linux_ioctl_unregister_
* Linux emulation IOCTL
*/
static int
DRM(linux_ioctl)(DRM_OS_STRUCTPROC *p, struct linux_ioctl_args* args)
DRM(linux_ioctl)(DRM_STRUCTPROC *p, struct linux_ioctl_args* args)
{
#if (__FreeBSD_version >= 500000)
struct file *fp = p->td_proc->p_fd->fd_ofiles[args->fd];

22
bsd-core/drm_fops.c
View file

@ -32,7 +32,7 @@
#include "drmP.h"
drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev, DRM_OS_STRUCTPROC *p)
drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev, DRM_STRUCTPROC *p)
{
#if __FreeBSD_version >= 500021
uid_t uid = p->td_proc->p_ucred->cr_svuid;
@ -51,7 +51,7 @@ drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev, DRM_OS_STRUCTPROC *p)
/* DRM(open) is called whenever a process opens /dev/drm. */
int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p,
int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_STRUCTPROC *p,
drm_device_t *dev)
{
int m = minor(kdev);
@ -61,9 +61,9 @@ int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p,
return EBUSY; /* No exclusive opens */
dev->flags = flags;
if (!DRM(cpu_valid)())
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
DRM_DEBUG("pid = %d, minor = %d\n", DRM_OS_CURRENTPID, m);
DRM_DEBUG("pid = %d, minor = %d\n", DRM_CURRENTPID, m);
/* FIXME: linux mallocs and bzeros here */
priv = (drm_file_t *) DRM(find_file_by_proc)(dev, p);
@ -84,10 +84,10 @@ int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p,
priv->minor = m;
priv->devXX = dev;
priv->ioctl_count = 0;
priv->authenticated = !DRM_OS_SUSER(p);
DRM_OS_LOCK;
priv->authenticated = !DRM_SUSER(p);
DRM_LOCK;
TAILQ_INSERT_TAIL(&dev->files, priv, link);
DRM_OS_UNLOCK;
DRM_UNLOCK;
}
#ifdef __FreeBSD__
kdev->si_drv1 = dev;
@ -102,7 +102,7 @@ int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p,
ssize_t DRM(read)(dev_t kdev, struct uio *uio, int ioflag)
{
DRM_OS_DEVICE;
DRM_DEVICE;
int left;
int avail;
int send;
@ -207,9 +207,9 @@ int DRM(write_string)(drm_device_t *dev, const char *s)
return 0;
}
int DRM(poll)(dev_t kdev, int events, DRM_OS_STRUCTPROC *p)
int DRM(poll)(dev_t kdev, int events, DRM_STRUCTPROC *p)
{
DRM_OS_DEVICE;
DRM_DEVICE;
int s;
int revents = 0;
@ -229,7 +229,7 @@ int DRM(poll)(dev_t kdev, int events, DRM_OS_STRUCTPROC *p)
int DRM(write)(dev_t kdev, struct uio *uio, int ioflag)
{
#if DRM_DEBUG_CODE
DRM_OS_DEVICE;
DRM_DEVICE;
#endif
#ifdef __FreeBSD__
DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",

76
bsd-core/drm_ioctl.c
View file

@ -31,7 +31,7 @@
#include "drmP.h"
int DRM(irq_busid)( DRM_OS_IOCTL )
int DRM(irq_busid)( DRM_IOCTL_ARGS )
{
#ifdef __FreeBSD__
drm_irq_busid_t id;
@ -40,7 +40,7 @@ int DRM(irq_busid)( DRM_OS_IOCTL )
device_t *kids;
int error, i, num_kids;
DRM_OS_KRNFROMUSR( id, (drm_irq_busid_t *)data, sizeof(id) );
DRM_COPY_FROM_USER_IOCTL( id, (drm_irq_busid_t *)data, sizeof(id) );
pci = devclass_find("pci");
if (!pci)
@ -69,7 +69,7 @@ int DRM(irq_busid)( DRM_OS_IOCTL )
DRM_DEBUG("%d:%d:%d => IRQ %d\n",
id.busnum, id.devnum, id.funcnum, id.irq);
DRM_OS_KRNTOUSR( (drm_irq_busid_t *)data, id, sizeof(id) );
DRM_COPY_TO_USER_IOCTL( (drm_irq_busid_t *)data, id, sizeof(id) );
return 0;
#else
@ -78,44 +78,44 @@ int DRM(irq_busid)( DRM_OS_IOCTL )
#endif
}
int DRM(getunique)( DRM_OS_IOCTL )
int DRM(getunique)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_unique_t u;
DRM_OS_KRNFROMUSR( u, (drm_unique_t *)data, sizeof(u) );
DRM_COPY_FROM_USER_IOCTL( u, (drm_unique_t *)data, sizeof(u) );
if (u.unique_len >= dev->unique_len) {
if (DRM_OS_COPYTOUSR(u.unique, dev->unique, dev->unique_len))
DRM_OS_RETURN(EFAULT);
if (DRM_COPY_TO_USER(u.unique, dev->unique, dev->unique_len))
return DRM_ERR(EFAULT);
}
u.unique_len = dev->unique_len;
DRM_OS_KRNTOUSR( (drm_unique_t *)data, u, sizeof(u) );
DRM_COPY_TO_USER_IOCTL( (drm_unique_t *)data, u, sizeof(u) );
return 0;
}
int DRM(setunique)( DRM_OS_IOCTL )
int DRM(setunique)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_unique_t u;
if (dev->unique_len || dev->unique)
DRM_OS_RETURN(EBUSY);
return DRM_ERR(EBUSY);
DRM_OS_KRNFROMUSR( u, (drm_unique_t *)data, sizeof(u) );
DRM_COPY_FROM_USER_IOCTL( u, (drm_unique_t *)data, sizeof(u) );
if (!u.unique_len || u.unique_len > 1024)
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
dev->unique_len = u.unique_len;
dev->unique = DRM(alloc)(u.unique_len + 1, DRM_MEM_DRIVER);
if(!dev->unique) DRM_OS_RETURN(ENOMEM);
if(!dev->unique) return DRM_ERR(ENOMEM);
if (DRM_OS_COPYFROMUSR(dev->unique, u.unique, dev->unique_len))
DRM_OS_RETURN(EFAULT);
if (DRM_COPY_FROM_USER(dev->unique, u.unique, dev->unique_len))
return DRM_ERR(EFAULT);
dev->unique[dev->unique_len] = '\0';
@ -123,7 +123,7 @@ int DRM(setunique)( DRM_OS_IOCTL )
DRM_MEM_DRIVER);
if(!dev->devname) {
DRM(free)(dev->devname, sizeof(*dev->devname), DRM_MEM_DRIVER);
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
sprintf(dev->devname, "%s@%s", dev->name, dev->unique);
@ -132,23 +132,23 @@ int DRM(setunique)( DRM_OS_IOCTL )
}
int DRM(getmap)( DRM_OS_IOCTL )
int DRM(getmap)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_map_t map;
drm_map_t *mapinlist;
drm_map_list_entry_t *list;
int idx;
int i = 0;
DRM_OS_KRNFROMUSR( map, (drm_map_t *)data, sizeof(map) );
DRM_COPY_FROM_USER_IOCTL( map, (drm_map_t *)data, sizeof(map) );
idx = map.offset;
DRM_OS_LOCK;
DRM_LOCK;
if (idx < 0 || idx >= dev->map_count) {
DRM_OS_UNLOCK;
DRM_OS_RETURN(EINVAL);
DRM_UNLOCK;
return DRM_ERR(EINVAL);
}
TAILQ_FOREACH(list, dev->maplist, link) {
@ -165,28 +165,28 @@ int DRM(getmap)( DRM_OS_IOCTL )
i++;
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
if (!list)
return EINVAL;
DRM_OS_KRNTOUSR( (drm_map_t *)data, map, sizeof(map) );
DRM_COPY_TO_USER_IOCTL( (drm_map_t *)data, map, sizeof(map) );
return 0;
}
int DRM(getclient)( DRM_OS_IOCTL )
int DRM(getclient)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_client_t client;
drm_file_t *pt;
int idx;
int i = 0;
DRM_OS_KRNFROMUSR( client, (drm_client_t *)data, sizeof(client) );
DRM_COPY_FROM_USER_IOCTL( client, (drm_client_t *)data, sizeof(client) );
idx = client.idx;
DRM_OS_LOCK;
DRM_LOCK;
TAILQ_FOREACH(pt, &dev->files, link) {
if (i==idx)
{
@ -195,29 +195,29 @@ int DRM(getclient)( DRM_OS_IOCTL )
client.uid = pt->uid;
client.magic = pt->magic;
client.iocs = pt->ioctl_count;
DRM_OS_UNLOCK;
DRM_UNLOCK;
*(drm_client_t *)data = client;
return 0;
}
i++;
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM_OS_KRNTOUSR( (drm_client_t *)data, client, sizeof(client) );
DRM_COPY_TO_USER_IOCTL( (drm_client_t *)data, client, sizeof(client) );
return 0;
}
int DRM(getstats)( DRM_OS_IOCTL )
int DRM(getstats)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_stats_t stats;
int i;
memset(&stats, 0, sizeof(stats));
DRM_OS_LOCK;
DRM_LOCK;
for (i = 0; i < dev->counters; i++) {
if (dev->types[i] == _DRM_STAT_LOCK)
@ -231,9 +231,9 @@ int DRM(getstats)( DRM_OS_IOCTL )
stats.count = dev->counters;
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM_OS_KRNTOUSR( (drm_stats_t *)data, stats, sizeof(stats) );
DRM_COPY_TO_USER_IOCTL( (drm_stats_t *)data, stats, sizeof(stats) );
return 0;
}

14
bsd-core/drm_lock.c
View file

@ -31,13 +31,13 @@
#include "drmP.h"
int DRM(block)( DRM_OS_IOCTL )
int DRM(block)( DRM_IOCTL_ARGS )
{
DRM_DEBUG("\n");
return 0;
}
int DRM(unblock)( DRM_OS_IOCTL )
int DRM(unblock)( DRM_IOCTL_ARGS )
{
DRM_DEBUG("\n");
return 0;
@ -108,7 +108,7 @@ int DRM(lock_free)(drm_device_t *dev,
pid);
return 1;
}
DRM_OS_WAKEUP_INT((void *)&dev->lock.lock_queue);
DRM_WAKEUP_INT((void *)&dev->lock.lock_queue);
return 0;
}
@ -146,7 +146,7 @@ static int DRM(flush_unblock_queue)(drm_device_t *dev, int context)
if (atomic_read(&q->use_count) > 1) {
if (atomic_read(&q->block_write)) {
atomic_dec(&q->block_write);
DRM_OS_WAKEUP_INT((void *)&q->write_queue);
DRM_WAKEUP_INT((void *)&q->write_queue);
}
}
atomic_dec(&q->use_count);
@ -193,15 +193,15 @@ int DRM(flush_unblock)(drm_device_t *dev, int context, drm_lock_flags_t flags)
return ret;
}
int DRM(finish)( DRM_OS_IOCTL )
int DRM(finish)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
int ret = 0;
drm_lock_t lock;
DRM_DEBUG("\n");
DRM_OS_KRNFROMUSR( lock, (drm_lock_t *)data, sizeof(lock) );
DRM_COPY_FROM_USER_IOCTL( lock, (drm_lock_t *)data, sizeof(lock) );
ret = DRM(flush_block_and_flush)(dev, lock.context, lock.flags);
DRM(flush_unblock)(dev, lock.context, lock.flags);

84
bsd-core/drm_memory.c
View file

@ -49,7 +49,7 @@ typedef struct drm_mem_stats {
unsigned long bytes_freed;
} drm_mem_stats_t;
static DRM_OS_SPINTYPE DRM(mem_lock);
static DRM_SPINTYPE DRM(mem_lock);
static unsigned long DRM(ram_available) = 0; /* In pages */
static unsigned long DRM(ram_used) = 0;
static drm_mem_stats_t DRM(mem_stats)[] = {
@ -81,7 +81,7 @@ void DRM(mem_init)(void)
{
drm_mem_stats_t *mem;
DRM_OS_SPININIT(DRM(mem_lock), "drm memory");
DRM_SPININIT(DRM(mem_lock), "drm memory");
for (mem = DRM(mem_stats); mem->name; ++mem) {
mem->succeed_count = 0;
@ -133,9 +133,9 @@ int DRM(mem_info) DRM_SYSCTL_HANDLER_ARGS
{
int ret;
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
ret = DRM(_mem_info)(oidp, arg1, arg2, req);
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return ret;
}
#endif
@ -154,15 +154,15 @@ void *DRM(alloc)(size_t size, int area)
#elif defined(__NetBSD__)
if (!(pt = malloc(size, M_DEVBUF, M_NOWAIT))) {
#endif
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[area].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return NULL;
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[area].succeed_count;
DRM(mem_stats)[area].bytes_allocated += size;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return pt;
}
@ -210,11 +210,11 @@ void DRM(free)(void *pt, size_t size, int area)
#elif defined(__NetBSD__)
free(pt, M_DEVBUF);
#endif
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
DRM(mem_stats)[area].bytes_freed += size;
free_count = ++DRM(mem_stats)[area].free_count;
alloc_count = DRM(mem_stats)[area].succeed_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
if (free_count > alloc_count) {
DRM_MEM_ERROR(area, "Excess frees: %d frees, %d allocs\n",
free_count, alloc_count);
@ -232,15 +232,15 @@ void *DRM(ioremap)(unsigned long offset, unsigned long size)
}
if (!(pt = pmap_mapdev(offset, size))) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_MAPPINGS].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return NULL;
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_MAPPINGS].succeed_count;
DRM(mem_stats)[DRM_MEM_MAPPINGS].bytes_allocated += size;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return pt;
}
@ -258,15 +258,15 @@ void *DRM(ioremap_nocache)(unsigned long offset, unsigned long size)
/* FIXME FOR BSD */
if (!(pt = ioremap_nocache(offset, size))) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_MAPPINGS].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return NULL;
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_MAPPINGS].succeed_count;
DRM(mem_stats)[DRM_MEM_MAPPINGS].bytes_allocated += size;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return pt;
}
#endif
@ -282,11 +282,11 @@ void DRM(ioremapfree)(void *pt, unsigned long size)
else
pmap_unmapdev((vm_offset_t) pt, size);
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
DRM(mem_stats)[DRM_MEM_MAPPINGS].bytes_freed += size;
free_count = ++DRM(mem_stats)[DRM_MEM_MAPPINGS].free_count;
alloc_count = DRM(mem_stats)[DRM_MEM_MAPPINGS].succeed_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
if (free_count > alloc_count) {
DRM_MEM_ERROR(DRM_MEM_MAPPINGS,
"Excess frees: %d frees, %d allocs\n",
@ -305,16 +305,16 @@ agp_memory *DRM(alloc_agp)(int pages, u32 type)
}
if ((handle = DRM(agp_allocate_memory)(pages, type))) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_TOTALAGP].succeed_count;
DRM(mem_stats)[DRM_MEM_TOTALAGP].bytes_allocated
+= pages << PAGE_SHIFT;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return handle;
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_TOTALAGP].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return NULL;
}
@ -326,16 +326,16 @@ int DRM(free_agp)(agp_memory *handle, int pages)
if (!handle) {
DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
"Attempt to free NULL AGP handle\n");
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (DRM(agp_free_memory)(handle)) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
free_count = ++DRM(mem_stats)[DRM_MEM_TOTALAGP].free_count;
alloc_count = DRM(mem_stats)[DRM_MEM_TOTALAGP].succeed_count;
DRM(mem_stats)[DRM_MEM_TOTALAGP].bytes_freed
+= pages << PAGE_SHIFT;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
if (free_count > alloc_count) {
DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
"Excess frees: %d frees, %d allocs\n",
@ -343,13 +343,13 @@ int DRM(free_agp)(agp_memory *handle, int pages)
}
return 0;
}
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
int DRM(bind_agp)(agp_memory *handle, unsigned int start)
{
int retcode;
device_t dev = DRM_OS_AGP_FIND_DEVICE();
device_t dev = DRM_AGP_FIND_DEVICE();
struct agp_memory_info info;
if (!dev)
@ -358,22 +358,22 @@ int DRM(bind_agp)(agp_memory *handle, unsigned int start)
if (!handle) {
DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
"Attempt to bind NULL AGP handle\n");
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (!(retcode = DRM(agp_bind_memory)(handle, start))) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_BOUNDAGP].succeed_count;
agp_memory_info(dev, handle, &info);
DRM(mem_stats)[DRM_MEM_BOUNDAGP].bytes_allocated
+= info.ami_size;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_OS_RETURN(0);
DRM_SPINUNLOCK(&DRM(mem_lock));
return DRM_ERR(0);
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_BOUNDAGP].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_OS_RETURN(retcode);
DRM_SPINUNLOCK(&DRM(mem_lock));
return DRM_ERR(retcode);
}
int DRM(unbind_agp)(agp_memory *handle)
@ -381,7 +381,7 @@ int DRM(unbind_agp)(agp_memory *handle)
int alloc_count;
int free_count;
int retcode = EINVAL;
device_t dev = DRM_OS_AGP_FIND_DEVICE();
device_t dev = DRM_AGP_FIND_DEVICE();
struct agp_memory_info info;
if (!dev)
@ -390,25 +390,25 @@ int DRM(unbind_agp)(agp_memory *handle)
if (!handle) {
DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
"Attempt to unbind NULL AGP handle\n");
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
agp_memory_info(dev, handle, &info);
if ((retcode = DRM(agp_unbind_memory)(handle)))
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
free_count = ++DRM(mem_stats)[DRM_MEM_BOUNDAGP].free_count;
alloc_count = DRM(mem_stats)[DRM_MEM_BOUNDAGP].succeed_count;
DRM(mem_stats)[DRM_MEM_BOUNDAGP].bytes_freed
+= info.ami_size;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
if (free_count > alloc_count) {
DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
"Excess frees: %d frees, %d allocs\n",
free_count, alloc_count);
}
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
#endif

94
bsd-core/drm_os_freebsd.h
View file

@ -74,47 +74,48 @@
#define CDEV_MAJOR 145
#if __FreeBSD_version >= 500000
#define DRM_OS_SPINTYPE struct mtx
#define DRM_OS_SPININIT(l,name) mtx_init(&l, name, NULL, MTX_DEF)
#define DRM_OS_SPINLOCK(l) mtx_lock(l)
#define DRM_OS_SPINUNLOCK(u) mtx_unlock(u);
#define DRM_OS_CURPROC curthread
#define DRM_OS_STRUCTPROC struct thread
#define DRM_OS_CURRENTPID curthread->td_proc->p_pid
#define DRM_CURPROC curthread
#define DRM_STRUCTPROC struct thread
#define DRM_SPINTYPE struct mtx
#define DRM_SPININIT(l,name) mtx_init(&l, name, NULL, MTX_DEF)
#define DRM_SPINLOCK(l) mtx_lock(l)
#define DRM_SPINUNLOCK(u) mtx_unlock(u);
#define DRM_CURRENTPID curthread->td_proc->p_pid
#else
#define DRM_OS_CURPROC curproc
#define DRM_OS_STRUCTPROC struct proc
#define DRM_OS_SPINTYPE struct simplelock
#define DRM_OS_SPININIT(l,name) simple_lock_init(&l)
#define DRM_OS_SPINLOCK(l) simple_lock(l)
#define DRM_OS_SPINUNLOCK(u) simple_unlock(u);
#define DRM_OS_CURRENTPID curproc->p_pid
#define DRM_CURPROC curproc
#define DRM_STRUCTPROC struct proc
#define DRM_SPINTYPE struct simplelock
#define DRM_SPININIT(l,name) simple_lock_init(&l)
#define DRM_SPINLOCK(l) simple_lock(l)
#define DRM_SPINUNLOCK(u) simple_unlock(u);
#define DRM_CURRENTPID curproc->p_pid
#endif
#define DRM_OS_IOCTL dev_t kdev, u_long cmd, caddr_t data, int flags, DRM_OS_STRUCTPROC *p
#define DRM_OS_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, DRM_OS_CURPROC)
#define DRM_OS_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, 0, DRM_OS_CURPROC)
#define DRM_OS_SUSER(p) suser(p)
#define DRM_OS_TASKQUEUE_ARGS void *dev, int pending
#define DRM_OS_IRQ_ARGS void *device
#define DRM_OS_DEVICE drm_device_t *dev = kdev->si_drv1
#define DRM_OS_MALLOC(size) malloc( size, DRM(M_DRM), M_NOWAIT )
#define DRM_OS_FREE(pt) free( pt, DRM(M_DRM) )
#define DRM_OS_VTOPHYS(addr) vtophys(addr)
#define DRM_OS_READ8(addr) *((volatile char *)(addr))
#define DRM_OS_READ32(addr) *((volatile long *)(addr))
#define DRM_OS_WRITE8(addr, val) *((volatile char *)(addr)) = (val)
#define DRM_OS_WRITE32(addr, val) *((volatile long *)(addr)) = (val)
#define DRM_OS_AGP_FIND_DEVICE() agp_find_device()
#define DRM_IOCTL_ARGS dev_t kdev, u_long cmd, caddr_t data, int flags, DRM_STRUCTPROC *p
#define DRM_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, DRM_CURPROC)
#define DRM_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, 0, DRM_CURPROC)
#define DRM_SUSER(p) suser(p)
#define DRM_TASKQUEUE_ARGS void *dev, int pending
#define DRM_IRQ_ARGS void *device
#define DRM_DEVICE drm_device_t *dev = kdev->si_drv1
#define DRM_MALLOC(size) malloc( size, DRM(M_DRM), M_NOWAIT )
#define DRM_FREE(pt) free( pt, DRM(M_DRM) )
#define DRM_VTOPHYS(addr) vtophys(addr)
#define DRM_READ8(addr) *((volatile char *)(addr))
#define DRM_READ32(addr) *((volatile long *)(addr))
#define DRM_WRITE8(addr, val) *((volatile char *)(addr)) = (val)
#define DRM_WRITE32(addr, val) *((volatile long *)(addr)) = (val)
#define DRM_AGP_FIND_DEVICE() agp_find_device()
#define DRM_ERR(v) v
#define DRM_OS_PRIV \
#define DRM_PRIV \
drm_file_t *priv = (drm_file_t *) DRM(find_file_by_proc)(dev, p); \
if (!priv) { \
DRM_DEBUG("can't find authenticator\n"); \
return EINVAL; \
}
#define DRM_OS_DELAY( udelay ) \
#define DRM_UDELAY( udelay ) \
do { \
struct timeval tv1, tv2; \
microtime(&tv1); \
@ -124,7 +125,7 @@ do { \
while (((tv2.tv_sec-tv1.tv_sec)*1000000 + tv2.tv_usec - tv1.tv_usec) < udelay ); \
} while (0)
#define DRM_OS_GETSAREA() \
#define DRM_GETSAREA() \
do { \
drm_map_list_entry_t *listentry; \
TAILQ_FOREACH(listentry, dev->maplist, link) { \
@ -137,41 +138,38 @@ do { \
} \
} while (0)
#define DRM_OS_RETURN(v) return v;
#define DRM_OS_ERR(v) v
#define DRM_OS_KRNTOUSR(arg1, arg2, arg3) \
#define DRM_COPY_TO_USER_IOCTL(arg1, arg2, arg3) \
*arg1 = arg2
#define DRM_OS_KRNFROMUSR(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER_IOCTL(arg1, arg2, arg3) \
arg1 = *arg2
#define DRM_OS_COPYTOUSR(arg1, arg2, arg3) \
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
copyout(arg2, arg1, arg3)
#define DRM_OS_COPYFROMUSR(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER(arg1, arg2, arg3) \
copyin(arg2, arg1, arg3)
/* Macros for userspace access with checking readability once */
/* FIXME: can't find equivalent functionality for nocheck yet.
* It's be slower than linux, but should be correct.
*/
#define DRM_OS_VERIFYAREA_READ( uaddr, size ) \
#define DRM_VERIFYAREA_READ( uaddr, size ) \
(!useracc((caddr_t)uaddr, size, VM_PROT_READ))
#define DRM_OS_COPYFROMUSR_NC(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
copyin(arg2, arg1, arg3)
#define DRM_OS_FETCHU_32_NC(val, uaddr) \
#define DRM_GET_USER_UNCHECKED(val, uaddr) \
((val) = fuword(uaddr), 0)
/* From machine/bus_at386.h on i386 */
#define DRM_OS_READMEMORYBARRIER() \
#define DRM_READMEMORYBARRIER() \
do { \
__asm __volatile("lock; addl $0,0(%%esp)" : : : "memory"); \
} while (0)
#define DRM_OS_WRITEMEMORYBARRIER() \
#define DRM_WRITEMEMORYBARRIER() \
do { \
__asm __volatile("" : : : "memory"); \
} while (0)
#define DRM_OS_WAKEUP(w) wakeup(w)
#define DRM_OS_WAKEUP_INT(w) wakeup(w)
#define DRM_WAKEUP(w) wakeup(w)
#define DRM_WAKEUP_INT(w) wakeup(w)
#define PAGE_ALIGN(addr) round_page(addr)
@ -347,9 +345,9 @@ extern d_write_t DRM(write);
extern d_poll_t DRM(poll);
extern d_mmap_t DRM(mmap);
extern int DRM(open_helper)(dev_t kdev, int flags, int fmt,
DRM_OS_STRUCTPROC *p, drm_device_t *dev);
DRM_STRUCTPROC *p, drm_device_t *dev);
extern drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev,
DRM_OS_STRUCTPROC *p);
DRM_STRUCTPROC *p);
/* Misc. IOCTL support (drm_ioctl.h) */
extern d_ioctl_t DRM(irq_busid);

74
bsd-core/drm_os_netbsd.h
View file

@ -59,38 +59,38 @@ extern struct cfdriver DRM(_cd);
#define DRM_DEV_GID 0
#define CDEV_MAJOR 90
#define DRM_OS_CURPROC curproc
#define DRM_OS_STRUCTPROC struct proc
#define DRM_OS_SPINTYPE struct simplelock
#define DRM_OS_SPININIT(l,name) simple_lock_init(&l)
#define DRM_OS_SPINLOCK(l) simple_lock(l)
#define DRM_OS_SPINUNLOCK(u) simple_unlock(u);
#define DRM_OS_CURRENTPID curproc->p_pid
#define DRM_CURPROC curproc
#define DRM_STRUCTPROC struct proc
#define DRM_SPINTYPE struct simplelock
#define DRM_SPININIT(l,name) simple_lock_init(&l)
#define DRM_SPINLOCK(l) simple_lock(l)
#define DRM_SPINUNLOCK(u) simple_unlock(u);
#define DRM_CURRENTPID curproc->p_pid
#define DRM_OS_IOCTL dev_t kdev, u_long cmd, caddr_t data, int flags, DRM_OS_STRUCTPROC *p
#define DRM_OS_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, NULL)
#define DRM_OS_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, NULL)
#define DRM_OS_SUSER(p) suser(p->p_ucred, &p->p_acflag)
#define DRM_OS_TASKQUEUE_ARGS void *dev, int pending
#define DRM_OS_IRQ_ARGS void *device
#define DRM_OS_DEVICE drm_device_t *dev = device_lookup(&DRM(_cd), minor(kdev))
#define DRM_OS_MALLOC(size) malloc( size, DRM(M_DRM), M_NOWAIT )
#define DRM_OS_FREE(pt) free( pt, DRM(M_DRM) )
#define DRM_OS_VTOPHYS(addr) vtophys(addr)
#define DRM_OS_READ8(addr) *((volatile char *)(addr))
#define DRM_OS_READ32(addr) *((volatile long *)(addr))
#define DRM_OS_WRITE8(addr, val) *((volatile char *)(addr)) = (val)
#define DRM_OS_WRITE32(addr, val) *((volatile long *)(addr)) = (val)
#define DRM_OS_AGP_FIND_DEVICE()
#define DRM_IOCTL_ARGS dev_t kdev, u_long cmd, caddr_t data, int flags, DRM_STRUCTPROC *p
#define DRM_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, NULL)
#define DRM_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, NULL)
#define DRM_SUSER(p) suser(p->p_ucred, &p->p_acflag)
#define DRM_TASKQUEUE_ARGS void *dev, int pending
#define DRM_IRQ_ARGS void *device
#define DRM_DEVICE drm_device_t *dev = device_lookup(&DRM(_cd), minor(kdev))
#define DRM_MALLOC(size) malloc( size, DRM(M_DRM), M_NOWAIT )
#define DRM_FREE(pt) free( pt, DRM(M_DRM) )
#define DRM_VTOPHYS(addr) vtophys(addr)
#define DRM_READ8(addr) *((volatile char *)(addr))
#define DRM_READ32(addr) *((volatile long *)(addr))
#define DRM_WRITE8(addr, val) *((volatile char *)(addr)) = (val)
#define DRM_WRITE32(addr, val) *((volatile long *)(addr)) = (val)
#define DRM_AGP_FIND_DEVICE()
#define DRM_OS_PRIV \
#define DRM_PRIV \
drm_file_t *priv = (drm_file_t *) DRM(find_file_by_proc)(dev, p); \
if (!priv) { \
DRM_DEBUG("can't find authenticator\n"); \
return EINVAL; \
}
#define DRM_OS_DELAY( udelay ) \
#define DRM_UDELAY( udelay ) \
do { \
struct timeval tv1, tv2; \
microtime(&tv1); \
@ -100,7 +100,7 @@ do { \
while (((tv2.tv_sec-tv1.tv_sec)*1000000 + tv2.tv_usec - tv1.tv_usec) < udelay ); \
} while (0)
#define DRM_OS_GETSAREA() \
#define DRM_GETSAREA() \
do { \
drm_map_list_entry_t *listentry; \
TAILQ_FOREACH(listentry, dev->maplist, link) { \
@ -113,19 +113,19 @@ do { \
} \
} while (0)
#define DRM_OS_RETURN(v) return v;
#define DRM_OS_ERR(v) v
#define return DRM_ERR(v) return v;
#define DRM_ERR(v) v
#define DRM_OS_KRNTOUSR(arg1, arg2, arg3) \
#define DRM_COPY_TO_USER_IOCTL(arg1, arg2, arg3) \
*arg1 = arg2
#define DRM_OS_KRNFROMUSR(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER_IOCTL(arg1, arg2, arg3) \
arg1 = *arg2
#define DRM_OS_COPYTOUSR(arg1, arg2, arg3) \
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
copyout(arg2, arg1, arg3)
#define DRM_OS_COPYFROMUSR(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER(arg1, arg2, arg3) \
copyin(arg2, arg1, arg3)
#define DRM_OS_READMEMORYBARRIER \
#define DRM_READMEMORYBARRIER \
{ \
int xchangeDummy; \
DRM_DEBUG("%s\n", __FUNCTION__); \
@ -135,10 +135,10 @@ do { \
" pop %%eax" : /* no outputs */ : /* no inputs */ ); \
} while (0);
#define DRM_OS_WRITEMEMORYBARRIER DRM_OS_READMEMORYBARRIER
#define DRM_WRITEMEMORYBARRIER DRM_READMEMORYBARRIER
#define DRM_OS_WAKEUP(w) wakeup(w)
#define DRM_OS_WAKEUP_INT(w) wakeup(w)
#define DRM_WAKEUP(w) wakeup(w)
#define DRM_WAKEUP_INT(w) wakeup(w)
#define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK)
@ -300,9 +300,9 @@ extern dev_type_write(DRM(write));
extern dev_type_poll(DRM(poll));
extern dev_type_mmap(DRM(mmap));
extern int DRM(open_helper)(dev_t kdev, int flags, int fmt,
DRM_OS_STRUCTPROC *p, drm_device_t *dev);
DRM_STRUCTPROC *p, drm_device_t *dev);
extern drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev,
DRM_OS_STRUCTPROC *p);
DRM_STRUCTPROC *p);
/* Misc. IOCTL support (drm_ioctl.h) */
extern dev_type_ioctl(DRM(irq_busid));

22
bsd-core/drm_scatter.c
View file

@ -48,9 +48,9 @@ void DRM(sg_cleanup)( drm_sg_mem_t *entry )
DRM_MEM_SGLISTS );
}
int DRM(sg_alloc)( DRM_OS_IOCTL )
int DRM(sg_alloc)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
unsigned long pages;
@ -60,7 +60,7 @@ int DRM(sg_alloc)( DRM_OS_IOCTL )
if ( dev->sg )
return EINVAL;
DRM_OS_KRNFROMUSR(request, (drm_scatter_gather_t *)data,
DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
sizeof(request) );
entry = DRM(alloc)( sizeof(*entry), DRM_MEM_SGLISTS );
@ -118,7 +118,7 @@ int DRM(sg_alloc)( DRM_OS_IOCTL )
request.handle = entry->handle;
DRM_OS_KRNTOUSR( (drm_scatter_gather_t *)data,
DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
request,
sizeof(request) );
@ -170,13 +170,13 @@ int DRM(sg_alloc)( DRM_OS_IOCTL )
return ENOMEM;
}
int DRM(sg_free)( DRM_OS_IOCTL )
int DRM(sg_free)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
DRM_OS_KRNFROMUSR( request, (drm_scatter_gather_t *)data,
DRM_COPY_FROM_USER_IOCTL( request, (drm_scatter_gather_t *)data,
sizeof(request) );
entry = dev->sg;
@ -194,13 +194,13 @@ int DRM(sg_free)( DRM_OS_IOCTL )
#else /* __REALLY_HAVE_SG */
int DRM(sg_alloc)( DRM_OS_IOCTL )
int DRM(sg_alloc)( DRM_IOCTL_ARGS )
{
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
int DRM(sg_free)( DRM_OS_IOCTL )
int DRM(sg_free)( DRM_IOCTL_ARGS )
{
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
#endif

24
bsd-core/drm_sysctl.c
View file

@ -168,9 +168,9 @@ static int DRM(vm_info)DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = DRM(_vm_info)(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
@ -219,9 +219,9 @@ static int DRM(queues_info) DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = DRM(_queues_info)(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
@ -269,9 +269,9 @@ static int DRM(bufs_info) DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = DRM(_bufs_info)(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
@ -303,9 +303,9 @@ static int DRM(clients_info)DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = DRM(_clients_info)(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
@ -388,9 +388,9 @@ static int DRM(vma_info)DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = DRM(_vma_info)(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
#endif
@ -517,9 +517,9 @@ static int DRM(histo_info)DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = _drm_histo_info(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
#endif

10
bsd-core/drm_vm.c
View file

@ -5,7 +5,7 @@ static int DRM(dma_mmap)(dev_t kdev, vm_offset_t offset, int prot)
static paddr_t DRM(dma_mmap)(dev_t kdev, vm_offset_t offset, int prot)
#endif
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
unsigned long physical;
unsigned long page;
@ -26,20 +26,20 @@ int DRM(mmap)(dev_t kdev, vm_offset_t offset, int prot)
paddr_t DRM(mmap)(dev_t kdev, off_t offset, int prot)
#endif
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_map_t *map = NULL;
drm_map_list_entry_t *listentry=NULL;
drm_file_t *priv;
/* DRM_DEBUG("offset = 0x%x\n", offset);*/
priv = DRM(find_file_by_proc)(dev, DRM_OS_CURPROC);
priv = DRM(find_file_by_proc)(dev, DRM_CURPROC);
if (!priv) {
DRM_DEBUG("can't find authenticator\n");
return EINVAL;
}
if (!priv->authenticated) DRM_OS_RETURN(EACCES);
if (!priv->authenticated) return DRM_ERR(EACCES);
if (dev->dma
&& offset >= 0
@ -64,7 +64,7 @@ paddr_t DRM(mmap)(dev_t kdev, off_t offset, int prot)
DRM_DEBUG("can't find map\n");
return -1;
}
if (((map->flags&_DRM_RESTRICTED) && DRM_OS_SUSER(DRM_OS_CURPROC))) {
if (((map->flags&_DRM_RESTRICTED) && DRM_SUSER(DRM_CURPROC))) {
DRM_DEBUG("restricted map\n");
return -1;
}

2
bsd/ati_pcigart.h
View file

@ -122,7 +122,7 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
ret = 1;
DRM_OS_READMEMORYBARRIER();
DRM_READMEMORYBARRIER();
done:
*addr = address;

14
bsd/drmP.h
View file

@ -243,8 +243,8 @@ typedef struct drm_waitlist {
drm_buf_t **rp; /* Read pointer */
drm_buf_t **wp; /* Write pointer */
drm_buf_t **end; /* End pointer */
DRM_OS_SPINTYPE read_lock;
DRM_OS_SPINTYPE write_lock;
DRM_SPINTYPE read_lock;
DRM_SPINTYPE write_lock;
} drm_waitlist_t;
typedef struct drm_freelist {
@ -256,7 +256,7 @@ typedef struct drm_freelist {
int low_mark; /* Low water mark */
int high_mark; /* High water mark */
atomic_t wfh; /* If waiting for high mark */
DRM_OS_SPINTYPE lock;
DRM_SPINTYPE lock;
} drm_freelist_t;
typedef struct drm_buf_entry {
@ -410,7 +410,7 @@ struct drm_device {
int writable; /* Opened with FWRITE */
/* Locks */
DRM_OS_SPINTYPE count_lock; /* For inuse, open_count, buf_use */
DRM_SPINTYPE count_lock; /* For inuse, open_count, buf_use */
struct lock dev_lock; /* For others */
/* Usage Counters */
int open_count; /* Outstanding files open */
@ -510,7 +510,7 @@ extern int DRM(add_magic)(drm_device_t *dev, drm_file_t *priv,
extern int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic);
/* Driver support (drm_drv.h) */
extern int DRM(version)( DRM_OS_IOCTL );
extern int DRM(version)( DRM_IOCTL_ARGS );
extern int DRM(write_string)(drm_device_t *dev, const char *s);
/* Memory management support (drm_memory.h) */
@ -578,9 +578,9 @@ extern int DRM(dma_get_buffers)(drm_device_t *dev, drm_dma_t *dma);
#if __HAVE_DMA_IRQ
extern int DRM(irq_install)( drm_device_t *dev, int irq );
extern int DRM(irq_uninstall)( drm_device_t *dev );
extern void DRM(dma_service)( DRM_OS_IRQ_ARGS );
extern void DRM(dma_service)( DRM_IRQ_ARGS );
#if __HAVE_DMA_IRQ_BH
extern void DRM(dma_immediate_bh)( DRM_OS_TASKQUEUE_ARGS );
extern void DRM(dma_immediate_bh)( DRM_TASKQUEUE_ARGS );
#endif
#endif
#if DRM_DMA_HISTOGRAM

44
bsd/drm_agpsupport.h
View file

@ -31,9 +31,9 @@
#include "drmP.h"
int DRM(agp_info)(DRM_OS_IOCTL)
int DRM(agp_info)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
struct agp_info *kern;
drm_agp_info_t info;
@ -55,9 +55,9 @@ int DRM(agp_info)(DRM_OS_IOCTL)
return 0;
}
int DRM(agp_acquire)(DRM_OS_IOCTL)
int DRM(agp_acquire)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
int retcode;
if (!dev->agp || dev->agp->acquired) return EINVAL;
@ -67,9 +67,9 @@ int DRM(agp_acquire)(DRM_OS_IOCTL)
return 0;
}
int DRM(agp_release)(DRM_OS_IOCTL)
int DRM(agp_release)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
if (!dev->agp || !dev->agp->acquired)
return EINVAL;
@ -83,14 +83,14 @@ void DRM(agp_do_release)(void)
{
device_t agpdev;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (agpdev)
agp_release(agpdev);
}
int DRM(agp_enable)(DRM_OS_IOCTL)
int DRM(agp_enable)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_agp_mode_t mode;
if (!dev->agp || !dev->agp->acquired) return EINVAL;
@ -104,9 +104,9 @@ int DRM(agp_enable)(DRM_OS_IOCTL)
return 0;
}
int DRM(agp_alloc)(DRM_OS_IOCTL)
int DRM(agp_alloc)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_agp_buffer_t request;
drm_agp_mem_t *entry;
void *handle;
@ -159,9 +159,9 @@ static drm_agp_mem_t * DRM(agp_lookup_entry)(drm_device_t *dev, void *handle)
return NULL;
}
int DRM(agp_unbind)(DRM_OS_IOCTL)
int DRM(agp_unbind)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_agp_binding_t request;
drm_agp_mem_t *entry;
int retcode;
@ -181,9 +181,9 @@ int DRM(agp_unbind)(DRM_OS_IOCTL)
return retcode;
}
int DRM(agp_bind)(DRM_OS_IOCTL)
int DRM(agp_bind)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_agp_binding_t request;
drm_agp_mem_t *entry;
int retcode;
@ -203,9 +203,9 @@ int DRM(agp_bind)(DRM_OS_IOCTL)
return 0;
}
int DRM(agp_free)(DRM_OS_IOCTL)
int DRM(agp_free)(DRM_IOCTL_ARGS)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_agp_buffer_t request;
drm_agp_mem_t *entry;
@ -229,7 +229,7 @@ drm_agp_head_t *DRM(agp_init)(void)
drm_agp_head_t *head = NULL;
int agp_available = 1;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev)
agp_available = 0;
@ -278,7 +278,7 @@ agp_memory *DRM(agp_allocate_memory)(size_t pages, u32 type)
{
device_t agpdev;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev)
return NULL;
@ -289,7 +289,7 @@ int DRM(agp_free_memory)(agp_memory *handle)
{
device_t agpdev;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return 0;
@ -301,7 +301,7 @@ int DRM(agp_bind_memory)(agp_memory *handle, off_t start)
{
device_t agpdev;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return EINVAL;
@ -312,7 +312,7 @@ int DRM(agp_unbind_memory)(agp_memory *handle)
{
device_t agpdev;
agpdev = DRM_OS_AGP_FIND_DEVICE();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return EINVAL;

42
bsd/drm_auth.h
View file

@ -42,14 +42,14 @@ static drm_file_t *DRM(find_file)(drm_device_t *dev, drm_magic_t magic)
drm_magic_entry_t *pt;
int hash = DRM(hash_magic)(magic);
DRM_OS_LOCK;
DRM_LOCK;
for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
if (pt->magic == magic) {
retval = pt->priv;
break;
}
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return retval;
}
@ -62,13 +62,13 @@ int DRM(add_magic)(drm_device_t *dev, drm_file_t *priv, drm_magic_t magic)
hash = DRM(hash_magic)(magic);
entry = (drm_magic_entry_t*) DRM(alloc)(sizeof(*entry), DRM_MEM_MAGIC);
if (!entry) DRM_OS_RETURN(ENOMEM);
if (!entry) return DRM_ERR(ENOMEM);
memset(entry, 0, sizeof(*entry));
entry->magic = magic;
entry->priv = priv;
entry->next = NULL;
DRM_OS_LOCK;
DRM_LOCK;
if (dev->magiclist[hash].tail) {
dev->magiclist[hash].tail->next = entry;
dev->magiclist[hash].tail = entry;
@ -76,7 +76,7 @@ int DRM(add_magic)(drm_device_t *dev, drm_file_t *priv, drm_magic_t magic)
dev->magiclist[hash].head = entry;
dev->magiclist[hash].tail = entry;
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
@ -90,7 +90,7 @@ int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic)
DRM_DEBUG("%d\n", magic);
hash = DRM(hash_magic)(magic);
DRM_OS_LOCK;
DRM_LOCK;
for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
if (pt->magic == magic) {
if (dev->magiclist[hash].head == pt) {
@ -102,27 +102,27 @@ int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic)
if (prev) {
prev->next = pt->next;
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM(free)(pt, sizeof(*pt), DRM_MEM_MAGIC);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
int DRM(getmagic)(DRM_OS_IOCTL)
int DRM(getmagic)(DRM_IOCTL_ARGS)
{
static drm_magic_t sequence = 0;
drm_auth_t auth;
static DRM_OS_SPINTYPE lock;
static DRM_SPINTYPE lock;
static int first = 1;
DRM_OS_DEVICE;
DRM_OS_PRIV;
DRM_DEVICE;
DRM_PRIV;
if (first) {
DRM_OS_SPININIT(lock, "drm getmagic");
DRM_SPININIT(lock, "drm getmagic");
first = 0;
}
@ -131,10 +131,10 @@ int DRM(getmagic)(DRM_OS_IOCTL)
auth.magic = priv->magic;
} else {
do {
DRM_OS_SPINLOCK(&lock);
DRM_SPINLOCK(&lock);
if (!sequence) ++sequence; /* reserve 0 */
auth.magic = sequence++;
DRM_OS_SPINUNLOCK(&lock);
DRM_SPINUNLOCK(&lock);
} while (DRM(find_file)(dev, auth.magic));
priv->magic = auth.magic;
DRM(add_magic)(dev, priv, auth.magic);
@ -142,18 +142,18 @@ int DRM(getmagic)(DRM_OS_IOCTL)
DRM_DEBUG("%u\n", auth.magic);
DRM_OS_KRNTOUSR((drm_auth_t *)data, auth, sizeof(auth));
DRM_COPY_TO_USER_IOCTL((drm_auth_t *)data, auth, sizeof(auth));
return 0;
}
int DRM(authmagic)(DRM_OS_IOCTL)
int DRM(authmagic)(DRM_IOCTL_ARGS)
{
drm_auth_t auth;
drm_file_t *file;
DRM_OS_DEVICE;
DRM_DEVICE;
DRM_OS_KRNFROMUSR(auth, (drm_auth_t *)data, sizeof(auth));
DRM_COPY_FROM_USER_IOCTL(auth, (drm_auth_t *)data, sizeof(auth));
DRM_DEBUG("%u\n", auth.magic);
if ((file = DRM(find_file)(dev, auth.magic))) {
@ -161,5 +161,5 @@ int DRM(authmagic)(DRM_OS_IOCTL)
DRM(remove_magic)(dev, auth.magic);
return 0;
}
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}

274
bsd/drm_bufs.h
View file

@ -66,18 +66,18 @@ int DRM(order)( unsigned long size )
return order;
}
int DRM(addmap)( DRM_OS_IOCTL )
int DRM(addmap)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_map_t *map;
drm_map_list_entry_t *list;
if (!(dev->flags & (FREAD|FWRITE)))
DRM_OS_RETURN(EACCES); /* Require read/write */
return DRM_ERR(EACCES); /* Require read/write */
map = (drm_map_t *) DRM(alloc)( sizeof(*map), DRM_MEM_MAPS );
if ( !map )
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
*map = *(drm_map_t *)data;
@ -87,13 +87,13 @@ int DRM(addmap)( DRM_OS_IOCTL )
*/
if ( (map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM ) {
DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_DEBUG( "offset = 0x%08lx, size = 0x%08lx, type = %d\n",
map->offset, map->size, map->type );
if ( (map->offset & PAGE_MASK) || (map->size & PAGE_MASK) ) {
DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
map->mtrr = -1;
map->handle = 0;
@ -105,7 +105,7 @@ int DRM(addmap)( DRM_OS_IOCTL )
if ( map->offset + map->size < map->offset
) {
DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
#endif
#ifdef __alpha__
@ -148,7 +148,7 @@ int DRM(addmap)( DRM_OS_IOCTL )
map->size, DRM(order)( map->size ), map->handle );
if ( !map->handle ) {
DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
map->offset = (unsigned long)map->handle;
if ( map->flags & _DRM_CONTAINS_LOCK ) {
@ -167,27 +167,27 @@ int DRM(addmap)( DRM_OS_IOCTL )
case _DRM_SCATTER_GATHER:
if (!dev->sg) {
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
map->offset = map->offset + dev->sg->handle;
break;
default:
DRM(free)( map, sizeof(*map), DRM_MEM_MAPS );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
list = DRM(alloc)(sizeof(*list), DRM_MEM_MAPS);
if(!list) {
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
memset(list, 0, sizeof(*list));
list->map = map;
DRM_OS_LOCK;
DRM_LOCK;
TAILQ_INSERT_TAIL(dev->maplist, list, link);
DRM_OS_UNLOCK;
DRM_UNLOCK;
*(drm_map_t *)data = *map;
@ -202,17 +202,17 @@ int DRM(addmap)( DRM_OS_IOCTL )
* isn't in use.
*/
int DRM(rmmap)( DRM_OS_IOCTL )
int DRM(rmmap)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_map_list_entry_t *list;
drm_map_t *map;
drm_map_t request;
int found_maps = 0;
DRM_OS_KRNFROMUSR( request, (drm_map_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_map_t *)data, sizeof(request) );
DRM_OS_LOCK;
DRM_LOCK;
TAILQ_FOREACH(list, dev->maplist, link) {
map = list->map;
if(map->handle == request.handle &&
@ -223,8 +223,8 @@ int DRM(rmmap)( DRM_OS_IOCTL )
* find anything.
*/
if(list == NULL) {
DRM_OS_UNLOCK;
DRM_OS_RETURN(EINVAL);
DRM_UNLOCK;
return DRM_ERR(EINVAL);
}
TAILQ_REMOVE(dev->maplist, list, link);
DRM(free)(list, sizeof(*list), DRM_MEM_MAPS);
@ -270,7 +270,7 @@ int DRM(rmmap)( DRM_OS_IOCTL )
}
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
@ -317,9 +317,9 @@ static void DRM(cleanup_buf_error)(drm_buf_entry_t *entry)
}
#if __REALLY_HAVE_AGP
int DRM(addbufs_agp)( DRM_OS_IOCTL )
int DRM(addbufs_agp)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_desc_t request;
drm_buf_entry_t *entry;
@ -336,9 +336,9 @@ int DRM(addbufs_agp)( DRM_OS_IOCTL )
int i;
drm_buf_t **temp_buflist;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_KRNFROMUSR( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
count = request.count;
order = DRM(order)( request.size );
@ -361,38 +361,38 @@ int DRM(addbufs_agp)( DRM_OS_IOCTL )
DRM_DEBUG( "total: %d\n", total );
if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
if ( dev->queue_count )
DRM_OS_RETURN(EBUSY); /* Not while in use */
return DRM_ERR(EBUSY); /* Not while in use */
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( dev->buf_use ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
atomic_inc( &dev->buf_alloc );
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_LOCK;
DRM_LOCK;
entry = &dma->bufs[order];
if ( entry->buf_count ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM); /* May only call once for each order */
return DRM_ERR(ENOMEM); /* May only call once for each order */
}
if (count < 0 || count > 4096) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
DRM_MEM_BUFS );
if ( !entry->buflist ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
@ -449,9 +449,9 @@ int DRM(addbufs_agp)( DRM_OS_IOCTL )
if(!temp_buflist) {
/* Free the entry because it isn't valid */
DRM(cleanup_buf_error)(entry);
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
dma->buflist = temp_buflist;
@ -471,12 +471,12 @@ int DRM(addbufs_agp)( DRM_OS_IOCTL )
DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
}
#endif
DRM_OS_UNLOCK;
DRM_UNLOCK;
request.count = entry->buf_count;
request.size = size;
DRM_OS_KRNTOUSR( (drm_buf_desc_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_buf_desc_t *)data, request, sizeof(request) );
dma->flags = _DRM_DMA_USE_AGP;
@ -486,9 +486,9 @@ int DRM(addbufs_agp)( DRM_OS_IOCTL )
#endif /* __REALLY_HAVE_AGP */
#if __HAVE_PCI_DMA
int DRM(addbufs_pci)( DRM_OS_IOCTL )
int DRM(addbufs_pci)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_desc_t request;
int count;
@ -507,9 +507,9 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
unsigned long *temp_pagelist;
drm_buf_t **temp_buflist;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_KRNFROMUSR( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
count = request.count;
order = DRM(order)( request.size );
@ -520,43 +520,43 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
order, dev->queue_count );
if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
if ( dev->queue_count )
DRM_OS_RETURN(EBUSY); /* Not while in use */
return DRM_ERR(EBUSY); /* Not while in use */
alignment = (request.flags & _DRM_PAGE_ALIGN)
? round_page(size) : size;
page_order = order - PAGE_SHIFT > 0 ? order - PAGE_SHIFT : 0;
total = PAGE_SIZE << page_order;
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( dev->buf_use ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
atomic_inc( &dev->buf_alloc );
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_LOCK;
DRM_LOCK;
entry = &dma->bufs[order];
if ( entry->buf_count ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM); /* May only call once for each order */
return DRM_ERR(ENOMEM); /* May only call once for each order */
}
if (count < 0 || count > 4096) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
DRM_MEM_BUFS );
if ( !entry->buflist ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
@ -566,9 +566,9 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
DRM(free)( entry->buflist,
count * sizeof(*entry->buflist),
DRM_MEM_BUFS );
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( entry->seglist, 0, count * sizeof(*entry->seglist) );
@ -584,9 +584,9 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
DRM(free)( entry->seglist,
count * sizeof(*entry->seglist),
DRM_MEM_SEGS );
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
dma->pagelist = temp_pagelist;
@ -644,9 +644,9 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
if(!temp_buflist) {
/* Free the entry because it isn't valid */
DRM(cleanup_buf_error)(entry);
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
dma->buflist = temp_buflist;
@ -665,12 +665,12 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
}
#endif
DRM_OS_UNLOCK;
DRM_UNLOCK;
request.count = entry->buf_count;
request.size = size;
DRM_OS_KRNTOUSR( (drm_buf_desc_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_buf_desc_t *)data, request, sizeof(request) );
atomic_dec( &dev->buf_alloc );
return 0;
@ -679,9 +679,9 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
#endif /* __HAVE_PCI_DMA */
#if __REALLY_HAVE_SG
int DRM(addbufs_sg)( DRM_OS_IOCTL )
int DRM(addbufs_sg)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_desc_t request;
drm_buf_entry_t *entry;
@ -698,9 +698,9 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
int i;
drm_buf_t **temp_buflist;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_KRNFROMUSR( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
count = request.count;
order = DRM(order)( request.size );
@ -723,37 +723,37 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
DRM_DEBUG( "total: %d\n", total );
if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER )
DRM_OS_RETURN(EINVAL);
if ( dev->queue_count ) DRM_OS_RETURN(EBUSY); /* Not while in use */
return DRM_ERR(EINVAL);
if ( dev->queue_count ) return DRM_ERR(EBUSY); /* Not while in use */
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( dev->buf_use ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
atomic_inc( &dev->buf_alloc );
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_LOCK;
DRM_LOCK;
entry = &dma->bufs[order];
if ( entry->buf_count ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM); /* May only call once for each order */
return DRM_ERR(ENOMEM); /* May only call once for each order */
}
if (count < 0 || count > 4096) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
entry->buflist = DRM(alloc)( count * sizeof(*entry->buflist),
DRM_MEM_BUFS );
if ( !entry->buflist ) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
@ -785,9 +785,9 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
/* Set count correctly so we free the proper amount. */
entry->buf_count = count;
DRM(cleanup_buf_error)(entry);
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( buf->dev_private, 0, buf->dev_priv_size );
@ -816,9 +816,9 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
if(!temp_buflist) {
/* Free the entry because it isn't valid */
DRM(cleanup_buf_error)(entry);
DRM_OS_UNLOCK;
DRM_UNLOCK;
atomic_dec( &dev->buf_alloc );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
dma->buflist = temp_buflist;
@ -838,12 +838,12 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
DRM(freelist_put)( dev, &entry->freelist, &entry->buflist[i] );
}
#endif
DRM_OS_UNLOCK;
DRM_UNLOCK;
request.count = entry->buf_count;
request.size = size;
DRM_OS_KRNTOUSR( (drm_buf_desc_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_buf_desc_t *)data, request, sizeof(request) );
dma->flags = _DRM_DMA_USE_SG;
@ -852,11 +852,11 @@ int DRM(addbufs_sg)( DRM_OS_IOCTL )
}
#endif /* __REALLY_HAVE_SG */
int DRM(addbufs)( DRM_OS_IOCTL )
int DRM(addbufs)( DRM_IOCTL_ARGS )
{
drm_buf_desc_t request;
DRM_OS_KRNFROMUSR( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
#if __REALLY_HAVE_AGP
if ( request.flags & _DRM_AGP_BUFFER )
@ -871,29 +871,29 @@ int DRM(addbufs)( DRM_OS_IOCTL )
#if __HAVE_PCI_DMA
return DRM(addbufs_pci)( kdev, cmd, data, flags, p );
#else
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
#endif
}
int DRM(infobufs)( DRM_OS_IOCTL )
int DRM(infobufs)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_info_t request;
int i;
int count;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( atomic_read( &dev->buf_alloc ) ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
++dev->buf_use; /* Can't allocate more after this call */
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_KRNFROMUSR( request, (drm_buf_info_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_info_t *)data, sizeof(request) );
for ( i = 0, count = 0 ; i < DRM_MAX_ORDER + 1 ; i++ ) {
if ( dma->bufs[i].buf_count ) ++count;
@ -907,19 +907,19 @@ int DRM(infobufs)( DRM_OS_IOCTL )
drm_buf_desc_t *to = &request.list[count];
drm_buf_entry_t *from = &dma->bufs[i];
drm_freelist_t *list = &dma->bufs[i].freelist;
if ( DRM_OS_COPYTOUSR( &to->count,
if ( DRM_COPY_TO_USER( &to->count,
&from->buf_count,
sizeof(from->buf_count) ) ||
DRM_OS_COPYTOUSR( &to->size,
DRM_COPY_TO_USER( &to->size,
&from->buf_size,
sizeof(from->buf_size) ) ||
DRM_OS_COPYTOUSR( &to->low_mark,
DRM_COPY_TO_USER( &to->low_mark,
&list->low_mark,
sizeof(list->low_mark) ) ||
DRM_OS_COPYTOUSR( &to->high_mark,
DRM_COPY_TO_USER( &to->high_mark,
&list->high_mark,
sizeof(list->high_mark) ) )
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
DRM_DEBUG( "%d %d %d %d %d\n",
i,
@ -933,34 +933,34 @@ int DRM(infobufs)( DRM_OS_IOCTL )
}
request.count = count;
DRM_OS_KRNTOUSR( (drm_buf_info_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_buf_info_t *)data, request, sizeof(request) );
return 0;
}
int DRM(markbufs)( DRM_OS_IOCTL )
int DRM(markbufs)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_desc_t request;
int order;
drm_buf_entry_t *entry;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_KRNFROMUSR( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
DRM_DEBUG( "%d, %d, %d\n",
request.size, request.low_mark, request.high_mark );
order = DRM(order)( request.size );
if ( order < DRM_MIN_ORDER || order > DRM_MAX_ORDER )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
entry = &dma->bufs[order];
if ( request.low_mark < 0 || request.low_mark > entry->buf_count )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
if ( request.high_mark < 0 || request.high_mark > entry->buf_count )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
entry->freelist.low_mark = request.low_mark;
entry->freelist.high_mark = request.high_mark;
@ -968,35 +968,35 @@ int DRM(markbufs)( DRM_OS_IOCTL )
return 0;
}
int DRM(freebufs)( DRM_OS_IOCTL )
int DRM(freebufs)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_buf_free_t request;
int i;
int idx;
drm_buf_t *buf;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_KRNFROMUSR( request, (drm_buf_free_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_free_t *)data, sizeof(request) );
DRM_DEBUG( "%d\n", request.count );
for ( i = 0 ; i < request.count ; i++ ) {
if ( DRM_OS_COPYFROMUSR( &idx,
if ( DRM_COPY_FROM_USER( &idx,
&request.list[i],
sizeof(idx) ) )
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
if ( idx < 0 || idx >= dma->buf_count ) {
DRM_ERROR( "Index %d (of %d max)\n",
idx, dma->buf_count - 1 );
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
buf = dma->buflist[idx];
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "Process %d freeing buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
DRM_OS_RETURN(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
DRM(free_buffer)( dev, buf );
}
@ -1004,9 +1004,9 @@ int DRM(freebufs)( DRM_OS_IOCTL )
return 0;
}
int DRM(mapbufs)( DRM_OS_IOCTL )
int DRM(mapbufs)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
int retcode = 0;
const int zero = 0;
@ -1025,17 +1025,17 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
drm_buf_map_t request;
int i;
if ( !dma ) DRM_OS_RETURN(EINVAL);
if ( !dma ) return DRM_ERR(EINVAL);
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( atomic_read( &dev->buf_alloc ) ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
dev->buf_use++; /* Can't allocate more after this call */
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_KRNFROMUSR( request, (drm_buf_map_t *)data, sizeof(request) );
DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_map_t *)data, sizeof(request) );
#ifdef __NetBSD__
if(!vfinddev(kdev, VCHR, &vn))
@ -1097,26 +1097,26 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
request.virtual = (void *)virtual;
for ( i = 0 ; i < dma->buf_count ; i++ ) {
if ( DRM_OS_COPYTOUSR( &request.list[i].idx,
if ( DRM_COPY_TO_USER( &request.list[i].idx,
&dma->buflist[i]->idx,
sizeof(request.list[0].idx) ) ) {
retcode = EFAULT;
goto done;
}
if ( DRM_OS_COPYTOUSR( &request.list[i].total,
if ( DRM_COPY_TO_USER( &request.list[i].total,
&dma->buflist[i]->total,
sizeof(request.list[0].total) ) ) {
retcode = EFAULT;
goto done;
}
if ( DRM_OS_COPYTOUSR( &request.list[i].used,
if ( DRM_COPY_TO_USER( &request.list[i].used,
&zero,
sizeof(zero) ) ) {
retcode = EFAULT;
goto done;
}
address = virtual + dma->buflist[i]->offset; /* *** */
if ( DRM_OS_COPYTOUSR( &request.list[i].address,
if ( DRM_COPY_TO_USER( &request.list[i].address,
&address,
sizeof(address) ) ) {
retcode = EFAULT;
@ -1129,9 +1129,9 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
DRM_DEBUG( "%d buffers, retcode = %d\n", request.count, retcode );
DRM_OS_KRNTOUSR( (drm_buf_map_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_buf_map_t *)data, request, sizeof(request) );
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
#endif /* __HAVE_DMA */

188
bsd/drm_context.h
View file

@ -43,10 +43,10 @@ void DRM(ctxbitmap_free)( drm_device_t *dev, int ctx_handle )
if ( !dev->ctx_bitmap ) goto failed;
if ( ctx_handle < DRM_MAX_CTXBITMAP ) {
DRM_OS_LOCK;
DRM_LOCK;
clear_bit( ctx_handle, dev->ctx_bitmap );
dev->context_sareas[ctx_handle] = NULL;
DRM_OS_UNLOCK;
DRM_UNLOCK;
return;
}
failed:
@ -61,7 +61,7 @@ int DRM(ctxbitmap_next)( drm_device_t *dev )
if(!dev->ctx_bitmap) return -1;
DRM_OS_LOCK;
DRM_LOCK;
bit = find_first_zero_bit( dev->ctx_bitmap, DRM_MAX_CTXBITMAP );
if ( bit < DRM_MAX_CTXBITMAP ) {
set_bit( bit, dev->ctx_bitmap );
@ -79,7 +79,7 @@ int DRM(ctxbitmap_next)( drm_device_t *dev )
DRM_MEM_MAPS);
if(!ctx_sareas) {
clear_bit(bit, dev->ctx_bitmap);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return -1;
}
dev->context_sareas = ctx_sareas;
@ -92,16 +92,16 @@ int DRM(ctxbitmap_next)( drm_device_t *dev )
DRM_MEM_MAPS);
if(!dev->context_sareas) {
clear_bit(bit, dev->ctx_bitmap);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return -1;
}
dev->context_sareas[bit] = NULL;
}
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return bit;
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return -1;
}
@ -110,17 +110,17 @@ int DRM(ctxbitmap_init)( drm_device_t *dev )
int i;
int temp;
DRM_OS_LOCK;
DRM_LOCK;
dev->ctx_bitmap = (atomic_t *) DRM(alloc)( PAGE_SIZE,
DRM_MEM_CTXBITMAP );
if ( dev->ctx_bitmap == NULL ) {
DRM_OS_UNLOCK;
DRM_OS_RETURN(ENOMEM);
DRM_UNLOCK;
return DRM_ERR(ENOMEM);
}
memset( (void *)dev->ctx_bitmap, 0, PAGE_SIZE );
dev->context_sareas = NULL;
dev->max_context = -1;
DRM_OS_UNLOCK;
DRM_UNLOCK;
for ( i = 0 ; i < DRM_RESERVED_CONTEXTS ; i++ ) {
temp = DRM(ctxbitmap_next)( dev );
@ -132,55 +132,55 @@ int DRM(ctxbitmap_init)( drm_device_t *dev )
void DRM(ctxbitmap_cleanup)( drm_device_t *dev )
{
DRM_OS_LOCK;
DRM_LOCK;
if( dev->context_sareas ) DRM(free)( dev->context_sareas,
sizeof(*dev->context_sareas) *
dev->max_context,
DRM_MEM_MAPS );
DRM(free)( (void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP );
DRM_OS_UNLOCK;
DRM_UNLOCK;
}
/* ================================================================
* Per Context SAREA Support
*/
int DRM(getsareactx)( DRM_OS_IOCTL )
int DRM(getsareactx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_priv_map_t request;
drm_map_t *map;
DRM_OS_KRNFROMUSR( request, (drm_ctx_priv_map_t *)data,
DRM_COPY_FROM_USER_IOCTL( request, (drm_ctx_priv_map_t *)data,
sizeof(request) );
DRM_OS_LOCK;
DRM_LOCK;
if (dev->max_context < 0 || request.ctx_id >= (unsigned) dev->max_context) {
DRM_OS_UNLOCK;
DRM_OS_RETURN(EINVAL);
DRM_UNLOCK;
return DRM_ERR(EINVAL);
}
map = dev->context_sareas[request.ctx_id];
DRM_OS_UNLOCK;
DRM_UNLOCK;
request.handle = map->handle;
DRM_OS_KRNTOUSR( (drm_ctx_priv_map_t *)data, request, sizeof(request) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_priv_map_t *)data, request, sizeof(request) );
return 0;
}
int DRM(setsareactx)( DRM_OS_IOCTL )
int DRM(setsareactx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_priv_map_t request;
drm_map_t *map = NULL;
drm_map_list_entry_t *list;
DRM_OS_KRNFROMUSR( request, (drm_ctx_priv_map_t *)data,
DRM_COPY_FROM_USER_IOCTL( request, (drm_ctx_priv_map_t *)data,
sizeof(request) );
DRM_OS_LOCK;
DRM_LOCK;
TAILQ_FOREACH(list, dev->maplist, link) {
map=list->map;
if(map->handle == request.handle)
@ -188,8 +188,8 @@ int DRM(setsareactx)( DRM_OS_IOCTL )
}
bad:
DRM_OS_UNLOCK;
return DRM_OS_ERR(EINVAL);
DRM_UNLOCK;
return DRM_ERR(EINVAL);
found:
map = list->map;
@ -199,7 +199,7 @@ found:
if (request.ctx_id >= (unsigned) dev->max_context)
goto bad;
dev->context_sareas[request.ctx_id] = map;
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
@ -213,7 +213,7 @@ int DRM(context_switch)( drm_device_t *dev, int old, int new )
if ( test_and_set_bit( 0, &dev->context_flag ) ) {
DRM_ERROR( "Reentering -- FIXME\n" );
DRM_OS_RETURN(EBUSY);
return DRM_ERR(EBUSY);
}
#if __HAVE_DMA_HISTOGRAM
@ -255,41 +255,41 @@ int DRM(context_switch_complete)( drm_device_t *dev, int new )
#endif
clear_bit( 0, &dev->context_flag );
DRM_OS_WAKEUP( (void *)&dev->context_wait );
DRM_WAKEUP( (void *)&dev->context_wait );
return 0;
}
int DRM(resctx)( DRM_OS_IOCTL )
int DRM(resctx)( DRM_IOCTL_ARGS )
{
drm_ctx_res_t res;
drm_ctx_t ctx;
int i;
DRM_OS_KRNFROMUSR( res, (drm_ctx_res_t *)data, sizeof(res) );
DRM_COPY_FROM_USER_IOCTL( res, (drm_ctx_res_t *)data, sizeof(res) );
if ( res.count >= DRM_RESERVED_CONTEXTS ) {
memset( &ctx, 0, sizeof(ctx) );
for ( i = 0 ; i < DRM_RESERVED_CONTEXTS ; i++ ) {
ctx.handle = i;
if ( DRM_OS_COPYTOUSR( &res.contexts[i],
if ( DRM_COPY_TO_USER( &res.contexts[i],
&i, sizeof(i) ) )
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
}
}
res.count = DRM_RESERVED_CONTEXTS;
DRM_OS_KRNTOUSR( (drm_ctx_res_t *)data, res, sizeof(res) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_res_t *)data, res, sizeof(res) );
return 0;
}
int DRM(addctx)( DRM_OS_IOCTL )
int DRM(addctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
ctx.handle = DRM(ctxbitmap_next)( dev );
if ( ctx.handle == DRM_KERNEL_CONTEXT ) {
@ -300,51 +300,51 @@ int DRM(addctx)( DRM_OS_IOCTL )
if ( ctx.handle == -1 ) {
DRM_DEBUG( "Not enough free contexts.\n" );
/* Should this return -EBUSY instead? */
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
DRM_OS_KRNTOUSR( (drm_ctx_t *)data, ctx, sizeof(ctx) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_t *)data, ctx, sizeof(ctx) );
return 0;
}
int DRM(modctx)( DRM_OS_IOCTL )
int DRM(modctx)( DRM_IOCTL_ARGS )
{
/* This does nothing */
return 0;
}
int DRM(getctx)( DRM_OS_IOCTL )
int DRM(getctx)( DRM_IOCTL_ARGS )
{
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
/* This is 0, because we don't handle any context flags */
ctx.flags = 0;
DRM_OS_KRNTOUSR( (drm_ctx_t *)data, ctx, sizeof(ctx) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_t *)data, ctx, sizeof(ctx) );
return 0;
}
int DRM(switchctx)( DRM_OS_IOCTL )
int DRM(switchctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG( "%d\n", ctx.handle );
return DRM(context_switch)( dev, dev->last_context, ctx.handle );
}
int DRM(newctx)( DRM_OS_IOCTL )
int DRM(newctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG( "%d\n", ctx.handle );
DRM(context_switch_complete)( dev, ctx.handle );
@ -352,12 +352,12 @@ int DRM(newctx)( DRM_OS_IOCTL )
return 0;
}
int DRM(rmctx)( DRM_OS_IOCTL )
int DRM(rmctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG( "%d\n", ctx.handle );
if ( ctx.handle != DRM_KERNEL_CONTEXT ) {
@ -386,7 +386,7 @@ int DRM(context_switch)(drm_device_t *dev, int old, int new)
if (test_and_set_bit(0, &dev->context_flag)) {
DRM_ERROR("Reentering -- FIXME\n");
DRM_OS_RETURN(EBUSY);
return DRM_ERR(EBUSY);
}
#if __HAVE_DMA_HISTOGRAM
@ -397,7 +397,7 @@ int DRM(context_switch)(drm_device_t *dev, int old, int new)
if (new >= dev->queue_count) {
clear_bit(0, &dev->context_flag);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (new == dev->last_context) {
@ -410,7 +410,7 @@ int DRM(context_switch)(drm_device_t *dev, int old, int new)
if (atomic_read(&q->use_count) == 1) {
atomic_dec(&q->use_count);
clear_bit(0, &dev->context_flag);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (DRM(flags) & DRM_FLAG_NOCTX) {
@ -449,7 +449,7 @@ int DRM(context_switch_complete)(drm_device_t *dev, int new)
#endif
clear_bit(0, &dev->context_flag);
DRM_OS_WAKEUP_INT(&dev->context_wait);
DRM_WAKEUP_INT(&dev->context_wait);
return 0;
}
@ -513,7 +513,7 @@ static int DRM(alloc_queue)(drm_device_t *dev)
atomic_dec(&dev->queuelist[i]->use_count);
}
/* Allocate a new queue */
DRM_OS_LOCK;
DRM_LOCK;
queue = gamma_alloc(sizeof(*queue), DRM_MEM_QUEUES);
memset(queue, 0, sizeof(*queue));
@ -531,19 +531,19 @@ static int DRM(alloc_queue)(drm_device_t *dev)
newslots,
DRM_MEM_QUEUES);
if (!dev->queuelist) {
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM_DEBUG("out of memory\n");
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
}
dev->queuelist[dev->queue_count-1] = queue;
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM_DEBUG("%d (new)\n", dev->queue_count - 1);
return dev->queue_count - 1;
}
int DRM(resctx)( DRM_OS_IOCTL )
int DRM(resctx)( DRM_IOCTL_ARGS )
{
drm_ctx_res_t res;
drm_ctx_t ctx;
@ -551,31 +551,31 @@ int DRM(resctx)( DRM_OS_IOCTL )
DRM_DEBUG("%d\n", DRM_RESERVED_CONTEXTS);
DRM_OS_KRNFROMUSR( res, (drm_ctx_res_t *)data, sizeof(res) );
DRM_COPY_FROM_USER_IOCTL( res, (drm_ctx_res_t *)data, sizeof(res) );
if (res.count >= DRM_RESERVED_CONTEXTS) {
memset(&ctx, 0, sizeof(ctx));
for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
ctx.handle = i;
if (DRM_OS_COPYTOUSR(&res.contexts[i],
if (DRM_COPY_TO_USER(&res.contexts[i],
&i,
sizeof(i)))
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
}
}
res.count = DRM_RESERVED_CONTEXTS;
DRM_OS_KRNTOUSR( (drm_ctx_res_t *)data, res, sizeof(res) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_res_t *)data, res, sizeof(res) );
return 0;
}
int DRM(addctx)( DRM_OS_IOCTL )
int DRM(addctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
if ((ctx.handle = DRM(alloc_queue)(dev)) == DRM_KERNEL_CONTEXT) {
/* Init kernel's context and get a new one. */
@ -585,35 +585,35 @@ int DRM(addctx)( DRM_OS_IOCTL )
DRM(init_queue)(dev, dev->queuelist[ctx.handle], &ctx);
DRM_DEBUG("%d\n", ctx.handle);
DRM_OS_KRNTOUSR( (drm_ctx_t *)data, ctx, sizeof(ctx) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_t *)data, ctx, sizeof(ctx) );
return 0;
}
int DRM(modctx)( DRM_OS_IOCTL )
int DRM(modctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
drm_queue_t *q;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG("%d\n", ctx.handle);
if (ctx.handle < 0 || ctx.handle >= dev->queue_count)
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
q = dev->queuelist[ctx.handle];
atomic_inc(&q->use_count);
if (atomic_read(&q->use_count) == 1) {
/* No longer in use */
atomic_dec(&q->use_count);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (DRM_BUFCOUNT(&q->waitlist)) {
atomic_dec(&q->use_count);
DRM_OS_RETURN(EBUSY);
return DRM_ERR(EBUSY);
}
q->flags = ctx.flags;
@ -622,52 +622,52 @@ int DRM(modctx)( DRM_OS_IOCTL )
return 0;
}
int DRM(getctx)( DRM_OS_IOCTL )
int DRM(getctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
drm_queue_t *q;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG("%d\n", ctx.handle);
if (ctx.handle >= dev->queue_count)
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
q = dev->queuelist[ctx.handle];
atomic_inc(&q->use_count);
if (atomic_read(&q->use_count) == 1) {
/* No longer in use */
atomic_dec(&q->use_count);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
ctx.flags = q->flags;
atomic_dec(&q->use_count);
DRM_OS_KRNTOUSR( (drm_ctx_t *)data, ctx, sizeof(ctx) );
DRM_COPY_TO_USER_IOCTL( (drm_ctx_t *)data, ctx, sizeof(ctx) );
return 0;
}
int DRM(switchctx)( DRM_OS_IOCTL )
int DRM(switchctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG("%d\n", ctx.handle);
return DRM(context_switch)(dev, dev->last_context, ctx.handle);
}
int DRM(newctx)( DRM_OS_IOCTL )
int DRM(newctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG("%d\n", ctx.handle);
DRM(context_switch_complete)(dev, ctx.handle);
@ -675,25 +675,25 @@ int DRM(newctx)( DRM_OS_IOCTL )
return 0;
}
int DRM(rmctx)( DRM_OS_IOCTL )
int DRM(rmctx)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_ctx_t ctx;
drm_queue_t *q;
drm_buf_t *buf;
DRM_OS_KRNFROMUSR( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_COPY_FROM_USER_IOCTL( ctx, (drm_ctx_t *)data, sizeof(ctx) );
DRM_DEBUG("%d\n", ctx.handle);
if (ctx.handle >= dev->queue_count) DRM_OS_RETURN(EINVAL);
if (ctx.handle >= dev->queue_count) return DRM_ERR(EINVAL);
q = dev->queuelist[ctx.handle];
atomic_inc(&q->use_count);
if (atomic_read(&q->use_count) == 1) {
/* No longer in use */
atomic_dec(&q->use_count);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
atomic_inc(&q->finalization); /* Mark queue in finalization state */
@ -716,7 +716,7 @@ int DRM(rmctx)( DRM_OS_IOCTL )
/* Wakeup blocked processes */
wakeup( &q->block_read );
wakeup( &q->block_write );
DRM_OS_WAKEUP_INT( &q->flush_queue );
DRM_WAKEUP_INT( &q->flush_queue );
/* Finalization over. Queue is made
available when both use_count and
finalization become 0, which won't

66
bsd/drm_dma.h
View file

@ -55,7 +55,7 @@ int DRM(dma_setup)( drm_device_t *dev )
dev->dma = DRM(alloc)( sizeof(*dev->dma), DRM_MEM_DRIVER );
if ( !dev->dma )
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev->dma, 0, sizeof(*dev->dma) );
@ -244,7 +244,7 @@ void DRM(clear_next_buffer)(drm_device_t *dev)
dma->next_buffer = NULL;
if (dma->next_queue && !DRM_BUFCOUNT(&dma->next_queue->waitlist)) {
DRM_OS_WAKEUP_INT(&dma->next_queue->flush_queue);
DRM_WAKEUP_INT(&dma->next_queue->flush_queue);
}
dma->next_queue = NULL;
}
@ -336,7 +336,7 @@ int DRM(dma_enqueue)(drm_device_t *dev, drm_dma_t *d)
if (!_DRM_LOCK_IS_HELD(context)) {
DRM_ERROR("No lock held during \"while locked\""
" request\n");
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (d->context != _DRM_LOCKING_CONTEXT(context)
&& _DRM_LOCKING_CONTEXT(context) != DRM_KERNEL_CONTEXT) {
@ -344,7 +344,7 @@ int DRM(dma_enqueue)(drm_device_t *dev, drm_dma_t *d)
" \"while locked\" request\n",
_DRM_LOCKING_CONTEXT(context),
d->context);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
q = dev->queuelist[DRM_KERNEL_CONTEXT];
while_locked = 1;
@ -374,19 +374,19 @@ int DRM(dma_enqueue)(drm_device_t *dev, drm_dma_t *d)
atomic_dec(&q->use_count);
DRM_ERROR("Index %d (of %d max)\n",
d->send_indices[i], dma->buf_count - 1);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
buf = dma->buflist[ idx ];
if (buf->pid != DRM_OS_CURRENTPID) {
if (buf->pid != DRM_CURRENTPID) {
atomic_dec(&q->use_count);
DRM_ERROR("Process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid);
DRM_OS_RETURN(EINVAL);
DRM_CURRENTPID, buf->pid);
return DRM_ERR(EINVAL);
}
if (buf->list != DRM_LIST_NONE) {
atomic_dec(&q->use_count);
DRM_ERROR("Process %d using buffer %d on list %d\n",
DRM_OS_CURRENTPID, buf->idx, buf->list);
DRM_CURRENTPID, buf->idx, buf->list);
}
buf->used = d->send_sizes[i];
buf->while_locked = while_locked;
@ -399,14 +399,14 @@ int DRM(dma_enqueue)(drm_device_t *dev, drm_dma_t *d)
DRM_ERROR("Queueing pending buffer:"
" buffer %d, offset %d\n",
d->send_indices[i], i);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (buf->waiting) {
atomic_dec(&q->use_count);
DRM_ERROR("Queueing waiting buffer:"
" buffer %d, offset %d\n",
d->send_indices[i], i);
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
buf->waiting = 1;
if (atomic_read(&q->use_count) == 1
@ -440,16 +440,16 @@ static int DRM(dma_get_buffers_of_order)(drm_device_t *dev, drm_dma_t *d,
buf->waiting,
buf->pending);
}
buf->pid = DRM_OS_CURRENTPID;
if (DRM_OS_COPYTOUSR(&d->request_indices[i],
buf->pid = DRM_CURRENTPID;
if (DRM_COPY_TO_USER(&d->request_indices[i],
&buf->idx,
sizeof(buf->idx)))
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
if (DRM_OS_COPYTOUSR(&d->request_sizes[i],
if (DRM_COPY_TO_USER(&d->request_sizes[i],
&buf->total,
sizeof(buf->total)))
DRM_OS_RETURN(EFAULT);
return DRM_ERR(EFAULT);
++d->granted_count;
}
@ -507,15 +507,15 @@ int DRM(irq_install)( drm_device_t *dev, int irq )
int retcode;
if ( !irq )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
DRM_OS_LOCK;
DRM_LOCK;
if ( dev->irq ) {
DRM_OS_UNLOCK;
DRM_OS_RETURN(EBUSY);
DRM_UNLOCK;
return DRM_ERR(EBUSY);
}
dev->irq = irq;
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM_DEBUG( "%s: irq=%d\n", __FUNCTION__, irq );
@ -544,10 +544,10 @@ int DRM(irq_install)( drm_device_t *dev, int irq )
retcode = bus_setup_intr(dev->device, dev->irqr, INTR_TYPE_TTY,
DRM(dma_service), dev, &dev->irqh);
if ( retcode ) {
DRM_OS_LOCK;
DRM_LOCK;
bus_release_resource(dev->device, SYS_RES_IRQ, 0, dev->irqr);
dev->irq = 0;
DRM_OS_UNLOCK;
DRM_UNLOCK;
return retcode;
}
@ -561,13 +561,13 @@ int DRM(irq_uninstall)( drm_device_t *dev )
{
int irq;
DRM_OS_LOCK;
DRM_LOCK;
irq = dev->irq;
dev->irq = 0;
DRM_OS_UNLOCK;
DRM_UNLOCK;
if ( !irq )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
DRM_DEBUG( "%s: irq=%d\n", __FUNCTION__, irq );
@ -579,12 +579,12 @@ int DRM(irq_uninstall)( drm_device_t *dev )
return 0;
}
int DRM(control)( DRM_OS_IOCTL )
int DRM(control)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_control_t ctl;
DRM_OS_KRNFROMUSR( ctl, (drm_control_t *) data, sizeof(ctl) );
DRM_COPY_FROM_USER_IOCTL( ctl, (drm_control_t *) data, sizeof(ctl) );
switch ( ctl.func ) {
case DRM_INST_HANDLER:
@ -592,24 +592,24 @@ int DRM(control)( DRM_OS_IOCTL )
case DRM_UNINST_HANDLER:
return DRM(irq_uninstall)( dev );
default:
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
}
#else
int DRM(control)( DRM_OS_IOCTL )
int DRM(control)( DRM_IOCTL_ARGS )
{
drm_control_t ctl;
DRM_OS_KRNFROMUSR( ctl, (drm_control_t *) data, sizeof(ctl) );
DRM_COPY_FROM_USER_IOCTL( ctl, (drm_control_t *) data, sizeof(ctl) );
switch ( ctl.func ) {
case DRM_INST_HANDLER:
case DRM_UNINST_HANDLER:
return 0;
default:
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
}

6
bsd/drm_drawable.h
View file

@ -31,19 +31,19 @@
#include "drmP.h"
int DRM(adddraw)( DRM_OS_IOCTL )
int DRM(adddraw)( DRM_IOCTL_ARGS )
{
drm_draw_t draw;
draw.handle = 0; /* NOOP */
DRM_DEBUG("%d\n", draw.handle);
DRM_OS_KRNTOUSR( (drm_draw_t *)data, draw, sizeof(draw) );
DRM_COPY_TO_USER_IOCTL( (drm_draw_t *)data, draw, sizeof(draw) );
return 0;
}
int DRM(rmdraw)( DRM_OS_IOCTL )
int DRM(rmdraw)( DRM_IOCTL_ARGS )
{
return 0; /* NOOP */
}

106
bsd/drm_drv.h
View file

@ -426,7 +426,7 @@ static int DRM(setup)( drm_device_t *dev )
dev->maplist = DRM(alloc)(sizeof(*dev->maplist),
DRM_MEM_MAPS);
if(dev->maplist == NULL) DRM_OS_RETURN(ENOMEM);
if(dev->maplist == NULL) return DRM_ERR(ENOMEM);
memset(dev->maplist, 0, sizeof(*dev->maplist));
TAILQ_INIT(dev->maplist);
dev->map_count = 0;
@ -495,7 +495,7 @@ static int DRM(takedown)( drm_device_t *dev )
if ( dev->irq ) DRM(irq_uninstall)( dev );
#endif
DRM_OS_LOCK;
DRM_LOCK;
callout_stop( &dev->timer );
if ( dev->devname ) {
@ -580,7 +580,7 @@ static int DRM(takedown)( drm_device_t *dev )
/*mtrrmap.owner = p->p_pid;*/
/* XXX: Use curproc here? */
retcode = mtrr_set( &mtrrmap, &one,
DRM_OS_CURPROC, MTRR_GETSET_KERNEL);
DRM_CURPROC, MTRR_GETSET_KERNEL);
#endif
DRM_DEBUG( "mtrr_del=%d\n", retcode );
}
@ -643,9 +643,9 @@ static int DRM(takedown)( drm_device_t *dev )
if ( dev->lock.hw_lock ) {
dev->lock.hw_lock = NULL; /* SHM removed */
dev->lock.pid = 0;
DRM_OS_WAKEUP_INT((void *)&dev->lock.lock_queue);
DRM_WAKEUP_INT((void *)&dev->lock.lock_queue);
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
@ -684,7 +684,7 @@ static int DRM(init)( drm_device_t *dev )
#elif defined(__NetBSD__)
unit = minor(dev->device.dv_unit);
#endif
DRM_OS_SPININIT(dev->count_lock, "drm device");
DRM_SPININIT(dev->count_lock, "drm device");
lockinit(&dev->dev_lock, PZERO, "drmlk", 0, 0);
dev->name = DRIVER_NAME;
DRM(mem_init)();
@ -701,7 +701,7 @@ static int DRM(init)( drm_device_t *dev )
destroy_dev(dev->devnode);
#endif
DRM(takedown)( dev );
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
#endif /* __MUST_HAVE_AGP */
#if __REALLY_HAVE_MTRR
@ -813,20 +813,20 @@ static void DRM(cleanup)(drm_device_t *dev)
}
int DRM(version)( DRM_OS_IOCTL )
int DRM(version)( DRM_IOCTL_ARGS )
{
drm_version_t version;
int len;
DRM_OS_KRNFROMUSR( version, (drm_version_t *)data, sizeof(version) );
DRM_COPY_FROM_USER_IOCTL( version, (drm_version_t *)data, sizeof(version) );
#define DRM_COPY( name, value ) \
len = strlen( value ); \
if ( len > name##_len ) len = name##_len; \
name##_len = strlen( value ); \
if ( len && name ) { \
if ( DRM_OS_COPYTOUSR( name, value, len ) ) \
DRM_OS_RETURN(EFAULT); \
if ( DRM_COPY_TO_USER( name, value, len ) ) \
return DRM_ERR(EFAULT); \
}
version.version_major = DRIVER_MAJOR;
@ -837,12 +837,12 @@ int DRM(version)( DRM_OS_IOCTL )
DRM_COPY( version.date, DRIVER_DATE );
DRM_COPY( version.desc, DRIVER_DESC );
DRM_OS_KRNTOUSR( (drm_version_t *)data, version, sizeof(version) );
DRM_COPY_TO_USER_IOCTL( (drm_version_t *)data, version, sizeof(version) );
return 0;
}
int DRM(open)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
int DRM(open)(dev_t kdev, int flags, int fmt, DRM_STRUCTPROC *p)
{
drm_device_t *dev = NULL;
int retcode = 0;
@ -858,13 +858,13 @@ int DRM(open)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
if ( !retcode ) {
atomic_inc( &dev->counts[_DRM_STAT_OPENS] );
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( !dev->open_count++ ) {
retcode = DRM(setup)( dev );
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
return retcode;
}
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
}
#ifdef __FreeBSD__
device_unbusy(dev->device);
@ -873,10 +873,10 @@ int DRM(open)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
return retcode;
}
int DRM(close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
int DRM(close)(dev_t kdev, int flags, int fmt, DRM_STRUCTPROC *p)
{
drm_file_t *priv;
DRM_OS_DEVICE;
DRM_DEVICE;
int retcode = 0;
DRM_DEBUG( "open_count = %d\n", dev->open_count );
@ -894,16 +894,16 @@ int DRM(close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
#ifdef __FreeBSD__
DRM_DEBUG( "pid = %d, device = 0x%lx, open_count = %d\n",
DRM_OS_CURRENTPID, (long)dev->device, dev->open_count );
DRM_CURRENTPID, (long)dev->device, dev->open_count );
#elif defined(__NetBSD__)
DRM_DEBUG( "pid = %d, device = 0x%lx, open_count = %d\n",
DRM_OS_CURRENTPID, (long)&dev->device, dev->open_count);
DRM_CURRENTPID, (long)&dev->device, dev->open_count);
#endif
if (dev->lock.hw_lock && _DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)
&& dev->lock.pid == DRM_OS_CURRENTPID) {
&& dev->lock.pid == DRM_CURRENTPID) {
DRM_DEBUG("Process %d dead, freeing lock for context %d\n",
DRM_OS_CURRENTPID,
DRM_CURRENTPID,
_DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
#if HAVE_DRIVER_RELEASE
DRIVER_RELEASE();
@ -962,7 +962,7 @@ int DRM(close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
dev->buf_pgid = 0;
#endif /* __NetBSD__ */
DRM_OS_LOCK;
DRM_LOCK;
priv = DRM(find_file_by_proc)(dev, p);
if (priv) {
priv->refs--;
@ -970,7 +970,7 @@ int DRM(close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
TAILQ_REMOVE(&dev->files, priv, link);
}
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM(free)( priv, sizeof(*priv), DRM_MEM_FILES );
@ -979,36 +979,36 @@ int DRM(close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
*/
atomic_inc( &dev->counts[_DRM_STAT_CLOSES] );
DRM_OS_SPINLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
if ( !--dev->open_count ) {
if ( atomic_read( &dev->ioctl_count ) || dev->blocked ) {
DRM_ERROR( "Device busy: %ld %d\n",
(unsigned long)atomic_read( &dev->ioctl_count ),
dev->blocked );
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(EBUSY);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM_ERR(EBUSY);
}
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
return DRM(takedown)( dev );
}
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
#ifdef __FreeBSD__
device_unbusy(dev->device);
#endif
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
/* DRM(ioctl) is called whenever a process performs an ioctl on /dev/drm.
*/
int DRM(ioctl)( DRM_OS_IOCTL )
int DRM(ioctl)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
int retcode = 0;
drm_ioctl_desc_t *ioctl;
d_ioctl_t *func;
int nr = DRM_IOCTL_NR(cmd);
DRM_OS_PRIV;
DRM_PRIV;
atomic_inc( &dev->ioctl_count );
atomic_inc( &dev->counts[_DRM_STAT_IOCTLS] );
@ -1016,10 +1016,10 @@ int DRM(ioctl)( DRM_OS_IOCTL )
#ifdef __FreeBSD__
DRM_DEBUG( "pid=%d, cmd=0x%02lx, nr=0x%02x, dev 0x%lx, auth=%d\n",
DRM_OS_CURRENTPID, cmd, nr, (long)dev->device, priv->authenticated );
DRM_CURRENTPID, cmd, nr, (long)dev->device, priv->authenticated );
#elif defined(__NetBSD__)
DRM_DEBUG( "pid=%d, cmd=0x%02lx, nr=0x%02x, dev 0x%lx, auth=%d\n",
DRM_OS_CURRENTPID, cmd, nr, (long)&dev->device, priv->authenticated );
DRM_CURRENTPID, cmd, nr, (long)&dev->device, priv->authenticated );
#endif
switch (cmd) {
@ -1064,7 +1064,7 @@ int DRM(ioctl)( DRM_OS_IOCTL )
if ( !func ) {
DRM_DEBUG( "no function\n" );
retcode = EINVAL;
} else if ( ( ioctl->root_only && DRM_OS_SUSER(p) )
} else if ( ( ioctl->root_only && DRM_SUSER(p) )
|| ( ioctl->auth_needed && !priv->authenticated ) ) {
retcode = EACCES;
} else {
@ -1073,12 +1073,12 @@ int DRM(ioctl)( DRM_OS_IOCTL )
}
atomic_dec( &dev->ioctl_count );
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
int DRM(lock)( DRM_OS_IOCTL )
int DRM(lock)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_lock_t lock;
int ret = 0;
#if __HAVE_MULTIPLE_DMA_QUEUES
@ -1090,24 +1090,24 @@ int DRM(lock)( DRM_OS_IOCTL )
dev->lck_start = start = get_cycles();
#endif
DRM_OS_KRNFROMUSR( lock, (drm_lock_t *)data, sizeof(lock) );
DRM_COPY_FROM_USER_IOCTL( lock, (drm_lock_t *)data, sizeof(lock) );
if ( lock.context == DRM_KERNEL_CONTEXT ) {
DRM_ERROR( "Process %d using kernel context %d\n",
DRM_OS_CURRENTPID, lock.context );
DRM_OS_RETURN(EINVAL);
DRM_CURRENTPID, lock.context );
return DRM_ERR(EINVAL);
}
DRM_DEBUG( "%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
lock.context, DRM_OS_CURRENTPID,
lock.context, DRM_CURRENTPID,
dev->lock.hw_lock->lock, lock.flags );
#if __HAVE_DMA_QUEUE
if ( lock.context < 0 )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
#elif __HAVE_MULTIPLE_DMA_QUEUES
if ( lock.context < 0 || lock.context >= dev->queue_count )
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
q = dev->queuelist[lock.context];
#endif
@ -1123,7 +1123,7 @@ int DRM(lock)( DRM_OS_IOCTL )
}
if ( DRM(lock_take)( &dev->lock.hw_lock->lock,
lock.context ) ) {
dev->lock.pid = DRM_OS_CURRENTPID;
dev->lock.pid = DRM_CURRENTPID;
dev->lock.lock_time = jiffies;
atomic_inc( &dev->counts[_DRM_STAT_LOCKS] );
break; /* Got lock */
@ -1169,21 +1169,21 @@ int DRM(lock)( DRM_OS_IOCTL )
atomic_inc(&dev->histo.lacq[DRM(histogram_slot)(get_cycles()-start)]);
#endif
DRM_OS_RETURN(ret);
return DRM_ERR(ret);
}
int DRM(unlock)( DRM_OS_IOCTL )
int DRM(unlock)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_lock_t lock;
DRM_OS_KRNFROMUSR( lock, (drm_lock_t *)data, sizeof(lock) ) ;
DRM_COPY_FROM_USER_IOCTL( lock, (drm_lock_t *)data, sizeof(lock) ) ;
if ( lock.context == DRM_KERNEL_CONTEXT ) {
DRM_ERROR( "Process %d using kernel context %d\n",
DRM_OS_CURRENTPID, lock.context );
DRM_OS_RETURN(EINVAL);
DRM_CURRENTPID, lock.context );
return DRM_ERR(EINVAL);
}
atomic_inc( &dev->counts[_DRM_STAT_UNLOCKS] );
@ -1236,7 +1236,7 @@ SYSUNINIT(DRM( unregister), SI_SUB_KLD, SI_ORDER_MIDDLE, linux_ioctl_unregister_
* Linux emulation IOCTL
*/
static int
DRM(linux_ioctl)(DRM_OS_STRUCTPROC *p, struct linux_ioctl_args* args)
DRM(linux_ioctl)(DRM_STRUCTPROC *p, struct linux_ioctl_args* args)
{
#if (__FreeBSD_version >= 500000)
struct file *fp = p->td_proc->p_fd->fd_ofiles[args->fd];

22
bsd/drm_fops.h
View file

@ -32,7 +32,7 @@
#include "drmP.h"
drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev, DRM_OS_STRUCTPROC *p)
drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev, DRM_STRUCTPROC *p)
{
#if __FreeBSD_version >= 500021
uid_t uid = p->td_proc->p_ucred->cr_svuid;
@ -51,7 +51,7 @@ drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev, DRM_OS_STRUCTPROC *p)
/* DRM(open) is called whenever a process opens /dev/drm. */
int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p,
int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_STRUCTPROC *p,
drm_device_t *dev)
{
int m = minor(kdev);
@ -61,9 +61,9 @@ int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p,
return EBUSY; /* No exclusive opens */
dev->flags = flags;
if (!DRM(cpu_valid)())
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
DRM_DEBUG("pid = %d, minor = %d\n", DRM_OS_CURRENTPID, m);
DRM_DEBUG("pid = %d, minor = %d\n", DRM_CURRENTPID, m);
/* FIXME: linux mallocs and bzeros here */
priv = (drm_file_t *) DRM(find_file_by_proc)(dev, p);
@ -84,10 +84,10 @@ int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p,
priv->minor = m;
priv->devXX = dev;
priv->ioctl_count = 0;
priv->authenticated = !DRM_OS_SUSER(p);
DRM_OS_LOCK;
priv->authenticated = !DRM_SUSER(p);
DRM_LOCK;
TAILQ_INSERT_TAIL(&dev->files, priv, link);
DRM_OS_UNLOCK;
DRM_UNLOCK;
}
#ifdef __FreeBSD__
kdev->si_drv1 = dev;
@ -102,7 +102,7 @@ int DRM(open_helper)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p,
ssize_t DRM(read)(dev_t kdev, struct uio *uio, int ioflag)
{
DRM_OS_DEVICE;
DRM_DEVICE;
int left;
int avail;
int send;
@ -207,9 +207,9 @@ int DRM(write_string)(drm_device_t *dev, const char *s)
return 0;
}
int DRM(poll)(dev_t kdev, int events, DRM_OS_STRUCTPROC *p)
int DRM(poll)(dev_t kdev, int events, DRM_STRUCTPROC *p)
{
DRM_OS_DEVICE;
DRM_DEVICE;
int s;
int revents = 0;
@ -229,7 +229,7 @@ int DRM(poll)(dev_t kdev, int events, DRM_OS_STRUCTPROC *p)
int DRM(write)(dev_t kdev, struct uio *uio, int ioflag)
{
#if DRM_DEBUG_CODE
DRM_OS_DEVICE;
DRM_DEVICE;
#endif
#ifdef __FreeBSD__
DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",

76
bsd/drm_ioctl.h
View file

@ -31,7 +31,7 @@
#include "drmP.h"
int DRM(irq_busid)( DRM_OS_IOCTL )
int DRM(irq_busid)( DRM_IOCTL_ARGS )
{
#ifdef __FreeBSD__
drm_irq_busid_t id;
@ -40,7 +40,7 @@ int DRM(irq_busid)( DRM_OS_IOCTL )
device_t *kids;
int error, i, num_kids;
DRM_OS_KRNFROMUSR( id, (drm_irq_busid_t *)data, sizeof(id) );
DRM_COPY_FROM_USER_IOCTL( id, (drm_irq_busid_t *)data, sizeof(id) );
pci = devclass_find("pci");
if (!pci)
@ -69,7 +69,7 @@ int DRM(irq_busid)( DRM_OS_IOCTL )
DRM_DEBUG("%d:%d:%d => IRQ %d\n",
id.busnum, id.devnum, id.funcnum, id.irq);
DRM_OS_KRNTOUSR( (drm_irq_busid_t *)data, id, sizeof(id) );
DRM_COPY_TO_USER_IOCTL( (drm_irq_busid_t *)data, id, sizeof(id) );
return 0;
#else
@ -78,44 +78,44 @@ int DRM(irq_busid)( DRM_OS_IOCTL )
#endif
}
int DRM(getunique)( DRM_OS_IOCTL )
int DRM(getunique)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_unique_t u;
DRM_OS_KRNFROMUSR( u, (drm_unique_t *)data, sizeof(u) );
DRM_COPY_FROM_USER_IOCTL( u, (drm_unique_t *)data, sizeof(u) );
if (u.unique_len >= dev->unique_len) {
if (DRM_OS_COPYTOUSR(u.unique, dev->unique, dev->unique_len))
DRM_OS_RETURN(EFAULT);
if (DRM_COPY_TO_USER(u.unique, dev->unique, dev->unique_len))
return DRM_ERR(EFAULT);
}
u.unique_len = dev->unique_len;
DRM_OS_KRNTOUSR( (drm_unique_t *)data, u, sizeof(u) );
DRM_COPY_TO_USER_IOCTL( (drm_unique_t *)data, u, sizeof(u) );
return 0;
}
int DRM(setunique)( DRM_OS_IOCTL )
int DRM(setunique)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_unique_t u;
if (dev->unique_len || dev->unique)
DRM_OS_RETURN(EBUSY);
return DRM_ERR(EBUSY);
DRM_OS_KRNFROMUSR( u, (drm_unique_t *)data, sizeof(u) );
DRM_COPY_FROM_USER_IOCTL( u, (drm_unique_t *)data, sizeof(u) );
if (!u.unique_len || u.unique_len > 1024)
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
dev->unique_len = u.unique_len;
dev->unique = DRM(alloc)(u.unique_len + 1, DRM_MEM_DRIVER);
if(!dev->unique) DRM_OS_RETURN(ENOMEM);
if(!dev->unique) return DRM_ERR(ENOMEM);
if (DRM_OS_COPYFROMUSR(dev->unique, u.unique, dev->unique_len))
DRM_OS_RETURN(EFAULT);
if (DRM_COPY_FROM_USER(dev->unique, u.unique, dev->unique_len))
return DRM_ERR(EFAULT);
dev->unique[dev->unique_len] = '\0';
@ -123,7 +123,7 @@ int DRM(setunique)( DRM_OS_IOCTL )
DRM_MEM_DRIVER);
if(!dev->devname) {
DRM(free)(dev->devname, sizeof(*dev->devname), DRM_MEM_DRIVER);
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
sprintf(dev->devname, "%s@%s", dev->name, dev->unique);
@ -132,23 +132,23 @@ int DRM(setunique)( DRM_OS_IOCTL )
}
int DRM(getmap)( DRM_OS_IOCTL )
int DRM(getmap)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_map_t map;
drm_map_t *mapinlist;
drm_map_list_entry_t *list;
int idx;
int i = 0;
DRM_OS_KRNFROMUSR( map, (drm_map_t *)data, sizeof(map) );
DRM_COPY_FROM_USER_IOCTL( map, (drm_map_t *)data, sizeof(map) );
idx = map.offset;
DRM_OS_LOCK;
DRM_LOCK;
if (idx < 0 || idx >= dev->map_count) {
DRM_OS_UNLOCK;
DRM_OS_RETURN(EINVAL);
DRM_UNLOCK;
return DRM_ERR(EINVAL);
}
TAILQ_FOREACH(list, dev->maplist, link) {
@ -165,28 +165,28 @@ int DRM(getmap)( DRM_OS_IOCTL )
i++;
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
if (!list)
return EINVAL;
DRM_OS_KRNTOUSR( (drm_map_t *)data, map, sizeof(map) );
DRM_COPY_TO_USER_IOCTL( (drm_map_t *)data, map, sizeof(map) );
return 0;
}
int DRM(getclient)( DRM_OS_IOCTL )
int DRM(getclient)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_client_t client;
drm_file_t *pt;
int idx;
int i = 0;
DRM_OS_KRNFROMUSR( client, (drm_client_t *)data, sizeof(client) );
DRM_COPY_FROM_USER_IOCTL( client, (drm_client_t *)data, sizeof(client) );
idx = client.idx;
DRM_OS_LOCK;
DRM_LOCK;
TAILQ_FOREACH(pt, &dev->files, link) {
if (i==idx)
{
@ -195,29 +195,29 @@ int DRM(getclient)( DRM_OS_IOCTL )
client.uid = pt->uid;
client.magic = pt->magic;
client.iocs = pt->ioctl_count;
DRM_OS_UNLOCK;
DRM_UNLOCK;
*(drm_client_t *)data = client;
return 0;
}
i++;
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM_OS_KRNTOUSR( (drm_client_t *)data, client, sizeof(client) );
DRM_COPY_TO_USER_IOCTL( (drm_client_t *)data, client, sizeof(client) );
return 0;
}
int DRM(getstats)( DRM_OS_IOCTL )
int DRM(getstats)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_stats_t stats;
int i;
memset(&stats, 0, sizeof(stats));
DRM_OS_LOCK;
DRM_LOCK;
for (i = 0; i < dev->counters; i++) {
if (dev->types[i] == _DRM_STAT_LOCK)
@ -231,9 +231,9 @@ int DRM(getstats)( DRM_OS_IOCTL )
stats.count = dev->counters;
DRM_OS_UNLOCK;
DRM_UNLOCK;
DRM_OS_KRNTOUSR( (drm_stats_t *)data, stats, sizeof(stats) );
DRM_COPY_TO_USER_IOCTL( (drm_stats_t *)data, stats, sizeof(stats) );
return 0;
}

36
bsd/drm_lists.h
View file

@ -36,12 +36,12 @@
int DRM(waitlist_create)(drm_waitlist_t *bl, int count)
{
if (bl->count)
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
bl->bufs = DRM(alloc)((bl->count + 2) * sizeof(*bl->bufs),
DRM_MEM_BUFLISTS);
if(!bl->bufs) DRM_OS_RETURN(ENOMEM);
if(!bl->bufs) return DRM_ERR(ENOMEM);
memset(bl->bufs, 0, sizeof(*bl->bufs));
@ -49,15 +49,15 @@ int DRM(waitlist_create)(drm_waitlist_t *bl, int count)
bl->rp = bl->bufs;
bl->wp = bl->bufs;
bl->end = &bl->bufs[bl->count+1];
DRM_OS_SPININIT( bl->write_lock, "writelock" );
DRM_OS_SPININIT( bl->read_lock, "readlock" );
DRM_SPININIT( bl->write_lock, "writelock" );
DRM_SPININIT( bl->read_lock, "readlock" );
return 0;
}
int DRM(waitlist_destroy)(drm_waitlist_t *bl)
{
if (bl->rp != bl->wp)
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
if (bl->bufs) DRM(free)(bl->bufs,
(bl->count + 2) * sizeof(*bl->bufs),
DRM_MEM_BUFLISTS);
@ -77,19 +77,19 @@ int DRM(waitlist_put)(drm_waitlist_t *bl, drm_buf_t *buf)
if (!left) {
DRM_ERROR("Overflow while adding buffer %d from pid %d\n",
buf->idx, buf->pid);
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
}
#if __HAVE_DMA_HISTOGRAM
getnanotime(&buf->time_queued);
#endif
buf->list = DRM_LIST_WAIT;
DRM_OS_SPINLOCK(&bl->write_lock);
DRM_SPINLOCK(&bl->write_lock);
s = spldrm();
*bl->wp = buf;
if (++bl->wp >= bl->end) bl->wp = bl->bufs;
splx(s);
DRM_OS_SPINUNLOCK(&bl->write_lock);
DRM_SPINUNLOCK(&bl->write_lock);
return 0;
}
@ -99,17 +99,17 @@ drm_buf_t *DRM(waitlist_get)(drm_waitlist_t *bl)
drm_buf_t *buf;
int s;
DRM_OS_SPINLOCK(&bl->read_lock);
DRM_SPINLOCK(&bl->read_lock);
s = spldrm();
buf = *bl->rp;
if (bl->rp == bl->wp) {
splx(s);
DRM_OS_SPINUNLOCK(&bl->read_lock);
DRM_SPINUNLOCK(&bl->read_lock);
return NULL;
}
if (++bl->rp >= bl->end) bl->rp = bl->bufs;
splx(s);
DRM_OS_SPINUNLOCK(&bl->read_lock);
DRM_SPINUNLOCK(&bl->read_lock);
return buf;
}
@ -128,7 +128,7 @@ int DRM(freelist_create)(drm_freelist_t *bl, int count)
bl->low_mark = 0;
bl->high_mark = 0;
atomic_set(&bl->wfh, 0);
DRM_OS_SPININIT( bl->lock, "freelistlock" );
DRM_SPININIT( bl->lock, "freelistlock" );
++bl->initialized;
return 0;
}
@ -160,10 +160,10 @@ int DRM(freelist_put)(drm_device_t *dev, drm_freelist_t *bl, drm_buf_t *buf)
#endif
buf->list = DRM_LIST_FREE;
DRM_OS_SPINLOCK( &bl->lock );
DRM_SPINLOCK( &bl->lock );
buf->next = bl->next;
bl->next = buf;
DRM_OS_SPINUNLOCK( &bl->lock );
DRM_SPINUNLOCK( &bl->lock );
atomic_inc(&bl->count);
if (atomic_read(&bl->count) > dma->buf_count) {
@ -175,7 +175,7 @@ int DRM(freelist_put)(drm_device_t *dev, drm_freelist_t *bl, drm_buf_t *buf)
/* Check for high water mark */
if (atomic_read(&bl->wfh) && atomic_read(&bl->count)>=bl->high_mark) {
atomic_set(&bl->wfh, 0);
DRM_OS_WAKEUP_INT(&bl->waiting);
DRM_WAKEUP_INT(&bl->waiting);
}
return 0;
}
@ -187,14 +187,14 @@ static drm_buf_t *DRM(freelist_try)(drm_freelist_t *bl)
if (!bl) return NULL;
/* Get buffer */
DRM_OS_SPINLOCK(&bl->lock);
DRM_SPINLOCK(&bl->lock);
if (!bl->next) {
DRM_OS_SPINUNLOCK(&bl->lock);
DRM_SPINUNLOCK(&bl->lock);
return NULL;
}
buf = bl->next;
bl->next = bl->next->next;
DRM_OS_SPINUNLOCK(&bl->lock);
DRM_SPINUNLOCK(&bl->lock);
atomic_dec(&bl->count);
buf->next = NULL;

14
bsd/drm_lock.h
View file

@ -31,13 +31,13 @@
#include "drmP.h"
int DRM(block)( DRM_OS_IOCTL )
int DRM(block)( DRM_IOCTL_ARGS )
{
DRM_DEBUG("\n");
return 0;
}
int DRM(unblock)( DRM_OS_IOCTL )
int DRM(unblock)( DRM_IOCTL_ARGS )
{
DRM_DEBUG("\n");
return 0;
@ -108,7 +108,7 @@ int DRM(lock_free)(drm_device_t *dev,
pid);
return 1;
}
DRM_OS_WAKEUP_INT((void *)&dev->lock.lock_queue);
DRM_WAKEUP_INT((void *)&dev->lock.lock_queue);
return 0;
}
@ -146,7 +146,7 @@ static int DRM(flush_unblock_queue)(drm_device_t *dev, int context)
if (atomic_read(&q->use_count) > 1) {
if (atomic_read(&q->block_write)) {
atomic_dec(&q->block_write);
DRM_OS_WAKEUP_INT((void *)&q->write_queue);
DRM_WAKEUP_INT((void *)&q->write_queue);
}
}
atomic_dec(&q->use_count);
@ -193,15 +193,15 @@ int DRM(flush_unblock)(drm_device_t *dev, int context, drm_lock_flags_t flags)
return ret;
}
int DRM(finish)( DRM_OS_IOCTL )
int DRM(finish)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
int ret = 0;
drm_lock_t lock;
DRM_DEBUG("\n");
DRM_OS_KRNFROMUSR( lock, (drm_lock_t *)data, sizeof(lock) );
DRM_COPY_FROM_USER_IOCTL( lock, (drm_lock_t *)data, sizeof(lock) );
ret = DRM(flush_block_and_flush)(dev, lock.context, lock.flags);
DRM(flush_unblock)(dev, lock.context, lock.flags);

84
bsd/drm_memory.h
View file

@ -49,7 +49,7 @@ typedef struct drm_mem_stats {
unsigned long bytes_freed;
} drm_mem_stats_t;
static DRM_OS_SPINTYPE DRM(mem_lock);
static DRM_SPINTYPE DRM(mem_lock);
static unsigned long DRM(ram_available) = 0; /* In pages */
static unsigned long DRM(ram_used) = 0;
static drm_mem_stats_t DRM(mem_stats)[] = {
@ -81,7 +81,7 @@ void DRM(mem_init)(void)
{
drm_mem_stats_t *mem;
DRM_OS_SPININIT(DRM(mem_lock), "drm memory");
DRM_SPININIT(DRM(mem_lock), "drm memory");
for (mem = DRM(mem_stats); mem->name; ++mem) {
mem->succeed_count = 0;
@ -133,9 +133,9 @@ int DRM(mem_info) DRM_SYSCTL_HANDLER_ARGS
{
int ret;
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
ret = DRM(_mem_info)(oidp, arg1, arg2, req);
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return ret;
}
#endif
@ -154,15 +154,15 @@ void *DRM(alloc)(size_t size, int area)
#elif defined(__NetBSD__)
if (!(pt = malloc(size, M_DEVBUF, M_NOWAIT))) {
#endif
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[area].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return NULL;
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[area].succeed_count;
DRM(mem_stats)[area].bytes_allocated += size;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return pt;
}
@ -210,11 +210,11 @@ void DRM(free)(void *pt, size_t size, int area)
#elif defined(__NetBSD__)
free(pt, M_DEVBUF);
#endif
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
DRM(mem_stats)[area].bytes_freed += size;
free_count = ++DRM(mem_stats)[area].free_count;
alloc_count = DRM(mem_stats)[area].succeed_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
if (free_count > alloc_count) {
DRM_MEM_ERROR(area, "Excess frees: %d frees, %d allocs\n",
free_count, alloc_count);
@ -232,15 +232,15 @@ void *DRM(ioremap)(unsigned long offset, unsigned long size)
}
if (!(pt = pmap_mapdev(offset, size))) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_MAPPINGS].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return NULL;
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_MAPPINGS].succeed_count;
DRM(mem_stats)[DRM_MEM_MAPPINGS].bytes_allocated += size;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return pt;
}
@ -258,15 +258,15 @@ void *DRM(ioremap_nocache)(unsigned long offset, unsigned long size)
/* FIXME FOR BSD */
if (!(pt = ioremap_nocache(offset, size))) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_MAPPINGS].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return NULL;
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_MAPPINGS].succeed_count;
DRM(mem_stats)[DRM_MEM_MAPPINGS].bytes_allocated += size;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return pt;
}
#endif
@ -282,11 +282,11 @@ void DRM(ioremapfree)(void *pt, unsigned long size)
else
pmap_unmapdev((vm_offset_t) pt, size);
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
DRM(mem_stats)[DRM_MEM_MAPPINGS].bytes_freed += size;
free_count = ++DRM(mem_stats)[DRM_MEM_MAPPINGS].free_count;
alloc_count = DRM(mem_stats)[DRM_MEM_MAPPINGS].succeed_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
if (free_count > alloc_count) {
DRM_MEM_ERROR(DRM_MEM_MAPPINGS,
"Excess frees: %d frees, %d allocs\n",
@ -305,16 +305,16 @@ agp_memory *DRM(alloc_agp)(int pages, u32 type)
}
if ((handle = DRM(agp_allocate_memory)(pages, type))) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_TOTALAGP].succeed_count;
DRM(mem_stats)[DRM_MEM_TOTALAGP].bytes_allocated
+= pages << PAGE_SHIFT;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return handle;
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_TOTALAGP].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
return NULL;
}
@ -326,16 +326,16 @@ int DRM(free_agp)(agp_memory *handle, int pages)
if (!handle) {
DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
"Attempt to free NULL AGP handle\n");
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (DRM(agp_free_memory)(handle)) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
free_count = ++DRM(mem_stats)[DRM_MEM_TOTALAGP].free_count;
alloc_count = DRM(mem_stats)[DRM_MEM_TOTALAGP].succeed_count;
DRM(mem_stats)[DRM_MEM_TOTALAGP].bytes_freed
+= pages << PAGE_SHIFT;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
if (free_count > alloc_count) {
DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
"Excess frees: %d frees, %d allocs\n",
@ -343,13 +343,13 @@ int DRM(free_agp)(agp_memory *handle, int pages)
}
return 0;
}
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
int DRM(bind_agp)(agp_memory *handle, unsigned int start)
{
int retcode;
device_t dev = DRM_OS_AGP_FIND_DEVICE();
device_t dev = DRM_AGP_FIND_DEVICE();
struct agp_memory_info info;
if (!dev)
@ -358,22 +358,22 @@ int DRM(bind_agp)(agp_memory *handle, unsigned int start)
if (!handle) {
DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
"Attempt to bind NULL AGP handle\n");
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
if (!(retcode = DRM(agp_bind_memory)(handle, start))) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_BOUNDAGP].succeed_count;
agp_memory_info(dev, handle, &info);
DRM(mem_stats)[DRM_MEM_BOUNDAGP].bytes_allocated
+= info.ami_size;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_OS_RETURN(0);
DRM_SPINUNLOCK(&DRM(mem_lock));
return DRM_ERR(0);
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[DRM_MEM_BOUNDAGP].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_OS_RETURN(retcode);
DRM_SPINUNLOCK(&DRM(mem_lock));
return DRM_ERR(retcode);
}
int DRM(unbind_agp)(agp_memory *handle)
@ -381,7 +381,7 @@ int DRM(unbind_agp)(agp_memory *handle)
int alloc_count;
int free_count;
int retcode = EINVAL;
device_t dev = DRM_OS_AGP_FIND_DEVICE();
device_t dev = DRM_AGP_FIND_DEVICE();
struct agp_memory_info info;
if (!dev)
@ -390,25 +390,25 @@ int DRM(unbind_agp)(agp_memory *handle)
if (!handle) {
DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
"Attempt to unbind NULL AGP handle\n");
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
agp_memory_info(dev, handle, &info);
if ((retcode = DRM(agp_unbind_memory)(handle)))
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
DRM_OS_SPINLOCK(&DRM(mem_lock));
DRM_SPINLOCK(&DRM(mem_lock));
free_count = ++DRM(mem_stats)[DRM_MEM_BOUNDAGP].free_count;
alloc_count = DRM(mem_stats)[DRM_MEM_BOUNDAGP].succeed_count;
DRM(mem_stats)[DRM_MEM_BOUNDAGP].bytes_freed
+= info.ami_size;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
DRM_SPINUNLOCK(&DRM(mem_lock));
if (free_count > alloc_count) {
DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
"Excess frees: %d frees, %d allocs\n",
free_count, alloc_count);
}
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
#endif

94
bsd/drm_os_freebsd.h
View file

@ -74,47 +74,48 @@
#define CDEV_MAJOR 145
#if __FreeBSD_version >= 500000
#define DRM_OS_SPINTYPE struct mtx
#define DRM_OS_SPININIT(l,name) mtx_init(&l, name, NULL, MTX_DEF)
#define DRM_OS_SPINLOCK(l) mtx_lock(l)
#define DRM_OS_SPINUNLOCK(u) mtx_unlock(u);
#define DRM_OS_CURPROC curthread
#define DRM_OS_STRUCTPROC struct thread
#define DRM_OS_CURRENTPID curthread->td_proc->p_pid
#define DRM_CURPROC curthread
#define DRM_STRUCTPROC struct thread
#define DRM_SPINTYPE struct mtx
#define DRM_SPININIT(l,name) mtx_init(&l, name, NULL, MTX_DEF)
#define DRM_SPINLOCK(l) mtx_lock(l)
#define DRM_SPINUNLOCK(u) mtx_unlock(u);
#define DRM_CURRENTPID curthread->td_proc->p_pid
#else
#define DRM_OS_CURPROC curproc
#define DRM_OS_STRUCTPROC struct proc
#define DRM_OS_SPINTYPE struct simplelock
#define DRM_OS_SPININIT(l,name) simple_lock_init(&l)
#define DRM_OS_SPINLOCK(l) simple_lock(l)
#define DRM_OS_SPINUNLOCK(u) simple_unlock(u);
#define DRM_OS_CURRENTPID curproc->p_pid
#define DRM_CURPROC curproc
#define DRM_STRUCTPROC struct proc
#define DRM_SPINTYPE struct simplelock
#define DRM_SPININIT(l,name) simple_lock_init(&l)
#define DRM_SPINLOCK(l) simple_lock(l)
#define DRM_SPINUNLOCK(u) simple_unlock(u);
#define DRM_CURRENTPID curproc->p_pid
#endif
#define DRM_OS_IOCTL dev_t kdev, u_long cmd, caddr_t data, int flags, DRM_OS_STRUCTPROC *p
#define DRM_OS_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, DRM_OS_CURPROC)
#define DRM_OS_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, 0, DRM_OS_CURPROC)
#define DRM_OS_SUSER(p) suser(p)
#define DRM_OS_TASKQUEUE_ARGS void *dev, int pending
#define DRM_OS_IRQ_ARGS void *device
#define DRM_OS_DEVICE drm_device_t *dev = kdev->si_drv1
#define DRM_OS_MALLOC(size) malloc( size, DRM(M_DRM), M_NOWAIT )
#define DRM_OS_FREE(pt) free( pt, DRM(M_DRM) )
#define DRM_OS_VTOPHYS(addr) vtophys(addr)
#define DRM_OS_READ8(addr) *((volatile char *)(addr))
#define DRM_OS_READ32(addr) *((volatile long *)(addr))
#define DRM_OS_WRITE8(addr, val) *((volatile char *)(addr)) = (val)
#define DRM_OS_WRITE32(addr, val) *((volatile long *)(addr)) = (val)
#define DRM_OS_AGP_FIND_DEVICE() agp_find_device()
#define DRM_IOCTL_ARGS dev_t kdev, u_long cmd, caddr_t data, int flags, DRM_STRUCTPROC *p
#define DRM_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, DRM_CURPROC)
#define DRM_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, 0, DRM_CURPROC)
#define DRM_SUSER(p) suser(p)
#define DRM_TASKQUEUE_ARGS void *dev, int pending
#define DRM_IRQ_ARGS void *device
#define DRM_DEVICE drm_device_t *dev = kdev->si_drv1
#define DRM_MALLOC(size) malloc( size, DRM(M_DRM), M_NOWAIT )
#define DRM_FREE(pt) free( pt, DRM(M_DRM) )
#define DRM_VTOPHYS(addr) vtophys(addr)
#define DRM_READ8(addr) *((volatile char *)(addr))
#define DRM_READ32(addr) *((volatile long *)(addr))
#define DRM_WRITE8(addr, val) *((volatile char *)(addr)) = (val)
#define DRM_WRITE32(addr, val) *((volatile long *)(addr)) = (val)
#define DRM_AGP_FIND_DEVICE() agp_find_device()
#define DRM_ERR(v) v
#define DRM_OS_PRIV \
#define DRM_PRIV \
drm_file_t *priv = (drm_file_t *) DRM(find_file_by_proc)(dev, p); \
if (!priv) { \
DRM_DEBUG("can't find authenticator\n"); \
return EINVAL; \
}
#define DRM_OS_DELAY( udelay ) \
#define DRM_UDELAY( udelay ) \
do { \
struct timeval tv1, tv2; \
microtime(&tv1); \
@ -124,7 +125,7 @@ do { \
while (((tv2.tv_sec-tv1.tv_sec)*1000000 + tv2.tv_usec - tv1.tv_usec) < udelay ); \
} while (0)
#define DRM_OS_GETSAREA() \
#define DRM_GETSAREA() \
do { \
drm_map_list_entry_t *listentry; \
TAILQ_FOREACH(listentry, dev->maplist, link) { \
@ -137,41 +138,38 @@ do { \
} \
} while (0)
#define DRM_OS_RETURN(v) return v;
#define DRM_OS_ERR(v) v
#define DRM_OS_KRNTOUSR(arg1, arg2, arg3) \
#define DRM_COPY_TO_USER_IOCTL(arg1, arg2, arg3) \
*arg1 = arg2
#define DRM_OS_KRNFROMUSR(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER_IOCTL(arg1, arg2, arg3) \
arg1 = *arg2
#define DRM_OS_COPYTOUSR(arg1, arg2, arg3) \
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
copyout(arg2, arg1, arg3)
#define DRM_OS_COPYFROMUSR(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER(arg1, arg2, arg3) \
copyin(arg2, arg1, arg3)
/* Macros for userspace access with checking readability once */
/* FIXME: can't find equivalent functionality for nocheck yet.
* It's be slower than linux, but should be correct.
*/
#define DRM_OS_VERIFYAREA_READ( uaddr, size ) \
#define DRM_VERIFYAREA_READ( uaddr, size ) \
(!useracc((caddr_t)uaddr, size, VM_PROT_READ))
#define DRM_OS_COPYFROMUSR_NC(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
copyin(arg2, arg1, arg3)
#define DRM_OS_FETCHU_32_NC(val, uaddr) \
#define DRM_GET_USER_UNCHECKED(val, uaddr) \
((val) = fuword(uaddr), 0)
/* From machine/bus_at386.h on i386 */
#define DRM_OS_READMEMORYBARRIER() \
#define DRM_READMEMORYBARRIER() \
do { \
__asm __volatile("lock; addl $0,0(%%esp)" : : : "memory"); \
} while (0)
#define DRM_OS_WRITEMEMORYBARRIER() \
#define DRM_WRITEMEMORYBARRIER() \
do { \
__asm __volatile("" : : : "memory"); \
} while (0)
#define DRM_OS_WAKEUP(w) wakeup(w)
#define DRM_OS_WAKEUP_INT(w) wakeup(w)
#define DRM_WAKEUP(w) wakeup(w)
#define DRM_WAKEUP_INT(w) wakeup(w)
#define PAGE_ALIGN(addr) round_page(addr)
@ -347,9 +345,9 @@ extern d_write_t DRM(write);
extern d_poll_t DRM(poll);
extern d_mmap_t DRM(mmap);
extern int DRM(open_helper)(dev_t kdev, int flags, int fmt,
DRM_OS_STRUCTPROC *p, drm_device_t *dev);
DRM_STRUCTPROC *p, drm_device_t *dev);
extern drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev,
DRM_OS_STRUCTPROC *p);
DRM_STRUCTPROC *p);
/* Misc. IOCTL support (drm_ioctl.h) */
extern d_ioctl_t DRM(irq_busid);

74
bsd/drm_os_netbsd.h
View file

@ -59,38 +59,38 @@ extern struct cfdriver DRM(_cd);
#define DRM_DEV_GID 0
#define CDEV_MAJOR 90
#define DRM_OS_CURPROC curproc
#define DRM_OS_STRUCTPROC struct proc
#define DRM_OS_SPINTYPE struct simplelock
#define DRM_OS_SPININIT(l,name) simple_lock_init(&l)
#define DRM_OS_SPINLOCK(l) simple_lock(l)
#define DRM_OS_SPINUNLOCK(u) simple_unlock(u);
#define DRM_OS_CURRENTPID curproc->p_pid
#define DRM_CURPROC curproc
#define DRM_STRUCTPROC struct proc
#define DRM_SPINTYPE struct simplelock
#define DRM_SPININIT(l,name) simple_lock_init(&l)
#define DRM_SPINLOCK(l) simple_lock(l)
#define DRM_SPINUNLOCK(u) simple_unlock(u);
#define DRM_CURRENTPID curproc->p_pid
#define DRM_OS_IOCTL dev_t kdev, u_long cmd, caddr_t data, int flags, DRM_OS_STRUCTPROC *p
#define DRM_OS_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, NULL)
#define DRM_OS_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, NULL)
#define DRM_OS_SUSER(p) suser(p->p_ucred, &p->p_acflag)
#define DRM_OS_TASKQUEUE_ARGS void *dev, int pending
#define DRM_OS_IRQ_ARGS void *device
#define DRM_OS_DEVICE drm_device_t *dev = device_lookup(&DRM(_cd), minor(kdev))
#define DRM_OS_MALLOC(size) malloc( size, DRM(M_DRM), M_NOWAIT )
#define DRM_OS_FREE(pt) free( pt, DRM(M_DRM) )
#define DRM_OS_VTOPHYS(addr) vtophys(addr)
#define DRM_OS_READ8(addr) *((volatile char *)(addr))
#define DRM_OS_READ32(addr) *((volatile long *)(addr))
#define DRM_OS_WRITE8(addr, val) *((volatile char *)(addr)) = (val)
#define DRM_OS_WRITE32(addr, val) *((volatile long *)(addr)) = (val)
#define DRM_OS_AGP_FIND_DEVICE()
#define DRM_IOCTL_ARGS dev_t kdev, u_long cmd, caddr_t data, int flags, DRM_STRUCTPROC *p
#define DRM_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, NULL)
#define DRM_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, NULL)
#define DRM_SUSER(p) suser(p->p_ucred, &p->p_acflag)
#define DRM_TASKQUEUE_ARGS void *dev, int pending
#define DRM_IRQ_ARGS void *device
#define DRM_DEVICE drm_device_t *dev = device_lookup(&DRM(_cd), minor(kdev))
#define DRM_MALLOC(size) malloc( size, DRM(M_DRM), M_NOWAIT )
#define DRM_FREE(pt) free( pt, DRM(M_DRM) )
#define DRM_VTOPHYS(addr) vtophys(addr)
#define DRM_READ8(addr) *((volatile char *)(addr))
#define DRM_READ32(addr) *((volatile long *)(addr))
#define DRM_WRITE8(addr, val) *((volatile char *)(addr)) = (val)
#define DRM_WRITE32(addr, val) *((volatile long *)(addr)) = (val)
#define DRM_AGP_FIND_DEVICE()
#define DRM_OS_PRIV \
#define DRM_PRIV \
drm_file_t *priv = (drm_file_t *) DRM(find_file_by_proc)(dev, p); \
if (!priv) { \
DRM_DEBUG("can't find authenticator\n"); \
return EINVAL; \
}
#define DRM_OS_DELAY( udelay ) \
#define DRM_UDELAY( udelay ) \
do { \
struct timeval tv1, tv2; \
microtime(&tv1); \
@ -100,7 +100,7 @@ do { \
while (((tv2.tv_sec-tv1.tv_sec)*1000000 + tv2.tv_usec - tv1.tv_usec) < udelay ); \
} while (0)
#define DRM_OS_GETSAREA() \
#define DRM_GETSAREA() \
do { \
drm_map_list_entry_t *listentry; \
TAILQ_FOREACH(listentry, dev->maplist, link) { \
@ -113,19 +113,19 @@ do { \
} \
} while (0)
#define DRM_OS_RETURN(v) return v;
#define DRM_OS_ERR(v) v
#define return DRM_ERR(v) return v;
#define DRM_ERR(v) v
#define DRM_OS_KRNTOUSR(arg1, arg2, arg3) \
#define DRM_COPY_TO_USER_IOCTL(arg1, arg2, arg3) \
*arg1 = arg2
#define DRM_OS_KRNFROMUSR(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER_IOCTL(arg1, arg2, arg3) \
arg1 = *arg2
#define DRM_OS_COPYTOUSR(arg1, arg2, arg3) \
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
copyout(arg2, arg1, arg3)
#define DRM_OS_COPYFROMUSR(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER(arg1, arg2, arg3) \
copyin(arg2, arg1, arg3)
#define DRM_OS_READMEMORYBARRIER \
#define DRM_READMEMORYBARRIER \
{ \
int xchangeDummy; \
DRM_DEBUG("%s\n", __FUNCTION__); \
@ -135,10 +135,10 @@ do { \
" pop %%eax" : /* no outputs */ : /* no inputs */ ); \
} while (0);
#define DRM_OS_WRITEMEMORYBARRIER DRM_OS_READMEMORYBARRIER
#define DRM_WRITEMEMORYBARRIER DRM_READMEMORYBARRIER
#define DRM_OS_WAKEUP(w) wakeup(w)
#define DRM_OS_WAKEUP_INT(w) wakeup(w)
#define DRM_WAKEUP(w) wakeup(w)
#define DRM_WAKEUP_INT(w) wakeup(w)
#define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK)
@ -300,9 +300,9 @@ extern dev_type_write(DRM(write));
extern dev_type_poll(DRM(poll));
extern dev_type_mmap(DRM(mmap));
extern int DRM(open_helper)(dev_t kdev, int flags, int fmt,
DRM_OS_STRUCTPROC *p, drm_device_t *dev);
DRM_STRUCTPROC *p, drm_device_t *dev);
extern drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev,
DRM_OS_STRUCTPROC *p);
DRM_STRUCTPROC *p);
/* Misc. IOCTL support (drm_ioctl.h) */
extern dev_type_ioctl(DRM(irq_busid));

22
bsd/drm_scatter.h
View file

@ -48,9 +48,9 @@ void DRM(sg_cleanup)( drm_sg_mem_t *entry )
DRM_MEM_SGLISTS );
}
int DRM(sg_alloc)( DRM_OS_IOCTL )
int DRM(sg_alloc)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
unsigned long pages;
@ -60,7 +60,7 @@ int DRM(sg_alloc)( DRM_OS_IOCTL )
if ( dev->sg )
return EINVAL;
DRM_OS_KRNFROMUSR(request, (drm_scatter_gather_t *)data,
DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
sizeof(request) );
entry = DRM(alloc)( sizeof(*entry), DRM_MEM_SGLISTS );
@ -118,7 +118,7 @@ int DRM(sg_alloc)( DRM_OS_IOCTL )
request.handle = entry->handle;
DRM_OS_KRNTOUSR( (drm_scatter_gather_t *)data,
DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
request,
sizeof(request) );
@ -170,13 +170,13 @@ int DRM(sg_alloc)( DRM_OS_IOCTL )
return ENOMEM;
}
int DRM(sg_free)( DRM_OS_IOCTL )
int DRM(sg_free)( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
DRM_OS_KRNFROMUSR( request, (drm_scatter_gather_t *)data,
DRM_COPY_FROM_USER_IOCTL( request, (drm_scatter_gather_t *)data,
sizeof(request) );
entry = dev->sg;
@ -194,13 +194,13 @@ int DRM(sg_free)( DRM_OS_IOCTL )
#else /* __REALLY_HAVE_SG */
int DRM(sg_alloc)( DRM_OS_IOCTL )
int DRM(sg_alloc)( DRM_IOCTL_ARGS )
{
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
int DRM(sg_free)( DRM_OS_IOCTL )
int DRM(sg_free)( DRM_IOCTL_ARGS )
{
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
#endif

24
bsd/drm_sysctl.h
View file

@ -168,9 +168,9 @@ static int DRM(vm_info)DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = DRM(_vm_info)(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
@ -219,9 +219,9 @@ static int DRM(queues_info) DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = DRM(_queues_info)(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
@ -269,9 +269,9 @@ static int DRM(bufs_info) DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = DRM(_bufs_info)(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
@ -303,9 +303,9 @@ static int DRM(clients_info)DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = DRM(_clients_info)(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
@ -388,9 +388,9 @@ static int DRM(vma_info)DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = DRM(_vma_info)(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
#endif
@ -517,9 +517,9 @@ static int DRM(histo_info)DRM_SYSCTL_HANDLER_ARGS
drm_device_t *dev = arg1;
int ret;
DRM_OS_LOCK;
DRM_LOCK;
ret = _drm_histo_info(oidp, arg1, arg2, req);
DRM_OS_UNLOCK;
DRM_UNLOCK;
return ret;
}
#endif

10
bsd/drm_vm.h
View file

@ -5,7 +5,7 @@ static int DRM(dma_mmap)(dev_t kdev, vm_offset_t offset, int prot)
static paddr_t DRM(dma_mmap)(dev_t kdev, vm_offset_t offset, int prot)
#endif
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
unsigned long physical;
unsigned long page;
@ -26,20 +26,20 @@ int DRM(mmap)(dev_t kdev, vm_offset_t offset, int prot)
paddr_t DRM(mmap)(dev_t kdev, off_t offset, int prot)
#endif
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_map_t *map = NULL;
drm_map_list_entry_t *listentry=NULL;
drm_file_t *priv;
/* DRM_DEBUG("offset = 0x%x\n", offset);*/
priv = DRM(find_file_by_proc)(dev, DRM_OS_CURPROC);
priv = DRM(find_file_by_proc)(dev, DRM_CURPROC);
if (!priv) {
DRM_DEBUG("can't find authenticator\n");
return EINVAL;
}
if (!priv->authenticated) DRM_OS_RETURN(EACCES);
if (!priv->authenticated) return DRM_ERR(EACCES);
if (dev->dma
&& offset >= 0
@ -64,7 +64,7 @@ paddr_t DRM(mmap)(dev_t kdev, off_t offset, int prot)
DRM_DEBUG("can't find map\n");
return -1;
}
if (((map->flags&_DRM_RESTRICTED) && DRM_OS_SUSER(DRM_OS_CURPROC))) {
if (((map->flags&_DRM_RESTRICTED) && DRM_SUSER(DRM_CURPROC))) {
DRM_DEBUG("restricted map\n");
return -1;
}

56
bsd/gamma_dma.c
View file

@ -44,7 +44,7 @@ static __inline__ void gamma_dma_dispatch(drm_device_t *dev, unsigned long addre
drm_gamma_private_t *dev_priv =
(drm_gamma_private_t *)dev->dev_private;
GAMMA_WRITE(GAMMA_DMAADDRESS, DRM_OS_VTOPHYS((void *)address));
GAMMA_WRITE(GAMMA_DMAADDRESS, DRM_VTOPHYS((void *)address));
while (GAMMA_READ(GAMMA_GCOMMANDSTATUS) != 4)
;
GAMMA_WRITE(GAMMA_DMACOUNT, length / 4);
@ -114,7 +114,7 @@ static __inline__ int gamma_dma_is_ready(drm_device_t *dev)
return !GAMMA_READ(GAMMA_DMACOUNT);
}
void gamma_dma_service( DRM_OS_IRQ_ARGS)
void gamma_dma_service( DRM_IRQ_ARGS)
{
drm_device_t *dev = (drm_device_t *)device;
drm_device_dma_t *dma = dev->dma;
@ -150,7 +150,7 @@ static int gamma_do_dma(drm_device_t *dev, int locked)
cycles_t dma_start, dma_stop;
#endif
if (test_and_set_bit(0, &dev->dma_flag)) DRM_OS_RETURN( EBUSY );
if (test_and_set_bit(0, &dev->dma_flag)) return DRM_ERR( EBUSY );
#if DRM_DMA_HISTOGRAM
dma_start = get_cycles();
@ -159,7 +159,7 @@ static int gamma_do_dma(drm_device_t *dev, int locked)
if (!dma->next_buffer) {
DRM_ERROR("No next_buffer\n");
clear_bit(0, &dev->dma_flag);
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
}
buf = dma->next_buffer;
@ -173,7 +173,7 @@ static int gamma_do_dma(drm_device_t *dev, int locked)
gamma_clear_next_buffer(dev);
gamma_free_buffer(dev, buf);
clear_bit(0, &dev->dma_flag);
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
}
if (!length) {
@ -186,7 +186,7 @@ static int gamma_do_dma(drm_device_t *dev, int locked)
if (!gamma_dma_is_ready(dev)) {
clear_bit(0, &dev->dma_flag);
DRM_OS_RETURN( EBUSY );
return DRM_ERR( EBUSY );
}
if (buf->while_locked) {
@ -199,7 +199,7 @@ static int gamma_do_dma(drm_device_t *dev, int locked)
if (!locked && !gamma_lock_take(&dev->lock.hw_lock->lock,
DRM_KERNEL_CONTEXT)) {
clear_bit(0, &dev->dma_flag);
DRM_OS_RETURN( EBUSY );
return DRM_ERR( EBUSY );
}
}
@ -252,7 +252,7 @@ cleanup:
atomic_inc(&dev->histo.dma[gamma_histogram_slot(dma_stop - dma_start)]);
#endif
DRM_OS_RETURN( retcode );
return DRM_ERR( retcode );
}
static void gamma_dma_timer_bh(unsigned long dev)
@ -260,7 +260,7 @@ static void gamma_dma_timer_bh(unsigned long dev)
gamma_dma_schedule((drm_device_t *)dev, 0);
}
void gamma_dma_immediate_bh(DRM_OS_TASKQUEUE_ARGS)
void gamma_dma_immediate_bh(DRM_TASKQUEUE_ARGS)
{
gamma_dma_schedule(dev, 0);
}
@ -282,7 +282,7 @@ int gamma_dma_schedule(drm_device_t *dev, int locked)
if (test_and_set_bit(0, &dev->interrupt_flag)) {
/* Not reentrant */
atomic_inc(&dev->counts[10]); /* _DRM_STAT_MISSED */
DRM_OS_RETURN( EBUSY );
return DRM_ERR( EBUSY );
}
missed = atomic_read(&dev->counts[10]);
@ -293,7 +293,7 @@ int gamma_dma_schedule(drm_device_t *dev, int locked)
again:
if (dev->context_flag) {
clear_bit(0, &dev->interrupt_flag);
DRM_OS_RETURN( EBUSY );
return DRM_ERR( EBUSY );
}
if (dma->next_buffer) {
/* Unsent buffer that was previously
@ -379,15 +379,15 @@ static int gamma_dma_priority(drm_device_t *dev, drm_dma_t *d)
continue;
}
buf = dma->buflist[ idx ];
if (buf->pid != DRM_OS_CURRENTPID) {
if (buf->pid != DRM_CURRENTPID) {
DRM_ERROR("Process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid);
DRM_CURRENTPID, buf->pid);
retcode = EINVAL;
goto cleanup;
}
if (buf->list != DRM_LIST_NONE) {
DRM_ERROR("Process %d using %d's buffer on list %d\n",
DRM_OS_CURRENTPID, buf->pid, buf->list);
DRM_CURRENTPID, buf->pid, buf->list);
retcode = EINVAL;
goto cleanup;
}
@ -471,7 +471,7 @@ cleanup:
}
}
clear_bit(0, &dev->interrupt_flag);
DRM_OS_RETURN( retcode );
return DRM_ERR( retcode );
}
static int gamma_dma_send_buffers(drm_device_t *dev, drm_dma_t *d)
@ -494,7 +494,7 @@ static int gamma_dma_send_buffers(drm_device_t *dev, drm_dma_t *d)
gamma_dma_schedule(dev, 0);
if (d->flags & _DRM_DMA_BLOCK) {
DRM_DEBUG("%d waiting\n", DRM_OS_CURRENTPID);
DRM_DEBUG("%d waiting\n", DRM_CURRENTPID);
for (;;) {
retcode = tsleep(&last_buf->dma_wait, PZERO|PCATCH,
"gamdw", 0);
@ -505,7 +505,7 @@ static int gamma_dma_send_buffers(drm_device_t *dev, drm_dma_t *d)
break;
}
atomic_dec(&last_buf->dma_wait);
DRM_DEBUG("%d running\n", DRM_OS_CURRENTPID);
DRM_DEBUG("%d running\n", DRM_CURRENTPID);
if (!retcode
|| (last_buf->list==DRM_LIST_PEND && !last_buf->pending)) {
if (!last_buf->dma_wait) {
@ -521,31 +521,31 @@ static int gamma_dma_send_buffers(drm_device_t *dev, drm_dma_t *d)
last_buf->idx,
last_buf->list,
last_buf->pid,
DRM_OS_CURRENTPID);
DRM_CURRENTPID);
}
}
DRM_OS_RETURN( retcode );
return DRM_ERR( retcode );
}
int gamma_dma( DRM_OS_IOCTL )
int gamma_dma( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
int retcode = 0;
drm_dma_t d;
DRM_OS_KRNFROMUSR(d, (drm_dma_t *) data, sizeof(d));
DRM_COPY_FROM_USER_IOCTL(d, (drm_dma_t *) data, sizeof(d));
if (d.send_count < 0 || d.send_count > dma->buf_count) {
DRM_ERROR("Process %d trying to send %d buffers (of %d max)\n",
DRM_OS_CURRENTPID, d.send_count, dma->buf_count);
DRM_OS_RETURN( EINVAL );
DRM_CURRENTPID, d.send_count, dma->buf_count);
return DRM_ERR( EINVAL );
}
if (d.request_count < 0 || d.request_count > dma->buf_count) {
DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n",
DRM_OS_CURRENTPID, d.request_count, dma->buf_count);
DRM_OS_RETURN( EINVAL );
DRM_CURRENTPID, d.request_count, dma->buf_count);
return DRM_ERR( EINVAL );
}
if (d.send_count) {
@ -562,8 +562,8 @@ int gamma_dma( DRM_OS_IOCTL )
}
DRM_DEBUG("%d returning, granted = %d\n",
DRM_OS_CURRENTPID, d.granted_count);
DRM_OS_KRNTOUSR((drm_dma_t *) data, d, sizeof(d));
DRM_CURRENTPID, d.granted_count);
DRM_COPY_TO_USER_IOCTL((drm_dma_t *) data, d, sizeof(d));
return retcode;
}

6
bsd/gamma_drv.h
View file

@ -44,10 +44,10 @@ typedef struct drm_gamma_private {
#define LOCK_TEST_WITH_RETURN( dev ) \
do { \
if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \
dev->lock.pid != DRM_OS_CURRENTPID ) { \
dev->lock.pid != DRM_CURRENTPID ) { \
DRM_ERROR( "%s called without lock held\n", \
__FUNCTION__ ); \
DRM_OS_RETURN( EINVAL ); \
return DRM_ERR( EINVAL ); \
} \
} while (0)
@ -58,7 +58,7 @@ extern void gamma_dma_quiescent_dual(drm_device_t *dev);
/* gamma_dma.c */
extern int gamma_dma_schedule(drm_device_t *dev, int locked);
extern int gamma_dma( DRM_OS_IOCTL );
extern int gamma_dma( DRM_IOCTL_ARGS );
extern int gamma_find_devices(void);
extern int gamma_found(void);

116
bsd/i810_dma.c
View file

@ -121,7 +121,7 @@ static int i810_freelist_put(drm_device_t *dev, drm_buf_t *buf)
_DRM_CAS(buf_priv->in_use, I810_BUF_CLIENT, I810_BUF_FREE, failed);
if(failed) {
DRM_ERROR("Freeing buffer thats not in use : %d\n", buf->idx);
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
}
return 0;
@ -130,7 +130,7 @@ static int i810_freelist_put(drm_device_t *dev, drm_buf_t *buf)
#if 0
int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_i810_private_t *dev_priv;
drm_buf_t *buf;
drm_i810_buf_priv_t *buf_priv;
@ -149,20 +149,20 @@ int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma)
if (remap_page_range(vma->vm_start,
VM_OFFSET(vma),
vma->vm_end - vma->vm_start,
vma->vm_page_prot)) DRM_OS_RETURN(EAGAIN);
vma->vm_page_prot)) return DRM_ERR(EAGAIN);
return 0;
}
#endif
static int i810_map_buffer(drm_buf_t *buf, struct file *filp)
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_i810_buf_priv_t *buf_priv = buf->dev_private;
drm_i810_private_t *dev_priv = dev->dev_private;
struct file_operations *old_fops;
int retcode = 0;
if(buf_priv->currently_mapped == I810_BUF_MAPPED) DRM_OS_RETURN(EINVAL);
if(buf_priv->currently_mapped == I810_BUF_MAPPED) return DRM_ERR(EINVAL);
if(VM_DONTCOPY != 0) {
#if LINUX_VERSION_CODE <= 0x020402
@ -204,7 +204,7 @@ static int i810_unmap_buffer(drm_buf_t *buf)
if(VM_DONTCOPY != 0) {
if(buf_priv->currently_mapped != I810_BUF_MAPPED)
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
#if LINUX_VERSION_CODE <= 0x020402
down( &current->mm->mmap_sem );
#else
@ -237,7 +237,7 @@ static int i810_dma_get_buffer(drm_device_t *dev, drm_i810_dma_t *d,
if (!buf) {
retcode = -ENOMEM;
DRM_DEBUG("retcode=%d\n", retcode);
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
retcode = i810_map_buffer(buf, filp);
@ -277,7 +277,7 @@ static void i810_free_page(drm_device_t *dev, unsigned long page)
atomic_dec(&virt_to_page(page)->count);
clear_bit(PG_locked, &virt_to_page(page)->flags);
DRM_OS_WAKEUP(&virt_to_page(page)->wait);
DRM_WAKEUP(&virt_to_page(page)->wait);
free_page(page);
return;
}
@ -366,7 +366,7 @@ static int i810_freelist_init(drm_device_t *dev, drm_i810_private_t *dev_priv)
if(dma->buf_count > 1019) {
/* Not enough space in the status page for the freelist */
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
for (i = 0; i < dma->buf_count; i++) {
@ -406,21 +406,21 @@ static int i810_dma_initialize(drm_device_t *dev,
dev->dev_private = (void *)dev_priv;
i810_dma_cleanup(dev);
DRM_ERROR("can not find sarea!\n");
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->mmio_map, init->mmio_offset );
if(!dev_priv->mmio_map) {
dev->dev_private = (void *)dev_priv;
i810_dma_cleanup(dev);
DRM_ERROR("can not find mmio map!\n");
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->buffer_map, init->buffers_offset );
if(!dev_priv->buffer_map) {
dev->dev_private = (void *)dev_priv;
i810_dma_cleanup(dev);
DRM_ERROR("can not find dma buffer map!\n");
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->sarea_priv = (drm_i810_sarea_t *)
@ -443,7 +443,7 @@ static int i810_dma_initialize(drm_device_t *dev,
i810_dma_cleanup(dev);
DRM_ERROR("can not ioremap virtual address for"
" ring buffer\n");
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
dev_priv->ring.tail_mask = dev_priv->ring.Size - 1;
@ -464,7 +464,7 @@ static int i810_dma_initialize(drm_device_t *dev,
dev->dev_private = (void *)dev_priv;
i810_dma_cleanup(dev);
DRM_ERROR("Can not allocate hardware status page\n");
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset((void *) dev_priv->hw_status_page, 0, PAGE_SIZE);
DRM_DEBUG("hw status page @ %lx\n", dev_priv->hw_status_page);
@ -478,27 +478,27 @@ static int i810_dma_initialize(drm_device_t *dev,
i810_dma_cleanup(dev);
DRM_ERROR("Not enough space in the status page for"
" the freelist\n");
DRM_OS_RETURN(ENOMEM);
return DRM_ERR(ENOMEM);
}
dev->dev_private = (void *)dev_priv;
return 0;
}
int i810_dma_init( DRM_OS_IOCTL )
int i810_dma_init( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_i810_private_t *dev_priv;
drm_i810_init_t init;
int retcode = 0;
DRM_OS_KRNFROMUSR( init, (drm_i810_init_t *) data, sizeof(init) );
DRM_COPY_FROM_USER_IOCTL( init, (drm_i810_init_t *) data, sizeof(init) );
switch(init.func) {
case I810_INIT_DMA:
dev_priv = DRM(alloc)(sizeof(drm_i810_private_t),
DRM_MEM_DRIVER);
if(dev_priv == NULL) DRM_OS_RETURN(ENOMEM);
if(dev_priv == NULL) return DRM_ERR(ENOMEM);
retcode = i810_dma_initialize(dev, dev_priv, &init);
break;
case I810_CLEANUP_DMA:
@ -509,7 +509,7 @@ int i810_dma_init( DRM_OS_IOCTL )
break;
}
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
@ -899,7 +899,7 @@ void i810_dma_immediate_bh(void *device)
drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
atomic_set(&dev_priv->flush_done, 1);
DRM_OS_WAKEUP_INT(&dev_priv->flush_queue);
DRM_WAKEUP_INT(&dev_priv->flush_queue);
}
static inline void i810_dma_emit_flush(drm_device_t *dev)
@ -916,7 +916,7 @@ static inline void i810_dma_emit_flush(drm_device_t *dev)
/* i810_wait_ring( dev, dev_priv->ring.Size - 8 ); */
/* atomic_set(&dev_priv->flush_done, 1); */
/* DRM_OS_WAKEUP_INT(&dev_priv->flush_queue); */
/* DRM_WAKEUP_INT(&dev_priv->flush_queue); */
}
static inline void i810_dma_quiescent_emit(drm_device_t *dev)
@ -935,7 +935,7 @@ static inline void i810_dma_quiescent_emit(drm_device_t *dev)
/* i810_wait_ring( dev, dev_priv->ring.Size - 8 ); */
/* atomic_set(&dev_priv->flush_done, 1); */
/* DRM_OS_WAKEUP_INT(&dev_priv->flush_queue); */
/* DRM_WAKEUP_INT(&dev_priv->flush_queue); */
}
void i810_dma_quiescent(drm_device_t *dev)
@ -1051,14 +1051,14 @@ void i810_reclaim_buffers(drm_device_t *dev, pid_t pid)
}
}
int i810_flush_ioctl( DRM_OS_IOCTL )
int i810_flush_ioctl( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
DRM_DEBUG("i810_flush_ioctl\n");
if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
DRM_ERROR("i810_flush_ioctl called without lock held\n");
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
}
i810_flush_queue(dev);
@ -1066,9 +1066,9 @@ int i810_flush_ioctl( DRM_OS_IOCTL )
}
int i810_dma_vertex( DRM_OS_IOCTL )
int i810_dma_vertex( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
u32 *hw_status = (u32 *)dev_priv->hw_status_page;
@ -1076,17 +1076,17 @@ int i810_dma_vertex( DRM_OS_IOCTL )
dev_priv->sarea_priv;
drm_i810_vertex_t vertex;
DRM_OS_KRNFROMUSR( vertex, (drm_i810_vertex_t *) data, sizeof(vertex) );
DRM_COPY_FROM_USER_IOCTL( vertex, (drm_i810_vertex_t *) data, sizeof(vertex) );
if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
DRM_ERROR("i810_dma_vertex called without lock held\n");
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
}
DRM_DEBUG("i810 dma vertex, idx %d used %d discard %d\n",
vertex.idx, vertex.used, vertex.discard);
if(vertex.idx < 0 || vertex.idx > dma->buf_count) DRM_OS_RETURN(EINVAL);
if(vertex.idx < 0 || vertex.idx > dma->buf_count) return DRM_ERR(EINVAL);
i810_dma_dispatch_vertex( dev,
dma->buflist[ vertex.idx ],
@ -1102,21 +1102,21 @@ int i810_dma_vertex( DRM_OS_IOCTL )
int i810_clear_bufs( DRM_OS_IOCTL )
int i810_clear_bufs( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_i810_clear_t clear;
DRM_OS_KRNFROMUSR( clear, (drm_i810_clear_t *) data, sizeof(clear) );
DRM_COPY_FROM_USER_IOCTL( clear, (drm_i810_clear_t *) data, sizeof(clear) );
if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
DRM_ERROR("i810_clear_bufs called without lock held\n");
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
}
/* GH: Someone's doing nasty things... */
if (!dev->dev_private) {
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
i810_dma_dispatch_clear( dev, clear.flags,
@ -1125,24 +1125,24 @@ int i810_clear_bufs( DRM_OS_IOCTL )
return 0;
}
int i810_swap_bufs( DRM_OS_IOCTL )
int i810_swap_bufs( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
DRM_DEBUG("i810_swap_bufs\n");
if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
DRM_ERROR("i810_swap_buf called without lock held\n");
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
}
i810_dma_dispatch_swap( dev );
return 0;
}
int i810_getage( DRM_OS_IOCTL )
int i810_getage( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
u32 *hw_status = (u32 *)dev_priv->hw_status_page;
drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
@ -1152,9 +1152,9 @@ int i810_getage( DRM_OS_IOCTL )
return 0;
}
int i810_getbuf( DRM_OS_IOCTL )
int i810_getbuf( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
int retcode = 0;
drm_i810_dma_t d;
drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
@ -1163,11 +1163,11 @@ int i810_getbuf( DRM_OS_IOCTL )
dev_priv->sarea_priv;
DRM_DEBUG("getbuf\n");
DRM_OS_KRNFROMUSR( d, (drm_i810_dma_t *) data, sizeof(d) );
DRM_COPY_FROM_USER_IOCTL( d, (drm_i810_dma_t *) data, sizeof(d) );
if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
DRM_ERROR("i810_dma called without lock held\n");
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
}
d.granted = 0;
@ -1175,17 +1175,17 @@ int i810_getbuf( DRM_OS_IOCTL )
retcode = i810_dma_get_buffer(dev, &d, filp);
DRM_DEBUG("i810_dma: %d returning %d, granted = %d\n",
DRM_OS_CURRENTPID, retcode, d.granted);
DRM_CURRENTPID, retcode, d.granted);
DRM_OS_KRNTOUSR( (drm_dma_t *) data, d, sizeof(d) );
DRM_COPY_TO_USER_IOCTL( (drm_dma_t *) data, d, sizeof(d) );
sarea_priv->last_dispatch = (int) hw_status[5];
DRM_OS_RETURN(retcode);
return DRM_ERR(retcode);
}
int i810_copybuf( DRM_OS_IOCTL )
int i810_copybuf( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_i810_copy_t d;
drm_i810_private_t *dev_priv = (drm_i810_private_t *)dev->dev_private;
u32 *hw_status = (u32 *)dev_priv->hw_status_page;
@ -1197,26 +1197,26 @@ int i810_copybuf( DRM_OS_IOCTL )
if(!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
DRM_ERROR("i810_dma called without lock held\n");
DRM_OS_RETURN( EINVAL );
return DRM_ERR( EINVAL );
}
DRM_OS_KRNFROMUSR( d, (drm_i810_copy_t *) data, sizeof(d) );
DRM_COPY_FROM_USER_IOCTL( d, (drm_i810_copy_t *) data, sizeof(d) );
if(d.idx < 0 || d.idx > dma->buf_count) DRM_OS_RETURN(EINVAL);
if(d.idx < 0 || d.idx > dma->buf_count) return DRM_ERR(EINVAL);
buf = dma->buflist[ d.idx ];
buf_priv = buf->dev_private;
if (buf_priv->currently_mapped != I810_BUF_MAPPED) DRM_OS_RETURN(EPERM);
if(d.used < 0 || d.used > buf->total) DRM_OS_RETURN(EINVAL);
if (buf_priv->currently_mapped != I810_BUF_MAPPED) return DRM_ERR(EPERM);
if(d.used < 0 || d.used > buf->total) return DRM_ERR(EINVAL);
if (DRM_OS_COPYFROMUSR(buf_priv->virtual, d.address, d.used))
DRM_OS_RETURN( EFAULT );
if (DRM_COPY_FROM_USER(buf_priv->virtual, d.address, d.used))
return DRM_ERR( EFAULT );
sarea_priv->last_dispatch = (int) hw_status[5];
return 0;
}
int i810_docopy( DRM_OS_IOCTL )
int i810_docopy( DRM_IOCTL_ARGS )
{
if(VM_DONTCOPY == 0) return 1;
return 0;

18
bsd/i810_drv.h
View file

@ -79,22 +79,22 @@ typedef struct drm_i810_private {
/* i810_dma.c */
extern int i810_dma_schedule(drm_device_t *dev, int locked);
extern int i810_getbuf( DRM_OS_IOCTL );
extern int i810_dma_init( DRM_OS_IOCTL );
extern int i810_flush_ioctl( DRM_OS_IOCTL );
extern int i810_getage( DRM_OS_IOCTL );
extern int i810_getbuf( DRM_IOCTL_ARGS );
extern int i810_dma_init( DRM_IOCTL_ARGS );
extern int i810_flush_ioctl( DRM_IOCTL_ARGS );
extern int i810_getage( DRM_IOCTL_ARGS );
extern int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma);
extern int i810_copybuf( DRM_OS_IOCTL );
extern int i810_docopy( DRM_OS_IOCTL );
extern int i810_copybuf( DRM_IOCTL_ARGS );
extern int i810_docopy( DRM_IOCTL_ARGS );
extern void i810_dma_quiescent(drm_device_t *dev);
#define I810_VERBOSE 0
int i810_dma_vertex( DRM_OS_IOCTL );
int i810_swap_bufs( DRM_OS_IOCTL );
int i810_clear_bufs( DRM_OS_IOCTL );
int i810_dma_vertex( DRM_IOCTL_ARGS );
int i810_swap_bufs( DRM_IOCTL_ARGS );
int i810_clear_bufs( DRM_IOCTL_ARGS );
#define I810_BASE(reg) ((unsigned long) \
dev_priv->mmio_map->handle)

10
bsd/sis_drm.h
View file

@ -29,11 +29,11 @@ typedef struct {
#if defined(__KERNEL__) || defined(_KERNEL)
int sis_fb_alloc(DRM_OS_IOCTL);
int sis_fb_free(DRM_OS_IOCTL);
int sisp_agp_init(DRM_OS_IOCTL);
int sisp_agp_alloc(DRM_OS_IOCTL);
int sisp_agp_free(DRM_OS_IOCTL);
int sis_fb_alloc(DRM_IOCTL_ARGS);
int sis_fb_free(DRM_IOCTL_ARGS);
int sisp_agp_init(DRM_IOCTL_ARGS);
int sisp_agp_alloc(DRM_IOCTL_ARGS);
int sisp_agp_free(DRM_IOCTL_ARGS);
#endif

51
linux-core/drm_os_linux.h
View file

@ -1,49 +1,47 @@
#define __NO_VERSION__
#include <linux/interrupt.h> /* For task queue support */
#include <linux/delay.h>
#define DRM_OS_IOCTL struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data
#define DRM_OS_RETURN(d) return -(d)
#define DRM_OS_ERR(d) -(d)
#define DRM_OS_CURRENTPID current->pid
#define DRM_OS_DELAY(d) udelay(d)
#define DRM_OS_READ8(addr) readb(addr)
#define DRM_OS_READ32(addr) readl(addr)
#define DRM_OS_WRITE8(addr, val) writeb(val, addr)
#define DRM_OS_WRITE32(addr, val) writel(val, addr)
#define DRM_OS_READMEMORYBARRIER() mb()
#define DRM_OS_WRITEMEMORYBARRIER() wmb()
#define DRM_OS_DEVICE drm_file_t *priv = filp->private_data; \
#define DRM_IOCTL_ARGS struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data
#define DRM_ERR(d) -(d)
#define DRM_CURRENTPID current->pid
#define DRM_UDELAY(d) udelay(d)
#define DRM_READ8(addr) readb(addr)
#define DRM_READ32(addr) readl(addr)
#define DRM_WRITE8(addr, val) writeb(val, addr)
#define DRM_WRITE32(addr, val) writel(val, addr)
#define DRM_READMEMORYBARRIER() mb()
#define DRM_WRITEMEMORYBARRIER() wmb()
#define DRM_DEVICE drm_file_t *priv = filp->private_data; \
drm_device_t *dev = priv->dev
/* For data going from/to the kernel through the ioctl argument */
#define DRM_OS_KRNFROMUSR(arg1, arg2, arg3) \
if ( copy_from_user(&arg1, arg2, arg3) ) \
#define DRM_COPY_FROM_USER_IOCTL(arg1, arg2, arg3) \
if ( copy_from_user(&arg1, arg2, arg3) ) \
return -EFAULT
#define DRM_OS_KRNTOUSR(arg1, arg2, arg3) \
if ( copy_to_user(arg1, &arg2, arg3) ) \
#define DRM_COPY_TO_USER_IOCTL(arg1, arg2, arg3) \
if ( copy_to_user(arg1, &arg2, arg3) ) \
return -EFAULT
/* Other copying of data from/to kernel space */
#define DRM_OS_COPYFROMUSR(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER(arg1, arg2, arg3) \
copy_from_user(arg1, arg2, arg3)
#define DRM_OS_COPYTOUSR(arg1, arg2, arg3) \
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
copy_to_user(arg1, arg2, arg3)
/* Macros for checking readability once */
#define DRM_OS_VERIFYAREA_READ( uaddr, size ) \
/* Macros for copyfrom user, but checking readability only once */
#define DRM_VERIFYAREA_READ( uaddr, size ) \
verify_area( VERIFY_READ, uaddr, size )
#define DRM_OS_COPYFROMUSR_NC(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
__copy_from_user(arg1, arg2, arg3)
#define DRM_OS_FETCHU_32_NC(val, uaddr) \
#define DRM_GET_USER_UNCHECKED(val, uaddr) \
__get_user(val, uaddr)
/* malloc/free without the overhead of DRM(alloc) */
#define DRM_OS_MALLOC(x) kmalloc(x, GFP_KERNEL)
#define DRM_OS_FREE(x) kfree(x)
#define DRM_MALLOC(x) kmalloc(x, GFP_KERNEL)
#define DRM_FREE(x) kfree(x)
#define DRM_OS_GETSAREA() \
#define DRM_GETSAREA() \
do { \
struct list_head *list; \
list_for_each( list, &dev->maplist->head ) { \
@ -56,4 +54,3 @@ do { \
} \
} \
} while (0)

51
linux/drm_os_linux.h
View file

@ -1,49 +1,47 @@
#define __NO_VERSION__
#include <linux/interrupt.h> /* For task queue support */
#include <linux/delay.h>
#define DRM_OS_IOCTL struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data
#define DRM_OS_RETURN(d) return -(d)
#define DRM_OS_ERR(d) -(d)
#define DRM_OS_CURRENTPID current->pid
#define DRM_OS_DELAY(d) udelay(d)
#define DRM_OS_READ8(addr) readb(addr)
#define DRM_OS_READ32(addr) readl(addr)
#define DRM_OS_WRITE8(addr, val) writeb(val, addr)
#define DRM_OS_WRITE32(addr, val) writel(val, addr)
#define DRM_OS_READMEMORYBARRIER() mb()
#define DRM_OS_WRITEMEMORYBARRIER() wmb()
#define DRM_OS_DEVICE drm_file_t *priv = filp->private_data; \
#define DRM_IOCTL_ARGS struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data
#define DRM_ERR(d) -(d)
#define DRM_CURRENTPID current->pid
#define DRM_UDELAY(d) udelay(d)
#define DRM_READ8(addr) readb(addr)
#define DRM_READ32(addr) readl(addr)
#define DRM_WRITE8(addr, val) writeb(val, addr)
#define DRM_WRITE32(addr, val) writel(val, addr)
#define DRM_READMEMORYBARRIER() mb()
#define DRM_WRITEMEMORYBARRIER() wmb()
#define DRM_DEVICE drm_file_t *priv = filp->private_data; \
drm_device_t *dev = priv->dev
/* For data going from/to the kernel through the ioctl argument */
#define DRM_OS_KRNFROMUSR(arg1, arg2, arg3) \
if ( copy_from_user(&arg1, arg2, arg3) ) \
#define DRM_COPY_FROM_USER_IOCTL(arg1, arg2, arg3) \
if ( copy_from_user(&arg1, arg2, arg3) ) \
return -EFAULT
#define DRM_OS_KRNTOUSR(arg1, arg2, arg3) \
if ( copy_to_user(arg1, &arg2, arg3) ) \
#define DRM_COPY_TO_USER_IOCTL(arg1, arg2, arg3) \
if ( copy_to_user(arg1, &arg2, arg3) ) \
return -EFAULT
/* Other copying of data from/to kernel space */
#define DRM_OS_COPYFROMUSR(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER(arg1, arg2, arg3) \
copy_from_user(arg1, arg2, arg3)
#define DRM_OS_COPYTOUSR(arg1, arg2, arg3) \
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
copy_to_user(arg1, arg2, arg3)
/* Macros for checking readability once */
#define DRM_OS_VERIFYAREA_READ( uaddr, size ) \
/* Macros for copyfrom user, but checking readability only once */
#define DRM_VERIFYAREA_READ( uaddr, size ) \
verify_area( VERIFY_READ, uaddr, size )
#define DRM_OS_COPYFROMUSR_NC(arg1, arg2, arg3) \
#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
__copy_from_user(arg1, arg2, arg3)
#define DRM_OS_FETCHU_32_NC(val, uaddr) \
#define DRM_GET_USER_UNCHECKED(val, uaddr) \
__get_user(val, uaddr)
/* malloc/free without the overhead of DRM(alloc) */
#define DRM_OS_MALLOC(x) kmalloc(x, GFP_KERNEL)
#define DRM_OS_FREE(x) kfree(x)
#define DRM_MALLOC(x) kmalloc(x, GFP_KERNEL)
#define DRM_FREE(x) kfree(x)
#define DRM_OS_GETSAREA() \
#define DRM_GETSAREA() \
do { \
struct list_head *list; \
list_for_each( list, &dev->maplist->head ) { \
@ -56,4 +54,3 @@ do { \
} \
} \
} while (0)

82
shared-core/mga_dma.c
View file

@ -59,14 +59,14 @@ int mga_do_wait_for_idle( drm_mga_private_t *dev_priv )
MGA_WRITE8( MGA_CRTC_INDEX, 0 );
return 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if MGA_DMA_DEBUG
DRM_ERROR( "failed!\n" );
DRM_INFO( " status=0x%08x\n", status );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
int mga_do_dma_idle( drm_mga_private_t *dev_priv )
@ -78,13 +78,13 @@ int mga_do_dma_idle( drm_mga_private_t *dev_priv )
for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
status = MGA_READ( MGA_STATUS ) & MGA_DMA_IDLE_MASK;
if ( status == MGA_ENDPRDMASTS ) return 0;
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if MGA_DMA_DEBUG
DRM_ERROR( "failed! status=0x%08x\n", status );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
int mga_do_dma_reset( drm_mga_private_t *dev_priv )
@ -119,7 +119,7 @@ int mga_do_engine_reset( drm_mga_private_t *dev_priv )
* How about we clean up after ourselves?
*/
MGA_WRITE( MGA_RST, MGA_SOFTRESET );
DRM_OS_DELAY( 15 ); /* Wait at least 10 usecs */
DRM_UDELAY( 15 ); /* Wait at least 10 usecs */
MGA_WRITE( MGA_RST, 0 );
/* Initialize the registers that get clobbered by the soft
@ -302,7 +302,7 @@ static int mga_freelist_init( drm_device_t *dev, drm_mga_private_t *dev_priv )
dev_priv->head = DRM(alloc)( sizeof(drm_mga_freelist_t),
DRM_MEM_DRIVER );
if ( dev_priv->head == NULL )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev_priv->head, 0, sizeof(drm_mga_freelist_t) );
SET_AGE( &dev_priv->head->age, MGA_BUFFER_USED, 0 );
@ -314,7 +314,7 @@ static int mga_freelist_init( drm_device_t *dev, drm_mga_private_t *dev_priv )
entry = DRM(alloc)( sizeof(drm_mga_freelist_t),
DRM_MEM_DRIVER );
if ( entry == NULL )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( entry, 0, sizeof(drm_mga_freelist_t) );
@ -451,7 +451,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
dev_priv = DRM(alloc)( sizeof(drm_mga_private_t), DRM_MEM_DRIVER );
if ( !dev_priv )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev_priv, 0, sizeof(drm_mga_private_t) );
@ -481,14 +481,14 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
dev_priv->texture_offset = init->texture_offset[0];
dev_priv->texture_size = init->texture_size[0];
DRM_OS_GETSAREA();
DRM_GETSAREA();
if(!dev_priv->sarea) {
DRM_ERROR( "failed to find sarea!\n" );
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
@ -497,7 +497,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
if(!dev_priv->mmio) {
@ -505,7 +505,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->status, init->status_offset );
if(!dev_priv->status) {
@ -513,7 +513,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->warp, init->warp_offset );
@ -522,7 +522,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->primary, init->primary_offset );
if(!dev_priv->primary) {
@ -530,7 +530,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->buffers, init->buffers_offset );
if(!dev_priv->buffers) {
@ -538,7 +538,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->sarea_priv =
@ -556,7 +556,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
ret = mga_warp_install_microcode( dev_priv );
@ -618,7 +618,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
/* Make dev_private visable to others. */
@ -649,12 +649,12 @@ int mga_do_cleanup_dma( drm_device_t *dev )
return 0;
}
int mga_dma_init( DRM_OS_IOCTL )
int mga_dma_init( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_init_t init;
DRM_OS_KRNFROMUSR( init, (drm_mga_init_t *)data, sizeof(init) );
DRM_COPY_FROM_USER_IOCTL( init, (drm_mga_init_t *)data, sizeof(init) );
switch ( init.func ) {
case MGA_INIT_DMA:
@ -663,7 +663,7 @@ int mga_dma_init( DRM_OS_IOCTL )
return mga_do_cleanup_dma( dev );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
@ -671,15 +671,15 @@ int mga_dma_init( DRM_OS_IOCTL )
* Primary DMA stream management
*/
int mga_dma_flush( DRM_OS_IOCTL )
int mga_dma_flush( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
drm_lock_t lock;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( lock, (drm_lock_t *)data, sizeof(lock) );
DRM_COPY_FROM_USER_IOCTL( lock, (drm_lock_t *)data, sizeof(lock) );
DRM_DEBUG( "%s%s%s\n",
(lock.flags & _DRM_LOCK_FLUSH) ? "flush, " : "",
@ -706,9 +706,9 @@ int mga_dma_flush( DRM_OS_IOCTL )
}
}
int mga_dma_reset( DRM_OS_IOCTL )
int mga_dma_reset( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
LOCK_TEST_WITH_RETURN( dev );
@ -728,25 +728,25 @@ static int mga_dma_get_buffers( drm_device_t *dev, drm_dma_t *d )
for ( i = d->granted_count ; i < d->request_count ; i++ ) {
buf = mga_freelist_get( dev );
if ( !buf ) return DRM_OS_ERR(EAGAIN);
if ( !buf ) return DRM_ERR(EAGAIN);
buf->pid = DRM_OS_CURRENTPID;
buf->pid = DRM_CURRENTPID;
if ( DRM_OS_COPYTOUSR( &d->request_indices[i],
if ( DRM_COPY_TO_USER( &d->request_indices[i],
&buf->idx, sizeof(buf->idx) ) )
return DRM_OS_ERR(EFAULT);
if ( DRM_OS_COPYTOUSR( &d->request_sizes[i],
return DRM_ERR(EFAULT);
if ( DRM_COPY_TO_USER( &d->request_sizes[i],
&buf->total, sizeof(buf->total) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
d->granted_count++;
}
return 0;
}
int mga_dma_buffers( DRM_OS_IOCTL )
int mga_dma_buffers( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
drm_dma_t d;
@ -754,22 +754,22 @@ int mga_dma_buffers( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( d, (drm_dma_t *)data, sizeof(d) );
DRM_COPY_FROM_USER_IOCTL( d, (drm_dma_t *)data, sizeof(d) );
/* Please don't send us buffers.
*/
if ( d.send_count != 0 ) {
DRM_ERROR( "Process %d trying to send %d buffers via drmDMA\n",
DRM_OS_CURRENTPID, d.send_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.send_count );
return DRM_ERR(EINVAL);
}
/* We'll send you buffers.
*/
if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
DRM_ERROR( "Process %d trying to get %d buffers (of %d max)\n",
DRM_OS_CURRENTPID, d.request_count, dma->buf_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.request_count, dma->buf_count );
return DRM_ERR(EINVAL);
}
WRAP_TEST_WITH_RETURN( dev_priv );
@ -780,7 +780,7 @@ int mga_dma_buffers( DRM_OS_IOCTL )
ret = mga_dma_get_buffers( dev, &d );
}
DRM_OS_KRNTOUSR( (drm_dma_t *)data, d, sizeof(d) );
DRM_COPY_TO_USER_IOCTL( (drm_dma_t *)data, d, sizeof(d) );
return ret;
}

36
shared-core/mga_drv.h
View file

@ -101,10 +101,10 @@ typedef struct drm_mga_private {
} drm_mga_private_t;
/* mga_dma.c */
extern int mga_dma_init( DRM_OS_IOCTL );
extern int mga_dma_flush( DRM_OS_IOCTL );
extern int mga_dma_reset( DRM_OS_IOCTL );
extern int mga_dma_buffers( DRM_OS_IOCTL );
extern int mga_dma_init( DRM_IOCTL_ARGS );
extern int mga_dma_flush( DRM_IOCTL_ARGS );
extern int mga_dma_reset( DRM_IOCTL_ARGS );
extern int mga_dma_buffers( DRM_IOCTL_ARGS );
extern int mga_do_wait_for_idle( drm_mga_private_t *dev_priv );
extern int mga_do_dma_idle( drm_mga_private_t *dev_priv );
@ -119,18 +119,18 @@ extern void mga_do_dma_wrap_end( drm_mga_private_t *dev_priv );
extern int mga_freelist_put( drm_device_t *dev, drm_buf_t *buf );
/* mga_state.c */
extern int mga_dma_clear( DRM_OS_IOCTL );
extern int mga_dma_swap( DRM_OS_IOCTL );
extern int mga_dma_vertex( DRM_OS_IOCTL );
extern int mga_dma_indices( DRM_OS_IOCTL );
extern int mga_dma_iload( DRM_OS_IOCTL );
extern int mga_dma_blit( DRM_OS_IOCTL );
extern int mga_dma_clear( DRM_IOCTL_ARGS );
extern int mga_dma_swap( DRM_IOCTL_ARGS );
extern int mga_dma_vertex( DRM_IOCTL_ARGS );
extern int mga_dma_indices( DRM_IOCTL_ARGS );
extern int mga_dma_iload( DRM_IOCTL_ARGS );
extern int mga_dma_blit( DRM_IOCTL_ARGS );
/* mga_warp.c */
extern int mga_warp_install_microcode( drm_mga_private_t *dev_priv );
extern int mga_warp_init( drm_mga_private_t *dev_priv );
#define mga_flush_write_combine() DRM_OS_WRITEMEMORYBARRIER()
#define mga_flush_write_combine() DRM_WRITEMEMORYBARRIER()
#define MGA_BASE( reg ) ((unsigned long)(dev_priv->mmio->handle))
@ -141,12 +141,12 @@ extern int mga_warp_init( drm_mga_private_t *dev_priv );
#ifdef __alpha__
#define MGA_READ( reg ) (_MGA_READ((u32 *)MGA_ADDR(reg)))
#define MGA_WRITE( reg, val ) do { DRM_OS_WRITEMEMORYBARRIER(); MGA_DEREF( reg ) = val; } while (0)
#define MGA_WRITE8( reg, val ) do { DRM_OS_WRITEMEMORYBARRIER(); MGA_DEREF8( reg ) = val; } while (0)
#define MGA_WRITE( reg, val ) do { DRM_WRITEMEMORYBARRIER(); MGA_DEREF( reg ) = val; } while (0)
#define MGA_WRITE8( reg, val ) do { DRM_WRITEMEMORYBARRIER(); MGA_DEREF8( reg ) = val; } while (0)
static inline u32 _MGA_READ(u32 *addr)
{
DRM_OS_READMEMORYBARRIER();
DRM_READMEMORYBARRIER();
return *(volatile u32 *)addr;
}
@ -186,10 +186,10 @@ do { \
#define LOCK_TEST_WITH_RETURN( dev ) \
do { \
if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \
dev->lock.pid != DRM_OS_CURRENTPID ) { \
dev->lock.pid != DRM_CURRENTPID ) { \
DRM_ERROR( "%s called without lock held\n", \
__func__ ); \
return DRM_OS_ERR(EINVAL); \
return DRM_ERR(EINVAL); \
} \
} while (0)
@ -202,7 +202,7 @@ do { \
dev_priv->prim.high_mark ) { \
if ( MGA_DMA_DEBUG ) \
DRM_INFO( "%s: wrap...\n", __func__ ); \
return DRM_OS_ERR(EBUSY); \
return DRM_ERR(EBUSY); \
} \
} \
} while (0)
@ -213,7 +213,7 @@ do { \
if ( mga_do_wait_for_idle( dev_priv ) < 0 ) { \
if ( MGA_DMA_DEBUG ) \
DRM_INFO( "%s: wrap...\n", __func__ ); \
return DRM_OS_ERR(EBUSY); \
return DRM_ERR(EBUSY); \
} \
mga_do_dma_wrap_end( dev_priv ); \
} \

60
shared-core/mga_state.c
View file

@ -421,7 +421,7 @@ static int mga_verify_context( drm_mga_private_t *dev_priv )
ctx->dstorg, dev_priv->front_offset,
dev_priv->back_offset );
ctx->dstorg = 0;
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
return 0;
@ -441,7 +441,7 @@ static int mga_verify_tex( drm_mga_private_t *dev_priv, int unit )
DRM_ERROR( "*** bad TEXORG: 0x%x, unit %d\n",
tex->texorg, unit );
tex->texorg = 0;
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
return 0;
@ -483,13 +483,13 @@ static int mga_verify_iload( drm_mga_private_t *dev_priv,
dstorg + length > (dev_priv->texture_offset +
dev_priv->texture_size) ) {
DRM_ERROR( "*** bad iload DSTORG: 0x%x\n", dstorg );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( length & MGA_ILOAD_MASK ) {
DRM_ERROR( "*** bad iload length: 0x%x\n",
length & MGA_ILOAD_MASK );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
return 0;
@ -502,7 +502,7 @@ static int mga_verify_blit( drm_mga_private_t *dev_priv,
(dstorg & 0x3) == (MGA_SRCACC_PCI | MGA_SRCMAP_SYSMEM) ) {
DRM_ERROR( "*** bad blit: src=0x%x dst=0x%x\n",
srcorg, dstorg );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
return 0;
}
@ -881,16 +881,16 @@ static void mga_dma_dispatch_blit( drm_device_t *dev,
*
*/
int mga_dma_clear( DRM_OS_IOCTL )
int mga_dma_clear( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_mga_clear_t clear;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( clear, (drm_mga_clear_t *)data, sizeof(clear) );
DRM_COPY_FROM_USER_IOCTL( clear, (drm_mga_clear_t *)data, sizeof(clear) );
if ( sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS )
sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
@ -906,9 +906,9 @@ int mga_dma_clear( DRM_OS_IOCTL )
return 0;
}
int mga_dma_swap( DRM_OS_IOCTL )
int mga_dma_swap( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
@ -928,9 +928,9 @@ int mga_dma_swap( DRM_OS_IOCTL )
return 0;
}
int mga_dma_vertex( DRM_OS_IOCTL )
int mga_dma_vertex( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -939,11 +939,11 @@ int mga_dma_vertex( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( vertex,
DRM_COPY_FROM_USER_IOCTL( vertex,
(drm_mga_vertex_t *)data,
sizeof(vertex) );
if(vertex.idx < 0 || vertex.idx > dma->buf_count) return DRM_OS_ERR(EINVAL);
if(vertex.idx < 0 || vertex.idx > dma->buf_count) return DRM_ERR(EINVAL);
buf = dma->buflist[vertex.idx];
buf_priv = buf->dev_private;
@ -957,7 +957,7 @@ int mga_dma_vertex( DRM_OS_IOCTL )
buf_priv->dispatched = 0;
mga_freelist_put( dev, buf );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
WRAP_TEST_WITH_RETURN( dev_priv );
@ -967,9 +967,9 @@ int mga_dma_vertex( DRM_OS_IOCTL )
return 0;
}
int mga_dma_indices( DRM_OS_IOCTL )
int mga_dma_indices( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -978,11 +978,11 @@ int mga_dma_indices( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( indices,
DRM_COPY_FROM_USER_IOCTL( indices,
(drm_mga_indices_t *)data,
sizeof(indices) );
if(indices.idx < 0 || indices.idx > dma->buf_count) return DRM_OS_ERR(EINVAL);
if(indices.idx < 0 || indices.idx > dma->buf_count) return DRM_ERR(EINVAL);
buf = dma->buflist[indices.idx];
buf_priv = buf->dev_private;
@ -996,7 +996,7 @@ int mga_dma_indices( DRM_OS_IOCTL )
buf_priv->dispatched = 0;
mga_freelist_put( dev, buf );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
WRAP_TEST_WITH_RETURN( dev_priv );
@ -1006,9 +1006,9 @@ int mga_dma_indices( DRM_OS_IOCTL )
return 0;
}
int mga_dma_iload( DRM_OS_IOCTL )
int mga_dma_iload( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_buf_t *buf;
@ -1018,23 +1018,23 @@ int mga_dma_iload( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( iload, (drm_mga_iload_t *)data, sizeof(iload) );
DRM_COPY_FROM_USER_IOCTL( iload, (drm_mga_iload_t *)data, sizeof(iload) );
#if 0
if ( mga_do_wait_for_idle( dev_priv ) < 0 ) {
if ( MGA_DMA_DEBUG )
DRM_INFO( "%s: -EBUSY\n", __func__ );
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
#endif
if(iload.idx < 0 || iload.idx > dma->buf_count) return DRM_OS_ERR(EINVAL);
if(iload.idx < 0 || iload.idx > dma->buf_count) return DRM_ERR(EINVAL);
buf = dma->buflist[iload.idx];
buf_priv = buf->dev_private;
if ( mga_verify_iload( dev_priv, iload.dstorg, iload.length ) ) {
mga_freelist_put( dev, buf );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
WRAP_TEST_WITH_RETURN( dev_priv );
@ -1048,9 +1048,9 @@ int mga_dma_iload( DRM_OS_IOCTL )
return 0;
}
int mga_dma_blit( DRM_OS_IOCTL )
int mga_dma_blit( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_mga_blit_t blit;
@ -1058,13 +1058,13 @@ int mga_dma_blit( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( blit, (drm_mga_blit_t *)data, sizeof(blit) );
DRM_COPY_FROM_USER_IOCTL( blit, (drm_mga_blit_t *)data, sizeof(blit) );
if ( sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS )
sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
if ( mga_verify_blit( dev_priv, blit.srcorg, blit.dstorg ) )
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
WRAP_TEST_WITH_RETURN( dev_priv );

10
shared-core/mga_warp.c
View file

@ -107,7 +107,7 @@ static int mga_warp_install_g400_microcode( drm_mga_private_t *dev_priv )
if ( size > dev_priv->warp->size ) {
DRM_ERROR( "microcode too large! (%u > %lu)\n",
size, dev_priv->warp->size );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( dev_priv->warp_pipe_phys, 0,
@ -144,7 +144,7 @@ static int mga_warp_install_g200_microcode( drm_mga_private_t *dev_priv )
if ( size > dev_priv->warp->size ) {
DRM_ERROR( "microcode too large! (%u > %lu)\n",
size, dev_priv->warp->size );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( dev_priv->warp_pipe_phys, 0,
@ -170,7 +170,7 @@ int mga_warp_install_microcode( drm_mga_private_t *dev_priv )
case MGA_CARD_TYPE_G200:
return mga_warp_install_g200_microcode( dev_priv );
default:
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
}
@ -195,7 +195,7 @@ int mga_warp_init( drm_mga_private_t *dev_priv )
MGA_WRITE( MGA_WVRTXSZ, 7 );
break;
default:
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
MGA_WRITE( MGA_WMISC, (MGA_WUCODECACHE_ENABLE |
@ -205,7 +205,7 @@ int mga_warp_init( drm_mga_private_t *dev_priv )
if ( wmisc != WMISC_EXPECTED ) {
DRM_ERROR( "WARP engine config failed! 0x%x != 0x%x\n",
wmisc, WMISC_EXPECTED );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
return 0;

122
shared-core/r128_cce.c
View file

@ -126,13 +126,13 @@ static int r128_do_pixcache_flush( drm_r128_private_t *dev_priv )
if ( !(R128_READ( R128_PC_NGUI_CTLSTAT ) & R128_PC_BUSY) ) {
return 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if R128_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
static int r128_do_wait_for_fifo( drm_r128_private_t *dev_priv, int entries )
@ -142,13 +142,13 @@ static int r128_do_wait_for_fifo( drm_r128_private_t *dev_priv, int entries )
for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
int slots = R128_READ( R128_GUI_STAT ) & R128_GUI_FIFOCNT_MASK;
if ( slots >= entries ) return 0;
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if R128_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
int r128_do_wait_for_idle( drm_r128_private_t *dev_priv )
@ -163,13 +163,13 @@ int r128_do_wait_for_idle( drm_r128_private_t *dev_priv )
r128_do_pixcache_flush( dev_priv );
return 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if R128_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
@ -223,14 +223,14 @@ int r128_do_cce_idle( drm_r128_private_t *dev_priv )
return r128_do_pixcache_flush( dev_priv );
}
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if R128_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
r128_status( dev_priv );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
/* Start the Concurrent Command Engine.
@ -378,7 +378,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
dev_priv = DRM(alloc)( sizeof(drm_r128_private_t), DRM_MEM_DRIVER );
if ( dev_priv == NULL )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev_priv, 0, sizeof(drm_r128_private_t) );
@ -388,7 +388,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_ERROR( "PCI GART memory not allocated!\n" );
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->usec_timeout = init->usec_timeout;
@ -397,7 +397,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_DEBUG( "TIMEOUT problem!\n" );
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->cce_mode = init->cce_mode;
@ -417,7 +417,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_DEBUG( "Bad cce_mode!\n" );
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
switch ( init->cce_mode ) {
@ -479,13 +479,13 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
dev_priv->span_pitch_offset_c = (((dev_priv->depth_pitch/8) << 21) |
(dev_priv->span_offset >> 5));
DRM_OS_GETSAREA();
DRM_GETSAREA();
if(!dev_priv->sarea) {
DRM_ERROR("could not find sarea!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
@ -493,35 +493,35 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_ERROR("could not find framebuffer!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
if(!dev_priv->mmio) {
DRM_ERROR("could not find mmio region!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->cce_ring, init->ring_offset );
if(!dev_priv->cce_ring) {
DRM_ERROR("could not find cce ring region!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->ring_rptr, init->ring_rptr_offset );
if(!dev_priv->ring_rptr) {
DRM_ERROR("could not find ring read pointer!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->buffers, init->buffers_offset );
if(!dev_priv->buffers) {
DRM_ERROR("could not find dma buffer region!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( !dev_priv->is_pci ) {
@ -531,7 +531,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_ERROR("could not find agp texture region!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
}
@ -549,7 +549,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_ERROR("Could not ioremap agp regions!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
} else {
dev_priv->cce_ring->handle =
@ -594,7 +594,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_ERROR( "failed to init PCI GART!\n" );
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
R128_WRITE( R128_PCI_GART_PAGE, dev_priv->bus_pci_gart );
}
@ -638,14 +638,14 @@ int r128_do_cleanup_cce( drm_device_t *dev )
return 0;
}
int r128_cce_init( DRM_OS_IOCTL )
int r128_cce_init( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_init_t init;
DRM_DEBUG( "\n" );
DRM_OS_KRNFROMUSR( init, (drm_r128_init_t *)data, sizeof(init) );
DRM_COPY_FROM_USER_IOCTL( init, (drm_r128_init_t *)data, sizeof(init) );
switch ( init.func ) {
case R128_INIT_CCE:
@ -654,12 +654,12 @@ int r128_cce_init( DRM_OS_IOCTL )
return r128_do_cleanup_cce( dev );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
int r128_cce_start( DRM_OS_IOCTL )
int r128_cce_start( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -678,9 +678,9 @@ int r128_cce_start( DRM_OS_IOCTL )
/* Stop the CCE. The engine must have been idled before calling this
* routine.
*/
int r128_cce_stop( DRM_OS_IOCTL )
int r128_cce_stop( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_cce_stop_t stop;
int ret;
@ -688,7 +688,7 @@ int r128_cce_stop( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR(stop, (drm_r128_cce_stop_t *)data, sizeof(stop) );
DRM_COPY_FROM_USER_IOCTL(stop, (drm_r128_cce_stop_t *)data, sizeof(stop) );
/* Flush any pending CCE commands. This ensures any outstanding
* commands are exectuted by the engine before we turn it off.
@ -719,9 +719,9 @@ int r128_cce_stop( DRM_OS_IOCTL )
/* Just reset the CCE ring. Called as part of an X Server engine reset.
*/
int r128_cce_reset( DRM_OS_IOCTL )
int r128_cce_reset( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -729,7 +729,7 @@ int r128_cce_reset( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_DEBUG( "%s called before init done\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
r128_do_cce_reset( dev_priv );
@ -740,9 +740,9 @@ int r128_cce_reset( DRM_OS_IOCTL )
return 0;
}
int r128_cce_idle( DRM_OS_IOCTL )
int r128_cce_idle( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -755,9 +755,9 @@ int r128_cce_idle( DRM_OS_IOCTL )
return r128_do_cce_idle( dev_priv );
}
int r128_engine_reset( DRM_OS_IOCTL )
int r128_engine_reset( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
DRM_DEBUG( "\n" );
LOCK_TEST_WITH_RETURN( dev );
@ -802,14 +802,14 @@ int r128_do_cleanup_pageflip( drm_device_t *dev )
return 0;
}
int r128_fullscreen( DRM_OS_IOCTL )
int r128_fullscreen( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_fullscreen_t fs;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( fs, (drm_r128_fullscreen_t *)data, sizeof(fs) );
DRM_COPY_FROM_USER_IOCTL( fs, (drm_r128_fullscreen_t *)data, sizeof(fs) );
switch ( fs.func ) {
case R128_INIT_FULLSCREEN:
@ -818,7 +818,7 @@ int r128_fullscreen( DRM_OS_IOCTL )
return r128_do_cleanup_pageflip( dev );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
@ -841,7 +841,7 @@ static int r128_freelist_init( drm_device_t *dev )
dev_priv->head = DRM(alloc)( sizeof(drm_r128_freelist_t),
DRM_MEM_DRIVER );
if ( dev_priv->head == NULL )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev_priv->head, 0, sizeof(drm_r128_freelist_t) );
dev_priv->head->age = R128_BUFFER_USED;
@ -852,7 +852,7 @@ static int r128_freelist_init( drm_device_t *dev )
entry = DRM(alloc)( sizeof(drm_r128_freelist_t),
DRM_MEM_DRIVER );
if ( !entry ) return DRM_OS_ERR(ENOMEM);
if ( !entry ) return DRM_ERR(ENOMEM);
entry->age = R128_BUFFER_FREE;
entry->buf = buf;
@ -907,7 +907,7 @@ drm_buf_t *r128_freelist_get( drm_device_t *dev )
return buf;
}
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
DRM_ERROR( "returning NULL!\n" );
@ -940,12 +940,12 @@ int r128_wait_ring( drm_r128_private_t *dev_priv, int n )
r128_update_ring_snapshot( ring );
if ( ring->space >= n )
return 0;
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
/* FIXME: This is being ignored... */
DRM_ERROR( "failed!\n" );
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
static int r128_cce_get_buffers( drm_device_t *dev, drm_dma_t *d )
@ -955,47 +955,47 @@ static int r128_cce_get_buffers( drm_device_t *dev, drm_dma_t *d )
for ( i = d->granted_count ; i < d->request_count ; i++ ) {
buf = r128_freelist_get( dev );
if ( !buf ) return DRM_OS_ERR(EAGAIN);
if ( !buf ) return DRM_ERR(EAGAIN);
buf->pid = DRM_OS_CURRENTPID;
buf->pid = DRM_CURRENTPID;
if ( DRM_OS_COPYTOUSR( &d->request_indices[i], &buf->idx,
if ( DRM_COPY_TO_USER( &d->request_indices[i], &buf->idx,
sizeof(buf->idx) ) )
return DRM_OS_ERR(EFAULT);
if ( DRM_OS_COPYTOUSR( &d->request_sizes[i], &buf->total,
return DRM_ERR(EFAULT);
if ( DRM_COPY_TO_USER( &d->request_sizes[i], &buf->total,
sizeof(buf->total) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
d->granted_count++;
}
return 0;
}
int r128_cce_buffers( DRM_OS_IOCTL )
int r128_cce_buffers( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
int ret = 0;
drm_dma_t d;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( d, (drm_dma_t *) data, sizeof(d) );
DRM_COPY_FROM_USER_IOCTL( d, (drm_dma_t *) data, sizeof(d) );
/* Please don't send us buffers.
*/
if ( d.send_count != 0 ) {
DRM_ERROR( "Process %d trying to send %d buffers via drmDMA\n",
DRM_OS_CURRENTPID, d.send_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.send_count );
return DRM_ERR(EINVAL);
}
/* We'll send you buffers.
*/
if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
DRM_ERROR( "Process %d trying to get %d buffers (of %d max)\n",
DRM_OS_CURRENTPID, d.request_count, dma->buf_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.request_count, dma->buf_count );
return DRM_ERR(EINVAL);
}
d.granted_count = 0;
@ -1004,7 +1004,7 @@ int r128_cce_buffers( DRM_OS_IOCTL )
ret = r128_cce_get_buffers( dev, &d );
}
DRM_OS_KRNTOUSR((drm_dma_t *) data, d, sizeof(d) );
DRM_COPY_TO_USER_IOCTL((drm_dma_t *) data, d, sizeof(d) );
return ret;
}

54
shared-core/r128_drv.h
View file

@ -34,8 +34,8 @@
#ifndef __R128_DRV_H__
#define __R128_DRV_H__
#define GET_RING_HEAD(ring) DRM_OS_READ32( (volatile u32 *) (ring)->head )
#define SET_RING_HEAD(ring,val) DRM_OS_WRITE32( (volatile u32 *) (ring)->head, (val) )
#define GET_RING_HEAD(ring) DRM_READ32( (volatile u32 *) (ring)->head )
#define SET_RING_HEAD(ring,val) DRM_WRITE32( (volatile u32 *) (ring)->head, (val) )
typedef struct drm_r128_freelist {
unsigned int age;
@ -116,14 +116,14 @@ typedef struct drm_r128_buf_priv {
} drm_r128_buf_priv_t;
/* r128_cce.c */
extern int r128_cce_init( DRM_OS_IOCTL );
extern int r128_cce_start( DRM_OS_IOCTL );
extern int r128_cce_stop( DRM_OS_IOCTL );
extern int r128_cce_reset( DRM_OS_IOCTL );
extern int r128_cce_idle( DRM_OS_IOCTL );
extern int r128_engine_reset( DRM_OS_IOCTL );
extern int r128_fullscreen( DRM_OS_IOCTL );
extern int r128_cce_buffers( DRM_OS_IOCTL );
extern int r128_cce_init( DRM_IOCTL_ARGS );
extern int r128_cce_start( DRM_IOCTL_ARGS );
extern int r128_cce_stop( DRM_IOCTL_ARGS );
extern int r128_cce_reset( DRM_IOCTL_ARGS );
extern int r128_cce_idle( DRM_IOCTL_ARGS );
extern int r128_engine_reset( DRM_IOCTL_ARGS );
extern int r128_fullscreen( DRM_IOCTL_ARGS );
extern int r128_cce_buffers( DRM_IOCTL_ARGS );
extern void r128_freelist_reset( drm_device_t *dev );
extern drm_buf_t *r128_freelist_get( drm_device_t *dev );
@ -143,14 +143,14 @@ extern int r128_do_cleanup_cce( drm_device_t *dev );
extern int r128_do_cleanup_pageflip( drm_device_t *dev );
/* r128_state.c */
extern int r128_cce_clear( DRM_OS_IOCTL );
extern int r128_cce_swap( DRM_OS_IOCTL );
extern int r128_cce_vertex( DRM_OS_IOCTL );
extern int r128_cce_indices( DRM_OS_IOCTL );
extern int r128_cce_blit( DRM_OS_IOCTL );
extern int r128_cce_depth( DRM_OS_IOCTL );
extern int r128_cce_stipple( DRM_OS_IOCTL );
extern int r128_cce_indirect( DRM_OS_IOCTL );
extern int r128_cce_clear( DRM_IOCTL_ARGS );
extern int r128_cce_swap( DRM_IOCTL_ARGS );
extern int r128_cce_vertex( DRM_IOCTL_ARGS );
extern int r128_cce_indices( DRM_IOCTL_ARGS );
extern int r128_cce_blit( DRM_IOCTL_ARGS );
extern int r128_cce_depth( DRM_IOCTL_ARGS );
extern int r128_cce_stipple( DRM_IOCTL_ARGS );
extern int r128_cce_indirect( DRM_IOCTL_ARGS );
/* Register definitions, register access macros and drmAddMap constants
@ -368,11 +368,11 @@ extern int r128_cce_indirect( DRM_OS_IOCTL );
#define R128_BASE(reg) ((unsigned long)(dev_priv->mmio->handle))
#define R128_ADDR(reg) (R128_BASE( reg ) + reg)
#define R128_READ(reg) DRM_OS_READ32( (volatile u32 *) R128_ADDR(reg) )
#define R128_WRITE(reg,val) DRM_OS_WRITE32( (volatile u32 *) R128_ADDR(reg), (val) )
#define R128_READ(reg) DRM_READ32( (volatile u32 *) R128_ADDR(reg) )
#define R128_WRITE(reg,val) DRM_WRITE32( (volatile u32 *) R128_ADDR(reg), (val) )
#define R128_READ8(reg) DRM_OS_READ8( (volatile u8 *) R128_ADDR(reg) )
#define R128_WRITE8(reg,val) DRM_OS_WRITE8( (volatile u8 *) R128_ADDR(reg), (val) )
#define R128_READ8(reg) DRM_READ8( (volatile u8 *) R128_ADDR(reg) )
#define R128_WRITE8(reg,val) DRM_WRITE8( (volatile u8 *) R128_ADDR(reg), (val) )
#define R128_WRITE_PLL(addr,val) \
do { \
@ -400,9 +400,9 @@ extern int R128_READ_PLL(drm_device_t *dev, int addr);
#define LOCK_TEST_WITH_RETURN( dev ) \
do { \
if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \
dev->lock.pid != DRM_OS_CURRENTPID ) { \
dev->lock.pid != DRM_CURRENTPID ) { \
DRM_ERROR( "%s called without lock held\n", __func__ ); \
return DRM_OS_ERR(EINVAL); \
return DRM_ERR(EINVAL); \
} \
} while (0)
@ -414,10 +414,10 @@ do { \
r128_update_ring_snapshot( ring ); \
if ( ring->space >= ring->high_mark ) \
goto __ring_space_done; \
DRM_OS_DELAY(1); \
DRM_UDELAY(1); \
} \
DRM_ERROR( "ring space check failed!\n" ); \
return DRM_OS_ERR(EBUSY); \
return DRM_ERR(EBUSY); \
} \
__ring_space_done: \
; \
@ -447,7 +447,7 @@ do { \
#if defined(__powerpc__)
#define r128_flush_write_combine() (void) GET_RING_HEAD( &dev_priv->ring )
#else
#define r128_flush_write_combine() DRM_OS_WRITEMEMORYBARRIER()
#define r128_flush_write_combine() DRM_WRITEMEMORYBARRIER()
#endif

264
shared-core/r128_state.c
View file

@ -809,7 +809,7 @@ static int r128_cce_dispatch_blit( drm_device_t *dev,
break;
default:
DRM_ERROR( "invalid blit format %d\n", blit->format );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
/* Flush the pixel cache, and mark the contents as Read Invalid.
@ -829,14 +829,14 @@ static int r128_cce_dispatch_blit( drm_device_t *dev,
buf = dma->buflist[blit->idx];
buf_priv = buf->dev_private;
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", blit->idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf_priv->discard = 1;
@ -901,33 +901,33 @@ static int r128_cce_dispatch_write_span( drm_device_t *dev,
DRM_DEBUG( "\n" );
count = depth->n;
if ( DRM_OS_COPYFROMUSR( &x, depth->x, sizeof(x) ) ) {
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &x, depth->x, sizeof(x) ) ) {
return DRM_ERR(EFAULT);
}
if ( DRM_OS_COPYFROMUSR( &y, depth->y, sizeof(y) ) ) {
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &y, depth->y, sizeof(y) ) ) {
return DRM_ERR(EFAULT);
}
buffer = DRM_OS_MALLOC( depth->n * sizeof(u32) );
buffer = DRM_MALLOC( depth->n * sizeof(u32) );
if ( buffer == NULL )
return DRM_OS_ERR(ENOMEM);
if ( DRM_OS_COPYFROMUSR( buffer, depth->buffer,
return DRM_ERR(ENOMEM);
if ( DRM_COPY_FROM_USER( buffer, depth->buffer,
depth->n * sizeof(u32) ) ) {
DRM_OS_FREE( buffer );
return DRM_OS_ERR(EFAULT);
DRM_FREE( buffer );
return DRM_ERR(EFAULT);
}
if ( depth->mask ) {
mask = DRM_OS_MALLOC( depth->n * sizeof(u8) );
mask = DRM_MALLOC( depth->n * sizeof(u8) );
if ( mask == NULL ) {
DRM_OS_FREE( buffer );
return DRM_OS_ERR(ENOMEM);
DRM_FREE( buffer );
return DRM_ERR(ENOMEM);
}
if ( DRM_OS_COPYFROMUSR( mask, depth->mask,
if ( DRM_COPY_FROM_USER( mask, depth->mask,
depth->n * sizeof(u8) ) ) {
DRM_OS_FREE( buffer );
DRM_OS_FREE( mask );
return DRM_OS_ERR(EFAULT);
DRM_FREE( buffer );
DRM_FREE( mask );
return DRM_ERR(EFAULT);
}
for ( i = 0 ; i < count ; i++, x++ ) {
@ -953,7 +953,7 @@ static int r128_cce_dispatch_write_span( drm_device_t *dev,
}
}
DRM_OS_FREE( mask );
DRM_FREE( mask );
} else {
for ( i = 0 ; i < count ; i++, x++ ) {
BEGIN_RING( 6 );
@ -977,7 +977,7 @@ static int r128_cce_dispatch_write_span( drm_device_t *dev,
}
}
DRM_OS_FREE( buffer );
DRM_FREE( buffer );
return 0;
}
@ -995,55 +995,55 @@ static int r128_cce_dispatch_write_pixels( drm_device_t *dev,
count = depth->n;
x = DRM_OS_MALLOC( count * sizeof(*x) );
x = DRM_MALLOC( count * sizeof(*x) );
if ( x == NULL ) {
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
y = DRM_OS_MALLOC( count * sizeof(*y) );
y = DRM_MALLOC( count * sizeof(*y) );
if ( y == NULL ) {
DRM_OS_FREE( x );
return DRM_OS_ERR(ENOMEM);
DRM_FREE( x );
return DRM_ERR(ENOMEM);
}
if ( DRM_OS_COPYFROMUSR( x, depth->x, count * sizeof(int) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( x, depth->x, count * sizeof(int) ) ) {
DRM_FREE( x );
DRM_FREE( y );
return DRM_ERR(EFAULT);
}
if ( DRM_OS_COPYFROMUSR( y, depth->y, count * sizeof(int) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( y, depth->y, count * sizeof(int) ) ) {
DRM_FREE( x );
DRM_FREE( y );
return DRM_ERR(EFAULT);
}
buffer = DRM_OS_MALLOC( depth->n * sizeof(u32) );
buffer = DRM_MALLOC( depth->n * sizeof(u32) );
if ( buffer == NULL ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
return DRM_OS_ERR(ENOMEM);
DRM_FREE( x );
DRM_FREE( y );
return DRM_ERR(ENOMEM);
}
if ( DRM_OS_COPYFROMUSR( buffer, depth->buffer,
if ( DRM_COPY_FROM_USER( buffer, depth->buffer,
depth->n * sizeof(u32) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
DRM_OS_FREE( buffer );
return DRM_OS_ERR(EFAULT);
DRM_FREE( x );
DRM_FREE( y );
DRM_FREE( buffer );
return DRM_ERR(EFAULT);
}
if ( depth->mask ) {
mask = DRM_OS_MALLOC( depth->n * sizeof(u8) );
mask = DRM_MALLOC( depth->n * sizeof(u8) );
if ( mask == NULL ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
DRM_OS_FREE( buffer );
return DRM_OS_ERR(ENOMEM);
DRM_FREE( x );
DRM_FREE( y );
DRM_FREE( buffer );
return DRM_ERR(ENOMEM);
}
if ( DRM_OS_COPYFROMUSR( mask, depth->mask,
if ( DRM_COPY_FROM_USER( mask, depth->mask,
depth->n * sizeof(u8) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
DRM_OS_FREE( buffer );
DRM_OS_FREE( mask );
return DRM_OS_ERR(EFAULT);
DRM_FREE( x );
DRM_FREE( y );
DRM_FREE( buffer );
DRM_FREE( mask );
return DRM_ERR(EFAULT);
}
for ( i = 0 ; i < count ; i++ ) {
@ -1069,7 +1069,7 @@ static int r128_cce_dispatch_write_pixels( drm_device_t *dev,
}
}
DRM_OS_FREE( mask );
DRM_FREE( mask );
} else {
for ( i = 0 ; i < count ; i++ ) {
BEGIN_RING( 6 );
@ -1093,9 +1093,9 @@ static int r128_cce_dispatch_write_pixels( drm_device_t *dev,
}
}
DRM_OS_FREE( x );
DRM_OS_FREE( y );
DRM_OS_FREE( buffer );
DRM_FREE( x );
DRM_FREE( y );
DRM_FREE( buffer );
return 0;
}
@ -1109,11 +1109,11 @@ static int r128_cce_dispatch_read_span( drm_device_t *dev,
DRM_DEBUG( "\n" );
count = depth->n;
if ( DRM_OS_COPYFROMUSR( &x, depth->x, sizeof(x) ) ) {
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &x, depth->x, sizeof(x) ) ) {
return DRM_ERR(EFAULT);
}
if ( DRM_OS_COPYFROMUSR( &y, depth->y, sizeof(y) ) ) {
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &y, depth->y, sizeof(y) ) ) {
return DRM_ERR(EFAULT);
}
BEGIN_RING( 7 );
@ -1155,24 +1155,24 @@ static int r128_cce_dispatch_read_pixels( drm_device_t *dev,
count = dev_priv->depth_pitch;
}
x = DRM_OS_MALLOC( count * sizeof(*x) );
x = DRM_MALLOC( count * sizeof(*x) );
if ( x == NULL ) {
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
y = DRM_OS_MALLOC( count * sizeof(*y) );
y = DRM_MALLOC( count * sizeof(*y) );
if ( y == NULL ) {
DRM_OS_FREE( x );
return DRM_OS_ERR(ENOMEM);
DRM_FREE( x );
return DRM_ERR(ENOMEM);
}
if ( DRM_OS_COPYFROMUSR( x, depth->x, count * sizeof(int) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( x, depth->x, count * sizeof(int) ) ) {
DRM_FREE( x );
DRM_FREE( y );
return DRM_ERR(EFAULT);
}
if ( DRM_OS_COPYFROMUSR( y, depth->y, count * sizeof(int) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( y, depth->y, count * sizeof(int) ) ) {
DRM_FREE( x );
DRM_FREE( y );
return DRM_ERR(EFAULT);
}
for ( i = 0 ; i < count ; i++ ) {
@ -1199,8 +1199,8 @@ static int r128_cce_dispatch_read_pixels( drm_device_t *dev,
ADVANCE_RING();
}
DRM_OS_FREE( x );
DRM_OS_FREE( y );
DRM_FREE( x );
DRM_FREE( y );
return 0;
}
@ -1232,9 +1232,9 @@ static void r128_cce_dispatch_stipple( drm_device_t *dev, u32 *stipple )
* IOCTL functions
*/
int r128_cce_clear( DRM_OS_IOCTL )
int r128_cce_clear( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_r128_clear_t clear;
@ -1242,7 +1242,7 @@ int r128_cce_clear( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( clear, (drm_r128_clear_t *) data,
DRM_COPY_FROM_USER_IOCTL( clear, (drm_r128_clear_t *) data,
sizeof(clear) );
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1259,9 +1259,9 @@ int r128_cce_clear( DRM_OS_IOCTL )
return 0;
}
int r128_cce_swap( DRM_OS_IOCTL )
int r128_cce_swap( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
DRM_DEBUG( "%s\n", __func__ );
@ -1284,9 +1284,9 @@ int r128_cce_swap( DRM_OS_IOCTL )
return 0;
}
int r128_cce_vertex( DRM_OS_IOCTL )
int r128_cce_vertex( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -1297,25 +1297,25 @@ int r128_cce_vertex( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( vertex, (drm_r128_vertex_t *) data,
DRM_COPY_FROM_USER_IOCTL( vertex, (drm_r128_vertex_t *) data,
sizeof(vertex) );
DRM_DEBUG( "pid=%d index=%d count=%d discard=%d\n",
DRM_OS_CURRENTPID,
DRM_CURRENTPID,
vertex.idx, vertex.count, vertex.discard );
if ( vertex.idx < 0 || vertex.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
vertex.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( vertex.prim < 0 ||
vertex.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2 ) {
DRM_ERROR( "buffer prim %d\n", vertex.prim );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1324,14 +1324,14 @@ int r128_cce_vertex( DRM_OS_IOCTL )
buf = dma->buflist[vertex.idx];
buf_priv = buf->dev_private;
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", vertex.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf->used = vertex.count;
@ -1343,9 +1343,9 @@ int r128_cce_vertex( DRM_OS_IOCTL )
return 0;
}
int r128_cce_indices( DRM_OS_IOCTL )
int r128_cce_indices( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -1357,24 +1357,24 @@ int r128_cce_indices( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( elts, (drm_r128_indices_t *) data,
DRM_COPY_FROM_USER_IOCTL( elts, (drm_r128_indices_t *) data,
sizeof(elts) );
DRM_DEBUG( "pid=%d buf=%d s=%d e=%d d=%d\n", DRM_OS_CURRENTPID,
DRM_DEBUG( "pid=%d buf=%d s=%d e=%d d=%d\n", DRM_CURRENTPID,
elts.idx, elts.start, elts.end, elts.discard );
if ( elts.idx < 0 || elts.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
elts.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( elts.prim < 0 ||
elts.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2 ) {
DRM_ERROR( "buffer prim %d\n", elts.prim );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1383,14 +1383,14 @@ int r128_cce_indices( DRM_OS_IOCTL )
buf = dma->buflist[elts.idx];
buf_priv = buf->dev_private;
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", elts.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
count = (elts.end - elts.start) / sizeof(u16);
@ -1398,11 +1398,11 @@ int r128_cce_indices( DRM_OS_IOCTL )
if ( elts.start & 0x7 ) {
DRM_ERROR( "misaligned buffer 0x%x\n", elts.start );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( elts.start < buf->used ) {
DRM_ERROR( "no header 0x%x - 0x%x\n", elts.start, buf->used );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf->used = elts.end;
@ -1414,24 +1414,24 @@ int r128_cce_indices( DRM_OS_IOCTL )
return 0;
}
int r128_cce_blit( DRM_OS_IOCTL )
int r128_cce_blit( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_blit_t blit;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( blit, (drm_r128_blit_t *) data,
DRM_COPY_FROM_USER_IOCTL( blit, (drm_r128_blit_t *) data,
sizeof(blit) );
DRM_DEBUG( "pid=%d index=%d\n", DRM_OS_CURRENTPID, blit.idx );
DRM_DEBUG( "pid=%d index=%d\n", DRM_CURRENTPID, blit.idx );
if ( blit.idx < 0 || blit.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
blit.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1440,15 +1440,15 @@ int r128_cce_blit( DRM_OS_IOCTL )
return r128_cce_dispatch_blit( dev, &blit );
}
int r128_cce_depth( DRM_OS_IOCTL )
int r128_cce_depth( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_depth_t depth;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( depth, (drm_r128_depth_t *) data,
DRM_COPY_FROM_USER_IOCTL( depth, (drm_r128_depth_t *) data,
sizeof(depth) );
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1464,24 +1464,24 @@ int r128_cce_depth( DRM_OS_IOCTL )
return r128_cce_dispatch_read_pixels( dev, &depth );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
int r128_cce_stipple( DRM_OS_IOCTL )
int r128_cce_stipple( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_stipple_t stipple;
u32 mask[32];
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( stipple, (drm_r128_stipple_t *) data,
DRM_COPY_FROM_USER_IOCTL( stipple, (drm_r128_stipple_t *) data,
sizeof(stipple) );
if ( DRM_OS_COPYFROMUSR( &mask, stipple.mask,
if ( DRM_COPY_FROM_USER( &mask, stipple.mask,
32 * sizeof(u32) ) )
return DRM_OS_ERR( EFAULT );
return DRM_ERR( EFAULT );
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1490,9 +1490,9 @@ int r128_cce_stipple( DRM_OS_IOCTL )
return 0;
}
int r128_cce_indirect( DRM_OS_IOCTL )
int r128_cce_indirect( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -1506,10 +1506,10 @@ int r128_cce_indirect( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( indirect, (drm_r128_indirect_t *) data,
DRM_COPY_FROM_USER_IOCTL( indirect, (drm_r128_indirect_t *) data,
sizeof(indirect) );
DRM_DEBUG( "indirect: idx=%d s=%d e=%d d=%d\n",
@ -1519,26 +1519,26 @@ int r128_cce_indirect( DRM_OS_IOCTL )
if ( indirect.idx < 0 || indirect.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
indirect.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf = dma->buflist[indirect.idx];
buf_priv = buf->dev_private;
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", indirect.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( indirect.start < buf->used ) {
DRM_ERROR( "reusing indirect: start=0x%x actual=0x%x\n",
indirect.start, buf->used );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );

110
shared-core/radeon_cp.c
View file

@ -354,14 +354,14 @@ static int radeon_do_pixcache_flush( drm_radeon_private_t *dev_priv )
& RADEON_RB2D_DC_BUSY) ) {
return 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if RADEON_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
radeon_status( dev_priv );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
static int radeon_do_wait_for_fifo( drm_radeon_private_t *dev_priv,
@ -373,14 +373,14 @@ static int radeon_do_wait_for_fifo( drm_radeon_private_t *dev_priv,
int slots = ( RADEON_READ( RADEON_RBBM_STATUS )
& RADEON_RBBM_FIFOCNT_MASK );
if ( slots >= entries ) return 0;
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if RADEON_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
radeon_status( dev_priv );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
static int radeon_do_wait_for_idle( drm_radeon_private_t *dev_priv )
@ -396,14 +396,14 @@ static int radeon_do_wait_for_idle( drm_radeon_private_t *dev_priv )
radeon_do_pixcache_flush( dev_priv );
return 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if RADEON_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
radeon_status( dev_priv );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
@ -657,7 +657,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
dev_priv = DRM(alloc)( sizeof(drm_radeon_private_t), DRM_MEM_DRIVER );
if ( dev_priv == NULL )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev_priv, 0, sizeof(drm_radeon_private_t) );
@ -670,7 +670,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR( "PCI GART not yet supported for Radeon!\n" );
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
#endif
@ -678,7 +678,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR( "PCI GART memory not allocated!\n" );
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->usec_timeout = init->usec_timeout;
@ -687,7 +687,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_DEBUG( "TIMEOUT problem!\n" );
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->cp_mode = init->cp_mode;
@ -705,7 +705,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_DEBUG( "BAD cp_mode (%x)!\n", init->cp_mode );
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
switch ( init->fb_bpp ) {
@ -771,13 +771,13 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
RADEON_ROUND_MODE_TRUNC |
RADEON_ROUND_PREC_8TH_PIX);
DRM_OS_GETSAREA();
DRM_GETSAREA();
if(!dev_priv->sarea) {
DRM_ERROR("could not find sarea!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
@ -785,35 +785,35 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR("could not find framebuffer!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
if(!dev_priv->mmio) {
DRM_ERROR("could not find mmio region!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->cp_ring, init->ring_offset );
if(!dev_priv->cp_ring) {
DRM_ERROR("could not find cp ring region!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->ring_rptr, init->ring_rptr_offset );
if(!dev_priv->ring_rptr) {
DRM_ERROR("could not find ring read pointer!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->buffers, init->buffers_offset );
if(!dev_priv->buffers) {
DRM_ERROR("could not find dma buffer region!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( !dev_priv->is_pci ) {
@ -823,7 +823,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR("could not find agp texture region!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
}
@ -841,7 +841,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR("could not find ioremap agp regions!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
} else {
dev_priv->cp_ring->handle =
@ -928,7 +928,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR( "failed to init PCI GART!\n" );
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
/* Turn on PCI GART
*/
@ -1001,12 +1001,12 @@ int radeon_do_cleanup_cp( drm_device_t *dev )
return 0;
}
int radeon_cp_init( DRM_OS_IOCTL )
int radeon_cp_init( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_init_t init;
DRM_OS_KRNFROMUSR( init, (drm_radeon_init_t *)data, sizeof(init) );
DRM_COPY_FROM_USER_IOCTL( init, (drm_radeon_init_t *)data, sizeof(init) );
switch ( init.func ) {
case RADEON_INIT_CP:
@ -1015,12 +1015,12 @@ int radeon_cp_init( DRM_OS_IOCTL )
return radeon_do_cleanup_cp( dev );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
int radeon_cp_start( DRM_OS_IOCTL )
int radeon_cp_start( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -1044,9 +1044,9 @@ int radeon_cp_start( DRM_OS_IOCTL )
/* Stop the CP. The engine must have been idled before calling this
* routine.
*/
int radeon_cp_stop( DRM_OS_IOCTL )
int radeon_cp_stop( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_cp_stop_t stop;
int ret;
@ -1054,7 +1054,7 @@ int radeon_cp_stop( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( stop, (drm_radeon_cp_stop_t *)data, sizeof(stop) );
DRM_COPY_FROM_USER_IOCTL( stop, (drm_radeon_cp_stop_t *)data, sizeof(stop) );
/* Flush any pending CP commands. This ensures any outstanding
* commands are exectuted by the engine before we turn it off.
@ -1085,9 +1085,9 @@ int radeon_cp_stop( DRM_OS_IOCTL )
/* Just reset the CP ring. Called as part of an X Server engine reset.
*/
int radeon_cp_reset( DRM_OS_IOCTL )
int radeon_cp_reset( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -1095,7 +1095,7 @@ int radeon_cp_reset( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_DEBUG( "%s called before init done\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
radeon_do_cp_reset( dev_priv );
@ -1106,9 +1106,9 @@ int radeon_cp_reset( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_idle( DRM_OS_IOCTL )
int radeon_cp_idle( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -1117,9 +1117,9 @@ int radeon_cp_idle( DRM_OS_IOCTL )
return radeon_do_cp_idle( dev_priv );
}
int radeon_engine_reset( DRM_OS_IOCTL )
int radeon_engine_reset( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
DRM_DEBUG( "\n" );
LOCK_TEST_WITH_RETURN( dev );
@ -1134,7 +1134,7 @@ int radeon_engine_reset( DRM_OS_IOCTL )
/* KW: Deprecated to say the least:
*/
int radeon_fullscreen( DRM_OS_IOCTL )
int radeon_fullscreen( DRM_IOCTL_ARGS )
{
return 0;
}
@ -1179,7 +1179,7 @@ drm_buf_t *radeon_freelist_get( drm_device_t *dev )
}
start = 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
DRM_ERROR( "returning NULL!\n" );
@ -1214,7 +1214,7 @@ int radeon_wait_ring( drm_radeon_private_t *dev_priv, int n )
radeon_update_ring_snapshot( ring );
if ( ring->space > n )
return 0;
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
/* FIXME: This return value is ignored in the BEGIN_RING macro! */
@ -1222,7 +1222,7 @@ int radeon_wait_ring( drm_radeon_private_t *dev_priv, int n )
radeon_status( dev_priv );
DRM_ERROR( "failed!\n" );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
static int radeon_cp_get_buffers( drm_device_t *dev, drm_dma_t *d )
@ -1232,47 +1232,47 @@ static int radeon_cp_get_buffers( drm_device_t *dev, drm_dma_t *d )
for ( i = d->granted_count ; i < d->request_count ; i++ ) {
buf = radeon_freelist_get( dev );
if ( !buf ) return DRM_OS_ERR(EAGAIN);
if ( !buf ) return DRM_ERR(EAGAIN);
buf->pid = DRM_OS_CURRENTPID;
buf->pid = DRM_CURRENTPID;
if ( DRM_OS_COPYTOUSR( &d->request_indices[i], &buf->idx,
if ( DRM_COPY_TO_USER( &d->request_indices[i], &buf->idx,
sizeof(buf->idx) ) )
return DRM_OS_ERR(EFAULT);
if ( DRM_OS_COPYTOUSR( &d->request_sizes[i], &buf->total,
return DRM_ERR(EFAULT);
if ( DRM_COPY_TO_USER( &d->request_sizes[i], &buf->total,
sizeof(buf->total) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
d->granted_count++;
}
return 0;
}
int radeon_cp_buffers( DRM_OS_IOCTL )
int radeon_cp_buffers( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
int ret = 0;
drm_dma_t d;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( d, (drm_dma_t *)data, sizeof(d) );
DRM_COPY_FROM_USER_IOCTL( d, (drm_dma_t *)data, sizeof(d) );
/* Please don't send us buffers.
*/
if ( d.send_count != 0 ) {
DRM_ERROR( "Process %d trying to send %d buffers via drmDMA\n",
DRM_OS_CURRENTPID, d.send_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.send_count );
return DRM_ERR(EINVAL);
}
/* We'll send you buffers.
*/
if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
DRM_ERROR( "Process %d trying to get %d buffers (of %d max)\n",
DRM_OS_CURRENTPID, d.request_count, dma->buf_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.request_count, dma->buf_count );
return DRM_ERR(EINVAL);
}
d.granted_count = 0;
@ -1281,7 +1281,7 @@ int radeon_cp_buffers( DRM_OS_IOCTL )
ret = radeon_cp_get_buffers( dev, &d );
}
DRM_OS_KRNTOUSR( (drm_dma_t *)data, d, sizeof(d) );
DRM_COPY_TO_USER_IOCTL( (drm_dma_t *)data, d, sizeof(d) );
return ret;
}

66
shared-core/radeon_drv.h
View file

@ -31,8 +31,8 @@
#ifndef __RADEON_DRV_H__
#define __RADEON_DRV_H__
#define GET_RING_HEAD(ring) DRM_OS_READ32( (volatile u32 *) (ring)->head )
#define SET_RING_HEAD(ring,val) DRM_OS_WRITE32( (volatile u32 *) (ring)->head , (val))
#define GET_RING_HEAD(ring) DRM_READ32( (volatile u32 *) (ring)->head )
#define SET_RING_HEAD(ring,val) DRM_WRITE32( (volatile u32 *) (ring)->head , (val))
typedef struct drm_radeon_freelist {
unsigned int age;
@ -119,14 +119,14 @@ typedef struct drm_radeon_buf_priv {
} drm_radeon_buf_priv_t;
/* radeon_cp.c */
extern int radeon_cp_init( DRM_OS_IOCTL );
extern int radeon_cp_start( DRM_OS_IOCTL );
extern int radeon_cp_stop( DRM_OS_IOCTL );
extern int radeon_cp_reset( DRM_OS_IOCTL );
extern int radeon_cp_idle( DRM_OS_IOCTL );
extern int radeon_engine_reset( DRM_OS_IOCTL );
extern int radeon_fullscreen( DRM_OS_IOCTL );
extern int radeon_cp_buffers( DRM_OS_IOCTL );
extern int radeon_cp_init( DRM_IOCTL_ARGS );
extern int radeon_cp_start( DRM_IOCTL_ARGS );
extern int radeon_cp_stop( DRM_IOCTL_ARGS );
extern int radeon_cp_reset( DRM_IOCTL_ARGS );
extern int radeon_cp_idle( DRM_IOCTL_ARGS );
extern int radeon_engine_reset( DRM_IOCTL_ARGS );
extern int radeon_fullscreen( DRM_IOCTL_ARGS );
extern int radeon_cp_buffers( DRM_IOCTL_ARGS );
extern void radeon_freelist_reset( drm_device_t *dev );
extern drm_buf_t *radeon_freelist_get( drm_device_t *dev );
@ -146,17 +146,17 @@ extern int radeon_do_cleanup_cp( drm_device_t *dev );
extern int radeon_do_cleanup_pageflip( drm_device_t *dev );
/* radeon_state.c */
extern int radeon_cp_clear( DRM_OS_IOCTL );
extern int radeon_cp_swap( DRM_OS_IOCTL );
extern int radeon_cp_vertex( DRM_OS_IOCTL );
extern int radeon_cp_indices( DRM_OS_IOCTL );
extern int radeon_cp_texture( DRM_OS_IOCTL );
extern int radeon_cp_stipple( DRM_OS_IOCTL );
extern int radeon_cp_indirect( DRM_OS_IOCTL );
extern int radeon_cp_vertex2( DRM_OS_IOCTL );
extern int radeon_cp_cmdbuf( DRM_OS_IOCTL );
extern int radeon_cp_getparam( DRM_OS_IOCTL );
extern int radeon_cp_flip( DRM_OS_IOCTL );
extern int radeon_cp_clear( DRM_IOCTL_ARGS );
extern int radeon_cp_swap( DRM_IOCTL_ARGS );
extern int radeon_cp_vertex( DRM_IOCTL_ARGS );
extern int radeon_cp_indices( DRM_IOCTL_ARGS );
extern int radeon_cp_texture( DRM_IOCTL_ARGS );
extern int radeon_cp_stipple( DRM_IOCTL_ARGS );
extern int radeon_cp_indirect( DRM_IOCTL_ARGS );
extern int radeon_cp_vertex2( DRM_IOCTL_ARGS );
extern int radeon_cp_cmdbuf( DRM_IOCTL_ARGS );
extern int radeon_cp_getparam( DRM_IOCTL_ARGS );
extern int radeon_cp_flip( DRM_IOCTL_ARGS );
@ -524,11 +524,11 @@ extern int radeon_cp_flip( DRM_OS_IOCTL );
#define RADEON_BASE(reg) ((unsigned long)(dev_priv->mmio->handle))
#define RADEON_ADDR(reg) (RADEON_BASE( reg ) + reg)
#define RADEON_READ(reg) DRM_OS_READ32( (volatile u32 *) RADEON_ADDR(reg) )
#define RADEON_WRITE(reg,val) DRM_OS_WRITE32( (volatile u32 *) RADEON_ADDR(reg), (val) )
#define RADEON_READ(reg) DRM_READ32( (volatile u32 *) RADEON_ADDR(reg) )
#define RADEON_WRITE(reg,val) DRM_WRITE32( (volatile u32 *) RADEON_ADDR(reg), (val) )
#define RADEON_READ8(reg) DRM_OS_READ8( (volatile u8 *) RADEON_ADDR(reg) )
#define RADEON_WRITE8(reg,val) DRM_OS_WRITE8( (volatile u8 *) RADEON_ADDR(reg), (val) )
#define RADEON_READ8(reg) DRM_READ8( (volatile u8 *) RADEON_ADDR(reg) )
#define RADEON_WRITE8(reg,val) DRM_WRITE8( (volatile u8 *) RADEON_ADDR(reg), (val) )
#define RADEON_WRITE_PLL( addr, val ) \
do { \
@ -608,9 +608,9 @@ extern int RADEON_READ_PLL( drm_device_t *dev, int addr );
#define LOCK_TEST_WITH_RETURN( dev ) \
do { \
if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \
dev->lock.pid != DRM_OS_CURRENTPID ) { \
dev->lock.pid != DRM_CURRENTPID ) { \
DRM_ERROR( "%s called without lock held\n", __func__ ); \
return DRM_OS_ERR(EINVAL); \
return DRM_ERR(EINVAL); \
} \
} while (0)
@ -622,7 +622,7 @@ do { \
radeon_update_ring_snapshot( ring ); \
if ( ring->space >= ring->high_mark ) \
goto __ring_space_done; \
DRM_OS_DELAY( 1 ); \
DRM_UDELAY( 1 ); \
} \
DRM_ERROR( "ring space check from memory failed, reading register...\n" ); \
/* If ring space check fails from RAM, try reading the \
@ -634,7 +634,7 @@ do { \
goto __ring_space_done; \
\
DRM_ERROR( "ring space check failed!\n" ); \
return DRM_OS_ERR(EBUSY); \
return DRM_ERR(EBUSY); \
} \
__ring_space_done: \
; \
@ -736,17 +736,17 @@ do { \
\
if (write + _size > mask) { \
int i = (mask+1) - write; \
if (DRM_OS_COPYFROMUSR_NC( (int *)(ring+write), \
if (DRM_COPY_FROM_USER_UNCHECKED( (int *)(ring+write), \
_tab, i*4 )) \
return DRM_OS_ERR(EFAULT); \
return DRM_ERR(EFAULT); \
write = 0; \
_size -= i; \
_tab += i; \
} \
\
if (_size && DRM_OS_COPYFROMUSR_NC( (int *)(ring+write), \
if (_size && DRM_COPY_FROM_USER_UNCHECKED( (int *)(ring+write), \
_tab, _size*4 )) \
return DRM_OS_ERR(EFAULT); \
return DRM_ERR(EFAULT); \
\
write += _size; \
write &= mask; \

236
shared-core/radeon_state.c
View file

@ -684,7 +684,7 @@ static void radeon_cp_dispatch_vertex( drm_device_t *dev,
do {
/* Emit the next cliprect */
if ( i < nbox ) {
if (DRM_OS_COPYFROMUSR_NC( &box, &boxes[i], sizeof(box) ))
if (DRM_COPY_FROM_USER_UNCHECKED( &box, &boxes[i], sizeof(box) ))
return;
radeon_emit_clip_rect( dev_priv, &box );
@ -817,7 +817,7 @@ static void radeon_cp_dispatch_indices( drm_device_t *dev,
do {
if ( i < nbox ) {
if (DRM_OS_COPYFROMUSR_NC( &box, &boxes[i], sizeof(box) ))
if (DRM_COPY_FROM_USER_UNCHECKED( &box, &boxes[i], sizeof(box) ))
return;
radeon_emit_clip_rect( dev_priv, &box );
@ -851,7 +851,7 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
/* FIXME: Be smarter about this...
*/
buf = radeon_freelist_get( dev );
if ( !buf ) return DRM_OS_ERR(EAGAIN);
if ( !buf ) return DRM_ERR(EAGAIN);
DRM_DEBUG( "tex: ofs=0x%x p=%d f=%d x=%hd y=%hd w=%hd h=%hd\n",
tex->offset >> 10, tex->pitch, tex->format,
@ -884,7 +884,7 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
break;
default:
DRM_ERROR( "invalid texture format %d\n", tex->format );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_DEBUG( " tex=%dx%d blit=%d\n",
@ -922,7 +922,7 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
if ( size > RADEON_MAX_TEXTURE_SIZE ) {
/* Texture image is too large, do a multipass upload */
ret = DRM_OS_ERR(EAGAIN);
ret = DRM_ERR(EAGAIN);
/* Adjust the blit size to fit the indirect buffer */
height = RADEON_MAX_TEXTURE_SIZE / blit_width;
@ -933,9 +933,9 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
image->height -= height;
image->data = (const char *)image->data + size;
if ( DRM_OS_COPYTOUSR( tex->image, image, sizeof(*image) ) ) {
if ( DRM_COPY_TO_USER( tex->image, image, sizeof(*image) ) ) {
DRM_ERROR( "EFAULT on tex->image\n" );
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
}
} else if ( size < 4 && size > 0 ) {
size = 4;
@ -970,9 +970,9 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
/* Texture image width is larger than the minimum, so we
* can upload it directly.
*/
if ( DRM_OS_COPYFROMUSR( buffer, data, dwords * sizeof(u32) ) ) {
if ( DRM_COPY_FROM_USER( buffer, data, dwords * sizeof(u32) ) ) {
DRM_ERROR( "EFAULT on data, %d dwords\n", dwords );
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
}
} else {
/* Texture image width is less than the minimum, so we
@ -980,17 +980,17 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
* width.
*/
for ( i = 0 ; i < tex->height ; i++ ) {
if ( DRM_OS_COPYFROMUSR( buffer, data, tex_width ) ) {
if ( DRM_COPY_FROM_USER( buffer, data, tex_width ) ) {
DRM_ERROR( "EFAULT on pad, %d bytes\n",
tex_width );
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
}
buffer += 8;
data += tex_width;
}
}
buf->pid = DRM_OS_CURRENTPID;
buf->pid = DRM_CURRENTPID;
buf->used = (dwords + 8) * sizeof(u32);
radeon_cp_dispatch_indirect( dev, buf, 0, buf->used );
@ -1035,9 +1035,9 @@ static void radeon_cp_dispatch_stipple( drm_device_t *dev, u32 *stipple )
* IOCTL functions
*/
int radeon_cp_clear( DRM_OS_IOCTL )
int radeon_cp_clear( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_radeon_clear_t clear;
@ -1046,7 +1046,7 @@ int radeon_cp_clear( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( clear, (drm_radeon_clear_t *)data,
DRM_COPY_FROM_USER_IOCTL( clear, (drm_radeon_clear_t *)data,
sizeof(clear) );
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1054,9 +1054,9 @@ int radeon_cp_clear( DRM_OS_IOCTL )
if ( sarea_priv->nbox > RADEON_NR_SAREA_CLIPRECTS )
sarea_priv->nbox = RADEON_NR_SAREA_CLIPRECTS;
if ( DRM_OS_COPYFROMUSR( &depth_boxes, clear.depth_boxes,
if ( DRM_COPY_FROM_USER( &depth_boxes, clear.depth_boxes,
sarea_priv->nbox * sizeof(depth_boxes[0]) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
radeon_cp_dispatch_clear( dev, &clear, depth_boxes );
@ -1104,9 +1104,9 @@ int radeon_do_cleanup_pageflip( drm_device_t *dev )
/* Swapping and flipping are different operations, need different ioctls.
* They can & should be intermixed to support multiple 3d windows.
*/
int radeon_cp_flip( DRM_OS_IOCTL )
int radeon_cp_flip( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -1123,9 +1123,9 @@ int radeon_cp_flip( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_swap( DRM_OS_IOCTL )
int radeon_cp_swap( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
DRM_DEBUG( "\n" );
@ -1144,9 +1144,9 @@ int radeon_cp_swap( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_vertex( DRM_OS_IOCTL )
int radeon_cp_vertex( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_device_dma_t *dma = dev->dma;
@ -1158,25 +1158,25 @@ int radeon_cp_vertex( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( vertex, (drm_radeon_vertex_t *)data,
DRM_COPY_FROM_USER_IOCTL( vertex, (drm_radeon_vertex_t *)data,
sizeof(vertex) );
DRM_DEBUG( "pid=%d index=%d count=%d discard=%d\n",
DRM_OS_CURRENTPID,
DRM_CURRENTPID,
vertex.idx, vertex.count, vertex.discard );
if ( vertex.idx < 0 || vertex.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
vertex.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( vertex.prim < 0 ||
vertex.prim > RADEON_PRIM_TYPE_3VRT_LINE_LIST ) {
DRM_ERROR( "buffer prim %d\n", vertex.prim );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1184,14 +1184,14 @@ int radeon_cp_vertex( DRM_OS_IOCTL )
buf = dma->buflist[vertex.idx];
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", vertex.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
/* Build up a prim_t record:
@ -1230,9 +1230,9 @@ int radeon_cp_vertex( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_indices( DRM_OS_IOCTL )
int radeon_cp_indices( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_device_dma_t *dma = dev->dma;
@ -1245,25 +1245,25 @@ int radeon_cp_indices( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( elts, (drm_radeon_indices_t *)data,
DRM_COPY_FROM_USER_IOCTL( elts, (drm_radeon_indices_t *)data,
sizeof(elts) );
DRM_DEBUG( "pid=%d index=%d start=%d end=%d discard=%d\n",
DRM_OS_CURRENTPID,
DRM_CURRENTPID,
elts.idx, elts.start, elts.end, elts.discard );
if ( elts.idx < 0 || elts.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
elts.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( elts.prim < 0 ||
elts.prim > RADEON_PRIM_TYPE_3VRT_LINE_LIST ) {
DRM_ERROR( "buffer prim %d\n", elts.prim );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1271,14 +1271,14 @@ int radeon_cp_indices( DRM_OS_IOCTL )
buf = dma->buflist[elts.idx];
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", elts.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
count = (elts.end - elts.start) / sizeof(u16);
@ -1286,11 +1286,11 @@ int radeon_cp_indices( DRM_OS_IOCTL )
if ( elts.start & 0x7 ) {
DRM_ERROR( "misaligned buffer 0x%x\n", elts.start );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( elts.start < buf->used ) {
DRM_ERROR( "no header 0x%x - 0x%x\n", elts.start, buf->used );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf->used = elts.end;
@ -1328,9 +1328,9 @@ int radeon_cp_indices( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_texture( DRM_OS_IOCTL )
int radeon_cp_texture( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_texture_t tex;
drm_radeon_tex_image_t image;
@ -1338,17 +1338,17 @@ int radeon_cp_texture( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( tex, (drm_radeon_texture_t *)data, sizeof(tex) );
DRM_COPY_FROM_USER_IOCTL( tex, (drm_radeon_texture_t *)data, sizeof(tex) );
if ( tex.image == NULL ) {
DRM_ERROR( "null texture image!\n" );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( DRM_OS_COPYFROMUSR( &image,
if ( DRM_COPY_FROM_USER( &image,
(drm_radeon_tex_image_t *)tex.image,
sizeof(image) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
RING_SPACE_TEST_WITH_RETURN( dev_priv );
VB_AGE_TEST_WITH_RETURN( dev_priv );
@ -1359,20 +1359,20 @@ int radeon_cp_texture( DRM_OS_IOCTL )
return ret;
}
int radeon_cp_stipple( DRM_OS_IOCTL )
int radeon_cp_stipple( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_stipple_t stipple;
u32 mask[32];
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( stipple, (drm_radeon_stipple_t *)data,
DRM_COPY_FROM_USER_IOCTL( stipple, (drm_radeon_stipple_t *)data,
sizeof(stipple) );
if ( DRM_OS_COPYFROMUSR( &mask, stipple.mask, 32 * sizeof(u32) ) )
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &mask, stipple.mask, 32 * sizeof(u32) ) )
return DRM_ERR(EFAULT);
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1382,9 +1382,9 @@ int radeon_cp_stipple( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_indirect( DRM_OS_IOCTL )
int radeon_cp_indirect( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -1395,10 +1395,10 @@ int radeon_cp_indirect( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( indirect, (drm_radeon_indirect_t *)data,
DRM_COPY_FROM_USER_IOCTL( indirect, (drm_radeon_indirect_t *)data,
sizeof(indirect) );
DRM_DEBUG( "indirect: idx=%d s=%d e=%d d=%d\n",
@ -1408,25 +1408,25 @@ int radeon_cp_indirect( DRM_OS_IOCTL )
if ( indirect.idx < 0 || indirect.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
indirect.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf = dma->buflist[indirect.idx];
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", indirect.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( indirect.start < buf->used ) {
DRM_ERROR( "reusing indirect: start=0x%x actual=0x%x\n",
indirect.start, buf->used );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1457,9 +1457,9 @@ int radeon_cp_indirect( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_vertex2( DRM_OS_IOCTL )
int radeon_cp_vertex2( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_device_dma_t *dma = dev->dma;
@ -1472,20 +1472,20 @@ int radeon_cp_vertex2( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( vertex, (drm_radeon_vertex2_t *)data,
DRM_COPY_FROM_USER_IOCTL( vertex, (drm_radeon_vertex2_t *)data,
sizeof(vertex) );
DRM_DEBUG( "pid=%d index=%d discard=%d\n",
DRM_OS_CURRENTPID,
DRM_CURRENTPID,
vertex.idx, vertex.discard );
if ( vertex.idx < 0 || vertex.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
vertex.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1493,34 +1493,34 @@ int radeon_cp_vertex2( DRM_OS_IOCTL )
buf = dma->buflist[vertex.idx];
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", vertex.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if (sarea_priv->nbox > RADEON_NR_SAREA_CLIPRECTS)
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
for (laststate = 0xff, i = 0 ; i < vertex.nr_prims ; i++) {
drm_radeon_prim_t prim;
drm_radeon_tcl_prim_t tclprim;
if ( DRM_OS_COPYFROMUSR( &prim, &vertex.prim[i], sizeof(prim) ) )
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &prim, &vertex.prim[i], sizeof(prim) ) )
return DRM_ERR(EFAULT);
if ( prim.stateidx != laststate ) {
drm_radeon_state_t state;
if ( DRM_OS_COPYFROMUSR( &state,
if ( DRM_COPY_FROM_USER( &state,
&vertex.state[prim.stateidx],
sizeof(state) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
radeon_emit_state2( dev_priv, &state );
@ -1573,7 +1573,7 @@ static int radeon_emit_packets(
RING_LOCALS;
if (sz * sizeof(int) > cmdbuf->bufsz)
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
BEGIN_RING(sz+1);
OUT_RING( CP_PACKET0( reg, (sz-1) ) );
@ -1642,14 +1642,14 @@ static int radeon_emit_packet3( drm_device_t *dev,
DRM_DEBUG("\n");
if (DRM_OS_FETCHU_32_NC( tmp, &cmd[0]))
return DRM_OS_ERR(EFAULT);
if (DRM_GET_USER_UNCHECKED( tmp, &cmd[0]))
return DRM_ERR(EFAULT);
cmdsz = 2 + ((tmp & RADEON_CP_PACKET_COUNT_MASK) >> 16);
if ((tmp & 0xc0000000) != RADEON_CP_PACKET3 ||
cmdsz * 4 > cmdbuf->bufsz)
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
BEGIN_RING( cmdsz );
OUT_RING_USER_TABLE( cmd, cmdsz );
@ -1674,19 +1674,19 @@ static int radeon_emit_packet3_cliprect( drm_device_t *dev,
DRM_DEBUG("\n");
if (DRM_OS_FETCHU_32_NC( tmp, &cmd[0]))
return DRM_OS_ERR(EFAULT);
if (DRM_GET_USER_UNCHECKED( tmp, &cmd[0]))
return DRM_ERR(EFAULT);
cmdsz = 2 + ((tmp & RADEON_CP_PACKET_COUNT_MASK) >> 16);
if ((tmp & 0xc0000000) != RADEON_CP_PACKET3 ||
cmdsz * 4 > cmdbuf->bufsz)
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
do {
if ( i < cmdbuf->nbox ) {
if (DRM_OS_COPYFROMUSR_NC( &box, &boxes[i], sizeof(box) ))
return DRM_OS_ERR(EFAULT);
if (DRM_COPY_FROM_USER_UNCHECKED( &box, &boxes[i], sizeof(box) ))
return DRM_ERR(EFAULT);
radeon_emit_clip_rect( dev_priv, &box );
}
@ -1706,9 +1706,9 @@ static int radeon_emit_packet3_cliprect( drm_device_t *dev,
int radeon_cp_cmdbuf( DRM_OS_IOCTL )
int radeon_cp_cmdbuf( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf = 0;
@ -1720,30 +1720,30 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( cmdbuf, (drm_radeon_cmd_buffer_t *)data,
DRM_COPY_FROM_USER_IOCTL( cmdbuf, (drm_radeon_cmd_buffer_t *)data,
sizeof(cmdbuf) );
DRM_DEBUG( "pid=%d\n", DRM_OS_CURRENTPID );
DRM_DEBUG( "pid=%d\n", DRM_CURRENTPID );
RING_SPACE_TEST_WITH_RETURN( dev_priv );
VB_AGE_TEST_WITH_RETURN( dev_priv );
if (DRM_OS_VERIFYAREA_READ( cmdbuf.buf, cmdbuf.bufsz ))
return DRM_OS_ERR(EFAULT);
if (DRM_VERIFYAREA_READ( cmdbuf.buf, cmdbuf.bufsz ))
return DRM_ERR(EFAULT);
if (cmdbuf.nbox &&
DRM_OS_VERIFYAREA_READ(cmdbuf.boxes,
DRM_VERIFYAREA_READ(cmdbuf.boxes,
cmdbuf.nbox * sizeof(drm_clip_rect_t)))
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
while ( cmdbuf.bufsz >= sizeof(header) ) {
if (DRM_OS_FETCHU_32_NC( header.i, (int *)cmdbuf.buf )) {
if (DRM_GET_USER_UNCHECKED( header.i, (int *)cmdbuf.buf )) {
DRM_ERROR("__get_user %p\n", cmdbuf.buf);
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
}
cmdbuf.buf += sizeof(header);
@ -1753,21 +1753,21 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
case RADEON_CMD_PACKET:
if (radeon_emit_packets( dev_priv, header, &cmdbuf )) {
DRM_ERROR("radeon_emit_packets failed\n");
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
break;
case RADEON_CMD_SCALARS:
if (radeon_emit_scalars( dev_priv, header, &cmdbuf )) {
DRM_ERROR("radeon_emit_scalars failed\n");
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
break;
case RADEON_CMD_VECTORS:
if (radeon_emit_vectors( dev_priv, header, &cmdbuf )) {
DRM_ERROR("radeon_emit_vectors failed\n");
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
break;
@ -1776,13 +1776,13 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
if ( idx < 0 || idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf = dma->buflist[idx];
if ( buf->pid != DRM_OS_CURRENTPID || buf->pending ) {
if ( buf->pid != DRM_CURRENTPID || buf->pending ) {
DRM_ERROR( "bad buffer\n" );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
radeon_cp_discard_buffer( dev, buf );
@ -1791,14 +1791,14 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
case RADEON_CMD_PACKET3:
if (radeon_emit_packet3( dev, &cmdbuf )) {
DRM_ERROR("radeon_emit_packet3 failed\n");
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
break;
case RADEON_CMD_PACKET3_CLIP:
if (radeon_emit_packet3_cliprect( dev, &cmdbuf )) {
DRM_ERROR("radeon_emit_packet3_clip failed\n");
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
break;
@ -1806,7 +1806,7 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
DRM_ERROR("bad cmd_type %d at %p\n",
header.header.cmd_type,
cmdbuf.buf - sizeof(header));
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
}
@ -1817,34 +1817,34 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
int radeon_cp_getparam( DRM_OS_IOCTL )
int radeon_cp_getparam( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_getparam_t param;
int value;
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( param, (drm_radeon_getparam_t *)data,
DRM_COPY_FROM_USER_IOCTL( param, (drm_radeon_getparam_t *)data,
sizeof(param) );
DRM_DEBUG( "pid=%d\n", DRM_OS_CURRENTPID );
DRM_DEBUG( "pid=%d\n", DRM_CURRENTPID );
switch( param.param ) {
case RADEON_PARAM_AGP_BUFFER_OFFSET:
value = dev_priv->agp_buffers_offset;
break;
default:
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( DRM_OS_COPYTOUSR( param.value, &value, sizeof(int) ) ) {
if ( DRM_COPY_TO_USER( param.value, &value, sizeof(int) ) ) {
DRM_ERROR( "copy_to_user\n" );
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
}
return 0;

82
shared/mga_dma.c
View file

@ -59,14 +59,14 @@ int mga_do_wait_for_idle( drm_mga_private_t *dev_priv )
MGA_WRITE8( MGA_CRTC_INDEX, 0 );
return 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if MGA_DMA_DEBUG
DRM_ERROR( "failed!\n" );
DRM_INFO( " status=0x%08x\n", status );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
int mga_do_dma_idle( drm_mga_private_t *dev_priv )
@ -78,13 +78,13 @@ int mga_do_dma_idle( drm_mga_private_t *dev_priv )
for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
status = MGA_READ( MGA_STATUS ) & MGA_DMA_IDLE_MASK;
if ( status == MGA_ENDPRDMASTS ) return 0;
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if MGA_DMA_DEBUG
DRM_ERROR( "failed! status=0x%08x\n", status );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
int mga_do_dma_reset( drm_mga_private_t *dev_priv )
@ -119,7 +119,7 @@ int mga_do_engine_reset( drm_mga_private_t *dev_priv )
* How about we clean up after ourselves?
*/
MGA_WRITE( MGA_RST, MGA_SOFTRESET );
DRM_OS_DELAY( 15 ); /* Wait at least 10 usecs */
DRM_UDELAY( 15 ); /* Wait at least 10 usecs */
MGA_WRITE( MGA_RST, 0 );
/* Initialize the registers that get clobbered by the soft
@ -302,7 +302,7 @@ static int mga_freelist_init( drm_device_t *dev, drm_mga_private_t *dev_priv )
dev_priv->head = DRM(alloc)( sizeof(drm_mga_freelist_t),
DRM_MEM_DRIVER );
if ( dev_priv->head == NULL )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev_priv->head, 0, sizeof(drm_mga_freelist_t) );
SET_AGE( &dev_priv->head->age, MGA_BUFFER_USED, 0 );
@ -314,7 +314,7 @@ static int mga_freelist_init( drm_device_t *dev, drm_mga_private_t *dev_priv )
entry = DRM(alloc)( sizeof(drm_mga_freelist_t),
DRM_MEM_DRIVER );
if ( entry == NULL )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( entry, 0, sizeof(drm_mga_freelist_t) );
@ -451,7 +451,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
dev_priv = DRM(alloc)( sizeof(drm_mga_private_t), DRM_MEM_DRIVER );
if ( !dev_priv )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev_priv, 0, sizeof(drm_mga_private_t) );
@ -481,14 +481,14 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
dev_priv->texture_offset = init->texture_offset[0];
dev_priv->texture_size = init->texture_size[0];
DRM_OS_GETSAREA();
DRM_GETSAREA();
if(!dev_priv->sarea) {
DRM_ERROR( "failed to find sarea!\n" );
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
@ -497,7 +497,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
if(!dev_priv->mmio) {
@ -505,7 +505,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->status, init->status_offset );
if(!dev_priv->status) {
@ -513,7 +513,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->warp, init->warp_offset );
@ -522,7 +522,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->primary, init->primary_offset );
if(!dev_priv->primary) {
@ -530,7 +530,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->buffers, init->buffers_offset );
if(!dev_priv->buffers) {
@ -538,7 +538,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->sarea_priv =
@ -556,7 +556,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
ret = mga_warp_install_microcode( dev_priv );
@ -618,7 +618,7 @@ static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
/* Assign dev_private so we can do cleanup. */
dev->dev_private = (void *)dev_priv;
mga_do_cleanup_dma( dev );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
/* Make dev_private visable to others. */
@ -649,12 +649,12 @@ int mga_do_cleanup_dma( drm_device_t *dev )
return 0;
}
int mga_dma_init( DRM_OS_IOCTL )
int mga_dma_init( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_init_t init;
DRM_OS_KRNFROMUSR( init, (drm_mga_init_t *)data, sizeof(init) );
DRM_COPY_FROM_USER_IOCTL( init, (drm_mga_init_t *)data, sizeof(init) );
switch ( init.func ) {
case MGA_INIT_DMA:
@ -663,7 +663,7 @@ int mga_dma_init( DRM_OS_IOCTL )
return mga_do_cleanup_dma( dev );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
@ -671,15 +671,15 @@ int mga_dma_init( DRM_OS_IOCTL )
* Primary DMA stream management
*/
int mga_dma_flush( DRM_OS_IOCTL )
int mga_dma_flush( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
drm_lock_t lock;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( lock, (drm_lock_t *)data, sizeof(lock) );
DRM_COPY_FROM_USER_IOCTL( lock, (drm_lock_t *)data, sizeof(lock) );
DRM_DEBUG( "%s%s%s\n",
(lock.flags & _DRM_LOCK_FLUSH) ? "flush, " : "",
@ -706,9 +706,9 @@ int mga_dma_flush( DRM_OS_IOCTL )
}
}
int mga_dma_reset( DRM_OS_IOCTL )
int mga_dma_reset( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
LOCK_TEST_WITH_RETURN( dev );
@ -728,25 +728,25 @@ static int mga_dma_get_buffers( drm_device_t *dev, drm_dma_t *d )
for ( i = d->granted_count ; i < d->request_count ; i++ ) {
buf = mga_freelist_get( dev );
if ( !buf ) return DRM_OS_ERR(EAGAIN);
if ( !buf ) return DRM_ERR(EAGAIN);
buf->pid = DRM_OS_CURRENTPID;
buf->pid = DRM_CURRENTPID;
if ( DRM_OS_COPYTOUSR( &d->request_indices[i],
if ( DRM_COPY_TO_USER( &d->request_indices[i],
&buf->idx, sizeof(buf->idx) ) )
return DRM_OS_ERR(EFAULT);
if ( DRM_OS_COPYTOUSR( &d->request_sizes[i],
return DRM_ERR(EFAULT);
if ( DRM_COPY_TO_USER( &d->request_sizes[i],
&buf->total, sizeof(buf->total) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
d->granted_count++;
}
return 0;
}
int mga_dma_buffers( DRM_OS_IOCTL )
int mga_dma_buffers( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
drm_dma_t d;
@ -754,22 +754,22 @@ int mga_dma_buffers( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( d, (drm_dma_t *)data, sizeof(d) );
DRM_COPY_FROM_USER_IOCTL( d, (drm_dma_t *)data, sizeof(d) );
/* Please don't send us buffers.
*/
if ( d.send_count != 0 ) {
DRM_ERROR( "Process %d trying to send %d buffers via drmDMA\n",
DRM_OS_CURRENTPID, d.send_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.send_count );
return DRM_ERR(EINVAL);
}
/* We'll send you buffers.
*/
if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
DRM_ERROR( "Process %d trying to get %d buffers (of %d max)\n",
DRM_OS_CURRENTPID, d.request_count, dma->buf_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.request_count, dma->buf_count );
return DRM_ERR(EINVAL);
}
WRAP_TEST_WITH_RETURN( dev_priv );
@ -780,7 +780,7 @@ int mga_dma_buffers( DRM_OS_IOCTL )
ret = mga_dma_get_buffers( dev, &d );
}
DRM_OS_KRNTOUSR( (drm_dma_t *)data, d, sizeof(d) );
DRM_COPY_TO_USER_IOCTL( (drm_dma_t *)data, d, sizeof(d) );
return ret;
}

36
shared/mga_drv.h
View file

@ -101,10 +101,10 @@ typedef struct drm_mga_private {
} drm_mga_private_t;
/* mga_dma.c */
extern int mga_dma_init( DRM_OS_IOCTL );
extern int mga_dma_flush( DRM_OS_IOCTL );
extern int mga_dma_reset( DRM_OS_IOCTL );
extern int mga_dma_buffers( DRM_OS_IOCTL );
extern int mga_dma_init( DRM_IOCTL_ARGS );
extern int mga_dma_flush( DRM_IOCTL_ARGS );
extern int mga_dma_reset( DRM_IOCTL_ARGS );
extern int mga_dma_buffers( DRM_IOCTL_ARGS );
extern int mga_do_wait_for_idle( drm_mga_private_t *dev_priv );
extern int mga_do_dma_idle( drm_mga_private_t *dev_priv );
@ -119,18 +119,18 @@ extern void mga_do_dma_wrap_end( drm_mga_private_t *dev_priv );
extern int mga_freelist_put( drm_device_t *dev, drm_buf_t *buf );
/* mga_state.c */
extern int mga_dma_clear( DRM_OS_IOCTL );
extern int mga_dma_swap( DRM_OS_IOCTL );
extern int mga_dma_vertex( DRM_OS_IOCTL );
extern int mga_dma_indices( DRM_OS_IOCTL );
extern int mga_dma_iload( DRM_OS_IOCTL );
extern int mga_dma_blit( DRM_OS_IOCTL );
extern int mga_dma_clear( DRM_IOCTL_ARGS );
extern int mga_dma_swap( DRM_IOCTL_ARGS );
extern int mga_dma_vertex( DRM_IOCTL_ARGS );
extern int mga_dma_indices( DRM_IOCTL_ARGS );
extern int mga_dma_iload( DRM_IOCTL_ARGS );
extern int mga_dma_blit( DRM_IOCTL_ARGS );
/* mga_warp.c */
extern int mga_warp_install_microcode( drm_mga_private_t *dev_priv );
extern int mga_warp_init( drm_mga_private_t *dev_priv );
#define mga_flush_write_combine() DRM_OS_WRITEMEMORYBARRIER()
#define mga_flush_write_combine() DRM_WRITEMEMORYBARRIER()
#define MGA_BASE( reg ) ((unsigned long)(dev_priv->mmio->handle))
@ -141,12 +141,12 @@ extern int mga_warp_init( drm_mga_private_t *dev_priv );
#ifdef __alpha__
#define MGA_READ( reg ) (_MGA_READ((u32 *)MGA_ADDR(reg)))
#define MGA_WRITE( reg, val ) do { DRM_OS_WRITEMEMORYBARRIER(); MGA_DEREF( reg ) = val; } while (0)
#define MGA_WRITE8( reg, val ) do { DRM_OS_WRITEMEMORYBARRIER(); MGA_DEREF8( reg ) = val; } while (0)
#define MGA_WRITE( reg, val ) do { DRM_WRITEMEMORYBARRIER(); MGA_DEREF( reg ) = val; } while (0)
#define MGA_WRITE8( reg, val ) do { DRM_WRITEMEMORYBARRIER(); MGA_DEREF8( reg ) = val; } while (0)
static inline u32 _MGA_READ(u32 *addr)
{
DRM_OS_READMEMORYBARRIER();
DRM_READMEMORYBARRIER();
return *(volatile u32 *)addr;
}
@ -186,10 +186,10 @@ do { \
#define LOCK_TEST_WITH_RETURN( dev ) \
do { \
if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \
dev->lock.pid != DRM_OS_CURRENTPID ) { \
dev->lock.pid != DRM_CURRENTPID ) { \
DRM_ERROR( "%s called without lock held\n", \
__func__ ); \
return DRM_OS_ERR(EINVAL); \
return DRM_ERR(EINVAL); \
} \
} while (0)
@ -202,7 +202,7 @@ do { \
dev_priv->prim.high_mark ) { \
if ( MGA_DMA_DEBUG ) \
DRM_INFO( "%s: wrap...\n", __func__ ); \
return DRM_OS_ERR(EBUSY); \
return DRM_ERR(EBUSY); \
} \
} \
} while (0)
@ -213,7 +213,7 @@ do { \
if ( mga_do_wait_for_idle( dev_priv ) < 0 ) { \
if ( MGA_DMA_DEBUG ) \
DRM_INFO( "%s: wrap...\n", __func__ ); \
return DRM_OS_ERR(EBUSY); \
return DRM_ERR(EBUSY); \
} \
mga_do_dma_wrap_end( dev_priv ); \
} \

60
shared/mga_state.c
View file

@ -421,7 +421,7 @@ static int mga_verify_context( drm_mga_private_t *dev_priv )
ctx->dstorg, dev_priv->front_offset,
dev_priv->back_offset );
ctx->dstorg = 0;
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
return 0;
@ -441,7 +441,7 @@ static int mga_verify_tex( drm_mga_private_t *dev_priv, int unit )
DRM_ERROR( "*** bad TEXORG: 0x%x, unit %d\n",
tex->texorg, unit );
tex->texorg = 0;
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
return 0;
@ -483,13 +483,13 @@ static int mga_verify_iload( drm_mga_private_t *dev_priv,
dstorg + length > (dev_priv->texture_offset +
dev_priv->texture_size) ) {
DRM_ERROR( "*** bad iload DSTORG: 0x%x\n", dstorg );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( length & MGA_ILOAD_MASK ) {
DRM_ERROR( "*** bad iload length: 0x%x\n",
length & MGA_ILOAD_MASK );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
return 0;
@ -502,7 +502,7 @@ static int mga_verify_blit( drm_mga_private_t *dev_priv,
(dstorg & 0x3) == (MGA_SRCACC_PCI | MGA_SRCMAP_SYSMEM) ) {
DRM_ERROR( "*** bad blit: src=0x%x dst=0x%x\n",
srcorg, dstorg );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
return 0;
}
@ -881,16 +881,16 @@ static void mga_dma_dispatch_blit( drm_device_t *dev,
*
*/
int mga_dma_clear( DRM_OS_IOCTL )
int mga_dma_clear( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_mga_clear_t clear;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( clear, (drm_mga_clear_t *)data, sizeof(clear) );
DRM_COPY_FROM_USER_IOCTL( clear, (drm_mga_clear_t *)data, sizeof(clear) );
if ( sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS )
sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
@ -906,9 +906,9 @@ int mga_dma_clear( DRM_OS_IOCTL )
return 0;
}
int mga_dma_swap( DRM_OS_IOCTL )
int mga_dma_swap( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
@ -928,9 +928,9 @@ int mga_dma_swap( DRM_OS_IOCTL )
return 0;
}
int mga_dma_vertex( DRM_OS_IOCTL )
int mga_dma_vertex( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -939,11 +939,11 @@ int mga_dma_vertex( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( vertex,
DRM_COPY_FROM_USER_IOCTL( vertex,
(drm_mga_vertex_t *)data,
sizeof(vertex) );
if(vertex.idx < 0 || vertex.idx > dma->buf_count) return DRM_OS_ERR(EINVAL);
if(vertex.idx < 0 || vertex.idx > dma->buf_count) return DRM_ERR(EINVAL);
buf = dma->buflist[vertex.idx];
buf_priv = buf->dev_private;
@ -957,7 +957,7 @@ int mga_dma_vertex( DRM_OS_IOCTL )
buf_priv->dispatched = 0;
mga_freelist_put( dev, buf );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
WRAP_TEST_WITH_RETURN( dev_priv );
@ -967,9 +967,9 @@ int mga_dma_vertex( DRM_OS_IOCTL )
return 0;
}
int mga_dma_indices( DRM_OS_IOCTL )
int mga_dma_indices( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -978,11 +978,11 @@ int mga_dma_indices( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( indices,
DRM_COPY_FROM_USER_IOCTL( indices,
(drm_mga_indices_t *)data,
sizeof(indices) );
if(indices.idx < 0 || indices.idx > dma->buf_count) return DRM_OS_ERR(EINVAL);
if(indices.idx < 0 || indices.idx > dma->buf_count) return DRM_ERR(EINVAL);
buf = dma->buflist[indices.idx];
buf_priv = buf->dev_private;
@ -996,7 +996,7 @@ int mga_dma_indices( DRM_OS_IOCTL )
buf_priv->dispatched = 0;
mga_freelist_put( dev, buf );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
WRAP_TEST_WITH_RETURN( dev_priv );
@ -1006,9 +1006,9 @@ int mga_dma_indices( DRM_OS_IOCTL )
return 0;
}
int mga_dma_iload( DRM_OS_IOCTL )
int mga_dma_iload( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_buf_t *buf;
@ -1018,23 +1018,23 @@ int mga_dma_iload( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( iload, (drm_mga_iload_t *)data, sizeof(iload) );
DRM_COPY_FROM_USER_IOCTL( iload, (drm_mga_iload_t *)data, sizeof(iload) );
#if 0
if ( mga_do_wait_for_idle( dev_priv ) < 0 ) {
if ( MGA_DMA_DEBUG )
DRM_INFO( "%s: -EBUSY\n", __func__ );
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
#endif
if(iload.idx < 0 || iload.idx > dma->buf_count) return DRM_OS_ERR(EINVAL);
if(iload.idx < 0 || iload.idx > dma->buf_count) return DRM_ERR(EINVAL);
buf = dma->buflist[iload.idx];
buf_priv = buf->dev_private;
if ( mga_verify_iload( dev_priv, iload.dstorg, iload.length ) ) {
mga_freelist_put( dev, buf );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
WRAP_TEST_WITH_RETURN( dev_priv );
@ -1048,9 +1048,9 @@ int mga_dma_iload( DRM_OS_IOCTL )
return 0;
}
int mga_dma_blit( DRM_OS_IOCTL )
int mga_dma_blit( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_mga_private_t *dev_priv = dev->dev_private;
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_mga_blit_t blit;
@ -1058,13 +1058,13 @@ int mga_dma_blit( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( blit, (drm_mga_blit_t *)data, sizeof(blit) );
DRM_COPY_FROM_USER_IOCTL( blit, (drm_mga_blit_t *)data, sizeof(blit) );
if ( sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS )
sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
if ( mga_verify_blit( dev_priv, blit.srcorg, blit.dstorg ) )
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
WRAP_TEST_WITH_RETURN( dev_priv );

10
shared/mga_warp.c
View file

@ -107,7 +107,7 @@ static int mga_warp_install_g400_microcode( drm_mga_private_t *dev_priv )
if ( size > dev_priv->warp->size ) {
DRM_ERROR( "microcode too large! (%u > %lu)\n",
size, dev_priv->warp->size );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( dev_priv->warp_pipe_phys, 0,
@ -144,7 +144,7 @@ static int mga_warp_install_g200_microcode( drm_mga_private_t *dev_priv )
if ( size > dev_priv->warp->size ) {
DRM_ERROR( "microcode too large! (%u > %lu)\n",
size, dev_priv->warp->size );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
memset( dev_priv->warp_pipe_phys, 0,
@ -170,7 +170,7 @@ int mga_warp_install_microcode( drm_mga_private_t *dev_priv )
case MGA_CARD_TYPE_G200:
return mga_warp_install_g200_microcode( dev_priv );
default:
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
}
@ -195,7 +195,7 @@ int mga_warp_init( drm_mga_private_t *dev_priv )
MGA_WRITE( MGA_WVRTXSZ, 7 );
break;
default:
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
MGA_WRITE( MGA_WMISC, (MGA_WUCODECACHE_ENABLE |
@ -205,7 +205,7 @@ int mga_warp_init( drm_mga_private_t *dev_priv )
if ( wmisc != WMISC_EXPECTED ) {
DRM_ERROR( "WARP engine config failed! 0x%x != 0x%x\n",
wmisc, WMISC_EXPECTED );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
return 0;

122
shared/r128_cce.c
View file

@ -126,13 +126,13 @@ static int r128_do_pixcache_flush( drm_r128_private_t *dev_priv )
if ( !(R128_READ( R128_PC_NGUI_CTLSTAT ) & R128_PC_BUSY) ) {
return 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if R128_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
static int r128_do_wait_for_fifo( drm_r128_private_t *dev_priv, int entries )
@ -142,13 +142,13 @@ static int r128_do_wait_for_fifo( drm_r128_private_t *dev_priv, int entries )
for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
int slots = R128_READ( R128_GUI_STAT ) & R128_GUI_FIFOCNT_MASK;
if ( slots >= entries ) return 0;
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if R128_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
int r128_do_wait_for_idle( drm_r128_private_t *dev_priv )
@ -163,13 +163,13 @@ int r128_do_wait_for_idle( drm_r128_private_t *dev_priv )
r128_do_pixcache_flush( dev_priv );
return 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if R128_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
@ -223,14 +223,14 @@ int r128_do_cce_idle( drm_r128_private_t *dev_priv )
return r128_do_pixcache_flush( dev_priv );
}
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if R128_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
r128_status( dev_priv );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
/* Start the Concurrent Command Engine.
@ -378,7 +378,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
dev_priv = DRM(alloc)( sizeof(drm_r128_private_t), DRM_MEM_DRIVER );
if ( dev_priv == NULL )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev_priv, 0, sizeof(drm_r128_private_t) );
@ -388,7 +388,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_ERROR( "PCI GART memory not allocated!\n" );
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->usec_timeout = init->usec_timeout;
@ -397,7 +397,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_DEBUG( "TIMEOUT problem!\n" );
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->cce_mode = init->cce_mode;
@ -417,7 +417,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_DEBUG( "Bad cce_mode!\n" );
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
switch ( init->cce_mode ) {
@ -479,13 +479,13 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
dev_priv->span_pitch_offset_c = (((dev_priv->depth_pitch/8) << 21) |
(dev_priv->span_offset >> 5));
DRM_OS_GETSAREA();
DRM_GETSAREA();
if(!dev_priv->sarea) {
DRM_ERROR("could not find sarea!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
@ -493,35 +493,35 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_ERROR("could not find framebuffer!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
if(!dev_priv->mmio) {
DRM_ERROR("could not find mmio region!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->cce_ring, init->ring_offset );
if(!dev_priv->cce_ring) {
DRM_ERROR("could not find cce ring region!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->ring_rptr, init->ring_rptr_offset );
if(!dev_priv->ring_rptr) {
DRM_ERROR("could not find ring read pointer!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->buffers, init->buffers_offset );
if(!dev_priv->buffers) {
DRM_ERROR("could not find dma buffer region!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( !dev_priv->is_pci ) {
@ -531,7 +531,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_ERROR("could not find agp texture region!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
}
@ -549,7 +549,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_ERROR("Could not ioremap agp regions!\n");
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
} else {
dev_priv->cce_ring->handle =
@ -594,7 +594,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
DRM_ERROR( "failed to init PCI GART!\n" );
dev->dev_private = (void *)dev_priv;
r128_do_cleanup_cce( dev );
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
R128_WRITE( R128_PCI_GART_PAGE, dev_priv->bus_pci_gart );
}
@ -638,14 +638,14 @@ int r128_do_cleanup_cce( drm_device_t *dev )
return 0;
}
int r128_cce_init( DRM_OS_IOCTL )
int r128_cce_init( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_init_t init;
DRM_DEBUG( "\n" );
DRM_OS_KRNFROMUSR( init, (drm_r128_init_t *)data, sizeof(init) );
DRM_COPY_FROM_USER_IOCTL( init, (drm_r128_init_t *)data, sizeof(init) );
switch ( init.func ) {
case R128_INIT_CCE:
@ -654,12 +654,12 @@ int r128_cce_init( DRM_OS_IOCTL )
return r128_do_cleanup_cce( dev );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
int r128_cce_start( DRM_OS_IOCTL )
int r128_cce_start( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -678,9 +678,9 @@ int r128_cce_start( DRM_OS_IOCTL )
/* Stop the CCE. The engine must have been idled before calling this
* routine.
*/
int r128_cce_stop( DRM_OS_IOCTL )
int r128_cce_stop( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_cce_stop_t stop;
int ret;
@ -688,7 +688,7 @@ int r128_cce_stop( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR(stop, (drm_r128_cce_stop_t *)data, sizeof(stop) );
DRM_COPY_FROM_USER_IOCTL(stop, (drm_r128_cce_stop_t *)data, sizeof(stop) );
/* Flush any pending CCE commands. This ensures any outstanding
* commands are exectuted by the engine before we turn it off.
@ -719,9 +719,9 @@ int r128_cce_stop( DRM_OS_IOCTL )
/* Just reset the CCE ring. Called as part of an X Server engine reset.
*/
int r128_cce_reset( DRM_OS_IOCTL )
int r128_cce_reset( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -729,7 +729,7 @@ int r128_cce_reset( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_DEBUG( "%s called before init done\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
r128_do_cce_reset( dev_priv );
@ -740,9 +740,9 @@ int r128_cce_reset( DRM_OS_IOCTL )
return 0;
}
int r128_cce_idle( DRM_OS_IOCTL )
int r128_cce_idle( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -755,9 +755,9 @@ int r128_cce_idle( DRM_OS_IOCTL )
return r128_do_cce_idle( dev_priv );
}
int r128_engine_reset( DRM_OS_IOCTL )
int r128_engine_reset( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
DRM_DEBUG( "\n" );
LOCK_TEST_WITH_RETURN( dev );
@ -802,14 +802,14 @@ int r128_do_cleanup_pageflip( drm_device_t *dev )
return 0;
}
int r128_fullscreen( DRM_OS_IOCTL )
int r128_fullscreen( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_fullscreen_t fs;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( fs, (drm_r128_fullscreen_t *)data, sizeof(fs) );
DRM_COPY_FROM_USER_IOCTL( fs, (drm_r128_fullscreen_t *)data, sizeof(fs) );
switch ( fs.func ) {
case R128_INIT_FULLSCREEN:
@ -818,7 +818,7 @@ int r128_fullscreen( DRM_OS_IOCTL )
return r128_do_cleanup_pageflip( dev );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
@ -841,7 +841,7 @@ static int r128_freelist_init( drm_device_t *dev )
dev_priv->head = DRM(alloc)( sizeof(drm_r128_freelist_t),
DRM_MEM_DRIVER );
if ( dev_priv->head == NULL )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev_priv->head, 0, sizeof(drm_r128_freelist_t) );
dev_priv->head->age = R128_BUFFER_USED;
@ -852,7 +852,7 @@ static int r128_freelist_init( drm_device_t *dev )
entry = DRM(alloc)( sizeof(drm_r128_freelist_t),
DRM_MEM_DRIVER );
if ( !entry ) return DRM_OS_ERR(ENOMEM);
if ( !entry ) return DRM_ERR(ENOMEM);
entry->age = R128_BUFFER_FREE;
entry->buf = buf;
@ -907,7 +907,7 @@ drm_buf_t *r128_freelist_get( drm_device_t *dev )
return buf;
}
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
DRM_ERROR( "returning NULL!\n" );
@ -940,12 +940,12 @@ int r128_wait_ring( drm_r128_private_t *dev_priv, int n )
r128_update_ring_snapshot( ring );
if ( ring->space >= n )
return 0;
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
/* FIXME: This is being ignored... */
DRM_ERROR( "failed!\n" );
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
static int r128_cce_get_buffers( drm_device_t *dev, drm_dma_t *d )
@ -955,47 +955,47 @@ static int r128_cce_get_buffers( drm_device_t *dev, drm_dma_t *d )
for ( i = d->granted_count ; i < d->request_count ; i++ ) {
buf = r128_freelist_get( dev );
if ( !buf ) return DRM_OS_ERR(EAGAIN);
if ( !buf ) return DRM_ERR(EAGAIN);
buf->pid = DRM_OS_CURRENTPID;
buf->pid = DRM_CURRENTPID;
if ( DRM_OS_COPYTOUSR( &d->request_indices[i], &buf->idx,
if ( DRM_COPY_TO_USER( &d->request_indices[i], &buf->idx,
sizeof(buf->idx) ) )
return DRM_OS_ERR(EFAULT);
if ( DRM_OS_COPYTOUSR( &d->request_sizes[i], &buf->total,
return DRM_ERR(EFAULT);
if ( DRM_COPY_TO_USER( &d->request_sizes[i], &buf->total,
sizeof(buf->total) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
d->granted_count++;
}
return 0;
}
int r128_cce_buffers( DRM_OS_IOCTL )
int r128_cce_buffers( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
int ret = 0;
drm_dma_t d;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( d, (drm_dma_t *) data, sizeof(d) );
DRM_COPY_FROM_USER_IOCTL( d, (drm_dma_t *) data, sizeof(d) );
/* Please don't send us buffers.
*/
if ( d.send_count != 0 ) {
DRM_ERROR( "Process %d trying to send %d buffers via drmDMA\n",
DRM_OS_CURRENTPID, d.send_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.send_count );
return DRM_ERR(EINVAL);
}
/* We'll send you buffers.
*/
if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
DRM_ERROR( "Process %d trying to get %d buffers (of %d max)\n",
DRM_OS_CURRENTPID, d.request_count, dma->buf_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.request_count, dma->buf_count );
return DRM_ERR(EINVAL);
}
d.granted_count = 0;
@ -1004,7 +1004,7 @@ int r128_cce_buffers( DRM_OS_IOCTL )
ret = r128_cce_get_buffers( dev, &d );
}
DRM_OS_KRNTOUSR((drm_dma_t *) data, d, sizeof(d) );
DRM_COPY_TO_USER_IOCTL((drm_dma_t *) data, d, sizeof(d) );
return ret;
}

54
shared/r128_drv.h
View file

@ -34,8 +34,8 @@
#ifndef __R128_DRV_H__
#define __R128_DRV_H__
#define GET_RING_HEAD(ring) DRM_OS_READ32( (volatile u32 *) (ring)->head )
#define SET_RING_HEAD(ring,val) DRM_OS_WRITE32( (volatile u32 *) (ring)->head, (val) )
#define GET_RING_HEAD(ring) DRM_READ32( (volatile u32 *) (ring)->head )
#define SET_RING_HEAD(ring,val) DRM_WRITE32( (volatile u32 *) (ring)->head, (val) )
typedef struct drm_r128_freelist {
unsigned int age;
@ -116,14 +116,14 @@ typedef struct drm_r128_buf_priv {
} drm_r128_buf_priv_t;
/* r128_cce.c */
extern int r128_cce_init( DRM_OS_IOCTL );
extern int r128_cce_start( DRM_OS_IOCTL );
extern int r128_cce_stop( DRM_OS_IOCTL );
extern int r128_cce_reset( DRM_OS_IOCTL );
extern int r128_cce_idle( DRM_OS_IOCTL );
extern int r128_engine_reset( DRM_OS_IOCTL );
extern int r128_fullscreen( DRM_OS_IOCTL );
extern int r128_cce_buffers( DRM_OS_IOCTL );
extern int r128_cce_init( DRM_IOCTL_ARGS );
extern int r128_cce_start( DRM_IOCTL_ARGS );
extern int r128_cce_stop( DRM_IOCTL_ARGS );
extern int r128_cce_reset( DRM_IOCTL_ARGS );
extern int r128_cce_idle( DRM_IOCTL_ARGS );
extern int r128_engine_reset( DRM_IOCTL_ARGS );
extern int r128_fullscreen( DRM_IOCTL_ARGS );
extern int r128_cce_buffers( DRM_IOCTL_ARGS );
extern void r128_freelist_reset( drm_device_t *dev );
extern drm_buf_t *r128_freelist_get( drm_device_t *dev );
@ -143,14 +143,14 @@ extern int r128_do_cleanup_cce( drm_device_t *dev );
extern int r128_do_cleanup_pageflip( drm_device_t *dev );
/* r128_state.c */
extern int r128_cce_clear( DRM_OS_IOCTL );
extern int r128_cce_swap( DRM_OS_IOCTL );
extern int r128_cce_vertex( DRM_OS_IOCTL );
extern int r128_cce_indices( DRM_OS_IOCTL );
extern int r128_cce_blit( DRM_OS_IOCTL );
extern int r128_cce_depth( DRM_OS_IOCTL );
extern int r128_cce_stipple( DRM_OS_IOCTL );
extern int r128_cce_indirect( DRM_OS_IOCTL );
extern int r128_cce_clear( DRM_IOCTL_ARGS );
extern int r128_cce_swap( DRM_IOCTL_ARGS );
extern int r128_cce_vertex( DRM_IOCTL_ARGS );
extern int r128_cce_indices( DRM_IOCTL_ARGS );
extern int r128_cce_blit( DRM_IOCTL_ARGS );
extern int r128_cce_depth( DRM_IOCTL_ARGS );
extern int r128_cce_stipple( DRM_IOCTL_ARGS );
extern int r128_cce_indirect( DRM_IOCTL_ARGS );
/* Register definitions, register access macros and drmAddMap constants
@ -368,11 +368,11 @@ extern int r128_cce_indirect( DRM_OS_IOCTL );
#define R128_BASE(reg) ((unsigned long)(dev_priv->mmio->handle))
#define R128_ADDR(reg) (R128_BASE( reg ) + reg)
#define R128_READ(reg) DRM_OS_READ32( (volatile u32 *) R128_ADDR(reg) )
#define R128_WRITE(reg,val) DRM_OS_WRITE32( (volatile u32 *) R128_ADDR(reg), (val) )
#define R128_READ(reg) DRM_READ32( (volatile u32 *) R128_ADDR(reg) )
#define R128_WRITE(reg,val) DRM_WRITE32( (volatile u32 *) R128_ADDR(reg), (val) )
#define R128_READ8(reg) DRM_OS_READ8( (volatile u8 *) R128_ADDR(reg) )
#define R128_WRITE8(reg,val) DRM_OS_WRITE8( (volatile u8 *) R128_ADDR(reg), (val) )
#define R128_READ8(reg) DRM_READ8( (volatile u8 *) R128_ADDR(reg) )
#define R128_WRITE8(reg,val) DRM_WRITE8( (volatile u8 *) R128_ADDR(reg), (val) )
#define R128_WRITE_PLL(addr,val) \
do { \
@ -400,9 +400,9 @@ extern int R128_READ_PLL(drm_device_t *dev, int addr);
#define LOCK_TEST_WITH_RETURN( dev ) \
do { \
if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \
dev->lock.pid != DRM_OS_CURRENTPID ) { \
dev->lock.pid != DRM_CURRENTPID ) { \
DRM_ERROR( "%s called without lock held\n", __func__ ); \
return DRM_OS_ERR(EINVAL); \
return DRM_ERR(EINVAL); \
} \
} while (0)
@ -414,10 +414,10 @@ do { \
r128_update_ring_snapshot( ring ); \
if ( ring->space >= ring->high_mark ) \
goto __ring_space_done; \
DRM_OS_DELAY(1); \
DRM_UDELAY(1); \
} \
DRM_ERROR( "ring space check failed!\n" ); \
return DRM_OS_ERR(EBUSY); \
return DRM_ERR(EBUSY); \
} \
__ring_space_done: \
; \
@ -447,7 +447,7 @@ do { \
#if defined(__powerpc__)
#define r128_flush_write_combine() (void) GET_RING_HEAD( &dev_priv->ring )
#else
#define r128_flush_write_combine() DRM_OS_WRITEMEMORYBARRIER()
#define r128_flush_write_combine() DRM_WRITEMEMORYBARRIER()
#endif

264
shared/r128_state.c
View file

@ -809,7 +809,7 @@ static int r128_cce_dispatch_blit( drm_device_t *dev,
break;
default:
DRM_ERROR( "invalid blit format %d\n", blit->format );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
/* Flush the pixel cache, and mark the contents as Read Invalid.
@ -829,14 +829,14 @@ static int r128_cce_dispatch_blit( drm_device_t *dev,
buf = dma->buflist[blit->idx];
buf_priv = buf->dev_private;
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", blit->idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf_priv->discard = 1;
@ -901,33 +901,33 @@ static int r128_cce_dispatch_write_span( drm_device_t *dev,
DRM_DEBUG( "\n" );
count = depth->n;
if ( DRM_OS_COPYFROMUSR( &x, depth->x, sizeof(x) ) ) {
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &x, depth->x, sizeof(x) ) ) {
return DRM_ERR(EFAULT);
}
if ( DRM_OS_COPYFROMUSR( &y, depth->y, sizeof(y) ) ) {
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &y, depth->y, sizeof(y) ) ) {
return DRM_ERR(EFAULT);
}
buffer = DRM_OS_MALLOC( depth->n * sizeof(u32) );
buffer = DRM_MALLOC( depth->n * sizeof(u32) );
if ( buffer == NULL )
return DRM_OS_ERR(ENOMEM);
if ( DRM_OS_COPYFROMUSR( buffer, depth->buffer,
return DRM_ERR(ENOMEM);
if ( DRM_COPY_FROM_USER( buffer, depth->buffer,
depth->n * sizeof(u32) ) ) {
DRM_OS_FREE( buffer );
return DRM_OS_ERR(EFAULT);
DRM_FREE( buffer );
return DRM_ERR(EFAULT);
}
if ( depth->mask ) {
mask = DRM_OS_MALLOC( depth->n * sizeof(u8) );
mask = DRM_MALLOC( depth->n * sizeof(u8) );
if ( mask == NULL ) {
DRM_OS_FREE( buffer );
return DRM_OS_ERR(ENOMEM);
DRM_FREE( buffer );
return DRM_ERR(ENOMEM);
}
if ( DRM_OS_COPYFROMUSR( mask, depth->mask,
if ( DRM_COPY_FROM_USER( mask, depth->mask,
depth->n * sizeof(u8) ) ) {
DRM_OS_FREE( buffer );
DRM_OS_FREE( mask );
return DRM_OS_ERR(EFAULT);
DRM_FREE( buffer );
DRM_FREE( mask );
return DRM_ERR(EFAULT);
}
for ( i = 0 ; i < count ; i++, x++ ) {
@ -953,7 +953,7 @@ static int r128_cce_dispatch_write_span( drm_device_t *dev,
}
}
DRM_OS_FREE( mask );
DRM_FREE( mask );
} else {
for ( i = 0 ; i < count ; i++, x++ ) {
BEGIN_RING( 6 );
@ -977,7 +977,7 @@ static int r128_cce_dispatch_write_span( drm_device_t *dev,
}
}
DRM_OS_FREE( buffer );
DRM_FREE( buffer );
return 0;
}
@ -995,55 +995,55 @@ static int r128_cce_dispatch_write_pixels( drm_device_t *dev,
count = depth->n;
x = DRM_OS_MALLOC( count * sizeof(*x) );
x = DRM_MALLOC( count * sizeof(*x) );
if ( x == NULL ) {
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
y = DRM_OS_MALLOC( count * sizeof(*y) );
y = DRM_MALLOC( count * sizeof(*y) );
if ( y == NULL ) {
DRM_OS_FREE( x );
return DRM_OS_ERR(ENOMEM);
DRM_FREE( x );
return DRM_ERR(ENOMEM);
}
if ( DRM_OS_COPYFROMUSR( x, depth->x, count * sizeof(int) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( x, depth->x, count * sizeof(int) ) ) {
DRM_FREE( x );
DRM_FREE( y );
return DRM_ERR(EFAULT);
}
if ( DRM_OS_COPYFROMUSR( y, depth->y, count * sizeof(int) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( y, depth->y, count * sizeof(int) ) ) {
DRM_FREE( x );
DRM_FREE( y );
return DRM_ERR(EFAULT);
}
buffer = DRM_OS_MALLOC( depth->n * sizeof(u32) );
buffer = DRM_MALLOC( depth->n * sizeof(u32) );
if ( buffer == NULL ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
return DRM_OS_ERR(ENOMEM);
DRM_FREE( x );
DRM_FREE( y );
return DRM_ERR(ENOMEM);
}
if ( DRM_OS_COPYFROMUSR( buffer, depth->buffer,
if ( DRM_COPY_FROM_USER( buffer, depth->buffer,
depth->n * sizeof(u32) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
DRM_OS_FREE( buffer );
return DRM_OS_ERR(EFAULT);
DRM_FREE( x );
DRM_FREE( y );
DRM_FREE( buffer );
return DRM_ERR(EFAULT);
}
if ( depth->mask ) {
mask = DRM_OS_MALLOC( depth->n * sizeof(u8) );
mask = DRM_MALLOC( depth->n * sizeof(u8) );
if ( mask == NULL ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
DRM_OS_FREE( buffer );
return DRM_OS_ERR(ENOMEM);
DRM_FREE( x );
DRM_FREE( y );
DRM_FREE( buffer );
return DRM_ERR(ENOMEM);
}
if ( DRM_OS_COPYFROMUSR( mask, depth->mask,
if ( DRM_COPY_FROM_USER( mask, depth->mask,
depth->n * sizeof(u8) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
DRM_OS_FREE( buffer );
DRM_OS_FREE( mask );
return DRM_OS_ERR(EFAULT);
DRM_FREE( x );
DRM_FREE( y );
DRM_FREE( buffer );
DRM_FREE( mask );
return DRM_ERR(EFAULT);
}
for ( i = 0 ; i < count ; i++ ) {
@ -1069,7 +1069,7 @@ static int r128_cce_dispatch_write_pixels( drm_device_t *dev,
}
}
DRM_OS_FREE( mask );
DRM_FREE( mask );
} else {
for ( i = 0 ; i < count ; i++ ) {
BEGIN_RING( 6 );
@ -1093,9 +1093,9 @@ static int r128_cce_dispatch_write_pixels( drm_device_t *dev,
}
}
DRM_OS_FREE( x );
DRM_OS_FREE( y );
DRM_OS_FREE( buffer );
DRM_FREE( x );
DRM_FREE( y );
DRM_FREE( buffer );
return 0;
}
@ -1109,11 +1109,11 @@ static int r128_cce_dispatch_read_span( drm_device_t *dev,
DRM_DEBUG( "\n" );
count = depth->n;
if ( DRM_OS_COPYFROMUSR( &x, depth->x, sizeof(x) ) ) {
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &x, depth->x, sizeof(x) ) ) {
return DRM_ERR(EFAULT);
}
if ( DRM_OS_COPYFROMUSR( &y, depth->y, sizeof(y) ) ) {
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &y, depth->y, sizeof(y) ) ) {
return DRM_ERR(EFAULT);
}
BEGIN_RING( 7 );
@ -1155,24 +1155,24 @@ static int r128_cce_dispatch_read_pixels( drm_device_t *dev,
count = dev_priv->depth_pitch;
}
x = DRM_OS_MALLOC( count * sizeof(*x) );
x = DRM_MALLOC( count * sizeof(*x) );
if ( x == NULL ) {
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
y = DRM_OS_MALLOC( count * sizeof(*y) );
y = DRM_MALLOC( count * sizeof(*y) );
if ( y == NULL ) {
DRM_OS_FREE( x );
return DRM_OS_ERR(ENOMEM);
DRM_FREE( x );
return DRM_ERR(ENOMEM);
}
if ( DRM_OS_COPYFROMUSR( x, depth->x, count * sizeof(int) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( x, depth->x, count * sizeof(int) ) ) {
DRM_FREE( x );
DRM_FREE( y );
return DRM_ERR(EFAULT);
}
if ( DRM_OS_COPYFROMUSR( y, depth->y, count * sizeof(int) ) ) {
DRM_OS_FREE( x );
DRM_OS_FREE( y );
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( y, depth->y, count * sizeof(int) ) ) {
DRM_FREE( x );
DRM_FREE( y );
return DRM_ERR(EFAULT);
}
for ( i = 0 ; i < count ; i++ ) {
@ -1199,8 +1199,8 @@ static int r128_cce_dispatch_read_pixels( drm_device_t *dev,
ADVANCE_RING();
}
DRM_OS_FREE( x );
DRM_OS_FREE( y );
DRM_FREE( x );
DRM_FREE( y );
return 0;
}
@ -1232,9 +1232,9 @@ static void r128_cce_dispatch_stipple( drm_device_t *dev, u32 *stipple )
* IOCTL functions
*/
int r128_cce_clear( DRM_OS_IOCTL )
int r128_cce_clear( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_r128_clear_t clear;
@ -1242,7 +1242,7 @@ int r128_cce_clear( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( clear, (drm_r128_clear_t *) data,
DRM_COPY_FROM_USER_IOCTL( clear, (drm_r128_clear_t *) data,
sizeof(clear) );
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1259,9 +1259,9 @@ int r128_cce_clear( DRM_OS_IOCTL )
return 0;
}
int r128_cce_swap( DRM_OS_IOCTL )
int r128_cce_swap( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
DRM_DEBUG( "%s\n", __func__ );
@ -1284,9 +1284,9 @@ int r128_cce_swap( DRM_OS_IOCTL )
return 0;
}
int r128_cce_vertex( DRM_OS_IOCTL )
int r128_cce_vertex( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -1297,25 +1297,25 @@ int r128_cce_vertex( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( vertex, (drm_r128_vertex_t *) data,
DRM_COPY_FROM_USER_IOCTL( vertex, (drm_r128_vertex_t *) data,
sizeof(vertex) );
DRM_DEBUG( "pid=%d index=%d count=%d discard=%d\n",
DRM_OS_CURRENTPID,
DRM_CURRENTPID,
vertex.idx, vertex.count, vertex.discard );
if ( vertex.idx < 0 || vertex.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
vertex.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( vertex.prim < 0 ||
vertex.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2 ) {
DRM_ERROR( "buffer prim %d\n", vertex.prim );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1324,14 +1324,14 @@ int r128_cce_vertex( DRM_OS_IOCTL )
buf = dma->buflist[vertex.idx];
buf_priv = buf->dev_private;
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", vertex.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf->used = vertex.count;
@ -1343,9 +1343,9 @@ int r128_cce_vertex( DRM_OS_IOCTL )
return 0;
}
int r128_cce_indices( DRM_OS_IOCTL )
int r128_cce_indices( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -1357,24 +1357,24 @@ int r128_cce_indices( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( elts, (drm_r128_indices_t *) data,
DRM_COPY_FROM_USER_IOCTL( elts, (drm_r128_indices_t *) data,
sizeof(elts) );
DRM_DEBUG( "pid=%d buf=%d s=%d e=%d d=%d\n", DRM_OS_CURRENTPID,
DRM_DEBUG( "pid=%d buf=%d s=%d e=%d d=%d\n", DRM_CURRENTPID,
elts.idx, elts.start, elts.end, elts.discard );
if ( elts.idx < 0 || elts.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
elts.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( elts.prim < 0 ||
elts.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2 ) {
DRM_ERROR( "buffer prim %d\n", elts.prim );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1383,14 +1383,14 @@ int r128_cce_indices( DRM_OS_IOCTL )
buf = dma->buflist[elts.idx];
buf_priv = buf->dev_private;
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", elts.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
count = (elts.end - elts.start) / sizeof(u16);
@ -1398,11 +1398,11 @@ int r128_cce_indices( DRM_OS_IOCTL )
if ( elts.start & 0x7 ) {
DRM_ERROR( "misaligned buffer 0x%x\n", elts.start );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( elts.start < buf->used ) {
DRM_ERROR( "no header 0x%x - 0x%x\n", elts.start, buf->used );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf->used = elts.end;
@ -1414,24 +1414,24 @@ int r128_cce_indices( DRM_OS_IOCTL )
return 0;
}
int r128_cce_blit( DRM_OS_IOCTL )
int r128_cce_blit( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_blit_t blit;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( blit, (drm_r128_blit_t *) data,
DRM_COPY_FROM_USER_IOCTL( blit, (drm_r128_blit_t *) data,
sizeof(blit) );
DRM_DEBUG( "pid=%d index=%d\n", DRM_OS_CURRENTPID, blit.idx );
DRM_DEBUG( "pid=%d index=%d\n", DRM_CURRENTPID, blit.idx );
if ( blit.idx < 0 || blit.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
blit.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1440,15 +1440,15 @@ int r128_cce_blit( DRM_OS_IOCTL )
return r128_cce_dispatch_blit( dev, &blit );
}
int r128_cce_depth( DRM_OS_IOCTL )
int r128_cce_depth( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_depth_t depth;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( depth, (drm_r128_depth_t *) data,
DRM_COPY_FROM_USER_IOCTL( depth, (drm_r128_depth_t *) data,
sizeof(depth) );
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1464,24 +1464,24 @@ int r128_cce_depth( DRM_OS_IOCTL )
return r128_cce_dispatch_read_pixels( dev, &depth );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
int r128_cce_stipple( DRM_OS_IOCTL )
int r128_cce_stipple( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_r128_stipple_t stipple;
u32 mask[32];
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( stipple, (drm_r128_stipple_t *) data,
DRM_COPY_FROM_USER_IOCTL( stipple, (drm_r128_stipple_t *) data,
sizeof(stipple) );
if ( DRM_OS_COPYFROMUSR( &mask, stipple.mask,
if ( DRM_COPY_FROM_USER( &mask, stipple.mask,
32 * sizeof(u32) ) )
return DRM_OS_ERR( EFAULT );
return DRM_ERR( EFAULT );
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1490,9 +1490,9 @@ int r128_cce_stipple( DRM_OS_IOCTL )
return 0;
}
int r128_cce_indirect( DRM_OS_IOCTL )
int r128_cce_indirect( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_r128_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -1506,10 +1506,10 @@ int r128_cce_indirect( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( indirect, (drm_r128_indirect_t *) data,
DRM_COPY_FROM_USER_IOCTL( indirect, (drm_r128_indirect_t *) data,
sizeof(indirect) );
DRM_DEBUG( "indirect: idx=%d s=%d e=%d d=%d\n",
@ -1519,26 +1519,26 @@ int r128_cce_indirect( DRM_OS_IOCTL )
if ( indirect.idx < 0 || indirect.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
indirect.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf = dma->buflist[indirect.idx];
buf_priv = buf->dev_private;
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", indirect.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( indirect.start < buf->used ) {
DRM_ERROR( "reusing indirect: start=0x%x actual=0x%x\n",
indirect.start, buf->used );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );

110
shared/radeon_cp.c
View file

@ -354,14 +354,14 @@ static int radeon_do_pixcache_flush( drm_radeon_private_t *dev_priv )
& RADEON_RB2D_DC_BUSY) ) {
return 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if RADEON_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
radeon_status( dev_priv );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
static int radeon_do_wait_for_fifo( drm_radeon_private_t *dev_priv,
@ -373,14 +373,14 @@ static int radeon_do_wait_for_fifo( drm_radeon_private_t *dev_priv,
int slots = ( RADEON_READ( RADEON_RBBM_STATUS )
& RADEON_RBBM_FIFOCNT_MASK );
if ( slots >= entries ) return 0;
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if RADEON_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
radeon_status( dev_priv );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
static int radeon_do_wait_for_idle( drm_radeon_private_t *dev_priv )
@ -396,14 +396,14 @@ static int radeon_do_wait_for_idle( drm_radeon_private_t *dev_priv )
radeon_do_pixcache_flush( dev_priv );
return 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
#if RADEON_FIFO_DEBUG
DRM_ERROR( "failed!\n" );
radeon_status( dev_priv );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
@ -657,7 +657,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
dev_priv = DRM(alloc)( sizeof(drm_radeon_private_t), DRM_MEM_DRIVER );
if ( dev_priv == NULL )
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
memset( dev_priv, 0, sizeof(drm_radeon_private_t) );
@ -670,7 +670,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR( "PCI GART not yet supported for Radeon!\n" );
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
#endif
@ -678,7 +678,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR( "PCI GART memory not allocated!\n" );
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->usec_timeout = init->usec_timeout;
@ -687,7 +687,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_DEBUG( "TIMEOUT problem!\n" );
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
dev_priv->cp_mode = init->cp_mode;
@ -705,7 +705,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_DEBUG( "BAD cp_mode (%x)!\n", init->cp_mode );
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
switch ( init->fb_bpp ) {
@ -771,13 +771,13 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
RADEON_ROUND_MODE_TRUNC |
RADEON_ROUND_PREC_8TH_PIX);
DRM_OS_GETSAREA();
DRM_GETSAREA();
if(!dev_priv->sarea) {
DRM_ERROR("could not find sarea!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
@ -785,35 +785,35 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR("could not find framebuffer!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
if(!dev_priv->mmio) {
DRM_ERROR("could not find mmio region!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->cp_ring, init->ring_offset );
if(!dev_priv->cp_ring) {
DRM_ERROR("could not find cp ring region!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->ring_rptr, init->ring_rptr_offset );
if(!dev_priv->ring_rptr) {
DRM_ERROR("could not find ring read pointer!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_FIND_MAP( dev_priv->buffers, init->buffers_offset );
if(!dev_priv->buffers) {
DRM_ERROR("could not find dma buffer region!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( !dev_priv->is_pci ) {
@ -823,7 +823,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR("could not find agp texture region!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
}
@ -841,7 +841,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR("could not find ioremap agp regions!\n");
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
} else {
dev_priv->cp_ring->handle =
@ -928,7 +928,7 @@ static int radeon_do_init_cp( drm_device_t *dev, drm_radeon_init_t *init )
DRM_ERROR( "failed to init PCI GART!\n" );
dev->dev_private = (void *)dev_priv;
radeon_do_cleanup_cp(dev);
return DRM_OS_ERR(ENOMEM);
return DRM_ERR(ENOMEM);
}
/* Turn on PCI GART
*/
@ -1001,12 +1001,12 @@ int radeon_do_cleanup_cp( drm_device_t *dev )
return 0;
}
int radeon_cp_init( DRM_OS_IOCTL )
int radeon_cp_init( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_init_t init;
DRM_OS_KRNFROMUSR( init, (drm_radeon_init_t *)data, sizeof(init) );
DRM_COPY_FROM_USER_IOCTL( init, (drm_radeon_init_t *)data, sizeof(init) );
switch ( init.func ) {
case RADEON_INIT_CP:
@ -1015,12 +1015,12 @@ int radeon_cp_init( DRM_OS_IOCTL )
return radeon_do_cleanup_cp( dev );
}
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
int radeon_cp_start( DRM_OS_IOCTL )
int radeon_cp_start( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -1044,9 +1044,9 @@ int radeon_cp_start( DRM_OS_IOCTL )
/* Stop the CP. The engine must have been idled before calling this
* routine.
*/
int radeon_cp_stop( DRM_OS_IOCTL )
int radeon_cp_stop( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_cp_stop_t stop;
int ret;
@ -1054,7 +1054,7 @@ int radeon_cp_stop( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( stop, (drm_radeon_cp_stop_t *)data, sizeof(stop) );
DRM_COPY_FROM_USER_IOCTL( stop, (drm_radeon_cp_stop_t *)data, sizeof(stop) );
/* Flush any pending CP commands. This ensures any outstanding
* commands are exectuted by the engine before we turn it off.
@ -1085,9 +1085,9 @@ int radeon_cp_stop( DRM_OS_IOCTL )
/* Just reset the CP ring. Called as part of an X Server engine reset.
*/
int radeon_cp_reset( DRM_OS_IOCTL )
int radeon_cp_reset( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -1095,7 +1095,7 @@ int radeon_cp_reset( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_DEBUG( "%s called before init done\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
radeon_do_cp_reset( dev_priv );
@ -1106,9 +1106,9 @@ int radeon_cp_reset( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_idle( DRM_OS_IOCTL )
int radeon_cp_idle( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -1117,9 +1117,9 @@ int radeon_cp_idle( DRM_OS_IOCTL )
return radeon_do_cp_idle( dev_priv );
}
int radeon_engine_reset( DRM_OS_IOCTL )
int radeon_engine_reset( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
DRM_DEBUG( "\n" );
LOCK_TEST_WITH_RETURN( dev );
@ -1134,7 +1134,7 @@ int radeon_engine_reset( DRM_OS_IOCTL )
/* KW: Deprecated to say the least:
*/
int radeon_fullscreen( DRM_OS_IOCTL )
int radeon_fullscreen( DRM_IOCTL_ARGS )
{
return 0;
}
@ -1179,7 +1179,7 @@ drm_buf_t *radeon_freelist_get( drm_device_t *dev )
}
start = 0;
}
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
DRM_ERROR( "returning NULL!\n" );
@ -1214,7 +1214,7 @@ int radeon_wait_ring( drm_radeon_private_t *dev_priv, int n )
radeon_update_ring_snapshot( ring );
if ( ring->space > n )
return 0;
DRM_OS_DELAY( 1 );
DRM_UDELAY( 1 );
}
/* FIXME: This return value is ignored in the BEGIN_RING macro! */
@ -1222,7 +1222,7 @@ int radeon_wait_ring( drm_radeon_private_t *dev_priv, int n )
radeon_status( dev_priv );
DRM_ERROR( "failed!\n" );
#endif
return DRM_OS_ERR(EBUSY);
return DRM_ERR(EBUSY);
}
static int radeon_cp_get_buffers( drm_device_t *dev, drm_dma_t *d )
@ -1232,47 +1232,47 @@ static int radeon_cp_get_buffers( drm_device_t *dev, drm_dma_t *d )
for ( i = d->granted_count ; i < d->request_count ; i++ ) {
buf = radeon_freelist_get( dev );
if ( !buf ) return DRM_OS_ERR(EAGAIN);
if ( !buf ) return DRM_ERR(EAGAIN);
buf->pid = DRM_OS_CURRENTPID;
buf->pid = DRM_CURRENTPID;
if ( DRM_OS_COPYTOUSR( &d->request_indices[i], &buf->idx,
if ( DRM_COPY_TO_USER( &d->request_indices[i], &buf->idx,
sizeof(buf->idx) ) )
return DRM_OS_ERR(EFAULT);
if ( DRM_OS_COPYTOUSR( &d->request_sizes[i], &buf->total,
return DRM_ERR(EFAULT);
if ( DRM_COPY_TO_USER( &d->request_sizes[i], &buf->total,
sizeof(buf->total) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
d->granted_count++;
}
return 0;
}
int radeon_cp_buffers( DRM_OS_IOCTL )
int radeon_cp_buffers( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
int ret = 0;
drm_dma_t d;
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( d, (drm_dma_t *)data, sizeof(d) );
DRM_COPY_FROM_USER_IOCTL( d, (drm_dma_t *)data, sizeof(d) );
/* Please don't send us buffers.
*/
if ( d.send_count != 0 ) {
DRM_ERROR( "Process %d trying to send %d buffers via drmDMA\n",
DRM_OS_CURRENTPID, d.send_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.send_count );
return DRM_ERR(EINVAL);
}
/* We'll send you buffers.
*/
if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
DRM_ERROR( "Process %d trying to get %d buffers (of %d max)\n",
DRM_OS_CURRENTPID, d.request_count, dma->buf_count );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, d.request_count, dma->buf_count );
return DRM_ERR(EINVAL);
}
d.granted_count = 0;
@ -1281,7 +1281,7 @@ int radeon_cp_buffers( DRM_OS_IOCTL )
ret = radeon_cp_get_buffers( dev, &d );
}
DRM_OS_KRNTOUSR( (drm_dma_t *)data, d, sizeof(d) );
DRM_COPY_TO_USER_IOCTL( (drm_dma_t *)data, d, sizeof(d) );
return ret;
}

66
shared/radeon_drv.h
View file

@ -31,8 +31,8 @@
#ifndef __RADEON_DRV_H__
#define __RADEON_DRV_H__
#define GET_RING_HEAD(ring) DRM_OS_READ32( (volatile u32 *) (ring)->head )
#define SET_RING_HEAD(ring,val) DRM_OS_WRITE32( (volatile u32 *) (ring)->head , (val))
#define GET_RING_HEAD(ring) DRM_READ32( (volatile u32 *) (ring)->head )
#define SET_RING_HEAD(ring,val) DRM_WRITE32( (volatile u32 *) (ring)->head , (val))
typedef struct drm_radeon_freelist {
unsigned int age;
@ -119,14 +119,14 @@ typedef struct drm_radeon_buf_priv {
} drm_radeon_buf_priv_t;
/* radeon_cp.c */
extern int radeon_cp_init( DRM_OS_IOCTL );
extern int radeon_cp_start( DRM_OS_IOCTL );
extern int radeon_cp_stop( DRM_OS_IOCTL );
extern int radeon_cp_reset( DRM_OS_IOCTL );
extern int radeon_cp_idle( DRM_OS_IOCTL );
extern int radeon_engine_reset( DRM_OS_IOCTL );
extern int radeon_fullscreen( DRM_OS_IOCTL );
extern int radeon_cp_buffers( DRM_OS_IOCTL );
extern int radeon_cp_init( DRM_IOCTL_ARGS );
extern int radeon_cp_start( DRM_IOCTL_ARGS );
extern int radeon_cp_stop( DRM_IOCTL_ARGS );
extern int radeon_cp_reset( DRM_IOCTL_ARGS );
extern int radeon_cp_idle( DRM_IOCTL_ARGS );
extern int radeon_engine_reset( DRM_IOCTL_ARGS );
extern int radeon_fullscreen( DRM_IOCTL_ARGS );
extern int radeon_cp_buffers( DRM_IOCTL_ARGS );
extern void radeon_freelist_reset( drm_device_t *dev );
extern drm_buf_t *radeon_freelist_get( drm_device_t *dev );
@ -146,17 +146,17 @@ extern int radeon_do_cleanup_cp( drm_device_t *dev );
extern int radeon_do_cleanup_pageflip( drm_device_t *dev );
/* radeon_state.c */
extern int radeon_cp_clear( DRM_OS_IOCTL );
extern int radeon_cp_swap( DRM_OS_IOCTL );
extern int radeon_cp_vertex( DRM_OS_IOCTL );
extern int radeon_cp_indices( DRM_OS_IOCTL );
extern int radeon_cp_texture( DRM_OS_IOCTL );
extern int radeon_cp_stipple( DRM_OS_IOCTL );
extern int radeon_cp_indirect( DRM_OS_IOCTL );
extern int radeon_cp_vertex2( DRM_OS_IOCTL );
extern int radeon_cp_cmdbuf( DRM_OS_IOCTL );
extern int radeon_cp_getparam( DRM_OS_IOCTL );
extern int radeon_cp_flip( DRM_OS_IOCTL );
extern int radeon_cp_clear( DRM_IOCTL_ARGS );
extern int radeon_cp_swap( DRM_IOCTL_ARGS );
extern int radeon_cp_vertex( DRM_IOCTL_ARGS );
extern int radeon_cp_indices( DRM_IOCTL_ARGS );
extern int radeon_cp_texture( DRM_IOCTL_ARGS );
extern int radeon_cp_stipple( DRM_IOCTL_ARGS );
extern int radeon_cp_indirect( DRM_IOCTL_ARGS );
extern int radeon_cp_vertex2( DRM_IOCTL_ARGS );
extern int radeon_cp_cmdbuf( DRM_IOCTL_ARGS );
extern int radeon_cp_getparam( DRM_IOCTL_ARGS );
extern int radeon_cp_flip( DRM_IOCTL_ARGS );
@ -524,11 +524,11 @@ extern int radeon_cp_flip( DRM_OS_IOCTL );
#define RADEON_BASE(reg) ((unsigned long)(dev_priv->mmio->handle))
#define RADEON_ADDR(reg) (RADEON_BASE( reg ) + reg)
#define RADEON_READ(reg) DRM_OS_READ32( (volatile u32 *) RADEON_ADDR(reg) )
#define RADEON_WRITE(reg,val) DRM_OS_WRITE32( (volatile u32 *) RADEON_ADDR(reg), (val) )
#define RADEON_READ(reg) DRM_READ32( (volatile u32 *) RADEON_ADDR(reg) )
#define RADEON_WRITE(reg,val) DRM_WRITE32( (volatile u32 *) RADEON_ADDR(reg), (val) )
#define RADEON_READ8(reg) DRM_OS_READ8( (volatile u8 *) RADEON_ADDR(reg) )
#define RADEON_WRITE8(reg,val) DRM_OS_WRITE8( (volatile u8 *) RADEON_ADDR(reg), (val) )
#define RADEON_READ8(reg) DRM_READ8( (volatile u8 *) RADEON_ADDR(reg) )
#define RADEON_WRITE8(reg,val) DRM_WRITE8( (volatile u8 *) RADEON_ADDR(reg), (val) )
#define RADEON_WRITE_PLL( addr, val ) \
do { \
@ -608,9 +608,9 @@ extern int RADEON_READ_PLL( drm_device_t *dev, int addr );
#define LOCK_TEST_WITH_RETURN( dev ) \
do { \
if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \
dev->lock.pid != DRM_OS_CURRENTPID ) { \
dev->lock.pid != DRM_CURRENTPID ) { \
DRM_ERROR( "%s called without lock held\n", __func__ ); \
return DRM_OS_ERR(EINVAL); \
return DRM_ERR(EINVAL); \
} \
} while (0)
@ -622,7 +622,7 @@ do { \
radeon_update_ring_snapshot( ring ); \
if ( ring->space >= ring->high_mark ) \
goto __ring_space_done; \
DRM_OS_DELAY( 1 ); \
DRM_UDELAY( 1 ); \
} \
DRM_ERROR( "ring space check from memory failed, reading register...\n" ); \
/* If ring space check fails from RAM, try reading the \
@ -634,7 +634,7 @@ do { \
goto __ring_space_done; \
\
DRM_ERROR( "ring space check failed!\n" ); \
return DRM_OS_ERR(EBUSY); \
return DRM_ERR(EBUSY); \
} \
__ring_space_done: \
; \
@ -736,17 +736,17 @@ do { \
\
if (write + _size > mask) { \
int i = (mask+1) - write; \
if (DRM_OS_COPYFROMUSR_NC( (int *)(ring+write), \
if (DRM_COPY_FROM_USER_UNCHECKED( (int *)(ring+write), \
_tab, i*4 )) \
return DRM_OS_ERR(EFAULT); \
return DRM_ERR(EFAULT); \
write = 0; \
_size -= i; \
_tab += i; \
} \
\
if (_size && DRM_OS_COPYFROMUSR_NC( (int *)(ring+write), \
if (_size && DRM_COPY_FROM_USER_UNCHECKED( (int *)(ring+write), \
_tab, _size*4 )) \
return DRM_OS_ERR(EFAULT); \
return DRM_ERR(EFAULT); \
\
write += _size; \
write &= mask; \

236
shared/radeon_state.c
View file

@ -684,7 +684,7 @@ static void radeon_cp_dispatch_vertex( drm_device_t *dev,
do {
/* Emit the next cliprect */
if ( i < nbox ) {
if (DRM_OS_COPYFROMUSR_NC( &box, &boxes[i], sizeof(box) ))
if (DRM_COPY_FROM_USER_UNCHECKED( &box, &boxes[i], sizeof(box) ))
return;
radeon_emit_clip_rect( dev_priv, &box );
@ -817,7 +817,7 @@ static void radeon_cp_dispatch_indices( drm_device_t *dev,
do {
if ( i < nbox ) {
if (DRM_OS_COPYFROMUSR_NC( &box, &boxes[i], sizeof(box) ))
if (DRM_COPY_FROM_USER_UNCHECKED( &box, &boxes[i], sizeof(box) ))
return;
radeon_emit_clip_rect( dev_priv, &box );
@ -851,7 +851,7 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
/* FIXME: Be smarter about this...
*/
buf = radeon_freelist_get( dev );
if ( !buf ) return DRM_OS_ERR(EAGAIN);
if ( !buf ) return DRM_ERR(EAGAIN);
DRM_DEBUG( "tex: ofs=0x%x p=%d f=%d x=%hd y=%hd w=%hd h=%hd\n",
tex->offset >> 10, tex->pitch, tex->format,
@ -884,7 +884,7 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
break;
default:
DRM_ERROR( "invalid texture format %d\n", tex->format );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_DEBUG( " tex=%dx%d blit=%d\n",
@ -922,7 +922,7 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
if ( size > RADEON_MAX_TEXTURE_SIZE ) {
/* Texture image is too large, do a multipass upload */
ret = DRM_OS_ERR(EAGAIN);
ret = DRM_ERR(EAGAIN);
/* Adjust the blit size to fit the indirect buffer */
height = RADEON_MAX_TEXTURE_SIZE / blit_width;
@ -933,9 +933,9 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
image->height -= height;
image->data = (const char *)image->data + size;
if ( DRM_OS_COPYTOUSR( tex->image, image, sizeof(*image) ) ) {
if ( DRM_COPY_TO_USER( tex->image, image, sizeof(*image) ) ) {
DRM_ERROR( "EFAULT on tex->image\n" );
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
}
} else if ( size < 4 && size > 0 ) {
size = 4;
@ -970,9 +970,9 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
/* Texture image width is larger than the minimum, so we
* can upload it directly.
*/
if ( DRM_OS_COPYFROMUSR( buffer, data, dwords * sizeof(u32) ) ) {
if ( DRM_COPY_FROM_USER( buffer, data, dwords * sizeof(u32) ) ) {
DRM_ERROR( "EFAULT on data, %d dwords\n", dwords );
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
}
} else {
/* Texture image width is less than the minimum, so we
@ -980,17 +980,17 @@ static int radeon_cp_dispatch_texture( drm_device_t *dev,
* width.
*/
for ( i = 0 ; i < tex->height ; i++ ) {
if ( DRM_OS_COPYFROMUSR( buffer, data, tex_width ) ) {
if ( DRM_COPY_FROM_USER( buffer, data, tex_width ) ) {
DRM_ERROR( "EFAULT on pad, %d bytes\n",
tex_width );
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
}
buffer += 8;
data += tex_width;
}
}
buf->pid = DRM_OS_CURRENTPID;
buf->pid = DRM_CURRENTPID;
buf->used = (dwords + 8) * sizeof(u32);
radeon_cp_dispatch_indirect( dev, buf, 0, buf->used );
@ -1035,9 +1035,9 @@ static void radeon_cp_dispatch_stipple( drm_device_t *dev, u32 *stipple )
* IOCTL functions
*/
int radeon_cp_clear( DRM_OS_IOCTL )
int radeon_cp_clear( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_radeon_clear_t clear;
@ -1046,7 +1046,7 @@ int radeon_cp_clear( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( clear, (drm_radeon_clear_t *)data,
DRM_COPY_FROM_USER_IOCTL( clear, (drm_radeon_clear_t *)data,
sizeof(clear) );
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1054,9 +1054,9 @@ int radeon_cp_clear( DRM_OS_IOCTL )
if ( sarea_priv->nbox > RADEON_NR_SAREA_CLIPRECTS )
sarea_priv->nbox = RADEON_NR_SAREA_CLIPRECTS;
if ( DRM_OS_COPYFROMUSR( &depth_boxes, clear.depth_boxes,
if ( DRM_COPY_FROM_USER( &depth_boxes, clear.depth_boxes,
sarea_priv->nbox * sizeof(depth_boxes[0]) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
radeon_cp_dispatch_clear( dev, &clear, depth_boxes );
@ -1104,9 +1104,9 @@ int radeon_do_cleanup_pageflip( drm_device_t *dev )
/* Swapping and flipping are different operations, need different ioctls.
* They can & should be intermixed to support multiple 3d windows.
*/
int radeon_cp_flip( DRM_OS_IOCTL )
int radeon_cp_flip( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
@ -1123,9 +1123,9 @@ int radeon_cp_flip( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_swap( DRM_OS_IOCTL )
int radeon_cp_swap( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
DRM_DEBUG( "\n" );
@ -1144,9 +1144,9 @@ int radeon_cp_swap( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_vertex( DRM_OS_IOCTL )
int radeon_cp_vertex( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_device_dma_t *dma = dev->dma;
@ -1158,25 +1158,25 @@ int radeon_cp_vertex( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( vertex, (drm_radeon_vertex_t *)data,
DRM_COPY_FROM_USER_IOCTL( vertex, (drm_radeon_vertex_t *)data,
sizeof(vertex) );
DRM_DEBUG( "pid=%d index=%d count=%d discard=%d\n",
DRM_OS_CURRENTPID,
DRM_CURRENTPID,
vertex.idx, vertex.count, vertex.discard );
if ( vertex.idx < 0 || vertex.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
vertex.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( vertex.prim < 0 ||
vertex.prim > RADEON_PRIM_TYPE_3VRT_LINE_LIST ) {
DRM_ERROR( "buffer prim %d\n", vertex.prim );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1184,14 +1184,14 @@ int radeon_cp_vertex( DRM_OS_IOCTL )
buf = dma->buflist[vertex.idx];
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", vertex.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
/* Build up a prim_t record:
@ -1230,9 +1230,9 @@ int radeon_cp_vertex( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_indices( DRM_OS_IOCTL )
int radeon_cp_indices( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_device_dma_t *dma = dev->dma;
@ -1245,25 +1245,25 @@ int radeon_cp_indices( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( elts, (drm_radeon_indices_t *)data,
DRM_COPY_FROM_USER_IOCTL( elts, (drm_radeon_indices_t *)data,
sizeof(elts) );
DRM_DEBUG( "pid=%d index=%d start=%d end=%d discard=%d\n",
DRM_OS_CURRENTPID,
DRM_CURRENTPID,
elts.idx, elts.start, elts.end, elts.discard );
if ( elts.idx < 0 || elts.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
elts.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( elts.prim < 0 ||
elts.prim > RADEON_PRIM_TYPE_3VRT_LINE_LIST ) {
DRM_ERROR( "buffer prim %d\n", elts.prim );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1271,14 +1271,14 @@ int radeon_cp_indices( DRM_OS_IOCTL )
buf = dma->buflist[elts.idx];
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", elts.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
count = (elts.end - elts.start) / sizeof(u16);
@ -1286,11 +1286,11 @@ int radeon_cp_indices( DRM_OS_IOCTL )
if ( elts.start & 0x7 ) {
DRM_ERROR( "misaligned buffer 0x%x\n", elts.start );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( elts.start < buf->used ) {
DRM_ERROR( "no header 0x%x - 0x%x\n", elts.start, buf->used );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf->used = elts.end;
@ -1328,9 +1328,9 @@ int radeon_cp_indices( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_texture( DRM_OS_IOCTL )
int radeon_cp_texture( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_texture_t tex;
drm_radeon_tex_image_t image;
@ -1338,17 +1338,17 @@ int radeon_cp_texture( DRM_OS_IOCTL )
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( tex, (drm_radeon_texture_t *)data, sizeof(tex) );
DRM_COPY_FROM_USER_IOCTL( tex, (drm_radeon_texture_t *)data, sizeof(tex) );
if ( tex.image == NULL ) {
DRM_ERROR( "null texture image!\n" );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( DRM_OS_COPYFROMUSR( &image,
if ( DRM_COPY_FROM_USER( &image,
(drm_radeon_tex_image_t *)tex.image,
sizeof(image) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
RING_SPACE_TEST_WITH_RETURN( dev_priv );
VB_AGE_TEST_WITH_RETURN( dev_priv );
@ -1359,20 +1359,20 @@ int radeon_cp_texture( DRM_OS_IOCTL )
return ret;
}
int radeon_cp_stipple( DRM_OS_IOCTL )
int radeon_cp_stipple( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_stipple_t stipple;
u32 mask[32];
LOCK_TEST_WITH_RETURN( dev );
DRM_OS_KRNFROMUSR( stipple, (drm_radeon_stipple_t *)data,
DRM_COPY_FROM_USER_IOCTL( stipple, (drm_radeon_stipple_t *)data,
sizeof(stipple) );
if ( DRM_OS_COPYFROMUSR( &mask, stipple.mask, 32 * sizeof(u32) ) )
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &mask, stipple.mask, 32 * sizeof(u32) ) )
return DRM_ERR(EFAULT);
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1382,9 +1382,9 @@ int radeon_cp_stipple( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_indirect( DRM_OS_IOCTL )
int radeon_cp_indirect( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf;
@ -1395,10 +1395,10 @@ int radeon_cp_indirect( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( indirect, (drm_radeon_indirect_t *)data,
DRM_COPY_FROM_USER_IOCTL( indirect, (drm_radeon_indirect_t *)data,
sizeof(indirect) );
DRM_DEBUG( "indirect: idx=%d s=%d e=%d d=%d\n",
@ -1408,25 +1408,25 @@ int radeon_cp_indirect( DRM_OS_IOCTL )
if ( indirect.idx < 0 || indirect.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
indirect.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf = dma->buflist[indirect.idx];
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", indirect.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( indirect.start < buf->used ) {
DRM_ERROR( "reusing indirect: start=0x%x actual=0x%x\n",
indirect.start, buf->used );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1457,9 +1457,9 @@ int radeon_cp_indirect( DRM_OS_IOCTL )
return 0;
}
int radeon_cp_vertex2( DRM_OS_IOCTL )
int radeon_cp_vertex2( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv;
drm_device_dma_t *dma = dev->dma;
@ -1472,20 +1472,20 @@ int radeon_cp_vertex2( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( vertex, (drm_radeon_vertex2_t *)data,
DRM_COPY_FROM_USER_IOCTL( vertex, (drm_radeon_vertex2_t *)data,
sizeof(vertex) );
DRM_DEBUG( "pid=%d index=%d discard=%d\n",
DRM_OS_CURRENTPID,
DRM_CURRENTPID,
vertex.idx, vertex.discard );
if ( vertex.idx < 0 || vertex.idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
vertex.idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
RING_SPACE_TEST_WITH_RETURN( dev_priv );
@ -1493,34 +1493,34 @@ int radeon_cp_vertex2( DRM_OS_IOCTL )
buf = dma->buflist[vertex.idx];
if ( buf->pid != DRM_OS_CURRENTPID ) {
if ( buf->pid != DRM_CURRENTPID ) {
DRM_ERROR( "process %d using buffer owned by %d\n",
DRM_OS_CURRENTPID, buf->pid );
return DRM_OS_ERR(EINVAL);
DRM_CURRENTPID, buf->pid );
return DRM_ERR(EINVAL);
}
if ( buf->pending ) {
DRM_ERROR( "sending pending buffer %d\n", vertex.idx );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if (sarea_priv->nbox > RADEON_NR_SAREA_CLIPRECTS)
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
for (laststate = 0xff, i = 0 ; i < vertex.nr_prims ; i++) {
drm_radeon_prim_t prim;
drm_radeon_tcl_prim_t tclprim;
if ( DRM_OS_COPYFROMUSR( &prim, &vertex.prim[i], sizeof(prim) ) )
return DRM_OS_ERR(EFAULT);
if ( DRM_COPY_FROM_USER( &prim, &vertex.prim[i], sizeof(prim) ) )
return DRM_ERR(EFAULT);
if ( prim.stateidx != laststate ) {
drm_radeon_state_t state;
if ( DRM_OS_COPYFROMUSR( &state,
if ( DRM_COPY_FROM_USER( &state,
&vertex.state[prim.stateidx],
sizeof(state) ) )
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
radeon_emit_state2( dev_priv, &state );
@ -1573,7 +1573,7 @@ static int radeon_emit_packets(
RING_LOCALS;
if (sz * sizeof(int) > cmdbuf->bufsz)
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
BEGIN_RING(sz+1);
OUT_RING( CP_PACKET0( reg, (sz-1) ) );
@ -1642,14 +1642,14 @@ static int radeon_emit_packet3( drm_device_t *dev,
DRM_DEBUG("\n");
if (DRM_OS_FETCHU_32_NC( tmp, &cmd[0]))
return DRM_OS_ERR(EFAULT);
if (DRM_GET_USER_UNCHECKED( tmp, &cmd[0]))
return DRM_ERR(EFAULT);
cmdsz = 2 + ((tmp & RADEON_CP_PACKET_COUNT_MASK) >> 16);
if ((tmp & 0xc0000000) != RADEON_CP_PACKET3 ||
cmdsz * 4 > cmdbuf->bufsz)
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
BEGIN_RING( cmdsz );
OUT_RING_USER_TABLE( cmd, cmdsz );
@ -1674,19 +1674,19 @@ static int radeon_emit_packet3_cliprect( drm_device_t *dev,
DRM_DEBUG("\n");
if (DRM_OS_FETCHU_32_NC( tmp, &cmd[0]))
return DRM_OS_ERR(EFAULT);
if (DRM_GET_USER_UNCHECKED( tmp, &cmd[0]))
return DRM_ERR(EFAULT);
cmdsz = 2 + ((tmp & RADEON_CP_PACKET_COUNT_MASK) >> 16);
if ((tmp & 0xc0000000) != RADEON_CP_PACKET3 ||
cmdsz * 4 > cmdbuf->bufsz)
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
do {
if ( i < cmdbuf->nbox ) {
if (DRM_OS_COPYFROMUSR_NC( &box, &boxes[i], sizeof(box) ))
return DRM_OS_ERR(EFAULT);
if (DRM_COPY_FROM_USER_UNCHECKED( &box, &boxes[i], sizeof(box) ))
return DRM_ERR(EFAULT);
radeon_emit_clip_rect( dev_priv, &box );
}
@ -1706,9 +1706,9 @@ static int radeon_emit_packet3_cliprect( drm_device_t *dev,
int radeon_cp_cmdbuf( DRM_OS_IOCTL )
int radeon_cp_cmdbuf( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_device_dma_t *dma = dev->dma;
drm_buf_t *buf = 0;
@ -1720,30 +1720,30 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( cmdbuf, (drm_radeon_cmd_buffer_t *)data,
DRM_COPY_FROM_USER_IOCTL( cmdbuf, (drm_radeon_cmd_buffer_t *)data,
sizeof(cmdbuf) );
DRM_DEBUG( "pid=%d\n", DRM_OS_CURRENTPID );
DRM_DEBUG( "pid=%d\n", DRM_CURRENTPID );
RING_SPACE_TEST_WITH_RETURN( dev_priv );
VB_AGE_TEST_WITH_RETURN( dev_priv );
if (DRM_OS_VERIFYAREA_READ( cmdbuf.buf, cmdbuf.bufsz ))
return DRM_OS_ERR(EFAULT);
if (DRM_VERIFYAREA_READ( cmdbuf.buf, cmdbuf.bufsz ))
return DRM_ERR(EFAULT);
if (cmdbuf.nbox &&
DRM_OS_VERIFYAREA_READ(cmdbuf.boxes,
DRM_VERIFYAREA_READ(cmdbuf.boxes,
cmdbuf.nbox * sizeof(drm_clip_rect_t)))
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
while ( cmdbuf.bufsz >= sizeof(header) ) {
if (DRM_OS_FETCHU_32_NC( header.i, (int *)cmdbuf.buf )) {
if (DRM_GET_USER_UNCHECKED( header.i, (int *)cmdbuf.buf )) {
DRM_ERROR("__get_user %p\n", cmdbuf.buf);
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
}
cmdbuf.buf += sizeof(header);
@ -1753,21 +1753,21 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
case RADEON_CMD_PACKET:
if (radeon_emit_packets( dev_priv, header, &cmdbuf )) {
DRM_ERROR("radeon_emit_packets failed\n");
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
break;
case RADEON_CMD_SCALARS:
if (radeon_emit_scalars( dev_priv, header, &cmdbuf )) {
DRM_ERROR("radeon_emit_scalars failed\n");
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
break;
case RADEON_CMD_VECTORS:
if (radeon_emit_vectors( dev_priv, header, &cmdbuf )) {
DRM_ERROR("radeon_emit_vectors failed\n");
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
break;
@ -1776,13 +1776,13 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
if ( idx < 0 || idx >= dma->buf_count ) {
DRM_ERROR( "buffer index %d (of %d max)\n",
idx, dma->buf_count - 1 );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
buf = dma->buflist[idx];
if ( buf->pid != DRM_OS_CURRENTPID || buf->pending ) {
if ( buf->pid != DRM_CURRENTPID || buf->pending ) {
DRM_ERROR( "bad buffer\n" );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
radeon_cp_discard_buffer( dev, buf );
@ -1791,14 +1791,14 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
case RADEON_CMD_PACKET3:
if (radeon_emit_packet3( dev, &cmdbuf )) {
DRM_ERROR("radeon_emit_packet3 failed\n");
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
break;
case RADEON_CMD_PACKET3_CLIP:
if (radeon_emit_packet3_cliprect( dev, &cmdbuf )) {
DRM_ERROR("radeon_emit_packet3_clip failed\n");
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
break;
@ -1806,7 +1806,7 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
DRM_ERROR("bad cmd_type %d at %p\n",
header.header.cmd_type,
cmdbuf.buf - sizeof(header));
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
}
@ -1817,34 +1817,34 @@ int radeon_cp_cmdbuf( DRM_OS_IOCTL )
int radeon_cp_getparam( DRM_OS_IOCTL )
int radeon_cp_getparam( DRM_IOCTL_ARGS )
{
DRM_OS_DEVICE;
DRM_DEVICE;
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_radeon_getparam_t param;
int value;
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __func__ );
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
DRM_OS_KRNFROMUSR( param, (drm_radeon_getparam_t *)data,
DRM_COPY_FROM_USER_IOCTL( param, (drm_radeon_getparam_t *)data,
sizeof(param) );
DRM_DEBUG( "pid=%d\n", DRM_OS_CURRENTPID );
DRM_DEBUG( "pid=%d\n", DRM_CURRENTPID );
switch( param.param ) {
case RADEON_PARAM_AGP_BUFFER_OFFSET:
value = dev_priv->agp_buffers_offset;
break;
default:
return DRM_OS_ERR(EINVAL);
return DRM_ERR(EINVAL);
}
if ( DRM_OS_COPYTOUSR( param.value, &value, sizeof(int) ) ) {
if ( DRM_COPY_TO_USER( param.value, &value, sizeof(int) ) ) {
DRM_ERROR( "copy_to_user\n" );
return DRM_OS_ERR(EFAULT);
return DRM_ERR(EFAULT);
}
return 0;