1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Routines for tracking a legacy ISA bridge 4 * 5 * Copyrigh 2007 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp. 6 * 7 * Some bits and pieces moved over from pci_64.c 8 * 9 * Copyrigh 2003 Anton Blanchard <anton@au.ibm.com>, IBM Corp. 10 */ 11 12 #define DEBUG 13 14 #include <linux/kernel.h> 15 #include <linux/pci.h> 16 #include <linux/string.h> 17 #include <linux/export.h> 18 #include <linux/init.h> 19 #include <linux/mm.h> 20 #include <linux/notifier.h> 21 #include <linux/vmalloc.h> 22 23 #include <asm/processor.h> 24 #include <asm/io.h> 25 #include <asm/prom.h> 26 #include <asm/pci-bridge.h> 27 #include <asm/machdep.h> 28 #include <asm/ppc-pci.h> 29 #include <asm/isa-bridge.h> 30 31 unsigned long isa_io_base; /* NULL if no ISA bus */ 32 EXPORT_SYMBOL(isa_io_base); 33 34 /* Cached ISA bridge dev. */ 35 static struct device_node *isa_bridge_devnode; 36 struct pci_dev *isa_bridge_pcidev; 37 EXPORT_SYMBOL_GPL(isa_bridge_pcidev); 38 39 #define ISA_SPACE_MASK 0x1 40 #define ISA_SPACE_IO 0x1 41 42 static void remap_isa_base(phys_addr_t pa, unsigned long size) 43 { 44 WARN_ON_ONCE(ISA_IO_BASE & ~PAGE_MASK); 45 WARN_ON_ONCE(pa & ~PAGE_MASK); 46 WARN_ON_ONCE(size & ~PAGE_MASK); 47 48 if (slab_is_available()) { 49 if (ioremap_page_range(ISA_IO_BASE, ISA_IO_BASE + size, pa, 50 pgprot_noncached(PAGE_KERNEL))) 51 unmap_kernel_range(ISA_IO_BASE, size); 52 } else { 53 early_ioremap_range(ISA_IO_BASE, pa, size, 54 pgprot_noncached(PAGE_KERNEL)); 55 } 56 } 57 58 static void pci_process_ISA_OF_ranges(struct device_node *isa_node, 59 unsigned long phb_io_base_phys) 60 { 61 /* We should get some saner parsing here and remove these structs */ 62 struct pci_address { 63 u32 a_hi; 64 u32 a_mid; 65 u32 a_lo; 66 }; 67 68 struct isa_address { 69 u32 a_hi; 70 u32 a_lo; 71 }; 72 73 struct isa_range { 74 struct isa_address isa_addr; 75 struct pci_address pci_addr; 76 unsigned int size; 77 }; 78 79 const struct isa_range *range; 80 unsigned long pci_addr; 81 unsigned int isa_addr; 82 unsigned int size; 83 int rlen = 0; 84 85 range = of_get_property(isa_node, "ranges", &rlen); 86 if (range == NULL || (rlen < sizeof(struct isa_range))) 87 goto inval_range; 88 89 /* From "ISA Binding to 1275" 90 * The ranges property is laid out as an array of elements, 91 * each of which comprises: 92 * cells 0 - 1: an ISA address 93 * cells 2 - 4: a PCI address 94 * (size depending on dev->n_addr_cells) 95 * cell 5: the size of the range 96 */ 97 if ((range->isa_addr.a_hi & ISA_SPACE_MASK) != ISA_SPACE_IO) { 98 range++; 99 rlen -= sizeof(struct isa_range); 100 if (rlen < sizeof(struct isa_range)) 101 goto inval_range; 102 } 103 if ((range->isa_addr.a_hi & ISA_SPACE_MASK) != ISA_SPACE_IO) 104 goto inval_range; 105 106 isa_addr = range->isa_addr.a_lo; 107 pci_addr = (unsigned long) range->pci_addr.a_mid << 32 | 108 range->pci_addr.a_lo; 109 110 /* Assume these are both zero. Note: We could fix that and 111 * do a proper parsing instead ... oh well, that will do for 112 * now as nobody uses fancy mappings for ISA bridges 113 */ 114 if ((pci_addr != 0) || (isa_addr != 0)) { 115 printk(KERN_ERR "unexpected isa to pci mapping: %s\n", 116 __func__); 117 return; 118 } 119 120 /* Align size and make sure it's cropped to 64K */ 121 size = PAGE_ALIGN(range->size); 122 if (size > 0x10000) 123 size = 0x10000; 124 125 remap_isa_base(phb_io_base_phys, size); 126 return; 127 128 inval_range: 129 printk(KERN_ERR "no ISA IO ranges or unexpected isa range, " 130 "mapping 64k\n"); 131 remap_isa_base(phb_io_base_phys, 0x10000); 132 } 133 134 135 /** 136 * isa_bridge_find_early - Find and map the ISA IO space early before 137 * main PCI discovery. This is optionally called by 138 * the arch code when adding PCI PHBs to get early 139 * access to ISA IO ports 140 */ 141 void __init isa_bridge_find_early(struct pci_controller *hose) 142 { 143 struct device_node *np, *parent = NULL, *tmp; 144 145 /* If we already have an ISA bridge, bail off */ 146 if (isa_bridge_devnode != NULL) 147 return; 148 149 /* For each "isa" node in the system. Note : we do a search by 150 * type and not by name. It might be better to do by name but that's 151 * what the code used to do and I don't want to break too much at 152 * once. We can look into changing that separately 153 */ 154 for_each_node_by_type(np, "isa") { 155 /* Look for our hose being a parent */ 156 for (parent = of_get_parent(np); parent;) { 157 if (parent == hose->dn) { 158 of_node_put(parent); 159 break; 160 } 161 tmp = parent; 162 parent = of_get_parent(parent); 163 of_node_put(tmp); 164 } 165 if (parent != NULL) 166 break; 167 } 168 if (np == NULL) 169 return; 170 isa_bridge_devnode = np; 171 172 /* Now parse the "ranges" property and setup the ISA mapping */ 173 pci_process_ISA_OF_ranges(np, hose->io_base_phys); 174 175 /* Set the global ISA io base to indicate we have an ISA bridge */ 176 isa_io_base = ISA_IO_BASE; 177 178 pr_debug("ISA bridge (early) is %pOF\n", np); 179 } 180 181 /** 182 * isa_bridge_find_early - Find and map the ISA IO space early before 183 * main PCI discovery. This is optionally called by 184 * the arch code when adding PCI PHBs to get early 185 * access to ISA IO ports 186 */ 187 void __init isa_bridge_init_non_pci(struct device_node *np) 188 { 189 const __be32 *ranges, *pbasep = NULL; 190 int rlen, i, rs; 191 u32 na, ns, pna; 192 u64 cbase, pbase, size = 0; 193 194 /* If we already have an ISA bridge, bail off */ 195 if (isa_bridge_devnode != NULL) 196 return; 197 198 pna = of_n_addr_cells(np); 199 if (of_property_read_u32(np, "#address-cells", &na) || 200 of_property_read_u32(np, "#size-cells", &ns)) { 201 pr_warn("ISA: Non-PCI bridge %pOF is missing address format\n", 202 np); 203 return; 204 } 205 206 /* Check it's a supported address format */ 207 if (na != 2 || ns != 1) { 208 pr_warn("ISA: Non-PCI bridge %pOF has unsupported address format\n", 209 np); 210 return; 211 } 212 rs = na + ns + pna; 213 214 /* Grab the ranges property */ 215 ranges = of_get_property(np, "ranges", &rlen); 216 if (ranges == NULL || rlen < rs) { 217 pr_warn("ISA: Non-PCI bridge %pOF has absent or invalid ranges\n", 218 np); 219 return; 220 } 221 222 /* Parse it. We are only looking for IO space */ 223 for (i = 0; (i + rs - 1) < rlen; i += rs) { 224 if (be32_to_cpup(ranges + i) != 1) 225 continue; 226 cbase = be32_to_cpup(ranges + i + 1); 227 size = of_read_number(ranges + i + na + pna, ns); 228 pbasep = ranges + i + na; 229 break; 230 } 231 232 /* Got something ? */ 233 if (!size || !pbasep) { 234 pr_warn("ISA: Non-PCI bridge %pOF has no usable IO range\n", 235 np); 236 return; 237 } 238 239 /* Align size and make sure it's cropped to 64K */ 240 size = PAGE_ALIGN(size); 241 if (size > 0x10000) 242 size = 0x10000; 243 244 /* Map pbase */ 245 pbase = of_translate_address(np, pbasep); 246 if (pbase == OF_BAD_ADDR) { 247 pr_warn("ISA: Non-PCI bridge %pOF failed to translate IO base\n", 248 np); 249 return; 250 } 251 252 /* We need page alignment */ 253 if ((cbase & ~PAGE_MASK) || (pbase & ~PAGE_MASK)) { 254 pr_warn("ISA: Non-PCI bridge %pOF has non aligned IO range\n", 255 np); 256 return; 257 } 258 259 /* Got it */ 260 isa_bridge_devnode = np; 261 262 /* Set the global ISA io base to indicate we have an ISA bridge 263 * and map it 264 */ 265 isa_io_base = ISA_IO_BASE; 266 remap_isa_base(pbase, size); 267 268 pr_debug("ISA: Non-PCI bridge is %pOF\n", np); 269 } 270 271 /** 272 * isa_bridge_find_late - Find and map the ISA IO space upon discovery of 273 * a new ISA bridge 274 */ 275 static void isa_bridge_find_late(struct pci_dev *pdev, 276 struct device_node *devnode) 277 { 278 struct pci_controller *hose = pci_bus_to_host(pdev->bus); 279 280 /* Store ISA device node and PCI device */ 281 isa_bridge_devnode = of_node_get(devnode); 282 isa_bridge_pcidev = pdev; 283 284 /* Now parse the "ranges" property and setup the ISA mapping */ 285 pci_process_ISA_OF_ranges(devnode, hose->io_base_phys); 286 287 /* Set the global ISA io base to indicate we have an ISA bridge */ 288 isa_io_base = ISA_IO_BASE; 289 290 pr_debug("ISA bridge (late) is %pOF on %s\n", 291 devnode, pci_name(pdev)); 292 } 293 294 /** 295 * isa_bridge_remove - Remove/unmap an ISA bridge 296 */ 297 static void isa_bridge_remove(void) 298 { 299 pr_debug("ISA bridge removed !\n"); 300 301 /* Clear the global ISA io base to indicate that we have no more 302 * ISA bridge. Note that drivers don't quite handle that, though 303 * we should probably do something about it. But do we ever really 304 * have ISA bridges being removed on machines using legacy devices ? 305 */ 306 isa_io_base = ISA_IO_BASE; 307 308 /* Clear references to the bridge */ 309 of_node_put(isa_bridge_devnode); 310 isa_bridge_devnode = NULL; 311 isa_bridge_pcidev = NULL; 312 313 /* Unmap the ISA area */ 314 unmap_kernel_range(ISA_IO_BASE, 0x10000); 315 } 316 317 /** 318 * isa_bridge_notify - Get notified of PCI devices addition/removal 319 */ 320 static int isa_bridge_notify(struct notifier_block *nb, unsigned long action, 321 void *data) 322 { 323 struct device *dev = data; 324 struct pci_dev *pdev = to_pci_dev(dev); 325 struct device_node *devnode = pci_device_to_OF_node(pdev); 326 327 switch(action) { 328 case BUS_NOTIFY_ADD_DEVICE: 329 /* Check if we have an early ISA device, without PCI dev */ 330 if (isa_bridge_devnode && isa_bridge_devnode == devnode && 331 !isa_bridge_pcidev) { 332 pr_debug("ISA bridge PCI attached: %s\n", 333 pci_name(pdev)); 334 isa_bridge_pcidev = pdev; 335 } 336 337 /* Check if we have no ISA device, and this happens to be one, 338 * register it as such if it has an OF device 339 */ 340 if (!isa_bridge_devnode && of_node_is_type(devnode, "isa")) 341 isa_bridge_find_late(pdev, devnode); 342 343 return 0; 344 case BUS_NOTIFY_DEL_DEVICE: 345 /* Check if this our existing ISA device */ 346 if (pdev == isa_bridge_pcidev || 347 (devnode && devnode == isa_bridge_devnode)) 348 isa_bridge_remove(); 349 return 0; 350 } 351 return 0; 352 } 353 354 static struct notifier_block isa_bridge_notifier = { 355 .notifier_call = isa_bridge_notify 356 }; 357 358 /** 359 * isa_bridge_init - register to be notified of ISA bridge addition/removal 360 * 361 */ 362 static int __init isa_bridge_init(void) 363 { 364 bus_register_notifier(&pci_bus_type, &isa_bridge_notifier); 365 return 0; 366 } 367 arch_initcall(isa_bridge_init); 368