arch/sparc/mm/io-unit.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * io-unit.c:  IO-UNIT specific routines for memory management.
   4  *
   5  * Copyright (C) 1997,1998 Jakub Jelinek    (jj@sunsite.mff.cuni.cz)
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/init.h>
  10 #include <linux/slab.h>
  11 #include <linux/spinlock.h>
  12 #include <linux/mm.h>
  13 #include <linux/highmem.h>      /* pte_offset_map => kmap_atomic */
  14 #include <linux/bitops.h>
  15 #include <linux/dma-mapping.h>
  16 #include <linux/of.h>
  17 #include <linux/of_device.h>
  18
  19 #include <asm/pgalloc.h>
  20 #include <asm/pgtable.h>
  21 #include <asm/io.h>
  22 #include <asm/io-unit.h>
  23 #include <asm/mxcc.h>
  24 #include <asm/cacheflush.h>
  25 #include <asm/tlbflush.h>
  26 #include <asm/dma.h>
  27 #include <asm/oplib.h>
  28
  29 #include "mm_32.h"
  30
  31 /* #define IOUNIT_DEBUG */
  32 #ifdef IOUNIT_DEBUG
  33 #define IOD(x) printk(x)
  34 #else
  35 #define IOD(x) do { } while (0)
  36 #endif
  37
  38 #define IOPERM        (IOUPTE_CACHE | IOUPTE_WRITE | IOUPTE_VALID)
  39 #define MKIOPTE(phys) __iopte((((phys)>>4) & IOUPTE_PAGE) | IOPERM)
  40
  41 static void __init iounit_iommu_init(struct platform_device *op)
  42 {
  43         struct iounit_struct *iounit;
  44         iopte_t __iomem *xpt;
  45         iopte_t __iomem *xptend;
  46
  47         iounit = kzalloc(sizeof(struct iounit_struct), GFP_ATOMIC);
  48         if (!iounit) {
  49                 prom_printf("SUN4D: Cannot alloc iounit, halting.\n");
  50                 prom_halt();
  51         }
  52
  53         iounit->limit[0] = IOUNIT_BMAP1_START;
  54         iounit->limit[1] = IOUNIT_BMAP2_START;
  55         iounit->limit[2] = IOUNIT_BMAPM_START;
  56         iounit->limit[3] = IOUNIT_BMAPM_END;
  57         iounit->rotor[1] = IOUNIT_BMAP2_START;
  58         iounit->rotor[2] = IOUNIT_BMAPM_START;
  59
  60         xpt = of_ioremap(&op->resource[2], 0, PAGE_SIZE * 16, "XPT");
  61         if (!xpt) {
  62                 prom_printf("SUN4D: Cannot map External Page Table.");
  63                 prom_halt();
  64         }
  65
  66         op->dev.archdata.iommu = iounit;
  67         iounit->page_table = xpt;
  68         spin_lock_init(&iounit->lock);
  69
  70         xptend = iounit->page_table + (16 * PAGE_SIZE) / sizeof(iopte_t);
  71         for (; xpt < xptend; xpt++)
  72                 sbus_writel(0, xpt);
  73 }
  74
  75 static int __init iounit_init(void)
  76 {
  77         extern void sun4d_init_sbi_irq(void);
  78         struct device_node *dp;
  79
  80         for_each_node_by_name(dp, "sbi") {
  81                 struct platform_device *op = of_find_device_by_node(dp);
  82
  83                 iounit_iommu_init(op);
  84                 of_propagate_archdata(op);
  85         }
  86
  87         sun4d_init_sbi_irq();
  88
  89         return 0;
  90 }
  91
  92 subsys_initcall(iounit_init);
  93
  94 /* One has to hold iounit->lock to call this */
  95 static unsigned long iounit_get_area(struct iounit_struct *iounit, unsigned long vaddr, int size)
  96 {
  97         int i, j, k, npages;
  98         unsigned long rotor, scan, limit;
  99         iopte_t iopte;
 100
 101         npages = ((vaddr & ~PAGE_MASK) + size + (PAGE_SIZE-1)) >> PAGE_SHIFT;
 102
 103         /* A tiny bit of magic ingredience :) */
 104         switch (npages) {
 105         case 1: i = 0x0231; break;
 106         case 2: i = 0x0132; break;
 107         default: i = 0x0213; break;
 108         }
 109
 110         IOD(("iounit_get_area(%08lx,%d[%d])=", vaddr, size, npages));
 111
 112 next:   j = (i & 15);
 113         rotor = iounit->rotor[j - 1];
 114         limit = iounit->limit[j];
 115         scan = rotor;
 116 nexti:  scan = find_next_zero_bit(iounit->bmap, limit, scan);
 117         if (scan + npages > limit) {
 118                 if (limit != rotor) {
 119                         limit = rotor;
 120                         scan = iounit->limit[j - 1];
 121                         goto nexti;
 122                 }
 123                 i >>= 4;
 124                 if (!(i & 15))
 125                         panic("iounit_get_area: Couldn't find free iopte slots for (%08lx,%d)\n", vaddr, size);
 126                 goto next;
 127         }
 128         for (k = 1, scan++; k < npages; k++)
 129                 if (test_bit(scan++, iounit->bmap))
 130                         goto nexti;
 131         iounit->rotor[j - 1] = (scan < limit) ? scan : iounit->limit[j - 1];
 132         scan -= npages;
 133         iopte = MKIOPTE(__pa(vaddr & PAGE_MASK));
 134         vaddr = IOUNIT_DMA_BASE + (scan << PAGE_SHIFT) + (vaddr & ~PAGE_MASK);
 135         for (k = 0; k < npages; k++, iopte = __iopte(iopte_val(iopte) + 0x100), scan++) {
 136                 set_bit(scan, iounit->bmap);
 137                 sbus_writel(iopte_val(iopte), &iounit->page_table[scan]);
 138         }
 139         IOD(("%08lx\n", vaddr));
 140         return vaddr;
 141 }
 142
 143 static dma_addr_t iounit_map_page(struct device *dev, struct page *page,
 144                 unsigned long offset, size_t len, enum dma_data_direction dir,
 145                 unsigned long attrs)
 146 {
 147         void *vaddr = page_address(page) + offset;
 148         struct iounit_struct *iounit = dev->archdata.iommu;
 149         unsigned long ret, flags;
 150
 151         /* XXX So what is maxphys for us and how do drivers know it? */
 152         if (!len || len > 256 * 1024)
 153                 return DMA_MAPPING_ERROR;
 154
 155         spin_lock_irqsave(&iounit->lock, flags);
 156         ret = iounit_get_area(iounit, (unsigned long)vaddr, len);
 157         spin_unlock_irqrestore(&iounit->lock, flags);
 158         return ret;
 159 }
 160
 161 static int iounit_map_sg(struct device *dev, struct scatterlist *sgl, int nents,
 162                 enum dma_data_direction dir, unsigned long attrs)
 163 {
 164         struct iounit_struct *iounit = dev->archdata.iommu;
 165         struct scatterlist *sg;
 166         unsigned long flags;
 167         int i;
 168
 169         /* FIXME: Cache some resolved pages - often several sg entries are to the same page */
 170         spin_lock_irqsave(&iounit->lock, flags);
 171         for_each_sg(sgl, sg, nents, i) {
 172                 sg->dma_address = iounit_get_area(iounit, (unsigned long) sg_virt(sg), sg->length);
 173                 sg->dma_length = sg->length;
 174         }
 175         spin_unlock_irqrestore(&iounit->lock, flags);
 176         return nents;
 177 }
 178
 179 static void iounit_unmap_page(struct device *dev, dma_addr_t vaddr, size_t len,
 180                 enum dma_data_direction dir, unsigned long attrs)
 181 {
 182         struct iounit_struct *iounit = dev->archdata.iommu;
 183         unsigned long flags;
 184
 185         spin_lock_irqsave(&iounit->lock, flags);
 186         len = ((vaddr & ~PAGE_MASK) + len + (PAGE_SIZE-1)) >> PAGE_SHIFT;
 187         vaddr = (vaddr - IOUNIT_DMA_BASE) >> PAGE_SHIFT;
 188         IOD(("iounit_release %08lx-%08lx\n", (long)vaddr, (long)len+vaddr));
 189         for (len += vaddr; vaddr < len; vaddr++)
 190                 clear_bit(vaddr, iounit->bmap);
 191         spin_unlock_irqrestore(&iounit->lock, flags);
 192 }
 193
 194 static void iounit_unmap_sg(struct device *dev, struct scatterlist *sgl,
 195                 int nents, enum dma_data_direction dir, unsigned long attrs)
 196 {
 197         struct iounit_struct *iounit = dev->archdata.iommu;
 198         unsigned long flags, vaddr, len;
 199         struct scatterlist *sg;
 200         int i;
 201
 202         spin_lock_irqsave(&iounit->lock, flags);
 203         for_each_sg(sgl, sg, nents, i) {
 204                 len = ((sg->dma_address & ~PAGE_MASK) + sg->length + (PAGE_SIZE-1)) >> PAGE_SHIFT;
 205                 vaddr = (sg->dma_address - IOUNIT_DMA_BASE) >> PAGE_SHIFT;
 206                 IOD(("iounit_release %08lx-%08lx\n", (long)vaddr, (long)len+vaddr));
 207                 for (len += vaddr; vaddr < len; vaddr++)
 208                         clear_bit(vaddr, iounit->bmap);
 209         }
 210         spin_unlock_irqrestore(&iounit->lock, flags);
 211 }
 212
 213 #ifdef CONFIG_SBUS
 214 static void *iounit_alloc(struct device *dev, size_t len,
 215                 dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
 216 {
 217         struct iounit_struct *iounit = dev->archdata.iommu;
 218         unsigned long va, addr, page, end, ret;
 219         pgprot_t dvma_prot;
 220         iopte_t __iomem *iopte;
 221
 222         /* XXX So what is maxphys for us and how do drivers know it? */
 223         if (!len || len > 256 * 1024)
 224                 return NULL;
 225
 226         len = PAGE_ALIGN(len);
 227         va = __get_free_pages(gfp | __GFP_ZERO, get_order(len));
 228         if (!va)
 229                 return NULL;
 230
 231         addr = ret = sparc_dma_alloc_resource(dev, len);
 232         if (!addr)
 233                 goto out_free_pages;
 234         *dma_handle = addr;
 235
 236         dvma_prot = __pgprot(SRMMU_CACHE | SRMMU_ET_PTE | SRMMU_PRIV);
 237         end = PAGE_ALIGN((addr + len));
 238         while(addr < end) {
 239                 page = va;
 240                 {
 241                         pgd_t *pgdp;
 242                         p4d_t *p4dp;
 243                         pud_t *pudp;
 244                         pmd_t *pmdp;
 245                         pte_t *ptep;
 246                         long i;
 247
 248                         pgdp = pgd_offset(&init_mm, addr);
 249                         p4dp = p4d_offset(pgdp, addr);
 250                         pudp = pud_offset(p4dp, addr);
 251                         pmdp = pmd_offset(pudp, addr);
 252                         ptep = pte_offset_map(pmdp, addr);
 253
 254                         set_pte(ptep, mk_pte(virt_to_page(page), dvma_prot));
 255
 256                         i = ((addr - IOUNIT_DMA_BASE) >> PAGE_SHIFT);
 257
 258                         iopte = iounit->page_table + i;
 259                         sbus_writel(iopte_val(MKIOPTE(__pa(page))), iopte);
 260                 }
 261                 addr += PAGE_SIZE;
 262                 va += PAGE_SIZE;
 263         }
 264         flush_cache_all();
 265         flush_tlb_all();
 266
 267         return (void *)ret;
 268
 269 out_free_pages:
 270         free_pages(va, get_order(len));
 271         return NULL;
 272 }
 273
 274 static void iounit_free(struct device *dev, size_t size, void *cpu_addr,
 275                 dma_addr_t dma_addr, unsigned long attrs)
 276 {
 277         /* XXX Somebody please fill this in */
 278 }
 279 #endif
 280
 281 static const struct dma_map_ops iounit_dma_ops = {
 282 #ifdef CONFIG_SBUS
 283         .alloc                  = iounit_alloc,
 284         .free                   = iounit_free,
 285 #endif
 286         .map_page               = iounit_map_page,
 287         .unmap_page             = iounit_unmap_page,
 288         .map_sg                 = iounit_map_sg,
 289         .unmap_sg               = iounit_unmap_sg,
 290 };
 291
 292 void __init ld_mmu_iounit(void)
 293 {
 294         dma_ops = &iounit_dma_ops;
 295 }