drm: Sync drm_pci.c with Linux 4.7.10
authorFrançois Tigeot <ftigeot@wolfpond.org>
Fri, 10 Aug 2018 19:11:19 +0000 (21:11 +0200)
committerFrançois Tigeot <ftigeot@wolfpond.org>
Fri, 10 Aug 2018 19:11:19 +0000 (21:11 +0200)
sys/dev/drm/drm_drv.c
sys/dev/drm/drm_gem.c
sys/dev/drm/drm_irq.c
sys/dev/drm/drm_pci.c
sys/dev/drm/i915/i915_drv.c
sys/dev/drm/include/drm/drmP.h
sys/dev/drm/radeon/radeon_drv.c

index f4490a5..a81b1c1 100644 (file)
@@ -1171,6 +1171,7 @@ int drm_close(struct dev_close_args *ap)
        return 0;
 }
 
+/* XXX: this is supposed to be drm_release() */
 void drm_cdevpriv_dtor(void *cd)
 {
        struct drm_file *file_priv = cd;
@@ -1193,8 +1194,7 @@ void drm_cdevpriv_dtor(void *cd)
        if (dev->driver->driver_features & DRIVER_GEM)
                drm_gem_release(dev, file_priv);
 
-       if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) &&
-           !dev->driver->reclaim_buffers_locked)
+       if (drm_core_check_feature(dev, DRIVER_HAVE_DMA))
                drm_legacy_reclaim_buffers(dev, file_priv);
 
        funsetown(&dev->buf_sigio);
index 476138a..72ea6c6 100644 (file)
@@ -804,7 +804,7 @@ drm_gem_mmap_single(struct drm_device *dev, vm_ooffset_t *offset, vm_size_t size
        drm_gem_object_reference(gem_obj);
        DRM_UNLOCK(dev);
        vm_obj = cdev_pager_allocate(gem_obj, OBJT_MGTDEVICE,
-           dev->driver->gem_pager_ops, size, nprot,
+           dev->driver->gem_vm_ops, size, nprot,
            DRM_GEM_MAPPING_MAPOFF(*offset), curthread->td_ucred);
        if (vm_obj == NULL) {
                drm_gem_object_unreference_unlocked(gem_obj);
index 1dd6c53..622dbb1 100644 (file)
@@ -631,7 +631,7 @@ int drm_control(struct drm_device *dev, void *data,
 
        switch (ctl->func) {
        case DRM_INST_HANDLER:
-               irq = dev->irq;
+               irq = dev->pdev->irq;
 
                if (dev->if_version < DRM_IF_VERSION(1, 2) &&
                    ctl->irq != irq)
index 4947875..93fcd8c 100644 (file)
  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
 #include <linux/export.h>
 #include <drm/drmP.h>
 #include "drm_internal.h"
 #include "drm_legacy.h"
 
-/**********************************************************************/
-/** \name PCI memory */
-/*@{*/
-
-static void
-drm_pci_busdma_callback(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
-{
-       drm_dma_handle_t *dmah = arg;
-
-       if (error != 0)
-               return;
-
-       KASSERT(nsegs == 1, ("drm_pci_busdma_callback: bad dma segment count"));
-       dmah->busaddr = segs[0].ds_addr;
-}
-
 /**
- * \brief Allocate a PCI consistent memory block, for DMA.
+ * drm_pci_alloc - Allocate a PCI consistent memory block, for DMA.
+ * @dev: DRM device
+ * @size: size of block to allocate
+ * @align: alignment of block
+ *
+ * Return: A handle to the allocated memory block on success or NULL on
+ * failure.
  */
 drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t align)
 {
        drm_dma_handle_t *dmah;
-       int ret;
+       unsigned long addr;
+       size_t sz;
 
        /* pci_alloc_consistent only guarantees alignment to the smallest
         * PAGE_SIZE order which is greater than or equal to the requested size.
@@ -58,52 +51,34 @@ drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t ali
        if (align > size)
                return NULL;
 
-       /* Need power-of-two alignment, so fail the allocation if it isn't. */
-       if ((align & (align - 1)) != 0) {
-               DRM_ERROR("drm_pci_alloc with non-power-of-two alignment %d\n",
-                   (int)align);
-               return NULL;
-       }
-
        dmah = kmalloc(sizeof(drm_dma_handle_t), M_DRM, M_WAITOK | M_NULLOK);
        if (!dmah)
                return NULL;
 
        dmah->size = size;
+       dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL);
 
-       ret = bus_dma_tag_create(NULL, align, 0, /* tag, align, boundary */
-           ~0, BUS_SPACE_MAXADDR, /* lowaddr, highaddr */
-           NULL, NULL, /* filtfunc, filtfuncargs */
-           size, 1, size, /* maxsize, nsegs, maxsegsize */
-           0,          /* flags */
-           &dmah->tag);
-       if (ret != 0) {
+       if (dmah->vaddr == NULL) {
                kfree(dmah);
                return NULL;
        }
 
-       ret = bus_dmamem_alloc(dmah->tag, &dmah->vaddr,
-           BUS_DMA_WAITOK | BUS_DMA_ZERO | BUS_DMA_NOCACHE, &dmah->map);
-       if (ret != 0) {
-               bus_dma_tag_destroy(dmah->tag);
-               kfree(dmah);
-               return NULL;
-       }
+       memset(dmah->vaddr, 0, size);
 
-       ret = bus_dmamap_load(dmah->tag, dmah->map, dmah->vaddr, size,
-           drm_pci_busdma_callback, dmah, BUS_DMA_NOWAIT);
-       if (ret != 0) {
-               bus_dmamem_free(dmah->tag, dmah->vaddr, dmah->map);
-               bus_dma_tag_destroy(dmah->tag);
-               kfree(dmah);
-               return NULL;
+       /* XXX - Is virt_to_page() legal for consistent mem? */
+       /* Reserve */
+       for (addr = (unsigned long)dmah->vaddr, sz = size;
+            sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
+#if 0
+               SetPageReserved(virt_to_page((void *)addr));
+#endif
        }
 
-       memset(dmah->vaddr, 0, size);
-
        return dmah;
 }
 
+EXPORT_SYMBOL(drm_pci_alloc);
+
 /*
  * Free a PCI consistent memory block without freeing its descriptor.
  *
@@ -111,11 +86,21 @@ drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t ali
  */
 void __drm_legacy_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
 {
-       if (dmah == NULL)
-               return;
-
-       bus_dmamem_free(dmah->tag, dmah->vaddr, dmah->map);
-       bus_dma_tag_destroy(dmah->tag);
+       unsigned long addr;
+       size_t sz;
+
+       if (dmah->vaddr) {
+               /* XXX - Is virt_to_page() legal for consistent mem? */
+               /* Unreserve */
+               for (addr = (unsigned long)dmah->vaddr, sz = dmah->size;
+                    sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {
+#if 0
+                       ClearPageReserved(virt_to_page((void *)addr));
+#endif
+               }
+               dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr,
+                                 dmah->busaddr);
+       }
 }
 
 /**
@@ -129,6 +114,186 @@ void drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
        kfree(dmah);
 }
 
+EXPORT_SYMBOL(drm_pci_free);
+
+#ifdef CONFIG_PCI
+
+static int drm_get_pci_domain(struct drm_device *dev)
+{
+#ifndef __alpha__
+       /* For historical reasons, drm_get_pci_domain() is busticated
+        * on most archs and has to remain so for userspace interface
+        * < 1.4, except on alpha which was right from the beginning
+        */
+       if (dev->if_version < 0x10004)
+               return 0;
+#endif /* __alpha__ */
+
+#if 0
+       return pci_domain_nr(dev->pdev->bus);
+#else
+       return dev->pci_domain;
+#endif
+}
+
+int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master)
+{
+       master->unique = kasprintf(GFP_KERNEL, "pci:%04x:%02x:%02x.%d",
+                                       drm_get_pci_domain(dev),
+                                       dev->pdev->bus->number,
+                                       PCI_SLOT(dev->pdev->devfn),
+                                       PCI_FUNC(dev->pdev->devfn));
+       if (!master->unique)
+               return -ENOMEM;
+
+       master->unique_len = strlen(master->unique);
+       return 0;
+}
+EXPORT_SYMBOL(drm_pci_set_busid);
+
+int drm_pci_set_unique(struct drm_device *dev,
+                      struct drm_master *master,
+                      struct drm_unique *u)
+{
+       int domain, bus, slot, func, ret;
+
+       master->unique_len = u->unique_len;
+       master->unique = kmalloc(master->unique_len + 1, M_DRM, M_NOWAIT);
+       if (!master->unique) {
+               ret = -ENOMEM;
+               goto err;
+       }
+
+       if (copy_from_user(master->unique, u->unique, master->unique_len)) {
+               ret = -EFAULT;
+               goto err;
+       }
+
+       master->unique[master->unique_len] = '\0';
+
+       /* Return error if the busid submitted doesn't match the device's actual
+        * busid.
+        */
+       ret = ksscanf(master->unique, "PCI:%d:%d:%d", &bus, &slot, &func);
+       if (ret != 3) {
+               ret = -EINVAL;
+               goto err;
+       }
+
+       domain = bus >> 8;
+       bus &= 0xff;
+
+       if ((domain != drm_get_pci_domain(dev)) ||
+           (bus != dev->pdev->bus->number) ||
+           (slot != PCI_SLOT(dev->pdev->devfn)) ||
+           (func != PCI_FUNC(dev->pdev->devfn))) {
+               ret = -EINVAL;
+               goto err;
+       }
+       return 0;
+err:
+       return ret;
+}
+
+static int drm_pci_irq_by_busid(struct drm_device *dev, struct drm_irq_busid *p)
+{
+       if ((p->busnum >> 8) != dev->pci_domain ||
+           (p->busnum & 0xff) != dev->pci_bus ||
+           p->devnum != dev->pci_slot || p->funcnum != dev->pci_func)
+               return -EINVAL;
+
+       p->irq = dev->pdev->irq;
+
+       DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum,
+                 p->irq);
+       return 0;
+}
+
+/**
+ * drm_irq_by_busid - Get interrupt from bus ID
+ * @dev: DRM device
+ * @data: IOCTL parameter pointing to a drm_irq_busid structure
+ * @file_priv: DRM file private.
+ *
+ * Finds the PCI device with the specified bus id and gets its IRQ number.
+ * This IOCTL is deprecated, and will now return EINVAL for any busid not equal
+ * to that of the device that this DRM instance attached to.
+ *
+ * Return: 0 on success or a negative error code on failure.
+ */
+int drm_irq_by_busid(struct drm_device *dev, void *data,
+                    struct drm_file *file_priv)
+{
+       struct drm_irq_busid *p = data;
+
+       if (drm_core_check_feature(dev, DRIVER_MODESET))
+               return -EINVAL;
+
+       /* UMS was only ever support on PCI devices. */
+       if (WARN_ON(!dev->pdev))
+               return -EINVAL;
+
+       if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
+               return -EINVAL;
+
+       return drm_pci_irq_by_busid(dev, p);
+}
+
+/**
+ * drm_pci_init - Register matching PCI devices with the DRM subsystem
+ * @driver: DRM device driver
+ * @pdriver: PCI device driver
+ *
+ * Initializes a drm_device structures, registering the stubs and initializing
+ * the AGP device.
+ *
+ * NOTE: This function is deprecated. Modern modesetting drm drivers should use
+ * pci_register_driver() directly, this function only provides shadow-binding
+ * support for old legacy drivers on top of that core pci function.
+ *
+ * Return: 0 on success or a negative error code on failure.
+ */
+int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver)
+{
+#if 0
+       struct pci_dev *pdev = NULL;
+       const struct pci_device_id *pid;
+       int i;
+#endif
+
+       DRM_DEBUG("\n");
+
+       if (driver->driver_features & DRIVER_MODESET)
+               return pci_register_driver(pdriver);
+
+#if 0
+       /* If not using KMS, fall back to stealth mode manual scanning. */
+       INIT_LIST_HEAD(&driver->legacy_dev_list);
+       for (i = 0; pdriver->id_table[i].vendor != 0; i++) {
+               pid = &pdriver->id_table[i];
+
+               /* Loop around setting up a DRM device for each PCI device
+                * matching our ID and device class.  If we had the internal
+                * function that pci_get_subsys and pci_get_class used, we'd
+                * be able to just pass pid in instead of doing a two-stage
+                * thing.
+                */
+               pdev = NULL;
+               while ((pdev =
+                       pci_get_subsys(pid->vendor, pid->device, pid->subvendor,
+                                      pid->subdevice, pdev)) != NULL) {
+                       if ((pdev->class & pid->class_mask) != pid->class)
+                               continue;
+
+                       /* stealth mode requires a manual probe */
+                       pci_dev_get(pdev);
+                       drm_get_pci_dev(pdev, pid, driver);
+               }
+       }
+#endif
+       return 0;
+}
+
 int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask)
 {
        device_t root;
@@ -136,6 +301,8 @@ int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask)
        u32 lnkcap = 0, lnkcap2 = 0;
 
        *mask = 0;
+       if (!dev->pdev)
+               return -EINVAL;
 
        root = device_get_parent(dev->dev->bsddev);
 
@@ -172,7 +339,7 @@ int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask)
                if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB)
                        *mask |= DRM_PCIE_SPEED_25;
                if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB)
-                       *mask |= DRM_PCIE_SPEED_50;
+                       *mask |= (DRM_PCIE_SPEED_25 | DRM_PCIE_SPEED_50);
        }
 
        DRM_INFO("probing gen 2 caps for device %x:%x = %x/%x\n", pci_get_vendor(root), pci_get_device(root), lnkcap, lnkcap2);
@@ -202,34 +369,28 @@ int drm_pcie_get_max_link_width(struct drm_device *dev, u32 *mlw)
 EXPORT_SYMBOL(drm_pcie_get_max_link_width);
 #endif
 
-/**
- * Get interrupt from bus id.
- *
- * \param inode device inode.
- * \param file_priv DRM file private.
- * \param cmd command.
- * \param arg user argument, pointing to a drm_irq_busid structure.
- * \return zero on success or a negative number on failure.
- *
- * Finds the PCI device with the specified bus id and gets its IRQ number.
- * This IOCTL is deprecated, and will now return EINVAL for any busid not equal
- * to that of the device that this DRM instance attached to.
- */
-int drm_irq_by_busid(struct drm_device *dev, void *data,
-                    struct drm_file *file_priv)
-{
-       struct drm_irq_busid *irq = data;
+#else
 
-       if ((irq->busnum >> 8) != dev->pci_domain ||
-           (irq->busnum & 0xff) != dev->pci_bus ||
-           irq->devnum != dev->pci_slot ||
-           irq->funcnum != dev->pci_func)
-               return -EINVAL;
 
-       irq->irq = dev->irq;
+int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver)
+{
+       return -1;
+}
 
-       DRM_DEBUG("%d:%d:%d => IRQ %d\n",
-           irq->busnum, irq->devnum, irq->funcnum, irq->irq);
+void drm_pci_agp_destroy(struct drm_device *dev) {}
 
-       return 0;
+int drm_irq_by_busid(struct drm_device *dev, void *data,
+                    struct drm_file *file_priv)
+{
+       return -EINVAL;
 }
+
+int drm_pci_set_unique(struct drm_device *dev,
+                      struct drm_master *master,
+                      struct drm_unique *u)
+{
+       return -EINVAL;
+}
+#endif
+
+EXPORT_SYMBOL(drm_pci_init);
index 214984e..c33edd6 100644 (file)
@@ -1800,7 +1800,7 @@ static struct drm_driver driver = {
        .debugfs_cleanup = i915_debugfs_cleanup,
 #endif
        .gem_free_object = i915_gem_free_object,
-       .gem_pager_ops = &i915_gem_vm_ops,
+       .gem_vm_ops = &i915_gem_vm_ops,
 
        .dumb_create = i915_gem_dumb_create,
        .dumb_map_offset = i915_gem_mmap_gtt,
index 8b26f96..45137fb 100644 (file)
@@ -564,19 +564,18 @@ struct drm_master {
  */
 struct drm_driver {
        int (*load) (struct drm_device *, unsigned long flags);
-       int (*use_msi) (struct drm_device *, unsigned long flags);
        int (*firstopen) (struct drm_device *);
        int (*open) (struct drm_device *, struct drm_file *);
        void (*preclose) (struct drm_device *, struct drm_file *file_priv);
        void (*postclose) (struct drm_device *, struct drm_file *);
        void (*lastclose) (struct drm_device *);
        int (*unload) (struct drm_device *);
-       void (*reclaim_buffers_locked) (struct drm_device *,
-                                       struct drm_file *file_priv);
+       int (*suspend) (struct drm_device *, pm_message_t state);
+       int (*resume) (struct drm_device *);
        int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
        int (*dma_quiescent) (struct drm_device *);
-       int (*context_ctor) (struct drm_device *dev, int context);
        int (*context_dtor) (struct drm_device *dev, int context);
+       int (*set_busid)(struct drm_device *dev, struct drm_master *master);
 
        /**
         * get_vblank_counter - get raw hardware vblank counter
@@ -651,6 +650,7 @@ struct drm_driver {
         *               scanout position query. Can be NULL to skip timestamp.
         * \param *etime Target location for timestamp taken immediately after
         *               scanout position query. Can be NULL to skip timestamp.
+        * \param mode Current display timings.
         *
         * Returns vpos as a positive number while in active scanout area.
         * Returns vpos as a negative number inside vblank, counting the number
@@ -713,21 +713,78 @@ struct drm_driver {
        int (*irq_postinstall) (struct drm_device *dev);
        void (*irq_uninstall) (struct drm_device *dev);
 
+       /* Master routines */
+       int (*master_create)(struct drm_device *dev, struct drm_master *master);
+       void (*master_destroy)(struct drm_device *dev, struct drm_master *master);
        /**
-        * Driver-specific constructor for drm_gem_objects, to set up
-        * obj->driver_private.
+        * master_set is called whenever the minor master is set.
+        * master_drop is called whenever the minor master is dropped.
+        */
+
+       int (*master_set)(struct drm_device *dev, struct drm_file *file_priv,
+                         bool from_open);
+       void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv,
+                           bool from_release);
+
+       int (*debugfs_init)(struct drm_minor *minor);
+       void (*debugfs_cleanup)(struct drm_minor *minor);
+
+       /**
+        * @gem_free_object: deconstructor for drm_gem_objects
         *
-        * Returns 0 on success.
+        * This is deprecated and should not be used by new drivers. Use
+        * @gem_free_object_unlocked instead.
         */
        void (*gem_free_object) (struct drm_gem_object *obj);
+
+       /**
+        * @gem_free_object_unlocked: deconstructor for drm_gem_objects
+        *
+        * This is for drivers which are not encumbered with dev->struct_mutex
+        * legacy locking schemes. Use this hook instead of @gem_free_object.
+        */
+       void (*gem_free_object_unlocked) (struct drm_gem_object *obj);
+
        int (*gem_open_object) (struct drm_gem_object *, struct drm_file *);
        void (*gem_close_object) (struct drm_gem_object *, struct drm_file *);
 
-       int (*sysctl_init) (struct drm_device *dev,
-                   struct sysctl_ctx_list *ctx, struct sysctl_oid *top);
-       void (*sysctl_cleanup) (struct drm_device *dev);
-
-       drm_pci_id_list_t *id_entry;    /* PCI ID, name, and chipset private */
+       /**
+        * Hook for allocating the GEM object struct, for use by core
+        * helpers.
+        */
+       struct drm_gem_object *(*gem_create_object)(struct drm_device *dev,
+                                                   size_t size);
+
+       /* prime: */
+       /* export handle -> fd (see drm_gem_prime_handle_to_fd() helper) */
+       int (*prime_handle_to_fd)(struct drm_device *dev, struct drm_file *file_priv,
+                               uint32_t handle, uint32_t flags, int *prime_fd);
+       /* import fd -> handle (see drm_gem_prime_fd_to_handle() helper) */
+       int (*prime_fd_to_handle)(struct drm_device *dev, struct drm_file *file_priv,
+                               int prime_fd, uint32_t *handle);
+       /* export GEM -> dmabuf */
+       struct dma_buf * (*gem_prime_export)(struct drm_device *dev,
+                               struct drm_gem_object *obj, int flags);
+       /* import dmabuf -> GEM */
+       struct drm_gem_object * (*gem_prime_import)(struct drm_device *dev,
+                               struct dma_buf *dma_buf);
+       /* low-level interface used by drm_gem_prime_{import,export} */
+       int (*gem_prime_pin)(struct drm_gem_object *obj);
+       void (*gem_prime_unpin)(struct drm_gem_object *obj);
+       struct reservation_object * (*gem_prime_res_obj)(
+                               struct drm_gem_object *obj);
+       struct sg_table *(*gem_prime_get_sg_table)(struct drm_gem_object *obj);
+       struct drm_gem_object *(*gem_prime_import_sg_table)(
+                               struct drm_device *dev,
+                               struct dma_buf_attachment *attach,
+                               struct sg_table *sgt);
+       void *(*gem_prime_vmap)(struct drm_gem_object *obj);
+       void (*gem_prime_vunmap)(struct drm_gem_object *obj, void *vaddr);
+       int (*gem_prime_mmap)(struct drm_gem_object *obj,
+                               struct vm_area_struct *vma);
+
+       /* vga arb irq handler */
+       void (*vgaarb_irq)(struct drm_device *dev, bool state);
 
        /* dumb alloc support */
        int (*dumb_create)(struct drm_file *file_priv,
@@ -741,19 +798,35 @@ struct drm_driver {
                            uint32_t handle);
 
        /* Driver private ops for this object */
-       struct cdev_pager_ops *gem_pager_ops;
+       struct cdev_pager_ops *gem_vm_ops;
 
        int major;
        int minor;
        int patchlevel;
-       const char *name;               /* Simple driver name              */
-       const char *desc;               /* Longer driver name              */
-       const char *date;               /* Date of last major changes.     */
+       char *name;
+       char *desc;
+       char *date;
 
        u32 driver_features;
        int dev_priv_size;
        const struct drm_ioctl_desc *ioctls;
        int num_ioctls;
+       const struct file_operations *fops;
+
+       /* List of devices hanging off this driver with stealth attach. */
+       struct list_head legacy_dev_list;
+#ifdef __DragonFly__
+       int (*sysctl_init) (struct drm_device *dev,
+                   struct sysctl_ctx_list *ctx, struct sysctl_oid *top);
+       void (*sysctl_cleanup) (struct drm_device *dev);
+#endif /* __DragonFly__ */
+};
+
+enum drm_minor_type {
+       DRM_MINOR_LEGACY,
+       DRM_MINOR_CONTROL,
+       DRM_MINOR_RENDER,
+       DRM_MINOR_CNT,
 };
 
 /**
@@ -1247,6 +1320,29 @@ static __inline__ int drm_pci_device_is_agp(struct drm_device *dev)
 
        return (pci_find_extcap(dev->pdev->dev.bsddev, PCIY_AGP, NULL) == 0);
 }
+void drm_pci_agp_destroy(struct drm_device *dev);
+
+extern int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver);
+extern void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver);
+#ifdef CONFIG_PCI
+extern int drm_get_pci_dev(struct pci_dev *pdev,
+                          const struct pci_device_id *ent,
+                          struct drm_driver *driver);
+extern int drm_pci_set_busid(struct drm_device *dev, struct drm_master *master);
+#else
+static inline int drm_get_pci_dev(struct pci_dev *pdev,
+                                 const struct pci_device_id *ent,
+                                 struct drm_driver *driver)
+{
+       return -ENOSYS;
+}
+
+static inline int drm_pci_set_busid(struct drm_device *dev,
+                                   struct drm_master *master)
+{
+       return -ENOSYS;
+}
+#endif
 
 #define DRM_PCIE_SPEED_25 1
 #define DRM_PCIE_SPEED_50 2
index f23114a..c8d6fe5 100644 (file)
@@ -495,7 +495,6 @@ static struct drm_driver kms_driver = {
            DRIVER_HAVE_IRQ | DRIVER_IRQ_SHARED | DRIVER_GEM |
            DRIVER_PRIME | DRIVER_RENDER,
        .load = radeon_driver_load_kms,
-       .use_msi = radeon_msi_ok,
        .open = radeon_driver_open_kms,
        .preclose = radeon_driver_preclose_kms,
        .postclose = radeon_driver_postclose_kms,