drm_context.o drm_dma.o \
                drm_fops.o drm_gem.o drm_ioctl.o drm_irq.o \
                drm_lock.o drm_memory.o drm_drv.o drm_vm.o \
-               drm_agpsupport.o drm_scatter.o drm_pci.o \
+               drm_scatter.o drm_pci.o \
                drm_platform.o drm_sysfs.o drm_hashtab.o drm_mm.o \
                drm_crtc.o drm_modes.o drm_edid.o \
                drm_info.o drm_debugfs.o drm_encoder_slave.o \
 drm-$(CONFIG_PCI) += ati_pcigart.o
 drm-$(CONFIG_DRM_PANEL) += drm_panel.o
 drm-$(CONFIG_OF) += drm_of.o
+drm-$(CONFIG_AGP) += drm_agpsupport.o
 
 drm_kms_helper-y := drm_crtc_helper.o drm_dp_helper.o drm_probe_helper.o \
                drm_plane_helper.o drm_dp_mst_topology.o drm_atomic_helper.o
 
 #include <linux/slab.h>
 #include "drm_legacy.h"
 
-#if __OS_HAS_AGP
-
 #include <asm/agp.h>
 
 /**
        return mem;
 }
 EXPORT_SYMBOL(drm_agp_bind_pages);
-
-#endif /* __OS_HAS_AGP */
 
        }
 }
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
 /**
  * Add AGP buffers for DMA transfers.
  *
        return 0;
 }
 EXPORT_SYMBOL(drm_legacy_addbufs_agp);
-#endif                         /* __OS_HAS_AGP */
+#endif /* CONFIG_AGP */
 
 int drm_legacy_addbufs_pci(struct drm_device *dev,
                           struct drm_buf_desc *request)
        if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
                return -EINVAL;
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (request->flags & _DRM_AGP_BUFFER)
                ret = drm_legacy_addbufs_agp(dev, request);
        else
 
        return 0;
 }
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
 typedef struct drm_agp_mode32 {
        u32 mode;       /**< AGP mode */
 } drm_agp_mode32_t;
 
        return drm_ioctl(file, DRM_IOCTL_AGP_UNBIND, (unsigned long)request);
 }
-#endif                         /* __OS_HAS_AGP */
+#endif /* CONFIG_AGP */
 
 typedef struct drm_scatter_gather32 {
        u32 size;       /**< In bytes -- will round to page boundary */
        [DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX32)] = compat_drm_getsareactx,
        [DRM_IOCTL_NR(DRM_IOCTL_RES_CTX32)] = compat_drm_resctx,
        [DRM_IOCTL_NR(DRM_IOCTL_DMA32)] = compat_drm_dma,
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        [DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE32)] = compat_drm_agp_enable,
        [DRM_IOCTL_NR(DRM_IOCTL_AGP_INFO32)] = compat_drm_agp_info,
        [DRM_IOCTL_NR(DRM_IOCTL_AGP_ALLOC32)] = compat_drm_agp_alloc,
 
 
        DRM_IOCTL_DEF(DRM_IOCTL_CONTROL, drm_control, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        DRM_IOCTL_DEF(DRM_IOCTL_AGP_ACQUIRE, drm_agp_acquire_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
        DRM_IOCTL_DEF(DRM_IOCTL_AGP_RELEASE, drm_agp_release_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
        DRM_IOCTL_DEF(DRM_IOCTL_AGP_ENABLE, drm_agp_enable_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
 
 #include <drm/drmP.h>
 #include "drm_legacy.h"
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
 
 #ifdef HAVE_PAGE_AGP
 # include <asm/agp.h>
        return agp_unbind_memory(handle);
 }
 
-#else  /*  __OS_HAS_AGP  */
+#else /*  CONFIG_AGP  */
 static inline void *agp_remap(unsigned long offset, unsigned long size,
                              struct drm_device * dev)
 {
        return NULL;
 }
 
-#endif                         /* agp */
+#endif /* CONFIG_AGP */
 
 void drm_legacy_ioremap(struct drm_local_map *map, struct drm_device *dev)
 {
 
  * 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
+#if IS_ENABLED(CONFIG_AGP)
 static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
        struct drm_file *priv = vma->vm_file->private_data;
 vm_fault_error:
        return VM_FAULT_SIGBUS; /* Disallow mremap */
 }
-#else                          /* __OS_HAS_AGP */
+#else
 static int drm_do_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 {
        return VM_FAULT_SIGBUS;
 }
-#endif                         /* __OS_HAS_AGP */
+#endif
 
 /**
  * \c nopage method for shared virtual memory.
         * --BenH.
         */
        if (!vma->vm_pgoff
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
            && (!dev->agp
                || dev->agp->agp_info.device->vendor != PCI_VENDOR_ID_APPLE)
 #endif
 
        return 0;
 }
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
 /**
  * Bootstrap the driver for AGP DMA.
  *
                        drm_legacy_ioremapfree(dev->agp_buffer_map, dev);
 
                if (dev_priv->used_new_dma_init) {
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
                        if (dev_priv->agp_handle != 0) {
                                struct drm_agp_binding unbind_req;
                                struct drm_agp_buffer free_req;
 
 nouveau_ttm_tt_create(struct ttm_bo_device *bdev, unsigned long size,
                      uint32_t page_flags, struct page *dummy_read)
 {
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        struct nouveau_drm *drm = nouveau_bdev(bdev);
 
        if (drm->agp.bridge) {
                /* System memory */
                return 0;
        case TTM_PL_TT:
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
                if (drm->agp.bridge) {
                        mem->bus.offset = mem->start << PAGE_SHIFT;
                        mem->bus.base = drm->agp.base;
            ttm->caching_state == tt_uncached)
                return ttm_dma_populate(ttm_dma, dev->dev);
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (drm->agp.bridge) {
                return ttm_agp_tt_populate(ttm);
        }
                return;
        }
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (drm->agp.bridge) {
                ttm_agp_tt_unpopulate(ttm);
                return;
 
        /* The manual (p. 2) says this address is in "VM space".  This
         * means it's an offset from the start of AGP space.
         */
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (!dev_priv->is_pci)
                ring_start = dev_priv->cce_ring->offset - dev->agp->base;
        else
            (drm_r128_sarea_t *) ((u8 *) dev_priv->sarea->handle +
                                  init->sarea_priv_offset);
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (!dev_priv->is_pci) {
                drm_legacy_ioremap_wc(dev_priv->cce_ring, dev);
                drm_legacy_ioremap_wc(dev_priv->ring_rptr, dev);
                        (void *)(unsigned long)dev->agp_buffer_map->offset;
        }
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (!dev_priv->is_pci)
                dev_priv->cce_buffers_offset = dev->agp->base;
        else
        dev_priv->sarea_priv->last_dispatch = 0;
        R128_WRITE(R128_LAST_DISPATCH_REG, dev_priv->sarea_priv->last_dispatch);
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->is_pci) {
 #endif
                dev_priv->gart_info.table_mask = DMA_BIT_MASK(32);
                        return -ENOMEM;
                }
                R128_WRITE(R128_PCI_GART_PAGE, dev_priv->gart_info.bus_addr);
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        }
 #endif
 
        if (dev->dev_private) {
                drm_r128_private_t *dev_priv = dev->dev_private;
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
                if (!dev_priv->is_pci) {
                        if (dev_priv->cce_ring != NULL)
                                drm_legacy_ioremapfree(dev_priv->cce_ring, dev);
 
        SET_RING_HEAD(dev_priv, 0);
        dev_priv->ring.tail = 0;
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP) {
                rptr_addr = dev_priv->ring_rptr->offset
                        - dev->agp->base +
                     dev_priv->ring.size_l2qw);
 #endif
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP) {
                /* XXX */
                radeon_write_agp_base(dev_priv, dev->agp->base);
        if (dev->irq_enabled)
                drm_irq_uninstall(dev);
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP) {
                if (dev_priv->cp_ring != NULL) {
                        drm_legacy_ioremapfree(dev_priv->cp_ring, dev);
                }
        }
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        /* XXX */
        if (dev_priv->flags & RADEON_IS_AGP) {
                drm_legacy_ioremap_wc(dev_priv->cp_ring, dev);
                 * location in the card and on the bus, though we have to
                 * align it down.
                 */
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
                /* XXX */
                if (dev_priv->flags & RADEON_IS_AGP) {
                        base = dev->agp->base;
                                 base, dev_priv->gart_vm_start);
        }
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        /* XXX */
        if (dev_priv->flags & RADEON_IS_AGP)
                dev_priv->gart_buffers_offset = (dev->agp_buffer_map->offset
 
        dev_priv->ring.high_mark = RADEON_RING_HIGH_MARK;
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP) {
                /* XXX turn off pcie gart */
        } else
 
 #include "radeon.h"
 #include <drm/radeon_drm.h>
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
 
 struct radeon_agpmode_quirk {
        u32 hostbridge_vendor;
 
 int radeon_agp_init(struct radeon_device *rdev)
 {
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        struct radeon_agpmode_quirk *p = radeon_agpmode_quirk_list;
        struct drm_agp_mode mode;
        struct drm_agp_info info;
 
 void radeon_agp_resume(struct radeon_device *rdev)
 {
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        int r;
        if (rdev->flags & RADEON_IS_AGP) {
                r = radeon_agp_init(rdev);
 
 void radeon_agp_fini(struct radeon_device *rdev)
 {
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (rdev->ddev->agp && rdev->ddev->agp->acquired) {
                drm_agp_release(rdev->ddev);
        }
 
                             ((dev_priv->gart_vm_start - 1) & 0xffff0000)
                             | (dev_priv->fb_location >> 16));
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP) {
                radeon_write_agp_base(dev_priv, dev->agp->base);
 
        SET_RING_HEAD(dev_priv, cur_read_ptr);
        dev_priv->ring.tail = cur_read_ptr;
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP) {
                RADEON_WRITE(RADEON_CP_RB_RPTR_ADDR,
                             dev_priv->ring_rptr->offset
                }
        }
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP) {
                drm_legacy_ioremap_wc(dev_priv->cp_ring, dev);
                drm_legacy_ioremap_wc(dev_priv->ring_rptr, dev);
                 * location in the card and on the bus, though we have to
                 * align it down.
                 */
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
                if (dev_priv->flags & RADEON_IS_AGP) {
                        base = dev->agp->base;
                        /* Check if valid */
                        RADEON_READ(RADEON_CONFIG_APER_SIZE);
        }
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP)
                dev_priv->gart_buffers_offset = (dev->agp_buffer_map->offset
                                                 - dev->agp->base
 
        dev_priv->ring.high_mark = RADEON_RING_HIGH_MARK;
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP) {
                /* Turn off PCI GART */
                radeon_set_pcigart(dev_priv, 0);
        if (dev->irq_enabled)
                drm_irq_uninstall(dev);
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP) {
                if (dev_priv->cp_ring != NULL) {
                        drm_legacy_ioremapfree(dev_priv->cp_ring, dev);
 
        DRM_DEBUG("Starting radeon_do_resume_cp()\n");
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (dev_priv->flags & RADEON_IS_AGP) {
                /* Turn off PCI GART */
                radeon_set_pcigart(dev_priv, 0);
 
                man->available_caching = TTM_PL_MASK_CACHING;
                man->default_caching = TTM_PL_FLAG_CACHED;
                man->flags = TTM_MEMTYPE_FLAG_MAPPABLE | TTM_MEMTYPE_FLAG_CMA;
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
                if (rdev->flags & RADEON_IS_AGP) {
                        if (!rdev->ddev->agp) {
                                DRM_ERROR("AGP is not enabled for memory type %u\n",
                /* system memory */
                return 0;
        case TTM_PL_TT:
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
                if (rdev->flags & RADEON_IS_AGP) {
                        /* RADEON_IS_AGP is set only if AGP is active */
                        mem->bus.offset = mem->start << PAGE_SHIFT;
        struct radeon_ttm_tt *gtt;
 
        rdev = radeon_get_rdev(bdev);
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (rdev->flags & RADEON_IS_AGP) {
                return ttm_agp_tt_create(bdev, rdev->ddev->agp->bridge,
                                         size, page_flags, dummy_read_page);
        }
 
        rdev = radeon_get_rdev(ttm->bdev);
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (rdev->flags & RADEON_IS_AGP) {
                return ttm_agp_tt_populate(ttm);
        }
                return;
 
        rdev = radeon_get_rdev(ttm->bdev);
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
        if (rdev->flags & RADEON_IS_AGP) {
                ttm_agp_tt_unpopulate(ttm);
                return;
 
 struct drm_device;
 struct drm_file;
 
-#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && \
-                                             defined(MODULE)))
-
 struct drm_agp_head {
        struct agp_kern_info agp_info;
        struct list_head memory;
        unsigned long page_mask;
 };
 
-#if __OS_HAS_AGP
+#if IS_ENABLED(CONFIG_AGP)
 
 void drm_free_agp(struct agp_memory * handle, int pages);
 int drm_bind_agp(struct agp_memory * handle, unsigned int start);
 int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
                       struct drm_file *file_priv);
 
-#else /* __OS_HAS_AGP */
+#else /* CONFIG_AGP */
 
 static inline void drm_free_agp(struct agp_memory * handle, int pages)
 {
        return -ENODEV;
 }
 
-#endif /* __OS_HAS_AGP */
+#endif /* CONFIG_AGP */
 
 #endif /* _DRM_AGPSUPPORT_H_ */