root/arch/sparc/kernel/ioport.c

DEFINITIONS

1. dma_make_coherent
2. xres_alloc
3. xres_free
4. ioremap
5. iounmap
6. of_ioremap
7. of_iounmap
8. _sparc_alloc_io
9. _sparc_ioremap
10. _sparc_free_io
11. sparc_dma_alloc_resource
12. sparc_dma_free_resource
13. sbus_set_sbus64
14. sparc_register_ioport
15. arch_dma_alloc
16. arch_dma_free
17. arch_sync_dma_for_cpu
18. sparc_io_proc_show
19. register_proc_sparc_ioport

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ioport.c:  Simple io mapping allocator.
   4  *
   5  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
   6  * Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
   7  *
   8  * 1996: sparc_free_io, 1999: ioremap()/iounmap() by Pete Zaitcev.
   9  *
  10  * 2000/01/29
  11  * <rth> zait: as long as pci_alloc_consistent produces something addressable, 
  12  *      things are ok.
  13  * <zaitcev> rth: no, it is relevant, because get_free_pages returns you a
  14  *      pointer into the big page mapping
  15  * <rth> zait: so what?
  16  * <rth> zait: remap_it_my_way(virt_to_phys(get_free_page()))
  17  * <zaitcev> Hmm
  18  * <zaitcev> Suppose I did this remap_it_my_way(virt_to_phys(get_free_page())).
  19  *      So far so good.
  20  * <zaitcev> Now, driver calls pci_free_consistent(with result of
  21  *      remap_it_my_way()).
  22  * <zaitcev> How do you find the address to pass to free_pages()?
  23  * <rth> zait: walk the page tables?  It's only two or three level after all.
  24  * <rth> zait: you have to walk them anyway to remove the mapping.
  25  * <zaitcev> Hmm
  26  * <zaitcev> Sounds reasonable
  27  */
  28 
  29 #include <linux/module.h>
  30 #include <linux/sched.h>
  31 #include <linux/kernel.h>
  32 #include <linux/errno.h>
  33 #include <linux/types.h>
  34 #include <linux/ioport.h>
  35 #include <linux/mm.h>
  36 #include <linux/slab.h>
  37 #include <linux/pci.h>          /* struct pci_dev */
  38 #include <linux/proc_fs.h>
  39 #include <linux/seq_file.h>
  40 #include <linux/scatterlist.h>
  41 #include <linux/dma-noncoherent.h>
  42 #include <linux/of_device.h>
  43 
  44 #include <asm/io.h>
  45 #include <asm/vaddrs.h>
  46 #include <asm/oplib.h>
  47 #include <asm/prom.h>
  48 #include <asm/page.h>
  49 #include <asm/pgalloc.h>
  50 #include <asm/dma.h>
  51 #include <asm/iommu.h>
  52 #include <asm/io-unit.h>
  53 #include <asm/leon.h>
  54 
  55 /* This function must make sure that caches and memory are coherent after DMA
  56  * On LEON systems without cache snooping it flushes the entire D-CACHE.
  57  */
  58 static inline void dma_make_coherent(unsigned long pa, unsigned long len)
  59 {
  60         if (sparc_cpu_model == sparc_leon) {
  61                 if (!sparc_leon3_snooping_enabled())
  62                         leon_flush_dcache_all();
  63         }
  64 }
  65 
  66 static void __iomem *_sparc_ioremap(struct resource *res, u32 bus, u32 pa, int sz);
  67 static void __iomem *_sparc_alloc_io(unsigned int busno, unsigned long phys,
  68     unsigned long size, char *name);
  69 static void _sparc_free_io(struct resource *res);
  70 
  71 static void register_proc_sparc_ioport(void);
  72 
  73 /* This points to the next to use virtual memory for DVMA mappings */
  74 static struct resource _sparc_dvma = {
  75         .name = "sparc_dvma", .start = DVMA_VADDR, .end = DVMA_END - 1
  76 };
  77 /* This points to the start of I/O mappings, cluable from outside. */
  78 /*ext*/ struct resource sparc_iomap = {
  79         .name = "sparc_iomap", .start = IOBASE_VADDR, .end = IOBASE_END - 1
  80 };
  81 
  82 /*
  83  * Our mini-allocator...
  84  * Boy this is gross! We need it because we must map I/O for
  85  * timers and interrupt controller before the kmalloc is available.
  86  */
  87 
  88 #define XNMLN  15
  89 #define XNRES  10       /* SS-10 uses 8 */
  90 
  91 struct xresource {
  92         struct resource xres;   /* Must be first */
  93         int xflag;              /* 1 == used */
  94         char xname[XNMLN+1];
  95 };
  96 
  97 static struct xresource xresv[XNRES];
  98 
  99 static struct xresource *xres_alloc(void) {
 100         struct xresource *xrp;
 101         int n;
 102 
 103         xrp = xresv;
 104         for (n = 0; n < XNRES; n++) {
 105                 if (xrp->xflag == 0) {
 106                         xrp->xflag = 1;
 107                         return xrp;
 108                 }
 109                 xrp++;
 110         }
 111         return NULL;
 112 }
 113 
 114 static void xres_free(struct xresource *xrp) {
 115         xrp->xflag = 0;
 116 }
 117 
 118 /*
 119  * These are typically used in PCI drivers
 120  * which are trying to be cross-platform.
 121  *
 122  * Bus type is always zero on IIep.
 123  */
 124 void __iomem *ioremap(phys_addr_t offset, size_t size)
 125 {
 126         char name[14];
 127 
 128         sprintf(name, "phys_%08x", (u32)offset);
 129         return _sparc_alloc_io(0, (unsigned long)offset, size, name);
 130 }
 131 EXPORT_SYMBOL(ioremap);
 132 
 133 /*
 134  * Complementary to ioremap().
 135  */
 136 void iounmap(volatile void __iomem *virtual)
 137 {
 138         unsigned long vaddr = (unsigned long) virtual & PAGE_MASK;
 139         struct resource *res;
 140 
 141         /*
 142          * XXX Too slow. Can have 8192 DVMA pages on sun4m in the worst case.
 143          * This probably warrants some sort of hashing.
 144         */
 145         if ((res = lookup_resource(&sparc_iomap, vaddr)) == NULL) {
 146                 printk("free_io/iounmap: cannot free %lx\n", vaddr);
 147                 return;
 148         }
 149         _sparc_free_io(res);
 150 
 151         if ((char *)res >= (char*)xresv && (char *)res < (char *)&xresv[XNRES]) {
 152                 xres_free((struct xresource *)res);
 153         } else {
 154                 kfree(res);
 155         }
 156 }
 157 EXPORT_SYMBOL(iounmap);
 158 
 159 void __iomem *of_ioremap(struct resource *res, unsigned long offset,
 160                          unsigned long size, char *name)
 161 {
 162         return _sparc_alloc_io(res->flags & 0xF,
 163                                res->start + offset,
 164                                size, name);
 165 }
 166 EXPORT_SYMBOL(of_ioremap);
 167 
 168 void of_iounmap(struct resource *res, void __iomem *base, unsigned long size)
 169 {
 170         iounmap(base);
 171 }
 172 EXPORT_SYMBOL(of_iounmap);
 173 
 174 /*
 175  * Meat of mapping
 176  */
 177 static void __iomem *_sparc_alloc_io(unsigned int busno, unsigned long phys,
 178     unsigned long size, char *name)
 179 {
 180         static int printed_full;
 181         struct xresource *xres;
 182         struct resource *res;
 183         char *tack;
 184         int tlen;
 185         void __iomem *va;       /* P3 diag */
 186 
 187         if (name == NULL) name = "???";
 188 
 189         if ((xres = xres_alloc()) != NULL) {
 190                 tack = xres->xname;
 191                 res = &xres->xres;
 192         } else {
 193                 if (!printed_full) {
 194                         printk("ioremap: done with statics, switching to malloc\n");
 195                         printed_full = 1;
 196                 }
 197                 tlen = strlen(name);
 198                 tack = kmalloc(sizeof (struct resource) + tlen + 1, GFP_KERNEL);
 199                 if (tack == NULL) return NULL;
 200                 memset(tack, 0, sizeof(struct resource));
 201                 res = (struct resource *) tack;
 202                 tack += sizeof (struct resource);
 203         }
 204 
 205         strlcpy(tack, name, XNMLN+1);
 206         res->name = tack;
 207 
 208         va = _sparc_ioremap(res, busno, phys, size);
 209         /* printk("ioremap(0x%x:%08lx[0x%lx])=%p\n", busno, phys, size, va); */ /* P3 diag */
 210         return va;
 211 }
 212 
 213 /*
 214  */
 215 static void __iomem *
 216 _sparc_ioremap(struct resource *res, u32 bus, u32 pa, int sz)
 217 {
 218         unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK);
 219 
 220         if (allocate_resource(&sparc_iomap, res,
 221             (offset + sz + PAGE_SIZE-1) & PAGE_MASK,
 222             sparc_iomap.start, sparc_iomap.end, PAGE_SIZE, NULL, NULL) != 0) {
 223                 /* Usually we cannot see printks in this case. */
 224                 prom_printf("alloc_io_res(%s): cannot occupy\n",
 225                     (res->name != NULL)? res->name: "???");
 226                 prom_halt();
 227         }
 228 
 229         pa &= PAGE_MASK;
 230         srmmu_mapiorange(bus, pa, res->start, resource_size(res));
 231 
 232         return (void __iomem *)(unsigned long)(res->start + offset);
 233 }
 234 
 235 /*
 236  * Complementary to _sparc_ioremap().
 237  */
 238 static void _sparc_free_io(struct resource *res)
 239 {
 240         unsigned long plen;
 241 
 242         plen = resource_size(res);
 243         BUG_ON((plen & (PAGE_SIZE-1)) != 0);
 244         srmmu_unmapiorange(res->start, plen);
 245         release_resource(res);
 246 }
 247 
 248 unsigned long sparc_dma_alloc_resource(struct device *dev, size_t len)
 249 {
 250         struct resource *res;
 251 
 252         res = kzalloc(sizeof(*res), GFP_KERNEL);
 253         if (!res)
 254                 return 0;
 255         res->name = dev->of_node->full_name;
 256 
 257         if (allocate_resource(&_sparc_dvma, res, len, _sparc_dvma.start,
 258                               _sparc_dvma.end, PAGE_SIZE, NULL, NULL) != 0) {
 259                 printk("%s: cannot occupy 0x%zx", __func__, len);
 260                 kfree(res);
 261                 return 0;
 262         }
 263 
 264         return res->start;
 265 }
 266 
 267 bool sparc_dma_free_resource(void *cpu_addr, size_t size)
 268 {
 269         unsigned long addr = (unsigned long)cpu_addr;
 270         struct resource *res;
 271 
 272         res = lookup_resource(&_sparc_dvma, addr);
 273         if (!res) {
 274                 printk("%s: cannot free %p\n", __func__, cpu_addr);
 275                 return false;
 276         }
 277 
 278         if ((addr & (PAGE_SIZE - 1)) != 0) {
 279                 printk("%s: unaligned va %p\n", __func__, cpu_addr);
 280                 return false;
 281         }
 282 
 283         size = PAGE_ALIGN(size);
 284         if (resource_size(res) != size) {
 285                 printk("%s: region 0x%lx asked 0x%zx\n",
 286                         __func__, (long)resource_size(res), size);
 287                 return false;
 288         }
 289 
 290         release_resource(res);
 291         kfree(res);
 292         return true;
 293 }
 294 
 295 #ifdef CONFIG_SBUS
 296 
 297 void sbus_set_sbus64(struct device *dev, int x)
 298 {
 299         printk("sbus_set_sbus64: unsupported\n");
 300 }
 301 EXPORT_SYMBOL(sbus_set_sbus64);
 302 
 303 static int __init sparc_register_ioport(void)
 304 {
 305         register_proc_sparc_ioport();
 306 
 307         return 0;
 308 }
 309 
 310 arch_initcall(sparc_register_ioport);
 311 
 312 #endif /* CONFIG_SBUS */
 313 
 314 
 315 /* Allocate and map kernel buffer using consistent mode DMA for a device.
 316  * hwdev should be valid struct pci_dev pointer for PCI devices.
 317  */
 318 void *arch_dma_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
 319                 gfp_t gfp, unsigned long attrs)
 320 {
 321         unsigned long addr;
 322         void *va;
 323 
 324         if (!size || size > 256 * 1024) /* __get_free_pages() limit */
 325                 return NULL;
 326 
 327         size = PAGE_ALIGN(size);
 328         va = (void *) __get_free_pages(gfp | __GFP_ZERO, get_order(size));
 329         if (!va) {
 330                 printk("%s: no %zd pages\n", __func__, size >> PAGE_SHIFT);
 331                 return NULL;
 332         }
 333 
 334         addr = sparc_dma_alloc_resource(dev, size);
 335         if (!addr)
 336                 goto err_nomem;
 337 
 338         srmmu_mapiorange(0, virt_to_phys(va), addr, size);
 339 
 340         *dma_handle = virt_to_phys(va);
 341         return (void *)addr;
 342 
 343 err_nomem:
 344         free_pages((unsigned long)va, get_order(size));
 345         return NULL;
 346 }
 347 
 348 /* Free and unmap a consistent DMA buffer.
 349  * cpu_addr is what was returned arch_dma_alloc, size must be the same as what
 350  * was passed into arch_dma_alloc, and likewise dma_addr must be the same as
 351  * what *dma_ndler was set to.
 352  *
 353  * References to the memory and mappings associated with cpu_addr/dma_addr
 354  * past this call are illegal.
 355  */
 356 void arch_dma_free(struct device *dev, size_t size, void *cpu_addr,
 357                 dma_addr_t dma_addr, unsigned long attrs)
 358 {
 359         if (!sparc_dma_free_resource(cpu_addr, PAGE_ALIGN(size)))
 360                 return;
 361 
 362         dma_make_coherent(dma_addr, size);
 363         srmmu_unmapiorange((unsigned long)cpu_addr, size);
 364         free_pages((unsigned long)phys_to_virt(dma_addr), get_order(size));
 365 }
 366 
 367 /* IIep is write-through, not flushing on cpu to device transfer. */
 368 
 369 void arch_sync_dma_for_cpu(struct device *dev, phys_addr_t paddr,
 370                 size_t size, enum dma_data_direction dir)
 371 {
 372         if (dir != PCI_DMA_TODEVICE)
 373                 dma_make_coherent(paddr, PAGE_ALIGN(size));
 374 }
 375 
 376 const struct dma_map_ops *dma_ops;
 377 EXPORT_SYMBOL(dma_ops);
 378 
 379 #ifdef CONFIG_PROC_FS
 380 
 381 static int sparc_io_proc_show(struct seq_file *m, void *v)
 382 {
 383         struct resource *root = m->private, *r;
 384         const char *nm;
 385 
 386         for (r = root->child; r != NULL; r = r->sibling) {
 387                 if ((nm = r->name) == NULL) nm = "???";
 388                 seq_printf(m, "%016llx-%016llx: %s\n",
 389                                 (unsigned long long)r->start,
 390                                 (unsigned long long)r->end, nm);
 391         }
 392 
 393         return 0;
 394 }
 395 #endif /* CONFIG_PROC_FS */
 396 
 397 static void register_proc_sparc_ioport(void)
 398 {
 399 #ifdef CONFIG_PROC_FS
 400         proc_create_single_data("io_map", 0, NULL, sparc_io_proc_show,
 401                         &sparc_iomap);
 402         proc_create_single_data("dvma_map", 0, NULL, sparc_io_proc_show,
 403                         &_sparc_dvma);
 404 #endif
 405 }