MACHINE := $(shell uname -m)
# Modules for all architectures
-MODULE_LIST := gamma.o tdfx.o r128.o radeon.o mga.o sis.o savage.o via.o mach64.o
+MODULE_LIST := tdfx.o r128.o radeon.o mga.o sis.o savage.o via.o mach64.o
# Modules only for ix86 architectures
ifneq (,$(findstring 86,$(MACHINE)))
/** \name DRM template customization defaults */
/*@{*/
-#ifndef __HAVE_AGP
-#define __HAVE_AGP 0
-#endif
-#ifndef __HAVE_MTRR
-#define __HAVE_MTRR 0
-#endif
-#ifndef __HAVE_CTX_BITMAP
-#define __HAVE_CTX_BITMAP 0
-#endif
-#ifndef __HAVE_DMA
-#define __HAVE_DMA 0
-#endif
-#ifndef __HAVE_IRQ
-#define __HAVE_IRQ 0
-#endif
-
-#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)
-
+/* driver capabilities and requirements mask */
+#define DRIVER_USE_AGP 0x1
+#define DRIVER_REQUIRE_AGP 0x2
+#define DRIVER_USE_MTRR 0x4
+#define DRIVER_HAVE_DMA 0x10
+#define DRIVER_HAVE_IRQ 0x20
+#define DRIVER_SG 0x40
+#define DRIVER_PCI_DMA 0x80
+#define DRIVER_IRQ_SHARED 0x100
+#define DRIVER_IRQ_VBL 0x200
+#define DRIVER_DMA_QUEUE 0x800
+
+#define __OS_HAS_AGP (defined(CONFIG_AGP) || defined(CONFIG_AGP_MODULE))
+#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
/*@}*/
struct drm_device *dev;
int remove_auth_on_close;
unsigned long lock_count;
-#ifdef DRIVER_FILE_FIELDS
- DRIVER_FILE_FIELDS;
-#endif
+ void *driver_priv;
} drm_file_t;
/** Wait queue */
/*@}*/
} drm_device_dma_t;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
/**
* AGP memory entry. Stored as a doubly linked list.
*/
drm_file_t *tag; /**< associated fd private data */
} drm_ctx_list_t;
-#ifdef __HAVE_VBL_IRQ
typedef struct drm_vbl_sig {
struct list_head head;
struct task_struct *task;
} drm_vbl_sig_t;
-#endif
/**
* DRM device functions structure
int (*postcleanup)(struct drm_device *);
int (*presetup)(struct drm_device *);
int (*postsetup)(struct drm_device *);
- void (*open_helper)(struct drm_device *, drm_file_t *);
+
+ /* these are opposites at the moment */
+ int (*open_helper)(struct drm_device *, drm_file_t *);
+ void (*free_filp_private)(struct drm_device *, drm_file_t *);
+
void (*release)(struct drm_device *, struct file *filp);
void (*dma_ready)(struct drm_device *);
int (*dma_quiescent)(struct drm_device *);
int (*waitlist_destroy)(drm_waitlist_t *bl);
int (*freelist_create)(drm_freelist_t *bl, int count);
int (*freelist_put)(struct drm_device *dev, drm_freelist_t *bl, drm_buf_t *buf);
- int (*freelist_destroy)(drm_freelist_t *bl);
+ int (*freelist_destroy)(drm_freelist_t *bl);
+ int (*vblank_wait)(struct drm_device *dev, unsigned int *sequence);
+/* these have to be filled in */
+ irqreturn_t (*irq_handler)( DRM_IRQ_ARGS );
+ void (*irq_preinstall)(struct drm_device *dev);
+ void (*irq_postinstall)(struct drm_device *dev);
+ void (*irq_uninstall)(struct drm_device *dev);
+ void (*reclaim_buffers)(struct file *filp);
+ unsigned long (*get_map_ofs)(drm_map_t *map);
+ unsigned long (*get_reg_ofs)(struct drm_device *dev);
+ void (*set_version)(struct drm_device *dev, drm_set_version_t *sv);
};
/**
#endif
/** \name VBLANK IRQ support */
/*@{*/
-#ifdef __HAVE_VBL_IRQ
+
wait_queue_head_t vbl_queue; /**< VBLANK wait queue */
atomic_t vbl_received;
spinlock_t vbl_lock;
drm_vbl_sig_t vbl_sigs; /**< signal list to send on VBLANK */
unsigned int vbl_pending;
-#endif
+
/*@}*/
cycles_t ctx_start;
cycles_t lck_start;
wait_queue_head_t buf_readers; /**< Processes waiting to read */
wait_queue_head_t buf_writers; /**< Processes waiting to ctx switch */
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
drm_agp_head_t *agp; /**< AGP data */
#endif
struct drm_driver_fn fn_tbl;
drm_local_map_t *agp_buffer_map;
int dev_priv_size;
+ u32 driver_features;
} drm_device_t;
extern void DRM(driver_register_fns)(struct drm_device *dev);
drm_device_t *dev);
extern void DRM(ioremapfree)(void *pt, unsigned long size, drm_device_t *dev);
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
extern DRM_AGP_MEM *DRM(alloc_agp)(int pages, u32 type);
extern int DRM(free_agp)(DRM_AGP_MEM *handle, int pages);
extern int DRM(bind_agp)(DRM_AGP_MEM *handle, unsigned int start);
extern int DRM(context_switch)(drm_device_t *dev, int old, int new);
extern int DRM(context_switch_complete)(drm_device_t *dev, int new);
-#if __HAVE_CTX_BITMAP
extern int DRM(ctxbitmap_init)( drm_device_t *dev );
extern void DRM(ctxbitmap_cleanup)( drm_device_t *dev );
-#endif
extern int DRM(setsareactx)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg );
unsigned int cmd, unsigned long arg );
extern int DRM(initmap)( drm_device_t *dev, unsigned int offset,
unsigned int size, int type, int flags );
-#if __HAVE_DMA
extern int DRM(addbufs)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg );
extern int DRM(infobufs)( struct inode *inode, struct file *filp,
extern void DRM(dma_takedown)(drm_device_t *dev);
extern void DRM(free_buffer)(drm_device_t *dev, drm_buf_t *buf);
extern void DRM(reclaim_buffers)( struct file *filp );
-#endif /* __HAVE_DMA */
/* IRQ support (drm_irq.h) */
-#if __HAVE_IRQ || __HAVE_DMA
extern int DRM(control)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg );
-#endif
-#if __HAVE_IRQ
extern int DRM(irq_install)( drm_device_t *dev );
extern int DRM(irq_uninstall)( drm_device_t *dev );
extern irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS );
extern void DRM(driver_irq_preinstall)( drm_device_t *dev );
extern void DRM(driver_irq_postinstall)( drm_device_t *dev );
extern void DRM(driver_irq_uninstall)( drm_device_t *dev );
-#ifdef __HAVE_VBL_IRQ
+
extern int DRM(wait_vblank)(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
extern int DRM(vblank_wait)(drm_device_t *dev, unsigned int *vbl_seq);
extern void DRM(vbl_send_signals)( drm_device_t *dev );
-#endif
-#ifdef __HAVE_IRQ_BH
-extern void DRM(irq_immediate_bh)( void *dev );
-#endif
-#endif
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
/* AGP/GART support (drm_agpsupport.h) */
extern drm_agp_head_t *DRM(agp_init)(void);
extern void DRM(agp_uninit)(void);
struct proc_dir_entry *root,
struct proc_dir_entry *dev_root);
-#ifdef __HAVE_SG
/* Scatter Gather Support (drm_scatter.h) */
extern void DRM(sg_cleanup)(drm_sg_mem_t *entry);
extern int DRM(sg_alloc)(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
extern int DRM(sg_free)(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
-#endif
/* ATI PCIGART support (ati_pcigart.h) */
extern int DRM(ati_pcigart_init)(drm_device_t *dev,
}
/*@}*/
+extern unsigned long DRM(core_get_map_ofs)(drm_map_t *map);
+extern unsigned long DRM(core_get_reg_ofs)(struct drm_device *dev);
#endif /* __KERNEL__ */
#endif
#include "drmP.h"
#include <linux/module.h>
-#if __REALLY_HAVE_AGP
-
+#if __OS_HAS_AGP
#define DRM_AGP_GET (drm_agp_t *)inter_module_get("drm_agp")
#define DRM_AGP_PUT inter_module_put("drm_agp")
return drm_agp->unbind_memory(handle);
}
-#endif /* __REALLY_HAVE_AGP */
+#endif /* __OS_HAS_AGP */
#include <linux/vmalloc.h>
#include "drmP.h"
-#ifndef __HAVE_PCI_DMA
-#define __HAVE_PCI_DMA 0
-#endif
-
-#ifndef __HAVE_SG
-#define __HAVE_SG 0
-#endif
-
/**
* Compute size order. Returns the exponent of the smaller power of two which
* is greater or equal to given number.
#ifdef __alpha__
map->offset += dev->hose->mem_space->start;
#endif
-#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 );
+#if __OS_HAS_MTRR
+ if ( dev->driver_features & DRIVER_USE_MTRR) {
+ if ( map->type == _DRM_FRAME_BUFFER ||
+ (map->flags & _DRM_WRITE_COMBINING) ) {
+ map->mtrr = mtrr_add( map->offset, map->size,
+ MTRR_TYPE_WRCOMB, 1 );
+ }
}
#endif
if (map->type == _DRM_REGISTERS)
return 0;
}
-
/**
* Ioctl to specify a range of memory that is available for mapping by a non-root process.
*
#ifdef __alpha__
map->offset += dev->hose->mem_space->start;
#endif
-#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 );
+#if __OS_HAS_MTRR
+ if (dev->driver_features & DRIVER_USE_MTRR) {
+ if ( map->type == _DRM_FRAME_BUFFER ||
+ (map->flags & _DRM_WRITE_COMBINING) ) {
+ map->mtrr = mtrr_add( map->offset, map->size,
+ MTRR_TYPE_WRCOMB, 1 );
+ }
}
#endif
if (map->type == _DRM_REGISTERS)
dev->lock.hw_lock = map->handle; /* Pointer to lock */
}
break;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
case _DRM_AGP:
+ if (dev->driver_features & DRIVER_USE_AGP) {
#ifdef __alpha__
- map->offset += dev->hose->mem_space->start;
+ map->offset += dev->hose->mem_space->start;
#endif
- map->offset += dev->agp->base;
- map->mtrr = dev->agp->agp_mtrr; /* for getmap */
+ map->offset += dev->agp->base;
+ map->mtrr = dev->agp->agp_mtrr; /* for getmap */
+ }
break;
#endif
case _DRM_SCATTER_GATHER:
return 0;
}
-#if __HAVE_DMA
-
/**
* Cleanup after an error on one of the addbufs() functions.
*
}
}
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
/**
* Add AGP buffers for DMA transfers (ioctl).
*
atomic_dec( &dev->buf_alloc );
return 0;
}
-#endif /* __REALLY_HAVE_AGP */
+#endif /* __OS_HAS_AGP */
-#if __HAVE_PCI_DMA
int DRM(addbufs_pci)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg )
{
drm_buf_t **temp_buflist;
drm_buf_desc_t __user *argp = (void __user *)arg;
+ if (!(dev->driver_features & DRIVER_PCI_DMA)) return -EINVAL;
+
if ( !dma ) return -EINVAL;
if ( copy_from_user( &request, argp, sizeof(request) ) )
return 0;
}
-#endif /* __HAVE_PCI_DMA */
-#if __HAVE_SG
int DRM(addbufs_sg)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg )
{
int i;
drm_buf_t **temp_buflist;
+ if (!(dev->driver_features & DRIVER_SG)) return -EINVAL;
+
if ( !dma ) return -EINVAL;
if ( copy_from_user( &request, argp, sizeof(request) ) )
atomic_dec( &dev->buf_alloc );
return 0;
}
-#endif /* __HAVE_SG */
/**
* Add buffers for DMA transfers (ioctl).
unsigned int cmd, unsigned long arg )
{
drm_buf_desc_t request;
+ drm_file_t *priv = filp->private_data;
+ drm_device_t *dev = priv->dev;
+
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
if ( copy_from_user( &request, (drm_buf_desc_t __user *)arg,
sizeof(request) ) )
return -EFAULT;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( request.flags & _DRM_AGP_BUFFER )
return DRM(addbufs_agp)( inode, filp, cmd, arg );
else
#endif
-#if __HAVE_SG
if ( request.flags & _DRM_SG_BUFFER )
return DRM(addbufs_sg)( inode, filp, cmd, arg );
else
-#endif
-#if __HAVE_PCI_DMA
return DRM(addbufs_pci)( inode, filp, cmd, arg );
-#else
- return -EINVAL;
-#endif
}
int i;
int count;
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
+
if ( !dma ) return -EINVAL;
spin_lock( &dev->count_lock );
int order;
drm_buf_entry_t *entry;
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
+
if ( !dma ) return -EINVAL;
if ( copy_from_user( &request,
int idx;
drm_buf_t *buf;
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
+
if ( !dma ) return -EINVAL;
if ( copy_from_user( &request,
drm_buf_map_t request;
int i;
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
+
if ( !dma ) return -EINVAL;
spin_lock( &dev->count_lock );
return -EFAULT;
if ( request.count >= dma->buf_count ) {
- if ( (__HAVE_AGP && (dma->flags & _DRM_DMA_USE_AGP)) ||
- (__HAVE_SG && (dma->flags & _DRM_DMA_USE_SG)) ) {
+ if (( (dev->driver_features & DRIVER_USE_AGP) && (dma->flags & _DRM_DMA_USE_AGP)) ||
+ ( (dev->driver_features & DRIVER_SG) && (dma->flags & _DRM_DMA_USE_SG)) ) {
drm_map_t *map = dev->agp_buffer_map;
if ( !map ) {
return retcode;
}
-#endif /* __HAVE_DMA */
/**
- * \file drm_context.h
+* \file drm_context.h
* IOCTLs for generic contexts
*
* \author Rickard E. (Rik) Faith <faith@valinux.com>
#define __NO_VERSION__
#include "drmP.h"
-#if !__HAVE_CTX_BITMAP
-#error "__HAVE_CTX_BITMAP must be defined"
-#endif
-
-
+#ifndef DRIVER_ALTERNATE_CONTEXT
/******************************************************************/
/** \name Context bitmap support */
/*@{*/
return 0;
}
+#endif
+extern drm_ioctl_desc_t DRM(ioctls)[];
+void DRM(context_add_ioctls)(void)
+{
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)].func = DRM(setsareactx);
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)].auth_needed = 1;
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)].root_only = 1;
+
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)].func = DRM(getsareactx);
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)].auth_needed = 1;
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)].root_only = 0;
+}
/*@}*/
+
#include "drmP.h"
-#ifndef __HAVE_DMA_WAITQUEUE
-#define __HAVE_DMA_WAITQUEUE 0
-#endif
-#ifndef __HAVE_DMA_RECLAIM
-#define __HAVE_DMA_RECLAIM 0
-#endif
-
-#if __HAVE_DMA
-
/**
* Initialize the DMA data.
*
buf->filp = NULL;
buf->used = 0;
- if ( __HAVE_DMA_WAITQUEUE && waitqueue_active(&buf->dma_wait)) {
+ if ( (dev->driver_features & DRIVER_DMA_QUEUE) && waitqueue_active(&buf->dma_wait)) {
wake_up_interruptible(&buf->dma_wait);
}
/* If processes are waiting, the last one
}
-#if !__HAVE_DMA_RECLAIM
/**
* Reclaim the buffers.
*
*
* Frees each buffer associated with \p filp not already on the hardware.
*/
-void DRM(reclaim_buffers)( struct file *filp )
+void DRM(core_reclaim_buffers)( struct file *filp )
{
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->dev;
}
}
}
-#endif
-
-#if !__HAVE_IRQ
-/* This stub DRM_IOCTL_CONTROL handler is for the drivers that used to require
- * IRQs for DMA but no longer do. It maintains compatibility with the X Servers
- * that try to use the control ioctl by simply returning success.
- */
-int DRM(control)( struct inode *inode, struct file *filp,
- unsigned int cmd, unsigned long arg )
-{
- drm_control_t ctl;
-
- if ( copy_from_user( &ctl, (drm_control_t __user *)arg, sizeof(ctl) ) )
- return -EFAULT;
-
- switch ( ctl.func ) {
- case DRM_INST_HANDLER:
- case DRM_UNINST_HANDLER:
- return 0;
- default:
- return -EINVAL;
- }
-}
-#endif
-#endif /* __HAVE_DMA */
* OTHER DEALINGS IN THE SOFTWARE.
*/
-#ifndef __MUST_HAVE_AGP
-#define __MUST_HAVE_AGP 0
-#endif
-#ifndef __HAVE_CTX_BITMAP
-#define __HAVE_CTX_BITMAP 0
-#endif
-#ifndef __HAVE_IRQ
-#define __HAVE_IRQ 0
-#endif
-#ifndef __HAVE_DMA_QUEUE
-#define __HAVE_DMA_QUEUE 0
-#endif
-#ifndef __HAVE_MULTIPLE_DMA_QUEUES
-#define __HAVE_MULTIPLE_DMA_QUEUES 0
-#endif
+
+
#ifndef __HAVE_COUNTERS
#define __HAVE_COUNTERS 0
#endif
-#ifndef __HAVE_SG
-#define __HAVE_SG 0
-#endif
#ifndef DRIVER_IOCTLS
#define DRIVER_IOCTLS
[DRM_IOCTL_NR(DRM_IOCTL_VERSION)] = { DRM(version), 0, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_GET_UNIQUE)] = { DRM(getunique), 0, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_GET_MAGIC)] = { DRM(getmagic), 0, 0 },
-#if __HAVE_IRQ
[DRM_IOCTL_NR(DRM_IOCTL_IRQ_BUSID)] = { DRM(irq_by_busid), 0, 1 },
-#endif
[DRM_IOCTL_NR(DRM_IOCTL_GET_MAP)] = { DRM(getmap), 0, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_GET_CLIENT)] = { DRM(getclient), 0, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_GET_STATS)] = { DRM(getstats), 0, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_ADD_MAP)] = { DRM(addmap), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_RM_MAP)] = { DRM(rmmap), 1, 0 },
-#if __HAVE_CTX_BITMAP
- [DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)] = { DRM(setsareactx), 1, 1 },
- [DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)] = { DRM(getsareactx), 1, 0 },
-#endif
-
[DRM_IOCTL_NR(DRM_IOCTL_ADD_CTX)] = { DRM(addctx), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_RM_CTX)] = { DRM(rmctx), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_MOD_CTX)] = { DRM(modctx), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_FINISH)] = { DRM(noop), 1, 0 },
-#if __HAVE_DMA
[DRM_IOCTL_NR(DRM_IOCTL_ADD_BUFS)] = { DRM(addbufs), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_MARK_BUFS)] = { DRM(markbufs), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_INFO_BUFS)] = { DRM(infobufs), 1, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_MAP_BUFS)] = { DRM(mapbufs), 1, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_FREE_BUFS)] = { DRM(freebufs), 1, 0 },
/* The DRM_IOCTL_DMA ioctl should be defined by the driver. */
-#endif
-#if __HAVE_IRQ || __HAVE_DMA
+
[DRM_IOCTL_NR(DRM_IOCTL_CONTROL)] = { DRM(control), 1, 1 },
-#endif
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
[DRM_IOCTL_NR(DRM_IOCTL_AGP_ACQUIRE)] = { DRM(agp_acquire), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_RELEASE)] = { DRM(agp_release), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE)] = { DRM(agp_enable), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] = { DRM(agp_unbind), 1, 1 },
#endif
-#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
-#if __HAVE_VBL_IRQ
[DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)] = { DRM(wait_vblank), 0, 0 },
-#endif
DRIVER_IOCTLS
};
dev->buf_use = 0;
atomic_set( &dev->buf_alloc, 0 );
-#if __HAVE_DMA
- i = DRM(dma_setup)( dev );
- if ( i < 0 )
- return i;
-#endif
+ if (dev->driver_features & DRIVER_HAVE_DMA)
+ {
+ i = DRM(dma_setup)( dev );
+ if ( i < 0 )
+ return i;
+ }
dev->counters = 6 + __HAVE_COUNTERS;
dev->types[0] = _DRM_STAT_LOCK;
if (dev->fn_tbl.pretakedown)
dev->fn_tbl.pretakedown(dev);
-#if __HAVE_IRQ
+
if ( dev->irq_enabled ) DRM(irq_uninstall)( dev );
-#endif
down( &dev->struct_sem );
del_timer( &dev->timer );
dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
}
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
/* Clear AGP information */
- if ( dev->agp ) {
+ if ( (dev->driver_features & DRIVER_USE_AGP) && dev->agp ) {
drm_agp_mem_t *entry;
drm_agp_mem_t *nexte;
*/
break;
case _DRM_SCATTER_GATHER:
- /* Handle it, but do nothing, if HAVE_SG
- * isn't defined.
- */
-#if __HAVE_SG
- if(dev->sg) {
+ /* Handle it */
+ if (dev->driver_features & DRIVER_SG && dev->sg) {
DRM(sg_cleanup)(dev->sg);
dev->sg = NULL;
}
-#endif
break;
}
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
}
}
-#if __HAVE_DMA_QUEUE || __HAVE_MULTIPLE_DMA_QUEUES
- if ( dev->queuelist ) {
+
+ if ( (dev->driver_features & DRIVER_DMA_QUEUE) && dev->queuelist ) {
for ( i = 0 ; i < dev->queue_count ; i++ ) {
if (dev->fn_tbl.waitlist_destroy)
dev->fn_tbl.waitlist_destroy( &dev->queuelist[i]->waitlist);
dev->queuelist = NULL;
}
dev->queue_count = 0;
-#endif
-#if __HAVE_DMA
- DRM(dma_takedown)( dev );
-#endif
+ if (dev->driver_features & DRIVER_HAVE_DMA)
+ DRM(dma_takedown)( dev );
+
if ( dev->lock.hw_lock ) {
dev->sigdata.lock = dev->lock.hw_lock = NULL; /* SHM removed */
dev->lock.filp = NULL;
return 0;
}
+static void DRM(init_fn_table)(struct drm_device *dev)
+{
+ dev->fn_tbl.reclaim_buffers = DRM(core_reclaim_buffers);
+ dev->fn_tbl.get_map_ofs = DRM(core_get_map_ofs);
+ dev->fn_tbl.get_reg_ofs = DRM(core_get_reg_ofs);
+}
+
#include "drm_pciids.h"
static struct pci_device_id DRM(pciidlist)[] = {
/* dev_priv_size can be changed by a driver in driver_register_fns */
dev->dev_priv_size = sizeof(u32);
- DRM(driver_register_fns)(dev);
+
+ DRM(init_fn_table)(dev);
+ DRM(driver_register_fns)(dev);
+
+ /* if we have CTX_BITMAP add the ioctls */
+ DRM(context_add_ioctls)();
+
if (dev->fn_tbl.preinit)
if ((retcode = dev->fn_tbl.preinit(dev, ent->driver_data)))
goto error_out_unreg;
-#if __REALLY_HAVE_AGP
- dev->agp = DRM(agp_init)();
-#if __MUST_HAVE_AGP
- if ( dev->agp == NULL ) {
- DRM_ERROR( "Cannot initialize the agpgart module.\n" );
- retcode = -EINVAL;
- goto error_out_unreg;
+#if __OS_HAS_AGP
+ if (dev->driver_features & DRIVER_USE_AGP) {
+ dev->agp = DRM(agp_init)();
+ if ( (dev->driver_features & DRIVER_REQUIRE_AGP) && dev->agp == NULL ) {
+ DRM_ERROR( "Cannot initialize the agpgart module.\n" );
+ retcode = -EINVAL;
+ goto error_out_unreg;
+ }
+
+#if __OS_HAS_MTRR
+ if (dev->driver_features & DRIVER_USE_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
-#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 __HAVE_CTX_BITMAP
retcode = DRM(ctxbitmap_init)( dev );
if( retcode ) {
- DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
- goto error_out_unreg;
- }
-#endif
+ DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
+ goto error_out_unreg;
+ }
+
if ((dev->minor = DRM(stub_register)(DRIVER_NAME, &DRM(fops),dev)) < 0)
{
retcode = -EPERM;
break;
case _DRM_FRAME_BUFFER:
-#if __REALLY_HAVE_MTRR
- if ( map->mtrr >= 0 ) {
- int retcode;
- retcode = mtrr_del( map->mtrr,
- map->offset,
- map->size );
- DRM_DEBUG( "mtrr_del=%d\n", retcode );
+#if __OS_HAS_MTRR
+ if ( dev->driver_features & DRIVER_USE_MTRR) {
+ if ( map->mtrr >= 0 ) {
+ int retcode;
+ retcode = mtrr_del( map->mtrr,
+ map->offset,
+ map->size );
+ DRM_DEBUG( "mtrr_del=%d\n", retcode );
+ }
}
#endif
break;
} else {
DRM_DEBUG( "minor %d unregistered\n", dev->minor);
}
-#if __HAVE_CTX_BITMAP
+
DRM(ctxbitmap_cleanup)( dev );
-#endif
-#if __REALLY_HAVE_AGP && __REALLY_HAVE_MTRR
- if ( dev->agp && dev->agp->agp_mtrr >= 0) {
+
+#if __OS_HAS_AGP
+#if __OS_HAS_MTRR
+ if ( (dev->driver_features & DRIVER_USE_MTRR) && dev->agp && dev->agp->agp_mtrr >= 0 ) {
int retval;
retval = mtrr_del( dev->agp->agp_mtrr,
dev->agp->agp_info.aper_base,
DRM_DEBUG( "mtrr_del=%d\n", retval );
}
#endif
-#if __REALLY_HAVE_AGP
- if ( dev->agp ) {
+ if ( (dev->driver_features & DRIVER_USE_AGP) && dev->agp ) {
DRM(agp_uninit)();
DRM(free)( dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS );
dev->agp = NULL;
}
}
-#if __HAVE_DMA
- DRM(reclaim_buffers)( filp );
-#endif
+ if (dev->driver_features & DRIVER_HAVE_DMA)
+ {
+ dev->fn_tbl.reclaim_buffers(filp);
+ }
DRM(fasync)( -1, filp, 0 );
pos->handle != DRM_KERNEL_CONTEXT ) {
if (dev->fn_tbl.context_dtor)
dev->fn_tbl.context_dtor(dev, pos->handle);
-#if __HAVE_CTX_BITMAP
+
DRM(ctxbitmap_free)( dev, pos->handle );
-#endif
+
list_del( &pos->head );
DRM(free)( pos, sizeof(*pos), DRM_MEM_CTXLIST );
--dev->ctx_count;
}
up( &dev->struct_sem );
+ if (dev->fn_tbl.free_filp_private)
+ dev->fn_tbl.free_filp_private( dev, priv );
DRM(free)( priv, sizeof(*priv), DRM_MEM_FILES );
/* ========================================================
DECLARE_WAITQUEUE( entry, current );
drm_lock_t lock;
int ret = 0;
-#if __HAVE_MULTIPLE_DMA_QUEUES
- drm_queue_t *q;
-#endif
++priv->lock_count;
lock.context, current->pid,
dev->lock.hw_lock->lock, lock.flags );
-#if __HAVE_DMA_QUEUE
- if ( lock.context < 0 )
- return -EINVAL;
-#elif __HAVE_MULTIPLE_DMA_QUEUES
- if ( lock.context < 0 || lock.context >= dev->queue_count )
- return -EINVAL;
- q = dev->queuelist[lock.context];
-#endif
+ if (dev->driver_features & DRIVER_DMA_QUEUE)
+ if ( lock.context < 0 )
+ return -EINVAL;
if (dev->fn_tbl.dma_flush_block_and_flush)
ret = dev->fn_tbl.dma_flush_block_and_flush(dev, lock.context, lock.flags);
{
int minor = iminor(inode);
drm_file_t *priv;
+ int ret;
if (filp->f_flags & O_EXCL) return -EBUSY; /* No exclusive opens */
if (!DRM(cpu_valid)()) return -EINVAL;
priv->lock_count = 0;
if (dev->fn_tbl.open_helper)
- dev->fn_tbl.open_helper(dev, priv);
+ {
+ ret=dev->fn_tbl.open_helper(dev, priv);
+ if (ret < 0)
+ goto out_free;
+ }
down(&dev->struct_sem);
if (!dev->file_last) {
#endif
return 0;
+ out_free:
+ DRM(free)(priv, sizeof(*priv), DRM_MEM_FILES);
+ return ret;
}
/** No-op. */
if (sv.drm_dd_major != DRIVER_MAJOR ||
sv.drm_dd_minor < 0 || sv.drm_dd_minor > DRIVER_MINOR)
return EINVAL;
-#ifdef DRIVER_SETVERSION
- DRIVER_SETVERSION(dev, &sv);
-#endif
+
+ if (dev->fn_tbl.set_version)
+ dev->fn_tbl.set_version(dev, &sv);
+
}
return 0;
}
#include <linux/interrupt.h> /* For task queue support */
-#ifndef __HAVE_SHARED_IRQ
-#define __HAVE_SHARED_IRQ 0
-#endif
-
-#if __HAVE_SHARED_IRQ
-#define DRM_IRQ_TYPE SA_SHIRQ
-#else
-#define DRM_IRQ_TYPE 0
-#endif
-
/**
* Get interrupt from bus id.
*
drm_irq_busid_t __user *argp = (void __user *)arg;
drm_irq_busid_t p;
+ if (!(dev->driver_features & DRIVER_HAVE_IRQ))
+ return -EINVAL;
+
if (copy_from_user(&p, argp, sizeof(p)))
return -EFAULT;
return 0;
}
-#if __HAVE_IRQ
-
/**
* Install IRQ handler.
*
int DRM(irq_install)( drm_device_t *dev )
{
int ret;
-
+ unsigned long sh_flags=0;
+
+ if (!(dev->driver_features & DRIVER_HAVE_IRQ ))
+ return -EINVAL;
+
if ( dev->irq == 0 )
return -EINVAL;
DRM_DEBUG( "%s: irq=%d\n", __FUNCTION__, dev->irq );
-#if __HAVE_DMA
dev->dma->next_buffer = NULL;
dev->dma->next_queue = NULL;
dev->dma->this_buffer = NULL;
-#endif
-
-#ifdef __HAVE_IRQ_BH
-#if !HAS_WORKQUEUE
- INIT_LIST_HEAD( &dev->tq.list );
- dev->tq.sync = 0;
- dev->tq.routine = DRM(irq_immediate_bh);
- dev->tq.data = dev;
-#else
- INIT_WORK(&dev->work, DRM(irq_immediate_bh), dev);
-#endif
-#endif
-
-#ifdef __HAVE_VBL_IRQ
- init_waitqueue_head(&dev->vbl_queue);
- spin_lock_init( &dev->vbl_lock );
-
- INIT_LIST_HEAD( &dev->vbl_sigs.head );
-
- dev->vbl_pending = 0;
-#endif
+ if (dev->driver_features & DRIVER_IRQ_VBL) {
+ init_waitqueue_head(&dev->vbl_queue);
+
+ spin_lock_init( &dev->vbl_lock );
+
+ INIT_LIST_HEAD( &dev->vbl_sigs.head );
+
+ dev->vbl_pending = 0;
+ }
/* Before installing handler */
- DRM(driver_irq_preinstall)(dev);
+ dev->fn_tbl.irq_preinstall(dev);
/* Install handler */
- ret = request_irq( dev->irq, DRM(irq_handler),
- DRM_IRQ_TYPE, dev->devname, dev );
+ if (dev->driver_features & DRIVER_IRQ_SHARED)
+ sh_flags = SA_SHIRQ;
+
+ ret = request_irq( dev->irq, dev->fn_tbl.irq_handler,
+ sh_flags, dev->devname, dev );
if ( ret < 0 ) {
down( &dev->struct_sem );
dev->irq_enabled = 0;
}
/* After installing handler */
- DRM(driver_irq_postinstall)(dev);
+ dev->fn_tbl.irq_postinstall(dev);
return 0;
}
{
int irq_enabled;
+ if (!(dev->driver_features & DRIVER_HAVE_IRQ ))
+ return -EINVAL;
+
down( &dev->struct_sem );
irq_enabled = dev->irq_enabled;
dev->irq_enabled = 0;
DRM_DEBUG( "%s: irq=%d\n", __FUNCTION__, dev->irq );
- DRM(driver_irq_uninstall)( dev );
+ dev->fn_tbl.irq_uninstall(dev);
free_irq( dev->irq, dev );
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->dev;
drm_control_t ctl;
+
+ /* if we haven't dma then no need for this control */
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
+
+ /* if we haven't irq we fallback for compatibility reasons - this used to be a separate function in drm_dma.h */
if ( copy_from_user( &ctl, (drm_control_t __user *)arg, sizeof(ctl) ) )
return -EFAULT;
switch ( ctl.func ) {
case DRM_INST_HANDLER:
+ if (!(dev->driver_features & DRIVER_HAVE_IRQ))
+ return 0;
if (dev->if_version < DRM_IF_VERSION(1, 2) &&
ctl.irq != dev->irq)
return -EINVAL;
return DRM(irq_install)( dev );
case DRM_UNINST_HANDLER:
+ if (!(dev->driver_features & DRIVER_HAVE_IRQ))
+ return 0;
return DRM(irq_uninstall)( dev );
default:
return -EINVAL;
}
}
-#ifdef __HAVE_VBL_IRQ
-
/**
* Wait for VBLANK.
*
int ret = 0;
unsigned int flags;
+ if (!(dev->driver_features & DRIVER_IRQ_VBL))
+ return -EINVAL;
+
if (!dev->irq)
return -EINVAL;
spin_unlock_irqrestore( &dev->vbl_lock, irqflags );
} else {
- ret = DRM(vblank_wait)( dev, &vblwait.request.sequence );
+ if (dev->fn_tbl.vblank_wait)
+ ret = dev->fn_tbl.vblank_wait( dev, &vblwait.request.sequence );
do_gettimeofday( &now );
vblwait.reply.tval_sec = now.tv_sec;
spin_unlock_irqrestore( &dev->vbl_lock, flags );
}
-#endif /* __HAVE_VBL_IRQ */
-#endif /* __HAVE_IRQ */
#define DEBUG_MEMORY 0
/* Need the 4-argument version of vmap(). */
-#if __REALLY_HAVE_AGP && defined(VMAP_4_ARGS)
+#if __OS_HAS_AGP && defined(VMAP_4_ARGS)
#include <linux/vmalloc.h>
return pte_pfn(*ptep) << PAGE_SHIFT;
}
-#endif /* __REALLY_HAVE_AGP && defined(VMAP_4_ARGS) */
+#endif /* __OS_HAS_AGP && defined(VMAP_4_ARGS) */
static inline void *drm_ioremap(unsigned long offset, unsigned long size, drm_device_t *dev)
{
-#if __REALLY_HAVE_AGP && defined(VMAP_4_ARGS)
- if (dev->agp && dev->agp->cant_use_aperture) {
+#if __OS_HAS_AGP && defined(VMAP_4_ARGS)
+ if ( (dev->driver_features & DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture) {
drm_map_t *map = drm_lookup_map(offset, size, dev);
if (map && map->type == _DRM_AGP)
static inline void *drm_ioremap_nocache(unsigned long offset, unsigned long size,
drm_device_t *dev)
{
-#if __REALLY_HAVE_AGP && defined(VMAP_4_ARGS)
- if (dev->agp && dev->agp->cant_use_aperture) {
+#if __OS_HAS_AGP&& defined(VMAP_4_ARGS)
+ if ( (dev->driver_features & DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture) {
drm_map_t *map = drm_lookup_map(offset, size, dev);
if (map && map->type == _DRM_AGP)
static inline void drm_ioremapfree(void *pt, unsigned long size, drm_device_t *dev)
{
-#if __REALLY_HAVE_AGP && defined(VMAP_4_ARGS)
+#if __OS_HAS_AGP && defined(VMAP_4_ARGS)
/*
* This is a bit ugly. It would be much cleaner if the DRM API would use separate
* routines for handling mappings in the AGP space. Hopefully this can be done in
* a future revision of the interface...
*/
- if (dev->agp && dev->agp->cant_use_aperture
+ if ((dev->driver_features & DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture
&& ((unsigned long) pt >= VMALLOC_START && (unsigned long) pt < VMALLOC_END))
{
unsigned long offset;
drm_ioremapfree(pt, size, dev);
}
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
/** Wrapper around agp_allocate_memory() */
DRM_AGP_MEM *DRM(alloc_agp)(int pages, u32 type)
{
}
}
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
DRM_AGP_MEM *DRM(alloc_agp)(int pages, u32 type)
{
DRM_DEBUG( "%s\n", __FUNCTION__ );
+ if ( dev->driver_features & DRIVER_SG )
+ return -EINVAL;
+
if ( dev->sg )
return -EINVAL;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
+ if ( dev->driver_features & DRIVER_SG )
+ return -EINVAL;
+
if ( copy_from_user( &request,
(drm_scatter_gather_t __user *)arg,
sizeof(request) ) )
static __inline__ struct page *DRM(do_vm_nopage)(struct vm_area_struct *vma,
unsigned long address)
{
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
drm_file_t *priv = vma->vm_file->private_data;
drm_device_t *dev = priv->dev;
drm_map_t *map = NULL;
/*
* Find the right map
*/
+ if (!(dev->agp && DRIVER_USE_AGP)) goto vm_nopage_error;
if(!dev->agp || !dev->agp->cant_use_aperture) goto vm_nopage_error;
return page;
}
vm_nopage_error:
-#endif /* __REALLY_HAVE_AGP */
+#endif /* __OS_HAS_AGP */
return NOPAGE_SIGBUS; /* Disallow mremap */
}
switch (map->type) {
case _DRM_REGISTERS:
case _DRM_FRAME_BUFFER:
-#if __REALLY_HAVE_MTRR
- if (map->mtrr >= 0) {
+#if __OS_HAS_MTRR
+ if ((dev->driver_features & DRIVER_USE_MTRR) && map->mtrr >= 0) {
int retcode;
retcode = mtrr_del(map->mtrr,
map->offset,
return 0;
}
-#ifndef DRIVER_GET_MAP_OFS
-#define DRIVER_GET_MAP_OFS() (map->offset)
-#endif
+unsigned long DRM(core_get_map_ofs)(drm_map_t *map)
+{
+ return map->offset;
+}
-#ifndef DRIVER_GET_REG_OFS
+unsigned long DRM(core_get_reg_ofs)(struct drm_device *dev)
+{
#ifdef __alpha__
-#define DRIVER_GET_REG_OFS() (dev->hose->dense_mem_base - \
- dev->hose->mem_space->start)
+ return dev->host->dense_mem_base - dev->hose_mem_space->start;
#else
-#define DRIVER_GET_REG_OFS() 0
-#endif
+ return 0;
#endif
+}
/**
* mmap DMA memory.
* --BenH.
*/
if (!VM_OFFSET(vma)
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
&& (!dev->agp || dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE)
#endif
)
r_list = list_entry(list, drm_map_list_t, head);
map = r_list->map;
if (!map) continue;
- off = DRIVER_GET_MAP_OFS();
+ off = dev->fn_tbl.get_map_ofs(map);
if (off == VM_OFFSET(vma)) break;
}
switch (map->type) {
case _DRM_AGP:
-#if __REALLY_HAVE_AGP
- if (dev->agp->cant_use_aperture) {
+#if __OS_HAS_AGP
+ if ((dev->driver_features & DRIVER_USE_AGP) && dev->agp->cant_use_aperture) {
/*
* On some platforms we can't talk to bus dma address from the CPU, so for
* memory of type DRM_AGP, we'll deal with sorting out the real physical
if (map->type != _DRM_AGP)
vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
#endif
- offset = DRIVER_GET_REG_OFS();
+ offset = dev->fn_tbl.get_reg_ofs(dev);
#ifdef __sparc__
if (io_remap_page_range(DRM_RPR_ARG(vma) vma->vm_start,
VM_OFFSET(vma) + offset,
wake_up_interruptible(&dev->lock.lock_queue);
}
+static unsigned long ffb_driver_get_map_ofs(drm_map_t *map)
+{
+ return (map->offset & 0xffffffff);
+}
+
+static unsigned long ffb_driver_get_reg_ofs(drm_device_t *dev)
+{
+ ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
+
+ if (ffb_priv)
+ return ffb_priv->card_phys_base;
+
+ return 0;
+}
+
static void ffb_driver_register_fns(drm_device_t *dev)
{
DRM(fops).get_unmapped_area = ffb_get_unmapped_area;
dev->fn_tbl.postcleanup = ffb_driver_postcleanup;
dev->fn_tbl.kernel_context_switch = ffb_context_switch;
dev->fn_tbl.kernel_context_switch_unlock = ffb_driver_kernel_context_switch_unlock;
+ dev->fn_tbl.get_map_ofs = ffb_driver_get_map_ofs;
+ dev->fn_tbl.get_reg_ofs = ffb_driver_get_reg_ofs;
+
}
#define DRIVER_COUNT_CARDS() ffb_count_card_instances()
-/* For mmap customization */
-#define DRIVER_GET_MAP_OFS() (map->offset & 0xffffffff)
-#define DRIVER_GET_REG_OFS() ffb_get_reg_offset(dev)
-
typedef struct _ffb_position_t {
int node;
int root;
return addr;
}
-static unsigned long ffb_get_reg_offset(drm_device_t *dev)
-{
- ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
-
- if (ffb_priv)
- return ffb_priv->card_phys_base;
-
- return 0;
-}
-
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_dma.h"
{
drm_device_dma_t *dma = dev->dma;
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
- if ( dev->irq_enabled ) DRM(irq_uninstall)(dev);
-#endif
+ if ( (dev->driver_features & DRIVER_HAVE_IRQ) && dev->irq_enabled )
+ DRM(irq_uninstall)(dev);
if (dev->dev_private) {
int i;
void i810_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_DMA | DRIVER_DMA_QUEUE;
dev->dev_priv_size = sizeof(drm_i810_buf_priv_t);
dev->fn_tbl.pretakedown = i810_driver_pretakedown;
dev->fn_tbl.release = i810_driver_release;
dev->fn_tbl.dma_quiescent = i810_driver_dma_quiescent;
+ dev->fn_tbl.reclaim_buffers = i810_reclaim_buffers;
}
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
+#include "drm_irq.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
{
drm_device_dma_t *dma = dev->dma;
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
if (dev->irq_enabled) DRM(irq_uninstall)(dev);
-#endif
if (dev->dev_private) {
int i;
void i830_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_DMA | DRIVER_DMA_QUEUE;
+#if USE_IRQS
+ dev->driver_features |= DRIVER_HAVE_IRQ | DRIVER_SHARED_IRQ;
+#endif
dev->dev_priv_size = sizeof(drm_i830_buf_priv_t);
dev->fn_tbl.pretakedown = i830_driver_pretakedown;
dev->fn_tbl.release = i830_driver_release;
dev->fn_tbl.dma_quiescent = i830_driver_dma_quiescent;
+ dev->fn_tbl.reclaim_buffers = i830_reclaim_buffers;
+#if USE_IRQS
+ dev->fn_tbl.irq_preinstall = i830_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = i830_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = i830_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = i830_driver_irq_handler;
+#endif
}
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
extern int i830_wait_irq(drm_device_t *dev, int irq_nr);
extern int i830_emit_irq(drm_device_t *dev);
+extern irqreturn_t i830_driver_irq_handler( DRM_IRQ_ARGS );
+extern void i830_driver_irq_preinstall( drm_device_t *dev );
+extern void i830_driver_irq_postinstall( drm_device_t *dev );
+extern void i830_driver_irq_uninstall( drm_device_t *dev );
#define I830_BASE(reg) ((unsigned long) \
dev_priv->mmio_map->handle)
#include <linux/delay.h>
-irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS )
+irqreturn_t i830_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *)arg;
drm_i830_private_t *dev_priv = (drm_i830_private_t *)dev->dev_private;
/* drm_dma.h hooks
*/
-void DRM(driver_irq_preinstall)( drm_device_t *dev ) {
+void i830_driver_irq_preinstall( drm_device_t *dev ) {
drm_i830_private_t *dev_priv =
(drm_i830_private_t *)dev->dev_private;
init_waitqueue_head(&dev_priv->irq_queue);
}
-void DRM(driver_irq_postinstall)( drm_device_t *dev ) {
+void i830_driver_irq_postinstall( drm_device_t *dev ) {
drm_i830_private_t *dev_priv =
(drm_i830_private_t *)dev->dev_private;
I830_WRITE16( I830REG_INT_ENABLE_R, 0x2 );
}
-void DRM(driver_irq_uninstall)( drm_device_t *dev ) {
+void i830_driver_irq_uninstall( drm_device_t *dev ) {
drm_i830_private_t *dev_priv =
(drm_i830_private_t *)dev->dev_private;
if (!dev_priv)
#include "drm_bufs.h"
#include "drm_context.h" /* is this needed? */
#include "drm_drawable.h" /* is this needed? */
+#include "drm_dma.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
*/
#define DRM(x) savage_##x
-/* General customization:
- */
-#define __HAVE_AGP 1
-#define __MUST_HAVE_AGP 1
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
-
#endif
void DRM(driver_register_fns)(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR;
}
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
+#include "drm_irq.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
+#include "drm_irq.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
#include "tdfx.h"
#include "drmP.h"
+#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
+#include "drm_irq.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
void DRM(driver_register_fns)(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_MTRR;
}
MACHINE := $(shell uname -m)
# Modules for all architectures
-MODULE_LIST := gamma.o tdfx.o r128.o radeon.o mga.o sis.o savage.o via.o mach64.o
+MODULE_LIST := tdfx.o r128.o radeon.o mga.o sis.o savage.o via.o mach64.o
# Modules only for ix86 architectures
ifneq (,$(findstring 86,$(MACHINE)))
/** \name DRM template customization defaults */
/*@{*/
-#ifndef __HAVE_AGP
-#define __HAVE_AGP 0
-#endif
-#ifndef __HAVE_MTRR
-#define __HAVE_MTRR 0
-#endif
-#ifndef __HAVE_CTX_BITMAP
-#define __HAVE_CTX_BITMAP 0
-#endif
-#ifndef __HAVE_DMA
-#define __HAVE_DMA 0
-#endif
-#ifndef __HAVE_IRQ
-#define __HAVE_IRQ 0
-#endif
-
-#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)
-
+/* driver capabilities and requirements mask */
+#define DRIVER_USE_AGP 0x1
+#define DRIVER_REQUIRE_AGP 0x2
+#define DRIVER_USE_MTRR 0x4
+#define DRIVER_HAVE_DMA 0x10
+#define DRIVER_HAVE_IRQ 0x20
+#define DRIVER_SG 0x40
+#define DRIVER_PCI_DMA 0x80
+#define DRIVER_IRQ_SHARED 0x100
+#define DRIVER_IRQ_VBL 0x200
+#define DRIVER_DMA_QUEUE 0x800
+
+#define __OS_HAS_AGP (defined(CONFIG_AGP) || defined(CONFIG_AGP_MODULE))
+#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
/*@}*/
struct drm_device *dev;
int remove_auth_on_close;
unsigned long lock_count;
-#ifdef DRIVER_FILE_FIELDS
- DRIVER_FILE_FIELDS;
-#endif
+ void *driver_priv;
} drm_file_t;
/** Wait queue */
/*@}*/
} drm_device_dma_t;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
/**
* AGP memory entry. Stored as a doubly linked list.
*/
drm_file_t *tag; /**< associated fd private data */
} drm_ctx_list_t;
-#ifdef __HAVE_VBL_IRQ
typedef struct drm_vbl_sig {
struct list_head head;
struct task_struct *task;
} drm_vbl_sig_t;
-#endif
/**
* DRM device functions structure
int (*postcleanup)(struct drm_device *);
int (*presetup)(struct drm_device *);
int (*postsetup)(struct drm_device *);
- void (*open_helper)(struct drm_device *, drm_file_t *);
+
+ /* these are opposites at the moment */
+ int (*open_helper)(struct drm_device *, drm_file_t *);
+ void (*free_filp_private)(struct drm_device *, drm_file_t *);
+
void (*release)(struct drm_device *, struct file *filp);
void (*dma_ready)(struct drm_device *);
int (*dma_quiescent)(struct drm_device *);
int (*waitlist_destroy)(drm_waitlist_t *bl);
int (*freelist_create)(drm_freelist_t *bl, int count);
int (*freelist_put)(struct drm_device *dev, drm_freelist_t *bl, drm_buf_t *buf);
- int (*freelist_destroy)(drm_freelist_t *bl);
+ int (*freelist_destroy)(drm_freelist_t *bl);
+ int (*vblank_wait)(struct drm_device *dev, unsigned int *sequence);
+/* these have to be filled in */
+ irqreturn_t (*irq_handler)( DRM_IRQ_ARGS );
+ void (*irq_preinstall)(struct drm_device *dev);
+ void (*irq_postinstall)(struct drm_device *dev);
+ void (*irq_uninstall)(struct drm_device *dev);
+ void (*reclaim_buffers)(struct file *filp);
+ unsigned long (*get_map_ofs)(drm_map_t *map);
+ unsigned long (*get_reg_ofs)(struct drm_device *dev);
+ void (*set_version)(struct drm_device *dev, drm_set_version_t *sv);
};
/**
#endif
/** \name VBLANK IRQ support */
/*@{*/
-#ifdef __HAVE_VBL_IRQ
+
wait_queue_head_t vbl_queue; /**< VBLANK wait queue */
atomic_t vbl_received;
spinlock_t vbl_lock;
drm_vbl_sig_t vbl_sigs; /**< signal list to send on VBLANK */
unsigned int vbl_pending;
-#endif
+
/*@}*/
cycles_t ctx_start;
cycles_t lck_start;
wait_queue_head_t buf_readers; /**< Processes waiting to read */
wait_queue_head_t buf_writers; /**< Processes waiting to ctx switch */
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
drm_agp_head_t *agp; /**< AGP data */
#endif
struct drm_driver_fn fn_tbl;
drm_local_map_t *agp_buffer_map;
int dev_priv_size;
+ u32 driver_features;
} drm_device_t;
extern void DRM(driver_register_fns)(struct drm_device *dev);
drm_device_t *dev);
extern void DRM(ioremapfree)(void *pt, unsigned long size, drm_device_t *dev);
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
extern DRM_AGP_MEM *DRM(alloc_agp)(int pages, u32 type);
extern int DRM(free_agp)(DRM_AGP_MEM *handle, int pages);
extern int DRM(bind_agp)(DRM_AGP_MEM *handle, unsigned int start);
extern int DRM(context_switch)(drm_device_t *dev, int old, int new);
extern int DRM(context_switch_complete)(drm_device_t *dev, int new);
-#if __HAVE_CTX_BITMAP
extern int DRM(ctxbitmap_init)( drm_device_t *dev );
extern void DRM(ctxbitmap_cleanup)( drm_device_t *dev );
-#endif
extern int DRM(setsareactx)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg );
unsigned int cmd, unsigned long arg );
extern int DRM(initmap)( drm_device_t *dev, unsigned int offset,
unsigned int size, int type, int flags );
-#if __HAVE_DMA
extern int DRM(addbufs)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg );
extern int DRM(infobufs)( struct inode *inode, struct file *filp,
extern void DRM(dma_takedown)(drm_device_t *dev);
extern void DRM(free_buffer)(drm_device_t *dev, drm_buf_t *buf);
extern void DRM(reclaim_buffers)( struct file *filp );
-#endif /* __HAVE_DMA */
/* IRQ support (drm_irq.h) */
-#if __HAVE_IRQ || __HAVE_DMA
extern int DRM(control)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg );
-#endif
-#if __HAVE_IRQ
extern int DRM(irq_install)( drm_device_t *dev );
extern int DRM(irq_uninstall)( drm_device_t *dev );
extern irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS );
extern void DRM(driver_irq_preinstall)( drm_device_t *dev );
extern void DRM(driver_irq_postinstall)( drm_device_t *dev );
extern void DRM(driver_irq_uninstall)( drm_device_t *dev );
-#ifdef __HAVE_VBL_IRQ
+
extern int DRM(wait_vblank)(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
extern int DRM(vblank_wait)(drm_device_t *dev, unsigned int *vbl_seq);
extern void DRM(vbl_send_signals)( drm_device_t *dev );
-#endif
-#ifdef __HAVE_IRQ_BH
-extern void DRM(irq_immediate_bh)( void *dev );
-#endif
-#endif
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
/* AGP/GART support (drm_agpsupport.h) */
extern drm_agp_head_t *DRM(agp_init)(void);
extern void DRM(agp_uninit)(void);
struct proc_dir_entry *root,
struct proc_dir_entry *dev_root);
-#ifdef __HAVE_SG
/* Scatter Gather Support (drm_scatter.h) */
extern void DRM(sg_cleanup)(drm_sg_mem_t *entry);
extern int DRM(sg_alloc)(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
extern int DRM(sg_free)(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
-#endif
/* ATI PCIGART support (ati_pcigart.h) */
extern int DRM(ati_pcigart_init)(drm_device_t *dev,
}
/*@}*/
+extern unsigned long DRM(core_get_map_ofs)(drm_map_t *map);
+extern unsigned long DRM(core_get_reg_ofs)(struct drm_device *dev);
#endif /* __KERNEL__ */
#endif
#include "drmP.h"
#include <linux/module.h>
-#if __REALLY_HAVE_AGP
-
+#if __OS_HAS_AGP
#define DRM_AGP_GET (drm_agp_t *)inter_module_get("drm_agp")
#define DRM_AGP_PUT inter_module_put("drm_agp")
return drm_agp->unbind_memory(handle);
}
-#endif /* __REALLY_HAVE_AGP */
+#endif /* __OS_HAS_AGP */
#include <linux/vmalloc.h>
#include "drmP.h"
-#ifndef __HAVE_PCI_DMA
-#define __HAVE_PCI_DMA 0
-#endif
-
-#ifndef __HAVE_SG
-#define __HAVE_SG 0
-#endif
-
/**
* Compute size order. Returns the exponent of the smaller power of two which
* is greater or equal to given number.
#ifdef __alpha__
map->offset += dev->hose->mem_space->start;
#endif
-#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 );
+#if __OS_HAS_MTRR
+ if ( dev->driver_features & DRIVER_USE_MTRR) {
+ if ( map->type == _DRM_FRAME_BUFFER ||
+ (map->flags & _DRM_WRITE_COMBINING) ) {
+ map->mtrr = mtrr_add( map->offset, map->size,
+ MTRR_TYPE_WRCOMB, 1 );
+ }
}
#endif
if (map->type == _DRM_REGISTERS)
return 0;
}
-
/**
* Ioctl to specify a range of memory that is available for mapping by a non-root process.
*
#ifdef __alpha__
map->offset += dev->hose->mem_space->start;
#endif
-#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 );
+#if __OS_HAS_MTRR
+ if (dev->driver_features & DRIVER_USE_MTRR) {
+ if ( map->type == _DRM_FRAME_BUFFER ||
+ (map->flags & _DRM_WRITE_COMBINING) ) {
+ map->mtrr = mtrr_add( map->offset, map->size,
+ MTRR_TYPE_WRCOMB, 1 );
+ }
}
#endif
if (map->type == _DRM_REGISTERS)
dev->lock.hw_lock = map->handle; /* Pointer to lock */
}
break;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
case _DRM_AGP:
+ if (dev->driver_features & DRIVER_USE_AGP) {
#ifdef __alpha__
- map->offset += dev->hose->mem_space->start;
+ map->offset += dev->hose->mem_space->start;
#endif
- map->offset += dev->agp->base;
- map->mtrr = dev->agp->agp_mtrr; /* for getmap */
+ map->offset += dev->agp->base;
+ map->mtrr = dev->agp->agp_mtrr; /* for getmap */
+ }
break;
#endif
case _DRM_SCATTER_GATHER:
return 0;
}
-#if __HAVE_DMA
-
/**
* Cleanup after an error on one of the addbufs() functions.
*
}
}
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
/**
* Add AGP buffers for DMA transfers (ioctl).
*
atomic_dec( &dev->buf_alloc );
return 0;
}
-#endif /* __REALLY_HAVE_AGP */
+#endif /* __OS_HAS_AGP */
-#if __HAVE_PCI_DMA
int DRM(addbufs_pci)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg )
{
drm_buf_t **temp_buflist;
drm_buf_desc_t __user *argp = (void __user *)arg;
+ if (!(dev->driver_features & DRIVER_PCI_DMA)) return -EINVAL;
+
if ( !dma ) return -EINVAL;
if ( copy_from_user( &request, argp, sizeof(request) ) )
return 0;
}
-#endif /* __HAVE_PCI_DMA */
-#if __HAVE_SG
int DRM(addbufs_sg)( struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg )
{
int i;
drm_buf_t **temp_buflist;
+ if (!(dev->driver_features & DRIVER_SG)) return -EINVAL;
+
if ( !dma ) return -EINVAL;
if ( copy_from_user( &request, argp, sizeof(request) ) )
atomic_dec( &dev->buf_alloc );
return 0;
}
-#endif /* __HAVE_SG */
/**
* Add buffers for DMA transfers (ioctl).
unsigned int cmd, unsigned long arg )
{
drm_buf_desc_t request;
+ drm_file_t *priv = filp->private_data;
+ drm_device_t *dev = priv->dev;
+
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
if ( copy_from_user( &request, (drm_buf_desc_t __user *)arg,
sizeof(request) ) )
return -EFAULT;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( request.flags & _DRM_AGP_BUFFER )
return DRM(addbufs_agp)( inode, filp, cmd, arg );
else
#endif
-#if __HAVE_SG
if ( request.flags & _DRM_SG_BUFFER )
return DRM(addbufs_sg)( inode, filp, cmd, arg );
else
-#endif
-#if __HAVE_PCI_DMA
return DRM(addbufs_pci)( inode, filp, cmd, arg );
-#else
- return -EINVAL;
-#endif
}
int i;
int count;
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
+
if ( !dma ) return -EINVAL;
spin_lock( &dev->count_lock );
int order;
drm_buf_entry_t *entry;
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
+
if ( !dma ) return -EINVAL;
if ( copy_from_user( &request,
int idx;
drm_buf_t *buf;
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
+
if ( !dma ) return -EINVAL;
if ( copy_from_user( &request,
drm_buf_map_t request;
int i;
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
+
if ( !dma ) return -EINVAL;
spin_lock( &dev->count_lock );
return -EFAULT;
if ( request.count >= dma->buf_count ) {
- if ( (__HAVE_AGP && (dma->flags & _DRM_DMA_USE_AGP)) ||
- (__HAVE_SG && (dma->flags & _DRM_DMA_USE_SG)) ) {
+ if (( (dev->driver_features & DRIVER_USE_AGP) && (dma->flags & _DRM_DMA_USE_AGP)) ||
+ ( (dev->driver_features & DRIVER_SG) && (dma->flags & _DRM_DMA_USE_SG)) ) {
drm_map_t *map = dev->agp_buffer_map;
if ( !map ) {
return retcode;
}
-#endif /* __HAVE_DMA */
/**
- * \file drm_context.h
+* \file drm_context.h
* IOCTLs for generic contexts
*
* \author Rickard E. (Rik) Faith <faith@valinux.com>
#define __NO_VERSION__
#include "drmP.h"
-#if !__HAVE_CTX_BITMAP
-#error "__HAVE_CTX_BITMAP must be defined"
-#endif
-
-
+#ifndef DRIVER_ALTERNATE_CONTEXT
/******************************************************************/
/** \name Context bitmap support */
/*@{*/
return 0;
}
+#endif
+extern drm_ioctl_desc_t DRM(ioctls)[];
+void DRM(context_add_ioctls)(void)
+{
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)].func = DRM(setsareactx);
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)].auth_needed = 1;
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)].root_only = 1;
+
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)].func = DRM(getsareactx);
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)].auth_needed = 1;
+ DRM(ioctls)[DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)].root_only = 0;
+}
/*@}*/
+
#include "drmP.h"
-#ifndef __HAVE_DMA_WAITQUEUE
-#define __HAVE_DMA_WAITQUEUE 0
-#endif
-#ifndef __HAVE_DMA_RECLAIM
-#define __HAVE_DMA_RECLAIM 0
-#endif
-
-#if __HAVE_DMA
-
/**
* Initialize the DMA data.
*
buf->filp = NULL;
buf->used = 0;
- if ( __HAVE_DMA_WAITQUEUE && waitqueue_active(&buf->dma_wait)) {
+ if ( (dev->driver_features & DRIVER_DMA_QUEUE) && waitqueue_active(&buf->dma_wait)) {
wake_up_interruptible(&buf->dma_wait);
}
/* If processes are waiting, the last one
}
-#if !__HAVE_DMA_RECLAIM
/**
* Reclaim the buffers.
*
*
* Frees each buffer associated with \p filp not already on the hardware.
*/
-void DRM(reclaim_buffers)( struct file *filp )
+void DRM(core_reclaim_buffers)( struct file *filp )
{
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->dev;
}
}
}
-#endif
-
-#if !__HAVE_IRQ
-/* This stub DRM_IOCTL_CONTROL handler is for the drivers that used to require
- * IRQs for DMA but no longer do. It maintains compatibility with the X Servers
- * that try to use the control ioctl by simply returning success.
- */
-int DRM(control)( struct inode *inode, struct file *filp,
- unsigned int cmd, unsigned long arg )
-{
- drm_control_t ctl;
-
- if ( copy_from_user( &ctl, (drm_control_t __user *)arg, sizeof(ctl) ) )
- return -EFAULT;
-
- switch ( ctl.func ) {
- case DRM_INST_HANDLER:
- case DRM_UNINST_HANDLER:
- return 0;
- default:
- return -EINVAL;
- }
-}
-#endif
-#endif /* __HAVE_DMA */
* OTHER DEALINGS IN THE SOFTWARE.
*/
-#ifndef __MUST_HAVE_AGP
-#define __MUST_HAVE_AGP 0
-#endif
-#ifndef __HAVE_CTX_BITMAP
-#define __HAVE_CTX_BITMAP 0
-#endif
-#ifndef __HAVE_IRQ
-#define __HAVE_IRQ 0
-#endif
-#ifndef __HAVE_DMA_QUEUE
-#define __HAVE_DMA_QUEUE 0
-#endif
-#ifndef __HAVE_MULTIPLE_DMA_QUEUES
-#define __HAVE_MULTIPLE_DMA_QUEUES 0
-#endif
+
+
#ifndef __HAVE_COUNTERS
#define __HAVE_COUNTERS 0
#endif
-#ifndef __HAVE_SG
-#define __HAVE_SG 0
-#endif
#ifndef DRIVER_IOCTLS
#define DRIVER_IOCTLS
[DRM_IOCTL_NR(DRM_IOCTL_VERSION)] = { DRM(version), 0, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_GET_UNIQUE)] = { DRM(getunique), 0, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_GET_MAGIC)] = { DRM(getmagic), 0, 0 },
-#if __HAVE_IRQ
[DRM_IOCTL_NR(DRM_IOCTL_IRQ_BUSID)] = { DRM(irq_by_busid), 0, 1 },
-#endif
[DRM_IOCTL_NR(DRM_IOCTL_GET_MAP)] = { DRM(getmap), 0, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_GET_CLIENT)] = { DRM(getclient), 0, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_GET_STATS)] = { DRM(getstats), 0, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_ADD_MAP)] = { DRM(addmap), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_RM_MAP)] = { DRM(rmmap), 1, 0 },
-#if __HAVE_CTX_BITMAP
- [DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)] = { DRM(setsareactx), 1, 1 },
- [DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)] = { DRM(getsareactx), 1, 0 },
-#endif
-
[DRM_IOCTL_NR(DRM_IOCTL_ADD_CTX)] = { DRM(addctx), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_RM_CTX)] = { DRM(rmctx), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_MOD_CTX)] = { DRM(modctx), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_FINISH)] = { DRM(noop), 1, 0 },
-#if __HAVE_DMA
[DRM_IOCTL_NR(DRM_IOCTL_ADD_BUFS)] = { DRM(addbufs), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_MARK_BUFS)] = { DRM(markbufs), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_INFO_BUFS)] = { DRM(infobufs), 1, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_MAP_BUFS)] = { DRM(mapbufs), 1, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_FREE_BUFS)] = { DRM(freebufs), 1, 0 },
/* The DRM_IOCTL_DMA ioctl should be defined by the driver. */
-#endif
-#if __HAVE_IRQ || __HAVE_DMA
+
[DRM_IOCTL_NR(DRM_IOCTL_CONTROL)] = { DRM(control), 1, 1 },
-#endif
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
[DRM_IOCTL_NR(DRM_IOCTL_AGP_ACQUIRE)] = { DRM(agp_acquire), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_RELEASE)] = { DRM(agp_release), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE)] = { DRM(agp_enable), 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] = { DRM(agp_unbind), 1, 1 },
#endif
-#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
-#if __HAVE_VBL_IRQ
[DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)] = { DRM(wait_vblank), 0, 0 },
-#endif
DRIVER_IOCTLS
};
dev->buf_use = 0;
atomic_set( &dev->buf_alloc, 0 );
-#if __HAVE_DMA
- i = DRM(dma_setup)( dev );
- if ( i < 0 )
- return i;
-#endif
+ if (dev->driver_features & DRIVER_HAVE_DMA)
+ {
+ i = DRM(dma_setup)( dev );
+ if ( i < 0 )
+ return i;
+ }
dev->counters = 6 + __HAVE_COUNTERS;
dev->types[0] = _DRM_STAT_LOCK;
if (dev->fn_tbl.pretakedown)
dev->fn_tbl.pretakedown(dev);
-#if __HAVE_IRQ
+
if ( dev->irq_enabled ) DRM(irq_uninstall)( dev );
-#endif
down( &dev->struct_sem );
del_timer( &dev->timer );
dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
}
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
/* Clear AGP information */
- if ( dev->agp ) {
+ if ( (dev->driver_features & DRIVER_USE_AGP) && dev->agp ) {
drm_agp_mem_t *entry;
drm_agp_mem_t *nexte;
*/
break;
case _DRM_SCATTER_GATHER:
- /* Handle it, but do nothing, if HAVE_SG
- * isn't defined.
- */
-#if __HAVE_SG
- if(dev->sg) {
+ /* Handle it */
+ if (dev->driver_features & DRIVER_SG && dev->sg) {
DRM(sg_cleanup)(dev->sg);
dev->sg = NULL;
}
-#endif
break;
}
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
}
}
-#if __HAVE_DMA_QUEUE || __HAVE_MULTIPLE_DMA_QUEUES
- if ( dev->queuelist ) {
+
+ if ( (dev->driver_features & DRIVER_DMA_QUEUE) && dev->queuelist ) {
for ( i = 0 ; i < dev->queue_count ; i++ ) {
if (dev->fn_tbl.waitlist_destroy)
dev->fn_tbl.waitlist_destroy( &dev->queuelist[i]->waitlist);
dev->queuelist = NULL;
}
dev->queue_count = 0;
-#endif
-#if __HAVE_DMA
- DRM(dma_takedown)( dev );
-#endif
+ if (dev->driver_features & DRIVER_HAVE_DMA)
+ DRM(dma_takedown)( dev );
+
if ( dev->lock.hw_lock ) {
dev->sigdata.lock = dev->lock.hw_lock = NULL; /* SHM removed */
dev->lock.filp = NULL;
return 0;
}
+static void DRM(init_fn_table)(struct drm_device *dev)
+{
+ dev->fn_tbl.reclaim_buffers = DRM(core_reclaim_buffers);
+ dev->fn_tbl.get_map_ofs = DRM(core_get_map_ofs);
+ dev->fn_tbl.get_reg_ofs = DRM(core_get_reg_ofs);
+}
+
#include "drm_pciids.h"
static struct pci_device_id DRM(pciidlist)[] = {
/* dev_priv_size can be changed by a driver in driver_register_fns */
dev->dev_priv_size = sizeof(u32);
- DRM(driver_register_fns)(dev);
+
+ DRM(init_fn_table)(dev);
+ DRM(driver_register_fns)(dev);
+
+ /* if we have CTX_BITMAP add the ioctls */
+ DRM(context_add_ioctls)();
+
if (dev->fn_tbl.preinit)
if ((retcode = dev->fn_tbl.preinit(dev, ent->driver_data)))
goto error_out_unreg;
-#if __REALLY_HAVE_AGP
- dev->agp = DRM(agp_init)();
-#if __MUST_HAVE_AGP
- if ( dev->agp == NULL ) {
- DRM_ERROR( "Cannot initialize the agpgart module.\n" );
- retcode = -EINVAL;
- goto error_out_unreg;
+#if __OS_HAS_AGP
+ if (dev->driver_features & DRIVER_USE_AGP) {
+ dev->agp = DRM(agp_init)();
+ if ( (dev->driver_features & DRIVER_REQUIRE_AGP) && dev->agp == NULL ) {
+ DRM_ERROR( "Cannot initialize the agpgart module.\n" );
+ retcode = -EINVAL;
+ goto error_out_unreg;
+ }
+
+#if __OS_HAS_MTRR
+ if (dev->driver_features & DRIVER_USE_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
-#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 __HAVE_CTX_BITMAP
retcode = DRM(ctxbitmap_init)( dev );
if( retcode ) {
- DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
- goto error_out_unreg;
- }
-#endif
+ DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
+ goto error_out_unreg;
+ }
+
if ((dev->minor = DRM(stub_register)(DRIVER_NAME, &DRM(fops),dev)) < 0)
{
retcode = -EPERM;
break;
case _DRM_FRAME_BUFFER:
-#if __REALLY_HAVE_MTRR
- if ( map->mtrr >= 0 ) {
- int retcode;
- retcode = mtrr_del( map->mtrr,
- map->offset,
- map->size );
- DRM_DEBUG( "mtrr_del=%d\n", retcode );
+#if __OS_HAS_MTRR
+ if ( dev->driver_features & DRIVER_USE_MTRR) {
+ if ( map->mtrr >= 0 ) {
+ int retcode;
+ retcode = mtrr_del( map->mtrr,
+ map->offset,
+ map->size );
+ DRM_DEBUG( "mtrr_del=%d\n", retcode );
+ }
}
#endif
break;
} else {
DRM_DEBUG( "minor %d unregistered\n", dev->minor);
}
-#if __HAVE_CTX_BITMAP
+
DRM(ctxbitmap_cleanup)( dev );
-#endif
-#if __REALLY_HAVE_AGP && __REALLY_HAVE_MTRR
- if ( dev->agp && dev->agp->agp_mtrr >= 0) {
+
+#if __OS_HAS_AGP
+#if __OS_HAS_MTRR
+ if ( (dev->driver_features & DRIVER_USE_MTRR) && dev->agp && dev->agp->agp_mtrr >= 0 ) {
int retval;
retval = mtrr_del( dev->agp->agp_mtrr,
dev->agp->agp_info.aper_base,
DRM_DEBUG( "mtrr_del=%d\n", retval );
}
#endif
-#if __REALLY_HAVE_AGP
- if ( dev->agp ) {
+ if ( (dev->driver_features & DRIVER_USE_AGP) && dev->agp ) {
DRM(agp_uninit)();
DRM(free)( dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS );
dev->agp = NULL;
}
}
-#if __HAVE_DMA
- DRM(reclaim_buffers)( filp );
-#endif
+ if (dev->driver_features & DRIVER_HAVE_DMA)
+ {
+ dev->fn_tbl.reclaim_buffers(filp);
+ }
DRM(fasync)( -1, filp, 0 );
pos->handle != DRM_KERNEL_CONTEXT ) {
if (dev->fn_tbl.context_dtor)
dev->fn_tbl.context_dtor(dev, pos->handle);
-#if __HAVE_CTX_BITMAP
+
DRM(ctxbitmap_free)( dev, pos->handle );
-#endif
+
list_del( &pos->head );
DRM(free)( pos, sizeof(*pos), DRM_MEM_CTXLIST );
--dev->ctx_count;
}
up( &dev->struct_sem );
+ if (dev->fn_tbl.free_filp_private)
+ dev->fn_tbl.free_filp_private( dev, priv );
DRM(free)( priv, sizeof(*priv), DRM_MEM_FILES );
/* ========================================================
DECLARE_WAITQUEUE( entry, current );
drm_lock_t lock;
int ret = 0;
-#if __HAVE_MULTIPLE_DMA_QUEUES
- drm_queue_t *q;
-#endif
++priv->lock_count;
lock.context, current->pid,
dev->lock.hw_lock->lock, lock.flags );
-#if __HAVE_DMA_QUEUE
- if ( lock.context < 0 )
- return -EINVAL;
-#elif __HAVE_MULTIPLE_DMA_QUEUES
- if ( lock.context < 0 || lock.context >= dev->queue_count )
- return -EINVAL;
- q = dev->queuelist[lock.context];
-#endif
+ if (dev->driver_features & DRIVER_DMA_QUEUE)
+ if ( lock.context < 0 )
+ return -EINVAL;
if (dev->fn_tbl.dma_flush_block_and_flush)
ret = dev->fn_tbl.dma_flush_block_and_flush(dev, lock.context, lock.flags);
{
int minor = iminor(inode);
drm_file_t *priv;
+ int ret;
if (filp->f_flags & O_EXCL) return -EBUSY; /* No exclusive opens */
if (!DRM(cpu_valid)()) return -EINVAL;
priv->lock_count = 0;
if (dev->fn_tbl.open_helper)
- dev->fn_tbl.open_helper(dev, priv);
+ {
+ ret=dev->fn_tbl.open_helper(dev, priv);
+ if (ret < 0)
+ goto out_free;
+ }
down(&dev->struct_sem);
if (!dev->file_last) {
#endif
return 0;
+ out_free:
+ DRM(free)(priv, sizeof(*priv), DRM_MEM_FILES);
+ return ret;
}
/** No-op. */
if (sv.drm_dd_major != DRIVER_MAJOR ||
sv.drm_dd_minor < 0 || sv.drm_dd_minor > DRIVER_MINOR)
return EINVAL;
-#ifdef DRIVER_SETVERSION
- DRIVER_SETVERSION(dev, &sv);
-#endif
+
+ if (dev->fn_tbl.set_version)
+ dev->fn_tbl.set_version(dev, &sv);
+
}
return 0;
}
#include <linux/interrupt.h> /* For task queue support */
-#ifndef __HAVE_SHARED_IRQ
-#define __HAVE_SHARED_IRQ 0
-#endif
-
-#if __HAVE_SHARED_IRQ
-#define DRM_IRQ_TYPE SA_SHIRQ
-#else
-#define DRM_IRQ_TYPE 0
-#endif
-
/**
* Get interrupt from bus id.
*
drm_irq_busid_t __user *argp = (void __user *)arg;
drm_irq_busid_t p;
+ if (!(dev->driver_features & DRIVER_HAVE_IRQ))
+ return -EINVAL;
+
if (copy_from_user(&p, argp, sizeof(p)))
return -EFAULT;
return 0;
}
-#if __HAVE_IRQ
-
/**
* Install IRQ handler.
*
int DRM(irq_install)( drm_device_t *dev )
{
int ret;
-
+ unsigned long sh_flags=0;
+
+ if (!(dev->driver_features & DRIVER_HAVE_IRQ ))
+ return -EINVAL;
+
if ( dev->irq == 0 )
return -EINVAL;
DRM_DEBUG( "%s: irq=%d\n", __FUNCTION__, dev->irq );
-#if __HAVE_DMA
dev->dma->next_buffer = NULL;
dev->dma->next_queue = NULL;
dev->dma->this_buffer = NULL;
-#endif
-
-#ifdef __HAVE_IRQ_BH
-#if !HAS_WORKQUEUE
- INIT_LIST_HEAD( &dev->tq.list );
- dev->tq.sync = 0;
- dev->tq.routine = DRM(irq_immediate_bh);
- dev->tq.data = dev;
-#else
- INIT_WORK(&dev->work, DRM(irq_immediate_bh), dev);
-#endif
-#endif
-
-#ifdef __HAVE_VBL_IRQ
- init_waitqueue_head(&dev->vbl_queue);
- spin_lock_init( &dev->vbl_lock );
-
- INIT_LIST_HEAD( &dev->vbl_sigs.head );
-
- dev->vbl_pending = 0;
-#endif
+ if (dev->driver_features & DRIVER_IRQ_VBL) {
+ init_waitqueue_head(&dev->vbl_queue);
+
+ spin_lock_init( &dev->vbl_lock );
+
+ INIT_LIST_HEAD( &dev->vbl_sigs.head );
+
+ dev->vbl_pending = 0;
+ }
/* Before installing handler */
- DRM(driver_irq_preinstall)(dev);
+ dev->fn_tbl.irq_preinstall(dev);
/* Install handler */
- ret = request_irq( dev->irq, DRM(irq_handler),
- DRM_IRQ_TYPE, dev->devname, dev );
+ if (dev->driver_features & DRIVER_IRQ_SHARED)
+ sh_flags = SA_SHIRQ;
+
+ ret = request_irq( dev->irq, dev->fn_tbl.irq_handler,
+ sh_flags, dev->devname, dev );
if ( ret < 0 ) {
down( &dev->struct_sem );
dev->irq_enabled = 0;
}
/* After installing handler */
- DRM(driver_irq_postinstall)(dev);
+ dev->fn_tbl.irq_postinstall(dev);
return 0;
}
{
int irq_enabled;
+ if (!(dev->driver_features & DRIVER_HAVE_IRQ ))
+ return -EINVAL;
+
down( &dev->struct_sem );
irq_enabled = dev->irq_enabled;
dev->irq_enabled = 0;
DRM_DEBUG( "%s: irq=%d\n", __FUNCTION__, dev->irq );
- DRM(driver_irq_uninstall)( dev );
+ dev->fn_tbl.irq_uninstall(dev);
free_irq( dev->irq, dev );
drm_file_t *priv = filp->private_data;
drm_device_t *dev = priv->dev;
drm_control_t ctl;
+
+ /* if we haven't dma then no need for this control */
+ if (!(dev->driver_features & DRIVER_HAVE_DMA))
+ return -EINVAL;
+
+ /* if we haven't irq we fallback for compatibility reasons - this used to be a separate function in drm_dma.h */
if ( copy_from_user( &ctl, (drm_control_t __user *)arg, sizeof(ctl) ) )
return -EFAULT;
switch ( ctl.func ) {
case DRM_INST_HANDLER:
+ if (!(dev->driver_features & DRIVER_HAVE_IRQ))
+ return 0;
if (dev->if_version < DRM_IF_VERSION(1, 2) &&
ctl.irq != dev->irq)
return -EINVAL;
return DRM(irq_install)( dev );
case DRM_UNINST_HANDLER:
+ if (!(dev->driver_features & DRIVER_HAVE_IRQ))
+ return 0;
return DRM(irq_uninstall)( dev );
default:
return -EINVAL;
}
}
-#ifdef __HAVE_VBL_IRQ
-
/**
* Wait for VBLANK.
*
int ret = 0;
unsigned int flags;
+ if (!(dev->driver_features & DRIVER_IRQ_VBL))
+ return -EINVAL;
+
if (!dev->irq)
return -EINVAL;
spin_unlock_irqrestore( &dev->vbl_lock, irqflags );
} else {
- ret = DRM(vblank_wait)( dev, &vblwait.request.sequence );
+ if (dev->fn_tbl.vblank_wait)
+ ret = dev->fn_tbl.vblank_wait( dev, &vblwait.request.sequence );
do_gettimeofday( &now );
vblwait.reply.tval_sec = now.tv_sec;
spin_unlock_irqrestore( &dev->vbl_lock, flags );
}
-#endif /* __HAVE_VBL_IRQ */
-#endif /* __HAVE_IRQ */
#define DEBUG_MEMORY 0
/* Need the 4-argument version of vmap(). */
-#if __REALLY_HAVE_AGP && defined(VMAP_4_ARGS)
+#if __OS_HAS_AGP && defined(VMAP_4_ARGS)
#include <linux/vmalloc.h>
return pte_pfn(*ptep) << PAGE_SHIFT;
}
-#endif /* __REALLY_HAVE_AGP && defined(VMAP_4_ARGS) */
+#endif /* __OS_HAS_AGP && defined(VMAP_4_ARGS) */
static inline void *drm_ioremap(unsigned long offset, unsigned long size, drm_device_t *dev)
{
-#if __REALLY_HAVE_AGP && defined(VMAP_4_ARGS)
- if (dev->agp && dev->agp->cant_use_aperture) {
+#if __OS_HAS_AGP && defined(VMAP_4_ARGS)
+ if ( (dev->driver_features & DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture) {
drm_map_t *map = drm_lookup_map(offset, size, dev);
if (map && map->type == _DRM_AGP)
static inline void *drm_ioremap_nocache(unsigned long offset, unsigned long size,
drm_device_t *dev)
{
-#if __REALLY_HAVE_AGP && defined(VMAP_4_ARGS)
- if (dev->agp && dev->agp->cant_use_aperture) {
+#if __OS_HAS_AGP&& defined(VMAP_4_ARGS)
+ if ( (dev->driver_features & DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture) {
drm_map_t *map = drm_lookup_map(offset, size, dev);
if (map && map->type == _DRM_AGP)
static inline void drm_ioremapfree(void *pt, unsigned long size, drm_device_t *dev)
{
-#if __REALLY_HAVE_AGP && defined(VMAP_4_ARGS)
+#if __OS_HAS_AGP && defined(VMAP_4_ARGS)
/*
* This is a bit ugly. It would be much cleaner if the DRM API would use separate
* routines for handling mappings in the AGP space. Hopefully this can be done in
* a future revision of the interface...
*/
- if (dev->agp && dev->agp->cant_use_aperture
+ if ((dev->driver_features & DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture
&& ((unsigned long) pt >= VMALLOC_START && (unsigned long) pt < VMALLOC_END))
{
unsigned long offset;
drm_ioremapfree(pt, size, dev);
}
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
/** Wrapper around agp_allocate_memory() */
DRM_AGP_MEM *DRM(alloc_agp)(int pages, u32 type)
{
}
}
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
DRM_AGP_MEM *DRM(alloc_agp)(int pages, u32 type)
{
DRM_DEBUG( "%s\n", __FUNCTION__ );
+ if ( dev->driver_features & DRIVER_SG )
+ return -EINVAL;
+
if ( dev->sg )
return -EINVAL;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
+ if ( dev->driver_features & DRIVER_SG )
+ return -EINVAL;
+
if ( copy_from_user( &request,
(drm_scatter_gather_t __user *)arg,
sizeof(request) ) )
static __inline__ struct page *DRM(do_vm_nopage)(struct vm_area_struct *vma,
unsigned long address)
{
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
drm_file_t *priv = vma->vm_file->private_data;
drm_device_t *dev = priv->dev;
drm_map_t *map = NULL;
/*
* Find the right map
*/
+ if (!(dev->agp && DRIVER_USE_AGP)) goto vm_nopage_error;
if(!dev->agp || !dev->agp->cant_use_aperture) goto vm_nopage_error;
return page;
}
vm_nopage_error:
-#endif /* __REALLY_HAVE_AGP */
+#endif /* __OS_HAS_AGP */
return NOPAGE_SIGBUS; /* Disallow mremap */
}
switch (map->type) {
case _DRM_REGISTERS:
case _DRM_FRAME_BUFFER:
-#if __REALLY_HAVE_MTRR
- if (map->mtrr >= 0) {
+#if __OS_HAS_MTRR
+ if ((dev->driver_features & DRIVER_USE_MTRR) && map->mtrr >= 0) {
int retcode;
retcode = mtrr_del(map->mtrr,
map->offset,
return 0;
}
-#ifndef DRIVER_GET_MAP_OFS
-#define DRIVER_GET_MAP_OFS() (map->offset)
-#endif
+unsigned long DRM(core_get_map_ofs)(drm_map_t *map)
+{
+ return map->offset;
+}
-#ifndef DRIVER_GET_REG_OFS
+unsigned long DRM(core_get_reg_ofs)(struct drm_device *dev)
+{
#ifdef __alpha__
-#define DRIVER_GET_REG_OFS() (dev->hose->dense_mem_base - \
- dev->hose->mem_space->start)
+ return dev->host->dense_mem_base - dev->hose_mem_space->start;
#else
-#define DRIVER_GET_REG_OFS() 0
-#endif
+ return 0;
#endif
+}
/**
* mmap DMA memory.
* --BenH.
*/
if (!VM_OFFSET(vma)
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
&& (!dev->agp || dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE)
#endif
)
r_list = list_entry(list, drm_map_list_t, head);
map = r_list->map;
if (!map) continue;
- off = DRIVER_GET_MAP_OFS();
+ off = dev->fn_tbl.get_map_ofs(map);
if (off == VM_OFFSET(vma)) break;
}
switch (map->type) {
case _DRM_AGP:
-#if __REALLY_HAVE_AGP
- if (dev->agp->cant_use_aperture) {
+#if __OS_HAS_AGP
+ if ((dev->driver_features & DRIVER_USE_AGP) && dev->agp->cant_use_aperture) {
/*
* On some platforms we can't talk to bus dma address from the CPU, so for
* memory of type DRM_AGP, we'll deal with sorting out the real physical
if (map->type != _DRM_AGP)
vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
#endif
- offset = DRIVER_GET_REG_OFS();
+ offset = dev->fn_tbl.get_reg_ofs(dev);
#ifdef __sparc__
if (io_remap_page_range(DRM_RPR_ARG(vma) vma->vm_start,
VM_OFFSET(vma) + offset,
wake_up_interruptible(&dev->lock.lock_queue);
}
+static unsigned long ffb_driver_get_map_ofs(drm_map_t *map)
+{
+ return (map->offset & 0xffffffff);
+}
+
+static unsigned long ffb_driver_get_reg_ofs(drm_device_t *dev)
+{
+ ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
+
+ if (ffb_priv)
+ return ffb_priv->card_phys_base;
+
+ return 0;
+}
+
static void ffb_driver_register_fns(drm_device_t *dev)
{
DRM(fops).get_unmapped_area = ffb_get_unmapped_area;
dev->fn_tbl.postcleanup = ffb_driver_postcleanup;
dev->fn_tbl.kernel_context_switch = ffb_context_switch;
dev->fn_tbl.kernel_context_switch_unlock = ffb_driver_kernel_context_switch_unlock;
+ dev->fn_tbl.get_map_ofs = ffb_driver_get_map_ofs;
+ dev->fn_tbl.get_reg_ofs = ffb_driver_get_reg_ofs;
+
}
#define DRIVER_COUNT_CARDS() ffb_count_card_instances()
-/* For mmap customization */
-#define DRIVER_GET_MAP_OFS() (map->offset & 0xffffffff)
-#define DRIVER_GET_REG_OFS() ffb_get_reg_offset(dev)
-
typedef struct _ffb_position_t {
int node;
int root;
return addr;
}
-static unsigned long ffb_get_reg_offset(drm_device_t *dev)
-{
- ffb_dev_priv_t *ffb_priv = (ffb_dev_priv_t *)dev->dev_private;
-
- if (ffb_priv)
- return ffb_priv->card_phys_base;
-
- return 0;
-}
-
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_dma.h"
/* General customization:
*/
-#define __HAVE_MTRR 1
-
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRIVER_NAME "gamma"
/* DMA customization:
*/
-#define __HAVE_DMA 1
-#define __HAVE_AGP 1
-#define __MUST_HAVE_AGP 0
-#define __HAVE_OLD_DMA 1
-#define __HAVE_PCI_DMA 1
-
#define __HAVE_MULTIPLE_DMA_QUEUES 1
#define __HAVE_DMA_WAITQUEUE 1
-#define __HAVE_IRQ 1
+
#define __HAVE_IRQ_BH 1
+#error "Gamma is broken"
+
#endif /* __GAMMA_H__ */
return 0;
}
+void DRM(ctxbitmap_free)( drm_device_t *dev, int ctx_handle )
+{
+
+}
+
+void DRM(ctxbitmap_cleanup)( drm_device_t *dev )
+{
+
+}
+
+int DRM(ctxbitmap_init)( drm_device_t *dev )
+{
+ return 0;
+}
return (!GAMMA_READ(GAMMA_DMACOUNT));
}
-irqreturn_t gamma_irq_handler( DRM_IRQ_ARGS )
+irqreturn_t gamma_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *)arg;
drm_device_dma_t *dma = dev->dma;
{
DRM_DEBUG( "%s\n", __FUNCTION__ );
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
- if ( dev->irq_enabled ) DRM(irq_uninstall)(dev);
-#endif
+ if ( dev->driver_features & DRIVER_HAVE_IRQ )
+ if ( dev->irq_enabled )
+ DRM(irq_uninstall)(dev);
if ( dev->dev_private ) {
return 0;
}
-void DRM(driver_irq_preinstall)( drm_device_t *dev ) {
+void gamma_driver_irq_preinstall( drm_device_t *dev ) {
drm_gamma_private_t *dev_priv =
(drm_gamma_private_t *)dev->dev_private;
GAMMA_WRITE( GAMMA_GDMACONTROL, 0x00000000 );
}
-void DRM(driver_irq_postinstall)( drm_device_t *dev ) {
+void gamma_driver_irq_postinstall( drm_device_t *dev ) {
drm_gamma_private_t *dev_priv =
(drm_gamma_private_t *)dev->dev_private;
GAMMA_WRITE( GAMMA_GDELAYTIMER, 0x00039090 );
}
-void DRM(driver_irq_uninstall)( drm_device_t *dev ) {
+void gamma_driver_irq_uninstall( drm_device_t *dev ) {
drm_gamma_private_t *dev_priv =
(drm_gamma_private_t *)dev->dev_private;
if (!dev_priv)
void gamma_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ;
DRM(fops).read = gamma_fops_read;
DRM(fops).poll = gamma_fops_poll;
dev->fn_tbl.preinit = gamma_driver_preinit;
dev->fn_tbl.freelist_create = gamma_freelist_create;
dev->fn_tbl.freelist_put = gamma_freelist_put;
dev->fn_tbl.freelist_destroy = gamma_freelist_destroy;
+ dev->fn_tbl.irq_preinstall = gamma_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = gamma_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = gamma_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = gamma_driver_irq_handler;
}
#include "drm_agpsupport.h"
#include "drm_bufs.h"
#include "gamma_context.h" /* NOTE! */
+#define DRIVER_ALTERNATE_CONTEXT
+#include "drm_context.h"
#include "drm_dma.h"
#include "gamma_old_dma.h" /* NOTE */
#include "drm_drawable.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
/* General customization:
*/
-#define __HAVE_AGP 1
-#define __MUST_HAVE_AGP 1
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#define __HAVE_COUNTER9 _DRM_STAT_DMA
-/* DMA customization:
- */
-#define __HAVE_DMA 1
-#define __HAVE_DMA_QUEUE 1
-#define __HAVE_DMA_RECLAIM 1
-
-/* Don't need an irq any more. The template code will make sure that
- * a noop stub is generated for compatibility.
- */
-/* XXX: Add vblank support? */
-#define __HAVE_IRQ 0
-
#endif
{
drm_device_dma_t *dma = dev->dma;
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
- if ( dev->irq_enabled ) DRM(irq_uninstall)(dev);
-#endif
+ if ( (dev->driver_features & DRIVER_HAVE_IRQ) && dev->irq_enabled )
+ DRM(irq_uninstall)(dev);
if (dev->dev_private) {
int i;
void i810_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_DMA | DRIVER_DMA_QUEUE;
dev->dev_priv_size = sizeof(drm_i810_buf_priv_t);
dev->fn_tbl.pretakedown = i810_driver_pretakedown;
dev->fn_tbl.release = i810_driver_release;
dev->fn_tbl.dma_quiescent = i810_driver_dma_quiescent;
+ dev->fn_tbl.reclaim_buffers = i810_reclaim_buffers;
}
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
+#include "drm_irq.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
/* General customization:
*/
-#define __HAVE_AGP 1
-#define __MUST_HAVE_AGP 1
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
#define __HAVE_COUNTER9 _DRM_STAT_DMA
-/* DMA customization:
- */
-#define __HAVE_DMA 1
-#define __HAVE_DMA_QUEUE 1
-#define __HAVE_DMA_RECLAIM 1
-
/* Driver will work either way: IRQ's save cpu time when waiting for
* the card, but are subject to subtle interactions between bios,
* hardware and the driver.
/* XXX: Add vblank support? */
#define USE_IRQS 0
-#if USE_IRQS
-#define __HAVE_IRQ 1
-#define __HAVE_SHARED_IRQ 1
-#else
-#define __HAVE_IRQ 0
-#endif
-
#endif
{
drm_device_dma_t *dma = dev->dma;
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
if (dev->irq_enabled) DRM(irq_uninstall)(dev);
-#endif
if (dev->dev_private) {
int i;
void i830_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_DMA | DRIVER_DMA_QUEUE;
+#if USE_IRQS
+ dev->driver_features |= DRIVER_HAVE_IRQ | DRIVER_SHARED_IRQ;
+#endif
dev->dev_priv_size = sizeof(drm_i830_buf_priv_t);
dev->fn_tbl.pretakedown = i830_driver_pretakedown;
dev->fn_tbl.release = i830_driver_release;
dev->fn_tbl.dma_quiescent = i830_driver_dma_quiescent;
+ dev->fn_tbl.reclaim_buffers = i830_reclaim_buffers;
+#if USE_IRQS
+ dev->fn_tbl.irq_preinstall = i830_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = i830_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = i830_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = i830_driver_irq_handler;
+#endif
}
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
extern int i830_wait_irq(drm_device_t *dev, int irq_nr);
extern int i830_emit_irq(drm_device_t *dev);
+extern irqreturn_t i830_driver_irq_handler( DRM_IRQ_ARGS );
+extern void i830_driver_irq_preinstall( drm_device_t *dev );
+extern void i830_driver_irq_postinstall( drm_device_t *dev );
+extern void i830_driver_irq_uninstall( drm_device_t *dev );
#define I830_BASE(reg) ((unsigned long) \
dev_priv->mmio_map->handle)
#include <linux/delay.h>
-irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS )
+irqreturn_t i830_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *)arg;
drm_i830_private_t *dev_priv = (drm_i830_private_t *)dev->dev_private;
/* drm_dma.h hooks
*/
-void DRM(driver_irq_preinstall)( drm_device_t *dev ) {
+void i830_driver_irq_preinstall( drm_device_t *dev ) {
drm_i830_private_t *dev_priv =
(drm_i830_private_t *)dev->dev_private;
init_waitqueue_head(&dev_priv->irq_queue);
}
-void DRM(driver_irq_postinstall)( drm_device_t *dev ) {
+void i830_driver_irq_postinstall( drm_device_t *dev ) {
drm_i830_private_t *dev_priv =
(drm_i830_private_t *)dev->dev_private;
I830_WRITE16( I830REG_INT_ENABLE_R, 0x2 );
}
-void DRM(driver_irq_uninstall)( drm_device_t *dev ) {
+void i830_driver_irq_uninstall( drm_device_t *dev ) {
drm_i830_private_t *dev_priv =
(drm_i830_private_t *)dev->dev_private;
if (!dev_priv)
#include "drm_bufs.h"
#include "drm_context.h" /* is this needed? */
#include "drm_drawable.h" /* is this needed? */
+#include "drm_dma.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
*/
#define DRM(x) savage_##x
-/* General customization:
- */
-#define __HAVE_AGP 1
-#define __MUST_HAVE_AGP 1
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
-
#endif
void DRM(driver_register_fns)(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR;
}
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
+#include "drm_irq.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
#include "drm_drv.h"
#include "drm_fops.h"
#include "drm_init.h"
+#include "drm_irq.h"
#include "drm_ioctl.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
#include "tdfx.h"
#include "drmP.h"
+#include "drm_agpsupport.h"
#include "drm_auth.h"
#include "drm_bufs.h"
#include "drm_context.h"
#include "drm_fops.h"
#include "drm_init.h"
#include "drm_ioctl.h"
+#include "drm_irq.h"
#include "drm_lock.h"
#include "drm_memory.h"
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
void DRM(driver_register_fns)(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_MTRR;
}
void i915_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED;
dev->fn_tbl.pretakedown = i915_driver_pretakedown;
dev->fn_tbl.prerelease = i915_driver_prerelease;
+ dev->fn_tbl.irq_preinstall = i915_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = i915_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = i915_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = i915_driver_irq_handler;
}
extern int i915_wait_irq(drm_device_t *dev, int irq_nr);
extern int i915_emit_irq(drm_device_t *dev);
+extern irqreturn_t i915_driver_irq_handler( DRM_IRQ_ARGS );
+extern void i915_driver_irq_preinstall( drm_device_t *dev );
+extern void i915_driver_irq_postinstall( drm_device_t *dev );
+extern void i915_driver_irq_uninstall( drm_device_t *dev );
/* i915_mem.c */
extern int i915_mem_alloc( DRM_IOCTL_ARGS );
#define READ_BREADCRUMB(dev_priv) (((u32*)(dev_priv->hw_status_page))[5])
-irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS )
+irqreturn_t i915_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *)arg;
drm_i915_private_t *dev_priv = (drm_i915_private_t *)dev->dev_private;
/* drm_dma.h hooks
*/
-void DRM(driver_irq_preinstall)( drm_device_t *dev ) {
+void i915_driver_irq_preinstall( drm_device_t *dev ) {
drm_i915_private_t *dev_priv =
(drm_i915_private_t *)dev->dev_private;
I915_WRITE16( I915REG_INT_ENABLE_R, 0x0 );
}
-void DRM(driver_irq_postinstall)( drm_device_t *dev ) {
+void i915_driver_irq_postinstall( drm_device_t *dev ) {
drm_i915_private_t *dev_priv =
(drm_i915_private_t *)dev->dev_private;
DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
}
-void DRM(driver_irq_uninstall)( drm_device_t *dev ) {
+void i915_driver_irq_uninstall( drm_device_t *dev ) {
drm_i915_private_t *dev_priv =
(drm_i915_private_t *)dev->dev_private;
if (!dev_priv)
{
DRM_DEBUG( "%s\n", __FUNCTION__ );
-#if _HAVE_DMA_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
if ( dev->irq ) DRM(irq_uninstall)(dev);
-#endif
if ( dev->dev_private ) {
drm_mach64_private_t *dev_priv = dev->dev_private;
void mach64_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL;
dev->fn_tbl.pretakedown = mach64_driver_pretakedown;
+ dev->fn_tbl.vblank_wait = mach64_driver_vblank_wait;
+ dev->fn_tbl.irq_preinstall = mach64_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = mach64_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = mach64_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = mach64_driver_irq_handler;
}
extern int mach64_dma_vertex( DRM_IOCTL_ARGS );
extern int mach64_dma_blit( DRM_IOCTL_ARGS );
extern int mach64_get_param( DRM_IOCTL_ARGS );
+extern int mach64_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence);
+
+extern irqreturn_t mach64_driver_irq_handler( DRM_IRQ_ARGS );
+extern void mach64_driver_irq_preinstall( drm_device_t *dev );
+extern void mach64_driver_irq_postinstall( drm_device_t *dev );
+extern void mach64_driver_irq_uninstall( drm_device_t *dev );
/* ================================================================
* Registers
#include "mach64_drm.h"
#include "mach64_drv.h"
-irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS )
+irqreturn_t mach64_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *) arg;
drm_mach64_private_t *dev_priv =
return IRQ_NONE;
}
-int DRM(vblank_wait)(drm_device_t *dev, unsigned int *sequence)
+int mach64_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
{
unsigned int cur_vblank;
int ret = 0;
/* drm_dma.h hooks
*/
-void DRM(driver_irq_preinstall)( drm_device_t *dev ) {
+void mach64_driver_irq_preinstall( drm_device_t *dev ) {
drm_mach64_private_t *dev_priv =
(drm_mach64_private_t *)dev->dev_private;
| MACH64_CRTC_VBLANK_INT );
}
-void DRM(driver_irq_postinstall)( drm_device_t *dev ) {
+void mach64_driver_irq_postinstall( drm_device_t *dev ) {
drm_mach64_private_t *dev_priv =
(drm_mach64_private_t *)dev->dev_private;
}
-void DRM(driver_irq_uninstall)( drm_device_t *dev ) {
+void mach64_driver_irq_uninstall( drm_device_t *dev ) {
drm_mach64_private_t *dev_priv =
(drm_mach64_private_t *)dev->dev_private;
if ( !dev_priv )
{
DRM_DEBUG( "\n" );
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
if ( dev->irq_enabled ) DRM(irq_uninstall)(dev);
-#endif
if ( dev->dev_private ) {
drm_mga_private_t *dev_priv = dev->dev_private;
void mga_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL;
dev->fn_tbl.pretakedown = mga_driver_pretakedown;
dev->fn_tbl.dma_quiescent = mga_driver_dma_quiescent;
+ dev->fn_tbl.vblank_wait = mga_driver_vblank_wait;
+ dev->fn_tbl.irq_preinstall = mga_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = mga_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = mga_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = mga_driver_irq_handler;
}
extern int mga_warp_install_microcode( drm_mga_private_t *dev_priv );
extern int mga_warp_init( drm_mga_private_t *dev_priv );
+extern int mga_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence);
+extern irqreturn_t mga_driver_irq_handler( DRM_IRQ_ARGS );
+extern void mga_driver_irq_preinstall( drm_device_t *dev );
+extern void mga_driver_irq_postinstall( drm_device_t *dev );
+extern void mga_driver_irq_uninstall( drm_device_t *dev );
+
#define mga_flush_write_combine() DRM_WRITEMEMORYBARRIER()
#if defined(__linux__) && defined(__alpha__)
#include "mga_drm.h"
#include "mga_drv.h"
-irqreturn_t mga_irq_handler( DRM_IRQ_ARGS )
+irqreturn_t mga_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *) arg;
drm_mga_private_t *dev_priv =
return IRQ_NONE;
}
-int mga_vblank_wait(drm_device_t *dev, unsigned int *sequence)
+int mga_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
{
unsigned int cur_vblank;
int ret = 0;
/* The manual (p. 2) says this address is in "VM space". This
* means it's an offset from the start of AGP space.
*/
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( !dev_priv->is_pci )
ring_start = dev_priv->cce_ring->offset - dev->agp->base;
else
(drm_r128_sarea_t *)((u8 *)dev_priv->sarea->handle +
init->sarea_priv_offset);
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( !dev_priv->is_pci ) {
drm_core_ioremap( dev_priv->cce_ring, dev );
drm_core_ioremap( dev_priv->ring_rptr, dev );
dev->agp_buffer_map->handle = (void *)dev->agp_buffer_map->offset;
}
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( !dev_priv->is_pci )
dev_priv->cce_buffers_offset = dev->agp->base;
else
R128_WRITE( R128_LAST_DISPATCH_REG,
dev_priv->sarea_priv->last_dispatch );
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( dev_priv->is_pci ) {
#endif
if (!DRM(ati_pcigart_init)( dev, &dev_priv->phys_pci_gart,
return DRM_ERR(ENOMEM);
}
R128_WRITE( R128_PCI_GART_PAGE, dev_priv->bus_pci_gart );
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
}
#endif
int r128_do_cleanup_cce( drm_device_t *dev )
{
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
if ( dev->irq_enabled ) DRM(irq_uninstall)(dev);
-#endif
if ( dev->dev_private ) {
drm_r128_private_t *dev_priv = dev->dev_private;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( !dev_priv->is_pci ) {
if ( dev_priv->cce_ring != NULL )
drm_core_ioremapfree( dev_priv->cce_ring, dev );
extern int r128_cce_stipple( DRM_IOCTL_ARGS );
extern int r128_cce_indirect( DRM_IOCTL_ARGS );
+extern int r128_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence);
+
+extern irqreturn_t r128_driver_irq_handler( DRM_IRQ_ARGS );
+extern void r128_driver_irq_preinstall( drm_device_t *dev );
+extern void r128_driver_irq_postinstall( drm_device_t *dev );
+extern void r128_driver_irq_uninstall( drm_device_t *dev );
/* Register definitions, register access macros and drmAddMap constants
* for Rage 128 kernel driver.
#include "r128_drm.h"
#include "r128_drv.h"
-irqreturn_t r128_irq_handler( DRM_IRQ_ARGS )
+irqreturn_t r128_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *) arg;
drm_r128_private_t *dev_priv =
return IRQ_NONE;
}
-int DRM(vblank_wait)(drm_device_t *dev, unsigned int *sequence)
+int r128_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
{
unsigned int cur_vblank;
int ret = 0;
void r128_driver_register_fns(drm_device_t *dev)
{
- dev->dev_priv_size = sizeof(drm_r128_buf_priv_t);
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_SG | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL;
+ dev->dev_priv_size = sizeof(drm_r128_buf_priv_t);
dev->fn_tbl.prerelease = r128_driver_prerelease;
dev->fn_tbl.pretakedown = r128_driver_pretakedown;
+ dev->fn_tbl.vblank_wait = r128_driver_vblank_wait;
+ dev->fn_tbl.irq_preinstall = r128_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = r128_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = r128_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = r128_driver_irq_handler;
}
( ( dev_priv->gart_vm_start - 1 ) & 0xffff0000 )
| ( dev_priv->fb_location >> 16 ) );
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP) {
RADEON_WRITE( RADEON_MC_AGP_LOCATION,
(((dev_priv->gart_vm_start - 1 +
SET_RING_HEAD( dev_priv, cur_read_ptr );
dev_priv->ring.tail = cur_read_ptr;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP) {
/* set RADEON_AGP_BASE here instead of relying on X from user space */
RADEON_WRITE( RADEON_AGP_BASE, (unsigned int)dev->agp->base );
(drm_radeon_sarea_t *)((u8 *)dev_priv->sarea->handle +
init->sarea_priv_offset);
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( dev_priv->flags & CHIP_IS_AGP ) {
drm_core_ioremap( dev_priv->cp_ring, dev );
drm_core_ioremap( dev_priv->ring_rptr, dev );
dev_priv->gart_vm_start = dev_priv->fb_location
+ RADEON_READ( RADEON_CONFIG_APER_SIZE );
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP)
dev_priv->gart_buffers_offset = (dev->agp_buffer_map->offset
- dev->agp->base
dev_priv->ring.high_mark = RADEON_RING_HIGH_MARK;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP) {
/* Turn off PCI GART */
radeon_set_pcigart( dev_priv, 0 );
drm_radeon_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
if ( dev->irq_enabled ) DRM(irq_uninstall)(dev);
-#endif
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP) {
if ( dev_priv->cp_ring != NULL ) {
drm_core_ioremapfree( dev_priv->cp_ring, dev );
DRM_DEBUG("Starting radeon_do_resume_cp()\n");
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP) {
/* Turn off PCI GART */
radeon_set_pcigart( dev_priv, 0 );
u32 se_cntl;
} drm_radeon_depth_clear_t;
+struct drm_radeon_driver_file_fields {
+ int64_t radeon_fb_delta;
+};
struct mem_block {
struct mem_block *next;
extern int radeon_emit_irq(drm_device_t *dev);
extern void radeon_do_release(drm_device_t *dev);
+extern int radeon_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence);
+extern irqreturn_t radeon_driver_irq_handler( DRM_IRQ_ARGS );
+extern void radeon_driver_irq_preinstall( drm_device_t *dev );
+extern void radeon_driver_irq_postinstall( drm_device_t *dev );
+extern void radeon_driver_irq_uninstall( drm_device_t *dev );
/* Flags for stats.boxes
*/
* tied to dma at all, this is just a hangover from dri prehistory.
*/
-irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS )
+irqreturn_t radeon_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *) arg;
drm_radeon_private_t *dev_priv =
}
-int DRM(vblank_wait)(drm_device_t *dev, unsigned int *sequence)
+int radeon_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
{
drm_radeon_private_t *dev_priv =
(drm_radeon_private_t *)dev->dev_private;
drm_file_t *filp_priv,
u32 *offset ) {
u32 off = *offset;
+ struct drm_radeon_driver_file_fields *radeon_priv;
if ( off >= dev_priv->fb_location &&
off < ( dev_priv->gart_vm_start + dev_priv->gart_size ) )
return 0;
- off += filp_priv->radeon_fb_delta;
+ radeon_priv = filp_priv->driver_priv;
+
+ off += radeon_priv->radeon_fb_delta;
DRM_DEBUG( "offset fixed up to 0x%x\n", off );
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_file_t *filp_priv;
drm_radeon_setparam_t sp;
-
+ struct drm_radeon_driver_file_fields *radeon_priv;
+
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
return DRM_ERR( EINVAL );
switch( sp.param ) {
case RADEON_SETPARAM_FB_LOCATION:
- filp_priv->radeon_fb_delta = dev_priv->fb_location - sp.value;
+ radeon_priv = filp_priv->driver_priv;
+ radeon_priv->radeon_fb_delta = dev_priv->fb_location - sp.value;
break;
default:
DRM_DEBUG( "Invalid parameter %d\n", sp.param );
radeon_do_release(dev);
}
-static void radeon_driver_open_helper(drm_device_t *dev, drm_file_t *filp_priv)
+static int radeon_driver_open_helper(drm_device_t *dev, drm_file_t *filp_priv)
{
drm_radeon_private_t *dev_priv = dev->dev_private;
+ struct drm_radeon_driver_file_fields *radeon_priv;
+
+ radeon_priv = (struct drm_radeon_driver_file_fields *)DRM(alloc)(sizeof(*radeon_priv), DRM_MEM_FILES);
+
+ if (!radeon_priv)
+ return -ENOMEM;
+
+ filp_priv->driver_priv = radeon_priv;
+
if ( dev_priv )
- filp_priv->radeon_fb_delta = dev_priv->fb_location;
+ radeon_priv->radeon_fb_delta = dev_priv->fb_location;
else
- filp_priv->radeon_fb_delta = 0;
+ radeon_priv->radeon_fb_delta = 0;
+ return 0;
+}
+
+static void radeon_driver_free_filp_private(drm_device_t *dev, drm_file_t *filp_priv)
+{
+ struct drm_radeon_driver_file_fields *radeon_priv = filp_priv->driver_priv;
+
+ DRM(free)(radeon_priv, sizeof(*radeon_priv), DRM_MEM_FILES);
}
void radeon_driver_register_fns(struct drm_device *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_SG | DRIVER_HAVE_IRQ | DRIVER_HAVE_DMA | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL;
dev->dev_priv_size = sizeof(drm_radeon_buf_priv_t);
dev->fn_tbl.preinit = radeon_preinit;
dev->fn_tbl.postinit = radeon_postinit;
dev->fn_tbl.prerelease = radeon_driver_prerelease;
dev->fn_tbl.pretakedown = radeon_driver_pretakedown;
dev->fn_tbl.open_helper = radeon_driver_open_helper;
+ dev->fn_tbl.vblank_wait = radeon_driver_vblank_wait;
+ dev->fn_tbl.irq_preinstall = radeon_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = radeon_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = radeon_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = radeon_driver_irq_handler;
+ dev->fn_tbl.free_filp_private = radeon_driver_free_filp_private;
}
void DRM(driver_register_fns)(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR;
dev->fn_tbl.context_ctor = sis_init_context;
dev->fn_tbl.context_dtor = sis_final_context;
}
/* General customization:
*/
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
extern int via_do_cleanup_map(drm_device_t *dev);
extern int via_map_init(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
+extern int via_driver_vblank_wait(drm_device_t* dev, unsigned int* sequence);
+
+extern irqreturn_t via_driver_irq_handler( DRM_IRQ_ARGS );
+extern void via_driver_irq_preinstall( drm_device_t *dev );
+extern void via_driver_irq_postinstall( drm_device_t *dev );
+extern void via_driver_irq_uninstall( drm_device_t *dev );
+
+extern int via_dma_cleanup(drm_device_t *dev);
extern int via_dma_cleanup(drm_device_t *dev);
#define VIA_IRQ_VBI_ENABLE (1 << 19)
#define VIA_IRQ_VBI_PENDING (1 << 3)
-irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS )
-
+irqreturn_t via_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t* dev = (drm_device_t*)arg;
drm_via_private_t* dev_priv = (drm_via_private_t*)dev->dev_private;
}
}
-int DRM(vblank_wait)(drm_device_t* dev, unsigned int* sequence)
+int via_driver_vblank_wait(drm_device_t* dev, unsigned int* sequence)
{
drm_via_private_t* dev_priv = (drm_via_private_t*)dev->dev_private;
unsigned int cur_vblank;
/*
* drm_dma.h hooks
*/
-void DRM(driver_irq_preinstall)(drm_device_t* dev){
+void via_driver_irq_preinstall(drm_device_t* dev){
drm_via_private_t* dev_priv = (drm_via_private_t *)dev->dev_private;
u32 status;
}
}
-void DRM(driver_irq_postinstall)(drm_device_t* dev){
+void via_driver_irq_postinstall(drm_device_t* dev){
drm_via_private_t* dev_priv = (drm_via_private_t *)dev->dev_private;
u32 status;
}
}
-void DRM(driver_irq_uninstall)(drm_device_t* dev){
+void via_driver_irq_uninstall(drm_device_t* dev){
drm_via_private_t* dev_priv = (drm_via_private_t *)dev->dev_private;
u32 status;
void DRM(driver_register_fns)(drm_device_t *dev)
{
- dev->fn_tbl.context_ctor = via_init_context;
- dev->fn_tbl.context_dtor = via_final_context;
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL;
+ dev->fn_tbl.context_ctor = via_init_context;
+ dev->fn_tbl.context_dtor = via_final_context;
+ dev->fn_tbl.vblank_wait = via_driver_vblank_wait;
+ dev->fn_tbl.irq_preinstall = via_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = via_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = via_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = via_driver_irq_handler;
}
/* General customization:
*/
-#define __HAVE_AGP 1
-#define __MUST_HAVE_AGP 1
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
#define DRIVER_AUTHOR "Tungsten Graphics, Inc."
/* We use our own dma mechanisms, not the drm template code. However,
* the shared IRQ code is useful to us:
*/
-#define __HAVE_DMA 0
-#define __HAVE_IRQ 1
-#define __HAVE_SHARED_IRQ 1
-
#define __HAVE_PM 1
void i915_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED;
dev->fn_tbl.pretakedown = i915_driver_pretakedown;
dev->fn_tbl.prerelease = i915_driver_prerelease;
+ dev->fn_tbl.irq_preinstall = i915_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = i915_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = i915_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = i915_driver_irq_handler;
}
extern int i915_wait_irq(drm_device_t *dev, int irq_nr);
extern int i915_emit_irq(drm_device_t *dev);
+extern irqreturn_t i915_driver_irq_handler( DRM_IRQ_ARGS );
+extern void i915_driver_irq_preinstall( drm_device_t *dev );
+extern void i915_driver_irq_postinstall( drm_device_t *dev );
+extern void i915_driver_irq_uninstall( drm_device_t *dev );
/* i915_mem.c */
extern int i915_mem_alloc( DRM_IOCTL_ARGS );
#define READ_BREADCRUMB(dev_priv) (((u32*)(dev_priv->hw_status_page))[5])
-irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS )
+irqreturn_t i915_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *)arg;
drm_i915_private_t *dev_priv = (drm_i915_private_t *)dev->dev_private;
/* drm_dma.h hooks
*/
-void DRM(driver_irq_preinstall)( drm_device_t *dev ) {
+void i915_driver_irq_preinstall( drm_device_t *dev ) {
drm_i915_private_t *dev_priv =
(drm_i915_private_t *)dev->dev_private;
I915_WRITE16( I915REG_INT_ENABLE_R, 0x0 );
}
-void DRM(driver_irq_postinstall)( drm_device_t *dev ) {
+void i915_driver_irq_postinstall( drm_device_t *dev ) {
drm_i915_private_t *dev_priv =
(drm_i915_private_t *)dev->dev_private;
DRM_INIT_WAITQUEUE(&dev_priv->irq_queue);
}
-void DRM(driver_irq_uninstall)( drm_device_t *dev ) {
+void i915_driver_irq_uninstall( drm_device_t *dev ) {
drm_i915_private_t *dev_priv =
(drm_i915_private_t *)dev->dev_private;
if (!dev_priv)
/* General customization:
*/
-#define __HAVE_AGP 1
-#define __MUST_HAVE_AGP 0
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
-#define __HAVE_PCI_DMA 1
#define DRIVER_AUTHOR "Gareth Hughes, Leif Delgass, José Fonseca"
[DRM_IOCTL_NR(DRM_IOCTL_MACH64_FLUSH)] = { mach64_dma_flush, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_MACH64_GETPARAM)] = { mach64_get_param, 1, 0 }
-/* DMA customization:
- */
-#define __HAVE_DMA 1
-#define __HAVE_DMA_IRQ 1
-#define __HAVE_VBL_IRQ 1
-#define __HAVE_SHARED_IRQ 1
-#define __HAVE_IRQ 1
-
#endif
{
DRM_DEBUG( "%s\n", __FUNCTION__ );
-#if _HAVE_DMA_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
if ( dev->irq ) DRM(irq_uninstall)(dev);
-#endif
if ( dev->dev_private ) {
drm_mach64_private_t *dev_priv = dev->dev_private;
void mach64_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL;
dev->fn_tbl.pretakedown = mach64_driver_pretakedown;
+ dev->fn_tbl.vblank_wait = mach64_driver_vblank_wait;
+ dev->fn_tbl.irq_preinstall = mach64_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = mach64_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = mach64_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = mach64_driver_irq_handler;
}
extern int mach64_dma_vertex( DRM_IOCTL_ARGS );
extern int mach64_dma_blit( DRM_IOCTL_ARGS );
extern int mach64_get_param( DRM_IOCTL_ARGS );
+extern int mach64_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence);
+
+extern irqreturn_t mach64_driver_irq_handler( DRM_IRQ_ARGS );
+extern void mach64_driver_irq_preinstall( drm_device_t *dev );
+extern void mach64_driver_irq_postinstall( drm_device_t *dev );
+extern void mach64_driver_irq_uninstall( drm_device_t *dev );
/* ================================================================
* Registers
#include "mach64_drm.h"
#include "mach64_drv.h"
-irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS )
+irqreturn_t mach64_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *) arg;
drm_mach64_private_t *dev_priv =
return IRQ_NONE;
}
-int DRM(vblank_wait)(drm_device_t *dev, unsigned int *sequence)
+int mach64_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
{
unsigned int cur_vblank;
int ret = 0;
/* drm_dma.h hooks
*/
-void DRM(driver_irq_preinstall)( drm_device_t *dev ) {
+void mach64_driver_irq_preinstall( drm_device_t *dev ) {
drm_mach64_private_t *dev_priv =
(drm_mach64_private_t *)dev->dev_private;
| MACH64_CRTC_VBLANK_INT );
}
-void DRM(driver_irq_postinstall)( drm_device_t *dev ) {
+void mach64_driver_irq_postinstall( drm_device_t *dev ) {
drm_mach64_private_t *dev_priv =
(drm_mach64_private_t *)dev->dev_private;
}
-void DRM(driver_irq_uninstall)( drm_device_t *dev ) {
+void mach64_driver_irq_uninstall( drm_device_t *dev ) {
drm_mach64_private_t *dev_priv =
(drm_mach64_private_t *)dev->dev_private;
if ( !dev_priv )
/* General customization:
*/
-#define __HAVE_AGP 1
-#define __MUST_HAVE_AGP 1
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
#define DRIVER_AUTHOR "Gareth Hughes, VA Linux Systems Inc."
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
-/* DMA customization:
- */
-#define __HAVE_DMA 1
-#define __HAVE_IRQ 1
-#define __HAVE_VBL_IRQ 1
-#define __HAVE_SHARED_IRQ 1
-
#endif
{
DRM_DEBUG( "\n" );
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
if ( dev->irq_enabled ) DRM(irq_uninstall)(dev);
-#endif
if ( dev->dev_private ) {
drm_mga_private_t *dev_priv = dev->dev_private;
void mga_driver_register_fns(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL;
dev->fn_tbl.pretakedown = mga_driver_pretakedown;
dev->fn_tbl.dma_quiescent = mga_driver_dma_quiescent;
+ dev->fn_tbl.vblank_wait = mga_driver_vblank_wait;
+ dev->fn_tbl.irq_preinstall = mga_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = mga_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = mga_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = mga_driver_irq_handler;
}
extern int mga_warp_install_microcode( drm_mga_private_t *dev_priv );
extern int mga_warp_init( drm_mga_private_t *dev_priv );
+extern int mga_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence);
+extern irqreturn_t mga_driver_irq_handler( DRM_IRQ_ARGS );
+extern void mga_driver_irq_preinstall( drm_device_t *dev );
+extern void mga_driver_irq_postinstall( drm_device_t *dev );
+extern void mga_driver_irq_uninstall( drm_device_t *dev );
+
#define mga_flush_write_combine() DRM_WRITEMEMORYBARRIER()
#if defined(__linux__) && defined(__alpha__)
#include "mga_drm.h"
#include "mga_drv.h"
-irqreturn_t mga_irq_handler( DRM_IRQ_ARGS )
+irqreturn_t mga_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *) arg;
drm_mga_private_t *dev_priv =
return IRQ_NONE;
}
-int mga_vblank_wait(drm_device_t *dev, unsigned int *sequence)
+int mga_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
{
unsigned int cur_vblank;
int ret = 0;
/* 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
#define DRIVER_AUTHOR "Gareth Hughes, VA Linux Systems Inc."
[DRM_IOCTL_NR(DRM_IOCTL_R128_GETPARAM)] = { r128_getparam, 1, 0 },
-/* DMA customization:
- */
-#define __HAVE_DMA 1
-#define __HAVE_IRQ 1
-#define __HAVE_VBL_IRQ 1
-#define __HAVE_SHARED_IRQ 1
-
#endif
/* The manual (p. 2) says this address is in "VM space". This
* means it's an offset from the start of AGP space.
*/
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( !dev_priv->is_pci )
ring_start = dev_priv->cce_ring->offset - dev->agp->base;
else
(drm_r128_sarea_t *)((u8 *)dev_priv->sarea->handle +
init->sarea_priv_offset);
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( !dev_priv->is_pci ) {
drm_core_ioremap( dev_priv->cce_ring, dev );
drm_core_ioremap( dev_priv->ring_rptr, dev );
dev->agp_buffer_map->handle = (void *)dev->agp_buffer_map->offset;
}
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( !dev_priv->is_pci )
dev_priv->cce_buffers_offset = dev->agp->base;
else
R128_WRITE( R128_LAST_DISPATCH_REG,
dev_priv->sarea_priv->last_dispatch );
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( dev_priv->is_pci ) {
#endif
if (!DRM(ati_pcigart_init)( dev, &dev_priv->phys_pci_gart,
return DRM_ERR(ENOMEM);
}
R128_WRITE( R128_PCI_GART_PAGE, dev_priv->bus_pci_gart );
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
}
#endif
int r128_do_cleanup_cce( drm_device_t *dev )
{
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
if ( dev->irq_enabled ) DRM(irq_uninstall)(dev);
-#endif
if ( dev->dev_private ) {
drm_r128_private_t *dev_priv = dev->dev_private;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( !dev_priv->is_pci ) {
if ( dev_priv->cce_ring != NULL )
drm_core_ioremapfree( dev_priv->cce_ring, dev );
extern int r128_cce_stipple( DRM_IOCTL_ARGS );
extern int r128_cce_indirect( DRM_IOCTL_ARGS );
+extern int r128_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence);
+
+extern irqreturn_t r128_driver_irq_handler( DRM_IRQ_ARGS );
+extern void r128_driver_irq_preinstall( drm_device_t *dev );
+extern void r128_driver_irq_postinstall( drm_device_t *dev );
+extern void r128_driver_irq_uninstall( drm_device_t *dev );
/* Register definitions, register access macros and drmAddMap constants
* for Rage 128 kernel driver.
#include "r128_drm.h"
#include "r128_drv.h"
-irqreturn_t r128_irq_handler( DRM_IRQ_ARGS )
+irqreturn_t r128_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *) arg;
drm_r128_private_t *dev_priv =
return IRQ_NONE;
}
-int DRM(vblank_wait)(drm_device_t *dev, unsigned int *sequence)
+int r128_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
{
unsigned int cur_vblank;
int ret = 0;
void r128_driver_register_fns(drm_device_t *dev)
{
- dev->dev_priv_size = sizeof(drm_r128_buf_priv_t);
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_SG | DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL;
+ dev->dev_priv_size = sizeof(drm_r128_buf_priv_t);
dev->fn_tbl.prerelease = r128_driver_prerelease;
dev->fn_tbl.pretakedown = r128_driver_pretakedown;
+ dev->fn_tbl.vblank_wait = r128_driver_vblank_wait;
+ dev->fn_tbl.irq_preinstall = r128_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = r128_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = r128_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = r128_driver_irq_handler;
}
/* 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
#define DRIVER_AUTHOR "Gareth Hughes, Keith Whitwell, others."
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_IRQ_WAIT)] = { radeon_irq_wait, 1, 0 }, \
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_SETPARAM)] = { radeon_cp_setparam, 1, 0 }, \
-#define DRIVER_FILE_FIELDS \
- int64_t radeon_fb_delta; \
-
-/* DMA customization:
- */
-#define __HAVE_DMA 1
-#define __HAVE_IRQ 1
-#define __HAVE_VBL_IRQ 1
-#define __HAVE_SHARED_IRQ 1
-
#endif
( ( dev_priv->gart_vm_start - 1 ) & 0xffff0000 )
| ( dev_priv->fb_location >> 16 ) );
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP) {
RADEON_WRITE( RADEON_MC_AGP_LOCATION,
(((dev_priv->gart_vm_start - 1 +
SET_RING_HEAD( dev_priv, cur_read_ptr );
dev_priv->ring.tail = cur_read_ptr;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP) {
/* set RADEON_AGP_BASE here instead of relying on X from user space */
RADEON_WRITE( RADEON_AGP_BASE, (unsigned int)dev->agp->base );
(drm_radeon_sarea_t *)((u8 *)dev_priv->sarea->handle +
init->sarea_priv_offset);
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if ( dev_priv->flags & CHIP_IS_AGP ) {
drm_core_ioremap( dev_priv->cp_ring, dev );
drm_core_ioremap( dev_priv->ring_rptr, dev );
dev_priv->gart_vm_start = dev_priv->fb_location
+ RADEON_READ( RADEON_CONFIG_APER_SIZE );
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP)
dev_priv->gart_buffers_offset = (dev->agp_buffer_map->offset
- dev->agp->base
dev_priv->ring.high_mark = RADEON_RING_HIGH_MARK;
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP) {
/* Turn off PCI GART */
radeon_set_pcigart( dev_priv, 0 );
drm_radeon_private_t *dev_priv = dev->dev_private;
DRM_DEBUG( "\n" );
-#if __HAVE_IRQ
/* Make sure interrupts are disabled here because the uninstall ioctl
* may not have been called from userspace and after dev_private
* is freed, it's too late.
*/
if ( dev->irq_enabled ) DRM(irq_uninstall)(dev);
-#endif
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP) {
if ( dev_priv->cp_ring != NULL ) {
drm_core_ioremapfree( dev_priv->cp_ring, dev );
DRM_DEBUG("Starting radeon_do_resume_cp()\n");
-#if __REALLY_HAVE_AGP
+#if __OS_HAS_AGP
if (dev_priv->flags & CHIP_IS_AGP) {
/* Turn off PCI GART */
radeon_set_pcigart( dev_priv, 0 );
u32 se_cntl;
} drm_radeon_depth_clear_t;
+struct drm_radeon_driver_file_fields {
+ int64_t radeon_fb_delta;
+};
struct mem_block {
struct mem_block *next;
extern int radeon_emit_irq(drm_device_t *dev);
extern void radeon_do_release(drm_device_t *dev);
+extern int radeon_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence);
+extern irqreturn_t radeon_driver_irq_handler( DRM_IRQ_ARGS );
+extern void radeon_driver_irq_preinstall( drm_device_t *dev );
+extern void radeon_driver_irq_postinstall( drm_device_t *dev );
+extern void radeon_driver_irq_uninstall( drm_device_t *dev );
/* Flags for stats.boxes
*/
* tied to dma at all, this is just a hangover from dri prehistory.
*/
-irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS )
+irqreturn_t radeon_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t *dev = (drm_device_t *) arg;
drm_radeon_private_t *dev_priv =
}
-int DRM(vblank_wait)(drm_device_t *dev, unsigned int *sequence)
+int radeon_driver_vblank_wait(drm_device_t *dev, unsigned int *sequence)
{
drm_radeon_private_t *dev_priv =
(drm_radeon_private_t *)dev->dev_private;
drm_file_t *filp_priv,
u32 *offset ) {
u32 off = *offset;
+ struct drm_radeon_driver_file_fields *radeon_priv;
if ( off >= dev_priv->fb_location &&
off < ( dev_priv->gart_vm_start + dev_priv->gart_size ) )
return 0;
- off += filp_priv->radeon_fb_delta;
+ radeon_priv = filp_priv->driver_priv;
+
+ off += radeon_priv->radeon_fb_delta;
DRM_DEBUG( "offset fixed up to 0x%x\n", off );
drm_radeon_private_t *dev_priv = dev->dev_private;
drm_file_t *filp_priv;
drm_radeon_setparam_t sp;
-
+ struct drm_radeon_driver_file_fields *radeon_priv;
+
if ( !dev_priv ) {
DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
return DRM_ERR( EINVAL );
switch( sp.param ) {
case RADEON_SETPARAM_FB_LOCATION:
- filp_priv->radeon_fb_delta = dev_priv->fb_location - sp.value;
+ radeon_priv = filp_priv->driver_priv;
+ radeon_priv->radeon_fb_delta = dev_priv->fb_location - sp.value;
break;
default:
DRM_DEBUG( "Invalid parameter %d\n", sp.param );
radeon_do_release(dev);
}
-static void radeon_driver_open_helper(drm_device_t *dev, drm_file_t *filp_priv)
+static int radeon_driver_open_helper(drm_device_t *dev, drm_file_t *filp_priv)
{
drm_radeon_private_t *dev_priv = dev->dev_private;
+ struct drm_radeon_driver_file_fields *radeon_priv;
+
+ radeon_priv = (struct drm_radeon_driver_file_fields *)DRM(alloc)(sizeof(*radeon_priv), DRM_MEM_FILES);
+
+ if (!radeon_priv)
+ return -ENOMEM;
+
+ filp_priv->driver_priv = radeon_priv;
+
if ( dev_priv )
- filp_priv->radeon_fb_delta = dev_priv->fb_location;
+ radeon_priv->radeon_fb_delta = dev_priv->fb_location;
else
- filp_priv->radeon_fb_delta = 0;
+ radeon_priv->radeon_fb_delta = 0;
+ return 0;
+}
+
+static void radeon_driver_free_filp_private(drm_device_t *dev, drm_file_t *filp_priv)
+{
+ struct drm_radeon_driver_file_fields *radeon_priv = filp_priv->driver_priv;
+
+ DRM(free)(radeon_priv, sizeof(*radeon_priv), DRM_MEM_FILES);
}
void radeon_driver_register_fns(struct drm_device *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_SG | DRIVER_HAVE_IRQ | DRIVER_HAVE_DMA | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL;
dev->dev_priv_size = sizeof(drm_radeon_buf_priv_t);
dev->fn_tbl.preinit = radeon_preinit;
dev->fn_tbl.postinit = radeon_postinit;
dev->fn_tbl.prerelease = radeon_driver_prerelease;
dev->fn_tbl.pretakedown = radeon_driver_pretakedown;
dev->fn_tbl.open_helper = radeon_driver_open_helper;
+ dev->fn_tbl.vblank_wait = radeon_driver_vblank_wait;
+ dev->fn_tbl.irq_preinstall = radeon_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = radeon_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = radeon_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = radeon_driver_irq_handler;
+ dev->fn_tbl.free_filp_private = radeon_driver_free_filp_private;
}
/* General customization:
*/
-#define __HAVE_AGP 1
-#define __MUST_HAVE_AGP 0
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
#define DRIVER_AUTHOR "SIS"
#define DRIVER_NAME "sis"
void DRM(driver_register_fns)(drm_device_t *dev)
{
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR;
dev->fn_tbl.context_ctor = sis_init_context;
dev->fn_tbl.context_dtor = sis_final_context;
}
/* General customization:
*/
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
#define DRIVER_AUTHOR "VA Linux Systems Inc."
#define DRM(x) viadrv_##x
-
-#define __HAVE_AGP 1
-#define __MUST_HAVE_AGP 0
-#define __HAVE_MTRR 1
-#define __HAVE_CTX_BITMAP 1
-
/* BEAM: Have enabled DMA,DMA_IRQ and VBL_IRQ needed to do this to get standard
* support for VBL_IRQ.
*/
-#define __HAVE_IRQ 1
-#define __HAVE_SHARED_IRQ 1
-#define __HAVE_VBL_IRQ 1
-
#endif
#include "drm_proc.h"
#include "drm_vm.h"
#include "drm_stub.h"
+#include "drm_scatter.h"
extern int via_do_cleanup_map(drm_device_t *dev);
extern int via_map_init(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
+extern int via_driver_vblank_wait(drm_device_t* dev, unsigned int* sequence);
+
+extern irqreturn_t via_driver_irq_handler( DRM_IRQ_ARGS );
+extern void via_driver_irq_preinstall( drm_device_t *dev );
+extern void via_driver_irq_postinstall( drm_device_t *dev );
+extern void via_driver_irq_uninstall( drm_device_t *dev );
+
+extern int via_dma_cleanup(drm_device_t *dev);
extern int via_dma_cleanup(drm_device_t *dev);
#define VIA_IRQ_VBI_ENABLE (1 << 19)
#define VIA_IRQ_VBI_PENDING (1 << 3)
-irqreturn_t DRM(irq_handler)( DRM_IRQ_ARGS )
-
+irqreturn_t via_driver_irq_handler( DRM_IRQ_ARGS )
{
drm_device_t* dev = (drm_device_t*)arg;
drm_via_private_t* dev_priv = (drm_via_private_t*)dev->dev_private;
}
}
-int DRM(vblank_wait)(drm_device_t* dev, unsigned int* sequence)
+int via_driver_vblank_wait(drm_device_t* dev, unsigned int* sequence)
{
drm_via_private_t* dev_priv = (drm_via_private_t*)dev->dev_private;
unsigned int cur_vblank;
/*
* drm_dma.h hooks
*/
-void DRM(driver_irq_preinstall)(drm_device_t* dev){
+void via_driver_irq_preinstall(drm_device_t* dev){
drm_via_private_t* dev_priv = (drm_via_private_t *)dev->dev_private;
u32 status;
}
}
-void DRM(driver_irq_postinstall)(drm_device_t* dev){
+void via_driver_irq_postinstall(drm_device_t* dev){
drm_via_private_t* dev_priv = (drm_via_private_t *)dev->dev_private;
u32 status;
}
}
-void DRM(driver_irq_uninstall)(drm_device_t* dev){
+void via_driver_irq_uninstall(drm_device_t* dev){
drm_via_private_t* dev_priv = (drm_via_private_t *)dev->dev_private;
u32 status;
void DRM(driver_register_fns)(drm_device_t *dev)
{
- dev->fn_tbl.context_ctor = via_init_context;
- dev->fn_tbl.context_dtor = via_final_context;
+ dev->driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL;
+ dev->fn_tbl.context_ctor = via_init_context;
+ dev->fn_tbl.context_dtor = via_final_context;
+ dev->fn_tbl.vblank_wait = via_driver_vblank_wait;
+ dev->fn_tbl.irq_preinstall = via_driver_irq_preinstall;
+ dev->fn_tbl.irq_postinstall = via_driver_irq_postinstall;
+ dev->fn_tbl.irq_uninstall = via_driver_irq_uninstall;
+ dev->fn_tbl.irq_handler = via_driver_irq_handler;
}
projects / platform / upstream / libdrm.git / commitdiff