via_3d_reg.h \
via_dma.c
-SUBDIR = drm i915 mach64 mga r128 radeon sis tdfx
+SUBDIR = drm mach64 mga r128 radeon sis tdfx # i915
CLEANFILES+= ${SHAREDFILES}
#define IRQ_HANDLED /* nothing */
#define IRQ_NONE /* nothing */
+enum {
+ DRM_IS_NOT_AGP,
+ DRM_MIGHT_BE_AGP,
+ DRM_IS_AGP
+};
+#define DRM_AGP_MEM struct agp_memory_info
+
#if defined(__FreeBSD__)
#define DRM_DEVICE \
drm_device_t *dev = kdev->si_drv1
int mtrr; /* Boolean: MTRR used */
/* Private data */
int rid; /* PCI resource ID for bus_space */
- int kernel_owned; /* Boolean: 1 = initmapped, 0 = addmapped */
struct resource *bsr;
bus_space_tag_t bst;
bus_space_handle_t bsh;
/* Buffer management support (drm_bufs.c) */
unsigned long drm_get_resource_start(drm_device_t *dev, unsigned int resource);
unsigned long drm_get_resource_len(drm_device_t *dev, unsigned int resource);
-int drm_initmap(drm_device_t *dev, unsigned long start, unsigned long len,
- unsigned int resource, int type, int flags);
-void drm_remove_map(drm_device_t *dev, drm_local_map_t *map);
+void drm_rmmap(drm_device_t *dev, drm_local_map_t *map);
int drm_order(unsigned long size);
+int drm_addmap(drm_device_t * dev, unsigned long offset, unsigned long size,
+ drm_map_type_t type, drm_map_flags_t flags,
+ drm_local_map_t **map_ptr);
+int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request);
+int drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request);
+int drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request);
/* DMA support (drm_dma.c) */
int drm_dma_setup(drm_device_t *dev);
int drm_device_is_agp(drm_device_t *dev);
drm_agp_head_t *drm_agp_init(void);
void drm_agp_uninit(void);
+int drm_agp_acquire(drm_device_t *dev);
int drm_agp_release(drm_device_t *dev);
+int drm_agp_info(drm_device_t * dev, drm_agp_info_t *info);
+int drm_agp_enable(drm_device_t *dev, drm_agp_mode_t mode);
void *drm_agp_allocate_memory(size_t pages, u32 type);
int drm_agp_free_memory(void *handle);
int drm_agp_bind_memory(void *handle, off_t start);
int drm_agp_unbind_memory(void *handle);
+#define drm_alloc_agp(dev, pages, type) drm_agp_allocate_memory(pages, type)
+#define drm_free_agp(handle, pages) drm_agp_free_memory(handle)
+#define drm_bind_agp(handle, start) drm_agp_bind_memory(handle, start)
+#define drm_unbind_agp(handle) drm_agp_unbind_memory(handle)
/* Scatter Gather Support (drm_scatter.c) */
void drm_sg_cleanup(drm_sg_mem_t *entry);
int drm_authmagic(DRM_IOCTL_ARGS);
/* Buffer management support (drm_bufs.c) */
-int drm_addmap(DRM_IOCTL_ARGS);
-int drm_rmmap(DRM_IOCTL_ARGS);
-int drm_addbufs(DRM_IOCTL_ARGS);
+int drm_addmap_ioctl(DRM_IOCTL_ARGS);
+int drm_rmmap_ioctl(DRM_IOCTL_ARGS);
+int drm_addbufs_ioctl(DRM_IOCTL_ARGS);
int drm_infobufs(DRM_IOCTL_ARGS);
int drm_markbufs(DRM_IOCTL_ARGS);
int drm_freebufs(DRM_IOCTL_ARGS);
int drm_wait_vblank(DRM_IOCTL_ARGS);
/* AGP/GART support (drm_agpsupport.c) */
-int drm_agp_acquire(DRM_IOCTL_ARGS);
+int drm_agp_acquire_ioctl(DRM_IOCTL_ARGS);
int drm_agp_release_ioctl(DRM_IOCTL_ARGS);
-int drm_agp_enable(DRM_IOCTL_ARGS);
-int drm_agp_info(DRM_IOCTL_ARGS);
+int drm_agp_enable_ioctl(DRM_IOCTL_ARGS);
+int drm_agp_info_ioctl(DRM_IOCTL_ARGS);
int drm_agp_alloc(DRM_IOCTL_ARGS);
int drm_agp_free(DRM_IOCTL_ARGS);
int drm_agp_unbind(DRM_IOCTL_ARGS);
#include <dev/pci/pcireg.h>
#endif
+/* Returns 1 if AGP or 0 if not. */
int
drm_device_is_agp(drm_device_t *dev)
{
+ int ret;
+
+ if (dev->device_is_agp != NULL) {
+ ret = (*dev->device_is_agp)(dev);
+
+ if (ret != DRM_MIGHT_BE_AGP) {
+ return ret == 2;
+ }
+ }
+
#ifdef __FreeBSD__
/* Code taken from agp.c. IWBNI that was a public interface. */
u_int32_t status;
u_int8_t ptr, next;
-
- if ( dev->driver->device_is_agp != NULL ) {
- int err = (*dev->driver->device_is_agp)( dev );
-
- if (err != 2) {
- return err;
- }
- }
-
/*
* Check the CAP_LIST bit of the PCI status register first.
*/
return 0;
#else
- if ( (dev->driver->device_is_agp != NULL)
- && ! (*dev->driver->device_is_agp)( dev ) ) {
- return 0;
- }
-
/* XXX: fill me in for non-FreeBSD */
return 1;
#endif
}
-int drm_agp_info(DRM_IOCTL_ARGS)
+int drm_agp_info(drm_device_t * dev, drm_agp_info_t *info)
{
- DRM_DEVICE;
struct agp_info *kern;
- drm_agp_info_t info;
if (!dev->agp || !dev->agp->acquired)
return EINVAL;
kern = &dev->agp->info;
agp_get_info(dev->agp->agpdev, kern);
- info.agp_version_major = 1;
- info.agp_version_minor = 0;
- info.mode = kern->ai_mode;
- info.aperture_base = kern->ai_aperture_base;
- info.aperture_size = kern->ai_aperture_size;
- info.memory_allowed = kern->ai_memory_allowed;
- info.memory_used = kern->ai_memory_used;
- info.id_vendor = kern->ai_devid & 0xffff;
- info.id_device = kern->ai_devid >> 16;
+ info->agp_version_major = 1;
+ info->agp_version_minor = 0;
+ info->mode = kern->ai_mode;
+ info->aperture_base = kern->ai_aperture_base;
+ info->aperture_size = kern->ai_aperture_size;
+ info->memory_allowed = kern->ai_memory_allowed;
+ info->memory_used = kern->ai_memory_used;
+ info->id_vendor = kern->ai_devid & 0xffff;
+ info->id_device = kern->ai_devid >> 16;
+
+ return 0;
+}
+
+int drm_agp_info_ioctl(DRM_IOCTL_ARGS)
+{
+ int err;
+ drm_agp_info_t info;
+ DRM_DEVICE;
+
+ err = drm_agp_info(dev, &info);
+ if (err != 0)
+ return err;
*(drm_agp_info_t *) data = info;
return 0;
}
-int drm_agp_acquire(DRM_IOCTL_ARGS)
+int drm_agp_acquire_ioctl(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
- int retcode;
+
+ return drm_agp_acquire(dev);
+}
+
+int drm_agp_acquire(drm_device_t *dev)
+{
+ int retcode;
if (!dev->agp || dev->agp->acquired)
return EINVAL;
+
retcode = agp_acquire(dev->agp->agpdev);
if (retcode)
return retcode;
+
dev->agp->acquired = 1;
return 0;
}
return drm_agp_release(dev);
}
-void drm_agp_release(drm_device_t * dev)
+int drm_agp_release(drm_device_t * dev)
{
if (!dev->agp || !dev->agp->acquired)
return EINVAL;
return 0;
}
-int drm_agp_enable(DRM_IOCTL_ARGS)
+int drm_agp_enable(drm_device_t *dev, drm_agp_mode_t mode)
{
- DRM_DEVICE;
- drm_agp_mode_t mode;
if (!dev->agp || !dev->agp->acquired)
return EINVAL;
-
- mode = *(drm_agp_mode_t *) data;
dev->agp->mode = mode.mode;
agp_enable(dev->agp->agpdev, mode.mode);
return 0;
}
+int drm_agp_enable_ioctl(DRM_IOCTL_ARGS)
+{
+ drm_agp_mode_t mode;
+ DRM_DEVICE;
+
+ mode = *(drm_agp_mode_t *) data;
+
+ return drm_agp_enable(dev, mode);
+}
+
int drm_agp_alloc(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
return len;
}
-int drm_initmap(drm_device_t *dev, unsigned long start, unsigned long len,
- unsigned int resource, int type, int flags)
+int drm_addmap(drm_device_t * dev, unsigned long offset, unsigned long size,
+ drm_map_type_t type, drm_map_flags_t flags, drm_local_map_t **map_ptr)
{
drm_local_map_t *map;
- struct resource *bsr;
-
- if (type != _DRM_REGISTERS && type != _DRM_FRAME_BUFFER)
- return EINVAL;
- if (len == 0)
- return EINVAL;
-
- map = malloc(sizeof(*map), M_DRM, M_ZERO | M_NOWAIT);
- if (map == NULL)
- return ENOMEM;
-
- map->rid = resource * 4 + 0x10;
- bsr = bus_alloc_resource_any(dev->device, SYS_RES_MEMORY, &map->rid,
- RF_ACTIVE | RF_SHAREABLE);
- if (bsr == NULL) {
- DRM_ERROR("Couldn't allocate %s resource\n",
- ((type == _DRM_REGISTERS) ? "mmio" : "framebuffer"));
- free(map, M_DRM);
- return ENOMEM;
- }
-
- map->kernel_owned = 1;
- map->type = type;
- map->flags = flags;
- map->bsr = bsr;
- map->bst = rman_get_bustag(bsr);
- map->bsh = rman_get_bushandle(bsr);
- map->offset = start;
- map->size = len;
-
- if (type == _DRM_REGISTERS)
- map->handle = rman_get_virtual(bsr);
-
- DRM_DEBUG("initmap %d,0x%x@0x%lx/0x%lx\n", map->type, map->flags,
- map->offset, map->size);
-
- if (map->flags & _DRM_WRITE_COMBINING) {
- int err;
-
- err = drm_mtrr_add(map->offset, map->size, DRM_MTRR_WC);
- if (err == 0)
- map->mtrr = 1;
- }
-
- DRM_LOCK();
- TAILQ_INSERT_TAIL(&dev->maplist, map, link);
- DRM_UNLOCK();
-
- return 0;
-}
-
-int drm_addmap(DRM_IOCTL_ARGS)
-{
- DRM_DEVICE;
- drm_map_t request;
- drm_local_map_t *map;
-
- if (!(dev->flags & (FREAD|FWRITE)))
- return DRM_ERR(EACCES); /* Require read/write */
-
- DRM_COPY_FROM_USER_IOCTL( request, (drm_map_t *)data, sizeof(drm_map_t) );
/* Only allow shared memory to be removable since we only keep enough
* book keeping information about shared memory to allow for removal
* when processes fork.
*/
- if ((request.flags & _DRM_REMOVABLE) && request.type != _DRM_SHM)
+ if ((flags & _DRM_REMOVABLE) && type != _DRM_SHM)
return EINVAL;
- if ((request.offset & PAGE_MASK) || (request.size & PAGE_MASK))
+ if ((offset & PAGE_MASK) || (size & PAGE_MASK))
return EINVAL;
- if (request.offset + request.size < request.offset)
+ if (offset + size < offset)
return EINVAL;
- DRM_DEBUG("offset = 0x%08lx, size = 0x%08lx, type = %d\n",
- request.offset, request.size, request.type);
+ DRM_DEBUG("offset = 0x%08lx, size = 0x%08lx, type = %d\n", offset,
+ size, type);
/* Check if this is just another version of a kernel-allocated map, and
* just hand that back if so.
*/
- if (request.type == _DRM_REGISTERS || request.type == _DRM_FRAME_BUFFER)
+ if (type == _DRM_REGISTERS || type == _DRM_FRAME_BUFFER)
{
DRM_LOCK();
TAILQ_FOREACH(map, &dev->maplist, link) {
- if (map->kernel_owned && map->type == request.type &&
- map->offset == request.offset) {
- /* XXX: this size setting is questionable. */
- map->size = request.size;
- DRM_DEBUG("Found kernel map %d\n", request.type);
+ if (map->type == type && map->offset == offset) {
+ map->size = size;
+ DRM_DEBUG("Found kernel map %d\n", type);
goto done;
}
}
if ( !map )
return DRM_ERR(ENOMEM);
- map->offset = request.offset;
- map->size = request.size;
- map->type = request.type;
- map->flags = request.flags;
+ map->offset = offset;
+ map->size = size;
+ map->type = type;
+ map->flags = flags;
switch ( map->type ) {
case _DRM_REGISTERS:
done:
/* Jumped to, with lock held, when a kernel map is found. */
+ DRM_UNLOCK();
+
+ DRM_DEBUG("Added map %d 0x%lx/0x%lx\n", map->type, map->offset,
+ map->size);
+
+ *map_ptr = map;
+
+ return 0;
+}
+
+int drm_addmap_ioctl(DRM_IOCTL_ARGS)
+{
+ drm_map_t request;
+ drm_local_map_t *map;
+ int err;
+ DRM_DEVICE;
+
+ if (!(dev->flags & (FREAD|FWRITE)))
+ return DRM_ERR(EACCES); /* Require read/write */
+
+ DRM_COPY_FROM_USER_IOCTL(request, (drm_map_t *)data, sizeof(drm_map_t));
+
+ err = drm_addmap(dev, request.offset, request.size, request.type,
+ request.flags, &map);
+ if (err != 0)
+ return err;
+
request.offset = map->offset;
request.size = map->size;
request.type = map->type;
request.flags = map->flags;
request.mtrr = map->mtrr;
request.handle = map->handle;
- DRM_UNLOCK();
-
- DRM_DEBUG("Added map %d 0x%lx/0x%lx\n", request.type, request.offset, request.size);
- if ( request.type != _DRM_SHM ) {
+ if (request.type != _DRM_SHM) {
request.handle = (void *)request.offset;
}
-
- DRM_COPY_TO_USER_IOCTL( (drm_map_t *)data, request, sizeof(drm_map_t) );
+ DRM_COPY_TO_USER_IOCTL((drm_map_t *)data, request, sizeof(drm_map_t));
return 0;
}
-void drm_remove_map(drm_device_t *dev, drm_local_map_t *map)
+void drm_rmmap(drm_device_t *dev, drm_local_map_t *map)
{
DRM_SPINLOCK_ASSERT(&dev->dev_lock);
* isn't in use.
*/
-int drm_rmmap(DRM_IOCTL_ARGS)
+int drm_rmmap_ioctl(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
drm_local_map_t *map;
return DRM_ERR(EINVAL);
}
- drm_remove_map(dev, map);
+ drm_rmmap(dev, map);
DRM_UNLOCK();
}
}
-static int drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
+static int drm_do_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
{
drm_device_dma_t *dma = dev->dma;
drm_buf_entry_t *entry;
return 0;
}
-static int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
+static int drm_do_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
{
drm_device_dma_t *dma = dev->dma;
int count;
}
-static int drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
+static int drm_do_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
{
drm_device_dma_t *dma = dev->dma;
drm_buf_entry_t *entry;
return 0;
}
-int drm_addbufs(DRM_IOCTL_ARGS)
+int drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
{
- DRM_DEVICE;
- drm_buf_desc_t request;
- int err;
- int order;
+ int order, ret;
- DRM_COPY_FROM_USER_IOCTL( request, (drm_buf_desc_t *)data, sizeof(request) );
+ DRM_SPINLOCK(&dev->dma_lock);
- if (request.count < 0 || request.count > 4096)
+ if (request->count < 0 || request->count > 4096)
+ return DRM_ERR(EINVAL);
+
+ order = drm_order(request->size);
+ if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
return DRM_ERR(EINVAL);
- order = drm_order(request.size);
+ /* No more allocations after first buffer-using ioctl. */
+ if (dev->buf_use != 0) {
+ DRM_SPINUNLOCK(&dev->dma_lock);
+ return DRM_ERR(EBUSY);
+ }
+ /* No more than one allocation per order */
+ if (dev->dma->bufs[order].buf_count != 0) {
+ DRM_SPINUNLOCK(&dev->dma_lock);
+ return DRM_ERR(ENOMEM);
+ }
+
+ ret = drm_do_addbufs_agp(dev, request);
+
+ DRM_SPINUNLOCK(&dev->dma_lock);
+
+ return ret;
+}
+
+int drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
+{
+ int order, ret;
+
+ DRM_SPINLOCK(&dev->dma_lock);
+
+ if (request->count < 0 || request->count > 4096)
+ return DRM_ERR(EINVAL);
+
+ order = drm_order(request->size);
if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
return DRM_ERR(EINVAL);
+ /* No more allocations after first buffer-using ioctl. */
+ if (dev->buf_use != 0) {
+ DRM_SPINUNLOCK(&dev->dma_lock);
+ return DRM_ERR(EBUSY);
+ }
+ /* No more than one allocation per order */
+ if (dev->dma->bufs[order].buf_count != 0) {
+ DRM_SPINUNLOCK(&dev->dma_lock);
+ return DRM_ERR(ENOMEM);
+ }
+
+ ret = drm_do_addbufs_sg(dev, request);
+
+ DRM_SPINUNLOCK(&dev->dma_lock);
+
+ return ret;
+}
+
+int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
+{
+ int order, ret;
+
DRM_SPINLOCK(&dev->dma_lock);
+
+ if (request->count < 0 || request->count > 4096)
+ return DRM_ERR(EINVAL);
+
+ order = drm_order(request->size);
+ if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
+ return DRM_ERR(EINVAL);
+
/* No more allocations after first buffer-using ioctl. */
if (dev->buf_use != 0) {
DRM_SPINUNLOCK(&dev->dma_lock);
return DRM_ERR(ENOMEM);
}
- if ( request.flags & _DRM_AGP_BUFFER )
+ ret = drm_do_addbufs_pci(dev, request);
+
+ DRM_SPINUNLOCK(&dev->dma_lock);
+
+ return ret;
+}
+
+int drm_addbufs_ioctl(DRM_IOCTL_ARGS)
+{
+ DRM_DEVICE;
+ drm_buf_desc_t request;
+ int err;
+
+ DRM_COPY_FROM_USER_IOCTL(request, (drm_buf_desc_t *)data,
+ sizeof(request));
+
+ if (request.flags & _DRM_AGP_BUFFER)
err = drm_addbufs_agp(dev, &request);
- else
- if ( request.flags & _DRM_SG_BUFFER )
+ else if (request.flags & _DRM_SG_BUFFER)
err = drm_addbufs_sg(dev, &request);
else
err = drm_addbufs_pci(dev, &request);
- DRM_SPINUNLOCK(&dev->dma_lock);
- DRM_COPY_TO_USER_IOCTL((drm_buf_desc_t *)data, request, sizeof(request));
+ DRM_COPY_TO_USER_IOCTL((drm_buf_desc_t *)data, request,
+ sizeof(request));
return err;
}
[DRM_IOCTL_NR(DRM_IOCTL_UNBLOCK)] = { drm_noop, 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_AUTH_MAGIC)] = { drm_authmagic, 1, 1 },
- [DRM_IOCTL_NR(DRM_IOCTL_ADD_MAP)] = { drm_addmap, 1, 1 },
- [DRM_IOCTL_NR(DRM_IOCTL_RM_MAP)] = { drm_rmmap, 1, 0 },
+ [DRM_IOCTL_NR(DRM_IOCTL_ADD_MAP)] = { drm_addmap_ioctl, 1, 1 },
+ [DRM_IOCTL_NR(DRM_IOCTL_RM_MAP)] = { drm_rmmap_ioctl, 1, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)] = { drm_setsareactx, 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)] = { drm_getsareactx, 1, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_UNLOCK)] = { drm_unlock, 1, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_FINISH)] = { drm_noop, 1, 0 },
- [DRM_IOCTL_NR(DRM_IOCTL_ADD_BUFS)] = { drm_addbufs, 1, 1 },
+ [DRM_IOCTL_NR(DRM_IOCTL_ADD_BUFS)] = { drm_addbufs_ioctl, 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_CONTROL)] = { drm_control, 1, 1 },
- [DRM_IOCTL_NR(DRM_IOCTL_AGP_ACQUIRE)] = { drm_agp_acquire, 1, 1 },
+ [DRM_IOCTL_NR(DRM_IOCTL_AGP_ACQUIRE)] = { drm_agp_acquire_ioctl, 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_RELEASE)] = { drm_agp_release_ioctl, 1, 1 },
- [DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE)] = { drm_agp_enable, 1, 1 },
- [DRM_IOCTL_NR(DRM_IOCTL_AGP_INFO)] = { drm_agp_info, 1, 0 },
+ [DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE)] = { drm_agp_enable_ioctl, 1, 1 },
+ [DRM_IOCTL_NR(DRM_IOCTL_AGP_INFO)] = { drm_agp_info_ioctl, 1, 0 },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_ALLOC)] = { drm_agp_alloc, 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_FREE)] = { drm_agp_free, 1, 1 },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_BIND)] = { drm_agp_bind, 1, 1 },
dev->agp->memory = NULL;
if (dev->agp->acquired)
- drm_agp_release();
+ drm_agp_release(dev);
dev->agp->acquired = 0;
dev->agp->enabled = 0;
dev->sg = NULL;
}
- /* Clean up maps that weren't set up by the driver. */
TAILQ_FOREACH_SAFE(map, &dev->maplist, link, mapsave) {
- if (!map->kernel_owned)
- drm_remove_map(dev, map);
+ drm_rmmap(dev, map);
}
drm_dma_takedown(dev);
*/
static void drm_cleanup(drm_device_t *dev)
{
- drm_local_map_t *map;
-
DRM_DEBUG( "\n" );
#ifdef __FreeBSD__
drm_takedown(dev);
DRM_UNLOCK();
- /* Clean up any maps left over that had been allocated by the driver. */
- while ((map = TAILQ_FIRST(&dev->maplist)) != NULL) {
- drm_remove_map(dev, map);
- }
-
if ( dev->agp ) {
drm_agp_uninit();
free(dev->agp, M_DRM);
#include "mga_drv.h"
#include "drm_pciids.h"
-int mga_driver_device_is_agp(drm_device_t * dev)
/* drv_PCI_IDs comes from drm_pciids.h, generated from drm_pciids.txt. */
static drm_pci_id_list_t mga_pciidlist[] = {
mga_PCI_IDS
};
-static int mga_driver_device_is_agp(drm_device_t * dev);
-
extern drm_ioctl_desc_t mga_ioctls[];
extern int mga_max_ioctl;
+/**
+ * Determine if the device really is AGP or not.
+ *
+ * In addition to the usual tests performed by \c drm_device_is_agp, this
+ * function detects PCI G450 cards that appear to the system exactly like
+ * AGP G450 cards.
+ *
+ * \param dev The device to be tested.
+ *
+ * \returns
+ * If the device is a PCI G450, zero is returned. Otherwise non-zero is
+ * returned.
+ *
+ * \bug
+ * This function needs to be filled in! The implementation in
+ * linux-core/mga_drv.c shows what needs to be done.
+ */
+static int mga_driver_device_is_agp(drm_device_t * dev)
+{
+ return 1;
+}
+
static void mga_configure(drm_device_t *dev)
{
dev->dev_priv_size = sizeof(drm_mga_buf_priv_t);
dev->dma_ioctl = mga_dma_buffers;
dev->pretakedown = mga_driver_pretakedown;
dev->dma_quiescent = mga_driver_dma_quiescent;
-
dev->device_is_agp = mga_driver_device_is_agp;
dev->driver_ioctls = mga_ioctls;
dev->use_vbl_irq = 1;
}
-/**
- * Determine if the device really is AGP or not.
- *
- * In addition to the usual tests performed by \c drm_device_is_agp, this
- * function detects PCI G450 cards that appear to the system exactly like
- * AGP G450 cards.
- *
- * \param dev The device to be tested.
- *
- * \returns
- * If the device is a PCI G450, zero is returned. Otherwise non-zero is
- * returned.
- *
- * \bug
- * This function needs to be filled in! The implementation in
- * linux-core/mga_drv.c shows what needs to be done.
- */
-int mga_driver_device_is_agp(drm_device_t * dev)
-{
- return 1;
-}
+
#ifdef __FreeBSD__
static int
projects / platform / upstream / libdrm.git / commitdiff