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

Rename fn_tbl to driver. Core driver now uses pci_driver name which 

reflects the personality name.
main
Jon Smirl 2004-10-10 22:54:55 +00:00
parent 3f02a79351
commit ad549c5ae6
23 changed files with 145 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
linux-core/drmP.h
View File

@ -508,7 +508,7 @@ typedef struct drm_vbl_sig {
*/
struct drm_device;
struct drm_driver_fn {
struct drm_driver {
int (*preinit) (struct drm_device *, unsigned long flags);
void (*prerelease) (struct drm_device *, struct file * filp);
void (*pretakedown) (struct drm_device *);
@ -553,7 +553,6 @@ struct drm_driver_fn {
* DRM device structure.
*/
typedef struct drm_device {
const char *name; /**< Simple driver name */
char *unique; /**< Unique identifier: e.g., busid */
int unique_len; /**< Length of unique field */
dev_t device; /**< Device number for mknod */
@ -679,7 +678,7 @@ typedef struct drm_device {
drm_sigdata_t sigdata; /**< For block_all_signals */
sigset_t sigmask;
struct drm_driver_fn *fn_tbl;
struct drm_driver *driver;
drm_local_map_t *agp_buffer_map;
} drm_device_t;
@ -696,7 +695,7 @@ typedef struct drm_minor {
static __inline__ int drm_core_check_feature(struct drm_device *dev,
int feature)
{
return ((dev->fn_tbl->driver_features & feature) ? 1 : 0);
return ((dev->driver->driver_features & feature) ? 1 : 0);
}
#if __OS_HAS_AGP
@ -728,10 +727,10 @@ extern int drm_cpu_valid(void);
/* Driver support (drm_drv.h) */
extern int drm_fb_loaded;
extern int __devinit drm_init(struct pci_driver *driver,
extern int __devinit drm_init(struct pci_driver *pci_driver,
struct pci_device_id *pciidlist,
struct drm_driver_fn *driver_fn);
extern void __exit drm_exit(struct pci_driver *driver);
struct drm_driver *driver);
extern void __exit drm_exit(struct pci_driver *pci_driver);
extern void __exit drm_cleanup_pci(struct pci_dev *pdev);
extern int drm_version(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg);
@ -911,7 +910,7 @@ extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
/* Stub support (drm_stub.h) */
extern int drm_probe(struct pci_dev *pdev, const struct pci_device_id *ent,
struct drm_driver_fn *driver_fn);
struct drm_driver *driver);
extern int drm_put_minor(drm_device_t * dev);
extern int drm_get_secondary_minor(drm_device_t * dev,
drm_minor_t ** sec_minor);

14
linux-core/drm_bufs.c
View File

@ -90,7 +90,7 @@ int drm_initmap(drm_device_t * dev, unsigned int offset, unsigned int size,
list_add(&list->head, &dev->maplist->head);
up(&dev->struct_sem);
dev->fn_tbl->permanent_maps = 1;
dev->driver->permanent_maps = 1;
DRM_DEBUG("finished\n");
return 0;
@ -155,7 +155,7 @@ int drm_addmap(struct inode *inode, struct file *filp,
struct list_head *_list;
/* If permanent maps are implemented, maps must match */
if (dev->fn_tbl->permanent_maps) {
if (dev->driver->permanent_maps) {
DRM_DEBUG
("Looking for: offset = 0x%08lx, size = 0x%08lx, type = %d\n",
map->offset, map->size, map->type);
@ -516,7 +516,7 @@ int drm_addbufs_agp(struct inode *inode, struct file *filp,
init_waitqueue_head(&buf->dma_wait);
buf->filp = NULL;
buf->dev_priv_size = dev->fn_tbl->dev_priv_size;
buf->dev_priv_size = dev->driver->dev_priv_size;
buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);
if (!buf->dev_private) {
/* Set count correctly so we free the proper amount. */
@ -730,8 +730,8 @@ int drm_addbufs_pci(struct inode *inode, struct file *filp,
init_waitqueue_head(&buf->dma_wait);
buf->filp = NULL;
buf->dev_priv_size = dev->fn_tbl->dev_priv_size;
buf->dev_private = drm_alloc(dev->fn_tbl->dev_priv_size,
buf->dev_priv_size = dev->driver->dev_priv_size;
buf->dev_private = drm_alloc(dev->driver->dev_priv_size,
DRM_MEM_BUFS);
if (!buf->dev_private) {
/* Set count correctly so we free the proper amount. */
@ -911,8 +911,8 @@ int drm_addbufs_sg(struct inode *inode, struct file *filp,
init_waitqueue_head(&buf->dma_wait);
buf->filp = NULL;
buf->dev_priv_size = dev->fn_tbl->dev_priv_size;
buf->dev_private = drm_alloc(dev->fn_tbl->dev_priv_size,
buf->dev_priv_size = dev->driver->dev_priv_size;
buf->dev_private = drm_alloc(dev->driver->dev_priv_size,
DRM_MEM_BUFS);
if (!buf->dev_private) {
/* Set count correctly so we free the proper amount. */

8
linux-core/drm_context.c
View File

@ -419,8 +419,8 @@ int drm_addctx(struct inode *inode, struct file *filp,
}
if (ctx.handle != DRM_KERNEL_CONTEXT) {
if (dev->fn_tbl->context_ctor)
dev->fn_tbl->context_ctor(dev, ctx.handle);
if (dev->driver->context_ctor)
dev->driver->context_ctor(dev, ctx.handle);
}
ctx_entry = drm_alloc(sizeof(*ctx_entry), DRM_MEM_CTXLIST);
@ -554,8 +554,8 @@ int drm_rmctx(struct inode *inode, struct file *filp,
priv->remove_auth_on_close = 1;
}
if (ctx.handle != DRM_KERNEL_CONTEXT) {
if (dev->fn_tbl->context_dtor)
dev->fn_tbl->context_dtor(dev, ctx.handle);
if (dev->driver->context_dtor)
dev->driver->context_dtor(dev, ctx.handle);
drm_ctxbitmap_free(dev, ctx.handle);
}

30
linux-core/drm_drv.c
View File

@ -163,8 +163,8 @@ int drm_takedown(drm_device_t * dev)
DRM_DEBUG("\n");
if (dev->fn_tbl->pretakedown)
dev->fn_tbl->pretakedown(dev);
if (dev->driver->pretakedown)
dev->driver->pretakedown(dev);
if (dev->irq_enabled)
drm_irq_uninstall(dev);
@ -318,9 +318,9 @@ MODULE_PARM(drm_opts, "s");
* Expands the \c DRIVER_PREINIT and \c DRIVER_POST_INIT macros before and
* after the initialization for driver customization.
*/
int drm_init(struct pci_driver *driver,
int drm_init(struct pci_driver *pci_driver,
struct pci_device_id *pciidlist,
struct drm_driver_fn *driver_fn)
struct drm_driver *driver)
{
struct pci_dev *pdev;
struct pci_device_id *pid;
@ -357,7 +357,7 @@ int drm_init(struct pci_driver *driver,
}
if (drm_fb_loaded == 0)
pci_register_driver(driver);
pci_register_driver(pci_driver);
else {
for (i = 0; pciidlist[i].vendor != 0; i++) {
pid = &pciidlist[i];
@ -370,7 +370,7 @@ int drm_init(struct pci_driver *driver,
pdev))) {
/* stealth mode requires a manual probe */
pci_dev_get(pdev);
drm_probe(pdev, &pciidlist[i], driver_fn);
drm_probe(pdev, &pciidlist[i], driver);
}
}
DRM_INFO("Used old pci detect: framebuffer loaded\n");
@ -459,14 +459,14 @@ static void __exit drm_cleanup(drm_device_t * dev)
drm_free(dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS);
dev->agp = NULL;
}
if (dev->fn_tbl->postcleanup)
dev->fn_tbl->postcleanup(dev);
if (dev->driver->postcleanup)
dev->driver->postcleanup(dev);
if (drm_put_minor(dev))
DRM_ERROR("Cannot unload module\n");
}
void __exit drm_exit(struct pci_driver *driver)
void __exit drm_exit(struct pci_driver *pci_driver)
{
int i;
drm_device_t *dev;
@ -486,7 +486,7 @@ void __exit drm_exit(struct pci_driver *driver)
}
}
} else
pci_unregister_driver(driver);
pci_unregister_driver(pci_driver);
DRM_INFO("Module unloaded\n");
}
EXPORT_SYMBOL(drm_exit);
@ -578,7 +578,7 @@ int drm_version(struct inode *inode, struct file *filp,
return -EFAULT;
/* version is a required function to return the personality module version */
if ((ret = dev->fn_tbl->version(&version)))
if ((ret = dev->driver->version(&version)))
return ret;
if (copy_to_user(argp, &version, sizeof(version)))
@ -619,14 +619,14 @@ int drm_ioctl(struct inode *inode, struct file *filp,
if (nr < DRIVER_IOCTL_COUNT)
ioctl = &drm_ioctls[nr];
else if ((nr >= DRM_COMMAND_BASE)
|| (nr < DRM_COMMAND_BASE + dev->fn_tbl->num_ioctls))
ioctl = &dev->fn_tbl->ioctls[nr - DRM_COMMAND_BASE];
|| (nr < DRM_COMMAND_BASE + dev->driver->num_ioctls))
ioctl = &dev->driver->ioctls[nr - DRM_COMMAND_BASE];
else
goto err_i1;
func = ioctl->func;
if ((nr == DRM_IOCTL_NR(DRM_IOCTL_DMA)) && dev->fn_tbl->dma_ioctl) /* Local override? */
func = dev->fn_tbl->dma_ioctl;
if ((nr == DRM_IOCTL_NR(DRM_IOCTL_DMA)) && dev->driver->dma_ioctl) /* Local override? */
func = dev->driver->dma_ioctl;
if (!func) {
DRM_DEBUG("no function\n");

38
linux-core/drm_fops.c
View File

@ -41,8 +41,8 @@ static int drm_setup(drm_device_t * dev)
{
int i;
if (dev->fn_tbl->presetup)
dev->fn_tbl->presetup(dev);
if (dev->driver->presetup)
dev->driver->presetup(dev);
atomic_set(&dev->ioctl_count, 0);
atomic_set(&dev->vma_count, 0);
@ -105,8 +105,8 @@ static int drm_setup(drm_device_t * dev)
* drm_select_queue fails between the time the interrupt is
* initialized and the time the queues are initialized.
*/
if (dev->fn_tbl->postsetup)
dev->fn_tbl->postsetup(dev);
if (dev->driver->postsetup)
dev->driver->postsetup(dev);
return 0;
}
@ -176,7 +176,7 @@ int drm_stub_open(struct inode *inode, struct file *filp)
return -ENODEV;
old_fops = filp->f_op;
filp->f_op = fops_get(&dev->fn_tbl->fops);
filp->f_op = fops_get(&dev->driver->fops);
if (filp->f_op->open && (err = filp->f_op->open(inode, filp))) {
fops_put(filp->f_op);
filp->f_op = fops_get(old_fops);
@ -224,8 +224,8 @@ int drm_open_helper(struct inode *inode, struct file *filp, drm_device_t * dev)
priv->authenticated = capable(CAP_SYS_ADMIN);
priv->lock_count = 0;
if (dev->fn_tbl->open_helper) {
ret = dev->fn_tbl->open_helper(dev, priv);
if (dev->driver->open_helper) {
ret = dev->driver->open_helper(dev, priv);
if (ret < 0)
goto out_free;
}
@ -307,8 +307,8 @@ int drm_release(struct inode *inode, struct file *filp)
DRM_DEBUG("open_count = %d\n", dev->open_count);
if (dev->fn_tbl->prerelease)
dev->fn_tbl->prerelease(dev, filp);
if (dev->driver->prerelease)
dev->driver->prerelease(dev, filp);
/* ========================================================
* Begin inline drm_release
@ -324,8 +324,8 @@ int drm_release(struct inode *inode, struct file *filp)
DRM_DEBUG("File %p released, freeing lock for context %d\n",
filp, _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
if (dev->fn_tbl->release)
dev->fn_tbl->release(dev, filp);
if (dev->driver->release)
dev->driver->release(dev, filp);
drm_lock_free(dev, &dev->lock.hw_lock->lock,
_DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
@ -334,7 +334,7 @@ int drm_release(struct inode *inode, struct file *filp)
hardware at this point, possibly
processed via a callback to the X
server. */
} else if (dev->fn_tbl->release && priv->lock_count
} else if (dev->driver->release && priv->lock_count
&& dev->lock.hw_lock) {
/* The lock is required to reclaim buffers */
DECLARE_WAITQUEUE(entry, current);
@ -364,15 +364,15 @@ int drm_release(struct inode *inode, struct file *filp)
current->state = TASK_RUNNING;
remove_wait_queue(&dev->lock.lock_queue, &entry);
if (!retcode) {
if (dev->fn_tbl->release)
dev->fn_tbl->release(dev, filp);
if (dev->driver->release)
dev->driver->release(dev, filp);
drm_lock_free(dev, &dev->lock.hw_lock->lock,
DRM_KERNEL_CONTEXT);
}
}
if (drm_core_check_feature(dev, DRIVER_HAVE_DMA)) {
dev->fn_tbl->reclaim_buffers(filp);
dev->driver->reclaim_buffers(filp);
}
drm_fasync(-1, filp, 0);
@ -384,8 +384,8 @@ int drm_release(struct inode *inode, struct file *filp)
list_for_each_entry_safe(pos, n, &dev->ctxlist->head, head) {
if (pos->tag == priv &&
pos->handle != DRM_KERNEL_CONTEXT) {
if (dev->fn_tbl->context_dtor)
dev->fn_tbl->context_dtor(dev,
if (dev->driver->context_dtor)
dev->driver->context_dtor(dev,
pos->handle);
drm_ctxbitmap_free(dev, pos->handle);
@ -418,8 +418,8 @@ int drm_release(struct inode *inode, struct file *filp)
}
up(&dev->struct_sem);
if (dev->fn_tbl->free_filp_priv)
dev->fn_tbl->free_filp_priv(dev, priv);
if (dev->driver->free_filp_priv)
dev->driver->free_filp_priv(dev, priv);
drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
/* ========================================================

12
linux-core/drm_ioctl.c
View File

@ -109,12 +109,12 @@ int drm_setunique(struct inode *inode, struct file *filp,
dev->unique[dev->unique_len] = '\0';
dev->devname = drm_alloc(strlen(dev->name) + strlen(dev->unique) + 2,
dev->devname = drm_alloc(strlen(dev->pdev->driver->name) + strlen(dev->unique) + 2,
DRM_MEM_DRIVER);
if (!dev->devname)
return -ENOMEM;
sprintf(dev->devname, "%s@%s", dev->name, dev->unique);
sprintf(dev->devname, "%s@%s", dev->pdev->driver->name, dev->unique);
/* Return error if the busid submitted doesn't match the device's actual
* busid.
@ -146,12 +146,12 @@ static int drm_set_busid(drm_device_t * dev)
snprintf(dev->unique, dev->unique_len, "pci:%04x:%02x:%02x.%d",
dev->pci_domain, dev->pci_bus, dev->pci_slot, dev->pci_func);
dev->devname = drm_alloc(strlen(dev->name) + dev->unique_len + 2,
dev->devname = drm_alloc(strlen(dev->pdev->driver->name) + dev->unique_len + 2,
DRM_MEM_DRIVER);
if (dev->devname == NULL)
return ENOMEM;
sprintf(dev->devname, "%s@%s", dev->name, dev->unique);
sprintf(dev->devname, "%s@%s", dev->pdev->driver->name, dev->unique);
return 0;
}
@ -350,8 +350,8 @@ int drm_setversion(DRM_IOCTL_ARGS)
sv.drm_dd_minor < 0 || sv.drm_dd_minor > DRIVER_MINOR)
return EINVAL;
if (dev->fn_tbl->set_version)
dev->fn_tbl->set_version(dev, &sv);
if (dev->driver->set_version)
dev->driver->set_version(dev, &sv);
}
return 0;
}

12
linux-core/drm_irq.c
View File

@ -125,13 +125,13 @@ int drm_irq_install(drm_device_t * dev)
}
/* Before installing handler */
dev->fn_tbl->irq_preinstall(dev);
dev->driver->irq_preinstall(dev);
/* Install handler */
if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
sh_flags = SA_SHIRQ;
ret = request_irq(dev->irq, dev->fn_tbl->irq_handler,
ret = request_irq(dev->irq, dev->driver->irq_handler,
sh_flags, dev->devname, dev);
if (ret < 0) {
down(&dev->struct_sem);
@ -141,7 +141,7 @@ int drm_irq_install(drm_device_t * dev)
}
/* After installing handler */
dev->fn_tbl->irq_postinstall(dev);
dev->driver->irq_postinstall(dev);
return 0;
}
@ -170,7 +170,7 @@ int drm_irq_uninstall(drm_device_t * dev)
DRM_DEBUG("%s: irq=%d\n", __FUNCTION__, dev->irq);
dev->fn_tbl->irq_uninstall(dev);
dev->driver->irq_uninstall(dev);
free_irq(dev->irq, dev);
@ -316,9 +316,9 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
} else {
if (dev->fn_tbl->vblank_wait)
if (dev->driver->vblank_wait)
ret =
dev->fn_tbl->vblank_wait(dev,
dev->driver->vblank_wait(dev,
&vblwait.request.sequence);
do_gettimeofday(&now);

16
linux-core/drm_lock.c
View File

@ -108,15 +108,15 @@ int drm_lock(struct inode *inode, struct file *filp,
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->driver->dma_ready && (lock.flags & _DRM_LOCK_READY))
dev->driver->dma_ready(dev);
if (dev->fn_tbl->dma_quiescent && (lock.flags & _DRM_LOCK_QUIESCENT))
return dev->fn_tbl->dma_quiescent(dev);
if (dev->driver->dma_quiescent && (lock.flags & _DRM_LOCK_QUIESCENT))
return dev->driver->dma_quiescent(dev);
if (dev->fn_tbl->kernel_context_switch
if (dev->driver->kernel_context_switch
&& dev->last_context != lock.context) {
dev->fn_tbl->kernel_context_switch(dev, dev->last_context,
dev->driver->kernel_context_switch(dev, dev->last_context,
lock.context);
}
@ -154,8 +154,8 @@ int drm_unlock(struct inode *inode, struct file *filp,
atomic_inc(&dev->counts[_DRM_STAT_UNLOCKS]);
if (dev->fn_tbl->kernel_context_switch_unlock)
dev->fn_tbl->kernel_context_switch_unlock(dev);
if (dev->driver->kernel_context_switch_unlock)
dev->driver->kernel_context_switch_unlock(dev);
else {
drm_lock_transfer(dev, &dev->lock.hw_lock->lock,
DRM_KERNEL_CONTEXT);

4
linux-core/drm_proc.c
View File

@ -175,10 +175,10 @@ static int drm_name_info(char *buf, char **start, off_t offset, int request,
if (dev->unique) {
DRM_PROC_PRINT("%s 0x%lx %s\n",
dev->name, (long)old_encode_dev(dev->device),
dev->pdev->driver->name, (long)old_encode_dev(dev->device),
dev->unique);
} else {
DRM_PROC_PRINT("%s 0x%lx\n", dev->name,
DRM_PROC_PRINT("%s 0x%lx\n", dev->pdev->driver->name,
(long)old_encode_dev(dev->device));
}

15
linux-core/drm_stub.c
View File

@ -54,7 +54,7 @@ struct proc_dir_entry *drm_proc_root;
static int fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
const struct pci_device_id *ent,
struct drm_driver_fn *driver_fn)
struct drm_driver *driver)
{
int retcode;
@ -63,7 +63,6 @@ static int fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
sema_init(&dev->struct_sem, 1);
sema_init(&dev->ctxlist_sem, 1);
dev->name = DRIVER_NAME;
dev->pdev = pdev;
#ifdef __alpha__
@ -91,10 +90,10 @@ static int fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
dev->types[4] = _DRM_STAT_LOCKS;
dev->types[5] = _DRM_STAT_UNLOCKS;
dev->fn_tbl = driver_fn;
dev->driver = driver;
if (dev->fn_tbl->preinit)
if ((retcode = dev->fn_tbl->preinit(dev, ent->driver_data)))
if (dev->driver->preinit)
if ((retcode = dev->driver->preinit(dev, ent->driver_data)))
goto error_out_unreg;
if (drm_core_has_AGP(dev)) {
@ -125,7 +124,7 @@ static int fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
/* postinit is a required function to display the signon banner */
/* drivers add secondary heads here if needed */
if ((retcode = dev->fn_tbl->postinit(dev, ent->driver_data)))
if ((retcode = dev->driver->postinit(dev, ent->driver_data)))
goto error_out_unreg;
return 0;
@ -147,7 +146,7 @@ static int fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
* Try and register, if we fail to register, backout previous work.
*/
int drm_probe(struct pci_dev *pdev, const struct pci_device_id *ent,
struct drm_driver_fn *driver_fn)
struct drm_driver *driver)
{
struct class_device *dev_class;
drm_device_t *dev;
@ -173,7 +172,7 @@ int drm_probe(struct pci_dev *pdev, const struct pci_device_id *ent,
pci_request_regions(pdev, DRIVER_NAME);
pci_enable_device(pdev);
}
if ((ret = fill_in_dev(dev, pdev, ent, driver_fn))) {
if ((ret = fill_in_dev(dev, pdev, ent, driver))) {
printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
goto err_g1;
}

4
linux-core/drm_vm.c
View File

@ -577,7 +577,7 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
map = r_list->map;
if (!map)
continue;
off = dev->fn_tbl->get_map_ofs(map);
off = dev->driver->get_map_ofs(map);
if (off == VM_OFFSET(vma))
break;
}
@ -638,7 +638,7 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma)
vma->vm_page_prot =
pgprot_writecombine(vma->vm_page_prot);
#endif
offset = dev->fn_tbl->get_reg_ofs(dev);
offset = dev->driver->get_reg_ofs(dev);
#ifdef __sparc__
if (io_remap_page_range(DRM_RPR_ARG(vma) vma->vm_start,
VM_OFFSET(vma) + offset,

10
linux-core/ffb_drv.c
View File

@ -305,7 +305,7 @@ static struct pci_device_id pciidlist[] = {
ffb_PCI_IDS
};
static struct drm_driver_fn ffb_driver_fn = {
static struct drm_driver ffb_driver = {
.release = ffb_driver_release,
.presetup = ffb_driver_presetup,
.pretakedown = ffb_driver_pretakedown,
@ -330,10 +330,10 @@ static struct drm_driver_fn ffb_driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -342,12 +342,12 @@ static struct pci_driver driver = {
static int __init ffb_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit ffb_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(ffb_init);

10
linux-core/i810_drv.c
View File

@ -92,7 +92,7 @@ static drm_ioctl_desc_t ioctls[] = {
[DRM_IOCTL_NR(DRM_I810_FLIP)] = {i810_flip_bufs, 1, 0}
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features =
DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR |
DRIVER_HAVE_DMA | DRIVER_DMA_QUEUE,
@ -120,10 +120,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -132,12 +132,12 @@ static struct pci_driver driver = {
static int __init i810_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit i810_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(i810_init);

10
linux-core/i830_drv.c
View File

@ -93,7 +93,7 @@ static drm_ioctl_desc_t ioctls[] = {
[DRM_IOCTL_NR(DRM_I830_SETPARAM)] = {i830_setparam, 1, 0}
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features =
DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR |
DRIVER_HAVE_DMA | DRIVER_DMA_QUEUE,
@ -130,10 +130,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -142,12 +142,12 @@ static struct pci_driver driver = {
static int __init i830_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit i830_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(i830_init);

10
linux-core/i915_drv.c
View File

@ -65,7 +65,7 @@ static drm_ioctl_desc_t ioctls[] = {
[DRM_IOCTL_NR(DRM_I915_CMDBUFFER)] = {i915_cmdbuffer, 1, 0}
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features =
DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR |
DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED,
@ -94,10 +94,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -106,12 +106,12 @@ static struct pci_driver driver = {
static int __init i915_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit i915_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(i915_init);

10
linux-core/mach64_drv.c
View File

@ -81,7 +81,7 @@ static drm_ioctl_desc_t ioctls[] = {
[DRM_IOCTL_NR(DRM_MACH64_GETPARAM)] = {mach64_get_param, 1, 0},
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features =
DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_HAVE_DMA
| DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL,
@ -111,10 +111,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -123,12 +123,12 @@ static struct pci_driver driver = {
static int __init mach64_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit mach64_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(mach64_init);

10
linux-core/mga_drv.c
View File

@ -84,7 +84,7 @@ static drm_ioctl_desc_t ioctls[] = {
[DRM_IOCTL_NR(DRM_MGA_GETPARAM)] = {mga_getparam, 1, 0},
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features =
DRIVER_USE_AGP | DRIVER_REQUIRE_AGP | DRIVER_USE_MTRR |
DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED |
@ -116,10 +116,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -128,12 +128,12 @@ static struct pci_driver driver = {
static int __init mga_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit mga_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(mga_init);

10
linux-core/r128_drv.c
View File

@ -93,7 +93,7 @@ static drm_ioctl_desc_t ioctls[] = {
[DRM_IOCTL_NR(DRM_R128_GETPARAM)] = {r128_getparam, 1, 0},
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features =
DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_SG |
DRIVER_HAVE_DMA | DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED |
@ -127,10 +127,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -139,12 +139,12 @@ static struct pci_driver driver = {
static int __init r128_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit r128_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(r128_init);

10
linux-core/radeon_drv.c
View File

@ -128,7 +128,7 @@ static drm_ioctl_desc_t ioctls[] = {
[DRM_IOCTL_NR(DRM_RADEON_SETPARAM)] = {radeon_cp_setparam, 1, 0},
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features =
DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_PCI_DMA | DRIVER_SG |
DRIVER_HAVE_IRQ | DRIVER_HAVE_DMA | DRIVER_IRQ_SHARED |
@ -167,10 +167,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -179,12 +179,12 @@ static struct pci_driver driver = {
static int __init radeon_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit radeon_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(radeon_init);

10
linux-core/savage_drv.c
View File

@ -282,7 +282,7 @@ static drm_ioctl_desc_t ioctls[] = {
#endif
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR,
.reclaim_buffers = drm_core_reclaim_buffers,
.get_map_ofs = drm_core_get_map_ofs,
@ -304,10 +304,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -316,12 +316,12 @@ static struct pci_driver driver = {
static int __init savage_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit savage_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(savage_init);

10
linux-core/sis_drv.c
View File

@ -70,7 +70,7 @@ static drm_ioctl_desc_t ioctls[] = {
[DRM_IOCTL_NR(DRM_SIS_FB_INIT)] = {sis_fb_init, 1, 1}
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features = DRIVER_USE_AGP | DRIVER_USE_MTRR,
.context_ctor = sis_init_context,
.context_dtor = sis_final_context,
@ -93,10 +93,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -105,12 +105,12 @@ static struct pci_driver driver = {
static int __init sis_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit sis_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(sis_init);

10
linux-core/tdfx_drv.c
View File

@ -65,7 +65,7 @@ static struct pci_device_id pciidlist[] = {
tdfx_PCI_IDS
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features = DRIVER_USE_MTRR,
.reclaim_buffers = drm_core_reclaim_buffers,
.get_map_ofs = drm_core_get_map_ofs,
@ -84,10 +84,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -96,12 +96,12 @@ static struct pci_driver driver = {
static int __init tdfx_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit tdfx_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(tdfx_init);

10
shared-core/via_drv.c
View File

@ -71,7 +71,7 @@ static drm_ioctl_desc_t ioctls[] = {
[DRM_IOCTL_NR(DRM_VIA_PCICMD)] = {via_pci_cmdbuffer, 1, 0}
};
static struct drm_driver_fn driver_fn = {
static struct drm_driver driver = {
.driver_features =
DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_IRQ |
DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL,
@ -101,10 +101,10 @@ static struct drm_driver_fn driver_fn = {
static int probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
return drm_probe(pdev, ent, &driver_fn);
return drm_probe(pdev, ent, &driver);
}
static struct pci_driver driver = {
static struct pci_driver pci_driver = {
.name = DRIVER_NAME,
.id_table = pciidlist,
.probe = probe,
@ -113,12 +113,12 @@ static struct pci_driver driver = {
static int __init via_init(void)
{
return drm_init(&driver, pciidlist, &driver_fn);
return drm_init(&pci_driver, pciidlist, &driver);
}
static void __exit via_exit(void)
{
drm_exit(&driver);
drm_exit(&pci_driver);
}
module_init(via_init);