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         ret = arm_iommu_attach_device(subdrv_dev, dev->archdata.mapping);
 104         if (ret < 0) {
 105                 DRM_DEBUG_KMS("failed iommu attach.\n");
 106                 return ret;
 107         }
 108
 109         /*
 110          * Set dma_ops to drm_device just one time.
 111          *
 112          * The dma mapping api needs device object and the api is used
 113          * to allocate physial memory and map it with iommu table.
 114          * If iommu attach succeeded, the sub driver would have dma_ops
 115          * for iommu and also all sub drivers have same dma_ops.
 116          */
 117         if (!dev->archdata.dma_ops)
 118                 dev->archdata.dma_ops = subdrv_dev->archdata.dma_ops;
 119
 120         return 0;
 121 }
 122
 123 /*
 124  * drm_iommu_detach_device -detach device address space mapping from device
 125  *
 126  * @drm_dev: DRM device
 127  * @subdrv_dev: device to be detached
 128  *
 129  * This function should be called by sub drivers to detach it from iommu
 130  * mapping
 131  */
 132 void drm_iommu_detach_device(struct drm_device *drm_dev,
 133                                 struct device *subdrv_dev)
 134 {
 135         struct device *dev = drm_dev->dev;
 136         struct dma_iommu_mapping *mapping = dev->archdata.mapping;
 137
 138         if (!mapping || !mapping->domain)
 139                 return;
 140
 141         iommu_detach_device(mapping->domain, subdrv_dev);
 142         drm_release_iommu_mapping(drm_dev);
 143 }