geemili
/
drm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

merged bsd-3-0-0-branch

main
Alan Hourihane 2002-07-05 08:31:11 +00:00
parent 24025ca5f7
commit 74ef13fd00
141 changed files with 18145 additions and 5320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
bsd-core/ati_pcigart.c
View File

@ -27,7 +27,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#if PAGE_SIZE == 8192
@ -46,40 +45,20 @@
static unsigned long DRM(ati_alloc_pcigart_table)( void )
{
unsigned long address;
struct page *page;
int i;
DRM_DEBUG( "%s\n", __FUNCTION__ );
address = __get_free_pages( GFP_KERNEL, ATI_PCIGART_TABLE_ORDER );
if ( address == 0UL ) {
return 0;
}
DRM_DEBUG( "\n" );
page = virt_to_page( address );
address = (unsigned long) malloc( (1 << ATI_PCIGART_TABLE_ORDER) * PAGE_SIZE, DRM(M_DRM), M_WAITOK );
for ( i = 0 ; i <= ATI_PCIGART_TABLE_PAGES ; i++, page++ ) {
atomic_inc( &page->count );
SetPageReserved( page );
}
DRM_DEBUG( "%s: returning 0x%08lx\n", __FUNCTION__, address );
DRM_DEBUG( "returning 0x%08lx\n", address );
return address;
}
static void DRM(ati_free_pcigart_table)( unsigned long address )
{
struct page *page;
int i;
DRM_DEBUG( "%s\n", __FUNCTION__ );
DRM_DEBUG( "\n" );
page = virt_to_page( address );
for ( i = 0 ; i <= ATI_PCIGART_TABLE_PAGES ; i++, page++ ) {
atomic_dec( &page->count );
ClearPageReserved( page );
}
free_pages( address, ATI_PCIGART_TABLE_ORDER );
free( (void *)address, DRM(M_DRM));
}
int DRM(ati_pcigart_init)( drm_device_t *dev,
@ -89,7 +68,7 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
drm_sg_mem_t *entry = dev->sg;
unsigned long address = 0;
unsigned long pages;
u32 *pci_gart, page_base, bus_address = 0;
u32 *pci_gart=0, page_base, bus_address = 0;
int i, j, ret = 0;
if ( !entry ) {
@ -103,41 +82,36 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
goto done;
}
if ( !dev->pdev ) {
DRM_ERROR( "PCI device unknown!\n" );
goto done;
}
bus_address = pci_map_single(dev->pdev, (void *)address,
/* FIXME non-vtophys==bustophys-arches */
bus_address = vtophys( address );
/*pci_map_single(dev->pdev, (void *)address,
ATI_PCIGART_TABLE_PAGES * PAGE_SIZE,
PCI_DMA_TODEVICE);
if (bus_address == 0) {
PCI_DMA_TODEVICE);*/
/* if (bus_address == 0) {
DRM_ERROR( "unable to map PCIGART pages!\n" );
DRM(ati_free_pcigart_table)( address );
DRM(ati_free_pcigart_table)( (unsigned long)address );
address = 0;
goto done;
}
}*/
pci_gart = (u32 *)address;
pages = ( entry->pages <= ATI_MAX_PCIGART_PAGES )
? entry->pages : ATI_MAX_PCIGART_PAGES;
memset( pci_gart, 0, ATI_MAX_PCIGART_PAGES * sizeof(u32) );
bzero( pci_gart, ATI_MAX_PCIGART_PAGES * sizeof(u32) );
for ( i = 0 ; i < pages ; i++ ) {
/* we need to support large memory configurations */
entry->busaddr[i] = pci_map_single(dev->pdev,
page_address( entry->pagelist[i] ),
PAGE_SIZE,
PCI_DMA_TODEVICE);
if (entry->busaddr[i] == 0) {
/* FIXME non-vtophys==vtobus-arches */
entry->busaddr[i] = vtophys( entry->handle + (i*PAGE_SIZE) );
/* if (entry->busaddr[i] == 0) {
DRM_ERROR( "unable to map PCIGART pages!\n" );
DRM(ati_pcigart_cleanup)( dev, address, bus_address );
DRM(ati_pcigart_cleanup)( dev, (unsigned long)address, bus_address );
address = 0;
bus_address = 0;
goto done;
}
}*/
page_base = (u32) entry->busaddr[i];
for (j = 0; j < (PAGE_SIZE / ATI_PCIGART_PAGE_SIZE); j++) {
@ -148,11 +122,7 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
ret = 1;
#if defined(__i386__) || defined(__x86_64__)
asm volatile ( "wbinvd" ::: "memory" );
#else
mb();
#endif
DRM_READMEMORYBARRIER();
done:
*addr = address;
@ -165,8 +135,6 @@ int DRM(ati_pcigart_cleanup)( drm_device_t *dev,
dma_addr_t bus_addr)
{
drm_sg_mem_t *entry = dev->sg;
unsigned long pages;
int i;
/* we need to support large memory configurations */
if ( !entry ) {
@ -174,21 +142,6 @@ int DRM(ati_pcigart_cleanup)( drm_device_t *dev,
return 0;
}
if ( bus_addr ) {
pci_unmap_single(dev->pdev, bus_addr,
ATI_PCIGART_TABLE_PAGES * PAGE_SIZE,
PCI_DMA_TODEVICE);
pages = ( entry->pages <= ATI_MAX_PCIGART_PAGES )
? entry->pages : ATI_MAX_PCIGART_PAGES;
for ( i = 0 ; i < pages ; i++ ) {
if ( !entry->busaddr[i] ) break;
pci_unmap_single(dev->pdev, entry->busaddr[i],
PAGE_SIZE, PCI_DMA_TODEVICE);
}
}
if ( addr ) {
DRM(ati_free_pcigart_table)( addr );
}

64
bsd-core/drmP.h
View File

@ -69,7 +69,11 @@ typedef struct drm_file drm_file_t;
/* There's undoubtably more of this file to go into these OS dependent ones. */
#ifdef __FreeBSD__
#include "drm_os_freebsd.h"
#elif defined __NetBSD__
#include "drm_os_netbsd.h"
#endif
#include "drm.h"
@ -239,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 {
@ -252,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 {
@ -374,6 +378,7 @@ typedef struct drm_sg_mem {
void *virtual;
int pages;
struct page **pagelist;
dma_addr_t *busaddr;
} drm_sg_mem_t;
typedef struct drm_sigdata {
@ -388,20 +393,24 @@ typedef struct drm_map_list_entry {
} drm_map_list_entry_t;
struct drm_device {
#ifdef __NetBSD__
struct device device; /* NetBSD's softc is an extension of struct device */
#endif
const char *name; /* Simple driver name */
char *unique; /* Unique identifier: e.g., busid */
int unique_len; /* Length of unique field */
#ifdef __FreeBSD__
device_t device; /* Device instance from newbus */
#endif
dev_t devnode; /* Device number for mknod */
char *devname; /* For /proc/interrupts */
int blocked; /* Blocked due to VC switch? */
int flags; /* Flags to open(2) */
int writable; /* Opened with FWRITE */
struct proc_dir_entry *root; /* Root for this device's entries */
/* 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 */
@ -437,12 +446,17 @@ struct drm_device {
drm_device_dma_t *dma; /* Optional pointer for DMA support */
/* Context support */
#ifdef __FreeBSD__
int irq; /* Interrupt used by board */
struct resource *irqr; /* Resource for interrupt used by board */
#elif defined(__NetBSD__)
struct pci_attach_args pa;
pci_intr_handle_t ih;
#endif
void *irqh; /* Handle from bus_setup_intr */
__volatile__ long context_flag; /* Context swapping flag */
__volatile__ long interrupt_flag; /* Interruption handler flag */
__volatile__ long dma_flag; /* DMA dispatch flag */
atomic_t context_flag; /* Context swapping flag */
atomic_t interrupt_flag; /* Interruption handler flag */
atomic_t dma_flag; /* DMA dispatch flag */
struct callout timer; /* Timer for delaying ctx switch */
wait_queue_head_t context_wait; /* Processes waiting on ctx switch */
int last_checked; /* Last context checked for DMA */
@ -463,7 +477,11 @@ struct drm_device {
char *buf_rp; /* Read pointer */
char *buf_wp; /* Write pointer */
char *buf_end; /* End pointer */
#ifdef __FreeBSD__
struct sigio *buf_sigio; /* Processes waiting for SIGIO */
#elif defined(__NetBSD__)
pid_t buf_pgid;
#endif
struct selinfo buf_sel; /* Workspace for select/poll */
int buf_selecting;/* True if poll sleeper */
wait_queue_head_t buf_readers; /* Processes waiting to read */
@ -474,17 +492,9 @@ struct drm_device {
#if __REALLY_HAVE_AGP
drm_agp_head_t *agp;
#endif
struct pci_dev *pdev;
#ifdef __alpha__
#if LINUX_VERSION_CODE < 0x020403
struct pci_controler *hose;
#else
struct pci_controller *hose;
#endif
#endif
drm_sg_mem_t *sg; /* Scatter gather memory */
unsigned long *ctx_bitmap;
atomic_t *ctx_bitmap;
void *dev_private;
drm_sigdata_t sigdata; /* For block_all_signals */
sigset_t sigmask;
@ -500,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) */
@ -511,9 +521,6 @@ extern void *DRM(realloc)(void *oldpt, size_t oldsize, size_t size,
extern char *DRM(strdup)(const char *s, int area);
extern void DRM(strfree)(char *s, int area);
extern void DRM(free)(void *pt, size_t size, int area);
extern unsigned long DRM(alloc_pages)(int order, int area);
extern void DRM(free_pages)(unsigned long address, int order,
int area);
extern void *DRM(ioremap)(unsigned long offset, unsigned long size);
extern void *DRM(ioremap_nocache)(unsigned long offset, unsigned long size);
extern void DRM(ioremapfree)(void *pt, unsigned long size);
@ -571,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
@ -608,15 +615,6 @@ extern int DRM(agp_bind_memory)(agp_memory *handle, off_t start);
extern int DRM(agp_unbind_memory)(agp_memory *handle);
#endif
/* Proc support (drm_proc.h) */
extern struct proc_dir_entry *DRM(proc_init)(drm_device_t *dev,
int minor,
struct proc_dir_entry *root,
struct proc_dir_entry **dev_root);
extern int DRM(proc_cleanup)(int minor,
struct proc_dir_entry *root,
struct proc_dir_entry *dev_root);
#if __HAVE_SG
/* Scatter Gather Support (drm_scatter.h) */
extern void DRM(sg_cleanup)(drm_sg_mem_t *entry);
@ -633,4 +631,4 @@ extern int DRM(ati_pcigart_cleanup)(drm_device_t *dev,
#endif
#endif /* __KERNEL__ */
#endif
#endif /* _DRM_P_H_ */

54
bsd-core/drm_agpsupport.c
View File

@ -31,15 +31,9 @@
#include "drmP.h"
#include <vm/vm.h>
#include <vm/pmap.h>
#if __REALLY_HAVE_AGP
#include <sys/agpio.h>
#endif
int DRM(agp_info)(DRM_OS_IOCTL)
int DRM(agp_info)(DRM_IOCTL_ARGS)
{
drm_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
struct agp_info *kern;
drm_agp_info_t info;
@ -61,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
int retcode;
if (!dev->agp || dev->agp->acquired) return EINVAL;
@ -73,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
if (!dev->agp || !dev->agp->acquired)
return EINVAL;
@ -89,14 +83,14 @@ void DRM(agp_do_release)(void)
{
device_t agpdev;
agpdev = 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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_agp_mode_t mode;
if (!dev->agp || !dev->agp->acquired) return EINVAL;
@ -110,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_agp_buffer_t request;
drm_agp_mem_t *entry;
void *handle;
@ -165,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_agp_binding_t request;
drm_agp_mem_t *entry;
int retcode;
@ -187,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_agp_binding_t request;
drm_agp_mem_t *entry;
int retcode;
@ -209,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_agp_buffer_t request;
drm_agp_mem_t *entry;
@ -235,7 +229,7 @@ drm_agp_head_t *DRM(agp_init)(void)
drm_agp_head_t *head = NULL;
int agp_available = 1;
agpdev = agp_find_device();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev)
agp_available = 0;
@ -267,9 +261,9 @@ drm_agp_head_t *DRM(agp_init)(void)
default:
}
#endif
DRM_INFO("AGP at 0x%08x %dMB\n",
DRM_INFO("AGP at 0x%08lx %dMB\n",
head->info.ai_aperture_base,
head->info.ai_aperture_size >> 20);
(int)(head->info.ai_aperture_size >> 20));
}
return head;
}
@ -284,7 +278,7 @@ agp_memory *DRM(agp_allocate_memory)(size_t pages, u32 type)
{
device_t agpdev;
agpdev = agp_find_device();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev)
return NULL;
@ -295,7 +289,7 @@ int DRM(agp_free_memory)(agp_memory *handle)
{
device_t agpdev;
agpdev = agp_find_device();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return 0;
@ -307,7 +301,7 @@ int DRM(agp_bind_memory)(agp_memory *handle, off_t start)
{
device_t agpdev;
agpdev = agp_find_device();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return EINVAL;
@ -318,7 +312,7 @@ int DRM(agp_unbind_memory)(agp_memory *handle)
{
device_t agpdev;
agpdev = agp_find_device();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return EINVAL;

44
bsd-core/drm_auth.c
View File

@ -29,7 +29,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
static int DRM(hash_magic)(drm_magic_t magic)
@ -43,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;
}
@ -63,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;
@ -77,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;
}
@ -91,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) {
@ -103,28 +102,27 @@ int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic)
if (prev) {
prev->next = pt->next;
}
DRM_OS_UNLOCK;
DRM(free)(pt, sizeof(*pt), DRM_MEM_MAGIC);
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;
}
@ -133,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);
@ -144,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))) {
@ -163,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);
}

388
bsd-core/drm_bufs.c
View File

@ -29,14 +29,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include <machine/param.h>
#include <sys/mman.h>
#include <vm/vm.h>
#include <vm/pmap.h>
#include <vm/vm_extern.h>
#include <vm/vm_map.h>
#include <vm/vm_param.h>
#include "drmP.h"
#ifndef __HAVE_PCI_DMA
@ -74,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;
@ -95,30 +87,17 @@ 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;
TAILQ_FOREACH(list, dev->maplist, link) {
drm_map_t *entry = list->map;
if ( (entry->offset >= map->offset
&& (entry->offset) < (map->offset + map->size) )
|| ((entry->offset + entry->size) >= map->offset
&& (entry->offset + entry->size) < (map->offset + map->size) )
|| ((entry->offset < map->offset)
&& (entry->offset + entry->size) >= (map->offset + map->size) ) )
DRM_DEBUG("map collission: add(0x%lx-0x%lx), current(0x%lx-0x%lx)\n",
entry->offset, entry->offset + entry->size - 1,
map->offset, map->offset + map->size - 1);
}
switch ( map->type ) {
case _DRM_REGISTERS:
case _DRM_FRAME_BUFFER:
@ -126,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__
@ -135,23 +114,41 @@ int DRM(addmap)( DRM_OS_IOCTL )
#if __REALLY_HAVE_MTRR
if ( map->type == _DRM_FRAME_BUFFER ||
(map->flags & _DRM_WRITE_COMBINING) ) {
map->mtrr = mtrr_add( map->offset, map->size,
MTRR_TYPE_WRCOMB, 1 );
}
#ifdef __FreeBSD__
int retcode = 0, act;
struct mem_range_desc mrdesc;
mrdesc.mr_base = map->offset;
mrdesc.mr_len = map->size;
mrdesc.mr_flags = MDF_WRITECOMBINE;
act = MEMRANGE_SET_UPDATE;
bcopy(DRIVER_NAME, &mrdesc.mr_owner, strlen(DRIVER_NAME));
retcode = mem_range_attr_set(&mrdesc, &act);
map->mtrr=1;
#elif defined __NetBSD__
struct mtrr mtrrmap;
int one = 1;
mtrrmap.base = map->offset;
mtrrmap.len = map->size;
mtrrmap.type = MTRR_TYPE_WC;
mtrrmap.flags = MTRR_PRIVATE | MTRR_VALID;
mtrrmap.owner = p->p_pid;
/* USER? KERNEL? XXX */
map->mtrr = mtrr_get( &mtrrmap, &one, p, MTRR_GETSET_KERNEL );
#endif
}
#endif /* __REALLY_HAVE_MTRR */
map->handle = DRM(ioremap)( map->offset, map->size );
break;
case _DRM_SHM:
DRM_INFO( "%ld %d %d\n",
map->size, DRM(order)( map->size ), PAGE_SHIFT);
map->handle = (void *)DRM(alloc_pages)
(DRM(order)(map->size) - PAGE_SHIFT, DRM_MEM_SAREA);
map->handle = (void *)DRM(alloc)(map->size, DRM_MEM_SAREA);
DRM_DEBUG( "%ld %d %p\n",
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 ) {
@ -170,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;
@ -205,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 &&
@ -226,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);
@ -240,16 +237,32 @@ int DRM(rmmap)( DRM_OS_IOCTL )
#if __REALLY_HAVE_MTRR
if (map->mtrr >= 0) {
int retcode;
retcode = mtrr_del(map->mtrr,
map->offset,
map->size);
#ifdef __FreeBSD__
int act;
struct mem_range_desc mrdesc;
mrdesc.mr_base = map->offset;
mrdesc.mr_len = map->size;
mrdesc.mr_flags = MDF_WRITECOMBINE;
act = MEMRANGE_SET_REMOVE;
bcopy(DRIVER_NAME, &mrdesc.mr_owner, strlen(DRIVER_NAME));
retcode = mem_range_attr_set(&mrdesc, &act);
#elif defined __NetBSD__
struct mtrr mtrrmap;
int one = 1;
mtrrmap.base = map->offset;
mtrrmap.len = map->size;
mtrrmap.type = 0;
mtrrmap.flags = 0;
mtrrmap.owner = p->p_pid;
retcode = mtrr_set( &mtrrmap, &one, p, MTRR_GETSET_KERNEL);
DRM_DEBUG("mtrr_del = %d\n", retcode);
#endif
}
#endif
DRM(ioremapfree)(map->handle, map->size);
break;
case _DRM_SHM:
DRM(free_pages)( (unsigned long)map->handle, DRM(order)(map->size), DRM_MEM_SAREA );
DRM(free)( map->handle, map->size, DRM_MEM_SAREA );
break;
case _DRM_AGP:
case _DRM_SCATTER_GATHER:
@ -257,7 +270,7 @@ int DRM(rmmap)( DRM_OS_IOCTL )
}
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
@ -270,8 +283,8 @@ static void DRM(cleanup_buf_error)(drm_buf_entry_t *entry)
if (entry->seg_count) {
for (i = 0; i < entry->seg_count; i++) {
DRM(free_pages)(entry->seglist[i],
entry->page_order,
DRM(free)((void *)entry->seglist[i],
entry->buf_size,
DRM_MEM_DMA);
}
DRM(free)(entry->seglist,
@ -304,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;
@ -323,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 );
@ -348,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) );
@ -436,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;
@ -458,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;
@ -473,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;
@ -494,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 );
@ -507,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) );
@ -553,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) );
@ -571,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;
@ -586,7 +599,7 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
page_count = 0;
while ( entry->buf_count < count ) {
page = DRM(alloc_pages)( page_order, DRM_MEM_DMA );
page = (unsigned long)DRM(alloc)( size, DRM_MEM_DMA );
if ( !page ) break;
entry->seglist[entry->seg_count++] = page;
for ( i = 0 ; i < (1 << page_order) ; i++ ) {
@ -631,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;
@ -652,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;
@ -666,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;
@ -685,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 );
@ -710,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) );
@ -772,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 );
@ -803,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;
@ -825,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;
@ -839,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 )
@ -858,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;
@ -894,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,
@ -920,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;
@ -955,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 );
}
@ -991,32 +1004,43 @@ 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;
vm_offset_t virtual, address;
#ifdef __FreeBSD__
#if __FreeBSD_version >= 500000
struct vmspace *vms = p->td_proc->p_vmspace;
#else
struct vmspace *vms = p->p_vmspace;
#endif
#endif /* __FreeBSD__ */
#ifdef __NetBSD__
struct vnode *vn;
#endif /* __NetBSD__ */
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))
return 0; /* FIXME: Shouldn't this be EINVAL or something? */
#endif /* __NetBSD__ */
if ( request.count >= dma->buf_count ) {
if ( (__HAVE_AGP && (dma->flags & _DRM_DMA_USE_AGP)) ||
@ -1028,6 +1052,7 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
goto done;
}
#ifdef __FreeBSD__
virtual = round_page((vm_offset_t)vms->vm_daddr + MAXDSIZ);
retcode = vm_mmap(&vms->vm_map,
&virtual,
@ -1036,7 +1061,18 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
MAP_SHARED,
SLIST_FIRST(&kdev->si_hlist),
(unsigned long)map->offset );
#elif defined(__NetBSD__)
virtual = round_page((vaddr_t)vms->vm_daddr + MAXDSIZ);
retcode = uvm_mmap(&vms->vm_map,
(vaddr_t *)&virtual,
round_page(map->size),
UVM_PROT_READ | UVM_PROT_WRITE,
UVM_PROT_ALL, MAP_SHARED,
&vn->v_uobj, map->offset,
p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur);
#endif /* __NetBSD__ */
} else {
#ifdef __FreeBSD__
virtual = round_page((vm_offset_t)vms->vm_daddr + MAXDSIZ);
retcode = vm_mmap(&vms->vm_map,
&virtual,
@ -1045,32 +1081,42 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
MAP_SHARED,
SLIST_FIRST(&kdev->si_hlist),
0);
#elif defined(__NetBSD__)
virtual = round_page((vaddr_t)vms->vm_daddr + MAXDSIZ);
retcode = uvm_mmap(&vms->vm_map,
(vaddr_t *)&virtual,
round_page(dma->byte_count),
UVM_PROT_READ | UVM_PROT_WRITE,
UVM_PROT_ALL, MAP_SHARED,
&vn->v_uobj, 0,
p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur);
#endif /* __NetBSD__ */
}
if (retcode)
goto done;
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;
@ -1083,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 */

191
bsd-core/drm_context.c
View File

@ -29,7 +29,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#if __HAVE_CTX_BITMAP
@ -44,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:
@ -62,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 );
@ -80,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;
@ -93,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;
}
@ -111,17 +110,17 @@ int DRM(ctxbitmap_init)( drm_device_t *dev )
int i;
int temp;
DRM_OS_LOCK;
dev->ctx_bitmap = (unsigned long *) DRM(alloc)( PAGE_SIZE,
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 );
@ -133,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)
@ -189,8 +188,8 @@ int DRM(setsareactx)( DRM_OS_IOCTL )
}
bad:
DRM_OS_UNLOCK;
return -EINVAL;
DRM_UNLOCK;
return DRM_ERR(EINVAL);
found:
map = list->map;
@ -200,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;
}
@ -214,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
@ -256,41 +255,41 @@ int DRM(context_switch_complete)( drm_device_t *dev, int new )
#endif
clear_bit( 0, &dev->context_flag );
DRM_OS_WAKEUP( &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 ) {
@ -301,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 );
@ -353,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 ) {
@ -387,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
@ -398,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) {
@ -411,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) {
@ -450,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;
}
@ -514,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));
@ -532,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;
@ -552,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. */
@ -586,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;
@ -623,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);
@ -676,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 */
@ -717,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

77
bsd-core/drm_dma.c
View File

@ -29,10 +29,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/rman.h>
#include "drmP.h"
#ifndef __HAVE_DMA_WAITQUEUE
@ -59,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) );
@ -85,8 +81,8 @@ void DRM(dma_takedown)(drm_device_t *dev)
dma->bufs[i].buf_count,
dma->bufs[i].seg_count);
for (j = 0; j < dma->bufs[i].seg_count; j++) {
DRM(free_pages)(dma->bufs[i].seglist[j],
dma->bufs[i].page_order,
DRM(free)((void *)dma->bufs[i].seglist[j],
dma->bufs[i].buf_size,
DRM_MEM_DMA);
}
DRM(free)(dma->bufs[i].seglist,
@ -197,7 +193,7 @@ void DRM(free_buffer)(drm_device_t *dev, drm_buf_t *buf)
#endif
if ( buf->dma_wait ) {
wakeup( &buf->dma_wait );
wakeup( (void *)&buf->dma_wait );
buf->dma_wait = 0;
}
#if __HAVE_DMA_FREELIST
@ -248,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;
}
@ -340,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) {
@ -348,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;
@ -378,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;
@ -403,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
@ -444,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;
}
@ -511,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 );
@ -548,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;
}
@ -565,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 );
@ -583,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:
@ -596,25 +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_OS_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:
case DRM_UNINST_HANDLER:
return 0;
default:
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
}

7
bsd-core/drm_drawable.c
View File

@ -29,22 +29,21 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#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 */
}

561
bsd-core/drm_drv.c
View File

@ -116,15 +116,7 @@
#define DRIVER_IOCTLS
#endif
#ifndef DRIVER_FOPS
#if DRM_LINUX
#include <sys/file.h>
#include <sys/proc.h>
#include <machine/../linux/linux.h>
#include <machine/../linux/linux_proto.h>
#include "drm_linux.h"
#endif
#endif
/*
* The default number of instances (minor numbers) to initialize.
@ -133,9 +125,15 @@
#define DRIVER_NUM_CARDS 1
#endif
#ifdef __FreeBSD__
static int DRM(init)(device_t nbdev);
static void DRM(cleanup)(device_t nbdev);
#elif defined(__NetBSD__)
static int DRM(init)(drm_device_t *);
static void DRM(cleanup)(drm_device_t *);
#endif
#ifdef __FreeBSD__
#define CDEV_MAJOR 145
#define DRIVER_SOFTC(unit) \
((drm_device_t *) devclass_get_softc(DRM(devclass), unit))
@ -146,11 +144,13 @@ MODULE_DEPEND(DRIVER_NAME, agp, 1, 1, 1);
#if DRM_LINUX
MODULE_DEPEND(DRIVER_NAME, linux, 1, 1, 1);
#endif
#endif /* __FreeBSD__ */
static drm_device_t *DRM(device);
static int *DRM(minor);
static int DRM(numdevs) = 0;
#ifdef __NetBSD__
#define CDEV_MAJOR 90
#define DRIVER_SOFTC(unit) \
((drm_device_t *) device_lookup(&DRM(_cd), unit))
#endif /* __NetBSD__ */
static drm_ioctl_desc_t DRM(ioctls)[] = {
[DRM_IOCTL_NR(DRM_IOCTL_VERSION)] = { DRM(version), 0, 0 },
@ -212,7 +212,7 @@ static drm_ioctl_desc_t DRM(ioctls)[] = {
[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] = { DRM(agp_unbind), 1, 1 },
#endif
#if __REALLY_HAVE_SG
#if __HAVE_SG
[DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] = { DRM(sg_alloc), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] = { DRM(sg_free), 1, 1 },
#endif
@ -222,28 +222,18 @@ static drm_ioctl_desc_t DRM(ioctls)[] = {
#define DRIVER_IOCTL_COUNT DRM_ARRAY_SIZE( DRM(ioctls) )
const char *DRM(find_description)(int vendor, int device);
#ifdef __FreeBSD__
static int DRM(probe)(device_t dev)
{
const char *s = 0;
const char *s = NULL;
int pciid=pci_get_devid(dev);
int vendor = (pciid & 0x0000ffff);
int device = (pciid & 0xffff0000) >> 16;
int i=0, done=0;
DRM_INFO("Checking PCI vendor=%d, device=%d\n", vendor, device);
while ( !done && (DRM(devicelist)[i].vendor != 0 ) ) {
if ( (DRM(devicelist)[i].vendor == vendor) &&
(DRM(devicelist)[i].device == device) ) {
done=1;
if ( DRM(devicelist)[i].supported )
s = DRM(devicelist)[i].name;
else
DRM_INFO("%s not supported\n", DRM(devicelist)[i].name);
}
i++;
}
s = DRM(find_description)(vendor, device);
if (s) {
device_set_desc(dev, s);
return 0;
@ -262,7 +252,6 @@ static int DRM(detach)(device_t dev)
DRM(cleanup)(dev);
return 0;
}
static device_method_t DRM(methods)[] = {
/* Device interface */
DEVMETHOD(device_probe, DRM( probe)),
@ -301,6 +290,78 @@ static struct cdevsw DRM( cdevsw) = {
#endif
};
#elif defined(__NetBSD__)
int DRM(probe)(struct device *parent, struct cfdata *match, void *aux);
void DRM(attach)(struct device *parent, struct device *self, void *aux);
int DRM(detach)(struct device *self, int flags);
int DRM(activate)(struct device *self, enum devact act);
struct cfattach DRM(_ca) = {
sizeof(drm_device_t), DRM(probe),
DRM(attach), DRM(detach), DRM(activate) };
int DRM(probe)(struct device *parent, struct cfdata *match, void *aux)
{
struct pci_attach_args *pa = aux;
const char *desc;
desc = DRM(find_description)(PCI_VENDOR(pa->pa_id), PCI_PRODUCT(pa->pa_id));
if (desc != NULL)
return 10;
return 0;
}
void DRM(attach)(struct device *parent, struct device *self, void *aux)
{
struct pci_attach_args *pa = aux;
drm_device_t *dev = (drm_device_t *)self;
memcpy(&dev->pa, aux, sizeof(dev->pa));
DRM_INFO("%s", DRM(find_description)(PCI_VENDOR(pa->pa_id), PCI_PRODUCT(pa->pa_id)));
DRM(init)(dev);
}
int DRM(detach)(struct device *self, int flags)
{
DRM(cleanup)((drm_device_t *)self);
return 0;
}
int DRM(activate)(struct device *self, enum devact act)
{
switch (act) {
case DVACT_ACTIVATE:
return (EOPNOTSUPP);
break;
case DVACT_DEACTIVATE:
/* FIXME */
break;
}
return (0);
}
#endif
const char *DRM(find_description)(int vendor, int device) {
const char *s = NULL;
int i=0, done=0;
while ( !done && (DRM(devicelist)[i].vendor != 0 ) ) {
if ( (DRM(devicelist)[i].vendor == vendor) &&
(DRM(devicelist)[i].device == device) ) {
done=1;
if ( DRM(devicelist)[i].supported )
s = DRM(devicelist)[i].name;
else
DRM_INFO("%s not supported\n", DRM(devicelist)[i].name);
}
i++;
}
return s;
}
static int DRM(setup)( drm_device_t *dev )
{
int i;
@ -365,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;
@ -397,7 +458,11 @@ static int DRM(setup)( drm_device_t *dev )
dev->buf_rp = dev->buf;
dev->buf_wp = dev->buf;
dev->buf_end = dev->buf + DRM_BSZ;
#ifdef __FreeBSD__
dev->buf_sigio = NULL;
#elif defined(__NetBSD__)
dev->buf_pgid = 0;
#endif
dev->buf_readers = 0;
dev->buf_writers = 0;
dev->buf_selecting = 0;
@ -430,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 ) {
@ -495,18 +560,36 @@ static int DRM(takedown)( drm_device_t *dev )
#if __REALLY_HAVE_MTRR
if ( map->mtrr >= 0 ) {
int retcode;
retcode = mtrr_del( map->mtrr,
map->offset,
map->size );
#ifdef __FreeBSD__
int act;
struct mem_range_desc mrdesc;
mrdesc.mr_base = map->offset;
mrdesc.mr_len = map->size;
mrdesc.mr_flags = MDF_WRITECOMBINE;
act = MEMRANGE_SET_UPDATE;
bcopy(DRIVER_NAME, &mrdesc.mr_owner, strlen(DRIVER_NAME));
retcode = mem_range_attr_set(&mrdesc, &act);
map->mtrr=1;
#elif defined __NetBSD__
struct mtrr mtrrmap;
int one = 1;
mtrrmap.base = map->offset;
mtrrmap.len = map->size;
mtrrmap.type = MTRR_TYPE_WC;
mtrrmap.flags = 0;
/*mtrrmap.owner = p->p_pid;*/
/* XXX: Use curproc here? */
retcode = mtrr_set( &mtrrmap, &one,
DRM_CURPROC, MTRR_GETSET_KERNEL);
#endif
DRM_DEBUG( "mtrr_del=%d\n", retcode );
}
#endif
DRM(ioremapfree)( map->handle, map->size );
break;
case _DRM_SHM:
DRM(free_pages)((unsigned long)map->handle,
DRM(order)(map->size)
- PAGE_SHIFT,
DRM(free)(map->handle,
map->size,
DRM_MEM_SAREA);
break;
@ -560,206 +643,190 @@ 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(&dev->lock.lock_queue);
DRM_WAKEUP_INT((void *)&dev->lock.lock_queue);
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
/*
* Figure out how many instances to initialize.
*/
static int drm_count_cards(void)
{
int num = 0;
#if defined(DRIVER_CARD_LIST)
int i;
drm_pci_list_t *l;
u16 device, vendor;
struct pci_dev *pdev = NULL;
#endif
DRM_DEBUG( "\n" );
#if defined(DRIVER_COUNT_CARDS)
num = DRIVER_COUNT_CARDS();
#elif defined(DRIVER_CARD_LIST)
for (i = 0, l = DRIVER_CARD_LIST; l[i].vendor != 0; i++) {
pdev = NULL;
vendor = l[i].vendor;
device = l[i].device;
if(device == 0xffff) device = PCI_ANY_ID;
if(vendor == 0xffff) vendor = PCI_ANY_ID;
while ((pdev = pci_find_device(vendor, device, pdev))) {
num++; /* FIXME: What about two cards of the same device id? */
}
}
#else
num = DRIVER_NUM_CARDS;
#endif
DRM_DEBUG("numdevs = %d\n", num);
return num;
}
/* drm_init is called via init_module at module load time, or via
* linux/init/main.c (this is not currently supported).
/* linux: drm_init is called via init_module at module load time, or via
* linux/init/main.c (this is not currently supported).
* bsd: drm_init is called via the attach function per device.
*/
#ifdef __FreeBSD__
static int DRM(init)( device_t nbdev )
#elif defined(__NetBSD__)
static int DRM(init)( drm_device_t *dev )
#endif
{
int unit;
#ifdef __FreeBSD__
drm_device_t *dev;
int i;
#endif
#if __HAVE_CTX_BITMAP
int retcode;
#endif
DRM_DEBUG( "\n" );
#ifdef MODULE
DRM(parse_options)( drm_opts );
#endif
DRM(numdevs) = drm_count_cards();
/* Force at least one instance. */
if (DRM(numdevs) <= 0)
DRM(numdevs) = 1;
DRM(device) = DRM_OS_MALLOC(sizeof(*DRM(device)) * DRM(numdevs));
if (!DRM(device)) {
DRM_OS_RETURN(ENOMEM);
}
DRM(minor) = DRM_OS_MALLOC(sizeof(*(DRM(minor))) * DRM(numdevs));
if (!DRM(minor)) {
DRM_OS_FREE(DRM(device));
DRM_OS_RETURN(ENOMEM);
}
DRIVER_PREINIT();
for (i = 0; i < DRM(numdevs); i++) {
int unit = device_get_unit(nbdev);
/* FIXME??? - multihead !!! */
dev = device_get_softc(nbdev);
memset( (void *)dev, 0, sizeof(*dev) );
DRM(minor)[i]=unit;
DRM_OS_SPININIT(dev->count_lock, "drm device");
lockinit(&dev->dev_lock, PZERO, "drmlk", 0, 0);
dev->device = nbdev;
dev->devnode = make_dev( &DRM(cdevsw),
unit,
DRM_DEV_UID,
DRM_DEV_GID,
DRM_DEV_MODE,
"dri/card%d", unit );
dev->name = DRIVER_NAME;
DRM(mem_init)();
DRM(sysctl_init)(dev);
TAILQ_INIT(&dev->files);
#ifdef __FreeBSD__
unit = device_get_unit(nbdev);
dev = device_get_softc(nbdev);
memset( (void *)dev, 0, sizeof(*dev) );
dev->device = nbdev;
dev->devnode = make_dev( &DRM(cdevsw),
unit,
DRM_DEV_UID,
DRM_DEV_GID,
DRM_DEV_MODE,
"dri/card%d", unit );
#elif defined(__NetBSD__)
unit = minor(dev->device.dv_unit);
#endif
DRM_SPININIT(dev->count_lock, "drm device");
lockinit(&dev->dev_lock, PZERO, "drmlk", 0, 0);
dev->name = DRIVER_NAME;
DRM(mem_init)();
DRM(sysctl_init)(dev);
TAILQ_INIT(&dev->files);
#if __REALLY_HAVE_AGP
dev->agp = DRM(agp_init)();
dev->agp = DRM(agp_init)();
#if __MUST_HAVE_AGP
if ( dev->agp == NULL ) {
DRM_ERROR( "Cannot initialize the agpgart module.\n" );
DRM(sysctl_cleanup)( dev );
destroy_dev(dev->devnode);
DRM(takedown)( dev );
DRM_OS_RETURN(ENOMEM);
}
if ( dev->agp == NULL ) {
DRM_ERROR( "Cannot initialize the agpgart module.\n" );
DRM(sysctl_cleanup)( dev );
#ifdef __FreeBSD__
destroy_dev(dev->devnode);
#endif
DRM(takedown)( dev );
return DRM_ERR(ENOMEM);
}
#endif /* __MUST_HAVE_AGP */
#if __REALLY_HAVE_MTRR
if (dev->agp)
dev->agp->agp_mtrr = mtrr_add( dev->agp->agp_info.aper_base,
dev->agp->agp_info.aper_size*1024*1024,
MTRR_TYPE_WRCOMB,
1 );
#endif
#endif
if (dev->agp) {
#ifdef __FreeBSD__
int retcode = 0, act;
struct mem_range_desc mrdesc;
mrdesc.mr_base = dev->agp->info.ai_aperture_base;
mrdesc.mr_len = dev->agp->info.ai_aperture_size;
mrdesc.mr_flags = MDF_WRITECOMBINE;
act = MEMRANGE_SET_UPDATE;
bcopy(DRIVER_NAME, &mrdesc.mr_owner, strlen(DRIVER_NAME));
retcode = mem_range_attr_set(&mrdesc, &act);
dev->agp->agp_mtrr=1;
#elif defined __NetBSD__
struct mtrr mtrrmap;
int one = 1;
mtrrmap.base = dev->agp->info.ai_aperture_base;
/* Might need a multiplier here XXX */
mtrrmap.len = dev->agp->info.ai_aperture_size;
mtrrmap.type = MTRR_TYPE_WC;
mtrrmap.flags = MTRR_VALID;
dev->agp->agp_mtrr = mtrr_set( &mtrrmap, &one, NULL, MTRR_GETSET_KERNEL);
#endif /* __NetBSD__ */
}
#endif /* __REALLY_HAVE_MTRR */
#endif /* __REALLY_HAVE_AGP */
#if __HAVE_CTX_BITMAP
retcode = DRM(ctxbitmap_init)( dev );
if( retcode ) {
DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
DRM(sysctl_cleanup)( dev );
destroy_dev(dev->devnode);
DRM(takedown)( dev );
return retcode;
}
retcode = DRM(ctxbitmap_init)( dev );
if( retcode ) {
DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
DRM(sysctl_cleanup)( dev );
#ifdef __FreeBSD__
destroy_dev(dev->devnode);
#endif
DRM_INFO( "Initialized %s %d.%d.%d %s on minor %d\n",
DRIVER_NAME,
DRIVER_MAJOR,
DRIVER_MINOR,
DRIVER_PATCHLEVEL,
DRIVER_DATE,
DRM(minor)[i] );
DRM(takedown)( dev );
return retcode;
}
#endif
DRM_INFO( "Initialized %s %d.%d.%d %s on minor %d\n",
DRIVER_NAME,
DRIVER_MAJOR,
DRIVER_MINOR,
DRIVER_PATCHLEVEL,
DRIVER_DATE,
unit );
DRIVER_POSTINIT();
return 0;
}
/* drm_cleanup is called via cleanup_module at module unload time.
/* linux: drm_cleanup is called via cleanup_module at module unload time.
* bsd: drm_cleanup is called per device at module unload time.
* FIXME: NetBSD
*/
#ifdef __FreeBSD__
static void DRM(cleanup)(device_t nbdev)
#elif defined(__NetBSD__)
static void DRM(cleanup)(drm_device_t *dev)
#endif
{
#ifdef __FreeBSD__
drm_device_t *dev;
int i;
#endif
#if __REALLY_HAVE_MTRR
#ifdef __NetBSD__
struct mtrr mtrrmap;
int one = 1;
#endif /* __NetBSD__ */
#endif /* __REALLY_HAVE_MTRR */
DRM_DEBUG( "\n" );
for (i = DRM(numdevs) - 1; i >= 0; i--) {
/* FIXME??? - multihead */
dev = device_get_softc(nbdev);
DRM(sysctl_cleanup)( dev );
destroy_dev(dev->devnode);
#ifdef __FreeBSD__
dev = device_get_softc(nbdev);
#endif
DRM(sysctl_cleanup)( dev );
#ifdef __FreeBSD__
destroy_dev(dev->devnode);
#endif
#if __HAVE_CTX_BITMAP
DRM(ctxbitmap_cleanup)( dev );
DRM(ctxbitmap_cleanup)( dev );
#endif
#if __REALLY_HAVE_AGP && __REALLY_HAVE_MTRR
if ( dev->agp && dev->agp->agp_mtrr >= 0) {
int retval;
retval = mtrr_del( dev->agp->agp_mtrr,
dev->agp->agp_info.aper_base,
dev->agp->agp_info.aper_size*1024*1024 );
DRM_DEBUG( "mtrr_del=%d\n", retval );
}
#endif
DRM(takedown)( dev );
#if __REALLY_HAVE_AGP
if ( dev->agp ) {
DRM(agp_uninit)();
DRM(free)( dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS );
dev->agp = NULL;
}
if ( dev->agp && dev->agp->agp_mtrr >= 0) {
#if defined(__NetBSD__)
mtrrmap.base = dev->agp->info.ai_aperture_base;
mtrrmap.len = dev->agp->info.ai_aperture_size;
mtrrmap.type = 0;
mtrrmap.flags = 0;
retval = mtrr_set( &mtrrmap, &one, NULL, MTRR_GETSET_KERNEL);
#endif
}
#endif
DRM(takedown)( dev );
#if __REALLY_HAVE_AGP
if ( dev->agp ) {
DRM(agp_uninit)();
DRM(free)( dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS );
dev->agp = NULL;
}
#endif
DRIVER_POSTCLEANUP();
DRM_OS_FREE(DRM(minor));
DRM_OS_FREE(DRM(device));
DRM(numdevs) = 0;
}
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;
@ -770,48 +837,40 @@ 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;
int i;
for (i = 0; i < DRM(numdevs); i++) {
/* FIXME ??? - multihead */
dev = DRIVER_SOFTC(minor(kdev));
}
if (!dev) {
DRM_OS_RETURN(ENODEV);
}
dev = DRIVER_SOFTC(minor(kdev));
DRM_DEBUG( "open_count = %d\n", dev->open_count );
device_busy(dev->device);
retcode = DRM(open_helper)(kdev, flags, fmt, p, dev);
if ( !retcode ) {
atomic_inc( &dev->counts[_DRM_STAT_OPENS] );
DRM_OS_SPINLOCK( &dev->count_lock );
if ( !dev->open_count++ ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
return DRM(setup)( dev );
}
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
#ifdef __FreeBSD__
device_busy(dev->device);
#endif
if ( !dev->open_count++ )
retcode = DRM(setup)( dev );
DRM_SPINUNLOCK( &dev->count_lock );
}
device_unbusy(dev->device);
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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
int retcode = 0;
DRM_DEBUG( "open_count = %d\n", dev->open_count );
@ -827,13 +886,18 @@ int DRM( close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
* Begin inline drm_release
*/
#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_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();
@ -853,7 +917,7 @@ int DRM( close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
for (;;) {
if ( !dev->lock.hw_lock ) {
/* Device has been unregistered */
retcode = EINTR;
retcode = DRM_ERR(EINTR);
break;
}
if ( DRM(lock_take)( &dev->lock.hw_lock->lock,
@ -884,9 +948,15 @@ int DRM( close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
DRM(reclaim_buffers)( dev, priv->pid );
#endif
#if defined (__FreeBSD__) && (__FreeBSD_version >= 500000)
funsetown(&dev->buf_sigio);
#elif defined(__FreeBSD__)
funsetown(dev->buf_sigio);
#elif defined(__NetBSD__)
dev->buf_pgid = 0;
#endif /* __NetBSD__ */
DRM_OS_LOCK;
DRM_LOCK;
priv = DRM(find_file_by_proc)(dev, p);
if (priv) {
priv->refs--;
@ -894,7 +964,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 );
@ -903,42 +973,48 @@ 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 );
#ifdef __FreeBSD__
device_unbusy(dev->device);
#endif
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 );
device_unbusy(dev->device);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM(takedown)( dev );
}
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(retcode);
return 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] );
++priv->ioctl_count;
#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_CURRENTPID, cmd, nr, (long)&dev->device, priv->authenticated );
#endif
switch (cmd) {
case FIONBIO:
@ -950,6 +1026,7 @@ int DRM(ioctl)( DRM_OS_IOCTL )
dev->flags |= FASYNC;
return 0;
#ifdef __FreeBSD__
case FIOSETOWN:
atomic_dec(&dev->ioctl_count);
return fsetown(*(int *)data, &dev->buf_sigio);
@ -959,6 +1036,18 @@ int DRM(ioctl)( DRM_OS_IOCTL )
*(int *) data = fgetown(dev->buf_sigio);
return 0;
}
#endif /* __FreeBSD__ */
#ifdef __NetBSD__
case TIOCSPGRP:
atomic_dec(&dev->ioctl_count);
dev->buf_pgid = *(int *)data;
return 0;
case TIOCGPGRP:
atomic_dec(&dev->ioctl_count);
*(int *)data = dev->buf_pgid;
return 0;
#endif /* __NetBSD__ */
if ( nr >= DRIVER_IOCTL_COUNT ) {
retcode = EINVAL;
@ -969,7 +1058,7 @@ int DRM(ioctl)( DRM_OS_IOCTL )
if ( !func ) {
DRM_DEBUG( "no function\n" );
retcode = EINVAL;
} else if ( ( ioctl->root_only && DRM_OS_CHECKSUSER )
} else if ( ( ioctl->root_only && DRM_SUSER(p) )
|| ( ioctl->auth_needed && !priv->authenticated ) ) {
retcode = EACCES;
} else {
@ -978,12 +1067,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
@ -995,24 +1084,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
@ -1028,14 +1117,14 @@ 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 */
}
/* Contention */
ret = tsleep(&dev->lock.lock_queue,
ret = tsleep((void *)&dev->lock.lock_queue,
PZERO|PCATCH,
"drmlk2",
0);
@ -1074,21 +1163,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] );
@ -1141,7 +1230,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];

61
bsd-core/drm_fops.c
View File

@ -30,14 +30,9 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#include <sys/signalvar.h>
#include <sys/poll.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;
@ -56,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);
@ -66,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);
@ -89,15 +84,14 @@ 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_CHECKSUSER;
lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, p);
priv->authenticated = !DRM_SUSER(p);
DRM_LOCK;
TAILQ_INSERT_TAIL(&dev->files, priv, link);
lockmgr(&dev->dev_lock, LK_RELEASE, 0, p);
DRM_UNLOCK;
}
#ifdef __FreeBSD__
kdev->si_drv1 = dev;
#endif
return 0;
}
@ -108,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;
@ -156,6 +150,9 @@ int DRM(write_string)(drm_device_t *dev, const char *s)
int left = (dev->buf_rp + DRM_BSZ - dev->buf_wp) % DRM_BSZ;
int send = strlen(s);
int count;
#ifdef __NetBSD__
struct proc *p;
#endif /* __NetBSD__ */
DRM_DEBUG("%d left, %d to send (%p, %p)\n",
left, send, dev->buf_rp, dev->buf_wp);
@ -186,19 +183,33 @@ int DRM(write_string)(drm_device_t *dev, const char *s)
}
DRM_DEBUG("dev->buf_sigio=%p\n", dev->buf_sigio);
#ifdef __FreeBSD__
if (dev->buf_sigio) {
DRM_DEBUG("dev->buf_sigio->sio_pgid=%d\n", dev->buf_sigio->sio_pgid);
#if __FreeBSD_version >= 500000
pgsigio(&dev->buf_sigio, SIGIO, 0);
#else
pgsigio(dev->buf_sigio, SIGIO, 0);
#endif /* __FreeBSD_version */
}
#endif /* __FreeBSD__ */
#ifdef __NetBSD__
if (dev->buf_pgid) {
DRM_DEBUG("dev->buf_pgid=%d\n", dev->buf_pgid);
if(dev->buf_pgid > 0)
gsignal(dev->buf_pgid, SIGIO);
else if(dev->buf_pgid && (p = pfind(-dev->buf_pgid)) != NULL)
psignal(p, SIGIO);
#endif /* __NetBSD__ */
DRM_DEBUG("waking\n");
wakeup(&dev->buf_rp);
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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
int s;
int revents = 0;
@ -217,7 +228,15 @@ int DRM(poll)(dev_t kdev, int events, DRM_OS_STRUCTPROC *p)
int DRM(write)(dev_t kdev, struct uio *uio, int ioflag)
{
DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",
curproc->p_pid, ((drm_device_t *)kdev->si_drv1)->device, ((drm_device_t *)kdev->si_drv1)->open_count);
return 0;
#if DRM_DEBUG_CODE
DRM_DEVICE;
#endif
#ifdef __FreeBSD__
DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",
curproc->p_pid, dev->device, dev->open_count);
#elif defined(__NetBSD__)
DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",
curproc->p_pid, &dev->device, dev->open_count);
#endif
return 0;
}

84
bsd-core/drm_ioctl.c
View File

@ -29,20 +29,18 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#include <sys/bus.h>
#include <pci/pcivar.h>
int DRM(irq_busid)( DRM_OS_IOCTL )
int DRM(irq_busid)( DRM_IOCTL_ARGS )
{
#ifdef __FreeBSD__
drm_irq_busid_t id;
devclass_t pci;
device_t bus, dev;
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)
@ -71,49 +69,53 @@ 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
/* don't support interrupt-driven drivers on Net yet */
return ENOENT;
#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';
@ -121,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);
@ -130,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) {
@ -163,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)
{
@ -193,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)
@ -229,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;
}

17
bsd-core/drm_lock.c
View File

@ -29,16 +29,15 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#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;
@ -109,7 +108,7 @@ int DRM(lock_free)(drm_device_t *dev,
pid);
return 1;
}
DRM_OS_WAKEUP_INT(&dev->lock.lock_queue);
DRM_WAKEUP_INT((void *)&dev->lock.lock_queue);
return 0;
}
@ -125,7 +124,7 @@ static int DRM(flush_queue)(drm_device_t *dev, int context)
if (atomic_read(&q->use_count) > 1) {
atomic_inc(&q->block_write);
atomic_inc(&q->block_count);
error = tsleep(&q->flush_queue, PZERO|PCATCH, "drmfq", 0);
error = tsleep((void *)&q->flush_queue, PZERO|PCATCH, "drmfq", 0);
if (error)
return error;
atomic_dec(&q->block_count);
@ -147,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(&q->write_queue);
DRM_WAKEUP_INT((void *)&q->write_queue);
}
}
atomic_dec(&q->use_count);
@ -194,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);

161
bsd-core/drm_memory.c
View File

@ -29,20 +29,16 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#include <vm/vm.h>
#include <vm/pmap.h>
#if __REALLY_HAVE_AGP
#include <sys/agpio.h>
#endif
#ifdef __FreeBSD__
#define malloctype DRM(M_DRM)
/* The macros confliced in the MALLOC_DEFINE */
MALLOC_DEFINE(malloctype, "drm", "DRM Data Structures");
#undef malloctype
#endif
typedef struct drm_mem_stats {
const char *name;
@ -53,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)[] = {
@ -85,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;
@ -99,8 +95,8 @@ void DRM(mem_init)(void)
DRM(ram_used) = 0;
}
#ifdef __FreeBSD__
/* drm_mem_info is called whenever a process reads /dev/drm/mem. */
static int DRM(_mem_info) DRM_SYSCTL_HANDLER_ARGS
{
drm_mem_stats_t *pt;
@ -137,11 +133,12 @@ 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
void *DRM(alloc)(size_t size, int area)
{
@ -152,16 +149,20 @@ void *DRM(alloc)(size_t size, int area)
return NULL;
}
#ifdef __FreeBSD__
if (!(pt = malloc(size, DRM(M_DRM), M_NOWAIT))) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
#elif defined(__NetBSD__)
if (!(pt = malloc(size, M_DEVBUF, M_NOWAIT))) {
#endif
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;
}
@ -203,70 +204,23 @@ void DRM(free)(void *pt, size_t size, int area)
int free_count;
if (!pt) DRM_MEM_ERROR(area, "Attempt to free NULL pointer\n");
else free(pt, DRM(M_DRM));
DRM_OS_SPINLOCK(&DRM(mem_lock));
else
#ifdef __FreeBSD__
free(pt, DRM(M_DRM));
#elif defined(__NetBSD__)
free(pt, M_DEVBUF);
#endif
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);
}
}
unsigned long DRM(alloc_pages)(int order, int area)
{
vm_offset_t address;
unsigned long bytes = PAGE_SIZE << order;
address = (vm_offset_t) contigmalloc(bytes, DRM(M_DRM), M_WAITOK, 0, ~0, 1, 0);
if (!address) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[area].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
return 0;
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[area].succeed_count;
DRM(mem_stats)[area].bytes_allocated += bytes;
DRM(ram_used) += bytes;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
/* Zero outside the lock */
memset((void *)address, 0, bytes);
return address;
}
void DRM(free_pages)(unsigned long address, int order, int area)
{
unsigned long bytes = PAGE_SIZE << order;
int alloc_count;
int free_count;
if (!address) {
DRM_MEM_ERROR(area, "Attempt to free address 0\n");
} else {
contigfree((void *) address, bytes, DRM(M_DRM));
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
free_count = ++DRM(mem_stats)[area].free_count;
alloc_count = DRM(mem_stats)[area].succeed_count;
DRM(mem_stats)[area].bytes_freed += bytes;
DRM(ram_used) -= bytes;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
if (free_count > alloc_count) {
DRM_MEM_ERROR(area,
"Excess frees: %d frees, %d allocs\n",
free_count, alloc_count);
}
}
void *DRM(ioremap)(unsigned long offset, unsigned long size)
{
void *pt;
@ -278,18 +232,20 @@ 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;
}
/* unused so far */
#if 0
void *DRM(ioremap_nocache)(unsigned long offset, unsigned long size)
{
void *pt;
@ -302,17 +258,18 @@ 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
void DRM(ioremapfree)(void *pt, unsigned long size)
{
@ -325,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",
@ -348,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;
}
@ -369,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",
@ -386,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 = agp_find_device();
device_t dev = DRM_AGP_FIND_DEVICE();
struct agp_memory_info info;
if (!dev)
@ -401,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)
@ -424,7 +381,7 @@ int DRM(unbind_agp)(agp_memory *handle)
int alloc_count;
int free_count;
int retcode = EINVAL;
device_t dev = agp_find_device();
device_t dev = DRM_AGP_FIND_DEVICE();
struct agp_memory_info info;
if (!dev)
@ -433,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

207
bsd-core/drm_os_freebsd.h
View File

@ -12,12 +12,26 @@
#include <sys/uio.h>
#include <sys/filio.h>
#include <sys/sysctl.h>
#include <sys/select.h>
#include <sys/bus.h>
#include <sys/signalvar.h>
#include <sys/poll.h>
#include <vm/vm.h>
#include <vm/pmap.h>
#include <vm/vm_extern.h>
#include <vm/vm_map.h>
#include <vm/vm_param.h>
#include <machine/param.h>
#include <machine/pmap.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/mman.h>
#include <sys/rman.h>
#include <sys/memrange.h>
#include <pci/pcivar.h>
#if __FreeBSD_version >= 500000
#include <sys/selinfo.h>
#else
#include <sys/select.h>
#endif
#include <sys/bus.h>
#if __FreeBSD_version >= 400005
@ -31,11 +45,27 @@
#define __REALLY_HAVE_AGP __HAVE_AGP
#endif
#define __REALLY_HAVE_MTRR 0
#define __REALLY_HAVE_SG 0
#define __REALLY_HAVE_MTRR (__HAVE_MTRR)
#define __REALLY_HAVE_SG (__HAVE_SG)
#if __REALLY_HAVE_AGP
#include <pci/agpvar.h>
#include <sys/agpio.h>
#endif
#include <opt_drm.h>
#if DRM_DEBUG
#undef DRM_DEBUG_CODE
#define DRM_DEBUG_CODE 2
#endif
#undef DRM_DEBUG
#if DRM_LINUX
#include <sys/file.h>
#include <sys/proc.h>
#include <machine/../linux/linux.h>
#include <machine/../linux/linux_proto.h>
#include "drm_linux.h"
#endif
#define DRM_TIME_SLICE (hz/20) /* Time slice for GLXContexts */
@ -43,49 +73,51 @@
#define DRM_DEV_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
#define DRM_DEV_UID 0
#define DRM_DEV_GID 0
#define CDEV_MAJOR 145
#if __FreeBSD_version >= 500000
#define DRM_OS_SPINTYPE struct mtx
#define DRM_OS_SPININIT(l,name) mtx_init(&l, name, MTX_DEF)
#define DRM_OS_SPINLOCK(l) mtx_lock(l)
#define DRM_OS_SPINUNLOCK(u) mtx_unlock(u);
#define DRM_OS_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curthread)
#define DRM_OS_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, 0, curthread)
#define DRM_OS_CURPROC curthread
#define DRM_OS_STRUCTPROC struct thread
#define DRM_OS_CURRENTPID curthread->td_proc->p_pid
#define DRM_OS_IOCTL dev_t kdev, u_long cmd, caddr_t data, int flags, struct thread *p
#define DRM_OS_CHECKSUSER suser(p->td_proc)
#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_IOCTL dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p
#define DRM_OS_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc)
#define DRM_OS_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc)
#define DRM_OS_CURRENTPID curproc->p_pid
#define DRM_OS_CHECKSUSER suser(p)
#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_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_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); \
@ -95,34 +127,53 @@ do { \
while (((tv2.tv_sec-tv1.tv_sec)*1000000 + tv2.tv_usec - tv1.tv_usec) < udelay ); \
} while (0)
#define DRM_OS_RETURN(v) return v;
#define DRM_GETSAREA() \
do { \
drm_map_list_entry_t *listentry; \
TAILQ_FOREACH(listentry, dev->maplist, link) { \
drm_map_t *map = listentry->map; \
if (map->type == _DRM_SHM && \
map->flags & _DRM_CONTAINS_LOCK) { \
dev_priv->sarea = map; \
break; \
} \
} \
} while (0)
#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_VERIFYAREA_READ( uaddr, size ) \
(!useracc((caddr_t)uaddr, size, VM_PROT_READ))
#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
copyin(arg2, arg1, arg3)
#define DRM_GET_USER_UNCHECKED(val, uaddr) \
((val) = fuword(uaddr), 0)
#define DRM_OS_READMEMORYBARRIER \
{ \
int xchangeDummy; \
DRM_DEBUG("%s\n", __FUNCTION__); \
__asm__ volatile(" push %%eax ; xchg %%eax, %0 ; pop %%eax" : : "m" (xchangeDummy)); \
__asm__ volatile(" push %%eax ; push %%ebx ; push %%ecx ; push %%edx ;" \
" movl $0,%%eax ; cpuid ; pop %%edx ; pop %%ecx ; pop %%ebx ;" \
" pop %%eax" : /* no outputs */ : /* no inputs */ ); \
} while (0);
/* From machine/bus_at386.h on i386 */
#define DRM_READMEMORYBARRIER() \
do { \
__asm __volatile("lock; addl $0,0(%%esp)" : : : "memory"); \
} while (0)
#define DRM_OS_WRITEMEMORYBARRIER DRM_OS_READMEMORYBARRIER
#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) (((addr)+PAGE_SIZE-1)&PAGE_MASK)
#define PAGE_ALIGN(addr) round_page(addr)
#define malloctype DRM(M_DRM)
/* The macros confliced in the MALLOC_DEFINE */
@ -137,7 +188,10 @@ typedef struct drm_chipinfo
char *name;
} drm_chipinfo_t;
typedef unsigned long atomic_t;
#define cpu_to_le32(x) (x)
typedef u_int32_t dma_addr_t;
typedef u_int32_t atomic_t;
typedef u_int32_t cycles_t;
typedef u_int32_t spinlock_t;
typedef u_int32_t u32;
@ -145,14 +199,14 @@ typedef u_int16_t u16;
typedef u_int8_t u8;
#define atomic_set(p, v) (*(p) = (v))
#define atomic_read(p) (*(p))
#define atomic_inc(p) atomic_add_long(p, 1)
#define atomic_dec(p) atomic_subtract_long(p, 1)
#define atomic_add(n, p) atomic_add_long(p, n)
#define atomic_sub(n, p) atomic_subtract_long(p, n)
#define atomic_inc(p) atomic_add_int(p, 1)
#define atomic_dec(p) atomic_subtract_int(p, 1)
#define atomic_add(n, p) atomic_add_int(p, n)
#define atomic_sub(n, p) atomic_subtract_int(p, n)
/* Fake this */
static __inline unsigned int
test_and_set_bit(int b, volatile unsigned long *p)
static __inline atomic_t
test_and_set_bit(int b, atomic_t *p)
{
int s = splhigh();
unsigned int m = 1<<b;
@ -163,25 +217,25 @@ test_and_set_bit(int b, volatile unsigned long *p)
}
static __inline void
clear_bit(int b, volatile unsigned long *p)
clear_bit(int b, atomic_t *p)
{
atomic_clear_long(p + (b >> 5), 1 << (b & 0x1f));
atomic_clear_int(p + (b >> 5), 1 << (b & 0x1f));
}
static __inline void
set_bit(int b, volatile unsigned long *p)
set_bit(int b, atomic_t *p)
{
atomic_set_long(p + (b >> 5), 1 << (b & 0x1f));
atomic_set_int(p + (b >> 5), 1 << (b & 0x1f));
}
static __inline int
test_bit(int b, volatile unsigned long *p)
test_bit(int b, atomic_t *p)
{
return p[b >> 5] & (1 << (b & 0x1f));
}
static __inline int
find_first_zero_bit(volatile unsigned long *p, int max)
find_first_zero_bit(atomic_t *p, int max)
{
int b;
@ -227,24 +281,23 @@ find_first_zero_bit(volatile unsigned long *p, int max)
} while (0)
/* Redefinitions to make templating easy */
#define wait_queue_head_t long
#define wait_queue_head_t atomic_t
#define agp_memory void
#define jiffies ticks
/* Macros to make printf easier */
#define DRM_ERROR(fmt, arg...) \
printf("error: " "[" DRM_NAME ":" __FUNCTION__ "] *ERROR* " fmt , ##arg)
printf("error: " "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ## arg)
#define DRM_MEM_ERROR(area, fmt, arg...) \
printf("error: " "[" DRM_NAME ":" __FUNCTION__ ":%s] *ERROR* " fmt , \
DRM(mem_stats)[area].name , ##arg)
#define DRM_INFO(fmt, arg...) printf("info: " "[" DRM_NAME "] " fmt , ##arg)
printf("error: " "[" DRM_NAME ":%s:%s] *ERROR* " fmt , \
__func__, DRM(mem_stats)[area].name , ##arg)
#define DRM_INFO(fmt, arg...) printf("info: " "[" DRM_NAME "] " fmt , ## arg)
#if DRM_DEBUG_CODE
#define DRM_DEBUG(fmt, arg...) \
do { \
if (DRM(flags) & DRM_FLAG_DEBUG) \
printf("[" DRM_NAME ":" __FUNCTION__ "] " fmt , \
##arg); \
if (DRM(flags) & DRM_FLAG_DEBUG) \
printf("[" DRM_NAME ":%s] " fmt , __func__ , ## arg); \
} while (0)
#else
#define DRM_DEBUG(fmt, arg...) do { } while (0)
@ -294,9 +347,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);
@ -348,7 +401,7 @@ extern d_ioctl_t DRM(mapbufs);
extern int DRM(mem_info) DRM_SYSCTL_HANDLER_ARGS;
/* DMA support (drm_dma.h) */
#if __HAVE_DMA_IRQ
#if __HAVE_DMA
extern d_ioctl_t DRM(control);
#endif

378
bsd-core/drm_os_netbsd.h Normal file
View File

@ -0,0 +1,378 @@
#include <sys/param.h>
#include <sys/queue.h>
#include <sys/malloc.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/proc.h>
#include <sys/lock.h>
#include <sys/fcntl.h>
#include <sys/uio.h>
#include <sys/filio.h>
#include <sys/sysctl.h>
#include <sys/select.h>
#include <sys/device.h>
#include <sys/mman.h>
#include <uvm/uvm.h>
#include <sys/vnode.h>
#include <sys/poll.h>
/* For TIOCSPGRP/TIOCGPGRP */
#include <sys/ttycom.h>
#include <uvm/uvm.h>
#include <machine/pmap.h>
#include <machine/bus.h>
#include <sys/resourcevar.h>
#include <machine/sysarch.h>
#include <machine/mtrr.h>
#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
#include "drmvar.h"
#define __REALLY_HAVE_AGP __HAVE_AGP
#define __REALLY_HAVE_MTRR 0
#define __REALLY_HAVE_SG 0
#if __REALLY_HAVE_AGP
#include <dev/pci/agpvar.h>
#include <sys/agpio.h>
#endif
#define device_t struct device *
extern struct cfdriver DRM(_cd);
#if DRM_DEBUG
#undef DRM_DEBUG_CODE
#define DRM_DEBUG_CODE 2
#endif
#undef DRM_DEBUG
#define DRM_TIME_SLICE (hz/20) /* Time slice for GLXContexts */
#define DRM_DEV_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
#define DRM_DEV_UID 0
#define DRM_DEV_GID 0
#define CDEV_MAJOR 90
#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_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_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_UDELAY( udelay ) \
do { \
struct timeval tv1, tv2; \
microtime(&tv1); \
do { \
microtime(&tv2); \
} \
while (((tv2.tv_sec-tv1.tv_sec)*1000000 + tv2.tv_usec - tv1.tv_usec) < udelay ); \
} while (0)
#define DRM_GETSAREA() \
do { \
drm_map_list_entry_t *listentry; \
TAILQ_FOREACH(listentry, dev->maplist, link) { \
drm_map_t *map = listentry->map; \
if (map->type == _DRM_SHM && \
map->flags & _DRM_CONTAINS_LOCK) { \
dev_priv->sarea = map; \
break; \
} \
} \
} while (0)
#define return DRM_ERR(v) return v;
#define DRM_ERR(v) v
#define DRM_COPY_TO_USER_IOCTL(arg1, arg2, arg3) \
*arg1 = arg2
#define DRM_COPY_FROM_USER_IOCTL(arg1, arg2, arg3) \
arg1 = *arg2
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
copyout(arg2, arg1, arg3)
#define DRM_COPY_FROM_USER(arg1, arg2, arg3) \
copyin(arg2, arg1, arg3)
#define DRM_READMEMORYBARRIER \
{ \
int xchangeDummy; \
DRM_DEBUG("%s\n", __FUNCTION__); \
__asm__ volatile(" push %%eax ; xchg %%eax, %0 ; pop %%eax" : : "m" (xchangeDummy)); \
__asm__ volatile(" push %%eax ; push %%ebx ; push %%ecx ; push %%edx ;" \
" movl $0,%%eax ; cpuid ; pop %%edx ; pop %%ecx ; pop %%ebx ;" \
" pop %%eax" : /* no outputs */ : /* no inputs */ ); \
} while (0);
#define DRM_WRITEMEMORYBARRIER DRM_READMEMORYBARRIER
#define DRM_WAKEUP(w) wakeup(w)
#define DRM_WAKEUP_INT(w) wakeup(w)
#define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK)
typedef struct drm_chipinfo
{
int vendor;
int device;
int supported;
char *name;
} drm_chipinfo_t;
typedef u_int32_t dma_addr_t;
typedef volatile u_int32_t atomic_t;
typedef u_int32_t cycles_t;
typedef u_int32_t spinlock_t;
typedef u_int32_t u32;
typedef u_int16_t u16;
typedef u_int8_t u8;
typedef dev_type_ioctl(d_ioctl_t);
typedef vaddr_t vm_offset_t;
#define atomic_set(p, v) (*(p) = (v))
#define atomic_read(p) (*(p))
#define atomic_inc(p) atomic_add_int(p, 1)
#define atomic_dec(p) atomic_subtract_int(p, 1)
#define atomic_add(n, p) atomic_add_int(p, n)
#define atomic_sub(n, p) atomic_subtract_int(p, n)
/* FIXME: Is NetBSD's kernel non-reentrant? */
#define atomic_add_int(p, v) *(p) += v
#define atomic_subtract_int(p, v) *(p) -= v
#define atomic_set_int(p, bits) *(p) |= (bits)
#define atomic_clear_int(p, bits) *(p) &= ~(bits)
/* Fake this */
static __inline atomic_t
test_and_set_bit(int b, atomic_t *p)
{
int s = splhigh();
unsigned int m = 1<<b;
unsigned int r = *p & m;
*p |= m;
splx(s);
return r;
}
static __inline void
clear_bit(int b, atomic_t *p)
{
atomic_clear_int(p + (b >> 5), 1 << (b & 0x1f));
}
static __inline void
set_bit(int b, atomic_t *p)
{
atomic_set_int(p + (b >> 5), 1 << (b & 0x1f));
}
static __inline int
test_bit(int b, atomic_t *p)
{
return p[b >> 5] & (1 << (b & 0x1f));
}
static __inline int
find_first_zero_bit(atomic_t *p, int max)
{
int b;
for (b = 0; b < max; b += 32) {
if (p[b >> 5] != ~0) {
for (;;) {
if ((p[b >> 5] & (1 << (b & 0x1f))) == 0)
return b;
b++;
}
}
}
return max;
}
#define spldrm() spltty()
#define jiffies hardclock_ticks
#define __drm_dummy_lock(lock) (*(__volatile__ unsigned int *)lock)
#define _DRM_CAS(lock,old,new,__ret) \
do { \
int __dummy; /* Can't mark eax as clobbered */ \
__asm__ __volatile__( \
"lock ; cmpxchg %4,%1\n\t" \
"setnz %0" \
: "=d" (__ret), \
"=m" (__drm_dummy_lock(lock)), \
"=a" (__dummy) \
: "2" (old), \
"r" (new)); \
} while (0)
/* Redefinitions to make templating easy */
#define wait_queue_head_t atomic_t
#define agp_memory void
/* Macros to make printf easier */
#define DRM_ERROR(fmt, arg...) \
do { \
printf("error: [" DRM_NAME ":%s] *ERROR* ", __func__ ); \
printf( fmt,## arg ); \
} while (0)
#define DRM_MEM_ERROR(area, fmt, arg...) \
printf("error: [" DRM_NAME ":%s:%s] *ERROR* " fmt , \
__func__, DRM(mem_stats)[area].name ,## arg)
#define DRM_INFO(fmt, arg...) printf("info: " "[" DRM_NAME "] " fmt ,## arg)
#if DRM_DEBUG_CODE
#define DRM_DEBUG(fmt, arg...) \
do { \
if (DRM(flags) & DRM_FLAG_DEBUG) \
printf("[" DRM_NAME ":%s] " fmt , __FUNCTION__,## arg); \
} while (0)
#else
#define DRM_DEBUG(fmt, arg...) do { } while (0)
#endif
#define DRM_PROC_LIMIT (PAGE_SIZE-80)
#define DRM_SYSCTL_PRINT(fmt, arg...) \
snprintf(buf, sizeof(buf), fmt, ##arg); \
error = SYSCTL_OUT(req, buf, strlen(buf)); \
if (error) return error;
#define DRM_SYSCTL_PRINT_RET(ret, fmt, arg...) \
snprintf(buf, sizeof(buf), fmt, ##arg); \
error = SYSCTL_OUT(req, buf, strlen(buf)); \
if (error) { ret; return error; }
#define DRM_FIND_MAP(dest, o) \
do { \
drm_map_list_entry_t *listentry; \
TAILQ_FOREACH(listentry, dev->maplist, link) { \
if ( listentry->map->offset == o ) { \
dest = listentry->map; \
break; \
} \
} \
} while (0)
/* Internal functions */
/* drm_drv.h */
extern dev_type_ioctl(DRM(ioctl));
extern dev_type_ioctl(DRM(lock));
extern dev_type_ioctl(DRM(unlock));
extern dev_type_open(DRM(open));
extern dev_type_close(DRM(close));
extern dev_type_read(DRM(read));
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_STRUCTPROC *p, drm_device_t *dev);
extern drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev,
DRM_STRUCTPROC *p);
/* Misc. IOCTL support (drm_ioctl.h) */
extern dev_type_ioctl(DRM(irq_busid));
extern dev_type_ioctl(DRM(getunique));
extern dev_type_ioctl(DRM(setunique));
extern dev_type_ioctl(DRM(getmap));
extern dev_type_ioctl(DRM(getclient));
extern dev_type_ioctl(DRM(getstats));
/* Context IOCTL support (drm_context.h) */
extern dev_type_ioctl(DRM(resctx));
extern dev_type_ioctl(DRM(addctx));
extern dev_type_ioctl(DRM(modctx));
extern dev_type_ioctl(DRM(getctx));
extern dev_type_ioctl(DRM(switchctx));
extern dev_type_ioctl(DRM(newctx));
extern dev_type_ioctl(DRM(rmctx));
extern dev_type_ioctl(DRM(setsareactx));
extern dev_type_ioctl(DRM(getsareactx));
/* Drawable IOCTL support (drm_drawable.h) */
extern dev_type_ioctl(DRM(adddraw));
extern dev_type_ioctl(DRM(rmdraw));
/* Authentication IOCTL support (drm_auth.h) */
extern dev_type_ioctl(DRM(getmagic));
extern dev_type_ioctl(DRM(authmagic));
/* Locking IOCTL support (drm_lock.h) */
extern dev_type_ioctl(DRM(block));
extern dev_type_ioctl(DRM(unblock));
extern dev_type_ioctl(DRM(finish));
/* Buffer management support (drm_bufs.h) */
extern dev_type_ioctl(DRM(addmap));
extern dev_type_ioctl(DRM(rmmap));
#if __HAVE_DMA
extern dev_type_ioctl(DRM(addbufs_agp));
extern dev_type_ioctl(DRM(addbufs_pci));
extern dev_type_ioctl(DRM(addbufs_sg));
extern dev_type_ioctl(DRM(addbufs));
extern dev_type_ioctl(DRM(infobufs));
extern dev_type_ioctl(DRM(markbufs));
extern dev_type_ioctl(DRM(freebufs));
extern dev_type_ioctl(DRM(mapbufs));
#endif
/* DMA support (drm_dma.h) */
#if __HAVE_DMA
extern dev_type_ioctl(DRM(control));
#endif
/* AGP/GART support (drm_agpsupport.h) */
#if __REALLY_HAVE_AGP
extern dev_type_ioctl(DRM(agp_acquire));
extern dev_type_ioctl(DRM(agp_release));
extern dev_type_ioctl(DRM(agp_enable));
extern dev_type_ioctl(DRM(agp_info));
extern dev_type_ioctl(DRM(agp_alloc));
extern dev_type_ioctl(DRM(agp_free));
extern dev_type_ioctl(DRM(agp_unbind));
extern dev_type_ioctl(DRM(agp_bind));
#endif
/* Scatter Gather Support (drm_scatter.h) */
#if __HAVE_SG
extern dev_type_ioctl(DRM(sg_alloc));
extern dev_type_ioctl(DRM(sg_free));
#endif
/* SysCtl Support (drm_sysctl.h) */
extern int DRM(sysctl_init)(drm_device_t *dev);
extern int DRM(sysctl_cleanup)(drm_device_t *dev);

115
bsd-core/drm_scatter.c
View File

@ -27,25 +27,15 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include <linux/config.h>
#include <linux/vmalloc.h>
#include "drmP.h"
#define DEBUG_SCATTER 0
#if __REALLY_HAVE_SG
void DRM(sg_cleanup)( drm_sg_mem_t *entry )
{
struct page *page;
int i;
for ( i = 0 ; i < entry->pages ; i++ ) {
page = entry->pagelist[i];
if ( page )
ClearPageReserved( page );
}
vfree( entry->virtual );
free( entry->virtual, DRM(M_DRM) );
DRM(free)( entry->busaddr,
entry->pages * sizeof(*entry->busaddr),
@ -58,35 +48,28 @@ void DRM(sg_cleanup)( drm_sg_mem_t *entry )
DRM_MEM_SGLISTS );
}
int DRM(sg_alloc)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg )
int DRM(sg_alloc)( DRM_IOCTL_ARGS )
{
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->dev;
DRM_DEVICE;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
unsigned long pages, i, j;
pgd_t *pgd;
pmd_t *pmd;
pte_t *pte;
unsigned long pages;
DRM_DEBUG( "%s\n", __FUNCTION__ );
if ( dev->sg )
return -EINVAL;
return EINVAL;
if ( copy_from_user( &request,
(drm_scatter_gather_t *)arg,
sizeof(request) ) )
return -EFAULT;
DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
sizeof(request) );
entry = DRM(alloc)( sizeof(*entry), DRM_MEM_SGLISTS );
if ( !entry )
return -ENOMEM;
return ENOMEM;
memset( entry, 0, sizeof(*entry) );
bzero( entry, sizeof(*entry) );
pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
pages = round_page(request.size) / PAGE_SIZE;
DRM_DEBUG( "sg size=%ld pages=%ld\n", request.size, pages );
entry->pages = pages;
@ -94,10 +77,10 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
DRM_MEM_PAGES );
if ( !entry->pagelist ) {
DRM(free)( entry, sizeof(*entry), DRM_MEM_SGLISTS );
return -ENOMEM;
return ENOMEM;
}
memset(entry->pagelist, 0, pages * sizeof(*entry->pagelist));
bzero(entry->pagelist, pages * sizeof(*entry->pagelist));
entry->busaddr = DRM(alloc)( pages * sizeof(*entry->busaddr),
DRM_MEM_PAGES );
@ -108,11 +91,11 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
DRM(free)( entry,
sizeof(*entry),
DRM_MEM_SGLISTS );
return -ENOMEM;
return ENOMEM;
}
memset( (void *)entry->busaddr, 0, pages * sizeof(*entry->busaddr) );
bzero( (void *)entry->busaddr, pages * sizeof(*entry->busaddr) );
entry->virtual = vmalloc_32( pages << PAGE_SHIFT );
entry->virtual = malloc( pages << PAGE_SHIFT, DRM(M_DRM), M_WAITOK );
if ( !entry->virtual ) {
DRM(free)( entry->busaddr,
entry->pages * sizeof(*entry->busaddr),
@ -123,45 +106,21 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
DRM(free)( entry,
sizeof(*entry),
DRM_MEM_SGLISTS );
return -ENOMEM;
return ENOMEM;
}
/* This also forces the mapping of COW pages, so our page list
* will be valid. Please don't remove it...
*/
memset( entry->virtual, 0, pages << PAGE_SHIFT );
bzero( entry->virtual, pages << PAGE_SHIFT );
entry->handle = (unsigned long)entry->virtual;
DRM_DEBUG( "sg alloc handle = %08lx\n", entry->handle );
DRM_DEBUG( "sg alloc virtual = %p\n", entry->virtual );
for ( i = entry->handle, j = 0 ; j < pages ; i += PAGE_SIZE, j++ ) {
pgd = pgd_offset_k( i );
if ( !pgd_present( *pgd ) )
goto failed;
pmd = pmd_offset( pgd, i );
if ( !pmd_present( *pmd ) )
goto failed;
pte = pte_offset( pmd, i );
if ( !pte_present( *pte ) )
goto failed;
entry->pagelist[j] = pte_page( *pte );
SetPageReserved( entry->pagelist[j] );
}
request.handle = entry->handle;
if ( copy_to_user( (drm_scatter_gather_t *)arg,
&request,
sizeof(request) ) ) {
DRM(sg_cleanup)( entry );
return -EFAULT;
}
DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
request,
sizeof(request) );
dev->sg = entry;
@ -207,29 +166,24 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
return 0;
failed:
DRM(sg_cleanup)( entry );
return -ENOMEM;
return ENOMEM;
}
int DRM(sg_free)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg )
int DRM(sg_free)( DRM_IOCTL_ARGS )
{
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->dev;
DRM_DEVICE;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
if ( copy_from_user( &request,
(drm_scatter_gather_t *)arg,
sizeof(request) ) )
return -EFAULT;
DRM_COPY_FROM_USER_IOCTL( request, (drm_scatter_gather_t *)data,
sizeof(request) );
entry = dev->sg;
dev->sg = NULL;
if ( !entry || entry->handle != request.handle )
return -EINVAL;
return EINVAL;
DRM_DEBUG( "sg free virtual = %p\n", entry->virtual );
@ -237,3 +191,16 @@ int DRM(sg_free)( struct inode *inode, struct file *filp,
return 0;
}
#else /* __REALLY_HAVE_SG */
int DRM(sg_alloc)( DRM_IOCTL_ARGS )
{
return DRM_ERR(EINVAL);
}
int DRM(sg_free)( DRM_IOCTL_ARGS )
{
return DRM_ERR(EINVAL);
}
#endif

123
bsd-core/drm_sysctl.c
View File

@ -1,4 +1,10 @@
SYSCTL_NODE(_hw, OID_AUTO, dri, CTLFLAG_RW, 0, "DRI Graphics");
/*
* $FreeBSD: src/sys/dev/drm/drm_sysctl.h,v 1.1 2002/04/27 20:47:57 anholt Exp $
*/
#ifdef __FreeBSD__
#include <sys/sysctl.h>
static int DRM(name_info)DRM_SYSCTL_HANDLER_ARGS;
static int DRM(vm_info)DRM_SYSCTL_HANDLER_ARGS;
@ -32,8 +38,7 @@ struct DRM(sysctl_list) {
#define DRM_SYSCTL_ENTRIES (sizeof(DRM(sysctl_list))/sizeof(DRM(sysctl_list)[0]))
struct drm_sysctl_info {
struct sysctl_oid oids[DRM_SYSCTL_ENTRIES + 1];
struct sysctl_oid_list list;
struct sysctl_ctx_list ctx;
char name[2];
};
@ -41,65 +46,62 @@ int DRM(sysctl_init)(drm_device_t *dev)
{
struct drm_sysctl_info *info;
struct sysctl_oid *oid;
struct sysctl_oid *top;
struct sysctl_oid *top, *drioid;
int i;
/* Find the next free slot under hw.graphics */
info = DRM(alloc)(sizeof *info, DRM_MEM_DRIVER);
if ( !info )
return 1;
bzero(info, sizeof *info);
dev->sysctl = info;
/* Add the sysctl node for DRI if it doesn't already exist */
drioid = SYSCTL_ADD_NODE( &info->ctx, &sysctl__hw_children, OID_AUTO, "dri", CTLFLAG_RW, NULL, "DRI Graphics");
if (!drioid)
return 1;
/* Find the next free slot under hw.dri */
i = 0;
SLIST_FOREACH(oid, &sysctl__hw_dri_children, oid_link) {
SLIST_FOREACH(oid, SYSCTL_CHILDREN(drioid), oid_link) {
if (i <= oid->oid_arg2)
i = oid->oid_arg2 + 1;
}
if (i>9)
return 1;
info = DRM(alloc)(sizeof *info, DRM_MEM_DRIVER);
dev->sysctl = info;
/* Construct the node under hw.graphics */
/* Add the hw.dri.x for our device */
info->name[0] = '0' + i;
info->name[1] = 0;
oid = &info->oids[DRM_SYSCTL_ENTRIES];
bzero(oid, sizeof(*oid));
oid->oid_parent = &sysctl__hw_dri_children;
oid->oid_number = OID_AUTO;
oid->oid_kind = CTLTYPE_NODE | CTLFLAG_RW;
oid->oid_arg1 = &info->list;
oid->oid_arg2 = i;
oid->oid_name = info->name;
oid->oid_handler = 0;
oid->oid_fmt = "N";
SLIST_INIT(&info->list);
sysctl_register_oid(oid);
top = oid;
top = SYSCTL_ADD_NODE( &info->ctx, SYSCTL_CHILDREN(drioid), OID_AUTO, info->name, CTLFLAG_RW, NULL, NULL);
if (!top)
return 1;
for (i = 0; i < DRM_SYSCTL_ENTRIES; i++) {
oid = &info->oids[i];
bzero(oid, sizeof(*oid));
oid->oid_parent = top->oid_arg1;
oid->oid_number = OID_AUTO;
oid->oid_kind = CTLTYPE_INT | CTLFLAG_RD;
oid->oid_arg1 = dev;
oid->oid_arg2 = 0;
oid->oid_name = DRM(sysctl_list)[i].name;
oid->oid_handler = DRM(sysctl_list[)i].f;
oid->oid_fmt = "A";
sysctl_register_oid(oid);
oid = sysctl_add_oid( &info->ctx,
SYSCTL_CHILDREN(top),
OID_AUTO,
DRM(sysctl_list)[i].name,
CTLTYPE_INT | CTLFLAG_RD,
dev,
0,
DRM(sysctl_list)[i].f,
"A",
NULL);
if (!oid)
return 1;
}
return 0;
}
int DRM(sysctl_cleanup)(drm_device_t *dev)
{
int i;
DRM_DEBUG("dev->sysctl=%p\n", dev->sysctl);
for (i = 0; i < DRM_SYSCTL_ENTRIES + 1; i++)
sysctl_unregister_oid(&dev->sysctl->oids[i]);
int error;
error = sysctl_ctx_free( &dev->sysctl->ctx );
DRM(free)(dev->sysctl, sizeof *dev->sysctl, DRM_MEM_DRIVER);
dev->sysctl = NULL;
return 0;
return error;
}
static int DRM(name_info)DRM_SYSCTL_HANDLER_ARGS
@ -166,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;
}
@ -217,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;
}
@ -267,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;
}
@ -301,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;
}
@ -386,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
@ -515,9 +517,22 @@ 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
#elif defined(__NetBSD__)
/* stub it out for now, sysctl is only for debugging */
int DRM(sysctl_init)(drm_device_t *dev)
{
return 0;
}
int DRM(sysctl_cleanup)(drm_device_t *dev)
{
return 0;
}
#endif

26
bsd-core/drm_vm.c
View File

@ -1,9 +1,11 @@
#include <vm/vm.h>
#include <vm/pmap.h>
#ifdef __FreeBSD__
static int DRM(dma_mmap)(dev_t kdev, vm_offset_t offset, int prot)
#elif defined(__NetBSD__)
static paddr_t DRM(dma_mmap)(dev_t kdev, vm_offset_t offset, int prot)
#endif
{
drm_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
unsigned long physical;
unsigned long page;
@ -14,27 +16,30 @@ static int DRM(dma_mmap)(dev_t kdev, vm_offset_t offset, int prot)
page = offset >> PAGE_SHIFT;
physical = dma->pagelist[page];
DRM_DEBUG("0x%08x (page %lu) => 0x%08lx\n", offset, page, physical);
DRM_DEBUG("0x%08lx (page %lu) => 0x%08lx\n", (long)offset, page, physical);
return atop(physical);
}
#ifdef __FreeBSD__
int DRM(mmap)(dev_t kdev, vm_offset_t offset, int prot)
#elif defined(__NetBSD__)
paddr_t DRM(mmap)(dev_t kdev, off_t offset, int prot)
#endif
{
drm_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_map_t *map = NULL;
drm_map_list_entry_t *listentry=NULL;
/*drm_file_t *priv;*/
drm_file_t *priv;
/* DRM_DEBUG("offset = 0x%x\n", offset);*/
/*XXX Fixme */
/*priv = DRM(find_file_by_proc)(dev, p);
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
@ -59,7 +64,7 @@ int DRM(mmap)(dev_t kdev, vm_offset_t offset, int prot)
DRM_DEBUG("can't find map\n");
return -1;
}
if (((map->flags&_DRM_RESTRICTED) && suser(curproc))) {
if (((map->flags&_DRM_RESTRICTED) && DRM_SUSER(DRM_CURPROC))) {
DRM_DEBUG("restricted map\n");
return -1;
}
@ -69,6 +74,7 @@ int DRM(mmap)(dev_t kdev, vm_offset_t offset, int prot)
case _DRM_REGISTERS:
case _DRM_AGP:
return atop(offset);
case _DRM_SCATTER_GATHER:
case _DRM_SHM:
return atop(vtophys(offset));
default:

20
bsd-core/mga/Makefile
View File

@ -1,9 +1,10 @@
# $FreeBSD$
.PATH: ${.CURDIR}/..
KMOD= mga
NOMAN= YES
SRCS= mga_drv.c mga_state.c mga_warp.c mga_dma.c
SRCS+= device_if.h bus_if.h pci_if.h opt_drm_linux.h
SRCS+= device_if.h bus_if.h pci_if.h opt_drm.h
CFLAGS+= ${DEBUG_FLAGS} -I. -I..
@:
@ -12,14 +13,17 @@ CFLAGS+= ${DEBUG_FLAGS} -I. -I..
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#MGA_OPTS= "\#define DRM_LINUX" 1
.if defined(DRM_DEBUG)
DRM_DEBUG_OPT= "\#define DRM_DEBUG 1"
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(MGA_OPTS) >> opt_drm_linux.h
.if !defined(DRM_NOLINUX)
DRM_LINUX_OPT= "\#define DRM_LINUX 1"
.endif
opt_drm.h:
touch opt_drm.h
echo $(DRM_DEBUG_OPT) >> opt_drm.h
echo $(DRM_LINUX_OPT) >> opt_drm.h
.include <bsd.kmod.mk>

71
linux/mga.h → bsd-core/mga_drv.c
View File

@ -1,6 +1,7 @@
/* mga.h -- Matrox G200/G400 DRM template customization -*- linux-c -*-
* Created: Thu Jan 11 21:29:32 2001 by gareth@valinux.com
/* mga_drv.c -- Matrox G200/G400 driver -*- linux-c -*-
* Created: Mon Dec 13 01:56:22 1999 by jhartmann@precisioninsight.com
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
@ -24,44 +25,42 @@
* OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Rickard E. (Rik) Faith <faith@valinux.com>
* Gareth Hughes <gareth@valinux.com>
*/
#ifndef __MGA_H__
#define __MGA_H__
#include <sys/types.h>
/* This remains constant for all DRM template files.
#include "mga.h"
#include "drmP.h"
#include "drm.h"
#include "mga_drm.h"
#include "mga_drv.h"
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
* Please report to anholt@teleport.com inaccuracies or if a chip you have works that is marked unsupported here.
*/
#define DRM(x) mga_##x
drm_chipinfo_t DRM(devicelist)[] = {
{0x102b, 0x0520, 0, "Matrox G200 (PCI)"},
{0x102b, 0x0521, 1, "Matrox G200 (AGP)"},
{0x102b, 0x0525, 1, "Matrox G400/G450 (AGP)"},
{0x102b, 0x2527, 1, "Matrox G550 (AGP)"},
{0, 0, 0, NULL}
};
/* General customization:
*/
#define __HAVE_AGP 1
#define __MUST_HAVE_AGP 1
#define __HAVE_MTRR 1
#define __HAVE_CTX_BITMAP 1
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_vm.h"
#include "drm_sysctl.h"
/* Driver customization:
*/
#define DRIVER_PRETAKEDOWN() do { \
if ( dev->dev_private ) mga_do_cleanup_dma( dev ); \
} while (0)
/* DMA customization:
*/
#define __HAVE_DMA 1
#define __HAVE_DMA_QUIESCENT 1
#define DRIVER_DMA_QUIESCENT() do { \
drm_mga_private_t *dev_priv = dev->dev_private; \
return mga_do_wait_for_idle( dev_priv ); \
} while (0)
/* Buffer customization:
*/
#define DRIVER_BUF_PRIV_T drm_mga_buf_priv_t
#define DRIVER_AGP_BUFFERS_MAP( dev ) \
((drm_mga_private_t *)((dev)->dev_private))->buffers
#endif
DRIVER_MODULE(mga, pci, mga_driver, mga_devclass, 0, 0);

20
bsd-core/r128/Makefile
View File

@ -1,9 +1,10 @@
# $FreeBSD$
.PATH: ${.CURDIR}/..
KMOD = r128
NOMAN= YES
SRCS = r128_cce.c r128_drv.c r128_state.c
SRCS += device_if.h bus_if.h pci_if.h opt_drm_linux.h
SRCS += device_if.h bus_if.h pci_if.h opt_drm.h
CFLAGS += ${DEBUG_FLAGS} -I. -I..
@:
@ -12,14 +13,17 @@ CFLAGS += ${DEBUG_FLAGS} -I. -I..
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#R128_OPTS= "\#define DRM_LINUX" 1
.if defined(DRM_DEBUG)
DRM_DEBUG_OPT= "\#define DRM_DEBUG 1"
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(R128_OPTS) >> opt_drm_linux.h
.if !defined(DRM_NOLINUX)
DRM_LINUX_OPT= "\#define DRM_LINUX 1"
.endif
opt_drm.h:
touch opt_drm.h
echo $(DRM_DEBUG_OPT) >> opt_drm.h
echo $(DRM_LINUX_OPT) >> opt_drm.h
.include <bsd.kmod.mk>

86
bsd-core/r128_drv.c Normal file
View File

@ -0,0 +1,86 @@
/* r128_drv.c -- ATI Rage 128 driver -*- linux-c -*-
* Created: Mon Dec 13 09:47:27 1999 by faith@precisioninsight.com
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Rickard E. (Rik) Faith <faith@valinux.com>
* Gareth Hughes <gareth@valinux.com>
*/
#include <sys/types.h>
#include "r128.h"
#include "drmP.h"
#include "drm.h"
#include "r128_drm.h"
#include "r128_drv.h"
#if __REALLY_HAVE_SG
#include "ati_pcigart.h"
#endif
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
* Please report to eta@lclark.edu inaccuracies or if a chip you have works that is marked unsupported here.
*/
drm_chipinfo_t DRM(devicelist)[] = {
{0x1002, 0x4c45, __REALLY_HAVE_SG, "ATI Rage 128 Mobility LE (PCI)"},
{0x1002, 0x4c46, 1, "ATI Rage 128 Mobility LF (AGP)"},
{0x1002, 0x4d46, 1, "ATI Rage 128 Mobility MF (AGP)"},
{0x1002, 0x4d4c, 1, "ATI Rage 128 Mobility ML (AGP)"},
{0x1002, 0x5044, __REALLY_HAVE_SG, "ATI Rage 128 Pro PD (PCI)"},
{0x1002, 0x5046, 1, "ATI Rage 128 Pro PF (AGP)"},
{0x1002, 0x5050, __REALLY_HAVE_SG, "ATI Rage 128 Pro PP (PCI)"},
{0x1002, 0x5052, __REALLY_HAVE_SG, "ATI Rage 128 Pro PR (PCI)"},
{0x1002, 0x5245, __REALLY_HAVE_SG, "ATI Rage 128 RE (PCI)"},
{0x1002, 0x5246, 1, "ATI Rage 128 RF (AGP)"},
{0x1002, 0x5247, 1, "ATI Rage 128 RG (AGP)"},
{0x1002, 0x524b, __REALLY_HAVE_SG, "ATI Rage 128 RK (PCI)"},
{0x1002, 0x524c, 1, "ATI Rage 128 RL (AGP)"},
{0x1002, 0x534d, 1, "ATI Rage 128 SM (AGP)"},
{0x1002, 0x5446, 1, "ATI Rage 128 Pro Ultra TF (AGP)"},
{0x1002, 0x544C, 1, "ATI Rage 128 Pro Ultra TL (AGP)"},
{0x1002, 0x5452, 1, "ATI Rage 128 Pro Ultra TR (AGP)"},
{0, 0, 0, NULL}
};
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_sysctl.h"
#include "drm_vm.h"
#if __HAVE_SG
#include "drm_scatter.h"
#endif
DRIVER_MODULE(r128, pci, r128_driver, r128_devclass, 0, 0);

20
bsd-core/radeon/Makefile
View File

@ -1,9 +1,10 @@
# $FreeBSD$
.PATH: ${.CURDIR}/..
KMOD = radeon
NOMAN= YES
SRCS = radeon_cp.c radeon_drv.c radeon_state.c
SRCS += device_if.h bus_if.h pci_if.h opt_drm_linux.h
SRCS += device_if.h bus_if.h pci_if.h opt_drm.h
CFLAGS += ${DEBUG_FLAGS} -I. -I..
@:
@ -12,14 +13,17 @@ CFLAGS += ${DEBUG_FLAGS} -I. -I..
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#RADEON_OPTS= "\#define DRM_LINUX" 1
.if defined(DRM_DEBUG)
DRM_DEBUG_OPT= "\#define DRM_DEBUG 1"
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(RADEON_OPTS) >> opt_drm_linux.h
.if !defined(DRM_NOLINUX)
DRM_LINUX_OPT= "\#define DRM_LINUX 1"
.endif
opt_drm.h:
touch opt_drm.h
echo $(DRM_DEBUG_OPT) >> opt_drm.h
echo $(DRM_LINUX_OPT) >> opt_drm.h
.include <bsd.kmod.mk>

76
bsd-core/radeon_drv.c Normal file
View File

@ -0,0 +1,76 @@
/* radeon_drv.c -- ATI Radeon driver -*- linux-c -*-
* Created: Wed Feb 14 17:10:04 2001 by gareth@valinux.com
*
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Gareth Hughes <gareth@valinux.com>
*/
#include <sys/types.h>
#include "radeon.h"
#include "drmP.h"
#include "drm.h"
#include "radeon_drm.h"
#include "radeon_drv.h"
#if __REALLY_HAVE_SG
#include "ati_pcigart.h"
#endif
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
* Please report to eta@lclark.edu inaccuracies or if a chip you have works that is marked unsupported here.
*/
drm_chipinfo_t DRM(devicelist)[] = {
{0x1002, 0x4C57, 1, "ATI Radeon LW Mobility 7 (AGP)"},
{0x1002, 0x4C59, 1, "ATI Radeon LY Mobility 6 (AGP)"},
{0x1002, 0x4C5A, 1, "ATI Radeon LZ Mobility 6 (AGP)"},
{0x1002, 0x5144, 1, "ATI Radeon QD (AGP)"},
{0x1002, 0x5145, 1, "ATI Radeon QE (AGP)"},
{0x1002, 0x5146, 1, "ATI Radeon QF (AGP)"},
{0x1002, 0x5147, 1, "ATI Radeon QG (AGP)"},
{0x1002, 0x5157, 1, "ATI Radeon QW 7500 (AGP)"},
{0x1002, 0x5159, 1, "ATI Radeon QY VE (AGP)"},
{0x1002, 0x515A, 1, "ATI Radeon QZ VE (AGP)"},
{0, 0, 0, NULL}
};
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_vm.h"
#include "drm_sysctl.h"
#if __HAVE_SG
#include "drm_scatter.h"
#endif
DRIVER_MODULE(DRIVER_NAME, pci, DRM(driver), DRM(devclass), 0, 0);

25
bsd-core/sis/Makefile
View File

@ -1,25 +0,0 @@
# $FreeBSD$
KMOD= sis
NOMAN= YES
SRCS= sis_drv.c sis_ds.c sis_mm.c
SRCS+= device_if.h bus_if.h pci_if.h opt_drm_linux.h
CFLAGS+= ${DEBUG_FLAGS} -I. -I..
@:
ln -sf /sys @
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#SIS_OPTS= "\#define DRM_LINUX" 1
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(SIS_OPTS) >> opt_drm_linux.h
.include <bsd.kmod.mk>

20
bsd-core/tdfx/Makefile
View File

@ -1,9 +1,10 @@
# $FreeBSD$
.PATH: ${.CURDIR}/..
KMOD= tdfx
NOMAN= YES
SRCS= tdfx_drv.c
SRCS+= device_if.h bus_if.h pci_if.h opt_drm_linux.h
SRCS+= device_if.h bus_if.h pci_if.h opt_drm.h
CFLAGS+= ${DEBUG_FLAGS} -I. -I..
@:
@ -12,14 +13,17 @@ CFLAGS+= ${DEBUG_FLAGS} -I. -I..
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#TDFX_OPTS= "\#define DRM_LINUX" 1
.if defined(DRM_DEBUG)
DRM_DEBUG_OPT= "\#define DRM_DEBUG 1"
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(TDFX_OPTS) >> opt_drm_linux.h
.if !defined(DRM_NOLINUX)
DRM_LINUX_OPT= "\#define DRM_LINUX 1"
.endif
opt_drm.h:
touch opt_drm.h
echo $(DRM_DEBUG_OPT) >> opt_drm.h
echo $(DRM_LINUX_OPT) >> opt_drm.h
.include <bsd.kmod.mk>

5
bsd/tdfx/tdfx_drv.c → bsd-core/tdfx_drv.c
View File

@ -32,9 +32,6 @@
#include <sys/types.h>
#include <sys/bus.h>
#include <pci/pcivar.h>
#include <opt_drm_linux.h>
#include "tdfx.h"
#include "drmP.h"
@ -97,4 +94,6 @@ drm_chipinfo_t DRM(devicelist)[] = {
#include "drm_vm.h"
#include "drm_sysctl.h"
#ifdef __FreeBSD__
DRIVER_MODULE(tdfx, pci, tdfx_driver, tdfx_devclass, 0, 0);
#endif /* __FreeBSD__ */

19
bsd/Imakefile
View File

@ -1,3 +1,4 @@
XCOMM $XFree86: xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/Imakefile,v 1.8 2001/12/13 00:24:45 alanh Exp $
XCOMM This is a kludge until we determine how best to build the
@ -18,3 +19,21 @@ all::
clean::
$(MAKE) -f Makefile.bsd clean
LinkSourceFile(mga.h,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(mga_dma.c,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(mga_drm.h,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(mga_drv.h,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(mga_state.c,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(mga_ucode.h,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(mga_warp.c,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(r128.h,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(r128_cce.c,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(r128_drm.h,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(r128_drv.h,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(r128_state.c,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(radeon.h,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(radeon_cp.c,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(radeon_drm.h,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(radeon_drv.h,$(XF86OSSRC)/shared/drm/kernel)
LinkSourceFile(radeon_state.c,$(XF86OSSRC)/shared/drm/kernel)

87
bsd/ati_pcigart.h
View File

@ -27,7 +27,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#if PAGE_SIZE == 8192
@ -46,40 +45,20 @@
static unsigned long DRM(ati_alloc_pcigart_table)( void )
{
unsigned long address;
struct page *page;
int i;
DRM_DEBUG( "%s\n", __FUNCTION__ );
address = __get_free_pages( GFP_KERNEL, ATI_PCIGART_TABLE_ORDER );
if ( address == 0UL ) {
return 0;
}
DRM_DEBUG( "\n" );
page = virt_to_page( address );
address = (unsigned long) malloc( (1 << ATI_PCIGART_TABLE_ORDER) * PAGE_SIZE, DRM(M_DRM), M_WAITOK );
for ( i = 0 ; i <= ATI_PCIGART_TABLE_PAGES ; i++, page++ ) {
atomic_inc( &page->count );
SetPageReserved( page );
}
DRM_DEBUG( "%s: returning 0x%08lx\n", __FUNCTION__, address );
DRM_DEBUG( "returning 0x%08lx\n", address );
return address;
}
static void DRM(ati_free_pcigart_table)( unsigned long address )
{
struct page *page;
int i;
DRM_DEBUG( "%s\n", __FUNCTION__ );
DRM_DEBUG( "\n" );
page = virt_to_page( address );
for ( i = 0 ; i <= ATI_PCIGART_TABLE_PAGES ; i++, page++ ) {
atomic_dec( &page->count );
ClearPageReserved( page );
}
free_pages( address, ATI_PCIGART_TABLE_ORDER );
free( (void *)address, DRM(M_DRM));
}
int DRM(ati_pcigart_init)( drm_device_t *dev,
@ -89,7 +68,7 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
drm_sg_mem_t *entry = dev->sg;
unsigned long address = 0;
unsigned long pages;
u32 *pci_gart, page_base, bus_address = 0;
u32 *pci_gart=0, page_base, bus_address = 0;
int i, j, ret = 0;
if ( !entry ) {
@ -103,41 +82,36 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
goto done;
}
if ( !dev->pdev ) {
DRM_ERROR( "PCI device unknown!\n" );
goto done;
}
bus_address = pci_map_single(dev->pdev, (void *)address,
/* FIXME non-vtophys==bustophys-arches */
bus_address = vtophys( address );
/*pci_map_single(dev->pdev, (void *)address,
ATI_PCIGART_TABLE_PAGES * PAGE_SIZE,
PCI_DMA_TODEVICE);
if (bus_address == 0) {
PCI_DMA_TODEVICE);*/
/* if (bus_address == 0) {
DRM_ERROR( "unable to map PCIGART pages!\n" );
DRM(ati_free_pcigart_table)( address );
DRM(ati_free_pcigart_table)( (unsigned long)address );
address = 0;
goto done;
}
}*/
pci_gart = (u32 *)address;
pages = ( entry->pages <= ATI_MAX_PCIGART_PAGES )
? entry->pages : ATI_MAX_PCIGART_PAGES;
memset( pci_gart, 0, ATI_MAX_PCIGART_PAGES * sizeof(u32) );
bzero( pci_gart, ATI_MAX_PCIGART_PAGES * sizeof(u32) );
for ( i = 0 ; i < pages ; i++ ) {
/* we need to support large memory configurations */
entry->busaddr[i] = pci_map_single(dev->pdev,
page_address( entry->pagelist[i] ),
PAGE_SIZE,
PCI_DMA_TODEVICE);
if (entry->busaddr[i] == 0) {
/* FIXME non-vtophys==vtobus-arches */
entry->busaddr[i] = vtophys( entry->handle + (i*PAGE_SIZE) );
/* if (entry->busaddr[i] == 0) {
DRM_ERROR( "unable to map PCIGART pages!\n" );
DRM(ati_pcigart_cleanup)( dev, address, bus_address );
DRM(ati_pcigart_cleanup)( dev, (unsigned long)address, bus_address );
address = 0;
bus_address = 0;
goto done;
}
}*/
page_base = (u32) entry->busaddr[i];
for (j = 0; j < (PAGE_SIZE / ATI_PCIGART_PAGE_SIZE); j++) {
@ -148,11 +122,7 @@ int DRM(ati_pcigart_init)( drm_device_t *dev,
ret = 1;
#if defined(__i386__) || defined(__x86_64__)
asm volatile ( "wbinvd" ::: "memory" );
#else
mb();
#endif
DRM_READMEMORYBARRIER();
done:
*addr = address;
@ -165,8 +135,6 @@ int DRM(ati_pcigart_cleanup)( drm_device_t *dev,
dma_addr_t bus_addr)
{
drm_sg_mem_t *entry = dev->sg;
unsigned long pages;
int i;
/* we need to support large memory configurations */
if ( !entry ) {
@ -174,21 +142,6 @@ int DRM(ati_pcigart_cleanup)( drm_device_t *dev,
return 0;
}
if ( bus_addr ) {
pci_unmap_single(dev->pdev, bus_addr,
ATI_PCIGART_TABLE_PAGES * PAGE_SIZE,
PCI_DMA_TODEVICE);
pages = ( entry->pages <= ATI_MAX_PCIGART_PAGES )
? entry->pages : ATI_MAX_PCIGART_PAGES;
for ( i = 0 ; i < pages ; i++ ) {
if ( !entry->busaddr[i] ) break;
pci_unmap_single(dev->pdev, entry->busaddr[i],
PAGE_SIZE, PCI_DMA_TODEVICE);
}
}
if ( addr ) {
DRM(ati_free_pcigart_table)( addr );
}

38
bsd/drm.h
View File

@ -35,8 +35,31 @@
#ifndef _DRM_H_
#define _DRM_H_
#if defined(__linux__)
#include <linux/config.h>
#include <asm/ioctl.h> /* For _IO* macros */
#define DRM_IOCTL_NR(n) _IOC_NR(n)
#define DRM_IOC_VOID _IOC_NONE
#define DRM_IOC_READ _IOC_READ
#define DRM_IOC_WRITE _IOC_WRITE
#define DRM_IOC_READWRITE _IOC_READ|_IOC_WRITE
#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
#elif defined(__FreeBSD__) || defined(__NetBSD__)
#if defined(__FreeBSD__) && defined(XFree86Server)
/* Prevent name collision when including sys/ioccom.h */
#undef ioctl
#include <sys/ioccom.h>
#define DRM_IOCTL_NR(n) ((n) & 0xff)
#define ioctl(a,b,c) xf86ioctl(a,b,c)
#else
#include <sys/ioccom.h>
#endif /* __FreeBSD__ && xf86ioctl */
#define DRM_IOCTL_NR(n) ((n) & 0xff)
#define DRM_IOC_VOID IOC_VOID
#define DRM_IOC_READ IOC_OUT
#define DRM_IOC_WRITE IOC_IN
#define DRM_IOC_READWRITE IOC_INOUT
#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
#endif
#define XFREE86_VERSION(major,minor,patch,snap) \
((major << 16) | (minor << 8) | patch)
@ -62,7 +85,7 @@
#define DRM_NAME "drm" /* Name in kernel, /dev, and /proc */
#define DRM_MIN_ORDER 5 /* At least 2^5 bytes = 32 bytes */
#define DRM_MAX_ORDER 22 /* Up to 2^22 bytes = 4MB */
#define DRM_RAM_PERCENT 50 /* How much system ram can we lock? */
#define DRM_RAM_PERCENT 10 /* How much system ram can we lock? */
#define _DRM_LOCK_HELD 0x80000000 /* Hardware lock is held */
#define _DRM_LOCK_CONT 0x40000000 /* Hardware lock is contended */
@ -78,6 +101,10 @@ typedef unsigned int drm_magic_t;
/* Warning: If you change this structure, make sure you change
* XF86DRIClipRectRec in the server as well */
/* KW: Actually it's illegal to change either for
* backwards-compatibility reasons.
*/
typedef struct drm_clip_rect {
unsigned short x1;
unsigned short y1;
@ -357,10 +384,9 @@ typedef struct drm_scatter_gather {
#define DRM_IOCTL_BASE 'd'
#define DRM_IO(nr) _IO(DRM_IOCTL_BASE,nr)
#define DRM_IOR(nr,size) _IOR(DRM_IOCTL_BASE,nr,size)
#define DRM_IOW(nr,size) _IOW(DRM_IOCTL_BASE,nr,size)
#define DRM_IOWR(nr,size) _IOWR(DRM_IOCTL_BASE,nr,size)
#define DRM_IOR(nr,type) _IOR(DRM_IOCTL_BASE,nr,type)
#define DRM_IOW(nr,type) _IOW(DRM_IOCTL_BASE,nr,type)
#define DRM_IOWR(nr,type) _IOWR(DRM_IOCTL_BASE,nr,type)
#define DRM_IOCTL_VERSION DRM_IOWR(0x00, drm_version_t)
#define DRM_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm_unique_t)

64
bsd/drmP.h
View File

@ -69,7 +69,11 @@ typedef struct drm_file drm_file_t;
/* There's undoubtably more of this file to go into these OS dependent ones. */
#ifdef __FreeBSD__
#include "drm_os_freebsd.h"
#elif defined __NetBSD__
#include "drm_os_netbsd.h"
#endif
#include "drm.h"
@ -239,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 {
@ -252,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 {
@ -374,6 +378,7 @@ typedef struct drm_sg_mem {
void *virtual;
int pages;
struct page **pagelist;
dma_addr_t *busaddr;
} drm_sg_mem_t;
typedef struct drm_sigdata {
@ -388,20 +393,24 @@ typedef struct drm_map_list_entry {
} drm_map_list_entry_t;
struct drm_device {
#ifdef __NetBSD__
struct device device; /* NetBSD's softc is an extension of struct device */
#endif
const char *name; /* Simple driver name */
char *unique; /* Unique identifier: e.g., busid */
int unique_len; /* Length of unique field */
#ifdef __FreeBSD__
device_t device; /* Device instance from newbus */
#endif
dev_t devnode; /* Device number for mknod */
char *devname; /* For /proc/interrupts */
int blocked; /* Blocked due to VC switch? */
int flags; /* Flags to open(2) */
int writable; /* Opened with FWRITE */
struct proc_dir_entry *root; /* Root for this device's entries */
/* 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 */
@ -437,12 +446,17 @@ struct drm_device {
drm_device_dma_t *dma; /* Optional pointer for DMA support */
/* Context support */
#ifdef __FreeBSD__
int irq; /* Interrupt used by board */
struct resource *irqr; /* Resource for interrupt used by board */
#elif defined(__NetBSD__)
struct pci_attach_args pa;
pci_intr_handle_t ih;
#endif
void *irqh; /* Handle from bus_setup_intr */
__volatile__ long context_flag; /* Context swapping flag */
__volatile__ long interrupt_flag; /* Interruption handler flag */
__volatile__ long dma_flag; /* DMA dispatch flag */
atomic_t context_flag; /* Context swapping flag */
atomic_t interrupt_flag; /* Interruption handler flag */
atomic_t dma_flag; /* DMA dispatch flag */
struct callout timer; /* Timer for delaying ctx switch */
wait_queue_head_t context_wait; /* Processes waiting on ctx switch */
int last_checked; /* Last context checked for DMA */
@ -463,7 +477,11 @@ struct drm_device {
char *buf_rp; /* Read pointer */
char *buf_wp; /* Write pointer */
char *buf_end; /* End pointer */
#ifdef __FreeBSD__
struct sigio *buf_sigio; /* Processes waiting for SIGIO */
#elif defined(__NetBSD__)
pid_t buf_pgid;
#endif
struct selinfo buf_sel; /* Workspace for select/poll */
int buf_selecting;/* True if poll sleeper */
wait_queue_head_t buf_readers; /* Processes waiting to read */
@ -474,17 +492,9 @@ struct drm_device {
#if __REALLY_HAVE_AGP
drm_agp_head_t *agp;
#endif
struct pci_dev *pdev;
#ifdef __alpha__
#if LINUX_VERSION_CODE < 0x020403
struct pci_controler *hose;
#else
struct pci_controller *hose;
#endif
#endif
drm_sg_mem_t *sg; /* Scatter gather memory */
unsigned long *ctx_bitmap;
atomic_t *ctx_bitmap;
void *dev_private;
drm_sigdata_t sigdata; /* For block_all_signals */
sigset_t sigmask;
@ -500,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) */
@ -511,9 +521,6 @@ extern void *DRM(realloc)(void *oldpt, size_t oldsize, size_t size,
extern char *DRM(strdup)(const char *s, int area);
extern void DRM(strfree)(char *s, int area);
extern void DRM(free)(void *pt, size_t size, int area);
extern unsigned long DRM(alloc_pages)(int order, int area);
extern void DRM(free_pages)(unsigned long address, int order,
int area);
extern void *DRM(ioremap)(unsigned long offset, unsigned long size);
extern void *DRM(ioremap_nocache)(unsigned long offset, unsigned long size);
extern void DRM(ioremapfree)(void *pt, unsigned long size);
@ -571,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
@ -608,15 +615,6 @@ extern int DRM(agp_bind_memory)(agp_memory *handle, off_t start);
extern int DRM(agp_unbind_memory)(agp_memory *handle);
#endif
/* Proc support (drm_proc.h) */
extern struct proc_dir_entry *DRM(proc_init)(drm_device_t *dev,
int minor,
struct proc_dir_entry *root,
struct proc_dir_entry **dev_root);
extern int DRM(proc_cleanup)(int minor,
struct proc_dir_entry *root,
struct proc_dir_entry *dev_root);
#if __HAVE_SG
/* Scatter Gather Support (drm_scatter.h) */
extern void DRM(sg_cleanup)(drm_sg_mem_t *entry);
@ -633,4 +631,4 @@ extern int DRM(ati_pcigart_cleanup)(drm_device_t *dev,
#endif
#endif /* __KERNEL__ */
#endif
#endif /* _DRM_P_H_ */

54
bsd/drm_agpsupport.h
View File

@ -31,15 +31,9 @@
#include "drmP.h"
#include <vm/vm.h>
#include <vm/pmap.h>
#if __REALLY_HAVE_AGP
#include <sys/agpio.h>
#endif
int DRM(agp_info)(DRM_OS_IOCTL)
int DRM(agp_info)(DRM_IOCTL_ARGS)
{
drm_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
struct agp_info *kern;
drm_agp_info_t info;
@ -61,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
int retcode;
if (!dev->agp || dev->agp->acquired) return EINVAL;
@ -73,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
if (!dev->agp || !dev->agp->acquired)
return EINVAL;
@ -89,14 +83,14 @@ void DRM(agp_do_release)(void)
{
device_t agpdev;
agpdev = 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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_agp_mode_t mode;
if (!dev->agp || !dev->agp->acquired) return EINVAL;
@ -110,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_agp_buffer_t request;
drm_agp_mem_t *entry;
void *handle;
@ -165,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_agp_binding_t request;
drm_agp_mem_t *entry;
int retcode;
@ -187,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_agp_binding_t request;
drm_agp_mem_t *entry;
int retcode;
@ -209,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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_agp_buffer_t request;
drm_agp_mem_t *entry;
@ -235,7 +229,7 @@ drm_agp_head_t *DRM(agp_init)(void)
drm_agp_head_t *head = NULL;
int agp_available = 1;
agpdev = agp_find_device();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev)
agp_available = 0;
@ -267,9 +261,9 @@ drm_agp_head_t *DRM(agp_init)(void)
default:
}
#endif
DRM_INFO("AGP at 0x%08x %dMB\n",
DRM_INFO("AGP at 0x%08lx %dMB\n",
head->info.ai_aperture_base,
head->info.ai_aperture_size >> 20);
(int)(head->info.ai_aperture_size >> 20));
}
return head;
}
@ -284,7 +278,7 @@ agp_memory *DRM(agp_allocate_memory)(size_t pages, u32 type)
{
device_t agpdev;
agpdev = agp_find_device();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev)
return NULL;
@ -295,7 +289,7 @@ int DRM(agp_free_memory)(agp_memory *handle)
{
device_t agpdev;
agpdev = agp_find_device();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return 0;
@ -307,7 +301,7 @@ int DRM(agp_bind_memory)(agp_memory *handle, off_t start)
{
device_t agpdev;
agpdev = agp_find_device();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return EINVAL;
@ -318,7 +312,7 @@ int DRM(agp_unbind_memory)(agp_memory *handle)
{
device_t agpdev;
agpdev = agp_find_device();
agpdev = DRM_AGP_FIND_DEVICE();
if (!agpdev || !handle)
return EINVAL;

44
bsd/drm_auth.h
View File

@ -29,7 +29,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
static int DRM(hash_magic)(drm_magic_t magic)
@ -43,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;
}
@ -63,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;
@ -77,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;
}
@ -91,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) {
@ -103,28 +102,27 @@ int DRM(remove_magic)(drm_device_t *dev, drm_magic_t magic)
if (prev) {
prev->next = pt->next;
}
DRM_OS_UNLOCK;
DRM(free)(pt, sizeof(*pt), DRM_MEM_MAGIC);
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;
}
@ -133,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);
@ -144,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))) {
@ -163,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);
}

388
bsd/drm_bufs.h
View File

@ -29,14 +29,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include <machine/param.h>
#include <sys/mman.h>
#include <vm/vm.h>
#include <vm/pmap.h>
#include <vm/vm_extern.h>
#include <vm/vm_map.h>
#include <vm/vm_param.h>
#include "drmP.h"
#ifndef __HAVE_PCI_DMA
@ -74,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;
@ -95,30 +87,17 @@ 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;
TAILQ_FOREACH(list, dev->maplist, link) {
drm_map_t *entry = list->map;
if ( (entry->offset >= map->offset
&& (entry->offset) < (map->offset + map->size) )
|| ((entry->offset + entry->size) >= map->offset
&& (entry->offset + entry->size) < (map->offset + map->size) )
|| ((entry->offset < map->offset)
&& (entry->offset + entry->size) >= (map->offset + map->size) ) )
DRM_DEBUG("map collission: add(0x%lx-0x%lx), current(0x%lx-0x%lx)\n",
entry->offset, entry->offset + entry->size - 1,
map->offset, map->offset + map->size - 1);
}
switch ( map->type ) {
case _DRM_REGISTERS:
case _DRM_FRAME_BUFFER:
@ -126,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__
@ -135,23 +114,41 @@ int DRM(addmap)( DRM_OS_IOCTL )
#if __REALLY_HAVE_MTRR
if ( map->type == _DRM_FRAME_BUFFER ||
(map->flags & _DRM_WRITE_COMBINING) ) {
map->mtrr = mtrr_add( map->offset, map->size,
MTRR_TYPE_WRCOMB, 1 );
}
#ifdef __FreeBSD__
int retcode = 0, act;
struct mem_range_desc mrdesc;
mrdesc.mr_base = map->offset;
mrdesc.mr_len = map->size;
mrdesc.mr_flags = MDF_WRITECOMBINE;
act = MEMRANGE_SET_UPDATE;
bcopy(DRIVER_NAME, &mrdesc.mr_owner, strlen(DRIVER_NAME));
retcode = mem_range_attr_set(&mrdesc, &act);
map->mtrr=1;
#elif defined __NetBSD__
struct mtrr mtrrmap;
int one = 1;
mtrrmap.base = map->offset;
mtrrmap.len = map->size;
mtrrmap.type = MTRR_TYPE_WC;
mtrrmap.flags = MTRR_PRIVATE | MTRR_VALID;
mtrrmap.owner = p->p_pid;
/* USER? KERNEL? XXX */
map->mtrr = mtrr_get( &mtrrmap, &one, p, MTRR_GETSET_KERNEL );
#endif
}
#endif /* __REALLY_HAVE_MTRR */
map->handle = DRM(ioremap)( map->offset, map->size );
break;
case _DRM_SHM:
DRM_INFO( "%ld %d %d\n",
map->size, DRM(order)( map->size ), PAGE_SHIFT);
map->handle = (void *)DRM(alloc_pages)
(DRM(order)(map->size) - PAGE_SHIFT, DRM_MEM_SAREA);
map->handle = (void *)DRM(alloc)(map->size, DRM_MEM_SAREA);
DRM_DEBUG( "%ld %d %p\n",
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 ) {
@ -170,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;
@ -205,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 &&
@ -226,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);
@ -240,16 +237,32 @@ int DRM(rmmap)( DRM_OS_IOCTL )
#if __REALLY_HAVE_MTRR
if (map->mtrr >= 0) {
int retcode;
retcode = mtrr_del(map->mtrr,
map->offset,
map->size);
#ifdef __FreeBSD__
int act;
struct mem_range_desc mrdesc;
mrdesc.mr_base = map->offset;
mrdesc.mr_len = map->size;
mrdesc.mr_flags = MDF_WRITECOMBINE;
act = MEMRANGE_SET_REMOVE;
bcopy(DRIVER_NAME, &mrdesc.mr_owner, strlen(DRIVER_NAME));
retcode = mem_range_attr_set(&mrdesc, &act);
#elif defined __NetBSD__
struct mtrr mtrrmap;
int one = 1;
mtrrmap.base = map->offset;
mtrrmap.len = map->size;
mtrrmap.type = 0;
mtrrmap.flags = 0;
mtrrmap.owner = p->p_pid;
retcode = mtrr_set( &mtrrmap, &one, p, MTRR_GETSET_KERNEL);
DRM_DEBUG("mtrr_del = %d\n", retcode);
#endif
}
#endif
DRM(ioremapfree)(map->handle, map->size);
break;
case _DRM_SHM:
DRM(free_pages)( (unsigned long)map->handle, DRM(order)(map->size), DRM_MEM_SAREA );
DRM(free)( map->handle, map->size, DRM_MEM_SAREA );
break;
case _DRM_AGP:
case _DRM_SCATTER_GATHER:
@ -257,7 +270,7 @@ int DRM(rmmap)( DRM_OS_IOCTL )
}
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
@ -270,8 +283,8 @@ static void DRM(cleanup_buf_error)(drm_buf_entry_t *entry)
if (entry->seg_count) {
for (i = 0; i < entry->seg_count; i++) {
DRM(free_pages)(entry->seglist[i],
entry->page_order,
DRM(free)((void *)entry->seglist[i],
entry->buf_size,
DRM_MEM_DMA);
}
DRM(free)(entry->seglist,
@ -304,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;
@ -323,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 );
@ -348,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) );
@ -436,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;
@ -458,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;
@ -473,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;
@ -494,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 );
@ -507,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) );
@ -553,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) );
@ -571,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;
@ -586,7 +599,7 @@ int DRM(addbufs_pci)( DRM_OS_IOCTL )
page_count = 0;
while ( entry->buf_count < count ) {
page = DRM(alloc_pages)( page_order, DRM_MEM_DMA );
page = (unsigned long)DRM(alloc)( size, DRM_MEM_DMA );
if ( !page ) break;
entry->seglist[entry->seg_count++] = page;
for ( i = 0 ; i < (1 << page_order) ; i++ ) {
@ -631,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;
@ -652,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;
@ -666,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;
@ -685,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 );
@ -710,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) );
@ -772,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 );
@ -803,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;
@ -825,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;
@ -839,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 )
@ -858,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;
@ -894,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,
@ -920,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;
@ -955,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 );
}
@ -991,32 +1004,43 @@ 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;
vm_offset_t virtual, address;
#ifdef __FreeBSD__
#if __FreeBSD_version >= 500000
struct vmspace *vms = p->td_proc->p_vmspace;
#else
struct vmspace *vms = p->p_vmspace;
#endif
#endif /* __FreeBSD__ */
#ifdef __NetBSD__
struct vnode *vn;
#endif /* __NetBSD__ */
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))
return 0; /* FIXME: Shouldn't this be EINVAL or something? */
#endif /* __NetBSD__ */
if ( request.count >= dma->buf_count ) {
if ( (__HAVE_AGP && (dma->flags & _DRM_DMA_USE_AGP)) ||
@ -1028,6 +1052,7 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
goto done;
}
#ifdef __FreeBSD__
virtual = round_page((vm_offset_t)vms->vm_daddr + MAXDSIZ);
retcode = vm_mmap(&vms->vm_map,
&virtual,
@ -1036,7 +1061,18 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
MAP_SHARED,
SLIST_FIRST(&kdev->si_hlist),
(unsigned long)map->offset );
#elif defined(__NetBSD__)
virtual = round_page((vaddr_t)vms->vm_daddr + MAXDSIZ);
retcode = uvm_mmap(&vms->vm_map,
(vaddr_t *)&virtual,
round_page(map->size),
UVM_PROT_READ | UVM_PROT_WRITE,
UVM_PROT_ALL, MAP_SHARED,
&vn->v_uobj, map->offset,
p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur);
#endif /* __NetBSD__ */
} else {
#ifdef __FreeBSD__
virtual = round_page((vm_offset_t)vms->vm_daddr + MAXDSIZ);
retcode = vm_mmap(&vms->vm_map,
&virtual,
@ -1045,32 +1081,42 @@ int DRM(mapbufs)( DRM_OS_IOCTL )
MAP_SHARED,
SLIST_FIRST(&kdev->si_hlist),
0);
#elif defined(__NetBSD__)
virtual = round_page((vaddr_t)vms->vm_daddr + MAXDSIZ);
retcode = uvm_mmap(&vms->vm_map,
(vaddr_t *)&virtual,
round_page(dma->byte_count),
UVM_PROT_READ | UVM_PROT_WRITE,
UVM_PROT_ALL, MAP_SHARED,
&vn->v_uobj, 0,
p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur);
#endif /* __NetBSD__ */
}
if (retcode)
goto done;
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;
@ -1083,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 */

191
bsd/drm_context.h
View File

@ -29,7 +29,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#if __HAVE_CTX_BITMAP
@ -44,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:
@ -62,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 );
@ -80,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;
@ -93,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;
}
@ -111,17 +110,17 @@ int DRM(ctxbitmap_init)( drm_device_t *dev )
int i;
int temp;
DRM_OS_LOCK;
dev->ctx_bitmap = (unsigned long *) DRM(alloc)( PAGE_SIZE,
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 );
@ -133,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)
@ -189,8 +188,8 @@ int DRM(setsareactx)( DRM_OS_IOCTL )
}
bad:
DRM_OS_UNLOCK;
return -EINVAL;
DRM_UNLOCK;
return DRM_ERR(EINVAL);
found:
map = list->map;
@ -200,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;
}
@ -214,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
@ -256,41 +255,41 @@ int DRM(context_switch_complete)( drm_device_t *dev, int new )
#endif
clear_bit( 0, &dev->context_flag );
DRM_OS_WAKEUP( &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 ) {
@ -301,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 );
@ -353,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 ) {
@ -387,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
@ -398,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) {
@ -411,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) {
@ -450,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;
}
@ -514,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));
@ -532,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;
@ -552,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. */
@ -586,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;
@ -623,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);
@ -676,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 */
@ -717,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

77
bsd/drm_dma.h
View File

@ -29,10 +29,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/rman.h>
#include "drmP.h"
#ifndef __HAVE_DMA_WAITQUEUE
@ -59,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) );
@ -85,8 +81,8 @@ void DRM(dma_takedown)(drm_device_t *dev)
dma->bufs[i].buf_count,
dma->bufs[i].seg_count);
for (j = 0; j < dma->bufs[i].seg_count; j++) {
DRM(free_pages)(dma->bufs[i].seglist[j],
dma->bufs[i].page_order,
DRM(free)((void *)dma->bufs[i].seglist[j],
dma->bufs[i].buf_size,
DRM_MEM_DMA);
}
DRM(free)(dma->bufs[i].seglist,
@ -197,7 +193,7 @@ void DRM(free_buffer)(drm_device_t *dev, drm_buf_t *buf)
#endif
if ( buf->dma_wait ) {
wakeup( &buf->dma_wait );
wakeup( (void *)&buf->dma_wait );
buf->dma_wait = 0;
}
#if __HAVE_DMA_FREELIST
@ -248,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;
}
@ -340,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) {
@ -348,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;
@ -378,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;
@ -403,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
@ -444,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;
}
@ -511,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 );
@ -548,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;
}
@ -565,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 );
@ -583,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:
@ -596,25 +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_OS_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:
case DRM_UNINST_HANDLER:
return 0;
default:
DRM_OS_RETURN(EINVAL);
return DRM_ERR(EINVAL);
}
}

7
bsd/drm_drawable.h
View File

@ -29,22 +29,21 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#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 */
}

561
bsd/drm_drv.h
View File

@ -116,15 +116,7 @@
#define DRIVER_IOCTLS
#endif
#ifndef DRIVER_FOPS
#if DRM_LINUX
#include <sys/file.h>
#include <sys/proc.h>
#include <machine/../linux/linux.h>
#include <machine/../linux/linux_proto.h>
#include "drm_linux.h"
#endif
#endif
/*
* The default number of instances (minor numbers) to initialize.
@ -133,9 +125,15 @@
#define DRIVER_NUM_CARDS 1
#endif
#ifdef __FreeBSD__
static int DRM(init)(device_t nbdev);
static void DRM(cleanup)(device_t nbdev);
#elif defined(__NetBSD__)
static int DRM(init)(drm_device_t *);
static void DRM(cleanup)(drm_device_t *);
#endif
#ifdef __FreeBSD__
#define CDEV_MAJOR 145
#define DRIVER_SOFTC(unit) \
((drm_device_t *) devclass_get_softc(DRM(devclass), unit))
@ -146,11 +144,13 @@ MODULE_DEPEND(DRIVER_NAME, agp, 1, 1, 1);
#if DRM_LINUX
MODULE_DEPEND(DRIVER_NAME, linux, 1, 1, 1);
#endif
#endif /* __FreeBSD__ */
static drm_device_t *DRM(device);
static int *DRM(minor);
static int DRM(numdevs) = 0;
#ifdef __NetBSD__
#define CDEV_MAJOR 90
#define DRIVER_SOFTC(unit) \
((drm_device_t *) device_lookup(&DRM(_cd), unit))
#endif /* __NetBSD__ */
static drm_ioctl_desc_t DRM(ioctls)[] = {
[DRM_IOCTL_NR(DRM_IOCTL_VERSION)] = { DRM(version), 0, 0 },
@ -212,7 +212,7 @@ static drm_ioctl_desc_t DRM(ioctls)[] = {
[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] = { DRM(agp_unbind), 1, 1 },
#endif
#if __REALLY_HAVE_SG
#if __HAVE_SG
[DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] = { DRM(sg_alloc), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] = { DRM(sg_free), 1, 1 },
#endif
@ -222,28 +222,18 @@ static drm_ioctl_desc_t DRM(ioctls)[] = {
#define DRIVER_IOCTL_COUNT DRM_ARRAY_SIZE( DRM(ioctls) )
const char *DRM(find_description)(int vendor, int device);
#ifdef __FreeBSD__
static int DRM(probe)(device_t dev)
{
const char *s = 0;
const char *s = NULL;
int pciid=pci_get_devid(dev);
int vendor = (pciid & 0x0000ffff);
int device = (pciid & 0xffff0000) >> 16;
int i=0, done=0;
DRM_INFO("Checking PCI vendor=%d, device=%d\n", vendor, device);
while ( !done && (DRM(devicelist)[i].vendor != 0 ) ) {
if ( (DRM(devicelist)[i].vendor == vendor) &&
(DRM(devicelist)[i].device == device) ) {
done=1;
if ( DRM(devicelist)[i].supported )
s = DRM(devicelist)[i].name;
else
DRM_INFO("%s not supported\n", DRM(devicelist)[i].name);
}
i++;
}
s = DRM(find_description)(vendor, device);
if (s) {
device_set_desc(dev, s);
return 0;
@ -262,7 +252,6 @@ static int DRM(detach)(device_t dev)
DRM(cleanup)(dev);
return 0;
}
static device_method_t DRM(methods)[] = {
/* Device interface */
DEVMETHOD(device_probe, DRM( probe)),
@ -301,6 +290,78 @@ static struct cdevsw DRM( cdevsw) = {
#endif
};
#elif defined(__NetBSD__)
int DRM(probe)(struct device *parent, struct cfdata *match, void *aux);
void DRM(attach)(struct device *parent, struct device *self, void *aux);
int DRM(detach)(struct device *self, int flags);
int DRM(activate)(struct device *self, enum devact act);
struct cfattach DRM(_ca) = {
sizeof(drm_device_t), DRM(probe),
DRM(attach), DRM(detach), DRM(activate) };
int DRM(probe)(struct device *parent, struct cfdata *match, void *aux)
{
struct pci_attach_args *pa = aux;
const char *desc;
desc = DRM(find_description)(PCI_VENDOR(pa->pa_id), PCI_PRODUCT(pa->pa_id));
if (desc != NULL)
return 10;
return 0;
}
void DRM(attach)(struct device *parent, struct device *self, void *aux)
{
struct pci_attach_args *pa = aux;
drm_device_t *dev = (drm_device_t *)self;
memcpy(&dev->pa, aux, sizeof(dev->pa));
DRM_INFO("%s", DRM(find_description)(PCI_VENDOR(pa->pa_id), PCI_PRODUCT(pa->pa_id)));
DRM(init)(dev);
}
int DRM(detach)(struct device *self, int flags)
{
DRM(cleanup)((drm_device_t *)self);
return 0;
}
int DRM(activate)(struct device *self, enum devact act)
{
switch (act) {
case DVACT_ACTIVATE:
return (EOPNOTSUPP);
break;
case DVACT_DEACTIVATE:
/* FIXME */
break;
}
return (0);
}
#endif
const char *DRM(find_description)(int vendor, int device) {
const char *s = NULL;
int i=0, done=0;
while ( !done && (DRM(devicelist)[i].vendor != 0 ) ) {
if ( (DRM(devicelist)[i].vendor == vendor) &&
(DRM(devicelist)[i].device == device) ) {
done=1;
if ( DRM(devicelist)[i].supported )
s = DRM(devicelist)[i].name;
else
DRM_INFO("%s not supported\n", DRM(devicelist)[i].name);
}
i++;
}
return s;
}
static int DRM(setup)( drm_device_t *dev )
{
int i;
@ -365,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;
@ -397,7 +458,11 @@ static int DRM(setup)( drm_device_t *dev )
dev->buf_rp = dev->buf;
dev->buf_wp = dev->buf;
dev->buf_end = dev->buf + DRM_BSZ;
#ifdef __FreeBSD__
dev->buf_sigio = NULL;
#elif defined(__NetBSD__)
dev->buf_pgid = 0;
#endif
dev->buf_readers = 0;
dev->buf_writers = 0;
dev->buf_selecting = 0;
@ -430,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 ) {
@ -495,18 +560,36 @@ static int DRM(takedown)( drm_device_t *dev )
#if __REALLY_HAVE_MTRR
if ( map->mtrr >= 0 ) {
int retcode;
retcode = mtrr_del( map->mtrr,
map->offset,
map->size );
#ifdef __FreeBSD__
int act;
struct mem_range_desc mrdesc;
mrdesc.mr_base = map->offset;
mrdesc.mr_len = map->size;
mrdesc.mr_flags = MDF_WRITECOMBINE;
act = MEMRANGE_SET_UPDATE;
bcopy(DRIVER_NAME, &mrdesc.mr_owner, strlen(DRIVER_NAME));
retcode = mem_range_attr_set(&mrdesc, &act);
map->mtrr=1;
#elif defined __NetBSD__
struct mtrr mtrrmap;
int one = 1;
mtrrmap.base = map->offset;
mtrrmap.len = map->size;
mtrrmap.type = MTRR_TYPE_WC;
mtrrmap.flags = 0;
/*mtrrmap.owner = p->p_pid;*/
/* XXX: Use curproc here? */
retcode = mtrr_set( &mtrrmap, &one,
DRM_CURPROC, MTRR_GETSET_KERNEL);
#endif
DRM_DEBUG( "mtrr_del=%d\n", retcode );
}
#endif
DRM(ioremapfree)( map->handle, map->size );
break;
case _DRM_SHM:
DRM(free_pages)((unsigned long)map->handle,
DRM(order)(map->size)
- PAGE_SHIFT,
DRM(free)(map->handle,
map->size,
DRM_MEM_SAREA);
break;
@ -560,206 +643,190 @@ 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(&dev->lock.lock_queue);
DRM_WAKEUP_INT((void *)&dev->lock.lock_queue);
}
DRM_OS_UNLOCK;
DRM_UNLOCK;
return 0;
}
/*
* Figure out how many instances to initialize.
*/
static int drm_count_cards(void)
{
int num = 0;
#if defined(DRIVER_CARD_LIST)
int i;
drm_pci_list_t *l;
u16 device, vendor;
struct pci_dev *pdev = NULL;
#endif
DRM_DEBUG( "\n" );
#if defined(DRIVER_COUNT_CARDS)
num = DRIVER_COUNT_CARDS();
#elif defined(DRIVER_CARD_LIST)
for (i = 0, l = DRIVER_CARD_LIST; l[i].vendor != 0; i++) {
pdev = NULL;
vendor = l[i].vendor;
device = l[i].device;
if(device == 0xffff) device = PCI_ANY_ID;
if(vendor == 0xffff) vendor = PCI_ANY_ID;
while ((pdev = pci_find_device(vendor, device, pdev))) {
num++; /* FIXME: What about two cards of the same device id? */
}
}
#else
num = DRIVER_NUM_CARDS;
#endif
DRM_DEBUG("numdevs = %d\n", num);
return num;
}
/* drm_init is called via init_module at module load time, or via
* linux/init/main.c (this is not currently supported).
/* linux: drm_init is called via init_module at module load time, or via
* linux/init/main.c (this is not currently supported).
* bsd: drm_init is called via the attach function per device.
*/
#ifdef __FreeBSD__
static int DRM(init)( device_t nbdev )
#elif defined(__NetBSD__)
static int DRM(init)( drm_device_t *dev )
#endif
{
int unit;
#ifdef __FreeBSD__
drm_device_t *dev;
int i;
#endif
#if __HAVE_CTX_BITMAP
int retcode;
#endif
DRM_DEBUG( "\n" );
#ifdef MODULE
DRM(parse_options)( drm_opts );
#endif
DRM(numdevs) = drm_count_cards();
/* Force at least one instance. */
if (DRM(numdevs) <= 0)
DRM(numdevs) = 1;
DRM(device) = DRM_OS_MALLOC(sizeof(*DRM(device)) * DRM(numdevs));
if (!DRM(device)) {
DRM_OS_RETURN(ENOMEM);
}
DRM(minor) = DRM_OS_MALLOC(sizeof(*(DRM(minor))) * DRM(numdevs));
if (!DRM(minor)) {
DRM_OS_FREE(DRM(device));
DRM_OS_RETURN(ENOMEM);
}
DRIVER_PREINIT();
for (i = 0; i < DRM(numdevs); i++) {
int unit = device_get_unit(nbdev);
/* FIXME??? - multihead !!! */
dev = device_get_softc(nbdev);
memset( (void *)dev, 0, sizeof(*dev) );
DRM(minor)[i]=unit;
DRM_OS_SPININIT(dev->count_lock, "drm device");
lockinit(&dev->dev_lock, PZERO, "drmlk", 0, 0);
dev->device = nbdev;
dev->devnode = make_dev( &DRM(cdevsw),
unit,
DRM_DEV_UID,
DRM_DEV_GID,
DRM_DEV_MODE,
"dri/card%d", unit );
dev->name = DRIVER_NAME;
DRM(mem_init)();
DRM(sysctl_init)(dev);
TAILQ_INIT(&dev->files);
#ifdef __FreeBSD__
unit = device_get_unit(nbdev);
dev = device_get_softc(nbdev);
memset( (void *)dev, 0, sizeof(*dev) );
dev->device = nbdev;
dev->devnode = make_dev( &DRM(cdevsw),
unit,
DRM_DEV_UID,
DRM_DEV_GID,
DRM_DEV_MODE,
"dri/card%d", unit );
#elif defined(__NetBSD__)
unit = minor(dev->device.dv_unit);
#endif
DRM_SPININIT(dev->count_lock, "drm device");
lockinit(&dev->dev_lock, PZERO, "drmlk", 0, 0);
dev->name = DRIVER_NAME;
DRM(mem_init)();
DRM(sysctl_init)(dev);
TAILQ_INIT(&dev->files);
#if __REALLY_HAVE_AGP
dev->agp = DRM(agp_init)();
dev->agp = DRM(agp_init)();
#if __MUST_HAVE_AGP
if ( dev->agp == NULL ) {
DRM_ERROR( "Cannot initialize the agpgart module.\n" );
DRM(sysctl_cleanup)( dev );
destroy_dev(dev->devnode);
DRM(takedown)( dev );
DRM_OS_RETURN(ENOMEM);
}
if ( dev->agp == NULL ) {
DRM_ERROR( "Cannot initialize the agpgart module.\n" );
DRM(sysctl_cleanup)( dev );
#ifdef __FreeBSD__
destroy_dev(dev->devnode);
#endif
DRM(takedown)( dev );
return DRM_ERR(ENOMEM);
}
#endif /* __MUST_HAVE_AGP */
#if __REALLY_HAVE_MTRR
if (dev->agp)
dev->agp->agp_mtrr = mtrr_add( dev->agp->agp_info.aper_base,
dev->agp->agp_info.aper_size*1024*1024,
MTRR_TYPE_WRCOMB,
1 );
#endif
#endif
if (dev->agp) {
#ifdef __FreeBSD__
int retcode = 0, act;
struct mem_range_desc mrdesc;
mrdesc.mr_base = dev->agp->info.ai_aperture_base;
mrdesc.mr_len = dev->agp->info.ai_aperture_size;
mrdesc.mr_flags = MDF_WRITECOMBINE;
act = MEMRANGE_SET_UPDATE;
bcopy(DRIVER_NAME, &mrdesc.mr_owner, strlen(DRIVER_NAME));
retcode = mem_range_attr_set(&mrdesc, &act);
dev->agp->agp_mtrr=1;
#elif defined __NetBSD__
struct mtrr mtrrmap;
int one = 1;
mtrrmap.base = dev->agp->info.ai_aperture_base;
/* Might need a multiplier here XXX */
mtrrmap.len = dev->agp->info.ai_aperture_size;
mtrrmap.type = MTRR_TYPE_WC;
mtrrmap.flags = MTRR_VALID;
dev->agp->agp_mtrr = mtrr_set( &mtrrmap, &one, NULL, MTRR_GETSET_KERNEL);
#endif /* __NetBSD__ */
}
#endif /* __REALLY_HAVE_MTRR */
#endif /* __REALLY_HAVE_AGP */
#if __HAVE_CTX_BITMAP
retcode = DRM(ctxbitmap_init)( dev );
if( retcode ) {
DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
DRM(sysctl_cleanup)( dev );
destroy_dev(dev->devnode);
DRM(takedown)( dev );
return retcode;
}
retcode = DRM(ctxbitmap_init)( dev );
if( retcode ) {
DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
DRM(sysctl_cleanup)( dev );
#ifdef __FreeBSD__
destroy_dev(dev->devnode);
#endif
DRM_INFO( "Initialized %s %d.%d.%d %s on minor %d\n",
DRIVER_NAME,
DRIVER_MAJOR,
DRIVER_MINOR,
DRIVER_PATCHLEVEL,
DRIVER_DATE,
DRM(minor)[i] );
DRM(takedown)( dev );
return retcode;
}
#endif
DRM_INFO( "Initialized %s %d.%d.%d %s on minor %d\n",
DRIVER_NAME,
DRIVER_MAJOR,
DRIVER_MINOR,
DRIVER_PATCHLEVEL,
DRIVER_DATE,
unit );
DRIVER_POSTINIT();
return 0;
}
/* drm_cleanup is called via cleanup_module at module unload time.
/* linux: drm_cleanup is called via cleanup_module at module unload time.
* bsd: drm_cleanup is called per device at module unload time.
* FIXME: NetBSD
*/
#ifdef __FreeBSD__
static void DRM(cleanup)(device_t nbdev)
#elif defined(__NetBSD__)
static void DRM(cleanup)(drm_device_t *dev)
#endif
{
#ifdef __FreeBSD__
drm_device_t *dev;
int i;
#endif
#if __REALLY_HAVE_MTRR
#ifdef __NetBSD__
struct mtrr mtrrmap;
int one = 1;
#endif /* __NetBSD__ */
#endif /* __REALLY_HAVE_MTRR */
DRM_DEBUG( "\n" );
for (i = DRM(numdevs) - 1; i >= 0; i--) {
/* FIXME??? - multihead */
dev = device_get_softc(nbdev);
DRM(sysctl_cleanup)( dev );
destroy_dev(dev->devnode);
#ifdef __FreeBSD__
dev = device_get_softc(nbdev);
#endif
DRM(sysctl_cleanup)( dev );
#ifdef __FreeBSD__
destroy_dev(dev->devnode);
#endif
#if __HAVE_CTX_BITMAP
DRM(ctxbitmap_cleanup)( dev );
DRM(ctxbitmap_cleanup)( dev );
#endif
#if __REALLY_HAVE_AGP && __REALLY_HAVE_MTRR
if ( dev->agp && dev->agp->agp_mtrr >= 0) {
int retval;
retval = mtrr_del( dev->agp->agp_mtrr,
dev->agp->agp_info.aper_base,
dev->agp->agp_info.aper_size*1024*1024 );
DRM_DEBUG( "mtrr_del=%d\n", retval );
}
#endif
DRM(takedown)( dev );
#if __REALLY_HAVE_AGP
if ( dev->agp ) {
DRM(agp_uninit)();
DRM(free)( dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS );
dev->agp = NULL;
}
if ( dev->agp && dev->agp->agp_mtrr >= 0) {
#if defined(__NetBSD__)
mtrrmap.base = dev->agp->info.ai_aperture_base;
mtrrmap.len = dev->agp->info.ai_aperture_size;
mtrrmap.type = 0;
mtrrmap.flags = 0;
retval = mtrr_set( &mtrrmap, &one, NULL, MTRR_GETSET_KERNEL);
#endif
}
#endif
DRM(takedown)( dev );
#if __REALLY_HAVE_AGP
if ( dev->agp ) {
DRM(agp_uninit)();
DRM(free)( dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS );
dev->agp = NULL;
}
#endif
DRIVER_POSTCLEANUP();
DRM_OS_FREE(DRM(minor));
DRM_OS_FREE(DRM(device));
DRM(numdevs) = 0;
}
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;
@ -770,48 +837,40 @@ 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;
int i;
for (i = 0; i < DRM(numdevs); i++) {
/* FIXME ??? - multihead */
dev = DRIVER_SOFTC(minor(kdev));
}
if (!dev) {
DRM_OS_RETURN(ENODEV);
}
dev = DRIVER_SOFTC(minor(kdev));
DRM_DEBUG( "open_count = %d\n", dev->open_count );
device_busy(dev->device);
retcode = DRM(open_helper)(kdev, flags, fmt, p, dev);
if ( !retcode ) {
atomic_inc( &dev->counts[_DRM_STAT_OPENS] );
DRM_OS_SPINLOCK( &dev->count_lock );
if ( !dev->open_count++ ) {
DRM_OS_SPINUNLOCK( &dev->count_lock );
return DRM(setup)( dev );
}
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINLOCK( &dev->count_lock );
#ifdef __FreeBSD__
device_busy(dev->device);
#endif
if ( !dev->open_count++ )
retcode = DRM(setup)( dev );
DRM_SPINUNLOCK( &dev->count_lock );
}
device_unbusy(dev->device);
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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
int retcode = 0;
DRM_DEBUG( "open_count = %d\n", dev->open_count );
@ -827,13 +886,18 @@ int DRM( close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
* Begin inline drm_release
*/
#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_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();
@ -853,7 +917,7 @@ int DRM( close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
for (;;) {
if ( !dev->lock.hw_lock ) {
/* Device has been unregistered */
retcode = EINTR;
retcode = DRM_ERR(EINTR);
break;
}
if ( DRM(lock_take)( &dev->lock.hw_lock->lock,
@ -884,9 +948,15 @@ int DRM( close)(dev_t kdev, int flags, int fmt, DRM_OS_STRUCTPROC *p)
DRM(reclaim_buffers)( dev, priv->pid );
#endif
#if defined (__FreeBSD__) && (__FreeBSD_version >= 500000)
funsetown(&dev->buf_sigio);
#elif defined(__FreeBSD__)
funsetown(dev->buf_sigio);
#elif defined(__NetBSD__)
dev->buf_pgid = 0;
#endif /* __NetBSD__ */
DRM_OS_LOCK;
DRM_LOCK;
priv = DRM(find_file_by_proc)(dev, p);
if (priv) {
priv->refs--;
@ -894,7 +964,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 );
@ -903,42 +973,48 @@ 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 );
#ifdef __FreeBSD__
device_unbusy(dev->device);
#endif
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 );
device_unbusy(dev->device);
DRM_SPINUNLOCK( &dev->count_lock );
return DRM(takedown)( dev );
}
DRM_OS_SPINUNLOCK( &dev->count_lock );
DRM_SPINUNLOCK( &dev->count_lock );
DRM_OS_RETURN(retcode);
return 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] );
++priv->ioctl_count;
#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_CURRENTPID, cmd, nr, (long)&dev->device, priv->authenticated );
#endif
switch (cmd) {
case FIONBIO:
@ -950,6 +1026,7 @@ int DRM(ioctl)( DRM_OS_IOCTL )
dev->flags |= FASYNC;
return 0;
#ifdef __FreeBSD__
case FIOSETOWN:
atomic_dec(&dev->ioctl_count);
return fsetown(*(int *)data, &dev->buf_sigio);
@ -959,6 +1036,18 @@ int DRM(ioctl)( DRM_OS_IOCTL )
*(int *) data = fgetown(dev->buf_sigio);
return 0;
}
#endif /* __FreeBSD__ */
#ifdef __NetBSD__
case TIOCSPGRP:
atomic_dec(&dev->ioctl_count);
dev->buf_pgid = *(int *)data;
return 0;
case TIOCGPGRP:
atomic_dec(&dev->ioctl_count);
*(int *)data = dev->buf_pgid;
return 0;
#endif /* __NetBSD__ */
if ( nr >= DRIVER_IOCTL_COUNT ) {
retcode = EINVAL;
@ -969,7 +1058,7 @@ int DRM(ioctl)( DRM_OS_IOCTL )
if ( !func ) {
DRM_DEBUG( "no function\n" );
retcode = EINVAL;
} else if ( ( ioctl->root_only && DRM_OS_CHECKSUSER )
} else if ( ( ioctl->root_only && DRM_SUSER(p) )
|| ( ioctl->auth_needed && !priv->authenticated ) ) {
retcode = EACCES;
} else {
@ -978,12 +1067,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
@ -995,24 +1084,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
@ -1028,14 +1117,14 @@ 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 */
}
/* Contention */
ret = tsleep(&dev->lock.lock_queue,
ret = tsleep((void *)&dev->lock.lock_queue,
PZERO|PCATCH,
"drmlk2",
0);
@ -1074,21 +1163,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] );
@ -1141,7 +1230,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];

61
bsd/drm_fops.h
View File

@ -30,14 +30,9 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#include <sys/signalvar.h>
#include <sys/poll.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;
@ -56,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);
@ -66,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);
@ -89,15 +84,14 @@ 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_CHECKSUSER;
lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, p);
priv->authenticated = !DRM_SUSER(p);
DRM_LOCK;
TAILQ_INSERT_TAIL(&dev->files, priv, link);
lockmgr(&dev->dev_lock, LK_RELEASE, 0, p);
DRM_UNLOCK;
}
#ifdef __FreeBSD__
kdev->si_drv1 = dev;
#endif
return 0;
}
@ -108,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;
@ -156,6 +150,9 @@ int DRM(write_string)(drm_device_t *dev, const char *s)
int left = (dev->buf_rp + DRM_BSZ - dev->buf_wp) % DRM_BSZ;
int send = strlen(s);
int count;
#ifdef __NetBSD__
struct proc *p;
#endif /* __NetBSD__ */
DRM_DEBUG("%d left, %d to send (%p, %p)\n",
left, send, dev->buf_rp, dev->buf_wp);
@ -186,19 +183,33 @@ int DRM(write_string)(drm_device_t *dev, const char *s)
}
DRM_DEBUG("dev->buf_sigio=%p\n", dev->buf_sigio);
#ifdef __FreeBSD__
if (dev->buf_sigio) {
DRM_DEBUG("dev->buf_sigio->sio_pgid=%d\n", dev->buf_sigio->sio_pgid);
#if __FreeBSD_version >= 500000
pgsigio(&dev->buf_sigio, SIGIO, 0);
#else
pgsigio(dev->buf_sigio, SIGIO, 0);
#endif /* __FreeBSD_version */
}
#endif /* __FreeBSD__ */
#ifdef __NetBSD__
if (dev->buf_pgid) {
DRM_DEBUG("dev->buf_pgid=%d\n", dev->buf_pgid);
if(dev->buf_pgid > 0)
gsignal(dev->buf_pgid, SIGIO);
else if(dev->buf_pgid && (p = pfind(-dev->buf_pgid)) != NULL)
psignal(p, SIGIO);
#endif /* __NetBSD__ */
DRM_DEBUG("waking\n");
wakeup(&dev->buf_rp);
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_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
int s;
int revents = 0;
@ -217,7 +228,15 @@ int DRM(poll)(dev_t kdev, int events, DRM_OS_STRUCTPROC *p)
int DRM(write)(dev_t kdev, struct uio *uio, int ioflag)
{
DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",
curproc->p_pid, ((drm_device_t *)kdev->si_drv1)->device, ((drm_device_t *)kdev->si_drv1)->open_count);
return 0;
#if DRM_DEBUG_CODE
DRM_DEVICE;
#endif
#ifdef __FreeBSD__
DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",
curproc->p_pid, dev->device, dev->open_count);
#elif defined(__NetBSD__)
DRM_DEBUG("pid = %d, device = %p, open_count = %d\n",
curproc->p_pid, &dev->device, dev->open_count);
#endif
return 0;
}

3
bsd/drm_init.h
View File

@ -29,10 +29,9 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#if 0 && DRM_DEBUG_CODE
#if 1 && DRM_DEBUG_CODE
int DRM(flags) = DRM_FLAG_DEBUG;
#else
int DRM(flags) = 0;

84
bsd/drm_ioctl.h
View File

@ -29,20 +29,18 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#include <sys/bus.h>
#include <pci/pcivar.h>
int DRM(irq_busid)( DRM_OS_IOCTL )
int DRM(irq_busid)( DRM_IOCTL_ARGS )
{
#ifdef __FreeBSD__
drm_irq_busid_t id;
devclass_t pci;
device_t bus, dev;
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)
@ -71,49 +69,53 @@ 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
/* don't support interrupt-driven drivers on Net yet */
return ENOENT;
#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';
@ -121,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);
@ -130,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) {
@ -163,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)
{
@ -193,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)
@ -229,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;
}

37
bsd/drm_lists.h
View File

@ -29,7 +29,6 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#if __HAVE_DMA_WAITLIST
@ -37,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));
@ -50,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);
@ -78,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;
}
@ -100,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;
}
@ -129,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;
}
@ -161,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) {
@ -176,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;
}
@ -188,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;

17
bsd/drm_lock.h
View File

@ -29,16 +29,15 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#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;
@ -109,7 +108,7 @@ int DRM(lock_free)(drm_device_t *dev,
pid);
return 1;
}
DRM_OS_WAKEUP_INT(&dev->lock.lock_queue);
DRM_WAKEUP_INT((void *)&dev->lock.lock_queue);
return 0;
}
@ -125,7 +124,7 @@ static int DRM(flush_queue)(drm_device_t *dev, int context)
if (atomic_read(&q->use_count) > 1) {
atomic_inc(&q->block_write);
atomic_inc(&q->block_count);
error = tsleep(&q->flush_queue, PZERO|PCATCH, "drmfq", 0);
error = tsleep((void *)&q->flush_queue, PZERO|PCATCH, "drmfq", 0);
if (error)
return error;
atomic_dec(&q->block_count);
@ -147,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(&q->write_queue);
DRM_WAKEUP_INT((void *)&q->write_queue);
}
}
atomic_dec(&q->use_count);
@ -194,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);

161
bsd/drm_memory.h
View File

@ -29,20 +29,16 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include "drmP.h"
#include <vm/vm.h>
#include <vm/pmap.h>
#if __REALLY_HAVE_AGP
#include <sys/agpio.h>
#endif
#ifdef __FreeBSD__
#define malloctype DRM(M_DRM)
/* The macros confliced in the MALLOC_DEFINE */
MALLOC_DEFINE(malloctype, "drm", "DRM Data Structures");
#undef malloctype
#endif
typedef struct drm_mem_stats {
const char *name;
@ -53,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)[] = {
@ -85,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;
@ -99,8 +95,8 @@ void DRM(mem_init)(void)
DRM(ram_used) = 0;
}
#ifdef __FreeBSD__
/* drm_mem_info is called whenever a process reads /dev/drm/mem. */
static int DRM(_mem_info) DRM_SYSCTL_HANDLER_ARGS
{
drm_mem_stats_t *pt;
@ -137,11 +133,12 @@ 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
void *DRM(alloc)(size_t size, int area)
{
@ -152,16 +149,20 @@ void *DRM(alloc)(size_t size, int area)
return NULL;
}
#ifdef __FreeBSD__
if (!(pt = malloc(size, DRM(M_DRM), M_NOWAIT))) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
#elif defined(__NetBSD__)
if (!(pt = malloc(size, M_DEVBUF, M_NOWAIT))) {
#endif
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;
}
@ -203,70 +204,23 @@ void DRM(free)(void *pt, size_t size, int area)
int free_count;
if (!pt) DRM_MEM_ERROR(area, "Attempt to free NULL pointer\n");
else free(pt, DRM(M_DRM));
DRM_OS_SPINLOCK(&DRM(mem_lock));
else
#ifdef __FreeBSD__
free(pt, DRM(M_DRM));
#elif defined(__NetBSD__)
free(pt, M_DEVBUF);
#endif
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);
}
}
unsigned long DRM(alloc_pages)(int order, int area)
{
vm_offset_t address;
unsigned long bytes = PAGE_SIZE << order;
address = (vm_offset_t) contigmalloc(bytes, DRM(M_DRM), M_WAITOK, 0, ~0, 1, 0);
if (!address) {
DRM_OS_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[area].fail_count;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
return 0;
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
++DRM(mem_stats)[area].succeed_count;
DRM(mem_stats)[area].bytes_allocated += bytes;
DRM(ram_used) += bytes;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
/* Zero outside the lock */
memset((void *)address, 0, bytes);
return address;
}
void DRM(free_pages)(unsigned long address, int order, int area)
{
unsigned long bytes = PAGE_SIZE << order;
int alloc_count;
int free_count;
if (!address) {
DRM_MEM_ERROR(area, "Attempt to free address 0\n");
} else {
contigfree((void *) address, bytes, DRM(M_DRM));
}
DRM_OS_SPINLOCK(&DRM(mem_lock));
free_count = ++DRM(mem_stats)[area].free_count;
alloc_count = DRM(mem_stats)[area].succeed_count;
DRM(mem_stats)[area].bytes_freed += bytes;
DRM(ram_used) -= bytes;
DRM_OS_SPINUNLOCK(&DRM(mem_lock));
if (free_count > alloc_count) {
DRM_MEM_ERROR(area,
"Excess frees: %d frees, %d allocs\n",
free_count, alloc_count);
}
}
void *DRM(ioremap)(unsigned long offset, unsigned long size)
{
void *pt;
@ -278,18 +232,20 @@ 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;
}
/* unused so far */
#if 0
void *DRM(ioremap_nocache)(unsigned long offset, unsigned long size)
{
void *pt;
@ -302,17 +258,18 @@ 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
void DRM(ioremapfree)(void *pt, unsigned long size)
{
@ -325,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",
@ -348,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;
}
@ -369,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",
@ -386,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 = agp_find_device();
device_t dev = DRM_AGP_FIND_DEVICE();
struct agp_memory_info info;
if (!dev)
@ -401,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)
@ -424,7 +381,7 @@ int DRM(unbind_agp)(agp_memory *handle)
int alloc_count;
int free_count;
int retcode = EINVAL;
device_t dev = agp_find_device();
device_t dev = DRM_AGP_FIND_DEVICE();
struct agp_memory_info info;
if (!dev)
@ -433,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

207
bsd/drm_os_freebsd.h
View File

@ -12,12 +12,26 @@
#include <sys/uio.h>
#include <sys/filio.h>
#include <sys/sysctl.h>
#include <sys/select.h>
#include <sys/bus.h>
#include <sys/signalvar.h>
#include <sys/poll.h>
#include <vm/vm.h>
#include <vm/pmap.h>
#include <vm/vm_extern.h>
#include <vm/vm_map.h>
#include <vm/vm_param.h>
#include <machine/param.h>
#include <machine/pmap.h>
#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/mman.h>
#include <sys/rman.h>
#include <sys/memrange.h>
#include <pci/pcivar.h>
#if __FreeBSD_version >= 500000
#include <sys/selinfo.h>
#else
#include <sys/select.h>
#endif
#include <sys/bus.h>
#if __FreeBSD_version >= 400005
@ -31,11 +45,27 @@
#define __REALLY_HAVE_AGP __HAVE_AGP
#endif
#define __REALLY_HAVE_MTRR 0
#define __REALLY_HAVE_SG 0
#define __REALLY_HAVE_MTRR (__HAVE_MTRR)
#define __REALLY_HAVE_SG (__HAVE_SG)
#if __REALLY_HAVE_AGP
#include <pci/agpvar.h>
#include <sys/agpio.h>
#endif
#include <opt_drm.h>
#if DRM_DEBUG
#undef DRM_DEBUG_CODE
#define DRM_DEBUG_CODE 2
#endif
#undef DRM_DEBUG
#if DRM_LINUX
#include <sys/file.h>
#include <sys/proc.h>
#include <machine/../linux/linux.h>
#include <machine/../linux/linux_proto.h>
#include "drm_linux.h"
#endif
#define DRM_TIME_SLICE (hz/20) /* Time slice for GLXContexts */
@ -43,49 +73,51 @@
#define DRM_DEV_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
#define DRM_DEV_UID 0
#define DRM_DEV_GID 0
#define CDEV_MAJOR 145
#if __FreeBSD_version >= 500000
#define DRM_OS_SPINTYPE struct mtx
#define DRM_OS_SPININIT(l,name) mtx_init(&l, name, MTX_DEF)
#define DRM_OS_SPINLOCK(l) mtx_lock(l)
#define DRM_OS_SPINUNLOCK(u) mtx_unlock(u);
#define DRM_OS_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curthread)
#define DRM_OS_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, 0, curthread)
#define DRM_OS_CURPROC curthread
#define DRM_OS_STRUCTPROC struct thread
#define DRM_OS_CURRENTPID curthread->td_proc->p_pid
#define DRM_OS_IOCTL dev_t kdev, u_long cmd, caddr_t data, int flags, struct thread *p
#define DRM_OS_CHECKSUSER suser(p->td_proc)
#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_IOCTL dev_t kdev, u_long cmd, caddr_t data, int flags, struct proc *p
#define DRM_OS_LOCK lockmgr(&dev->dev_lock, LK_EXCLUSIVE, 0, curproc)
#define DRM_OS_UNLOCK lockmgr(&dev->dev_lock, LK_RELEASE, 0, curproc)
#define DRM_OS_CURRENTPID curproc->p_pid
#define DRM_OS_CHECKSUSER suser(p)
#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_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_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); \
@ -95,34 +127,53 @@ do { \
while (((tv2.tv_sec-tv1.tv_sec)*1000000 + tv2.tv_usec - tv1.tv_usec) < udelay ); \
} while (0)
#define DRM_OS_RETURN(v) return v;
#define DRM_GETSAREA() \
do { \
drm_map_list_entry_t *listentry; \
TAILQ_FOREACH(listentry, dev->maplist, link) { \
drm_map_t *map = listentry->map; \
if (map->type == _DRM_SHM && \
map->flags & _DRM_CONTAINS_LOCK) { \
dev_priv->sarea = map; \
break; \
} \
} \
} while (0)
#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_VERIFYAREA_READ( uaddr, size ) \
(!useracc((caddr_t)uaddr, size, VM_PROT_READ))
#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
copyin(arg2, arg1, arg3)
#define DRM_GET_USER_UNCHECKED(val, uaddr) \
((val) = fuword(uaddr), 0)
#define DRM_OS_READMEMORYBARRIER \
{ \
int xchangeDummy; \
DRM_DEBUG("%s\n", __FUNCTION__); \
__asm__ volatile(" push %%eax ; xchg %%eax, %0 ; pop %%eax" : : "m" (xchangeDummy)); \
__asm__ volatile(" push %%eax ; push %%ebx ; push %%ecx ; push %%edx ;" \
" movl $0,%%eax ; cpuid ; pop %%edx ; pop %%ecx ; pop %%ebx ;" \
" pop %%eax" : /* no outputs */ : /* no inputs */ ); \
} while (0);
/* From machine/bus_at386.h on i386 */
#define DRM_READMEMORYBARRIER() \
do { \
__asm __volatile("lock; addl $0,0(%%esp)" : : : "memory"); \
} while (0)
#define DRM_OS_WRITEMEMORYBARRIER DRM_OS_READMEMORYBARRIER
#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) (((addr)+PAGE_SIZE-1)&PAGE_MASK)
#define PAGE_ALIGN(addr) round_page(addr)
#define malloctype DRM(M_DRM)
/* The macros confliced in the MALLOC_DEFINE */
@ -137,7 +188,10 @@ typedef struct drm_chipinfo
char *name;
} drm_chipinfo_t;
typedef unsigned long atomic_t;
#define cpu_to_le32(x) (x)
typedef u_int32_t dma_addr_t;
typedef u_int32_t atomic_t;
typedef u_int32_t cycles_t;
typedef u_int32_t spinlock_t;
typedef u_int32_t u32;
@ -145,14 +199,14 @@ typedef u_int16_t u16;
typedef u_int8_t u8;
#define atomic_set(p, v) (*(p) = (v))
#define atomic_read(p) (*(p))
#define atomic_inc(p) atomic_add_long(p, 1)
#define atomic_dec(p) atomic_subtract_long(p, 1)
#define atomic_add(n, p) atomic_add_long(p, n)
#define atomic_sub(n, p) atomic_subtract_long(p, n)
#define atomic_inc(p) atomic_add_int(p, 1)
#define atomic_dec(p) atomic_subtract_int(p, 1)
#define atomic_add(n, p) atomic_add_int(p, n)
#define atomic_sub(n, p) atomic_subtract_int(p, n)
/* Fake this */
static __inline unsigned int
test_and_set_bit(int b, volatile unsigned long *p)
static __inline atomic_t
test_and_set_bit(int b, atomic_t *p)
{
int s = splhigh();
unsigned int m = 1<<b;
@ -163,25 +217,25 @@ test_and_set_bit(int b, volatile unsigned long *p)
}
static __inline void
clear_bit(int b, volatile unsigned long *p)
clear_bit(int b, atomic_t *p)
{
atomic_clear_long(p + (b >> 5), 1 << (b & 0x1f));
atomic_clear_int(p + (b >> 5), 1 << (b & 0x1f));
}
static __inline void
set_bit(int b, volatile unsigned long *p)
set_bit(int b, atomic_t *p)
{
atomic_set_long(p + (b >> 5), 1 << (b & 0x1f));
atomic_set_int(p + (b >> 5), 1 << (b & 0x1f));
}
static __inline int
test_bit(int b, volatile unsigned long *p)
test_bit(int b, atomic_t *p)
{
return p[b >> 5] & (1 << (b & 0x1f));
}
static __inline int
find_first_zero_bit(volatile unsigned long *p, int max)
find_first_zero_bit(atomic_t *p, int max)
{
int b;
@ -227,24 +281,23 @@ find_first_zero_bit(volatile unsigned long *p, int max)
} while (0)
/* Redefinitions to make templating easy */
#define wait_queue_head_t long
#define wait_queue_head_t atomic_t
#define agp_memory void
#define jiffies ticks
/* Macros to make printf easier */
#define DRM_ERROR(fmt, arg...) \
printf("error: " "[" DRM_NAME ":" __FUNCTION__ "] *ERROR* " fmt , ##arg)
printf("error: " "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ## arg)
#define DRM_MEM_ERROR(area, fmt, arg...) \
printf("error: " "[" DRM_NAME ":" __FUNCTION__ ":%s] *ERROR* " fmt , \
DRM(mem_stats)[area].name , ##arg)
#define DRM_INFO(fmt, arg...) printf("info: " "[" DRM_NAME "] " fmt , ##arg)
printf("error: " "[" DRM_NAME ":%s:%s] *ERROR* " fmt , \
__func__, DRM(mem_stats)[area].name , ##arg)
#define DRM_INFO(fmt, arg...) printf("info: " "[" DRM_NAME "] " fmt , ## arg)
#if DRM_DEBUG_CODE
#define DRM_DEBUG(fmt, arg...) \
do { \
if (DRM(flags) & DRM_FLAG_DEBUG) \
printf("[" DRM_NAME ":" __FUNCTION__ "] " fmt , \
##arg); \
if (DRM(flags) & DRM_FLAG_DEBUG) \
printf("[" DRM_NAME ":%s] " fmt , __func__ , ## arg); \
} while (0)
#else
#define DRM_DEBUG(fmt, arg...) do { } while (0)
@ -294,9 +347,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);
@ -348,7 +401,7 @@ extern d_ioctl_t DRM(mapbufs);
extern int DRM(mem_info) DRM_SYSCTL_HANDLER_ARGS;
/* DMA support (drm_dma.h) */
#if __HAVE_DMA_IRQ
#if __HAVE_DMA
extern d_ioctl_t DRM(control);
#endif

378
bsd/drm_os_netbsd.h Normal file
View File

@ -0,0 +1,378 @@
#include <sys/param.h>
#include <sys/queue.h>
#include <sys/malloc.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/proc.h>
#include <sys/lock.h>
#include <sys/fcntl.h>
#include <sys/uio.h>
#include <sys/filio.h>
#include <sys/sysctl.h>
#include <sys/select.h>
#include <sys/device.h>
#include <sys/mman.h>
#include <uvm/uvm.h>
#include <sys/vnode.h>
#include <sys/poll.h>
/* For TIOCSPGRP/TIOCGPGRP */
#include <sys/ttycom.h>
#include <uvm/uvm.h>
#include <machine/pmap.h>
#include <machine/bus.h>
#include <sys/resourcevar.h>
#include <machine/sysarch.h>
#include <machine/mtrr.h>
#include <dev/pci/pcireg.h>
#include <dev/pci/pcivar.h>
#include "drmvar.h"
#define __REALLY_HAVE_AGP __HAVE_AGP
#define __REALLY_HAVE_MTRR 0
#define __REALLY_HAVE_SG 0
#if __REALLY_HAVE_AGP
#include <dev/pci/agpvar.h>
#include <sys/agpio.h>
#endif
#define device_t struct device *
extern struct cfdriver DRM(_cd);
#if DRM_DEBUG
#undef DRM_DEBUG_CODE
#define DRM_DEBUG_CODE 2
#endif
#undef DRM_DEBUG
#define DRM_TIME_SLICE (hz/20) /* Time slice for GLXContexts */
#define DRM_DEV_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
#define DRM_DEV_UID 0
#define DRM_DEV_GID 0
#define CDEV_MAJOR 90
#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_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_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_UDELAY( udelay ) \
do { \
struct timeval tv1, tv2; \
microtime(&tv1); \
do { \
microtime(&tv2); \
} \
while (((tv2.tv_sec-tv1.tv_sec)*1000000 + tv2.tv_usec - tv1.tv_usec) < udelay ); \
} while (0)
#define DRM_GETSAREA() \
do { \
drm_map_list_entry_t *listentry; \
TAILQ_FOREACH(listentry, dev->maplist, link) { \
drm_map_t *map = listentry->map; \
if (map->type == _DRM_SHM && \
map->flags & _DRM_CONTAINS_LOCK) { \
dev_priv->sarea = map; \
break; \
} \
} \
} while (0)
#define return DRM_ERR(v) return v;
#define DRM_ERR(v) v
#define DRM_COPY_TO_USER_IOCTL(arg1, arg2, arg3) \
*arg1 = arg2
#define DRM_COPY_FROM_USER_IOCTL(arg1, arg2, arg3) \
arg1 = *arg2
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
copyout(arg2, arg1, arg3)
#define DRM_COPY_FROM_USER(arg1, arg2, arg3) \
copyin(arg2, arg1, arg3)
#define DRM_READMEMORYBARRIER \
{ \
int xchangeDummy; \
DRM_DEBUG("%s\n", __FUNCTION__); \
__asm__ volatile(" push %%eax ; xchg %%eax, %0 ; pop %%eax" : : "m" (xchangeDummy)); \
__asm__ volatile(" push %%eax ; push %%ebx ; push %%ecx ; push %%edx ;" \
" movl $0,%%eax ; cpuid ; pop %%edx ; pop %%ecx ; pop %%ebx ;" \
" pop %%eax" : /* no outputs */ : /* no inputs */ ); \
} while (0);
#define DRM_WRITEMEMORYBARRIER DRM_READMEMORYBARRIER
#define DRM_WAKEUP(w) wakeup(w)
#define DRM_WAKEUP_INT(w) wakeup(w)
#define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK)
typedef struct drm_chipinfo
{
int vendor;
int device;
int supported;
char *name;
} drm_chipinfo_t;
typedef u_int32_t dma_addr_t;
typedef volatile u_int32_t atomic_t;
typedef u_int32_t cycles_t;
typedef u_int32_t spinlock_t;
typedef u_int32_t u32;
typedef u_int16_t u16;
typedef u_int8_t u8;
typedef dev_type_ioctl(d_ioctl_t);
typedef vaddr_t vm_offset_t;
#define atomic_set(p, v) (*(p) = (v))
#define atomic_read(p) (*(p))
#define atomic_inc(p) atomic_add_int(p, 1)
#define atomic_dec(p) atomic_subtract_int(p, 1)
#define atomic_add(n, p) atomic_add_int(p, n)
#define atomic_sub(n, p) atomic_subtract_int(p, n)
/* FIXME: Is NetBSD's kernel non-reentrant? */
#define atomic_add_int(p, v) *(p) += v
#define atomic_subtract_int(p, v) *(p) -= v
#define atomic_set_int(p, bits) *(p) |= (bits)
#define atomic_clear_int(p, bits) *(p) &= ~(bits)
/* Fake this */
static __inline atomic_t
test_and_set_bit(int b, atomic_t *p)
{
int s = splhigh();
unsigned int m = 1<<b;
unsigned int r = *p & m;
*p |= m;
splx(s);
return r;
}
static __inline void
clear_bit(int b, atomic_t *p)
{
atomic_clear_int(p + (b >> 5), 1 << (b & 0x1f));
}
static __inline void
set_bit(int b, atomic_t *p)
{
atomic_set_int(p + (b >> 5), 1 << (b & 0x1f));
}
static __inline int
test_bit(int b, atomic_t *p)
{
return p[b >> 5] & (1 << (b & 0x1f));
}
static __inline int
find_first_zero_bit(atomic_t *p, int max)
{
int b;
for (b = 0; b < max; b += 32) {
if (p[b >> 5] != ~0) {
for (;;) {
if ((p[b >> 5] & (1 << (b & 0x1f))) == 0)
return b;
b++;
}
}
}
return max;
}
#define spldrm() spltty()
#define jiffies hardclock_ticks
#define __drm_dummy_lock(lock) (*(__volatile__ unsigned int *)lock)
#define _DRM_CAS(lock,old,new,__ret) \
do { \
int __dummy; /* Can't mark eax as clobbered */ \
__asm__ __volatile__( \
"lock ; cmpxchg %4,%1\n\t" \
"setnz %0" \
: "=d" (__ret), \
"=m" (__drm_dummy_lock(lock)), \
"=a" (__dummy) \
: "2" (old), \
"r" (new)); \
} while (0)
/* Redefinitions to make templating easy */
#define wait_queue_head_t atomic_t
#define agp_memory void
/* Macros to make printf easier */
#define DRM_ERROR(fmt, arg...) \
do { \
printf("error: [" DRM_NAME ":%s] *ERROR* ", __func__ ); \
printf( fmt,## arg ); \
} while (0)
#define DRM_MEM_ERROR(area, fmt, arg...) \
printf("error: [" DRM_NAME ":%s:%s] *ERROR* " fmt , \
__func__, DRM(mem_stats)[area].name ,## arg)
#define DRM_INFO(fmt, arg...) printf("info: " "[" DRM_NAME "] " fmt ,## arg)
#if DRM_DEBUG_CODE
#define DRM_DEBUG(fmt, arg...) \
do { \
if (DRM(flags) & DRM_FLAG_DEBUG) \
printf("[" DRM_NAME ":%s] " fmt , __FUNCTION__,## arg); \
} while (0)
#else
#define DRM_DEBUG(fmt, arg...) do { } while (0)
#endif
#define DRM_PROC_LIMIT (PAGE_SIZE-80)
#define DRM_SYSCTL_PRINT(fmt, arg...) \
snprintf(buf, sizeof(buf), fmt, ##arg); \
error = SYSCTL_OUT(req, buf, strlen(buf)); \
if (error) return error;
#define DRM_SYSCTL_PRINT_RET(ret, fmt, arg...) \
snprintf(buf, sizeof(buf), fmt, ##arg); \
error = SYSCTL_OUT(req, buf, strlen(buf)); \
if (error) { ret; return error; }
#define DRM_FIND_MAP(dest, o) \
do { \
drm_map_list_entry_t *listentry; \
TAILQ_FOREACH(listentry, dev->maplist, link) { \
if ( listentry->map->offset == o ) { \
dest = listentry->map; \
break; \
} \
} \
} while (0)
/* Internal functions */
/* drm_drv.h */
extern dev_type_ioctl(DRM(ioctl));
extern dev_type_ioctl(DRM(lock));
extern dev_type_ioctl(DRM(unlock));
extern dev_type_open(DRM(open));
extern dev_type_close(DRM(close));
extern dev_type_read(DRM(read));
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_STRUCTPROC *p, drm_device_t *dev);
extern drm_file_t *DRM(find_file_by_proc)(drm_device_t *dev,
DRM_STRUCTPROC *p);
/* Misc. IOCTL support (drm_ioctl.h) */
extern dev_type_ioctl(DRM(irq_busid));
extern dev_type_ioctl(DRM(getunique));
extern dev_type_ioctl(DRM(setunique));
extern dev_type_ioctl(DRM(getmap));
extern dev_type_ioctl(DRM(getclient));
extern dev_type_ioctl(DRM(getstats));
/* Context IOCTL support (drm_context.h) */
extern dev_type_ioctl(DRM(resctx));
extern dev_type_ioctl(DRM(addctx));
extern dev_type_ioctl(DRM(modctx));
extern dev_type_ioctl(DRM(getctx));
extern dev_type_ioctl(DRM(switchctx));
extern dev_type_ioctl(DRM(newctx));
extern dev_type_ioctl(DRM(rmctx));
extern dev_type_ioctl(DRM(setsareactx));
extern dev_type_ioctl(DRM(getsareactx));
/* Drawable IOCTL support (drm_drawable.h) */
extern dev_type_ioctl(DRM(adddraw));
extern dev_type_ioctl(DRM(rmdraw));
/* Authentication IOCTL support (drm_auth.h) */
extern dev_type_ioctl(DRM(getmagic));
extern dev_type_ioctl(DRM(authmagic));
/* Locking IOCTL support (drm_lock.h) */
extern dev_type_ioctl(DRM(block));
extern dev_type_ioctl(DRM(unblock));
extern dev_type_ioctl(DRM(finish));
/* Buffer management support (drm_bufs.h) */
extern dev_type_ioctl(DRM(addmap));
extern dev_type_ioctl(DRM(rmmap));
#if __HAVE_DMA
extern dev_type_ioctl(DRM(addbufs_agp));
extern dev_type_ioctl(DRM(addbufs_pci));
extern dev_type_ioctl(DRM(addbufs_sg));
extern dev_type_ioctl(DRM(addbufs));
extern dev_type_ioctl(DRM(infobufs));
extern dev_type_ioctl(DRM(markbufs));
extern dev_type_ioctl(DRM(freebufs));
extern dev_type_ioctl(DRM(mapbufs));
#endif
/* DMA support (drm_dma.h) */
#if __HAVE_DMA
extern dev_type_ioctl(DRM(control));
#endif
/* AGP/GART support (drm_agpsupport.h) */
#if __REALLY_HAVE_AGP
extern dev_type_ioctl(DRM(agp_acquire));
extern dev_type_ioctl(DRM(agp_release));
extern dev_type_ioctl(DRM(agp_enable));
extern dev_type_ioctl(DRM(agp_info));
extern dev_type_ioctl(DRM(agp_alloc));
extern dev_type_ioctl(DRM(agp_free));
extern dev_type_ioctl(DRM(agp_unbind));
extern dev_type_ioctl(DRM(agp_bind));
#endif
/* Scatter Gather Support (drm_scatter.h) */
#if __HAVE_SG
extern dev_type_ioctl(DRM(sg_alloc));
extern dev_type_ioctl(DRM(sg_free));
#endif
/* SysCtl Support (drm_sysctl.h) */
extern int DRM(sysctl_init)(drm_device_t *dev);
extern int DRM(sysctl_cleanup)(drm_device_t *dev);

115
bsd/drm_scatter.h
View File

@ -27,25 +27,15 @@
* Gareth Hughes <gareth@valinux.com>
*/
#define __NO_VERSION__
#include <linux/config.h>
#include <linux/vmalloc.h>
#include "drmP.h"
#define DEBUG_SCATTER 0
#if __REALLY_HAVE_SG
void DRM(sg_cleanup)( drm_sg_mem_t *entry )
{
struct page *page;
int i;
for ( i = 0 ; i < entry->pages ; i++ ) {
page = entry->pagelist[i];
if ( page )
ClearPageReserved( page );
}
vfree( entry->virtual );
free( entry->virtual, DRM(M_DRM) );
DRM(free)( entry->busaddr,
entry->pages * sizeof(*entry->busaddr),
@ -58,35 +48,28 @@ void DRM(sg_cleanup)( drm_sg_mem_t *entry )
DRM_MEM_SGLISTS );
}
int DRM(sg_alloc)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg )
int DRM(sg_alloc)( DRM_IOCTL_ARGS )
{
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->dev;
DRM_DEVICE;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
unsigned long pages, i, j;
pgd_t *pgd;
pmd_t *pmd;
pte_t *pte;
unsigned long pages;
DRM_DEBUG( "%s\n", __FUNCTION__ );
if ( dev->sg )
return -EINVAL;
return EINVAL;
if ( copy_from_user( &request,
(drm_scatter_gather_t *)arg,
sizeof(request) ) )
return -EFAULT;
DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
sizeof(request) );
entry = DRM(alloc)( sizeof(*entry), DRM_MEM_SGLISTS );
if ( !entry )
return -ENOMEM;
return ENOMEM;
memset( entry, 0, sizeof(*entry) );
bzero( entry, sizeof(*entry) );
pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
pages = round_page(request.size) / PAGE_SIZE;
DRM_DEBUG( "sg size=%ld pages=%ld\n", request.size, pages );
entry->pages = pages;
@ -94,10 +77,10 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
DRM_MEM_PAGES );
if ( !entry->pagelist ) {
DRM(free)( entry, sizeof(*entry), DRM_MEM_SGLISTS );
return -ENOMEM;
return ENOMEM;
}
memset(entry->pagelist, 0, pages * sizeof(*entry->pagelist));
bzero(entry->pagelist, pages * sizeof(*entry->pagelist));
entry->busaddr = DRM(alloc)( pages * sizeof(*entry->busaddr),
DRM_MEM_PAGES );
@ -108,11 +91,11 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
DRM(free)( entry,
sizeof(*entry),
DRM_MEM_SGLISTS );
return -ENOMEM;
return ENOMEM;
}
memset( (void *)entry->busaddr, 0, pages * sizeof(*entry->busaddr) );
bzero( (void *)entry->busaddr, pages * sizeof(*entry->busaddr) );
entry->virtual = vmalloc_32( pages << PAGE_SHIFT );
entry->virtual = malloc( pages << PAGE_SHIFT, DRM(M_DRM), M_WAITOK );
if ( !entry->virtual ) {
DRM(free)( entry->busaddr,
entry->pages * sizeof(*entry->busaddr),
@ -123,45 +106,21 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
DRM(free)( entry,
sizeof(*entry),
DRM_MEM_SGLISTS );
return -ENOMEM;
return ENOMEM;
}
/* This also forces the mapping of COW pages, so our page list
* will be valid. Please don't remove it...
*/
memset( entry->virtual, 0, pages << PAGE_SHIFT );
bzero( entry->virtual, pages << PAGE_SHIFT );
entry->handle = (unsigned long)entry->virtual;
DRM_DEBUG( "sg alloc handle = %08lx\n", entry->handle );
DRM_DEBUG( "sg alloc virtual = %p\n", entry->virtual );
for ( i = entry->handle, j = 0 ; j < pages ; i += PAGE_SIZE, j++ ) {
pgd = pgd_offset_k( i );
if ( !pgd_present( *pgd ) )
goto failed;
pmd = pmd_offset( pgd, i );
if ( !pmd_present( *pmd ) )
goto failed;
pte = pte_offset( pmd, i );
if ( !pte_present( *pte ) )
goto failed;
entry->pagelist[j] = pte_page( *pte );
SetPageReserved( entry->pagelist[j] );
}
request.handle = entry->handle;
if ( copy_to_user( (drm_scatter_gather_t *)arg,
&request,
sizeof(request) ) ) {
DRM(sg_cleanup)( entry );
return -EFAULT;
}
DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
request,
sizeof(request) );
dev->sg = entry;
@ -207,29 +166,24 @@ int DRM(sg_alloc)( struct inode *inode, struct file *filp,
return 0;
failed:
DRM(sg_cleanup)( entry );
return -ENOMEM;
return ENOMEM;
}
int DRM(sg_free)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg )
int DRM(sg_free)( DRM_IOCTL_ARGS )
{
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->dev;
DRM_DEVICE;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
if ( copy_from_user( &request,
(drm_scatter_gather_t *)arg,
sizeof(request) ) )
return -EFAULT;
DRM_COPY_FROM_USER_IOCTL( request, (drm_scatter_gather_t *)data,
sizeof(request) );
entry = dev->sg;
dev->sg = NULL;
if ( !entry || entry->handle != request.handle )
return -EINVAL;
return EINVAL;
DRM_DEBUG( "sg free virtual = %p\n", entry->virtual );
@ -237,3 +191,16 @@ int DRM(sg_free)( struct inode *inode, struct file *filp,
return 0;
}
#else /* __REALLY_HAVE_SG */
int DRM(sg_alloc)( DRM_IOCTL_ARGS )
{
return DRM_ERR(EINVAL);
}
int DRM(sg_free)( DRM_IOCTL_ARGS )
{
return DRM_ERR(EINVAL);
}
#endif

123
bsd/drm_sysctl.h
View File

@ -1,4 +1,10 @@
SYSCTL_NODE(_hw, OID_AUTO, dri, CTLFLAG_RW, 0, "DRI Graphics");
/*
* $FreeBSD: src/sys/dev/drm/drm_sysctl.h,v 1.1 2002/04/27 20:47:57 anholt Exp $
*/
#ifdef __FreeBSD__
#include <sys/sysctl.h>
static int DRM(name_info)DRM_SYSCTL_HANDLER_ARGS;
static int DRM(vm_info)DRM_SYSCTL_HANDLER_ARGS;
@ -32,8 +38,7 @@ struct DRM(sysctl_list) {
#define DRM_SYSCTL_ENTRIES (sizeof(DRM(sysctl_list))/sizeof(DRM(sysctl_list)[0]))
struct drm_sysctl_info {
struct sysctl_oid oids[DRM_SYSCTL_ENTRIES + 1];
struct sysctl_oid_list list;
struct sysctl_ctx_list ctx;
char name[2];
};
@ -41,65 +46,62 @@ int DRM(sysctl_init)(drm_device_t *dev)
{
struct drm_sysctl_info *info;
struct sysctl_oid *oid;
struct sysctl_oid *top;
struct sysctl_oid *top, *drioid;
int i;
/* Find the next free slot under hw.graphics */
info = DRM(alloc)(sizeof *info, DRM_MEM_DRIVER);
if ( !info )
return 1;
bzero(info, sizeof *info);
dev->sysctl = info;
/* Add the sysctl node for DRI if it doesn't already exist */
drioid = SYSCTL_ADD_NODE( &info->ctx, &sysctl__hw_children, OID_AUTO, "dri", CTLFLAG_RW, NULL, "DRI Graphics");
if (!drioid)
return 1;
/* Find the next free slot under hw.dri */
i = 0;
SLIST_FOREACH(oid, &sysctl__hw_dri_children, oid_link) {
SLIST_FOREACH(oid, SYSCTL_CHILDREN(drioid), oid_link) {
if (i <= oid->oid_arg2)
i = oid->oid_arg2 + 1;
}
if (i>9)
return 1;
info = DRM(alloc)(sizeof *info, DRM_MEM_DRIVER);
dev->sysctl = info;
/* Construct the node under hw.graphics */
/* Add the hw.dri.x for our device */
info->name[0] = '0' + i;
info->name[1] = 0;
oid = &info->oids[DRM_SYSCTL_ENTRIES];
bzero(oid, sizeof(*oid));
oid->oid_parent = &sysctl__hw_dri_children;
oid->oid_number = OID_AUTO;
oid->oid_kind = CTLTYPE_NODE | CTLFLAG_RW;
oid->oid_arg1 = &info->list;
oid->oid_arg2 = i;
oid->oid_name = info->name;
oid->oid_handler = 0;
oid->oid_fmt = "N";
SLIST_INIT(&info->list);
sysctl_register_oid(oid);
top = oid;
top = SYSCTL_ADD_NODE( &info->ctx, SYSCTL_CHILDREN(drioid), OID_AUTO, info->name, CTLFLAG_RW, NULL, NULL);
if (!top)
return 1;
for (i = 0; i < DRM_SYSCTL_ENTRIES; i++) {
oid = &info->oids[i];
bzero(oid, sizeof(*oid));
oid->oid_parent = top->oid_arg1;
oid->oid_number = OID_AUTO;
oid->oid_kind = CTLTYPE_INT | CTLFLAG_RD;
oid->oid_arg1 = dev;
oid->oid_arg2 = 0;
oid->oid_name = DRM(sysctl_list)[i].name;
oid->oid_handler = DRM(sysctl_list[)i].f;
oid->oid_fmt = "A";
sysctl_register_oid(oid);
oid = sysctl_add_oid( &info->ctx,
SYSCTL_CHILDREN(top),
OID_AUTO,
DRM(sysctl_list)[i].name,
CTLTYPE_INT | CTLFLAG_RD,
dev,
0,
DRM(sysctl_list)[i].f,
"A",
NULL);
if (!oid)
return 1;
}
return 0;
}
int DRM(sysctl_cleanup)(drm_device_t *dev)
{
int i;
DRM_DEBUG("dev->sysctl=%p\n", dev->sysctl);
for (i = 0; i < DRM_SYSCTL_ENTRIES + 1; i++)
sysctl_unregister_oid(&dev->sysctl->oids[i]);
int error;
error = sysctl_ctx_free( &dev->sysctl->ctx );
DRM(free)(dev->sysctl, sizeof *dev->sysctl, DRM_MEM_DRIVER);
dev->sysctl = NULL;
return 0;
return error;
}
static int DRM(name_info)DRM_SYSCTL_HANDLER_ARGS
@ -166,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;
}
@ -217,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;
}
@ -267,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;
}
@ -301,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;
}
@ -386,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
@ -515,9 +517,22 @@ 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
#elif defined(__NetBSD__)
/* stub it out for now, sysctl is only for debugging */
int DRM(sysctl_init)(drm_device_t *dev)
{
return 0;
}
int DRM(sysctl_cleanup)(drm_device_t *dev)
{
return 0;
}
#endif

26
bsd/drm_vm.h
View File

@ -1,9 +1,11 @@
#include <vm/vm.h>
#include <vm/pmap.h>
#ifdef __FreeBSD__
static int DRM(dma_mmap)(dev_t kdev, vm_offset_t offset, int prot)
#elif defined(__NetBSD__)
static paddr_t DRM(dma_mmap)(dev_t kdev, vm_offset_t offset, int prot)
#endif
{
drm_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
unsigned long physical;
unsigned long page;
@ -14,27 +16,30 @@ static int DRM(dma_mmap)(dev_t kdev, vm_offset_t offset, int prot)
page = offset >> PAGE_SHIFT;
physical = dma->pagelist[page];
DRM_DEBUG("0x%08x (page %lu) => 0x%08lx\n", offset, page, physical);
DRM_DEBUG("0x%08lx (page %lu) => 0x%08lx\n", (long)offset, page, physical);
return atop(physical);
}
#ifdef __FreeBSD__
int DRM(mmap)(dev_t kdev, vm_offset_t offset, int prot)
#elif defined(__NetBSD__)
paddr_t DRM(mmap)(dev_t kdev, off_t offset, int prot)
#endif
{
drm_device_t *dev = kdev->si_drv1;
DRM_DEVICE;
drm_map_t *map = NULL;
drm_map_list_entry_t *listentry=NULL;
/*drm_file_t *priv;*/
drm_file_t *priv;
/* DRM_DEBUG("offset = 0x%x\n", offset);*/
/*XXX Fixme */
/*priv = DRM(find_file_by_proc)(dev, p);
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
@ -59,7 +64,7 @@ int DRM(mmap)(dev_t kdev, vm_offset_t offset, int prot)
DRM_DEBUG("can't find map\n");
return -1;
}
if (((map->flags&_DRM_RESTRICTED) && suser(curproc))) {
if (((map->flags&_DRM_RESTRICTED) && DRM_SUSER(DRM_CURPROC))) {
DRM_DEBUG("restricted map\n");
return -1;
}
@ -69,6 +74,7 @@ int DRM(mmap)(dev_t kdev, vm_offset_t offset, int prot)
case _DRM_REGISTERS:
case _DRM_AGP:
return atop(offset);
case _DRM_SCATTER_GATHER:
case _DRM_SHM:
return atop(vtophys(offset));
default:

0
bsd/gamma/gamma.h → bsd/gamma.h
View File

20
bsd/gamma/Makefile
View File

@ -1,9 +1,10 @@
# $FreeBSD$
.PATH: ${.CURDIR}/..
KMOD = gamma
NOMAN= YES
SRCS = gamma_drv.c gamma_dma.c
SRCS += device_if.h bus_if.h pci_if.h opt_drm_linux.h
SRCS += device_if.h bus_if.h pci_if.h opt_drm.h
CFLAGS += ${DEBUG_FLAGS} -I. -I..
@:
@ -12,14 +13,17 @@ CFLAGS += ${DEBUG_FLAGS} -I. -I..
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#TDFX_OPTS= "\#define DRM_LINUX" 1
.if defined(DRM_DEBUG)
DRM_DEBUG_OPT= "\#define DRM_DEBUG 1"
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(TDFX_OPTS) >> opt_drm_linux.h
.if !defined(DRM_NOLINUX)
DRM_LINUX_OPT= "\#define DRM_LINUX 1"
.endif
opt_drm.h:
touch opt_drm.h
echo $(DRM_DEBUG_OPT) >> opt_drm.h
echo $(DRM_LINUX_OPT) >> opt_drm.h
.include <bsd.kmod.mk>

569
bsd/gamma_dma.c Normal file
View File

@ -0,0 +1,569 @@
/* gamma_dma.c -- DMA support for GMX 2000 -*- linux-c -*-
* Created: Fri Mar 19 14:30:16 1999 by faith@precisioninsight.com
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Authors:
* Rickard E. (Rik) Faith <faith@valinux.com>
*
*/
#include "gamma.h"
#include "drmP.h"
#include "drm.h"
#include "gamma_drm.h"
#include "gamma_drv.h"
static __inline__ void gamma_dma_dispatch(drm_device_t *dev, unsigned long address,
unsigned long length)
{
drm_gamma_private_t *dev_priv =
(drm_gamma_private_t *)dev->dev_private;
GAMMA_WRITE(GAMMA_DMAADDRESS, DRM_VTOPHYS((void *)address));
while (GAMMA_READ(GAMMA_GCOMMANDSTATUS) != 4)
;
GAMMA_WRITE(GAMMA_DMACOUNT, length / 4);
}
void gamma_dma_quiescent_single(drm_device_t *dev)
{
drm_gamma_private_t *dev_priv =
(drm_gamma_private_t *)dev->dev_private;
while (GAMMA_READ(GAMMA_DMACOUNT))
;
while (GAMMA_READ(GAMMA_INFIFOSPACE) < 3)
;
GAMMA_WRITE(GAMMA_FILTERMODE, 1 << 10);
GAMMA_WRITE(GAMMA_SYNC, 0);
do {
while (!GAMMA_READ(GAMMA_OUTFIFOWORDS))
;
} while (GAMMA_READ(GAMMA_OUTPUTFIFO) != GAMMA_SYNC_TAG);
}
void gamma_dma_quiescent_dual(drm_device_t *dev)
{
drm_gamma_private_t *dev_priv =
(drm_gamma_private_t *)dev->dev_private;
while (GAMMA_READ(GAMMA_DMACOUNT))
;
while (GAMMA_READ(GAMMA_INFIFOSPACE) < 3)
;
GAMMA_WRITE(GAMMA_BROADCASTMASK, 3);
GAMMA_WRITE(GAMMA_FILTERMODE, 1 << 10);
GAMMA_WRITE(GAMMA_SYNC, 0);
/* Read from first MX */
do {
while (!GAMMA_READ(GAMMA_OUTFIFOWORDS))
;
} while (GAMMA_READ(GAMMA_OUTPUTFIFO) != GAMMA_SYNC_TAG);
/* Read from second MX */
do {
while (!GAMMA_READ(GAMMA_OUTFIFOWORDS + 0x10000))
;
} while (GAMMA_READ(GAMMA_OUTPUTFIFO + 0x10000) != GAMMA_SYNC_TAG);
}
void gamma_dma_ready(drm_device_t *dev)
{
drm_gamma_private_t *dev_priv =
(drm_gamma_private_t *)dev->dev_private;
while (GAMMA_READ(GAMMA_DMACOUNT))
;
}
static __inline__ int gamma_dma_is_ready(drm_device_t *dev)
{
drm_gamma_private_t *dev_priv =
(drm_gamma_private_t *)dev->dev_private;
return !GAMMA_READ(GAMMA_DMACOUNT);
}
void gamma_dma_service( DRM_IRQ_ARGS)
{
drm_device_t *dev = (drm_device_t *)device;
drm_device_dma_t *dma = dev->dma;
drm_gamma_private_t *dev_priv =
(drm_gamma_private_t *)dev->dev_private;
atomic_inc(&dev->counts[6]); /* _DRM_STAT_IRQ */
GAMMA_WRITE(GAMMA_GDELAYTIMER, 0xc350/2); /* 0x05S */
GAMMA_WRITE(GAMMA_GCOMMANDINTFLAGS, 8);
GAMMA_WRITE(GAMMA_GINTFLAGS, 0x2001);
if (gamma_dma_is_ready(dev)) {
/* Free previous buffer */
if (test_and_set_bit(0, &dev->dma_flag)) return;
if (dma->this_buffer) {
gamma_free_buffer(dev, dma->this_buffer);
dma->this_buffer = NULL;
}
clear_bit(0, &dev->dma_flag);
taskqueue_enqueue(taskqueue_swi, &dev->task);
}
}
/* Only called by gamma_dma_schedule. */
static int gamma_do_dma(drm_device_t *dev, int locked)
{
unsigned long address;
unsigned long length;
drm_buf_t *buf;
int retcode = 0;
drm_device_dma_t *dma = dev->dma;
#if DRM_DMA_HISTOGRAM
cycles_t dma_start, dma_stop;
#endif
if (test_and_set_bit(0, &dev->dma_flag)) return DRM_ERR( EBUSY );
#if DRM_DMA_HISTOGRAM
dma_start = get_cycles();
#endif
if (!dma->next_buffer) {
DRM_ERROR("No next_buffer\n");
clear_bit(0, &dev->dma_flag);
return DRM_ERR( EINVAL );
}
buf = dma->next_buffer;
address = (unsigned long)buf->address;
length = buf->used;
DRM_DEBUG("context %d, buffer %d (%ld bytes)\n",
buf->context, buf->idx, length);
if (buf->list == DRM_LIST_RECLAIM) {
gamma_clear_next_buffer(dev);
gamma_free_buffer(dev, buf);
clear_bit(0, &dev->dma_flag);
return DRM_ERR( EINVAL );
}
if (!length) {
DRM_ERROR("0 length buffer\n");
gamma_clear_next_buffer(dev);
gamma_free_buffer(dev, buf);
clear_bit(0, &dev->dma_flag);
return 0;
}
if (!gamma_dma_is_ready(dev)) {
clear_bit(0, &dev->dma_flag);
return DRM_ERR( EBUSY );
}
if (buf->while_locked) {
if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
DRM_ERROR("Dispatching buffer %d from pid %d"
" \"while locked\", but no lock held\n",
buf->idx, buf->pid);
}
} else {
if (!locked && !gamma_lock_take(&dev->lock.hw_lock->lock,
DRM_KERNEL_CONTEXT)) {
clear_bit(0, &dev->dma_flag);
return DRM_ERR( EBUSY );
}
}
if (dev->last_context != buf->context
&& !(dev->queuelist[buf->context]->flags
& _DRM_CONTEXT_PRESERVED)) {
/* PRE: dev->last_context != buf->context */
if (DRM(context_switch)(dev, dev->last_context,
buf->context)) {
DRM(clear_next_buffer)(dev);
DRM(free_buffer)(dev, buf);
}
retcode = EBUSY;
goto cleanup;
/* POST: we will wait for the context
switch and will dispatch on a later call
when dev->last_context == buf->context.
NOTE WE HOLD THE LOCK THROUGHOUT THIS
TIME! */
}
gamma_clear_next_buffer(dev);
buf->pending = 1;
buf->waiting = 0;
buf->list = DRM_LIST_PEND;
#if DRM_DMA_HISTOGRAM
buf->time_dispatched = get_cycles();
#endif
gamma_dma_dispatch(dev, address, length);
gamma_free_buffer(dev, dma->this_buffer);
dma->this_buffer = buf;
atomic_inc(&dev->counts[7]); /* _DRM_STAT_DMA */
atomic_add(length, &dev->counts[8]); /* _DRM_STAT_PRIMARY */
if (!buf->while_locked && !dev->context_flag && !locked) {
if (gamma_lock_free(dev, &dev->lock.hw_lock->lock,
DRM_KERNEL_CONTEXT)) {
DRM_ERROR("\n");
}
}
cleanup:
clear_bit(0, &dev->dma_flag);
#if DRM_DMA_HISTOGRAM
dma_stop = get_cycles();
atomic_inc(&dev->histo.dma[gamma_histogram_slot(dma_stop - dma_start)]);
#endif
return DRM_ERR( retcode );
}
static void gamma_dma_timer_bh(unsigned long dev)
{
gamma_dma_schedule((drm_device_t *)dev, 0);
}
void gamma_dma_immediate_bh(DRM_TASKQUEUE_ARGS)
{
gamma_dma_schedule(dev, 0);
}
int gamma_dma_schedule(drm_device_t *dev, int locked)
{
int next;
drm_queue_t *q;
drm_buf_t *buf;
int retcode = 0;
int processed = 0;
int missed;
int expire = 20;
drm_device_dma_t *dma = dev->dma;
#if DRM_DMA_HISTOGRAM
cycles_t schedule_start;
#endif
if (test_and_set_bit(0, &dev->interrupt_flag)) {
/* Not reentrant */
atomic_inc(&dev->counts[10]); /* _DRM_STAT_MISSED */
return DRM_ERR( EBUSY );
}
missed = atomic_read(&dev->counts[10]);
#if DRM_DMA_HISTOGRAM
schedule_start = get_cycles();
#endif
again:
if (dev->context_flag) {
clear_bit(0, &dev->interrupt_flag);
return DRM_ERR( EBUSY );
}
if (dma->next_buffer) {
/* Unsent buffer that was previously
selected, but that couldn't be sent
because the lock could not be obtained
or the DMA engine wasn't ready. Try
again. */
if (!(retcode = gamma_do_dma(dev, locked))) ++processed;
} else {
do {
next = gamma_select_queue(dev, gamma_dma_timer_bh);
if (next >= 0) {
q = dev->queuelist[next];
buf = gamma_waitlist_get(&q->waitlist);
dma->next_buffer = buf;
dma->next_queue = q;
if (buf && buf->list == DRM_LIST_RECLAIM) {
gamma_clear_next_buffer(dev);
gamma_free_buffer(dev, buf);
}
}
} while (next >= 0 && !dma->next_buffer);
if (dma->next_buffer) {
if (!(retcode = gamma_do_dma(dev, locked))) {
++processed;
}
}
}
if (--expire) {
if (missed != atomic_read(&dev->counts[10])) {
if (gamma_dma_is_ready(dev)) goto again;
}
if (processed && gamma_dma_is_ready(dev)) {
processed = 0;
goto again;
}
}
clear_bit(0, &dev->interrupt_flag);
#if DRM_DMA_HISTOGRAM
atomic_inc(&dev->histo.schedule[gamma_histogram_slot(get_cycles()
- schedule_start)]);
#endif
return retcode;
}
static int gamma_dma_priority(drm_device_t *dev, drm_dma_t *d)
{
unsigned long address;
unsigned long length;
int must_free = 0;
int retcode = 0;
int i;
int idx;
drm_buf_t *buf;
drm_buf_t *last_buf = NULL;
drm_device_dma_t *dma = dev->dma;
static int never;
/* Turn off interrupt handling */
while (test_and_set_bit(0, &dev->interrupt_flag)) {
retcode = tsleep(&never, PZERO|PCATCH, "gamp1", 1);
if (retcode)
return retcode;
}
if (!(d->flags & _DRM_DMA_WHILE_LOCKED)) {
while (!gamma_lock_take(&dev->lock.hw_lock->lock,
DRM_KERNEL_CONTEXT)) {
retcode = tsleep(&never, PZERO|PCATCH, "gamp2", 1);
if (retcode)
return retcode;
}
++must_free;
}
for (i = 0; i < d->send_count; i++) {
idx = d->send_indices[i];
if (idx < 0 || idx >= dma->buf_count) {
DRM_ERROR("Index %d (of %d max)\n",
d->send_indices[i], dma->buf_count - 1);
continue;
}
buf = dma->buflist[ idx ];
if (buf->pid != DRM_CURRENTPID) {
DRM_ERROR("Process %d using buffer owned by %d\n",
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_CURRENTPID, buf->pid, buf->list);
retcode = EINVAL;
goto cleanup;
}
/* This isn't a race condition on
buf->list, since our concern is the
buffer reclaim during the time the
process closes the /dev/drm? handle, so
it can't also be doing DMA. */
buf->list = DRM_LIST_PRIO;
buf->used = d->send_sizes[i];
buf->context = d->context;
buf->while_locked = d->flags & _DRM_DMA_WHILE_LOCKED;
address = (unsigned long)buf->address;
length = buf->used;
if (!length) {
DRM_ERROR("0 length buffer\n");
}
if (buf->pending) {
DRM_ERROR("Sending pending buffer:"
" buffer %d, offset %d\n",
d->send_indices[i], i);
retcode = EINVAL;
goto cleanup;
}
if (buf->waiting) {
DRM_ERROR("Sending waiting buffer:"
" buffer %d, offset %d\n",
d->send_indices[i], i);
retcode = EINVAL;
goto cleanup;
}
buf->pending = 1;
if (dev->last_context != buf->context
&& !(dev->queuelist[buf->context]->flags
& _DRM_CONTEXT_PRESERVED)) {
/* PRE: dev->last_context != buf->context */
DRM(context_switch)(dev, dev->last_context,
buf->context);
/* POST: we will wait for the context
switch and will dispatch on a later call
when dev->last_context == buf->context.
NOTE WE HOLD THE LOCK THROUGHOUT THIS
TIME! */
retcode = tsleep(&dev->context_wait, PZERO|PCATCH,
"gamctx", 0);
if (retcode)
goto cleanup;
if (dev->last_context != buf->context) {
DRM_ERROR("Context mismatch: %d %d\n",
dev->last_context,
buf->context);
}
}
#if DRM_DMA_HISTOGRAM
buf->time_queued = get_cycles();
buf->time_dispatched = buf->time_queued;
#endif
gamma_dma_dispatch(dev, address, length);
atomic_inc(&dev->counts[9]); /* _DRM_STAT_SPECIAL */
atomic_add(length, &dev->counts[8]); /* _DRM_STAT_PRIMARY */
if (last_buf) {
gamma_free_buffer(dev, last_buf);
}
last_buf = buf;
}
cleanup:
if (last_buf) {
gamma_dma_ready(dev);
gamma_free_buffer(dev, last_buf);
}
if (must_free && !dev->context_flag) {
if (gamma_lock_free(dev, &dev->lock.hw_lock->lock,
DRM_KERNEL_CONTEXT)) {
DRM_ERROR("\n");
}
}
clear_bit(0, &dev->interrupt_flag);
return DRM_ERR( retcode );
}
static int gamma_dma_send_buffers(drm_device_t *dev, drm_dma_t *d)
{
drm_buf_t *last_buf = NULL;
int retcode = 0;
drm_device_dma_t *dma = dev->dma;
if (d->flags & _DRM_DMA_BLOCK) {
last_buf = dma->buflist[d->send_indices[d->send_count-1]];
atomic_inc(&last_buf->dma_wait);
}
if ((retcode = gamma_dma_enqueue(dev, d))) {
if (d->flags & _DRM_DMA_BLOCK)
atomic_dec(&last_buf->dma_wait);
return retcode;
}
gamma_dma_schedule(dev, 0);
if (d->flags & _DRM_DMA_BLOCK) {
DRM_DEBUG("%d waiting\n", DRM_CURRENTPID);
for (;;) {
retcode = tsleep(&last_buf->dma_wait, PZERO|PCATCH,
"gamdw", 0);
if (!last_buf->waiting
&& !last_buf->pending)
break; /* finished */
if (retcode)
break;
}
atomic_dec(&last_buf->dma_wait);
DRM_DEBUG("%d running\n", DRM_CURRENTPID);
if (!retcode
|| (last_buf->list==DRM_LIST_PEND && !last_buf->pending)) {
if (!last_buf->dma_wait) {
gamma_free_buffer(dev, last_buf);
}
}
if (retcode) {
DRM_ERROR("ctx%d w%d p%d c%d i%d l%d %d/%d\n",
d->context,
last_buf->waiting,
last_buf->pending,
DRM_WAITCOUNT(dev, d->context),
last_buf->idx,
last_buf->list,
last_buf->pid,
DRM_CURRENTPID);
}
}
return DRM_ERR( retcode );
}
int gamma_dma( DRM_IOCTL_ARGS )
{
DRM_DEVICE;
drm_device_dma_t *dma = dev->dma;
int retcode = 0;
drm_dma_t 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_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_CURRENTPID, d.request_count, dma->buf_count);
return DRM_ERR( EINVAL );
}
if (d.send_count) {
if (d.flags & _DRM_DMA_PRIORITY)
retcode = gamma_dma_priority(dev, &d);
else
retcode = gamma_dma_send_buffers(dev, &d);
}
d.granted_count = 0;
if (!retcode && d.request_count) {
retcode = gamma_dma_get_buffers(dev, &d);
}
DRM_DEBUG("%d returning, granted = %d\n",
DRM_CURRENTPID, d.granted_count);
DRM_COPY_TO_USER_IOCTL((drm_dma_t *) data, d, sizeof(d));
return retcode;
}

70
bsd/sis/sis_drv.c → bsd/gamma_drv.c
View File

@ -1,4 +1,5 @@
/* sis.c -- sis driver -*- linux-c -*-
/* gamma.c -- 3dlabs GMX 2000 driver -*- linux-c -*-
* Created: Mon Jan 4 08:58:31 1999 by faith@precisioninsight.com
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
@ -10,11 +11,11 @@
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
@ -23,61 +24,56 @@
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Authors:
* Rickard E. (Rik) Faith <faith@valinux.com>
* Gareth Hughes <gareth@valinux.com>
*/
#include <sys/types.h>
#include <sys/bus.h>
#include <pci/pcivar.h>
#include <opt_drm_linux.h>
#include "sis.h"
#include "gamma.h"
#include "drmP.h"
#include "sis_drm.h"
#include "sis_drv.h"
#include "drm.h"
#include "gamma_drm.h"
#include "gamma_drv.h"
#define DRIVER_AUTHOR "SIS"
#define DRIVER_NAME "sis"
#define DRIVER_DESC "SIS 300/630/540"
#define DRIVER_DATE "20010503"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 0
#define DRIVER_PATCHLEVEL 0
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "gamma"
#define DRIVER_DESC "3DLabs gamma"
#define DRIVER_DATE "20010216"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 0
#define DRIVER_PATCHLEVEL 0
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = { gamma_dma, 1, 0 }
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
* Please report to anholt@teleport.com inaccuracies or if a chip you have works that is marked unsupported here.
*/
drm_chipinfo_t DRM(devicelist)[] = {
{0x1039, 0x0300, 1, "SIS 300"},
{0x1039, 0x0540, 1, "SIS 540"},
{0x1039, 0x0630, 1, "SIS 630"},
{0x3d3d, 0x0008, 1, "3DLabs Gamma"},
{0, 0, 0, NULL}
};
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(SIS_IOCTL_FB_ALLOC)] = { sis_fb_alloc, 1, 1 }, \
[DRM_IOCTL_NR(SIS_IOCTL_FB_FREE)] = { sis_fb_free, 1, 1 }, \
/* AGP Memory Management */ \
[DRM_IOCTL_NR(SIS_IOCTL_AGP_INIT)] = { sisp_agp_init, 1, 1 }, \
[DRM_IOCTL_NR(SIS_IOCTL_AGP_ALLOC)] = { sisp_agp_alloc, 1, 1 }, \
[DRM_IOCTL_NR(SIS_IOCTL_AGP_FREE)] = { sisp_agp_free, 1, 1 }
#if 0 /* these don't appear to be defined */
/* SIS Stereo */
[DRM_IOCTL_NR(DRM_IOCTL_CONTROL)] = { sis_control, 1, 1 },
[DRM_IOCTL_NR(SIS_IOCTL_FLIP)] = { sis_flip, 1, 1 },
[DRM_IOCTL_NR(SIS_IOCTL_FLIP_INIT)] = { sis_flip_init, 1, 1 },
[DRM_IOCTL_NR(SIS_IOCTL_FLIP_FINAL)] = { sis_flip_final, 1, 1 }
#endif
#define __HAVE_COUNTERS 5
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_DMA
#define __HAVE_COUNTER8 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER9 _DRM_STAT_SPECIAL
#define __HAVE_COUNTER10 _DRM_STAT_MISSED
#include "drm_auth.h"
#include "drm_agpsupport.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
@ -87,4 +83,4 @@ drm_chipinfo_t DRM(devicelist)[] = {
#include "drm_vm.h"
#include "drm_sysctl.h"
DRIVER_MODULE(sis, pci, sis_driver, sis_devclass, 0, 0);
DRIVER_MODULE(gamma, pci, gamma_driver, gamma_devclass, 0, 0);

6
bsd/gamma/gamma_drv.h → 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);

0
bsd/i810/i810.h → bsd/i810.h
View File

1223
bsd/i810_dma.c Normal file
View File

File diff suppressed because it is too large Load Diff

96
bsd/i810_drv.c Normal file
View File

@ -0,0 +1,96 @@
/* i810_drv.c -- I810 driver -*- linux-c -*-
* Created: Mon Dec 13 01:56:22 1999 by jhartmann@precisioninsight.com
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Rickard E. (Rik) Faith <faith@valinux.com>
* Jeff Hartmann <jhartmann@valinux.com>
* Gareth Hughes <gareth@valinux.com>
*/
#include <sys/types.h>
#include <sys/bus.h>
#include <pci/pcivar.h>
#include "i810.h"
#include "drmP.h"
#include "drm.h"
#include "i810_drm.h"
#include "i810_drv.h"
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "i810"
#define DRIVER_DESC "Intel i810"
#define DRIVER_DATE "20010616"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 2
#define DRIVER_PATCHLEVEL 0
/* Device IDs unknown. Can someone help? anholt@teleport.com */
drm_chipinfo_t DRM(devicelist)[] = {
{0, 0, 0, NULL}
};
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_I810_INIT)] = { i810_dma_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_VERTEX)] = { i810_dma_vertex, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_CLEAR)] = { i810_clear_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_FLUSH)] = { i810_flush_ioctl, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_GETAGE)] = { i810_getage, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_GETBUF)] = { i810_getbuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_SWAP)] = { i810_swap_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_COPY)] = { i810_copybuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_DOCOPY)] = { i810_docopy, 1, 0 },
#define __HAVE_COUNTERS 4
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#define __HAVE_COUNTER9 _DRM_STAT_DMA
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_lists.h"
#include "drm_memory.h"
#include "drm_vm.h"
#include "drm_sysctl.h"
DRIVER_MODULE(i810, pci, i810_driver, i810_devclass, 0, 0);

18
bsd/i810/i810_drv.h → 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)

0
bsd/i830/i830.h → bsd/i830.h
View File

1420
bsd/i830_dma.c Normal file
View File

File diff suppressed because it is too large Load Diff

104
bsd/i830_drv.c Normal file
View File

@ -0,0 +1,104 @@
/* i830_drv.c -- I810 driver -*- linux-c -*-
* Created: Mon Dec 13 01:56:22 1999 by jhartmann@precisioninsight.com
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Rickard E. (Rik) Faith <faith@valinux.com>
* Jeff Hartmann <jhartmann@valinux.com>
* Gareth Hughes <gareth@valinux.com>
* Abraham vd Merwe <abraham@2d3d.co.za>
*/
#include <linux/config.h>
#include "i830.h"
#include "drmP.h"
#include "drm.h"
#include "i830_drm.h"
#include "i830_drv.h"
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "i830"
#define DRIVER_DESC "Intel 830M"
#define DRIVER_DATE "20011004"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 2
#define DRIVER_PATCHLEVEL 0
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_I830_INIT)] = { i830_dma_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_VERTEX)] = { i830_dma_vertex, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_CLEAR)] = { i830_clear_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_FLUSH)] = { i830_flush_ioctl, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_GETAGE)] = { i830_getage, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_GETBUF)] = { i830_getbuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_SWAP)] = { i830_swap_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_COPY)] = { i830_copybuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_DOCOPY)] = { i830_docopy, 1, 0 },
#define __HAVE_COUNTERS 4
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#define __HAVE_COUNTER9 _DRM_STAT_DMA
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* JH- We have to hand expand the string ourselves because of the cpp. If
* anyone can think of a way that we can fit into the __setup macro without
* changing it, then please send the solution my way.
*/
static int __init i830_options( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", i830_options );
#endif
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_lists.h"
#include "drm_memory.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"

0
bsd/i830/i830_drv.h → bsd/i830_drv.h
View File

20
bsd/mga/Makefile
View File

@ -1,9 +1,10 @@
# $FreeBSD$
.PATH: ${.CURDIR}/..
KMOD= mga
NOMAN= YES
SRCS= mga_drv.c mga_state.c mga_warp.c mga_dma.c
SRCS+= device_if.h bus_if.h pci_if.h opt_drm_linux.h
SRCS+= device_if.h bus_if.h pci_if.h opt_drm.h
CFLAGS+= ${DEBUG_FLAGS} -I. -I..
@:
@ -12,14 +13,17 @@ CFLAGS+= ${DEBUG_FLAGS} -I. -I..
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#MGA_OPTS= "\#define DRM_LINUX" 1
.if defined(DRM_DEBUG)
DRM_DEBUG_OPT= "\#define DRM_DEBUG 1"
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(MGA_OPTS) >> opt_drm_linux.h
.if !defined(DRM_NOLINUX)
DRM_LINUX_OPT= "\#define DRM_LINUX 1"
.endif
opt_drm.h:
touch opt_drm.h
echo $(DRM_DEBUG_OPT) >> opt_drm.h
echo $(DRM_LINUX_OPT) >> opt_drm.h
.include <bsd.kmod.mk>

66
bsd/mga_drv.c Normal file
View File

@ -0,0 +1,66 @@
/* mga_drv.c -- Matrox G200/G400 driver -*- linux-c -*-
* Created: Mon Dec 13 01:56:22 1999 by jhartmann@precisioninsight.com
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Rickard E. (Rik) Faith <faith@valinux.com>
* Gareth Hughes <gareth@valinux.com>
*/
#include <sys/types.h>
#include "mga.h"
#include "drmP.h"
#include "drm.h"
#include "mga_drm.h"
#include "mga_drv.h"
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
* Please report to anholt@teleport.com inaccuracies or if a chip you have works that is marked unsupported here.
*/
drm_chipinfo_t DRM(devicelist)[] = {
{0x102b, 0x0520, 0, "Matrox G200 (PCI)"},
{0x102b, 0x0521, 1, "Matrox G200 (AGP)"},
{0x102b, 0x0525, 1, "Matrox G400/G450 (AGP)"},
{0x102b, 0x2527, 1, "Matrox G550 (AGP)"},
{0, 0, 0, NULL}
};
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_vm.h"
#include "drm_sysctl.h"
DRIVER_MODULE(mga, pci, mga_driver, mga_devclass, 0, 0);

20
bsd/r128/Makefile
View File

@ -1,9 +1,10 @@
# $FreeBSD$
.PATH: ${.CURDIR}/..
KMOD = r128
NOMAN= YES
SRCS = r128_cce.c r128_drv.c r128_state.c
SRCS += device_if.h bus_if.h pci_if.h opt_drm_linux.h
SRCS += device_if.h bus_if.h pci_if.h opt_drm.h
CFLAGS += ${DEBUG_FLAGS} -I. -I..
@:
@ -12,14 +13,17 @@ CFLAGS += ${DEBUG_FLAGS} -I. -I..
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#R128_OPTS= "\#define DRM_LINUX" 1
.if defined(DRM_DEBUG)
DRM_DEBUG_OPT= "\#define DRM_DEBUG 1"
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(R128_OPTS) >> opt_drm_linux.h
.if !defined(DRM_NOLINUX)
DRM_LINUX_OPT= "\#define DRM_LINUX 1"
.endif
opt_drm.h:
touch opt_drm.h
echo $(DRM_DEBUG_OPT) >> opt_drm.h
echo $(DRM_LINUX_OPT) >> opt_drm.h
.include <bsd.kmod.mk>

81
bsd/r128/r128.h
View File

@ -1,81 +0,0 @@
/* r128.h -- ATI Rage 128 DRM template customization -*- linux-c -*-
* Created: Wed Feb 14 16:07:10 2001 by gareth@valinux.com
*
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Gareth Hughes <gareth@valinux.com>
*/
#ifndef __R128_H__
#define __R128_H__
/* This remains constant for all DRM template files.
*/
#define DRM(x) r128_##x
/* General customization:
*/
#define __HAVE_AGP 1
#define __MUST_HAVE_AGP 0
#define __HAVE_MTRR 1
#define __HAVE_CTX_BITMAP 1
#define __HAVE_SG 1
#define __HAVE_PCI_DMA 1
/* Driver customization:
*/
#define DRIVER_PRERELEASE() do { \
if ( dev->dev_private ) { \
drm_r128_private_t *dev_priv = dev->dev_private; \
if ( dev_priv->page_flipping ) { \
r128_do_cleanup_pageflip( dev ); \
} \
} \
} while (0)
#define DRIVER_PRETAKEDOWN() do { \
if ( dev->dev_private ) r128_do_cleanup_cce( dev ); \
} while (0)
/* DMA customization:
*/
#define __HAVE_DMA 1
#if 0
/* GH: Remove this for now... */
#define __HAVE_DMA_QUIESCENT 1
#define DRIVER_DMA_QUIESCENT() do { \
drm_r128_private_t *dev_priv = dev->dev_private; \
return r128_do_cce_idle( dev_priv ); \
} while (0)
#endif
/* Buffer customization:
*/
#define DRIVER_BUF_PRIV_T drm_r128_buf_priv_t
#define DRIVER_AGP_BUFFERS_MAP( dev ) \
((drm_r128_private_t *)((dev)->dev_private))->buffers
#endif

86
bsd/r128_drv.c Normal file
View File

@ -0,0 +1,86 @@
/* r128_drv.c -- ATI Rage 128 driver -*- linux-c -*-
* Created: Mon Dec 13 09:47:27 1999 by faith@precisioninsight.com
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Rickard E. (Rik) Faith <faith@valinux.com>
* Gareth Hughes <gareth@valinux.com>
*/
#include <sys/types.h>
#include "r128.h"
#include "drmP.h"
#include "drm.h"
#include "r128_drm.h"
#include "r128_drv.h"
#if __REALLY_HAVE_SG
#include "ati_pcigart.h"
#endif
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
* Please report to eta@lclark.edu inaccuracies or if a chip you have works that is marked unsupported here.
*/
drm_chipinfo_t DRM(devicelist)[] = {
{0x1002, 0x4c45, __REALLY_HAVE_SG, "ATI Rage 128 Mobility LE (PCI)"},
{0x1002, 0x4c46, 1, "ATI Rage 128 Mobility LF (AGP)"},
{0x1002, 0x4d46, 1, "ATI Rage 128 Mobility MF (AGP)"},
{0x1002, 0x4d4c, 1, "ATI Rage 128 Mobility ML (AGP)"},
{0x1002, 0x5044, __REALLY_HAVE_SG, "ATI Rage 128 Pro PD (PCI)"},
{0x1002, 0x5046, 1, "ATI Rage 128 Pro PF (AGP)"},
{0x1002, 0x5050, __REALLY_HAVE_SG, "ATI Rage 128 Pro PP (PCI)"},
{0x1002, 0x5052, __REALLY_HAVE_SG, "ATI Rage 128 Pro PR (PCI)"},
{0x1002, 0x5245, __REALLY_HAVE_SG, "ATI Rage 128 RE (PCI)"},
{0x1002, 0x5246, 1, "ATI Rage 128 RF (AGP)"},
{0x1002, 0x5247, 1, "ATI Rage 128 RG (AGP)"},
{0x1002, 0x524b, __REALLY_HAVE_SG, "ATI Rage 128 RK (PCI)"},
{0x1002, 0x524c, 1, "ATI Rage 128 RL (AGP)"},
{0x1002, 0x534d, 1, "ATI Rage 128 SM (AGP)"},
{0x1002, 0x5446, 1, "ATI Rage 128 Pro Ultra TF (AGP)"},
{0x1002, 0x544C, 1, "ATI Rage 128 Pro Ultra TL (AGP)"},
{0x1002, 0x5452, 1, "ATI Rage 128 Pro Ultra TR (AGP)"},
{0, 0, 0, NULL}
};
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_sysctl.h"
#include "drm_vm.h"
#if __HAVE_SG
#include "drm_scatter.h"
#endif
DRIVER_MODULE(r128, pci, r128_driver, r128_devclass, 0, 0);

20
bsd/radeon/Makefile
View File

@ -1,9 +1,10 @@
# $FreeBSD$
.PATH: ${.CURDIR}/..
KMOD = radeon
NOMAN= YES
SRCS = radeon_cp.c radeon_drv.c radeon_state.c
SRCS += device_if.h bus_if.h pci_if.h opt_drm_linux.h
SRCS += device_if.h bus_if.h pci_if.h opt_drm.h
CFLAGS += ${DEBUG_FLAGS} -I. -I..
@:
@ -12,14 +13,17 @@ CFLAGS += ${DEBUG_FLAGS} -I. -I..
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#RADEON_OPTS= "\#define DRM_LINUX" 1
.if defined(DRM_DEBUG)
DRM_DEBUG_OPT= "\#define DRM_DEBUG 1"
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(RADEON_OPTS) >> opt_drm_linux.h
.if !defined(DRM_NOLINUX)
DRM_LINUX_OPT= "\#define DRM_LINUX 1"
.endif
opt_drm.h:
touch opt_drm.h
echo $(DRM_DEBUG_OPT) >> opt_drm.h
echo $(DRM_LINUX_OPT) >> opt_drm.h
.include <bsd.kmod.mk>

76
bsd/radeon_drv.c Normal file
View File

@ -0,0 +1,76 @@
/* radeon_drv.c -- ATI Radeon driver -*- linux-c -*-
* Created: Wed Feb 14 17:10:04 2001 by gareth@valinux.com
*
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Authors:
* Gareth Hughes <gareth@valinux.com>
*/
#include <sys/types.h>
#include "radeon.h"
#include "drmP.h"
#include "drm.h"
#include "radeon_drm.h"
#include "radeon_drv.h"
#if __REALLY_HAVE_SG
#include "ati_pcigart.h"
#endif
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
* Please report to eta@lclark.edu inaccuracies or if a chip you have works that is marked unsupported here.
*/
drm_chipinfo_t DRM(devicelist)[] = {
{0x1002, 0x4C57, 1, "ATI Radeon LW Mobility 7 (AGP)"},
{0x1002, 0x4C59, 1, "ATI Radeon LY Mobility 6 (AGP)"},
{0x1002, 0x4C5A, 1, "ATI Radeon LZ Mobility 6 (AGP)"},
{0x1002, 0x5144, 1, "ATI Radeon QD (AGP)"},
{0x1002, 0x5145, 1, "ATI Radeon QE (AGP)"},
{0x1002, 0x5146, 1, "ATI Radeon QF (AGP)"},
{0x1002, 0x5147, 1, "ATI Radeon QG (AGP)"},
{0x1002, 0x5157, 1, "ATI Radeon QW 7500 (AGP)"},
{0x1002, 0x5159, 1, "ATI Radeon QY VE (AGP)"},
{0x1002, 0x515A, 1, "ATI Radeon QZ VE (AGP)"},
{0, 0, 0, NULL}
};
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_vm.h"
#include "drm_sysctl.h"
#if __HAVE_SG
#include "drm_scatter.h"
#endif
DRIVER_MODULE(DRIVER_NAME, pci, DRM(driver), DRM(devclass), 0, 0);

25
bsd/sis/Makefile
View File

@ -1,25 +0,0 @@
# $FreeBSD$
KMOD= sis
NOMAN= YES
SRCS= sis_drv.c sis_ds.c sis_mm.c
SRCS+= device_if.h bus_if.h pci_if.h opt_drm_linux.h
CFLAGS+= ${DEBUG_FLAGS} -I. -I..
@:
ln -sf /sys @
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#SIS_OPTS= "\#define DRM_LINUX" 1
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(SIS_OPTS) >> opt_drm_linux.h
.include <bsd.kmod.mk>

45
bsd/sis/sis.h
View File

@ -1,45 +0,0 @@
/* sis_drv.h -- Private header for sis driver -*- linux-c -*-
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
*/
/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/bsd/drm/kernel/sis/sis.h,v 1.1 2001/12/13 00:24:51 alanh Exp $ */
#ifndef __SIS_H__
#define __SIS_H__
/* General customization:
*/
#define __HAVE_AGP 1
#define __MUST_HAVE_AGP 0
#define __HAVE_MTRR 1
#define __HAVE_CTX_BITMAP 1
/* Buffer customization:
*/
#define DRIVER_AGP_BUFFERS_MAP( dev ) \
((drm_sis_private_t *)((dev)->dev_private))->buffers
#endif

30
bsd/sis/sis_drm.h
View File

@ -1,30 +0,0 @@
#ifndef _sis_drm_public_h_
#define _sis_drm_public_h_
typedef struct {
int context;
unsigned int offset;
unsigned int size;
unsigned int free;
} drm_sis_mem_t;
typedef struct {
unsigned int offset, size;
} drm_sis_agp_t;
typedef struct {
unsigned int left, right;
} drm_sis_flip_t;
#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);
#endif
#endif

42
bsd/sis/sis_drv.h
View File

@ -1,42 +0,0 @@
/* sis_drv.h -- Private header for sis driver -*- linux-c -*-
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
*/
#ifndef _SIS_DRV_H_
#define _SIS_DRV_H_
typedef struct drm_sis_private {
drm_map_t *buffers;
} drm_sis_private_t;
/* Stereo ? - this was never committed */
int sis_flip( DRM_OS_IOCTL );
int sis_flip_init( DRM_OS_IOCTL );
int sis_flip_final( DRM_OS_IOCTL );
void flip_final(void);
#endif

398
bsd/sis/sis_ds.c
View File

@ -1,398 +0,0 @@
/* sis_ds.c -- Private header for Direct Rendering Manager -*- linux-c -*-
* Created: Mon Jan 4 10:05:05 1999 by sclin@sis.com.tw
*
* Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Authors:
* Sung-Ching Lin <sclin@sis.com.tw>
*
*/
#include "sis.h"
#include "drmP.h"
#include "sis_ds.h"
/* Set Data Structure, not check repeated value
* temporarily used
*/
set_t *setInit(void)
{
int i;
set_t *set;
set = (set_t *)SD_MALLOC(sizeof(set_t));
for(i = 0; i < SET_SIZE; i++){
set->list[i].free_next = i+1;
set->list[i].alloc_next = -1;
}
set->list[SET_SIZE-1].free_next = -1;
set->free = 0;
set->alloc = -1;
set->trace = -1;
return set;
}
int setAdd(set_t *set, ITEM_TYPE item)
{
int free = set->free;
if(free != -1){
set->list[free].val = item;
set->free = set->list[free].free_next;
}
else{
return 0;
}
set->list[free].alloc_next = set->alloc;
set->alloc = free;
set->list[free].free_next = -1;
return 1;
}
int setDel(set_t *set, ITEM_TYPE item)
{
int alloc = set->alloc;
int prev = -1;
while(alloc != -1){
if(set->list[alloc].val == item){
if(prev != -1)
set->list[prev].alloc_next = set->list[alloc].alloc_next;
else
set->alloc = set->list[alloc].alloc_next;
break;
}
prev = alloc;
alloc = set->list[alloc].alloc_next;
}
if(alloc == -1)
return 0;
set->list[alloc].free_next = set->free;
set->free = alloc;
set->list[alloc].alloc_next = -1;
return 1;
}
/* setFirst -> setAdd -> setNext is wrong */
int setFirst(set_t *set, ITEM_TYPE *item)
{
if(set->alloc == -1)
return 0;
*item = set->list[set->alloc].val;
set->trace = set->list[set->alloc].alloc_next;
return 1;
}
int setNext(set_t *set, ITEM_TYPE *item)
{
if(set->trace == -1)
return 0;
*item = set->list[set->trace].val;
set->trace = set->list[set->trace].alloc_next;
return 1;
}
int setDestroy(set_t *set)
{
SD_FREE(set);
return 1;
}
/*
* GLX Hardware Device Driver common code
* Copyright (C) 1999 Keith Whitwell
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
#define ISFREE(bptr) ((bptr)->free)
#define PRINTF(fmt, arg...) do{}while(0)
#define fprintf(fmt, arg...) do{}while(0)
static void *calloc(size_t nmemb, size_t size)
{
void *addr;
addr = SD_MALLOC(nmemb*size);
memset(addr, 0, nmemb*size);
return addr;
}
void mmDumpMemInfo( memHeap_t *heap )
{
TMemBlock *p;
PRINTF ("Memory heap %p:\n", heap);
if (heap == 0) {
PRINTF (" heap == 0\n");
} else {
p = (TMemBlock *)heap;
while (p) {
PRINTF (" Offset:%08x, Size:%08x, %c%c\n",p->ofs,p->size,
p->free ? '.':'U',
p->reserved ? 'R':'.');
p = p->next;
}
}
PRINTF ("End of memory blocks\n");
}
memHeap_t *mmInit(int ofs,
int size)
{
PMemBlock blocks;
if (size <= 0) {
return 0;
}
blocks = (TMemBlock *) calloc(1,sizeof(TMemBlock));
if (blocks) {
blocks->ofs = ofs;
blocks->size = size;
blocks->free = 1;
return (memHeap_t *)blocks;
} else
return 0;
}
/* Kludgey workaround for existing i810 server. Remove soon.
*/
memHeap_t *mmAddRange( memHeap_t *heap,
int ofs,
int size )
{
PMemBlock blocks;
blocks = (TMemBlock *) calloc(2,sizeof(TMemBlock));
if (blocks) {
blocks[0].size = size;
blocks[0].free = 1;
blocks[0].ofs = ofs;
blocks[0].next = &blocks[1];
/* Discontinuity - stops JoinBlock from trying to join non-adjacent
* ranges.
*/
blocks[1].size = 0;
blocks[1].free = 0;
blocks[1].ofs = ofs+size;
blocks[1].next = (PMemBlock) heap;
return (memHeap_t *)blocks;
}
else
return heap;
}
static TMemBlock* SliceBlock(TMemBlock *p,
int startofs, int size,
int reserved, int alignment)
{
TMemBlock *newblock;
/* break left */
if (startofs > p->ofs) {
newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock));
newblock->ofs = startofs;
newblock->size = p->size - (startofs - p->ofs);
newblock->free = 1;
newblock->next = p->next;
p->size -= newblock->size;
p->next = newblock;
p = newblock;
}
/* break right */
if (size < p->size) {
newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock));
newblock->ofs = startofs + size;
newblock->size = p->size - size;
newblock->free = 1;
newblock->next = p->next;
p->size = size;
p->next = newblock;
}
/* p = middle block */
p->align = alignment;
p->free = 0;
p->reserved = reserved;
return p;
}
PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch)
{
int mask,startofs,endofs;
TMemBlock *p;
if (!heap || align2 < 0 || size <= 0)
return NULL;
mask = (1 << align2)-1;
startofs = 0;
p = (TMemBlock *)heap;
while (p) {
if (ISFREE(p)) {
startofs = (p->ofs + mask) & ~mask;
if ( startofs < startSearch ) {
startofs = startSearch;
}
endofs = startofs+size;
if (endofs <= (p->ofs+p->size))
break;
}
p = p->next;
}
if (!p)
return NULL;
p = SliceBlock(p,startofs,size,0,mask+1);
p->heap = heap;
return p;
}
static __inline__ int Join2Blocks(TMemBlock *p)
{
if (p->free && p->next && p->next->free) {
TMemBlock *q = p->next;
p->size += q->size;
p->next = q->next;
SD_FREE(q);
return 1;
}
return 0;
}
int mmFreeMem(PMemBlock b)
{
TMemBlock *p,*prev;
if (!b)
return 0;
if (!b->heap) {
fprintf(stderr, "no heap\n");
return -1;
}
p = b->heap;
prev = NULL;
while (p && p != b) {
prev = p;
p = p->next;
}
if (!p || p->free || p->reserved) {
if (!p)
fprintf(stderr, "block not found in heap\n");
else if (p->free)
fprintf(stderr, "block already free\n");
else
fprintf(stderr, "block is reserved\n");
return -1;
}
p->free = 1;
Join2Blocks(p);
if (prev)
Join2Blocks(prev);
return 0;
}
int mmReserveMem(memHeap_t *heap, int offset,int size)
{
int endofs;
TMemBlock *p;
if (!heap || size <= 0)
return -1;
endofs = offset+size;
p = (TMemBlock *)heap;
while (p && p->ofs <= offset) {
if (ISFREE(p) && endofs <= (p->ofs+p->size)) {
SliceBlock(p,offset,size,1,1);
return 0;
}
p = p->next;
}
return -1;
}
int mmFreeReserved(memHeap_t *heap, int offset)
{
TMemBlock *p,*prev;
if (!heap)
return -1;
p = (TMemBlock *)heap;
prev = NULL;
while (p && p->ofs != offset) {
prev = p;
p = p->next;
}
if (!p || !p->reserved)
return -1;
p->free = 1;
p->reserved = 0;
Join2Blocks(p);
if (prev)
Join2Blocks(prev);
return 0;
}
void mmDestroy(memHeap_t *heap)
{
TMemBlock *p,*q;
if (!heap)
return;
p = (TMemBlock *)heap;
while (p) {
q = p->next;
SD_FREE(p);
p = q;
}
}

163
bsd/sis/sis_ds.h
View File

@ -1,163 +0,0 @@
/* sis_ds.h -- Private header for Direct Rendering Manager -*- linux-c -*-
* Created: Mon Jan 4 10:05:05 1999 by sclin@sis.com.tw
*
* Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Authors:
* Sung-Ching Lin <sclin@sis.com.tw>
*
*/
#ifndef _sis_ds_h_
#define _sis_ds_h_
/* Set Data Structure */
#define SET_SIZE 5000
#define SD_MALLOC(s) malloc( s, DRM(M_DRM), M_NOWAIT )
#define SD_FREE(s) free( s, DRM(M_DRM) )
typedef unsigned int ITEM_TYPE;
typedef struct {
ITEM_TYPE val;
int alloc_next, free_next;
} list_item_t;
typedef struct {
int alloc;
int free;
int trace;
list_item_t list[SET_SIZE];
} set_t;
set_t *setInit(void);
int setAdd(set_t *set, ITEM_TYPE item);
int setDel(set_t *set, ITEM_TYPE item);
int setFirst(set_t *set, ITEM_TYPE *item);
int setNext(set_t *set, ITEM_TYPE *item);
int setDestroy(set_t *set);
#endif
/*
* GLX Hardware Device Driver common code
* Copyright (C) 1999 Keith Whitwell
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
#ifndef MM_INC
#define MM_INC
struct mem_block_t {
struct mem_block_t *next;
struct mem_block_t *heap;
int ofs,size;
int align;
int free:1;
int reserved:1;
};
typedef struct mem_block_t TMemBlock;
typedef struct mem_block_t *PMemBlock;
/* a heap is just the first block in a chain */
typedef struct mem_block_t memHeap_t;
static __inline__ int mmBlockSize(PMemBlock b)
{ return b->size; }
static __inline__ int mmOffset(PMemBlock b)
{ return b->ofs; }
static __inline__ void mmMarkReserved(PMemBlock b)
{ b->reserved = 1; }
/*
* input: total size in bytes
* return: a heap pointer if OK, NULL if error
*/
memHeap_t *mmInit( int ofs, int size );
memHeap_t *mmAddRange( memHeap_t *heap,
int ofs,
int size );
/*
* Allocate 'size' bytes with 2^align2 bytes alignment,
* restrict the search to free memory after 'startSearch'
* depth and back buffers should be in different 4mb banks
* to get better page hits if possible
* input: size = size of block
* align2 = 2^align2 bytes alignment
* startSearch = linear offset from start of heap to begin search
* return: pointer to the allocated block, 0 if error
*/
PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch );
/*
* Free block starts at offset
* input: pointer to a block
* return: 0 if OK, -1 if error
*/
int mmFreeMem( PMemBlock b );
/*
* Reserve 'size' bytes block start at offset
* This is used to prevent allocation of memory already used
* by the X server for the front buffer, pixmaps, and cursor
* input: size, offset
* output: 0 if OK, -1 if error
*/
int mmReserveMem( memHeap_t *heap, int offset,int size );
int mmFreeReserved( memHeap_t *heap, int offset );
/*
* destroy MM
*/
void mmDestroy( memHeap_t *mmInit );
/* For debuging purpose. */
void mmDumpMemInfo( memHeap_t *mmInit );
#endif

300
bsd/sis/sis_mm.c
View File

@ -1,300 +0,0 @@
/* sis_mm.c -- Private header for Direct Rendering Manager -*- linux-c -*-
* Created: Mon Jan 4 10:05:05 1999 by sclin@sis.com.tw
*
* Copyright 2000 Silicon Integrated Systems Corp, Inc., HsinChu, Taiwan.
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Authors:
* Sung-Ching Lin <sclin@sis.com.tw>
*
*/
#ifdef __linux
#define __NO_VERSION__
#include <linux/sisfb.h>
#endif
#include "sis.h"
#include "drmP.h"
#include "sis_drm.h"
#include "sis_drv.h"
#include "sis_ds.h"
#define MAX_CONTEXT 100
#define VIDEO_TYPE 0
#define AGP_TYPE 1
typedef struct {
int used;
int context;
set_t *sets[2]; /* 0 for video, 1 for AGP */
} sis_context_t;
static sis_context_t global_ppriv[MAX_CONTEXT];
static int add_alloc_set(int context, int type, unsigned int val)
{
int i, retval = 0;
for(i = 0; i < MAX_CONTEXT; i++)
if(global_ppriv[i].used && global_ppriv[i].context == context){
retval = setAdd(global_ppriv[i].sets[type], val);
break;
}
return retval;
}
static int del_alloc_set(int context, int type, unsigned int val)
{
int i, retval = 0;
for(i = 0; i < MAX_CONTEXT; i++)
if(global_ppriv[i].used && global_ppriv[i].context == context){
retval = setDel(global_ppriv[i].sets[type], val);
break;
}
return retval;
}
/* fb management via fb device */
#if 1
int sis_fb_alloc( DRM_OS_IOCTL )
{
drm_sis_mem_t fb;
struct sis_memreq req;
int retval = 0;
DRM_OS_KRNFROMUSR( fb, (drm_sis_mem_t *) data, sizeof(fb) );
req.size = fb.size;
sis_malloc(&req);
if(req.offset){
/* TODO */
fb.offset = req.offset;
fb.free = req.offset;
if(!add_alloc_set(fb.context, VIDEO_TYPE, fb.free)){
DRM_DEBUG("adding to allocation set fails");
sis_free(req.offset);
retval = -1;
}
}
else{
fb.offset = 0;
fb.size = 0;
fb.free = 0;
}
DRM_OS_KRNTOUSR( (drm_sis_mem_t *) data, fb, sizeof(fb) );
DRM_DEBUG("alloc fb, size = %d, offset = %ld\n", fb.size, req.offset);
return retval;
}
int sis_fb_free( DRM_OS_IOCTL )
{
drm_sis_mem_t fb;
int retval = 0;
DRM_OS_KRNFROMUSR( fb, (drm_sis_mem_t *) data, sizeof(fb) );
if(!fb.free){
return -1;
}
sis_free(fb.free);
if(!del_alloc_set(fb.context, VIDEO_TYPE, fb.free))
retval = -1;
DRM_DEBUG("free fb, offset = %d\n", fb.free);
return retval;
}
#else
int sis_fb_alloc( DRM_OS_IOCTL )
{
return -1;
}
int sis_fb_free( DRM_OS_IOCTL )
{
return 0;
}
#endif
/* agp memory management */
#if 1
static memHeap_t *AgpHeap = NULL;
int sisp_agp_init( DRM_OS_IOCTL )
{
drm_sis_agp_t agp;
DRM_OS_KRNFROMUSR( agp, (drm_sis_agp_t *) data, sizeof(agp) );
AgpHeap = mmInit(agp.offset, agp.size);
DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);
return 0;
}
int sisp_agp_alloc( DRM_OS_IOCTL )
{
drm_sis_mem_t agp;
PMemBlock block;
int retval = 0;
if(!AgpHeap)
return -1;
DRM_OS_KRNFROMUSR( agp, (drm_sis_mem_t *) data, sizeof(agp));
block = mmAllocMem(AgpHeap, agp.size, 0, 0);
if(block){
/* TODO */
agp.offset = block->ofs;
agp.free = (unsigned int)block;
if(!add_alloc_set(agp.context, AGP_TYPE, agp.free)){
DRM_DEBUG("adding to allocation set fails");
mmFreeMem((PMemBlock)agp.free);
retval = -1;
}
}
else{
agp.offset = 0;
agp.size = 0;
agp.free = 0;
}
DRM_OS_KRNTOUSR( (drm_sis_mem_t *) data, agp, sizeof(agp) );
DRM_DEBUG("alloc agp, size = %d, offset = %d\n", agp.size, agp.offset);
return retval;
}
int sisp_agp_free( DRM_OS_IOCTL )
{
drm_sis_mem_t agp;
int retval = 0;
if(!AgpHeap)
return -1;
DRM_OS_KRNFROMUSR( agp, (drm_sis_mem_t *) data, sizeof(agp));
if(!agp.free){
return -1;
}
mmFreeMem((PMemBlock)agp.free);
if(!del_alloc_set(agp.context, AGP_TYPE, agp.free))
retval = -1;
DRM_DEBUG("free agp, free = %d\n", agp.free);
return retval;
}
#endif
int sis_init_context(int context)
{
int i;
for(i = 0; i < MAX_CONTEXT ; i++)
if(global_ppriv[i].used && (global_ppriv[i].context == context))
break;
if(i >= MAX_CONTEXT){
for(i = 0; i < MAX_CONTEXT ; i++){
if(!global_ppriv[i].used){
global_ppriv[i].context = context;
global_ppriv[i].used = 1;
global_ppriv[i].sets[0] = setInit();
global_ppriv[i].sets[1] = setInit();
DRM_DEBUG("init allocation set, socket=%d, context = %d\n",
i, context);
break;
}
}
if((i >= MAX_CONTEXT) || (global_ppriv[i].sets[0] == NULL) ||
(global_ppriv[i].sets[1] == NULL)){
return 0;
}
}
return 1;
}
int sis_final_context(int context)
{
int i;
for(i=0; i<MAX_CONTEXT; i++)
if(global_ppriv[i].used && (global_ppriv[i].context == context))
break;
if(i < MAX_CONTEXT){
set_t *set;
unsigned int item;
int retval;
DRM_DEBUG("find socket %d, context = %d\n", i, context);
/* Video Memory */
set = global_ppriv[i].sets[0];
retval = setFirst(set, &item);
while(retval){
DRM_DEBUG("free video memory 0x%x\n", item);
#if 0
sis_free(item);
#endif
retval = setNext(set, &item);
}
setDestroy(set);
/* AGP Memory */
set = global_ppriv[i].sets[1];
retval = setFirst(set, &item);
while(retval){
DRM_DEBUG("free agp memory 0x%x\n", item);
mmFreeMem((PMemBlock)item);
retval = setNext(set, &item);
}
setDestroy(set);
global_ppriv[i].used = 0;
}
/* turn-off auto-flip */
/* TODO */
#if defined(SIS_STEREO)
flip_final();
#endif
return 1;
}

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

0
bsd/tdfx/tdfx.h → bsd/tdfx.h
View File

20
bsd/tdfx/Makefile
View File

@ -1,9 +1,10 @@
# $FreeBSD$
.PATH: ${.CURDIR}/..
KMOD= tdfx
NOMAN= YES
SRCS= tdfx_drv.c
SRCS+= device_if.h bus_if.h pci_if.h opt_drm_linux.h
SRCS+= device_if.h bus_if.h pci_if.h opt_drm.h
CFLAGS+= ${DEBUG_FLAGS} -I. -I..
@:
@ -12,14 +13,17 @@ CFLAGS+= ${DEBUG_FLAGS} -I. -I..
machine:
ln -sf /sys/i386/include machine
.if ${MACHINE_ARCH} == "i386"
# This line enables linux ioctl handling
# If you want support for this uncomment this line
#TDFX_OPTS= "\#define DRM_LINUX" 1
.if defined(DRM_DEBUG)
DRM_DEBUG_OPT= "\#define DRM_DEBUG 1"
.endif
opt_drm_linux.h:
touch opt_drm_linux.h
echo $(TDFX_OPTS) >> opt_drm_linux.h
.if !defined(DRM_NOLINUX)
DRM_LINUX_OPT= "\#define DRM_LINUX 1"
.endif
opt_drm.h:
touch opt_drm.h
echo $(DRM_DEBUG_OPT) >> opt_drm.h
echo $(DRM_LINUX_OPT) >> opt_drm.h
.include <bsd.kmod.mk>

99
bsd/tdfx_drv.c Normal file
View File

@ -0,0 +1,99 @@
/* tdfx_drv.c -- tdfx driver -*- linux-c -*-
* Created: Thu Oct 7 10:38:32 1999 by faith@precisioninsight.com
*
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Authors:
* Rickard E. (Rik) Faith <faith@valinux.com>
* Daryll Strauss <daryll@valinux.com>
* Gareth Hughes <gareth@valinux.com>
*/
#include <sys/types.h>
#include "tdfx.h"
#include "drmP.h"
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "tdfx"
#define DRIVER_DESC "3dfx Banshee/Voodoo3+"
#define DRIVER_DATE "20010216"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 0
#define DRIVER_PATCHLEVEL 0
#ifndef PCI_VENDOR_ID_3DFX
#define PCI_VENDOR_ID_3DFX 0x121A
#endif
#ifndef PCI_DEVICE_ID_3DFX_VOODOO5
#define PCI_DEVICE_ID_3DFX_VOODOO5 0x0009
#endif
#ifndef PCI_DEVICE_ID_3DFX_VOODOO4
#define PCI_DEVICE_ID_3DFX_VOODOO4 0x0007
#endif
#ifndef PCI_DEVICE_ID_3DFX_VOODOO3_3000 /* Voodoo3 3000 */
#define PCI_DEVICE_ID_3DFX_VOODOO3_3000 0x0005
#endif
#ifndef PCI_DEVICE_ID_3DFX_VOODOO3_2000 /* Voodoo3 3000 */
#define PCI_DEVICE_ID_3DFX_VOODOO3_2000 0x0004
#endif
#ifndef PCI_DEVICE_ID_3DFX_BANSHEE
#define PCI_DEVICE_ID_3DFX_BANSHEE 0x0003
#endif
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
* Please report to anholt@teleport.com inaccuracies or if a chip you have works that is marked unsupported here.
*/
drm_chipinfo_t DRM(devicelist)[] = {
{0x121a, 0x0003, 1, "3dfx Voodoo Banshee"},
{0x121a, 0x0004, 1, "3dfx Voodoo3 2000"},
{0x121a, 0x0005, 1, "3dfx Voodoo3 3000"},
{0x121a, 0x0007, 1, "3dfx Voodoo4"},
{0x121a, 0x0009, 1, "3dfx Voodoo5"},
{0, 0, 0, NULL}
};
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_vm.h"
#include "drm_sysctl.h"
#ifdef __FreeBSD__
DRIVER_MODULE(tdfx, pci, tdfx_driver, tdfx_devclass, 0, 0);
#endif /* __FreeBSD__ */

9
libdrm/xf86drm.c
View File

@ -1381,7 +1381,8 @@ int drmCommandRead(int fd, unsigned long drmCommandIndex,
{
unsigned long request;
request = DRM_IOR( DRM_COMMAND_BASE + drmCommandIndex, size);
request = DRM_IOC( DRM_IOC_READ, DRM_IOCTL_BASE,
DRM_COMMAND_BASE + drmCommandIndex, size);
if (ioctl(fd, request, data)) {
return -errno;
@ -1394,7 +1395,8 @@ int drmCommandWrite(int fd, unsigned long drmCommandIndex,
{
unsigned long request;
request = DRM_IOW( DRM_COMMAND_BASE + drmCommandIndex, size);
request = DRM_IOC( DRM_IOC_WRITE, DRM_IOCTL_BASE,
DRM_COMMAND_BASE + drmCommandIndex, size);
if (ioctl(fd, request, data)) {
return -errno;
@ -1407,7 +1409,8 @@ int drmCommandWriteRead(int fd, unsigned long drmCommandIndex,
{
unsigned long request;
request = DRM_IOWR( DRM_COMMAND_BASE + drmCommandIndex, size);
request = DRM_IOC( DRM_IOC_READ|DRM_IOC_WRITE, DRM_IOCTL_BASE,
DRM_COMMAND_BASE + drmCommandIndex, size);
if (ioctl(fd, request, data)) {
return -errno;

4
linux-core/drmP.h
View File

@ -71,6 +71,8 @@
#include <asm/pgalloc.h>
#include "drm.h"
#include "drm_os_linux.h"
/* DRM template customization defaults
*/
#ifndef __HAVE_AGP
@ -101,7 +103,7 @@
#define __REALLY_HAVE_AGP (__HAVE_AGP && (defined(CONFIG_AGP) || \
defined(CONFIG_AGP_MODULE)))
#define __REALLY_HAVE_MTRR (__HAVE_MTRR && defined(CONFIG_MTRR))
#define __REALLY_HAVE_SG (__HAVE_SG)
/* Begin the DRM...
*/

16
linux-core/drm_drv.c
View File

@ -127,6 +127,22 @@ static struct file_operations DRM(fops) = { \
}
#endif
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* Use an additional macro to avoid preprocessor troubles */
#define DRM_OPTIONS_FUNC DRM(options)
static int __init DRM(options)( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", DRM_OPTIONS_FUNC );
#undef DRM_OPTIONS_FUNC
#endif
/*
* The default number of instances (minor numbers) to initialize.

56
linux-core/drm_os_linux.h Normal file
View File

@ -0,0 +1,56 @@
#define __NO_VERSION__
#include <linux/interrupt.h> /* For task queue support */
#include <linux/delay.h>
#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_COPY_FROM_USER_IOCTL(arg1, arg2, arg3) \
if ( copy_from_user(&arg1, arg2, arg3) ) \
return -EFAULT
#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_COPY_FROM_USER(arg1, arg2, arg3) \
copy_from_user(arg1, arg2, arg3)
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
copy_to_user(arg1, arg2, arg3)
/* Macros for copyfrom user, but checking readability only once */
#define DRM_VERIFYAREA_READ( uaddr, size ) \
verify_area( VERIFY_READ, uaddr, size )
#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
__copy_from_user(arg1, arg2, arg3)
#define DRM_GET_USER_UNCHECKED(val, uaddr) \
__get_user(val, uaddr)
/* malloc/free without the overhead of DRM(alloc) */
#define DRM_MALLOC(x) kmalloc(x, GFP_KERNEL)
#define DRM_FREE(x) kfree(x)
#define DRM_GETSAREA() \
do { \
struct list_head *list; \
list_for_each( list, &dev->maplist->head ) { \
drm_map_list_t *entry = (drm_map_list_t *)list; \
if ( entry->map && \
entry->map->type == _DRM_SHM && \
(entry->map->flags & _DRM_CONTAINS_LOCK) ) { \
dev_priv->sarea = entry->map; \
break; \
} \
} \
} while (0)

61
linux-core/i810_drv.c
View File

@ -37,48 +37,6 @@
#include "i810_drm.h"
#include "i810_drv.h"
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "i810"
#define DRIVER_DESC "Intel i810"
#define DRIVER_DATE "20020211"
/* Interface history
*
* 1.1 - XFree86 4.1
* 1.2 - XvMC interfaces
* - XFree86 4.2
* 1.2.1 - Disable copying code (leave stub ioctls for backwards compatibility)
* - Remove requirement for interrupt (leave stubs again)
*/
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 2
#define DRIVER_PATCHLEVEL 1
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_I810_INIT)] = { i810_dma_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_VERTEX)] = { i810_dma_vertex, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_CLEAR)] = { i810_clear_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_FLUSH)] = { i810_flush_ioctl, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_GETAGE)] = { i810_getage, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_GETBUF)] = { i810_getbuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_SWAP)] = { i810_swap_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_COPY)] = { i810_copybuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_DOCOPY)] = { i810_docopy, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_OV0INFO)] = { i810_ov0_info, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_FSTATUS)] = { i810_fstatus, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_OV0FLIP)] = { i810_ov0_flip, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_MC)] = { i810_dma_mc, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_RSTATUS)] = { i810_rstatus, 1, 0 }
#define __HAVE_COUNTERS 4
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#define __HAVE_COUNTER9 _DRM_STAT_DMA
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
@ -87,25 +45,6 @@
#include "drm_drawable.h"
#include "drm_drv.h"
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* JH- We have to hand expand the string ourselves because of the cpp. If
* anyone can think of a way that we can fit into the __setup macro without
* changing it, then please send the solution my way.
*/
static int __init i810_options( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", i810_options );
#endif
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"

47
linux-core/i830_drv.c
View File

@ -38,34 +38,6 @@
#include "i830_drm.h"
#include "i830_drv.h"
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "i830"
#define DRIVER_DESC "Intel 830M"
#define DRIVER_DATE "20011004"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 2
#define DRIVER_PATCHLEVEL 0
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_I830_INIT)] = { i830_dma_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_VERTEX)] = { i830_dma_vertex, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_CLEAR)] = { i830_clear_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_FLUSH)] = { i830_flush_ioctl, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_GETAGE)] = { i830_getage, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_GETBUF)] = { i830_getbuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_SWAP)] = { i830_swap_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_COPY)] = { i830_copybuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_DOCOPY)] = { i830_docopy, 1, 0 },
#define __HAVE_COUNTERS 4
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#define __HAVE_COUNTER9 _DRM_STAT_DMA
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
@ -74,25 +46,6 @@
#include "drm_drawable.h"
#include "drm_drv.h"
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* JH- We have to hand expand the string ourselves because of the cpp. If
* anyone can think of a way that we can fit into the __setup macro without
* changing it, then please send the solution my way.
*/
static int __init i830_options( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", i830_options );
#endif
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"

51
linux-core/mga_drv.c
View File

@ -35,36 +35,6 @@
#include "drm.h"
#include "mga_drm.h"
#include "mga_drv.h"
#define DRIVER_AUTHOR "Gareth Hughes, VA Linux Systems Inc."
#define DRIVER_NAME "mga"
#define DRIVER_DESC "Matrox G200/G400"
#define DRIVER_DATE "20010321"
#define DRIVER_MAJOR 3
#define DRIVER_MINOR 0
#define DRIVER_PATCHLEVEL 2
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = { mga_dma_buffers, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_MGA_INIT)] = { mga_dma_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_MGA_FLUSH)] = { mga_dma_flush, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_MGA_RESET)] = { mga_dma_reset, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_MGA_SWAP)] = { mga_dma_swap, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_MGA_CLEAR)] = { mga_dma_clear, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_MGA_VERTEX)] = { mga_dma_vertex, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_MGA_INDICES)] = { mga_dma_indices, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_MGA_ILOAD)] = { mga_dma_iload, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_MGA_BLIT)] = { mga_dma_blit, 1, 0 },
#define __HAVE_COUNTERS 3
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
@ -72,27 +42,6 @@
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* JH- We have to hand expand the string ourselves because of the cpp. If
* anyone can think of a way that we can fit into the __setup macro without
* changing it, then please send the solution my way.
*/
static int __init mga_options( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", mga_options );
#endif
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"

59
linux-core/r128_drv.c
View File

@ -37,45 +37,6 @@
#include "r128_drv.h"
#include "ati_pcigart.h"
#define DRIVER_AUTHOR "Gareth Hughes, VA Linux Systems Inc."
#define DRIVER_NAME "r128"
#define DRIVER_DESC "ATI Rage 128"
#define DRIVER_DATE "20010917"
#define DRIVER_MAJOR 2
#define DRIVER_MINOR 2
#define DRIVER_PATCHLEVEL 0
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = { r128_cce_buffers, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_INIT)] = { r128_cce_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_CCE_START)] = { r128_cce_start, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_CCE_STOP)] = { r128_cce_stop, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_CCE_RESET)] = { r128_cce_reset, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_CCE_IDLE)] = { r128_cce_idle, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_RESET)] = { r128_engine_reset, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_FULLSCREEN)] = { r128_fullscreen, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_SWAP)] = { r128_cce_swap, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_CLEAR)] = { r128_cce_clear, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_VERTEX)] = { r128_cce_vertex, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_INDICES)] = { r128_cce_indices, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_BLIT)] = { r128_cce_blit, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_DEPTH)] = { r128_cce_depth, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_STIPPLE)] = { r128_cce_stipple, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_R128_INDIRECT)] = { r128_cce_indirect, 1, 1 },
#if 0
/* GH: Count data sent to card via ring or vertex/indirect buffers.
*/
#define __HAVE_COUNTERS 3
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#endif
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
@ -83,26 +44,6 @@
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* JH- We have to hand expand the string ourselves because of the cpp. If
* anyone can think of a way that we can fit into the __setup macro without
* changing it, then please send the solution my way.
*/
static int __init r128_options( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", r128_options );
#endif
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"

63
linux-core/radeon_drv.c
View File

@ -35,49 +35,6 @@
#include "radeon_drv.h"
#include "ati_pcigart.h"
#define DRIVER_AUTHOR "Gareth Hughes, VA Linux Systems Inc."
#define DRIVER_NAME "radeon"
#define DRIVER_DESC "ATI Radeon"
#define DRIVER_DATE "20020611"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 3
#define DRIVER_PATCHLEVEL 1
/* Interface history:
*
* 1.1 - ??
* 1.2 - Add vertex2 ioctl (keith)
* - Add stencil capability to clear ioctl (gareth, keith)
* - Increase MAX_TEXTURE_LEVELS (brian)
* 1.3 - Add cmdbuf ioctl (keith)
* - Add support for new radeon packets (keith)
* - Add getparam ioctl (keith)
* - Add flip-buffers ioctl, deprecate fullscreen foo (keith).
*/
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = { radeon_cp_buffers, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CP_INIT)] = { radeon_cp_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CP_START)] = { radeon_cp_start, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CP_STOP)] = { radeon_cp_stop, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CP_RESET)] = { radeon_cp_reset, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CP_IDLE)] = { radeon_cp_idle, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_RESET)] = { radeon_engine_reset, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_FULLSCREEN)] = { radeon_fullscreen, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_SWAP)] = { radeon_cp_swap, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CLEAR)] = { radeon_cp_clear, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_VERTEX)] = { radeon_cp_vertex, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_INDICES)] = { radeon_cp_indices, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_TEXTURE)] = { radeon_cp_texture, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_STIPPLE)] = { radeon_cp_stipple, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_INDIRECT)] = { radeon_cp_indirect, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_VERTEX2)] = { radeon_cp_vertex2, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CMDBUF)] = { radeon_cp_cmdbuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_GETPARAM)] = { radeon_cp_getparam, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_FLIP)] = { radeon_cp_flip, 1, 0 },
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
@ -85,26 +42,6 @@
#include "drm_dma.h"
#include "drm_drawable.h"
#include "drm_drv.h"
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* JH- We have to hand expand the string ourselves because of the cpp. If
* anyone can think of a way that we can fit into the __setup macro without
* changing it, then please send the solution my way.
*/
static int __init radeon_options( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", radeon_options );
#endif
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"

25
linux-core/sis_drv.c
View File

@ -31,31 +31,6 @@
#include "sis_drm.h"
#include "sis_drv.h"
#define DRIVER_AUTHOR "SIS"
#define DRIVER_NAME "sis"
#define DRIVER_DESC "SIS 300/630/540"
#define DRIVER_DATE "20010503"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 0
#define DRIVER_PATCHLEVEL 0
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(SIS_IOCTL_FB_ALLOC)] = { sis_fb_alloc, 1, 0 }, \
[DRM_IOCTL_NR(SIS_IOCTL_FB_FREE)] = { sis_fb_free, 1, 0 }, \
/* AGP Memory Management */ \
[DRM_IOCTL_NR(SIS_IOCTL_AGP_INIT)] = { sisp_agp_init, 1, 0 }, \
[DRM_IOCTL_NR(SIS_IOCTL_AGP_ALLOC)] = { sisp_agp_alloc, 1, 0 }, \
[DRM_IOCTL_NR(SIS_IOCTL_AGP_FREE)] = { sisp_agp_free, 1, 0 }
#if 0 /* these don't appear to be defined */
/* SIS Stereo */
[DRM_IOCTL_NR(DRM_IOCTL_CONTROL)] = { sis_control, 1, 1 },
[DRM_IOCTL_NR(SIS_IOCTL_FLIP)] = { sis_flip, 1, 1 },
[DRM_IOCTL_NR(SIS_IOCTL_FLIP_INIT)] = { sis_flip_init, 1, 1 },
[DRM_IOCTL_NR(SIS_IOCTL_FLIP_FINAL)] = { sis_flip_final, 1, 1 }
#endif
#define __HAVE_COUNTERS 5
#include "drm_auth.h"
#include "drm_agpsupport.h"
#include "drm_bufs.h"

19
linux-core/tdfx_drv.c
View File

@ -82,25 +82,6 @@ static drm_pci_list_t DRM(idlist)[] = {
#include "drm_drawable.h"
#include "drm_drv.h"
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* JH- We have to hand expand the string ourselves because of the cpp. If
* anyone can think of a way that we can fit into the __setup macro without
* changing it, then please send the solution my way.
*/
static int __init tdfx_options( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", tdfx_options );
#endif
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"

30
linux/drm.h
View File

@ -38,10 +38,27 @@
#if defined(__linux__)
#include <linux/config.h>
#include <asm/ioctl.h> /* For _IO* macros */
#define DRM_IOCTL_NR(n) _IOC_NR(n)
#elif defined(__FreeBSD__)
#define DRM_IOCTL_NR(n) _IOC_NR(n)
#define DRM_IOC_VOID _IOC_NONE
#define DRM_IOC_READ _IOC_READ
#define DRM_IOC_WRITE _IOC_WRITE
#define DRM_IOC_READWRITE _IOC_READ|_IOC_WRITE
#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
#elif defined(__FreeBSD__) || defined(__NetBSD__)
#if defined(__FreeBSD__) && defined(XFree86Server)
/* Prevent name collision when including sys/ioccom.h */
#undef ioctl
#include <sys/ioccom.h>
#define DRM_IOCTL_NR(n) ((n) & 0xff)
#define ioctl(a,b,c) xf86ioctl(a,b,c)
#else
#include <sys/ioccom.h>
#endif /* __FreeBSD__ && xf86ioctl */
#define DRM_IOCTL_NR(n) ((n) & 0xff)
#define DRM_IOC_VOID IOC_VOID
#define DRM_IOC_READ IOC_OUT
#define DRM_IOC_WRITE IOC_IN
#define DRM_IOC_READWRITE IOC_INOUT
#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
#endif
#define XFREE86_VERSION(major,minor,patch,snap) \
@ -367,10 +384,9 @@ typedef struct drm_scatter_gather {
#define DRM_IOCTL_BASE 'd'
#define DRM_IO(nr) _IO(DRM_IOCTL_BASE,nr)
#define DRM_IOR(nr,size) _IOR(DRM_IOCTL_BASE,nr,size)
#define DRM_IOW(nr,size) _IOW(DRM_IOCTL_BASE,nr,size)
#define DRM_IOWR(nr,size) _IOWR(DRM_IOCTL_BASE,nr,size)
#define DRM_IOR(nr,type) _IOR(DRM_IOCTL_BASE,nr,type)
#define DRM_IOW(nr,type) _IOW(DRM_IOCTL_BASE,nr,type)
#define DRM_IOWR(nr,type) _IOWR(DRM_IOCTL_BASE,nr,type)
#define DRM_IOCTL_VERSION DRM_IOWR(0x00, drm_version_t)
#define DRM_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm_unique_t)

4
linux/drmP.h
View File

@ -71,6 +71,8 @@
#include <asm/pgalloc.h>
#include "drm.h"
#include "drm_os_linux.h"
/* DRM template customization defaults
*/
#ifndef __HAVE_AGP
@ -101,7 +103,7 @@
#define __REALLY_HAVE_AGP (__HAVE_AGP && (defined(CONFIG_AGP) || \
defined(CONFIG_AGP_MODULE)))
#define __REALLY_HAVE_MTRR (__HAVE_MTRR && defined(CONFIG_MTRR))
#define __REALLY_HAVE_SG (__HAVE_SG)
/* Begin the DRM...
*/

16
linux/drm_drv.h
View File

@ -127,6 +127,22 @@ static struct file_operations DRM(fops) = { \
}
#endif
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* Use an additional macro to avoid preprocessor troubles */
#define DRM_OPTIONS_FUNC DRM(options)
static int __init DRM(options)( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", DRM_OPTIONS_FUNC );
#undef DRM_OPTIONS_FUNC
#endif
/*
* The default number of instances (minor numbers) to initialize.

56
linux/drm_os_linux.h Normal file
View File

@ -0,0 +1,56 @@
#define __NO_VERSION__
#include <linux/interrupt.h> /* For task queue support */
#include <linux/delay.h>
#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_COPY_FROM_USER_IOCTL(arg1, arg2, arg3) \
if ( copy_from_user(&arg1, arg2, arg3) ) \
return -EFAULT
#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_COPY_FROM_USER(arg1, arg2, arg3) \
copy_from_user(arg1, arg2, arg3)
#define DRM_COPY_TO_USER(arg1, arg2, arg3) \
copy_to_user(arg1, arg2, arg3)
/* Macros for copyfrom user, but checking readability only once */
#define DRM_VERIFYAREA_READ( uaddr, size ) \
verify_area( VERIFY_READ, uaddr, size )
#define DRM_COPY_FROM_USER_UNCHECKED(arg1, arg2, arg3) \
__copy_from_user(arg1, arg2, arg3)
#define DRM_GET_USER_UNCHECKED(val, uaddr) \
__get_user(val, uaddr)
/* malloc/free without the overhead of DRM(alloc) */
#define DRM_MALLOC(x) kmalloc(x, GFP_KERNEL)
#define DRM_FREE(x) kfree(x)
#define DRM_GETSAREA() \
do { \
struct list_head *list; \
list_for_each( list, &dev->maplist->head ) { \
drm_map_list_t *entry = (drm_map_list_t *)list; \
if ( entry->map && \
entry->map->type == _DRM_SHM && \
(entry->map->flags & _DRM_CONTAINS_LOCK) ) { \
dev_priv->sarea = entry->map; \
break; \
} \
} \
} while (0)

25
linux/gamma.h
View File

@ -38,6 +38,31 @@
*/
#define __HAVE_MTRR 1
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "gamma"
#define DRIVER_DESC "3DLabs gamma"
#define DRIVER_DATE "20010624"
#define DRIVER_MAJOR 2
#define DRIVER_MINOR 0
#define DRIVER_PATCHLEVEL 0
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = { gamma_dma, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_GAMMA_INIT)] = { gamma_dma_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_GAMMA_COPY)] = { gamma_dma_copy, 1, 1 }
#define IOCTL_TABLE_NAME DRM(ioctls)
#define IOCTL_FUNC_NAME DRM(ioctl)
#define __HAVE_COUNTERS 5
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_DMA
#define __HAVE_COUNTER8 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER9 _DRM_STAT_SPECIAL
#define __HAVE_COUNTER10 _DRM_STAT_MISSED
/* DMA customization:
*/
#define __HAVE_DMA 1

45
linux/gamma_drv.c
View File

@ -36,32 +36,6 @@
#include "gamma_drm.h"
#include "gamma_drv.h"
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "gamma"
#define DRIVER_DESC "3DLabs gamma"
#define DRIVER_DATE "20010624"
#define DRIVER_MAJOR 2
#define DRIVER_MINOR 0
#define DRIVER_PATCHLEVEL 0
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = { gamma_dma, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_GAMMA_INIT)] = { gamma_dma_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_GAMMA_COPY)] = { gamma_dma_copy, 1, 1 }
#define IOCTL_TABLE_NAME DRM(ioctls)
#define IOCTL_FUNC_NAME DRM(ioctl)
#define __HAVE_COUNTERS 5
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_DMA
#define __HAVE_COUNTER8 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER9 _DRM_STAT_SPECIAL
#define __HAVE_COUNTER10 _DRM_STAT_MISSED
#include "drm_auth.h"
#include "drm_agpsupport.h"
#include "drm_bufs.h"
@ -70,25 +44,6 @@
#include "drm_drawable.h"
#include "drm_drv.h"
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* JH- We have to hand expand the string ourselves because of the cpp. If
* anyone can think of a way that we can fit into the __setup macro without
* changing it, then please send the solution my way.
*/
static int __init gamma_options( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", gamma_options );
#endif
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"

41
linux/i810.h
View File

@ -41,6 +41,47 @@
#define __HAVE_MTRR 1
#define __HAVE_CTX_BITMAP 1
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "i810"
#define DRIVER_DESC "Intel i810"
#define DRIVER_DATE "20020211"
/* Interface history
*
* 1.1 - XFree86 4.1
* 1.2 - XvMC interfaces
* - XFree86 4.2
* 1.2.1 - Disable copying code (leave stub ioctls for backwards compatibility)
* - Remove requirement for interrupt (leave stubs again)
*/
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 2
#define DRIVER_PATCHLEVEL 1
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_I810_INIT)] = { i810_dma_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_VERTEX)] = { i810_dma_vertex, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_CLEAR)] = { i810_clear_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_FLUSH)] = { i810_flush_ioctl, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_GETAGE)] = { i810_getage, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_GETBUF)] = { i810_getbuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_SWAP)] = { i810_swap_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_COPY)] = { i810_copybuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_DOCOPY)] = { i810_docopy, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_OV0INFO)] = { i810_ov0_info, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_FSTATUS)] = { i810_fstatus, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_OV0FLIP)] = { i810_ov0_flip, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_MC)] = { i810_dma_mc, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_RSTATUS)] = { i810_rstatus, 1, 0 }
#define __HAVE_COUNTERS 4
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#define __HAVE_COUNTER9 _DRM_STAT_DMA
/* Driver customization:
*/
#define __HAVE_RELEASE 1

61
linux/i810_drv.c
View File

@ -37,48 +37,6 @@
#include "i810_drm.h"
#include "i810_drv.h"
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "i810"
#define DRIVER_DESC "Intel i810"
#define DRIVER_DATE "20020211"
/* Interface history
*
* 1.1 - XFree86 4.1
* 1.2 - XvMC interfaces
* - XFree86 4.2
* 1.2.1 - Disable copying code (leave stub ioctls for backwards compatibility)
* - Remove requirement for interrupt (leave stubs again)
*/
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 2
#define DRIVER_PATCHLEVEL 1
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_I810_INIT)] = { i810_dma_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_VERTEX)] = { i810_dma_vertex, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_CLEAR)] = { i810_clear_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_FLUSH)] = { i810_flush_ioctl, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_GETAGE)] = { i810_getage, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_GETBUF)] = { i810_getbuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_SWAP)] = { i810_swap_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_COPY)] = { i810_copybuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_DOCOPY)] = { i810_docopy, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_OV0INFO)] = { i810_ov0_info, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_FSTATUS)] = { i810_fstatus, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_OV0FLIP)] = { i810_ov0_flip, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_MC)] = { i810_dma_mc, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I810_RSTATUS)] = { i810_rstatus, 1, 0 }
#define __HAVE_COUNTERS 4
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#define __HAVE_COUNTER9 _DRM_STAT_DMA
#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
@ -87,25 +45,6 @@
#include "drm_drawable.h"
#include "drm_drv.h"
#ifndef MODULE
/* DRM(options) is called by the kernel to parse command-line options
* passed via the boot-loader (e.g., LILO). It calls the insmod option
* routine, drm_parse_drm.
*/
/* JH- We have to hand expand the string ourselves because of the cpp. If
* anyone can think of a way that we can fit into the __setup macro without
* changing it, then please send the solution my way.
*/
static int __init i810_options( char *str )
{
DRM(parse_options)( str );
return 1;
}
__setup( DRIVER_NAME "=", i810_options );
#endif
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"

27
linux/i830.h
View File

@ -41,6 +41,33 @@
#define __HAVE_MTRR 1
#define __HAVE_CTX_BITMAP 1
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "i830"
#define DRIVER_DESC "Intel 830M"
#define DRIVER_DATE "20011004"
#define DRIVER_MAJOR 1
#define DRIVER_MINOR 2
#define DRIVER_PATCHLEVEL 0
#define DRIVER_IOCTLS \
[DRM_IOCTL_NR(DRM_IOCTL_I830_INIT)] = { i830_dma_init, 1, 1 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_VERTEX)] = { i830_dma_vertex, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_CLEAR)] = { i830_clear_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_FLUSH)] = { i830_flush_ioctl, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_GETAGE)] = { i830_getage, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_GETBUF)] = { i830_getbuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_SWAP)] = { i830_swap_bufs, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_COPY)] = { i830_copybuf, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_I830_DOCOPY)] = { i830_docopy, 1, 0 },
#define __HAVE_COUNTERS 4
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#define __HAVE_COUNTER9 _DRM_STAT_DMA
/* Driver customization:
*/
#define __HAVE_RELEASE 1

Some files were not shown because too many files have changed in this diff Show More