Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * This program is free software; you can redistribute it and/or modify it |
| 3 | * under the terms of the GNU General Public License as published by the |
| 4 | * Free Software Foundation; either version 2 of the License, or (at your |
| 5 | * option) any later version. |
| 6 | * |
| 7 | * Copyright (C) 2003, 04 Ralf Baechle (ralf@linux-mips.org) |
| 8 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 9 | #include <linux/kernel.h> |
| 10 | #include <linux/mm.h> |
| 11 | #include <linux/bootmem.h> |
| 12 | #include <linux/init.h> |
| 13 | #include <linux/types.h> |
| 14 | #include <linux/pci.h> |
| 15 | |
| 16 | /* |
| 17 | * Indicate whether we respect the PCI setup left by the firmware. |
| 18 | * |
| 19 | * Make this long-lived so that we know when shutting down |
| 20 | * whether we probed only or not. |
| 21 | */ |
| 22 | int pci_probe_only; |
| 23 | |
| 24 | #define PCI_ASSIGN_ALL_BUSSES 1 |
| 25 | |
| 26 | unsigned int pci_probe = PCI_ASSIGN_ALL_BUSSES; |
| 27 | |
| 28 | /* |
| 29 | * The PCI controller list. |
| 30 | */ |
| 31 | |
| 32 | struct pci_controller *hose_head, **hose_tail = &hose_head; |
| 33 | struct pci_controller *pci_isa_hose; |
| 34 | |
| 35 | unsigned long PCIBIOS_MIN_IO = 0x0000; |
| 36 | unsigned long PCIBIOS_MIN_MEM = 0; |
| 37 | |
| 38 | /* |
| 39 | * We need to avoid collisions with `mirrored' VGA ports |
| 40 | * and other strange ISA hardware, so we always want the |
| 41 | * addresses to be allocated in the 0x000-0x0ff region |
| 42 | * modulo 0x400. |
| 43 | * |
| 44 | * Why? Because some silly external IO cards only decode |
| 45 | * the low 10 bits of the IO address. The 0x00-0xff region |
| 46 | * is reserved for motherboard devices that decode all 16 |
| 47 | * bits, so it's ok to allocate at, say, 0x2800-0x28ff, |
| 48 | * but we want to try to avoid allocating at 0x2900-0x2bff |
| 49 | * which might have be mirrored at 0x0100-0x03ff.. |
| 50 | */ |
| 51 | void |
| 52 | pcibios_align_resource(void *data, struct resource *res, |
Greg Kroah-Hartman | e31dd6e | 2006-06-12 17:06:02 -0700 | [diff] [blame] | 53 | resource_size_t size, resource_size_t align) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | { |
| 55 | struct pci_dev *dev = data; |
| 56 | struct pci_controller *hose = dev->sysdata; |
Greg Kroah-Hartman | e31dd6e | 2006-06-12 17:06:02 -0700 | [diff] [blame] | 57 | resource_size_t start = res->start; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | |
| 59 | if (res->flags & IORESOURCE_IO) { |
| 60 | /* Make sure we start at our min on all hoses */ |
| 61 | if (start < PCIBIOS_MIN_IO + hose->io_resource->start) |
| 62 | start = PCIBIOS_MIN_IO + hose->io_resource->start; |
| 63 | |
| 64 | /* |
| 65 | * Put everything into 0x00-0xff region modulo 0x400 |
| 66 | */ |
| 67 | if (start & 0x300) |
| 68 | start = (start + 0x3ff) & ~0x3ff; |
| 69 | } else if (res->flags & IORESOURCE_MEM) { |
| 70 | /* Make sure we start at our min on all hoses */ |
| 71 | if (start < PCIBIOS_MIN_MEM + hose->mem_resource->start) |
| 72 | start = PCIBIOS_MIN_MEM + hose->mem_resource->start; |
| 73 | } |
| 74 | |
| 75 | res->start = start; |
| 76 | } |
| 77 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | void __init register_pci_controller(struct pci_controller *hose) |
| 79 | { |
Thomas Bogendoerfer | 639702b | 2007-04-08 13:28:44 +0200 | [diff] [blame^] | 80 | if (request_resource(&iomem_resource, hose->mem_resource) < 0) |
| 81 | goto out; |
| 82 | if (request_resource(&ioport_resource, hose->io_resource) < 0) { |
| 83 | release_resource(hose->mem_resource); |
| 84 | goto out; |
| 85 | } |
| 86 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | *hose_tail = hose; |
| 88 | hose_tail = &hose->next; |
Ralf Baechle | 140c172 | 2006-12-07 15:35:43 +0100 | [diff] [blame] | 89 | |
| 90 | /* |
| 91 | * Do not panic here but later - this might hapen before console init. |
| 92 | */ |
| 93 | if (!hose->io_map_base) { |
| 94 | printk(KERN_WARNING |
| 95 | "registering PCI controller with io_map_base unset\n"); |
| 96 | } |
Thomas Bogendoerfer | 639702b | 2007-04-08 13:28:44 +0200 | [diff] [blame^] | 97 | return; |
| 98 | |
| 99 | out: |
| 100 | printk(KERN_WARNING |
| 101 | "Skipping PCI bus scan due to resource conflict\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | } |
| 103 | |
| 104 | /* Most MIPS systems have straight-forward swizzling needs. */ |
| 105 | |
| 106 | static inline u8 bridge_swizzle(u8 pin, u8 slot) |
| 107 | { |
| 108 | return (((pin - 1) + slot) % 4) + 1; |
| 109 | } |
| 110 | |
| 111 | static u8 __init common_swizzle(struct pci_dev *dev, u8 *pinp) |
| 112 | { |
| 113 | u8 pin = *pinp; |
| 114 | |
| 115 | while (dev->bus->parent) { |
| 116 | pin = bridge_swizzle(pin, PCI_SLOT(dev->devfn)); |
| 117 | /* Move up the chain of bridges. */ |
| 118 | dev = dev->bus->self; |
| 119 | } |
| 120 | *pinp = pin; |
| 121 | |
| 122 | /* The slot is the slot of the last bridge. */ |
| 123 | return PCI_SLOT(dev->devfn); |
| 124 | } |
| 125 | |
| 126 | static int __init pcibios_init(void) |
| 127 | { |
| 128 | struct pci_controller *hose; |
| 129 | struct pci_bus *bus; |
| 130 | int next_busno; |
| 131 | int need_domain_info = 0; |
| 132 | |
| 133 | /* Scan all of the recorded PCI controllers. */ |
| 134 | for (next_busno = 0, hose = hose_head; hose; hose = hose->next) { |
| 135 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | if (!hose->iommu) |
| 137 | PCI_DMA_BUS_IS_PHYS = 1; |
| 138 | |
Andrew Isaacson | 8a1417d | 2005-10-19 23:59:11 -0700 | [diff] [blame] | 139 | if (hose->get_busno && pci_probe_only) |
| 140 | next_busno = (*hose->get_busno)(); |
| 141 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | bus = pci_scan_bus(next_busno, hose->pci_ops, hose); |
| 143 | hose->bus = bus; |
| 144 | hose->need_domain_info = need_domain_info; |
Andrew Isaacson | 8a1417d | 2005-10-19 23:59:11 -0700 | [diff] [blame] | 145 | if (bus) { |
| 146 | next_busno = bus->subordinate + 1; |
| 147 | /* Don't allow 8-bit bus number overflow inside the hose - |
| 148 | reserve some space for bridges. */ |
| 149 | if (next_busno > 224) { |
| 150 | next_busno = 0; |
| 151 | need_domain_info = 1; |
| 152 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | if (!pci_probe_only) |
| 157 | pci_assign_unassigned_resources(); |
| 158 | pci_fixup_irqs(common_swizzle, pcibios_map_irq); |
| 159 | |
| 160 | return 0; |
| 161 | } |
| 162 | |
| 163 | subsys_initcall(pcibios_init); |
| 164 | |
| 165 | static int pcibios_enable_resources(struct pci_dev *dev, int mask) |
| 166 | { |
| 167 | u16 cmd, old_cmd; |
| 168 | int idx; |
| 169 | struct resource *r; |
| 170 | |
| 171 | pci_read_config_word(dev, PCI_COMMAND, &cmd); |
| 172 | old_cmd = cmd; |
Ralf Baechle | e5de3b4 | 2005-07-12 09:18:53 +0000 | [diff] [blame] | 173 | for (idx=0; idx < PCI_NUM_RESOURCES; idx++) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | /* Only set up the requested stuff */ |
| 175 | if (!(mask & (1<<idx))) |
| 176 | continue; |
| 177 | |
| 178 | r = &dev->resource[idx]; |
| 179 | if (!r->start && r->end) { |
| 180 | printk(KERN_ERR "PCI: Device %s not available because of resource collisions\n", pci_name(dev)); |
| 181 | return -EINVAL; |
| 182 | } |
| 183 | if (r->flags & IORESOURCE_IO) |
| 184 | cmd |= PCI_COMMAND_IO; |
| 185 | if (r->flags & IORESOURCE_MEM) |
| 186 | cmd |= PCI_COMMAND_MEMORY; |
| 187 | } |
| 188 | if (dev->resource[PCI_ROM_RESOURCE].start) |
| 189 | cmd |= PCI_COMMAND_MEMORY; |
| 190 | if (cmd != old_cmd) { |
| 191 | printk("PCI: Enabling device %s (%04x -> %04x)\n", pci_name(dev), old_cmd, cmd); |
| 192 | pci_write_config_word(dev, PCI_COMMAND, cmd); |
| 193 | } |
| 194 | return 0; |
| 195 | } |
| 196 | |
| 197 | /* |
| 198 | * If we set up a device for bus mastering, we need to check the latency |
| 199 | * timer as certain crappy BIOSes forget to set it properly. |
| 200 | */ |
| 201 | unsigned int pcibios_max_latency = 255; |
| 202 | |
| 203 | void pcibios_set_master(struct pci_dev *dev) |
| 204 | { |
| 205 | u8 lat; |
| 206 | pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat); |
| 207 | if (lat < 16) |
| 208 | lat = (64 <= pcibios_max_latency) ? 64 : pcibios_max_latency; |
| 209 | else if (lat > pcibios_max_latency) |
| 210 | lat = pcibios_max_latency; |
| 211 | else |
| 212 | return; |
| 213 | printk(KERN_DEBUG "PCI: Setting latency timer of device %s to %d\n", |
| 214 | pci_name(dev), lat); |
| 215 | pci_write_config_byte(dev, PCI_LATENCY_TIMER, lat); |
| 216 | } |
| 217 | |
| 218 | unsigned int pcibios_assign_all_busses(void) |
| 219 | { |
| 220 | return (pci_probe & PCI_ASSIGN_ALL_BUSSES) ? 1 : 0; |
| 221 | } |
| 222 | |
| 223 | int pcibios_enable_device(struct pci_dev *dev, int mask) |
| 224 | { |
| 225 | int err; |
| 226 | |
| 227 | if ((err = pcibios_enable_resources(dev, mask)) < 0) |
| 228 | return err; |
| 229 | |
| 230 | return pcibios_plat_dev_init(dev); |
| 231 | } |
| 232 | |
Atsushi Nemoto | 4419708 | 2007-02-23 01:13:17 +0900 | [diff] [blame] | 233 | static void __devinit pcibios_fixup_device_resources(struct pci_dev *dev, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | struct pci_bus *bus) |
| 235 | { |
| 236 | /* Update device resources. */ |
| 237 | struct pci_controller *hose = (struct pci_controller *)bus->sysdata; |
| 238 | unsigned long offset = 0; |
| 239 | int i; |
| 240 | |
| 241 | for (i = 0; i < PCI_NUM_RESOURCES; i++) { |
| 242 | if (!dev->resource[i].start) |
| 243 | continue; |
| 244 | if (dev->resource[i].flags & IORESOURCE_IO) |
| 245 | offset = hose->io_offset; |
| 246 | else if (dev->resource[i].flags & IORESOURCE_MEM) |
| 247 | offset = hose->mem_offset; |
| 248 | |
| 249 | dev->resource[i].start += offset; |
| 250 | dev->resource[i].end += offset; |
| 251 | } |
| 252 | } |
| 253 | |
| 254 | void __devinit pcibios_fixup_bus(struct pci_bus *bus) |
| 255 | { |
| 256 | /* Propagate hose info into the subordinate devices. */ |
| 257 | |
| 258 | struct pci_controller *hose = bus->sysdata; |
| 259 | struct list_head *ln; |
| 260 | struct pci_dev *dev = bus->self; |
| 261 | |
| 262 | if (!dev) { |
| 263 | bus->resource[0] = hose->io_resource; |
| 264 | bus->resource[1] = hose->mem_resource; |
| 265 | } else if (pci_probe_only && |
| 266 | (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) { |
| 267 | pci_read_bridge_bases(bus); |
| 268 | pcibios_fixup_device_resources(dev, bus); |
Ralf Baechle | 42a3b4f | 2005-09-03 15:56:17 -0700 | [diff] [blame] | 269 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | |
| 271 | for (ln = bus->devices.next; ln != &bus->devices; ln = ln->next) { |
| 272 | struct pci_dev *dev = pci_dev_b(ln); |
| 273 | |
| 274 | if ((dev->class >> 8) != PCI_CLASS_BRIDGE_PCI) |
| 275 | pcibios_fixup_device_resources(dev, bus); |
| 276 | } |
| 277 | } |
| 278 | |
| 279 | void __init |
| 280 | pcibios_update_irq(struct pci_dev *dev, int irq) |
| 281 | { |
| 282 | pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq); |
| 283 | } |
| 284 | |
| 285 | void __devinit |
| 286 | pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region, |
| 287 | struct resource *res) |
| 288 | { |
| 289 | struct pci_controller *hose = (struct pci_controller *)dev->sysdata; |
| 290 | unsigned long offset = 0; |
| 291 | |
| 292 | if (res->flags & IORESOURCE_IO) |
| 293 | offset = hose->io_offset; |
| 294 | else if (res->flags & IORESOURCE_MEM) |
| 295 | offset = hose->mem_offset; |
| 296 | |
| 297 | region->start = res->start - offset; |
| 298 | region->end = res->end - offset; |
| 299 | } |
| 300 | |
Yoichi Yuasa | e63ea56 | 2005-09-03 15:56:20 -0700 | [diff] [blame] | 301 | void __devinit |
| 302 | pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res, |
| 303 | struct pci_bus_region *region) |
| 304 | { |
| 305 | struct pci_controller *hose = (struct pci_controller *)dev->sysdata; |
| 306 | unsigned long offset = 0; |
| 307 | |
| 308 | if (res->flags & IORESOURCE_IO) |
| 309 | offset = hose->io_offset; |
| 310 | else if (res->flags & IORESOURCE_MEM) |
| 311 | offset = hose->mem_offset; |
| 312 | |
| 313 | res->start = region->start + offset; |
| 314 | res->end = region->end + offset; |
| 315 | } |
| 316 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | #ifdef CONFIG_HOTPLUG |
| 318 | EXPORT_SYMBOL(pcibios_resource_to_bus); |
Yoichi Yuasa | e63ea56 | 2005-09-03 15:56:20 -0700 | [diff] [blame] | 319 | EXPORT_SYMBOL(pcibios_bus_to_resource); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | EXPORT_SYMBOL(PCIBIOS_MIN_IO); |
| 321 | EXPORT_SYMBOL(PCIBIOS_MIN_MEM); |
| 322 | #endif |
| 323 | |
| 324 | char *pcibios_setup(char *str) |
| 325 | { |
| 326 | return str; |
| 327 | } |