drivers/gpu/drm/exynos/exynos_drm_iommu.c

   1 /* exynos_drm_iommu.c
   2  *
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  * Author: Inki Dae <inki.dae@samsung.com>
   5  *
   6  * This program is free software; you can redistribute  it and/or modify it
   7  * under  the terms of  the GNU General  Public License as published by the
   8  * Free Software Foundation;  either version 2 of the  License, or (at your
   9  * option) any later version.
  10  */
  11
  12 #include <drmP.h>
  13 #include <drm/exynos_drm.h>
  14
  15 #include <linux/dma-mapping.h>
  16 #include <linux/iommu.h>
  17 #include <linux/kref.h>
  18
  19 #include <asm/dma-iommu.h>
  20
  21 #include "exynos_drm_drv.h"
  22 #include "exynos_drm_iommu.h"
  23
  24 /*
  25  * drm_create_iommu_mapping - create a mapping structure
  26  *
  27  * @drm_dev: DRM device
  28  */
  29 int drm_create_iommu_mapping(struct drm_device *drm_dev)
  30 {
  31         struct dma_iommu_mapping *mapping = NULL;
  32         struct exynos_drm_private *priv = drm_dev->dev_private;
  33         struct device *dev = drm_dev->dev;
  34
  35         if (!priv->da_start)
  36                 priv->da_start = EXYNOS_DEV_ADDR_START;
  37         if (!priv->da_space_size)
  38                 priv->da_space_size = EXYNOS_DEV_ADDR_SIZE;
  39
  40         mapping = arm_iommu_create_mapping(&platform_bus_type, priv->da_start,
  41                                                 priv->da_space_size);
  42
  43         if (IS_ERR(mapping))
  44                 return PTR_ERR(mapping);
  45
  46         dev->dma_parms = devm_kzalloc(dev, sizeof(*dev->dma_parms),
  47                                         GFP_KERNEL);
  48         if (!dev->dma_parms)
  49                 goto error;
  50
  51         dma_set_max_seg_size(dev, 0xffffffffu);
  52         dev->archdata.mapping = mapping;
  53
  54         return 0;
  55 error:
  56         arm_iommu_release_mapping(mapping);
  57         return -ENOMEM;
  58 }
  59
  60 /*
  61  * drm_release_iommu_mapping - release iommu mapping structure
  62  *
  63  * @drm_dev: DRM device
  64  *
  65  * if mapping->kref becomes 0 then all things related to iommu mapping
  66  * will be released
  67  */
  68 void drm_release_iommu_mapping(struct drm_device *drm_dev)
  69 {
  70         struct device *dev = drm_dev->dev;
  71
  72         arm_iommu_release_mapping(dev->archdata.mapping);
  73 }
  74
  75 /*
  76  * drm_iommu_attach_device- attach device to iommu mapping
  77  *
  78  * @drm_dev: DRM device
  79  * @subdrv_dev: device to be attach
  80  *
  81  * This function should be called by sub drivers to attach it to iommu
  82  * mapping.
  83  */
  84 int drm_iommu_attach_device(struct drm_device *drm_dev,
  85                                 struct device *subdrv_dev)
  86 {
  87         struct device *dev = drm_dev->dev;
  88         int ret;
  89
  90         if (!dev->archdata.mapping) {
  91                 DRM_ERROR("iommu_mapping is null.\n");
  92                 return -EFAULT;
  93         }
  94
  95         subdrv_dev->dma_parms = devm_kzalloc(subdrv_dev,
  96                                         sizeof(*subdrv_dev->dma_parms),
  97                                         GFP_KERNEL);
  98         if (!subdrv_dev->dma_parms)
  99                 return -ENOMEM;
 100
 101         dma_set_max_seg_size(subdrv_dev, 0xffffffffu);
 102
 103         if (subdrv_dev->archdata.mapping)
 104                 arm_iommu_detach_device(subdrv_dev);
 105
 106         ret = arm_iommu_attach_device(subdrv_dev, dev->archdata.mapping);
 107         if (ret < 0) {
 108                 DRM_DEBUG_KMS("failed iommu attach.\n");
 109                 return ret;
 110         }
 111
 112         /*
 113          * Set dma_ops to drm_device just one time.
 114          *
 115          * The dma mapping api needs device object and the api is used
 116          * to allocate physial memory and map it with iommu table.
 117          * If iommu attach succeeded, the sub driver would have dma_ops
 118          * for iommu and also all sub drivers have same dma_ops.
 119          */
 120         if (get_dma_ops(dev) == get_dma_ops(NULL))
 121                 set_dma_ops(dev, get_dma_ops(subdrv_dev));
 122
 123         return 0;
 124 }
 125
 126 /*
 127  * drm_iommu_detach_device -detach device address space mapping from device
 128  *
 129  * @drm_dev: DRM device
 130  * @subdrv_dev: device to be detached
 131  *
 132  * This function should be called by sub drivers to detach it from iommu
 133  * mapping
 134  */
 135 void drm_iommu_detach_device(struct drm_device *drm_dev,
 136                                 struct device *subdrv_dev)
 137 {
 138         struct device *dev = drm_dev->dev;
 139         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
 140
 141         if (!mapping || !mapping->domain)
 142                 return;
 143
 144         iommu_detach_device(mapping->domain, subdrv_dev);
 145         drm_release_iommu_mapping(drm_dev);
 146 }
 147
 148 int drm_iommu_attach_device_if_possible(struct exynos_drm_crtc *exynos_crtc,
 149                         struct drm_device *drm_dev, struct device *subdrv_dev)
 150 {
 151         int ret = 0;
 152
 153         if (is_drm_iommu_supported(drm_dev)) {
 154                 if (exynos_crtc->ops->clear_channels)
 155                         exynos_crtc->ops->clear_channels(exynos_crtc);
 156                 return drm_iommu_attach_device(drm_dev, subdrv_dev);
 157         }
 158
 159         return ret;
 160 }