Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Port for PPC64 David Engebretsen, IBM Corp. |
| 3 | * Contains common pci routines for ppc64 platform, pSeries and iSeries brands. |
| 4 | * |
| 5 | * Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM |
| 6 | * Rework, based on alpha PCI code. |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or |
| 9 | * modify it under the terms of the GNU General Public License |
| 10 | * as published by the Free Software Foundation; either version |
| 11 | * 2 of the License, or (at your option) any later version. |
| 12 | */ |
| 13 | |
| 14 | #undef DEBUG |
| 15 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | #include <linux/kernel.h> |
| 17 | #include <linux/pci.h> |
| 18 | #include <linux/string.h> |
| 19 | #include <linux/init.h> |
| 20 | #include <linux/bootmem.h> |
Paul Gortmaker | 66b15db | 2011-05-27 10:46:24 -0400 | [diff] [blame] | 21 | #include <linux/export.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | #include <linux/mm.h> |
| 23 | #include <linux/list.h> |
Paul Mackerras | b2ad7b5 | 2005-09-09 23:02:36 +1000 | [diff] [blame] | 24 | #include <linux/syscalls.h> |
Benjamin Herrenschmidt | 6e99e45 | 2006-07-10 04:44:42 -0700 | [diff] [blame] | 25 | #include <linux/irq.h> |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 26 | #include <linux/vmalloc.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | |
| 28 | #include <asm/processor.h> |
| 29 | #include <asm/io.h> |
| 30 | #include <asm/prom.h> |
| 31 | #include <asm/pci-bridge.h> |
| 32 | #include <asm/byteorder.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | #include <asm/machdep.h> |
Stephen Rothwell | d387899 | 2005-09-28 02:50:25 +1000 | [diff] [blame] | 34 | #include <asm/ppc-pci.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | /* pci_io_base -- the base address from which io bars are offsets. |
| 37 | * This is the lowest I/O base address (so bar values are always positive), |
| 38 | * and it *must* be the start of ISA space if an ISA bus exists because |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 39 | * ISA drivers use hard coded offsets. If no ISA bus exists nothing |
| 40 | * is mapped on the first 64K of IO space |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | */ |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 42 | unsigned long pci_io_base = ISA_IO_BASE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | EXPORT_SYMBOL(pci_io_base); |
| 44 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | static int __init pcibios_init(void) |
| 46 | { |
| 47 | struct pci_controller *hose, *tmp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | |
Benjamin Herrenschmidt | 3fd94c6 | 2007-12-20 14:54:53 +1100 | [diff] [blame] | 49 | printk(KERN_INFO "PCI: Probing PCI hardware\n"); |
| 50 | |
Benjamin Herrenschmidt | 5328032 | 2008-10-27 19:48:29 +0000 | [diff] [blame] | 51 | /* For now, override phys_mem_access_prot. If we need it,g |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | * later, we may move that initialization to each ppc_md |
| 53 | */ |
| 54 | ppc_md.phys_mem_access_prot = pci_phys_mem_access_prot; |
| 55 | |
Benjamin Herrenschmidt | 1fd0f52 | 2008-10-02 14:12:51 +0000 | [diff] [blame] | 56 | /* On ppc64, we always enable PCI domains and we keep domain 0 |
| 57 | * backward compatible in /proc for video cards |
| 58 | */ |
Rob Herring | 0e47ff1 | 2011-07-12 09:25:51 -0500 | [diff] [blame] | 59 | pci_add_flags(PCI_ENABLE_PROC_DOMAINS | PCI_COMPAT_DOMAIN_0); |
Benjamin Herrenschmidt | 1fd0f52 | 2008-10-02 14:12:51 +0000 | [diff] [blame] | 60 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | /* Scan all of the recorded PCI controllers. */ |
John Rose | 92eb460 | 2006-03-14 17:46:45 -0600 | [diff] [blame] | 62 | list_for_each_entry_safe(hose, tmp, &hose_list, list_node) { |
Grant Likely | b5d937d | 2011-02-04 11:24:11 -0700 | [diff] [blame] | 63 | pcibios_scan_phb(hose); |
John Rose | 92eb460 | 2006-03-14 17:46:45 -0600 | [diff] [blame] | 64 | pci_bus_add_devices(hose->bus); |
| 65 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | |
Benjamin Herrenschmidt | 3fd94c6 | 2007-12-20 14:54:53 +1100 | [diff] [blame] | 67 | /* Call common code to handle resource allocation */ |
| 68 | pcibios_resource_survey(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | |
Olof Johansson | e884e9c | 2006-04-12 15:26:59 -0500 | [diff] [blame] | 70 | printk(KERN_DEBUG "PCI: Probing PCI hardware done\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | |
| 72 | return 0; |
| 73 | } |
| 74 | |
| 75 | subsys_initcall(pcibios_init); |
| 76 | |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 77 | int pcibios_unmap_io_space(struct pci_bus *bus) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | { |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 79 | struct pci_controller *hose; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 81 | WARN_ON(bus == NULL); |
Benjamin Herrenschmidt | de82120 | 2007-05-15 16:19:36 +1000 | [diff] [blame] | 82 | |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 83 | /* If this is not a PHB, we only flush the hash table over |
| 84 | * the area mapped by this bridge. We don't play with the PTE |
| 85 | * mappings since we might have to deal with sub-page alignemnts |
| 86 | * so flushing the hash table is the only sane way to make sure |
| 87 | * that no hash entries are covering that removed bridge area |
| 88 | * while still allowing other busses overlapping those pages |
Benjamin Herrenschmidt | 9449168 | 2009-06-02 21:17:45 +0000 | [diff] [blame] | 89 | * |
| 90 | * Note: If we ever support P2P hotplug on Book3E, we'll have |
| 91 | * to do an appropriate TLB flush here too |
Benjamin Herrenschmidt | de82120 | 2007-05-15 16:19:36 +1000 | [diff] [blame] | 92 | */ |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 93 | if (bus->self) { |
Kumar Gala | ce7a35c | 2009-10-16 07:05:17 +0000 | [diff] [blame] | 94 | #ifdef CONFIG_PPC_STD_MMU_64 |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 95 | struct resource *res = bus->resource[0]; |
Kumar Gala | ce7a35c | 2009-10-16 07:05:17 +0000 | [diff] [blame] | 96 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | |
Benjamin Herrenschmidt | b0494bc | 2008-10-27 19:48:22 +0000 | [diff] [blame] | 98 | pr_debug("IO unmapping for PCI-PCI bridge %s\n", |
| 99 | pci_name(bus->self)); |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 100 | |
Benjamin Herrenschmidt | 9449168 | 2009-06-02 21:17:45 +0000 | [diff] [blame] | 101 | #ifdef CONFIG_PPC_STD_MMU_64 |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 102 | __flush_hash_table_range(&init_mm, res->start + _IO_BASE, |
Benjamin Herrenschmidt | b30115e | 2008-10-27 19:48:47 +0000 | [diff] [blame] | 103 | res->end + _IO_BASE + 1); |
Benjamin Herrenschmidt | 9449168 | 2009-06-02 21:17:45 +0000 | [diff] [blame] | 104 | #endif |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 105 | return 0; |
| 106 | } |
| 107 | |
| 108 | /* Get the host bridge */ |
| 109 | hose = pci_bus_to_host(bus); |
| 110 | |
| 111 | /* Check if we have IOs allocated */ |
| 112 | if (hose->io_base_alloc == 0) |
| 113 | return 0; |
| 114 | |
Benjamin Herrenschmidt | b0494bc | 2008-10-27 19:48:22 +0000 | [diff] [blame] | 115 | pr_debug("IO unmapping for PHB %s\n", hose->dn->full_name); |
| 116 | pr_debug(" alloc=0x%p\n", hose->io_base_alloc); |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 117 | |
| 118 | /* This is a PHB, we fully unmap the IO area */ |
| 119 | vunmap(hose->io_base_alloc); |
| 120 | |
| 121 | return 0; |
| 122 | } |
| 123 | EXPORT_SYMBOL_GPL(pcibios_unmap_io_space); |
| 124 | |
Greg Kroah-Hartman | cad5cef | 2012-12-21 14:04:10 -0800 | [diff] [blame] | 125 | static int pcibios_map_phb_io_space(struct pci_controller *hose) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | { |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 127 | struct vm_struct *area; |
| 128 | unsigned long phys_page; |
| 129 | unsigned long size_page; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | unsigned long io_virt_offset; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 132 | phys_page = _ALIGN_DOWN(hose->io_base_phys, PAGE_SIZE); |
| 133 | size_page = _ALIGN_UP(hose->pci_io_size, PAGE_SIZE); |
| 134 | |
| 135 | /* Make sure IO area address is clear */ |
| 136 | hose->io_base_alloc = NULL; |
| 137 | |
| 138 | /* If there's no IO to map on that bus, get away too */ |
| 139 | if (hose->pci_io_size == 0 || hose->io_base_phys == 0) |
| 140 | return 0; |
| 141 | |
| 142 | /* Let's allocate some IO space for that guy. We don't pass |
| 143 | * VM_IOREMAP because we don't care about alignment tricks that |
| 144 | * the core does in that case. Maybe we should due to stupid card |
| 145 | * with incomplete address decoding but I'd rather not deal with |
| 146 | * those outside of the reserved 64K legacy region. |
| 147 | */ |
| 148 | area = __get_vm_area(size_page, 0, PHB_IO_BASE, PHB_IO_END); |
| 149 | if (area == NULL) |
| 150 | return -ENOMEM; |
| 151 | hose->io_base_alloc = area->addr; |
| 152 | hose->io_base_virt = (void __iomem *)(area->addr + |
| 153 | hose->io_base_phys - phys_page); |
| 154 | |
Benjamin Herrenschmidt | b0494bc | 2008-10-27 19:48:22 +0000 | [diff] [blame] | 155 | pr_debug("IO mapping for PHB %s\n", hose->dn->full_name); |
Stephen Rothwell | 9477e45 | 2009-01-06 14:27:38 +0000 | [diff] [blame] | 156 | pr_debug(" phys=0x%016llx, virt=0x%p (alloc=0x%p)\n", |
Benjamin Herrenschmidt | b0494bc | 2008-10-27 19:48:22 +0000 | [diff] [blame] | 157 | hose->io_base_phys, hose->io_base_virt, hose->io_base_alloc); |
Stephen Rothwell | bcba077 | 2009-06-02 18:10:57 +0000 | [diff] [blame] | 158 | pr_debug(" size=0x%016llx (alloc=0x%016lx)\n", |
Benjamin Herrenschmidt | b0494bc | 2008-10-27 19:48:22 +0000 | [diff] [blame] | 159 | hose->pci_io_size, size_page); |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 160 | |
| 161 | /* Establish the mapping */ |
| 162 | if (__ioremap_at(phys_page, area->addr, size_page, |
| 163 | _PAGE_NO_CACHE | _PAGE_GUARDED) == NULL) |
| 164 | return -ENOMEM; |
| 165 | |
| 166 | /* Fixup hose IO resource */ |
Bjorn Helgaas | 38973ba | 2012-03-16 17:48:09 -0600 | [diff] [blame] | 167 | io_virt_offset = pcibios_io_space_offset(hose); |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 168 | hose->io_resource.start += io_virt_offset; |
| 169 | hose->io_resource.end += io_virt_offset; |
| 170 | |
Joe Perches | 518fdae | 2010-11-12 14:49:19 +0000 | [diff] [blame] | 171 | pr_debug(" hose->io_resource=%pR\n", &hose->io_resource); |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 172 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | return 0; |
| 174 | } |
Bjorn Helgaas | 49a6cba | 2011-10-28 16:27:38 -0600 | [diff] [blame] | 175 | |
Greg Kroah-Hartman | cad5cef | 2012-12-21 14:04:10 -0800 | [diff] [blame] | 176 | int pcibios_map_io_space(struct pci_bus *bus) |
Bjorn Helgaas | 49a6cba | 2011-10-28 16:27:38 -0600 | [diff] [blame] | 177 | { |
| 178 | WARN_ON(bus == NULL); |
| 179 | |
| 180 | /* If this not a PHB, nothing to do, page tables still exist and |
| 181 | * thus HPTEs will be faulted in when needed |
| 182 | */ |
| 183 | if (bus->self) { |
| 184 | pr_debug("IO mapping for PCI-PCI bridge %s\n", |
| 185 | pci_name(bus->self)); |
| 186 | pr_debug(" virt=0x%016llx...0x%016llx\n", |
| 187 | bus->resource[0]->start + _IO_BASE, |
| 188 | bus->resource[0]->end + _IO_BASE); |
| 189 | return 0; |
| 190 | } |
| 191 | |
| 192 | return pcibios_map_phb_io_space(pci_bus_to_host(bus)); |
| 193 | } |
Benjamin Herrenschmidt | 3d5134e | 2007-06-04 15:15:36 +1000 | [diff] [blame] | 194 | EXPORT_SYMBOL_GPL(pcibios_map_io_space); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | |
Greg Kroah-Hartman | cad5cef | 2012-12-21 14:04:10 -0800 | [diff] [blame] | 196 | void pcibios_setup_phb_io_space(struct pci_controller *hose) |
Grant Likely | 0ed2c72 | 2009-08-28 08:58:16 +0000 | [diff] [blame] | 197 | { |
Bjorn Helgaas | 49a6cba | 2011-10-28 16:27:38 -0600 | [diff] [blame] | 198 | pcibios_map_phb_io_space(hose); |
Grant Likely | 0ed2c72 | 2009-08-28 08:58:16 +0000 | [diff] [blame] | 199 | } |
| 200 | |
Paul Mackerras | b2ad7b5 | 2005-09-09 23:02:36 +1000 | [diff] [blame] | 201 | #define IOBASE_BRIDGE_NUMBER 0 |
| 202 | #define IOBASE_MEMORY 1 |
| 203 | #define IOBASE_IO 2 |
| 204 | #define IOBASE_ISA_IO 3 |
| 205 | #define IOBASE_ISA_MEM 4 |
| 206 | |
| 207 | long sys_pciconfig_iobase(long which, unsigned long in_bus, |
| 208 | unsigned long in_devfn) |
| 209 | { |
| 210 | struct pci_controller* hose; |
| 211 | struct list_head *ln; |
| 212 | struct pci_bus *bus = NULL; |
| 213 | struct device_node *hose_node; |
| 214 | |
| 215 | /* Argh ! Please forgive me for that hack, but that's the |
| 216 | * simplest way to get existing XFree to not lockup on some |
| 217 | * G5 machines... So when something asks for bus 0 io base |
| 218 | * (bus 0 is HT root), we return the AGP one instead. |
| 219 | */ |
Grant Likely | 71a157e | 2010-02-01 21:34:14 -0700 | [diff] [blame] | 220 | if (in_bus == 0 && of_machine_is_compatible("MacRISC4")) { |
Paul Mackerras | 16124f1 | 2008-12-28 14:12:57 +0000 | [diff] [blame] | 221 | struct device_node *agp; |
| 222 | |
| 223 | agp = of_find_compatible_node(NULL, NULL, "u3-agp"); |
| 224 | if (agp) |
Paul Mackerras | b2ad7b5 | 2005-09-09 23:02:36 +1000 | [diff] [blame] | 225 | in_bus = 0xf0; |
Paul Mackerras | 16124f1 | 2008-12-28 14:12:57 +0000 | [diff] [blame] | 226 | of_node_put(agp); |
| 227 | } |
Paul Mackerras | b2ad7b5 | 2005-09-09 23:02:36 +1000 | [diff] [blame] | 228 | |
| 229 | /* That syscall isn't quite compatible with PCI domains, but it's |
| 230 | * used on pre-domains setup. We return the first match |
| 231 | */ |
| 232 | |
| 233 | for (ln = pci_root_buses.next; ln != &pci_root_buses; ln = ln->next) { |
| 234 | bus = pci_bus_b(ln); |
Yinghai Lu | b918c62 | 2012-05-17 18:51:11 -0700 | [diff] [blame] | 235 | if (in_bus >= bus->number && in_bus <= bus->busn_res.end) |
Paul Mackerras | b2ad7b5 | 2005-09-09 23:02:36 +1000 | [diff] [blame] | 236 | break; |
| 237 | bus = NULL; |
| 238 | } |
Grant Likely | b5d937d | 2011-02-04 11:24:11 -0700 | [diff] [blame] | 239 | if (bus == NULL || bus->dev.of_node == NULL) |
Paul Mackerras | b2ad7b5 | 2005-09-09 23:02:36 +1000 | [diff] [blame] | 240 | return -ENODEV; |
| 241 | |
Grant Likely | b5d937d | 2011-02-04 11:24:11 -0700 | [diff] [blame] | 242 | hose_node = bus->dev.of_node; |
Paul Mackerras | b2ad7b5 | 2005-09-09 23:02:36 +1000 | [diff] [blame] | 243 | hose = PCI_DN(hose_node)->phb; |
| 244 | |
| 245 | switch (which) { |
| 246 | case IOBASE_BRIDGE_NUMBER: |
| 247 | return (long)hose->first_busno; |
| 248 | case IOBASE_MEMORY: |
Benjamin Herrenschmidt | 3fd47f0 | 2013-05-06 13:40:40 +1000 | [diff] [blame] | 249 | return (long)hose->mem_offset[0]; |
Paul Mackerras | b2ad7b5 | 2005-09-09 23:02:36 +1000 | [diff] [blame] | 250 | case IOBASE_IO: |
| 251 | return (long)hose->io_base_phys; |
| 252 | case IOBASE_ISA_IO: |
| 253 | return (long)isa_io_base; |
| 254 | case IOBASE_ISA_MEM: |
| 255 | return -EINVAL; |
| 256 | } |
| 257 | |
| 258 | return -EOPNOTSUPP; |
| 259 | } |
Anton Blanchard | 357518f | 2006-06-10 20:53:06 +1000 | [diff] [blame] | 260 | |
| 261 | #ifdef CONFIG_NUMA |
| 262 | int pcibus_to_node(struct pci_bus *bus) |
| 263 | { |
| 264 | struct pci_controller *phb = pci_bus_to_host(bus); |
| 265 | return phb->node; |
| 266 | } |
| 267 | EXPORT_SYMBOL(pcibus_to_node); |
| 268 | #endif |
Benjamin Herrenschmidt | b72c1f6 | 2013-05-21 22:58:21 +0000 | [diff] [blame] | 269 | |
| 270 | static void quirk_radeon_32bit_msi(struct pci_dev *dev) |
| 271 | { |
| 272 | struct pci_dn *pdn = pci_get_pdn(dev); |
| 273 | |
| 274 | if (pdn) |
| 275 | pdn->force_32bit_msi = 1; |
| 276 | } |
| 277 | DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x68f2, quirk_radeon_32bit_msi); |
| 278 | DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0xaa68, quirk_radeon_32bit_msi); |