drm: Move drm_memory.c map support declarations to <drm/drm_legacy.h>

[firefly-linux-kernel-4.4.55.git] / drivers / gpu / drm / mga / mga_dma.c

diff --git a/drivers/gpu/drm/mga/mga_dma.c b/drivers/gpu/drm/mga/mga_dma.c
index c3bf059ba720569540145f225222e0f2b444827c..8cfa9cb74c8679a329ff14293f0e1fd4b2927323 100644 (file)
--- a/drivers/gpu/drm/mga/mga_dma.c
+++ b/drivers/gpu/drm/mga/mga_dma.c
@@ -502,31 +502,31 @@ static int mga_do_agp_dma_bootstrap(struct drm_device *dev,
                return err;
        }
 
-       /* Make drm_addbufs happy by not trying to create a mapping for less
-        * than a page.
+       /* Make drm_legacy_addbufs happy by not trying to create a mapping for
+        * less than a page.
         */
        if (warp_size < PAGE_SIZE)
                warp_size = PAGE_SIZE;
 
        offset = 0;
-       err = drm_addmap(dev, offset, warp_size,
-                        _DRM_AGP, _DRM_READ_ONLY, &dev_priv->warp);
+       err = drm_legacy_addmap(dev, offset, warp_size,
+                               _DRM_AGP, _DRM_READ_ONLY, &dev_priv->warp);
        if (err) {
                DRM_ERROR("Unable to map WARP microcode: %d\n", err);
                return err;
        }
 
        offset += warp_size;
-       err = drm_addmap(dev, offset, dma_bs->primary_size,
-                        _DRM_AGP, _DRM_READ_ONLY, &dev_priv->primary);
+       err = drm_legacy_addmap(dev, offset, dma_bs->primary_size,
+                               _DRM_AGP, _DRM_READ_ONLY, &dev_priv->primary);
        if (err) {
                DRM_ERROR("Unable to map primary DMA region: %d\n", err);
                return err;
        }
 
        offset += dma_bs->primary_size;
-       err = drm_addmap(dev, offset, secondary_size,
-                        _DRM_AGP, 0, &dev->agp_buffer_map);
+       err = drm_legacy_addmap(dev, offset, secondary_size,
+                               _DRM_AGP, 0, &dev->agp_buffer_map);
        if (err) {
                DRM_ERROR("Unable to map secondary DMA region: %d\n", err);
                return err;
@@ -538,7 +538,7 @@ static int mga_do_agp_dma_bootstrap(struct drm_device *dev,
        req.flags = _DRM_AGP_BUFFER;
        req.agp_start = offset;
 
-       err = drm_addbufs_agp(dev, &req);
+       err = drm_legacy_addbufs_agp(dev, &req);
        if (err) {
                DRM_ERROR("Unable to add secondary DMA buffers: %d\n", err);
                return err;
@@ -559,16 +559,16 @@ static int mga_do_agp_dma_bootstrap(struct drm_device *dev,
        }
 
        offset += secondary_size;
-       err = drm_addmap(dev, offset, agp_size - offset,
-                        _DRM_AGP, 0, &dev_priv->agp_textures);
+       err = drm_legacy_addmap(dev, offset, agp_size - offset,
+                               _DRM_AGP, 0, &dev_priv->agp_textures);
        if (err) {
                DRM_ERROR("Unable to map AGP texture region %d\n", err);
                return err;
        }
 
-       drm_core_ioremap(dev_priv->warp, dev);
-       drm_core_ioremap(dev_priv->primary, dev);
-       drm_core_ioremap(dev->agp_buffer_map, dev);
+       drm_legacy_ioremap(dev_priv->warp, dev);
+       drm_legacy_ioremap(dev_priv->primary, dev);
+       drm_legacy_ioremap(dev->agp_buffer_map, dev);
 
        if (!dev_priv->warp->handle ||
            !dev_priv->primary->handle || !dev->agp_buffer_map->handle) {
@@ -602,7 +602,7 @@ static int mga_do_agp_dma_bootstrap(struct drm_device *dev,
  *
  * \todo
  * Determine whether the maximum address passed to drm_pci_alloc is correct.
- * The same goes for drm_addbufs_pci.
+ * The same goes for drm_legacy_addbufs_pci.
  *
  * \sa mga_do_dma_bootstrap, mga_do_agp_dma_bootstrap
  */
@@ -622,15 +622,15 @@ static int mga_do_pci_dma_bootstrap(struct drm_device *dev,
                return -EFAULT;
        }
 
-       /* Make drm_addbufs happy by not trying to create a mapping for less
-        * than a page.
+       /* Make drm_legacy_addbufs happy by not trying to create a mapping for
+        * less than a page.
         */
        if (warp_size < PAGE_SIZE)
                warp_size = PAGE_SIZE;
 
        /* The proper alignment is 0x100 for this mapping */
-       err = drm_addmap(dev, 0, warp_size, _DRM_CONSISTENT,
-                        _DRM_READ_ONLY, &dev_priv->warp);
+       err = drm_legacy_addmap(dev, 0, warp_size, _DRM_CONSISTENT,
+                               _DRM_READ_ONLY, &dev_priv->warp);
        if (err != 0) {
                DRM_ERROR("Unable to create mapping for WARP microcode: %d\n",
                          err);
@@ -645,8 +645,8 @@ static int mga_do_pci_dma_bootstrap(struct drm_device *dev,
        for (primary_size = dma_bs->primary_size; primary_size != 0;
             primary_size >>= 1) {
                /* The proper alignment for this mapping is 0x04 */
-               err = drm_addmap(dev, 0, primary_size, _DRM_CONSISTENT,
-                                _DRM_READ_ONLY, &dev_priv->primary);
+               err = drm_legacy_addmap(dev, 0, primary_size, _DRM_CONSISTENT,
+                                       _DRM_READ_ONLY, &dev_priv->primary);
                if (!err)
                        break;
        }
@@ -669,7 +669,7 @@ static int mga_do_pci_dma_bootstrap(struct drm_device *dev,
                req.count = bin_count;
                req.size = dma_bs->secondary_bin_size;
 
-               err = drm_addbufs_pci(dev, &req);
+               err = drm_legacy_addbufs_pci(dev, &req);
                if (!err)
                        break;
        }
@@ -708,15 +708,16 @@ static int mga_do_dma_bootstrap(struct drm_device *dev,
        /* The first steps are the same for both PCI and AGP based DMA.  Map
         * the cards MMIO registers and map a status page.
         */
-       err = drm_addmap(dev, dev_priv->mmio_base, dev_priv->mmio_size,
-                        _DRM_REGISTERS, _DRM_READ_ONLY, &dev_priv->mmio);
+       err = drm_legacy_addmap(dev, dev_priv->mmio_base, dev_priv->mmio_size,
+                               _DRM_REGISTERS, _DRM_READ_ONLY,
+                               &dev_priv->mmio);
        if (err) {
                DRM_ERROR("Unable to map MMIO region: %d\n", err);
                return err;
        }
 
-       err = drm_addmap(dev, 0, SAREA_MAX, _DRM_SHM,
-                        _DRM_READ_ONLY | _DRM_LOCKED | _DRM_KERNEL,
+       err = drm_legacy_addmap(dev, 0, SAREA_MAX, _DRM_SHM,
+                               _DRM_READ_ONLY | _DRM_LOCKED | _DRM_KERNEL,
                         &dev_priv->status);
        if (err) {
                DRM_ERROR("Unable to map status region: %d\n", err);
@@ -809,7 +810,7 @@ static int mga_do_init_dma(struct drm_device *dev, drm_mga_init_t *init)
        dev_priv->texture_offset = init->texture_offset[0];
        dev_priv->texture_size = init->texture_size[0];
 
-       dev_priv->sarea = drm_getsarea(dev);
+       dev_priv->sarea = drm_legacy_getsarea(dev);
        if (!dev_priv->sarea) {
                DRM_ERROR("failed to find sarea!\n");
                return -EINVAL;
@@ -820,37 +821,37 @@ static int mga_do_init_dma(struct drm_device *dev, drm_mga_init_t *init)
                dev_priv->dma_access = MGA_PAGPXFER;
                dev_priv->wagp_enable = MGA_WAGP_ENABLE;
 
-               dev_priv->status = drm_core_findmap(dev, init->status_offset);
+               dev_priv->status = drm_legacy_findmap(dev, init->status_offset);
                if (!dev_priv->status) {
                        DRM_ERROR("failed to find status page!\n");
                        return -EINVAL;
                }
-               dev_priv->mmio = drm_core_findmap(dev, init->mmio_offset);
+               dev_priv->mmio = drm_legacy_findmap(dev, init->mmio_offset);
                if (!dev_priv->mmio) {
                        DRM_ERROR("failed to find mmio region!\n");
                        return -EINVAL;
                }
-               dev_priv->warp = drm_core_findmap(dev, init->warp_offset);
+               dev_priv->warp = drm_legacy_findmap(dev, init->warp_offset);
                if (!dev_priv->warp) {
                        DRM_ERROR("failed to find warp microcode region!\n");
                        return -EINVAL;
                }
-               dev_priv->primary = drm_core_findmap(dev, init->primary_offset);
+               dev_priv->primary = drm_legacy_findmap(dev, init->primary_offset);
                if (!dev_priv->primary) {
                        DRM_ERROR("failed to find primary dma region!\n");
                        return -EINVAL;
                }
                dev->agp_buffer_token = init->buffers_offset;
                dev->agp_buffer_map =
-                   drm_core_findmap(dev, init->buffers_offset);
+                   drm_legacy_findmap(dev, init->buffers_offset);
                if (!dev->agp_buffer_map) {
                        DRM_ERROR("failed to find dma buffer region!\n");
                        return -EINVAL;
                }
 
-               drm_core_ioremap(dev_priv->warp, dev);
-               drm_core_ioremap(dev_priv->primary, dev);
-               drm_core_ioremap(dev->agp_buffer_map, dev);
+               drm_legacy_ioremap(dev_priv->warp, dev);
+               drm_legacy_ioremap(dev_priv->primary, dev);
+               drm_legacy_ioremap(dev->agp_buffer_map, dev);
        }
 
        dev_priv->sarea_priv =
@@ -936,14 +937,14 @@ static int mga_do_cleanup_dma(struct drm_device *dev, int full_cleanup)
 
                if ((dev_priv->warp != NULL)
                    && (dev_priv->warp->type != _DRM_CONSISTENT))
-                       drm_core_ioremapfree(dev_priv->warp, dev);
+                       drm_legacy_ioremapfree(dev_priv->warp, dev);
 
                if ((dev_priv->primary != NULL)
                    && (dev_priv->primary->type != _DRM_CONSISTENT))
-                       drm_core_ioremapfree(dev_priv->primary, dev);
+                       drm_legacy_ioremapfree(dev_priv->primary, dev);
 
                if (dev->agp_buffer_map != NULL)
-                       drm_core_ioremapfree(dev->agp_buffer_map, dev);
+                       drm_legacy_ioremapfree(dev->agp_buffer_map, dev);
 
                if (dev_priv->used_new_dma_init) {
 #if __OS_HAS_AGP