1 // SPDX-License-Identifier: GPL-2.0
3 * io-unit.c: IO-UNIT specific routines for memory management.
5 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
8 #include <linux/kernel.h>
9 #include <linux/init.h>
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
13 #include <linux/highmem.h> /* pte_offset_map => kmap_atomic */
14 #include <linux/bitops.h>
15 #include <linux/dma-mapping.h>
17 #include <linux/of_device.h>
19 #include <asm/pgalloc.h>
20 #include <asm/pgtable.h>
22 #include <asm/io-unit.h>
24 #include <asm/cacheflush.h>
25 #include <asm/tlbflush.h>
27 #include <asm/oplib.h>
31 /* #define IOUNIT_DEBUG */
33 #define IOD(x) printk(x)
35 #define IOD(x) do { } while (0)
38 #define IOPERM (IOUPTE_CACHE | IOUPTE_WRITE | IOUPTE_VALID)
39 #define MKIOPTE(phys) __iopte((((phys)>>4) & IOUPTE_PAGE) | IOPERM)
41 static void __init
iounit_iommu_init(struct platform_device
*op
)
43 struct iounit_struct
*iounit
;
45 iopte_t __iomem
*xptend
;
47 iounit
= kzalloc(sizeof(struct iounit_struct
), GFP_ATOMIC
);
49 prom_printf("SUN4D: Cannot alloc iounit, halting.\n");
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
;
60 xpt
= of_ioremap(&op
->resource
[2], 0, PAGE_SIZE
* 16, "XPT");
62 prom_printf("SUN4D: Cannot map External Page Table.");
66 op
->dev
.archdata
.iommu
= iounit
;
67 iounit
->page_table
= xpt
;
68 spin_lock_init(&iounit
->lock
);
70 xptend
= iounit
->page_table
+ (16 * PAGE_SIZE
) / sizeof(iopte_t
);
71 for (; xpt
< xptend
; xpt
++)
75 static int __init
iounit_init(void)
77 extern void sun4d_init_sbi_irq(void);
78 struct device_node
*dp
;
80 for_each_node_by_name(dp
, "sbi") {
81 struct platform_device
*op
= of_find_device_by_node(dp
);
83 iounit_iommu_init(op
);
84 of_propagate_archdata(op
);
92 subsys_initcall(iounit_init
);
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
)
98 unsigned long rotor
, scan
, limit
;
101 npages
= ((vaddr
& ~PAGE_MASK
) + size
+ (PAGE_SIZE
-1)) >> PAGE_SHIFT
;
103 /* A tiny bit of magic ingredience :) */
105 case 1: i
= 0x0231; break;
106 case 2: i
= 0x0132; break;
107 default: i
= 0x0213; break;
110 IOD(("iounit_get_area(%08lx,%d[%d])=", vaddr
, size
, npages
));
113 rotor
= iounit
->rotor
[j
- 1];
114 limit
= iounit
->limit
[j
];
116 nexti
: scan
= find_next_zero_bit(iounit
->bmap
, limit
, scan
);
117 if (scan
+ npages
> limit
) {
118 if (limit
!= rotor
) {
120 scan
= iounit
->limit
[j
- 1];
125 panic("iounit_get_area: Couldn't find free iopte slots for (%08lx,%d)\n", vaddr
, size
);
128 for (k
= 1, scan
++; k
< npages
; k
++)
129 if (test_bit(scan
++, iounit
->bmap
))
131 iounit
->rotor
[j
- 1] = (scan
< limit
) ? scan
: iounit
->limit
[j
- 1];
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
]);
139 IOD(("%08lx\n", vaddr
));
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
,
147 void *vaddr
= page_address(page
) + offset
;
148 struct iounit_struct
*iounit
= dev
->archdata
.iommu
;
149 unsigned long ret
, flags
;
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
;
155 spin_lock_irqsave(&iounit
->lock
, flags
);
156 ret
= iounit_get_area(iounit
, (unsigned long)vaddr
, len
);
157 spin_unlock_irqrestore(&iounit
->lock
, flags
);
161 static int iounit_map_sg(struct device
*dev
, struct scatterlist
*sgl
, int nents
,
162 enum dma_data_direction dir
, unsigned long attrs
)
164 struct iounit_struct
*iounit
= dev
->archdata
.iommu
;
165 struct scatterlist
*sg
;
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
;
175 spin_unlock_irqrestore(&iounit
->lock
, flags
);
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
)
182 struct iounit_struct
*iounit
= dev
->archdata
.iommu
;
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
);
194 static void iounit_unmap_sg(struct device
*dev
, struct scatterlist
*sgl
,
195 int nents
, enum dma_data_direction dir
, unsigned long attrs
)
197 struct iounit_struct
*iounit
= dev
->archdata
.iommu
;
198 unsigned long flags
, vaddr
, len
;
199 struct scatterlist
*sg
;
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
);
210 spin_unlock_irqrestore(&iounit
->lock
, flags
);
214 static void *iounit_alloc(struct device
*dev
, size_t len
,
215 dma_addr_t
*dma_handle
, gfp_t gfp
, unsigned long attrs
)
217 struct iounit_struct
*iounit
= dev
->archdata
.iommu
;
218 unsigned long va
, addr
, page
, end
, ret
;
220 iopte_t __iomem
*iopte
;
222 /* XXX So what is maxphys for us and how do drivers know it? */
223 if (!len
|| len
> 256 * 1024)
226 len
= PAGE_ALIGN(len
);
227 va
= __get_free_pages(gfp
| __GFP_ZERO
, get_order(len
));
231 addr
= ret
= sparc_dma_alloc_resource(dev
, len
);
236 dvma_prot
= __pgprot(SRMMU_CACHE
| SRMMU_ET_PTE
| SRMMU_PRIV
);
237 end
= PAGE_ALIGN((addr
+ len
));
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
);
254 set_pte(ptep
, mk_pte(virt_to_page(page
), dvma_prot
));
256 i
= ((addr
- IOUNIT_DMA_BASE
) >> PAGE_SHIFT
);
258 iopte
= iounit
->page_table
+ i
;
259 sbus_writel(iopte_val(MKIOPTE(__pa(page
))), iopte
);
270 free_pages(va
, get_order(len
));
274 static void iounit_free(struct device
*dev
, size_t size
, void *cpu_addr
,
275 dma_addr_t dma_addr
, unsigned long attrs
)
277 /* XXX Somebody please fill this in */
281 static const struct dma_map_ops iounit_dma_ops
= {
283 .alloc
= iounit_alloc
,
286 .map_page
= iounit_map_page
,
287 .unmap_page
= iounit_unmap_page
,
288 .map_sg
= iounit_map_sg
,
289 .unmap_sg
= iounit_unmap_sg
,
292 void __init
ld_mmu_iounit(void)
294 dma_ops
= &iounit_dma_ops
;