platforms/cell/spider-pci.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * IO workarounds for PCI on Celleb/Cell platform
0004  *
0005  * (C) Copyright 2006-2007 TOSHIBA CORPORATION
0006  */
0007
0008 #undef DEBUG
0009
0010 #include <linux/kernel.h>
0011 #include <linux/of_address.h>
0012 #include <linux/of_platform.h>
0013 #include <linux/slab.h>
0014 #include <linux/io.h>
0015
0016 #include <asm/ppc-pci.h>
0017 #include <asm/pci-bridge.h>
0018 #include <asm/io-workarounds.h>
0019
0020 #define SPIDER_PCI_DISABLE_PREFETCH
0021
0022 struct spiderpci_iowa_private {
0023     void __iomem *regs;
0024 };
0025
0026 static void spiderpci_io_flush(struct iowa_bus *bus)
0027 {
0028     struct spiderpci_iowa_private *priv;
0029
0030     priv = bus->private;
0031     in_be32(priv->regs + SPIDER_PCI_DUMMY_READ);
0032     iosync();
0033 }
0034
0035 #define SPIDER_PCI_MMIO_READ(name, ret)                 \
0036 static ret spiderpci_##name(const PCI_IO_ADDR addr)         \
0037 {                                   \
0038     ret val = __do_##name(addr);                    \
0039     spiderpci_io_flush(iowa_mem_find_bus(addr));            \
0040     return val;                         \
0041 }
0042
0043 #define SPIDER_PCI_MMIO_READ_STR(name)                  \
0044 static void spiderpci_##name(const PCI_IO_ADDR addr, void *buf,     \
0045                  unsigned long count)           \
0046 {                                   \
0047     __do_##name(addr, buf, count);                  \
0048     spiderpci_io_flush(iowa_mem_find_bus(addr));            \
0049 }
0050
0051 SPIDER_PCI_MMIO_READ(readb, u8)
0052 SPIDER_PCI_MMIO_READ(readw, u16)
0053 SPIDER_PCI_MMIO_READ(readl, u32)
0054 SPIDER_PCI_MMIO_READ(readq, u64)
0055 SPIDER_PCI_MMIO_READ(readw_be, u16)
0056 SPIDER_PCI_MMIO_READ(readl_be, u32)
0057 SPIDER_PCI_MMIO_READ(readq_be, u64)
0058 SPIDER_PCI_MMIO_READ_STR(readsb)
0059 SPIDER_PCI_MMIO_READ_STR(readsw)
0060 SPIDER_PCI_MMIO_READ_STR(readsl)
0061
0062 static void spiderpci_memcpy_fromio(void *dest, const PCI_IO_ADDR src,
0063                     unsigned long n)
0064 {
0065     __do_memcpy_fromio(dest, src, n);
0066     spiderpci_io_flush(iowa_mem_find_bus(src));
0067 }
0068
0069 static int __init spiderpci_pci_setup_chip(struct pci_controller *phb,
0070                        void __iomem *regs)
0071 {
0072     void *dummy_page_va;
0073     dma_addr_t dummy_page_da;
0074
0075 #ifdef SPIDER_PCI_DISABLE_PREFETCH
0076     u32 val = in_be32(regs + SPIDER_PCI_VCI_CNTL_STAT);
0077     pr_debug("SPIDER_IOWA:PVCI_Control_Status was 0x%08x\n", val);
0078     out_be32(regs + SPIDER_PCI_VCI_CNTL_STAT, val | 0x8);
0079 #endif /* SPIDER_PCI_DISABLE_PREFETCH */
0080
0081     /* setup dummy read */
0082     /*
0083      * On CellBlade, we can't know that which XDR memory is used by
0084      * kmalloc() to allocate dummy_page_va.
0085      * In order to improve the performance, the XDR which is used to
0086      * allocate dummy_page_va is the nearest the spider-pci.
0087      * We have to select the CBE which is the nearest the spider-pci
0088      * to allocate memory from the best XDR, but I don't know that
0089      * how to do.
0090      *
0091      * Celleb does not have this problem, because it has only one XDR.
0092      */
0093     dummy_page_va = kmalloc(PAGE_SIZE, GFP_KERNEL);
0094     if (!dummy_page_va) {
0095         pr_err("SPIDERPCI-IOWA:Alloc dummy_page_va failed.\n");
0096         return -1;
0097     }
0098
0099     dummy_page_da = dma_map_single(phb->parent, dummy_page_va,
0100                        PAGE_SIZE, DMA_FROM_DEVICE);
0101     if (dma_mapping_error(phb->parent, dummy_page_da)) {
0102         pr_err("SPIDER-IOWA:Map dummy page filed.\n");
0103         kfree(dummy_page_va);
0104         return -1;
0105     }
0106
0107     out_be32(regs + SPIDER_PCI_DUMMY_READ_BASE, dummy_page_da);
0108
0109     return 0;
0110 }
0111
0112 int __init spiderpci_iowa_init(struct iowa_bus *bus, void *data)
0113 {
0114     void __iomem *regs = NULL;
0115     struct spiderpci_iowa_private *priv;
0116     struct device_node *np = bus->phb->dn;
0117     struct resource r;
0118     unsigned long offset = (unsigned long)data;
0119
0120     pr_debug("SPIDERPCI-IOWA:Bus initialize for spider(%pOF)\n",
0121          np);
0122
0123     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
0124     if (!priv) {
0125         pr_err("SPIDERPCI-IOWA:"
0126                "Can't allocate struct spiderpci_iowa_private");
0127         return -1;
0128     }
0129
0130     if (of_address_to_resource(np, 0, &r)) {
0131         pr_err("SPIDERPCI-IOWA:Can't get resource.\n");
0132         goto error;
0133     }
0134
0135     regs = ioremap(r.start + offset, SPIDER_PCI_REG_SIZE);
0136     if (!regs) {
0137         pr_err("SPIDERPCI-IOWA:ioremap failed.\n");
0138         goto error;
0139     }
0140     priv->regs = regs;
0141     bus->private = priv;
0142
0143     if (spiderpci_pci_setup_chip(bus->phb, regs))
0144         goto error;
0145
0146     return 0;
0147
0148 error:
0149     kfree(priv);
0150     bus->private = NULL;
0151
0152     if (regs)
0153         iounmap(regs);
0154
0155     return -1;
0156 }
0157
0158 struct ppc_pci_io spiderpci_ops = {
0159     .readb = spiderpci_readb,
0160     .readw = spiderpci_readw,
0161     .readl = spiderpci_readl,
0162     .readq = spiderpci_readq,
0163     .readw_be = spiderpci_readw_be,
0164     .readl_be = spiderpci_readl_be,
0165     .readq_be = spiderpci_readq_be,
0166     .readsb = spiderpci_readsb,
0167     .readsw = spiderpci_readsw,
0168     .readsl = spiderpci_readsl,
0169     .memcpy_fromio = spiderpci_memcpy_fromio,
0170 };
0171