1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/arch/alpha/kernel/pci.c 4 * 5 * Extruded from code written by 6 * Dave Rusling (david.rusling@reo.mts.dec.com) 7 * David Mosberger (davidm@cs.arizona.edu) 8 */ 9 10 /* 2.3.x PCI/resources, 1999 Andrea Arcangeli <andrea@suse.de> */ 11 12 /* 13 * Nov 2000, Ivan Kokshaysky <ink@jurassic.park.msu.ru> 14 * PCI-PCI bridges cleanup 15 */ 16 #include <linux/string.h> 17 #include <linux/pci.h> 18 #include <linux/init.h> 19 #include <linux/ioport.h> 20 #include <linux/kernel.h> 21 #include <linux/bootmem.h> 22 #include <linux/module.h> 23 #include <linux/cache.h> 24 #include <linux/slab.h> 25 #include <asm/machvec.h> 26 27 #include "proto.h" 28 #include "pci_impl.h" 29 30 31 /* 32 * Some string constants used by the various core logics. 33 */ 34 35 const char *const pci_io_names[] = { 36 "PCI IO bus 0", "PCI IO bus 1", "PCI IO bus 2", "PCI IO bus 3", 37 "PCI IO bus 4", "PCI IO bus 5", "PCI IO bus 6", "PCI IO bus 7" 38 }; 39 40 const char *const pci_mem_names[] = { 41 "PCI mem bus 0", "PCI mem bus 1", "PCI mem bus 2", "PCI mem bus 3", 42 "PCI mem bus 4", "PCI mem bus 5", "PCI mem bus 6", "PCI mem bus 7" 43 }; 44 45 const char pci_hae0_name[] = "HAE0"; 46 47 /* 48 * If PCI_PROBE_ONLY in pci_flags is set, we don't change any PCI resource 49 * assignments. 50 */ 51 52 /* 53 * The PCI controller list. 54 */ 55 56 struct pci_controller *hose_head, **hose_tail = &hose_head; 57 struct pci_controller *pci_isa_hose; 58 59 /* 60 * Quirks. 61 */ 62 63 static void quirk_isa_bridge(struct pci_dev *dev) 64 { 65 dev->class = PCI_CLASS_BRIDGE_ISA << 8; 66 } 67 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82378, quirk_isa_bridge); 68 69 static void quirk_cypress(struct pci_dev *dev) 70 { 71 /* The Notorious Cy82C693 chip. */ 72 73 /* The generic legacy mode IDE fixup in drivers/pci/probe.c 74 doesn't work correctly with the Cypress IDE controller as 75 it has non-standard register layout. Fix that. */ 76 if (dev->class >> 8 == PCI_CLASS_STORAGE_IDE) { 77 dev->resource[2].start = dev->resource[3].start = 0; 78 dev->resource[2].end = dev->resource[3].end = 0; 79 dev->resource[2].flags = dev->resource[3].flags = 0; 80 if (PCI_FUNC(dev->devfn) == 2) { 81 dev->resource[0].start = 0x170; 82 dev->resource[0].end = 0x177; 83 dev->resource[1].start = 0x376; 84 dev->resource[1].end = 0x376; 85 } 86 } 87 88 /* The Cypress bridge responds on the PCI bus in the address range 89 0xffff0000-0xffffffff (conventional x86 BIOS ROM). There is no 90 way to turn this off. The bridge also supports several extended 91 BIOS ranges (disabled after power-up), and some consoles do turn 92 them on. So if we use a large direct-map window, or a large SG 93 window, we must avoid the entire 0xfff00000-0xffffffff region. */ 94 if (dev->class >> 8 == PCI_CLASS_BRIDGE_ISA) { 95 if (__direct_map_base + __direct_map_size >= 0xfff00000UL) 96 __direct_map_size = 0xfff00000UL - __direct_map_base; 97 else { 98 struct pci_controller *hose = dev->sysdata; 99 struct pci_iommu_arena *pci = hose->sg_pci; 100 if (pci && pci->dma_base + pci->size >= 0xfff00000UL) 101 pci->size = 0xfff00000UL - pci->dma_base; 102 } 103 } 104 } 105 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_CONTAQ, PCI_DEVICE_ID_CONTAQ_82C693, quirk_cypress); 106 107 /* Called for each device after PCI setup is done. */ 108 static void pcibios_fixup_final(struct pci_dev *dev) 109 { 110 unsigned int class = dev->class >> 8; 111 112 if (class == PCI_CLASS_BRIDGE_ISA || class == PCI_CLASS_BRIDGE_EISA) { 113 dev->dma_mask = MAX_ISA_DMA_ADDRESS - 1; 114 isa_bridge = dev; 115 } 116 } 117 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pcibios_fixup_final); 118 119 /* Just declaring that the power-of-ten prefixes are actually the 120 power-of-two ones doesn't make it true :) */ 121 #define KB 1024 122 #define MB (1024*KB) 123 #define GB (1024*MB) 124 125 resource_size_t 126 pcibios_align_resource(void *data, const struct resource *res, 127 resource_size_t size, resource_size_t align) 128 { 129 struct pci_dev *dev = data; 130 struct pci_controller *hose = dev->sysdata; 131 unsigned long alignto; 132 resource_size_t start = res->start; 133 134 if (res->flags & IORESOURCE_IO) { 135 /* Make sure we start at our min on all hoses */ 136 if (start - hose->io_space->start < PCIBIOS_MIN_IO) 137 start = PCIBIOS_MIN_IO + hose->io_space->start; 138 139 /* 140 * Put everything into 0x00-0xff region modulo 0x400 141 */ 142 if (start & 0x300) 143 start = (start + 0x3ff) & ~0x3ff; 144 } 145 else if (res->flags & IORESOURCE_MEM) { 146 /* Make sure we start at our min on all hoses */ 147 if (start - hose->mem_space->start < PCIBIOS_MIN_MEM) 148 start = PCIBIOS_MIN_MEM + hose->mem_space->start; 149 150 /* 151 * The following holds at least for the Low Cost 152 * Alpha implementation of the PCI interface: 153 * 154 * In sparse memory address space, the first 155 * octant (16MB) of every 128MB segment is 156 * aliased to the very first 16 MB of the 157 * address space (i.e., it aliases the ISA 158 * memory address space). Thus, we try to 159 * avoid allocating PCI devices in that range. 160 * Can be allocated in 2nd-7th octant only. 161 * Devices that need more than 112MB of 162 * address space must be accessed through 163 * dense memory space only! 164 */ 165 166 /* Align to multiple of size of minimum base. */ 167 alignto = max_t(resource_size_t, 0x1000, align); 168 start = ALIGN(start, alignto); 169 if (hose->sparse_mem_base && size <= 7 * 16*MB) { 170 if (((start / (16*MB)) & 0x7) == 0) { 171 start &= ~(128*MB - 1); 172 start += 16*MB; 173 start = ALIGN(start, alignto); 174 } 175 if (start/(128*MB) != (start + size - 1)/(128*MB)) { 176 start &= ~(128*MB - 1); 177 start += (128 + 16)*MB; 178 start = ALIGN(start, alignto); 179 } 180 } 181 } 182 183 return start; 184 } 185 #undef KB 186 #undef MB 187 #undef GB 188 189 static int __init 190 pcibios_init(void) 191 { 192 if (alpha_mv.init_pci) 193 alpha_mv.init_pci(); 194 return 0; 195 } 196 197 subsys_initcall(pcibios_init); 198 199 #ifdef ALPHA_RESTORE_SRM_SETUP 200 static struct pdev_srm_saved_conf *srm_saved_configs; 201 202 void pdev_save_srm_config(struct pci_dev *dev) 203 { 204 struct pdev_srm_saved_conf *tmp; 205 static int printed = 0; 206 207 if (!alpha_using_srm || pci_has_flag(PCI_PROBE_ONLY)) 208 return; 209 210 if (!printed) { 211 printk(KERN_INFO "pci: enabling save/restore of SRM state\n"); 212 printed = 1; 213 } 214 215 tmp = kmalloc(sizeof(*tmp), GFP_KERNEL); 216 if (!tmp) { 217 printk(KERN_ERR "%s: kmalloc() failed!\n", __func__); 218 return; 219 } 220 tmp->next = srm_saved_configs; 221 tmp->dev = dev; 222 223 pci_save_state(dev); 224 225 srm_saved_configs = tmp; 226 } 227 228 void 229 pci_restore_srm_config(void) 230 { 231 struct pdev_srm_saved_conf *tmp; 232 233 /* No need to restore if probed only. */ 234 if (pci_has_flag(PCI_PROBE_ONLY)) 235 return; 236 237 /* Restore SRM config. */ 238 for (tmp = srm_saved_configs; tmp; tmp = tmp->next) { 239 pci_restore_state(tmp->dev); 240 } 241 } 242 #endif 243 244 void pcibios_fixup_bus(struct pci_bus *bus) 245 { 246 struct pci_dev *dev = bus->self; 247 248 if (pci_has_flag(PCI_PROBE_ONLY) && dev && 249 (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) { 250 pci_read_bridge_bases(bus); 251 } 252 253 list_for_each_entry(dev, &bus->devices, bus_list) { 254 pdev_save_srm_config(dev); 255 } 256 } 257 258 /* 259 * If we set up a device for bus mastering, we need to check the latency 260 * timer as certain firmware forgets to set it properly, as seen 261 * on SX164 and LX164 with SRM. 262 */ 263 void 264 pcibios_set_master(struct pci_dev *dev) 265 { 266 u8 lat; 267 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat); 268 if (lat >= 16) return; 269 printk("PCI: Setting latency timer of device %s to 64\n", 270 pci_name(dev)); 271 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64); 272 } 273 274 void __init 275 pcibios_claim_one_bus(struct pci_bus *b) 276 { 277 struct pci_dev *dev; 278 struct pci_bus *child_bus; 279 280 list_for_each_entry(dev, &b->devices, bus_list) { 281 int i; 282 283 for (i = 0; i < PCI_NUM_RESOURCES; i++) { 284 struct resource *r = &dev->resource[i]; 285 286 if (r->parent || !r->start || !r->flags) 287 continue; 288 if (pci_has_flag(PCI_PROBE_ONLY) || 289 (r->flags & IORESOURCE_PCI_FIXED)) { 290 if (pci_claim_resource(dev, i) == 0) 291 continue; 292 293 pci_claim_bridge_resource(dev, i); 294 } 295 } 296 } 297 298 list_for_each_entry(child_bus, &b->children, node) 299 pcibios_claim_one_bus(child_bus); 300 } 301 302 static void __init 303 pcibios_claim_console_setup(void) 304 { 305 struct pci_bus *b; 306 307 list_for_each_entry(b, &pci_root_buses, node) 308 pcibios_claim_one_bus(b); 309 } 310 311 void __init 312 common_init_pci(void) 313 { 314 struct pci_controller *hose; 315 struct list_head resources; 316 struct pci_host_bridge *bridge; 317 struct pci_bus *bus; 318 int ret, next_busno; 319 int need_domain_info = 0; 320 u32 pci_mem_end; 321 u32 sg_base; 322 unsigned long end; 323 324 /* Scan all of the recorded PCI controllers. */ 325 for (next_busno = 0, hose = hose_head; hose; hose = hose->next) { 326 sg_base = hose->sg_pci ? hose->sg_pci->dma_base : ~0; 327 328 /* Adjust hose mem_space limit to prevent PCI allocations 329 in the iommu windows. */ 330 pci_mem_end = min((u32)__direct_map_base, sg_base) - 1; 331 end = hose->mem_space->start + pci_mem_end; 332 if (hose->mem_space->end > end) 333 hose->mem_space->end = end; 334 335 INIT_LIST_HEAD(&resources); 336 pci_add_resource_offset(&resources, hose->io_space, 337 hose->io_space->start); 338 pci_add_resource_offset(&resources, hose->mem_space, 339 hose->mem_space->start); 340 341 bridge = pci_alloc_host_bridge(0); 342 if (!bridge) 343 continue; 344 345 list_splice_init(&resources, &bridge->windows); 346 bridge->dev.parent = NULL; 347 bridge->sysdata = hose; 348 bridge->busnr = next_busno; 349 bridge->ops = alpha_mv.pci_ops; 350 bridge->swizzle_irq = alpha_mv.pci_swizzle; 351 bridge->map_irq = alpha_mv.pci_map_irq; 352 353 ret = pci_scan_root_bus_bridge(bridge); 354 if (ret) { 355 pci_free_host_bridge(bridge); 356 continue; 357 } 358 359 bus = hose->bus = bridge->bus; 360 hose->need_domain_info = need_domain_info; 361 next_busno = bus->busn_res.end + 1; 362 /* Don't allow 8-bit bus number overflow inside the hose - 363 reserve some space for bridges. */ 364 if (next_busno > 224) { 365 next_busno = 0; 366 need_domain_info = 1; 367 } 368 } 369 370 pcibios_claim_console_setup(); 371 372 pci_assign_unassigned_resources(); 373 for (hose = hose_head; hose; hose = hose->next) { 374 bus = hose->bus; 375 if (bus) 376 pci_bus_add_devices(bus); 377 } 378 } 379 380 struct pci_controller * __init 381 alloc_pci_controller(void) 382 { 383 struct pci_controller *hose; 384 385 hose = alloc_bootmem(sizeof(*hose)); 386 387 *hose_tail = hose; 388 hose_tail = &hose->next; 389 390 return hose; 391 } 392 393 struct resource * __init 394 alloc_resource(void) 395 { 396 return alloc_bootmem(sizeof(struct resource)); 397 } 398 399 400 /* Provide information on locations of various I/O regions in physical 401 memory. Do this on a per-card basis so that we choose the right hose. */ 402 403 asmlinkage long 404 sys_pciconfig_iobase(long which, unsigned long bus, unsigned long dfn) 405 { 406 struct pci_controller *hose; 407 struct pci_dev *dev; 408 409 /* from hose or from bus.devfn */ 410 if (which & IOBASE_FROM_HOSE) { 411 for(hose = hose_head; hose; hose = hose->next) 412 if (hose->index == bus) break; 413 if (!hose) return -ENODEV; 414 } else { 415 /* Special hook for ISA access. */ 416 if (bus == 0 && dfn == 0) { 417 hose = pci_isa_hose; 418 } else { 419 dev = pci_get_bus_and_slot(bus, dfn); 420 if (!dev) 421 return -ENODEV; 422 hose = dev->sysdata; 423 pci_dev_put(dev); 424 } 425 } 426 427 switch (which & ~IOBASE_FROM_HOSE) { 428 case IOBASE_HOSE: 429 return hose->index; 430 case IOBASE_SPARSE_MEM: 431 return hose->sparse_mem_base; 432 case IOBASE_DENSE_MEM: 433 return hose->dense_mem_base; 434 case IOBASE_SPARSE_IO: 435 return hose->sparse_io_base; 436 case IOBASE_DENSE_IO: 437 return hose->dense_io_base; 438 case IOBASE_ROOT_BUS: 439 return hose->bus->number; 440 } 441 442 return -EOPNOTSUPP; 443 } 444 445 /* Destroy an __iomem token. Not copied from lib/iomap.c. */ 446 447 void pci_iounmap(struct pci_dev *dev, void __iomem * addr) 448 { 449 if (__is_mmio(addr)) 450 iounmap(addr); 451 } 452 453 EXPORT_SYMBOL(pci_iounmap); 454 455 /* FIXME: Some boxes have multiple ISA bridges! */ 456 struct pci_dev *isa_bridge; 457 EXPORT_SYMBOL(isa_bridge); 458