suggested by Arjan..
Signed-off-by: Dave Airlie <airlied@linux.ie>
#include <asm/pgalloc.h>
#include "drm.h"
+#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
+#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
+
#include "drm_os_linux.h"
/* If you want the memory alloc debug functionality, change define below */
#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))
/*@}*/
-
/***********************************************************************/
/** \name Begin the DRM... */
/*@{*/
/*@}*/
} drm_device_dma_t;
-#if __OS_HAS_AGP
/**
* AGP memory entry. Stored as a doubly linked list.
*/
int cant_use_aperture;
unsigned long page_mask;
} drm_agp_head_t;
-#endif
/**
* Scatter-gather memory.
wait_queue_head_t buf_readers; /**< Processes waiting to read */
wait_queue_head_t buf_writers; /**< Processes waiting to ctx switch */
-#if __OS_HAS_AGP
drm_agp_head_t *agp; /**< AGP data */
-#endif
struct pci_dev *pdev; /**< PCI device structure */
int pci_domain; /**< PCI bus domain number */
return ((dev->driver_features & feature) ? 1 : 0);
}
+#if __OS_HAS_AGP
+static inline int drm_core_has_AGP(struct drm_device *dev)
+{
+ return drm_core_check_feature(dev, DRIVER_USE_AGP);
+}
+#else
+#define drm_core_has_AGP(dev) (0)
+#endif
+
+#if __OS_HAS_MTRR
+static inline int drm_core_has_MTRR(struct drm_device *dev)
+{
+ return drm_core_check_feature(dev, DRIVER_USE_MTRR);
+}
+#else
+#define drm_core_has_MTRR(dev) (0)
+#endif
+
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 __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(unbind_agp)(DRM_AGP_MEM *handle);
-#endif
/* Misc. IOCTL support (drm_ioctl.h) */
extern int DRM(irq_by_busid)(struct inode *inode, struct file *filp,
extern void DRM(vbl_send_signals)( drm_device_t *dev );
-#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);
extern int DRM(agp_free_memory)(DRM_AGP_MEM *handle);
extern int DRM(agp_bind_memory)(DRM_AGP_MEM *handle, off_t start);
extern int DRM(agp_unbind_memory)(DRM_AGP_MEM *handle);
-#endif
/* Stub support (drm_stub.h) */
int DRM(stub_register)(const char *name,
#ifdef __alpha__
map->offset += dev->hose->mem_space->start;
#endif
-#if __OS_HAS_MTRR
- if ( drm_core_check_feature(dev, DRIVER_USE_MTRR) ) {
+ if (drm_core_has_MTRR(dev)) {
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)
map->handle = DRM(ioremap)( map->offset, map->size, dev );
#ifdef __alpha__
map->offset += dev->hose->mem_space->start;
#endif
-#if __OS_HAS_MTRR
- if (drm_core_check_feature(dev, DRIVER_USE_MTRR)) {
+ if (drm_core_has_MTRR(dev)) {
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)
map->handle = DRM(ioremap)( map->offset, map->size,
dev );
dev->lock.hw_lock = map->handle; /* Pointer to lock */
}
break;
-#if __OS_HAS_AGP
case _DRM_AGP:
- if (drm_core_check_feature(dev, DRIVER_USE_AGP)) {
+ if (drm_core_has_AGP(dev)) {
#ifdef __alpha__
map->offset += dev->hose->mem_space->start;
#endif
map->mtrr = dev->agp->agp_mtrr; /* for getmap */
}
break;
-#endif
case _DRM_SCATTER_GATHER:
if (!dev->sg) {
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
return -EFAULT;
if ( request.count >= dma->buf_count ) {
- if (( drm_core_check_feature(dev, DRIVER_USE_AGP) && (dma->flags & _DRM_DMA_USE_AGP)) ||
- ( drm_core_check_feature(dev, DRIVER_SG) && (dma->flags & _DRM_DMA_USE_SG)) ) {
+ if ((drm_core_has_AGP(dev) && (dma->flags & _DRM_DMA_USE_AGP)) ||
+ (drm_core_check_feature(dev, DRIVER_SG) && (dma->flags & _DRM_DMA_USE_SG))) {
drm_map_t *map = dev->agp_buffer_map;
if ( !map ) {
dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
}
-#if __OS_HAS_AGP
/* Clear AGP information */
- if ( drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp ) {
+ if ( drm_core_has_AGP(dev) && dev->agp ) {
drm_agp_mem_t *entry;
drm_agp_mem_t *nexte;
dev->agp->acquired = 0;
dev->agp->enabled = 0;
}
-#endif
/* Clear vma list (only built for debugging) */
if ( dev->vmalist ) {
if ((retcode = dev->fn_tbl.preinit(dev, ent->driver_data)))
goto error_out_unreg;
-#if __OS_HAS_AGP
- if (drm_core_check_feature(dev, DRIVER_USE_AGP)) {
+ if (drm_core_has_AGP(dev)) {
dev->agp = DRM(agp_init)();
if ( drm_core_check_feature(dev, DRIVER_REQUIRE_AGP) && dev->agp == NULL ) {
DRM_ERROR( "Cannot initialize the agpgart module.\n" );
goto error_out_unreg;
}
-#if __OS_HAS_MTRR
- if (drm_core_check_feature(dev, DRIVER_USE_MTRR)) {
+
+ if (drm_core_has_MTRR(dev)) {
if (dev->agp)
dev->agp->agp_mtrr = mtrr_add( dev->agp->agp_info.aper_base,
dev->agp->agp_info.aper_size*1024*1024,
1 );
}
}
-#endif
-#endif
+
retcode = DRM(ctxbitmap_init)( dev );
if( retcode ) {
DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
static void __exit drm_cleanup_pci(struct pci_dev *pdev)
{
drm_device_t *dev = pci_get_drvdata(pdev);
-
+
pci_set_drvdata(pdev, NULL);
drm_cleanup(dev);
}
break;
case _DRM_FRAME_BUFFER:
-#if __OS_HAS_MTRR
- if ( drm_core_check_feature(dev, DRIVER_USE_MTRR)) {
+ if ( drm_core_has_MTRR(dev)) {
if ( map->mtrr >= 0 ) {
int retcode;
retcode = mtrr_del( map->mtrr,
DRM_DEBUG( "mtrr_del=%d\n", retcode );
}
}
-#endif
break;
case _DRM_SHM:
DRM(ctxbitmap_cleanup)( dev );
-#if __OS_HAS_AGP
-#if __OS_HAS_MTRR
- if ( drm_core_check_feature(dev, DRIVER_USE_MTRR) && dev->agp && dev->agp->agp_mtrr >= 0 ) {
+ if (drm_core_has_MTRR(dev) && drm_core_has_AGP(dev) && dev->agp && dev->agp->agp_mtrr >= 0) {
int retval;
retval = mtrr_del( dev->agp->agp_mtrr,
dev->agp->agp_info.aper_base,
dev->agp->agp_info.aper_size*1024*1024 );
DRM_DEBUG( "mtrr_del=%d\n", retval );
}
-#endif
- if ( drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp ) {
+
+ if (drm_core_has_AGP(dev) && dev->agp ) {
DRM(agp_uninit)();
DRM(free)( dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS );
dev->agp = NULL;
}
-#endif
if (dev->fn_tbl.postcleanup)
dev->fn_tbl.postcleanup(dev);
}
current->state = TASK_RUNNING;
remove_wait_queue( &dev->lock.lock_queue, &entry );
- if ( !ret ) {
- sigemptyset( &dev->sigmask );
- sigaddset( &dev->sigmask, SIGSTOP );
- sigaddset( &dev->sigmask, SIGTSTP );
- sigaddset( &dev->sigmask, SIGTTIN );
- sigaddset( &dev->sigmask, SIGTTOU );
- dev->sigdata.context = lock.context;
- dev->sigdata.lock = dev->lock.hw_lock;
- block_all_signals( DRM(notifier),
- &dev->sigdata, &dev->sigmask );
-
- if (dev->fn_tbl.dma_ready && (lock.flags & _DRM_LOCK_READY))
- dev->fn_tbl.dma_ready(dev);
-
- if ( dev->fn_tbl.dma_quiescent && (lock.flags & _DRM_LOCK_QUIESCENT ))
- return dev->fn_tbl.dma_quiescent(dev);
-
-
- if ( dev->fn_tbl.kernel_context_switch && dev->last_context != lock.context ) {
- dev->fn_tbl.kernel_context_switch(dev, dev->last_context,
- lock.context);
- }
- }
+ sigemptyset( &dev->sigmask );
+ sigaddset( &dev->sigmask, SIGSTOP );
+ sigaddset( &dev->sigmask, SIGTSTP );
+ sigaddset( &dev->sigmask, SIGTTIN );
+ sigaddset( &dev->sigmask, SIGTTOU );
+ dev->sigdata.context = lock.context;
+ dev->sigdata.lock = dev->lock.hw_lock;
+ block_all_signals( DRM(notifier),
+ &dev->sigdata, &dev->sigmask );
+
+ if (dev->fn_tbl.dma_ready && (lock.flags & _DRM_LOCK_READY))
+ dev->fn_tbl.dma_ready(dev);
+
+ if ( dev->fn_tbl.dma_quiescent && (lock.flags & _DRM_LOCK_QUIESCENT ))
+ return dev->fn_tbl.dma_quiescent(dev);
+
+
+ if ( dev->fn_tbl.kernel_context_switch && dev->last_context != lock.context ) {
+ dev->fn_tbl.kernel_context_switch(dev, dev->last_context,
+ lock.context);
+ }
+
DRM_DEBUG( "%d %s\n", lock.context, ret ? "interrupted" : "has lock" );
return pte_pfn(*ptep) << PAGE_SHIFT;
}
-#endif /* __OS_HAS_AGP && defined(VMAP_4_ARGS) */
+#else /* __OS_HAS_AGP */
+
+static inline drm_map_t *drm_lookup_map(unsigned long offset, unsigned long size, drm_device_t *dev)
+{
+ return NULL;
+}
+
+static inline void *agp_remap(unsigned long offset, unsigned long size, drm_device_t *dev)
+{
+ return NULL;
+}
+
+static inline unsigned long drm_follow_page (void *vaddr)
+{
+ return 0;
+}
+
+#endif
static inline void *drm_ioremap(unsigned long offset, unsigned long size, drm_device_t *dev)
{
-#if __OS_HAS_AGP && defined(VMAP_4_ARGS)
- if ( drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture) {
+#if defined(VMAP_4_ARGS)
+ if ( drm_core_has_AGP(dev) && 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 __OS_HAS_AGP&& defined(VMAP_4_ARGS)
- if ( drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture) {
+#if defined(VMAP_4_ARGS)
+ if ( drm_core_has_AGP(dev) && 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 __OS_HAS_AGP && defined(VMAP_4_ARGS)
+#if 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 (drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture
+ if (drm_core_has_AGP(dev) && dev->agp && dev->agp->cant_use_aperture
&& ((unsigned long) pt >= VMALLOC_START && (unsigned long) pt < VMALLOC_END))
{
unsigned long offset;
#endif
/** AGP types */
+#if __OS_HAS_AGP
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,70)
#define DRM_AGP_MEM agp_memory
#define DRM_AGP_KERN agp_kern_info
#define DRM_AGP_MEM struct agp_memory
#define DRM_AGP_KERN struct agp_kern_info
#endif
+#else
+/* define some dummy types for non AGP supporting kernels */
+struct no_agp_kern {
+ unsigned long aper_base;
+ unsigned long aper_size;
+};
+#define DRM_AGP_MEM int
+#define DRM_AGP_KERN struct no_agp_kern
+#endif
+
+#if !(__OS_HAS_MTRR)
+static __inline__ int mtrr_add (unsigned long base, unsigned long size,
+ unsigned int type, char increment)
+{
+ return -ENODEV;
+}
+
+static __inline__ int mtrr_del (int reg, unsigned long base,
+ unsigned long size)
+{
+ return -ENODEV;
+}
+#define MTRR_TYPE_WRCOMB 1
+#endif
/** Task queue handler arguments */
#define DRM_TASKQUEUE_ARGS void *arg
* Find the right map and if it's AGP memory find the real physical page to
* map, get the page, increment the use count and return it.
*/
+#if __OS_HAS_AGP
static __inline__ struct page *DRM(do_vm_nopage)(struct vm_area_struct *vma,
unsigned long address)
{
-#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 (!drm_core_check_feature(dev, DRIVER_USE_AGP))
+ if (!drm_core_has_AGP(dev))
goto vm_nopage_error;
if(!dev->agp || !dev->agp->cant_use_aperture) goto vm_nopage_error;
return page;
}
vm_nopage_error:
-#endif /* __OS_HAS_AGP */
-
return NOPAGE_SIGBUS; /* Disallow mremap */
}
+#else /* __OS_HAS_AGP */
+static __inline__ struct page *DRM(do_vm_nopage)(struct vm_area_struct *vma,
+ unsigned long address)
+{
+ return NOPAGE_SIGBUS;
+}
+#endif /* __OS_HAS_AGP */
/**
* \c nopage method for shared virtual memory.
switch (map->type) {
case _DRM_REGISTERS:
case _DRM_FRAME_BUFFER:
-#if __OS_HAS_MTRR
- if (drm_core_check_feature(dev, DRIVER_USE_MTRR) && map->mtrr >= 0) {
+ if (drm_core_has_MTRR(dev) && map->mtrr >= 0) {
int retcode;
retcode = mtrr_del(map->mtrr,
map->offset,
map->size);
DRM_DEBUG("mtrr_del = %d\n", retcode);
}
-#endif
DRM(ioremapfree)(map->handle, map->size, dev);
break;
case _DRM_SHM:
switch (map->type) {
case _DRM_AGP:
-#if __OS_HAS_AGP
- if (drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp->cant_use_aperture) {
+ if (drm_core_has_AGP(dev) && 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
vma->vm_ops = &DRM(vm_ops);
break;
}
-#endif
/* fall through to _DRM_FRAME_BUFFER... */
case _DRM_FRAME_BUFFER:
case _DRM_REGISTERS:
#include <asm/pgalloc.h>
#include "drm.h"
+#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
+#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
+
#include "drm_os_linux.h"
/* If you want the memory alloc debug functionality, change define below */
#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))
/*@}*/
-
/***********************************************************************/
/** \name Begin the DRM... */
/*@{*/
/*@}*/
} drm_device_dma_t;
-#if __OS_HAS_AGP
/**
* AGP memory entry. Stored as a doubly linked list.
*/
int cant_use_aperture;
unsigned long page_mask;
} drm_agp_head_t;
-#endif
/**
* Scatter-gather memory.
wait_queue_head_t buf_readers; /**< Processes waiting to read */
wait_queue_head_t buf_writers; /**< Processes waiting to ctx switch */
-#if __OS_HAS_AGP
drm_agp_head_t *agp; /**< AGP data */
-#endif
struct pci_dev *pdev; /**< PCI device structure */
int pci_domain; /**< PCI bus domain number */
return ((dev->driver_features & feature) ? 1 : 0);
}
+#if __OS_HAS_AGP
+static inline int drm_core_has_AGP(struct drm_device *dev)
+{
+ return drm_core_check_feature(dev, DRIVER_USE_AGP);
+}
+#else
+#define drm_core_has_AGP(dev) (0)
+#endif
+
+#if __OS_HAS_MTRR
+static inline int drm_core_has_MTRR(struct drm_device *dev)
+{
+ return drm_core_check_feature(dev, DRIVER_USE_MTRR);
+}
+#else
+#define drm_core_has_MTRR(dev) (0)
+#endif
+
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 __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(unbind_agp)(DRM_AGP_MEM *handle);
-#endif
/* Misc. IOCTL support (drm_ioctl.h) */
extern int DRM(irq_by_busid)(struct inode *inode, struct file *filp,
extern void DRM(vbl_send_signals)( drm_device_t *dev );
-#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);
extern int DRM(agp_free_memory)(DRM_AGP_MEM *handle);
extern int DRM(agp_bind_memory)(DRM_AGP_MEM *handle, off_t start);
extern int DRM(agp_unbind_memory)(DRM_AGP_MEM *handle);
-#endif
/* Stub support (drm_stub.h) */
int DRM(stub_register)(const char *name,
#ifdef __alpha__
map->offset += dev->hose->mem_space->start;
#endif
-#if __OS_HAS_MTRR
- if ( drm_core_check_feature(dev, DRIVER_USE_MTRR) ) {
+ if (drm_core_has_MTRR(dev)) {
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)
map->handle = DRM(ioremap)( map->offset, map->size, dev );
#ifdef __alpha__
map->offset += dev->hose->mem_space->start;
#endif
-#if __OS_HAS_MTRR
- if (drm_core_check_feature(dev, DRIVER_USE_MTRR)) {
+ if (drm_core_has_MTRR(dev)) {
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)
map->handle = DRM(ioremap)( map->offset, map->size,
dev );
dev->lock.hw_lock = map->handle; /* Pointer to lock */
}
break;
-#if __OS_HAS_AGP
case _DRM_AGP:
- if (drm_core_check_feature(dev, DRIVER_USE_AGP)) {
+ if (drm_core_has_AGP(dev)) {
#ifdef __alpha__
map->offset += dev->hose->mem_space->start;
#endif
map->mtrr = dev->agp->agp_mtrr; /* for getmap */
}
break;
-#endif
case _DRM_SCATTER_GATHER:
if (!dev->sg) {
DRM(free)(map, sizeof(*map), DRM_MEM_MAPS);
return -EFAULT;
if ( request.count >= dma->buf_count ) {
- if (( drm_core_check_feature(dev, DRIVER_USE_AGP) && (dma->flags & _DRM_DMA_USE_AGP)) ||
- ( drm_core_check_feature(dev, DRIVER_SG) && (dma->flags & _DRM_DMA_USE_SG)) ) {
+ if ((drm_core_has_AGP(dev) && (dma->flags & _DRM_DMA_USE_AGP)) ||
+ (drm_core_check_feature(dev, DRIVER_SG) && (dma->flags & _DRM_DMA_USE_SG))) {
drm_map_t *map = dev->agp_buffer_map;
if ( !map ) {
dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
}
-#if __OS_HAS_AGP
/* Clear AGP information */
- if ( drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp ) {
+ if ( drm_core_has_AGP(dev) && dev->agp ) {
drm_agp_mem_t *entry;
drm_agp_mem_t *nexte;
dev->agp->acquired = 0;
dev->agp->enabled = 0;
}
-#endif
/* Clear vma list (only built for debugging) */
if ( dev->vmalist ) {
if ((retcode = dev->fn_tbl.preinit(dev, ent->driver_data)))
goto error_out_unreg;
-#if __OS_HAS_AGP
- if (drm_core_check_feature(dev, DRIVER_USE_AGP)) {
+ if (drm_core_has_AGP(dev)) {
dev->agp = DRM(agp_init)();
if ( drm_core_check_feature(dev, DRIVER_REQUIRE_AGP) && dev->agp == NULL ) {
DRM_ERROR( "Cannot initialize the agpgart module.\n" );
goto error_out_unreg;
}
-#if __OS_HAS_MTRR
- if (drm_core_check_feature(dev, DRIVER_USE_MTRR)) {
+
+ if (drm_core_has_MTRR(dev)) {
if (dev->agp)
dev->agp->agp_mtrr = mtrr_add( dev->agp->agp_info.aper_base,
dev->agp->agp_info.aper_size*1024*1024,
1 );
}
}
-#endif
-#endif
+
retcode = DRM(ctxbitmap_init)( dev );
if( retcode ) {
DRM_ERROR( "Cannot allocate memory for context bitmap.\n" );
static void __exit drm_cleanup_pci(struct pci_dev *pdev)
{
drm_device_t *dev = pci_get_drvdata(pdev);
-
+
pci_set_drvdata(pdev, NULL);
drm_cleanup(dev);
}
break;
case _DRM_FRAME_BUFFER:
-#if __OS_HAS_MTRR
- if ( drm_core_check_feature(dev, DRIVER_USE_MTRR)) {
+ if ( drm_core_has_MTRR(dev)) {
if ( map->mtrr >= 0 ) {
int retcode;
retcode = mtrr_del( map->mtrr,
DRM_DEBUG( "mtrr_del=%d\n", retcode );
}
}
-#endif
break;
case _DRM_SHM:
DRM(ctxbitmap_cleanup)( dev );
-#if __OS_HAS_AGP
-#if __OS_HAS_MTRR
- if ( drm_core_check_feature(dev, DRIVER_USE_MTRR) && dev->agp && dev->agp->agp_mtrr >= 0 ) {
+ if (drm_core_has_MTRR(dev) && drm_core_has_AGP(dev) && dev->agp && dev->agp->agp_mtrr >= 0) {
int retval;
retval = mtrr_del( dev->agp->agp_mtrr,
dev->agp->agp_info.aper_base,
dev->agp->agp_info.aper_size*1024*1024 );
DRM_DEBUG( "mtrr_del=%d\n", retval );
}
-#endif
- if ( drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp ) {
+
+ if (drm_core_has_AGP(dev) && dev->agp ) {
DRM(agp_uninit)();
DRM(free)( dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS );
dev->agp = NULL;
}
-#endif
if (dev->fn_tbl.postcleanup)
dev->fn_tbl.postcleanup(dev);
}
current->state = TASK_RUNNING;
remove_wait_queue( &dev->lock.lock_queue, &entry );
- if ( !ret ) {
- sigemptyset( &dev->sigmask );
- sigaddset( &dev->sigmask, SIGSTOP );
- sigaddset( &dev->sigmask, SIGTSTP );
- sigaddset( &dev->sigmask, SIGTTIN );
- sigaddset( &dev->sigmask, SIGTTOU );
- dev->sigdata.context = lock.context;
- dev->sigdata.lock = dev->lock.hw_lock;
- block_all_signals( DRM(notifier),
- &dev->sigdata, &dev->sigmask );
-
- if (dev->fn_tbl.dma_ready && (lock.flags & _DRM_LOCK_READY))
- dev->fn_tbl.dma_ready(dev);
-
- if ( dev->fn_tbl.dma_quiescent && (lock.flags & _DRM_LOCK_QUIESCENT ))
- return dev->fn_tbl.dma_quiescent(dev);
-
-
- if ( dev->fn_tbl.kernel_context_switch && dev->last_context != lock.context ) {
- dev->fn_tbl.kernel_context_switch(dev, dev->last_context,
- lock.context);
- }
- }
+ sigemptyset( &dev->sigmask );
+ sigaddset( &dev->sigmask, SIGSTOP );
+ sigaddset( &dev->sigmask, SIGTSTP );
+ sigaddset( &dev->sigmask, SIGTTIN );
+ sigaddset( &dev->sigmask, SIGTTOU );
+ dev->sigdata.context = lock.context;
+ dev->sigdata.lock = dev->lock.hw_lock;
+ block_all_signals( DRM(notifier),
+ &dev->sigdata, &dev->sigmask );
+
+ if (dev->fn_tbl.dma_ready && (lock.flags & _DRM_LOCK_READY))
+ dev->fn_tbl.dma_ready(dev);
+
+ if ( dev->fn_tbl.dma_quiescent && (lock.flags & _DRM_LOCK_QUIESCENT ))
+ return dev->fn_tbl.dma_quiescent(dev);
+
+
+ if ( dev->fn_tbl.kernel_context_switch && dev->last_context != lock.context ) {
+ dev->fn_tbl.kernel_context_switch(dev, dev->last_context,
+ lock.context);
+ }
+
DRM_DEBUG( "%d %s\n", lock.context, ret ? "interrupted" : "has lock" );
return pte_pfn(*ptep) << PAGE_SHIFT;
}
-#endif /* __OS_HAS_AGP && defined(VMAP_4_ARGS) */
+#else /* __OS_HAS_AGP */
+
+static inline drm_map_t *drm_lookup_map(unsigned long offset, unsigned long size, drm_device_t *dev)
+{
+ return NULL;
+}
+
+static inline void *agp_remap(unsigned long offset, unsigned long size, drm_device_t *dev)
+{
+ return NULL;
+}
+
+static inline unsigned long drm_follow_page (void *vaddr)
+{
+ return 0;
+}
+
+#endif
static inline void *drm_ioremap(unsigned long offset, unsigned long size, drm_device_t *dev)
{
-#if __OS_HAS_AGP && defined(VMAP_4_ARGS)
- if ( drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture) {
+#if defined(VMAP_4_ARGS)
+ if ( drm_core_has_AGP(dev) && 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 __OS_HAS_AGP&& defined(VMAP_4_ARGS)
- if ( drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture) {
+#if defined(VMAP_4_ARGS)
+ if ( drm_core_has_AGP(dev) && 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 __OS_HAS_AGP && defined(VMAP_4_ARGS)
+#if 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 (drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp && dev->agp->cant_use_aperture
+ if (drm_core_has_AGP(dev) && dev->agp && dev->agp->cant_use_aperture
&& ((unsigned long) pt >= VMALLOC_START && (unsigned long) pt < VMALLOC_END))
{
unsigned long offset;
#endif
/** AGP types */
+#if __OS_HAS_AGP
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,70)
#define DRM_AGP_MEM agp_memory
#define DRM_AGP_KERN agp_kern_info
#define DRM_AGP_MEM struct agp_memory
#define DRM_AGP_KERN struct agp_kern_info
#endif
+#else
+/* define some dummy types for non AGP supporting kernels */
+struct no_agp_kern {
+ unsigned long aper_base;
+ unsigned long aper_size;
+};
+#define DRM_AGP_MEM int
+#define DRM_AGP_KERN struct no_agp_kern
+#endif
+
+#if !(__OS_HAS_MTRR)
+static __inline__ int mtrr_add (unsigned long base, unsigned long size,
+ unsigned int type, char increment)
+{
+ return -ENODEV;
+}
+
+static __inline__ int mtrr_del (int reg, unsigned long base,
+ unsigned long size)
+{
+ return -ENODEV;
+}
+#define MTRR_TYPE_WRCOMB 1
+#endif
/** Task queue handler arguments */
#define DRM_TASKQUEUE_ARGS void *arg
* Find the right map and if it's AGP memory find the real physical page to
* map, get the page, increment the use count and return it.
*/
+#if __OS_HAS_AGP
static __inline__ struct page *DRM(do_vm_nopage)(struct vm_area_struct *vma,
unsigned long address)
{
-#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 (!drm_core_check_feature(dev, DRIVER_USE_AGP))
+ if (!drm_core_has_AGP(dev))
goto vm_nopage_error;
if(!dev->agp || !dev->agp->cant_use_aperture) goto vm_nopage_error;
return page;
}
vm_nopage_error:
-#endif /* __OS_HAS_AGP */
-
return NOPAGE_SIGBUS; /* Disallow mremap */
}
+#else /* __OS_HAS_AGP */
+static __inline__ struct page *DRM(do_vm_nopage)(struct vm_area_struct *vma,
+ unsigned long address)
+{
+ return NOPAGE_SIGBUS;
+}
+#endif /* __OS_HAS_AGP */
/**
* \c nopage method for shared virtual memory.
switch (map->type) {
case _DRM_REGISTERS:
case _DRM_FRAME_BUFFER:
-#if __OS_HAS_MTRR
- if (drm_core_check_feature(dev, DRIVER_USE_MTRR) && map->mtrr >= 0) {
+ if (drm_core_has_MTRR(dev) && map->mtrr >= 0) {
int retcode;
retcode = mtrr_del(map->mtrr,
map->offset,
map->size);
DRM_DEBUG("mtrr_del = %d\n", retcode);
}
-#endif
DRM(ioremapfree)(map->handle, map->size, dev);
break;
case _DRM_SHM:
switch (map->type) {
case _DRM_AGP:
-#if __OS_HAS_AGP
- if (drm_core_check_feature(dev, DRIVER_USE_AGP) && dev->agp->cant_use_aperture) {
+ if (drm_core_has_AGP(dev) && 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
vma->vm_ops = &DRM(vm_ops);
break;
}
-#endif
/* fall through to _DRM_FRAME_BUFFER... */
case _DRM_FRAME_BUFFER:
case _DRM_REGISTERS:
projects / profile / ivi / libdrm.git / commitdiff