linux/arch/sparc/kernel/ioport.c
<<
>>
Prefs
   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-map-ops.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 */
  58static 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
  66static void __iomem *_sparc_ioremap(struct resource *res, u32 bus, u32 pa, int sz);
  67static void __iomem *_sparc_alloc_io(unsigned int busno, unsigned long phys,
  68    unsigned long size, char *name);
  69static void _sparc_free_io(struct resource *res);
  70
  71static void register_proc_sparc_ioport(void);
  72
  73/* This points to the next to use virtual memory for DVMA mappings */
  74static 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
  91struct xresource {
  92        struct resource xres;   /* Must be first */
  93        int xflag;              /* 1 == used */
  94        char xname[XNMLN+1];
  95};
  96
  97static struct xresource xresv[XNRES];
  98
  99static 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
 114static 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 */
 124void __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}
 131EXPORT_SYMBOL(ioremap);
 132
 133/*
 134 * Complementary to ioremap().
 135 */
 136void 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}
 157EXPORT_SYMBOL(iounmap);
 158
 159void __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}
 166EXPORT_SYMBOL(of_ioremap);
 167
 168void of_iounmap(struct resource *res, void __iomem *base, unsigned long size)
 169{
 170        iounmap(base);
 171}
 172EXPORT_SYMBOL(of_iounmap);
 173
 174/*
 175 * Meat of mapping
 176 */
 177static 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 */
 215static 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 */
 238static 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
 248unsigned 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
 267bool 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
 297void sbus_set_sbus64(struct device *dev, int x)
 298{
 299        printk("sbus_set_sbus64: unsupported\n");
 300}
 301EXPORT_SYMBOL(sbus_set_sbus64);
 302
 303static int __init sparc_register_ioport(void)
 304{
 305        register_proc_sparc_ioport();
 306
 307        return 0;
 308}
 309
 310arch_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 */
 318void *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
 343err_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 */
 356void 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
 369void arch_sync_dma_for_cpu(phys_addr_t paddr, size_t size,
 370                enum dma_data_direction dir)
 371{
 372        if (dir != PCI_DMA_TODEVICE)
 373                dma_make_coherent(paddr, PAGE_ALIGN(size));
 374}
 375
 376#ifdef CONFIG_PROC_FS
 377
 378static int sparc_io_proc_show(struct seq_file *m, void *v)
 379{
 380        struct resource *root = m->private, *r;
 381        const char *nm;
 382
 383        for (r = root->child; r != NULL; r = r->sibling) {
 384                if ((nm = r->name) == NULL) nm = "???";
 385                seq_printf(m, "%016llx-%016llx: %s\n",
 386                                (unsigned long long)r->start,
 387                                (unsigned long long)r->end, nm);
 388        }
 389
 390        return 0;
 391}
 392#endif /* CONFIG_PROC_FS */
 393
 394static void register_proc_sparc_ioport(void)
 395{
 396#ifdef CONFIG_PROC_FS
 397        proc_create_single_data("io_map", 0, NULL, sparc_io_proc_show,
 398                        &sparc_iomap);
 399        proc_create_single_data("dvma_map", 0, NULL, sparc_io_proc_show,
 400                        &_sparc_dvma);
 401#endif
 402}
 403
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.