drivers/iommu/rockchip-iovmm.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License version 2 as
   4  * published by the Free Software Foundation.
   5  */
   6
   7 #ifdef CONFIG_ROCKCHIP_IOMMU_DEBUG
   8 #define DEBUG
   9 #endif
  10
  11 #include <linux/kernel.h>
  12 #include <linux/hardirq.h>
  13 #include <linux/slab.h>
  14 #include <linux/scatterlist.h>
  15 #include <linux/err.h>
  16
  17 #include <linux/of.h>
  18 #include <linux/of_platform.h>
  19
  20 #include "rockchip-iommu.h"
  21
  22 static struct rk_vm_region *find_region(struct rk_iovmm *vmm, dma_addr_t iova)
  23 {
  24         struct rk_vm_region *region;
  25
  26         list_for_each_entry(region, &vmm->regions_list, node)
  27                 if (region->start == iova)
  28                         return region;
  29
  30         return NULL;
  31 }
  32
  33 void rockchip_iovmm_set_fault_handler(struct device *dev,
  34                                        rockchip_iommu_fault_handler_t handler)
  35 {
  36         return;
  37 }
  38
  39 int rockchip_iovmm_activate(struct device *dev)
  40 {
  41         struct rk_iovmm *vmm = rockchip_get_iovmm(dev);
  42
  43         return iommu_attach_device(vmm->domain, dev);
  44 }
  45
  46 void rockchip_iovmm_deactivate(struct device *dev)
  47 {
  48         struct rk_iovmm *vmm = rockchip_get_iovmm(dev);
  49
  50         iommu_detach_device(vmm->domain, dev);
  51 }
  52
  53 dma_addr_t rockchip_iovmm_map(struct device *dev,
  54         struct scatterlist *sg, off_t offset, size_t size)
  55 {
  56         off_t start_off;
  57         dma_addr_t addr, start = 0;
  58         size_t mapped_size = 0;
  59         struct rk_vm_region *region;
  60         struct rk_iovmm *vmm = rockchip_get_iovmm(dev);
  61         int order;
  62         int ret;
  63
  64         for (; sg_dma_len(sg) < offset; sg = sg_next(sg))
  65                 offset -= sg_dma_len(sg);
  66
  67         start_off = offset_in_page(sg_phys(sg) + offset);
  68         size = PAGE_ALIGN(size + start_off);
  69
  70         order = __fls(min_t(size_t, size, SZ_1M));
  71
  72         region = kmalloc(sizeof(*region), GFP_KERNEL);
  73         if (!region) {
  74                 ret = -ENOMEM;
  75                 goto err_map_nomem;
  76         }
  77
  78         start = (dma_addr_t)gen_pool_alloc(vmm->vmm_pool, size);
  79         if (!start) {
  80                 ret = -ENOMEM;
  81                 goto err_map_noiomem;
  82         }
  83
  84         addr = start;
  85         do {
  86                 phys_addr_t phys;
  87                 size_t len;
  88
  89                 phys = sg_phys(sg);
  90                 len = sg_dma_len(sg);
  91
  92                 /* if back to back sg entries are contiguous consolidate them */
  93                 while (sg_next(sg) && sg_phys(sg) +
  94                        sg_dma_len(sg) == sg_phys(sg_next(sg))) {
  95                         len += sg_dma_len(sg_next(sg));
  96                         sg = sg_next(sg);
  97                 }
  98
  99                 if (offset > 0) {
 100                         len -= offset;
 101                         phys += offset;
 102                         offset = 0;
 103                 }
 104
 105                 if (offset_in_page(phys)) {
 106                         len += offset_in_page(phys);
 107                         phys = round_down(phys, PAGE_SIZE);
 108                 }
 109
 110                 len = PAGE_ALIGN(len);
 111
 112                 if (len > (size - mapped_size))
 113                         len = size - mapped_size;
 114
 115                 ret = iommu_map(vmm->domain, addr, phys, len, 0);
 116                 if (ret)
 117                         break;
 118
 119                 addr += len;
 120                 mapped_size += len;
 121         } while ((sg = sg_next(sg)) && (mapped_size < size));
 122
 123         BUG_ON(mapped_size > size);
 124
 125         if (mapped_size < size)
 126                 goto err_map_map;
 127
 128         region->start = start + start_off;
 129         region->size = size;
 130
 131         INIT_LIST_HEAD(&region->node);
 132
 133         spin_lock(&vmm->lock);
 134
 135         list_add(&region->node, &vmm->regions_list);
 136
 137         spin_unlock(&vmm->lock);
 138
 139         ret = rockchip_iommu_tlb_invalidate(dev);
 140         if (ret)
 141                 goto err_map_map;
 142
 143         dev_dbg(dev->archdata.iommu, "IOVMM: Allocated VM region @ %#x/%#X bytes.\n",
 144         region->start, region->size);
 145
 146         return region->start;
 147
 148 err_map_map:
 149         iommu_unmap(vmm->domain, start, mapped_size);
 150         gen_pool_free(vmm->vmm_pool, start, size);
 151 err_map_noiomem:
 152         kfree(region);
 153 err_map_nomem:
 154         dev_err(dev->archdata.iommu, "IOVMM: Failed to allocated VM region for %#x bytes.\n", size);
 155         return (dma_addr_t)ret;
 156 }
 157
 158 void rockchip_iovmm_unmap(struct device *dev, dma_addr_t iova)
 159 {
 160         struct rk_vm_region *region;
 161         struct rk_iovmm *vmm = rockchip_get_iovmm(dev);
 162         size_t unmapped_size;
 163
 164         /* This function must not be called in IRQ handlers */
 165         BUG_ON(in_irq());
 166
 167         spin_lock(&vmm->lock);
 168
 169         region = find_region(vmm, iova);
 170         if (WARN_ON(!region)) {
 171                 spin_unlock(&vmm->lock);
 172                 return;
 173         }
 174
 175         list_del(&region->node);
 176
 177         spin_unlock(&vmm->lock);
 178
 179         region->start = round_down(region->start, PAGE_SIZE);
 180
 181         unmapped_size = iommu_unmap(vmm->domain,
 182                                     region->start, region->size);
 183         /*
 184         rockchip_iommu_tlb_invalidate(dev);
 185         */
 186         gen_pool_free(vmm->vmm_pool, region->start, region->size);
 187
 188         WARN_ON(unmapped_size != region->size);
 189
 190         dev_dbg(dev->archdata.iommu, "IOVMM: Unmapped %#x bytes from %#x.\n",
 191                 unmapped_size, region->start);
 192
 193         kfree(region);
 194 }
 195
 196 int rockchip_iovmm_map_oto(struct device *dev, phys_addr_t phys, size_t size)
 197 {
 198         struct rk_vm_region *region;
 199         struct rk_iovmm *vmm = rockchip_get_iovmm(dev);
 200         int ret;
 201
 202         if (WARN_ON((phys + size) >= IOVA_START)) {
 203                 dev_err(dev->archdata.iommu, "Unable to create one to one mapping for %#x @ %#x\n",
 204                        size, phys);
 205                 return -EINVAL;
 206         }
 207
 208         region = kmalloc(sizeof(*region), GFP_KERNEL);
 209         if (!region)
 210                 return -ENOMEM;
 211
 212         if (WARN_ON(phys & ~PAGE_MASK))
 213                 phys = round_down(phys, PAGE_SIZE);
 214
 215
 216         ret = iommu_map(vmm->domain, (dma_addr_t)phys, phys, size, 0);
 217         if (ret < 0) {
 218                 kfree(region);
 219                 return ret;
 220         }
 221
 222         region->start = (dma_addr_t)phys;
 223         region->size = size;
 224         INIT_LIST_HEAD(&region->node);
 225
 226         spin_lock(&vmm->lock);
 227
 228         list_add(&region->node, &vmm->regions_list);
 229
 230         spin_unlock(&vmm->lock);
 231
 232         ret = rockchip_iommu_tlb_invalidate(dev);
 233         if (ret)
 234                 return ret;
 235
 236         return 0;
 237 }
 238
 239 void rockchip_iovmm_unmap_oto(struct device *dev, phys_addr_t phys)
 240 {
 241         struct rk_vm_region *region;
 242         struct rk_iovmm *vmm = rockchip_get_iovmm(dev);
 243         size_t unmapped_size;
 244
 245         /* This function must not be called in IRQ handlers */
 246         BUG_ON(in_irq());
 247
 248         if (WARN_ON(phys & ~PAGE_MASK))
 249                 phys = round_down(phys, PAGE_SIZE);
 250
 251         spin_lock(&vmm->lock);
 252
 253         region = find_region(vmm, (dma_addr_t)phys);
 254         if (WARN_ON(!region)) {
 255                 spin_unlock(&vmm->lock);
 256                 return;
 257         }
 258
 259         list_del(&region->node);
 260
 261         spin_unlock(&vmm->lock);
 262
 263         unmapped_size = iommu_unmap(vmm->domain, region->start, region->size);
 264         WARN_ON(unmapped_size != region->size);
 265         dev_dbg(dev->archdata.iommu, "IOVMM: Unmapped %#x bytes from %#x.\n",
 266                unmapped_size, region->start);
 267
 268         kfree(region);
 269 }
 270
 271 int rockchip_init_iovmm(struct device *iommu, struct rk_iovmm *vmm)
 272 {
 273         int ret = 0;
 274
 275         vmm->vmm_pool = gen_pool_create(PAGE_SHIFT, -1);
 276         if (!vmm->vmm_pool) {
 277                 ret = -ENOMEM;
 278                 goto err_setup_genalloc;
 279         }
 280
 281         /* (1GB - 4KB) addr space from 0x10000000 */
 282         ret = gen_pool_add(vmm->vmm_pool, IOVA_START, IOVM_SIZE, -1);
 283         if (ret)
 284                 goto err_setup_domain;
 285
 286         vmm->domain = iommu_domain_alloc(&platform_bus_type);
 287         if (!vmm->domain) {
 288                 ret = -ENOMEM;
 289                 goto err_setup_domain;
 290         }
 291
 292         spin_lock_init(&vmm->lock);
 293
 294         INIT_LIST_HEAD(&vmm->regions_list);
 295
 296         dev_info(iommu, "IOVMM: Created %#x B IOVMM from %#x.\n",
 297                 IOVM_SIZE, IOVA_START);
 298         return 0;
 299 err_setup_domain:
 300         gen_pool_destroy(vmm->vmm_pool);
 301 err_setup_genalloc:
 302         dev_err(iommu, "IOVMM: Failed to create IOVMM (%d)\n", ret);
 303
 304         return ret;
 305 }