1 /* 2 * drivers/pci/bus.c 3 * 4 * From setup-res.c, by: 5 * Dave Rusling (david.rusling@reo.mts.dec.com) 6 * David Mosberger (davidm@cs.arizona.edu) 7 * David Miller (davem@redhat.com) 8 * Ivan Kokshaysky (ink@jurassic.park.msu.ru) 9 */ 10 #include <linux/module.h> 11 #include <linux/kernel.h> 12 #include <linux/pci.h> 13 #include <linux/errno.h> 14 #include <linux/ioport.h> 15 #include <linux/proc_fs.h> 16 #include <linux/slab.h> 17 18 #include "pci.h" 19 20 void pci_add_resource_offset(struct list_head *resources, struct resource *res, 21 resource_size_t offset) 22 { 23 struct resource_entry *entry; 24 25 entry = resource_list_create_entry(res, 0); 26 if (!entry) { 27 printk(KERN_ERR "PCI: can't add host bridge window %pR\n", res); 28 return; 29 } 30 31 entry->offset = offset; 32 resource_list_add_tail(entry, resources); 33 } 34 EXPORT_SYMBOL(pci_add_resource_offset); 35 36 void pci_add_resource(struct list_head *resources, struct resource *res) 37 { 38 pci_add_resource_offset(resources, res, 0); 39 } 40 EXPORT_SYMBOL(pci_add_resource); 41 42 void pci_free_resource_list(struct list_head *resources) 43 { 44 resource_list_free(resources); 45 } 46 EXPORT_SYMBOL(pci_free_resource_list); 47 48 void pci_bus_add_resource(struct pci_bus *bus, struct resource *res, 49 unsigned int flags) 50 { 51 struct pci_bus_resource *bus_res; 52 53 bus_res = kzalloc(sizeof(struct pci_bus_resource), GFP_KERNEL); 54 if (!bus_res) { 55 dev_err(&bus->dev, "can't add %pR resource\n", res); 56 return; 57 } 58 59 bus_res->res = res; 60 bus_res->flags = flags; 61 list_add_tail(&bus_res->list, &bus->resources); 62 } 63 64 struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n) 65 { 66 struct pci_bus_resource *bus_res; 67 68 if (n < PCI_BRIDGE_RESOURCE_NUM) 69 return bus->resource[n]; 70 71 n -= PCI_BRIDGE_RESOURCE_NUM; 72 list_for_each_entry(bus_res, &bus->resources, list) { 73 if (n-- == 0) 74 return bus_res->res; 75 } 76 return NULL; 77 } 78 EXPORT_SYMBOL_GPL(pci_bus_resource_n); 79 80 void pci_bus_remove_resources(struct pci_bus *bus) 81 { 82 int i; 83 struct pci_bus_resource *bus_res, *tmp; 84 85 for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) 86 bus->resource[i] = NULL; 87 88 list_for_each_entry_safe(bus_res, tmp, &bus->resources, list) { 89 list_del(&bus_res->list); 90 kfree(bus_res); 91 } 92 } 93 94 int devm_request_pci_bus_resources(struct device *dev, 95 struct list_head *resources) 96 { 97 struct resource_entry *win; 98 struct resource *parent, *res; 99 int err; 100 101 resource_list_for_each_entry(win, resources) { 102 res = win->res; 103 switch (resource_type(res)) { 104 case IORESOURCE_IO: 105 parent = &ioport_resource; 106 break; 107 case IORESOURCE_MEM: 108 parent = &iomem_resource; 109 break; 110 default: 111 continue; 112 } 113 114 err = devm_request_resource(dev, parent, res); 115 if (err) 116 return err; 117 } 118 119 return 0; 120 } 121 EXPORT_SYMBOL_GPL(devm_request_pci_bus_resources); 122 123 static struct pci_bus_region pci_32_bit = {0, 0xffffffffULL}; 124 #ifdef CONFIG_PCI_BUS_ADDR_T_64BIT 125 static struct pci_bus_region pci_64_bit = {0, 126 (pci_bus_addr_t) 0xffffffffffffffffULL}; 127 static struct pci_bus_region pci_high = {(pci_bus_addr_t) 0x100000000ULL, 128 (pci_bus_addr_t) 0xffffffffffffffffULL}; 129 #endif 130 131 /* 132 * @res contains CPU addresses. Clip it so the corresponding bus addresses 133 * on @bus are entirely within @region. This is used to control the bus 134 * addresses of resources we allocate, e.g., we may need a resource that 135 * can be mapped by a 32-bit BAR. 136 */ 137 static void pci_clip_resource_to_region(struct pci_bus *bus, 138 struct resource *res, 139 struct pci_bus_region *region) 140 { 141 struct pci_bus_region r; 142 143 pcibios_resource_to_bus(bus, &r, res); 144 if (r.start < region->start) 145 r.start = region->start; 146 if (r.end > region->end) 147 r.end = region->end; 148 149 if (r.end < r.start) 150 res->end = res->start - 1; 151 else 152 pcibios_bus_to_resource(bus, res, &r); 153 } 154 155 static int pci_bus_alloc_from_region(struct pci_bus *bus, struct resource *res, 156 resource_size_t size, resource_size_t align, 157 resource_size_t min, unsigned long type_mask, 158 resource_size_t (*alignf)(void *, 159 const struct resource *, 160 resource_size_t, 161 resource_size_t), 162 void *alignf_data, 163 struct pci_bus_region *region) 164 { 165 int i, ret; 166 struct resource *r, avail; 167 resource_size_t max; 168 169 type_mask |= IORESOURCE_TYPE_BITS; 170 171 pci_bus_for_each_resource(bus, r, i) { 172 resource_size_t min_used = min; 173 174 if (!r) 175 continue; 176 177 /* type_mask must match */ 178 if ((res->flags ^ r->flags) & type_mask) 179 continue; 180 181 /* We cannot allocate a non-prefetching resource 182 from a pre-fetching area */ 183 if ((r->flags & IORESOURCE_PREFETCH) && 184 !(res->flags & IORESOURCE_PREFETCH)) 185 continue; 186 187 avail = *r; 188 pci_clip_resource_to_region(bus, &avail, region); 189 190 /* 191 * "min" is typically PCIBIOS_MIN_IO or PCIBIOS_MIN_MEM to 192 * protect badly documented motherboard resources, but if 193 * this is an already-configured bridge window, its start 194 * overrides "min". 195 */ 196 if (avail.start) 197 min_used = avail.start; 198 199 max = avail.end; 200 201 /* Ok, try it out.. */ 202 ret = allocate_resource(r, res, size, min_used, max, 203 align, alignf, alignf_data); 204 if (ret == 0) 205 return 0; 206 } 207 return -ENOMEM; 208 } 209 210 /** 211 * pci_bus_alloc_resource - allocate a resource from a parent bus 212 * @bus: PCI bus 213 * @res: resource to allocate 214 * @size: size of resource to allocate 215 * @align: alignment of resource to allocate 216 * @min: minimum /proc/iomem address to allocate 217 * @type_mask: IORESOURCE_* type flags 218 * @alignf: resource alignment function 219 * @alignf_data: data argument for resource alignment function 220 * 221 * Given the PCI bus a device resides on, the size, minimum address, 222 * alignment and type, try to find an acceptable resource allocation 223 * for a specific device resource. 224 */ 225 int pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res, 226 resource_size_t size, resource_size_t align, 227 resource_size_t min, unsigned long type_mask, 228 resource_size_t (*alignf)(void *, 229 const struct resource *, 230 resource_size_t, 231 resource_size_t), 232 void *alignf_data) 233 { 234 #ifdef CONFIG_PCI_BUS_ADDR_T_64BIT 235 int rc; 236 237 if (res->flags & IORESOURCE_MEM_64) { 238 rc = pci_bus_alloc_from_region(bus, res, size, align, min, 239 type_mask, alignf, alignf_data, 240 &pci_high); 241 if (rc == 0) 242 return 0; 243 244 return pci_bus_alloc_from_region(bus, res, size, align, min, 245 type_mask, alignf, alignf_data, 246 &pci_64_bit); 247 } 248 #endif 249 250 return pci_bus_alloc_from_region(bus, res, size, align, min, 251 type_mask, alignf, alignf_data, 252 &pci_32_bit); 253 } 254 EXPORT_SYMBOL(pci_bus_alloc_resource); 255 256 /* 257 * The @idx resource of @dev should be a PCI-PCI bridge window. If this 258 * resource fits inside a window of an upstream bridge, do nothing. If it 259 * overlaps an upstream window but extends outside it, clip the resource so 260 * it fits completely inside. 261 */ 262 bool pci_bus_clip_resource(struct pci_dev *dev, int idx) 263 { 264 struct pci_bus *bus = dev->bus; 265 struct resource *res = &dev->resource[idx]; 266 struct resource orig_res = *res; 267 struct resource *r; 268 int i; 269 270 pci_bus_for_each_resource(bus, r, i) { 271 resource_size_t start, end; 272 273 if (!r) 274 continue; 275 276 if (resource_type(res) != resource_type(r)) 277 continue; 278 279 start = max(r->start, res->start); 280 end = min(r->end, res->end); 281 282 if (start > end) 283 continue; /* no overlap */ 284 285 if (res->start == start && res->end == end) 286 return false; /* no change */ 287 288 res->start = start; 289 res->end = end; 290 res->flags &= ~IORESOURCE_UNSET; 291 orig_res.flags &= ~IORESOURCE_UNSET; 292 dev_printk(KERN_DEBUG, &dev->dev, "%pR clipped to %pR\n", 293 &orig_res, res); 294 295 return true; 296 } 297 298 return false; 299 } 300 301 void __weak pcibios_resource_survey_bus(struct pci_bus *bus) { } 302 303 void __weak pcibios_bus_add_device(struct pci_dev *pdev) { } 304 305 /** 306 * pci_bus_add_device - start driver for a single device 307 * @dev: device to add 308 * 309 * This adds add sysfs entries and start device drivers 310 */ 311 void pci_bus_add_device(struct pci_dev *dev) 312 { 313 int retval; 314 315 /* 316 * Can not put in pci_device_add yet because resources 317 * are not assigned yet for some devices. 318 */ 319 pcibios_bus_add_device(dev); 320 pci_fixup_device(pci_fixup_final, dev); 321 pci_create_sysfs_dev_files(dev); 322 pci_proc_attach_device(dev); 323 pci_bridge_d3_update(dev); 324 325 dev->match_driver = true; 326 retval = device_attach(&dev->dev); 327 if (retval < 0 && retval != -EPROBE_DEFER) { 328 dev_warn(&dev->dev, "device attach failed (%d)\n", retval); 329 pci_proc_detach_device(dev); 330 pci_remove_sysfs_dev_files(dev); 331 return; 332 } 333 334 dev->is_added = 1; 335 } 336 EXPORT_SYMBOL_GPL(pci_bus_add_device); 337 338 /** 339 * pci_bus_add_devices - start driver for PCI devices 340 * @bus: bus to check for new devices 341 * 342 * Start driver for PCI devices and add some sysfs entries. 343 */ 344 void pci_bus_add_devices(const struct pci_bus *bus) 345 { 346 struct pci_dev *dev; 347 struct pci_bus *child; 348 349 list_for_each_entry(dev, &bus->devices, bus_list) { 350 /* Skip already-added devices */ 351 if (dev->is_added) 352 continue; 353 pci_bus_add_device(dev); 354 } 355 356 list_for_each_entry(dev, &bus->devices, bus_list) { 357 /* Skip if device attach failed */ 358 if (!dev->is_added) 359 continue; 360 child = dev->subordinate; 361 if (child) 362 pci_bus_add_devices(child); 363 } 364 } 365 EXPORT_SYMBOL(pci_bus_add_devices); 366 367 /** pci_walk_bus - walk devices on/under bus, calling callback. 368 * @top bus whose devices should be walked 369 * @cb callback to be called for each device found 370 * @userdata arbitrary pointer to be passed to callback. 371 * 372 * Walk the given bus, including any bridged devices 373 * on buses under this bus. Call the provided callback 374 * on each device found. 375 * 376 * We check the return of @cb each time. If it returns anything 377 * other than 0, we break out. 378 * 379 */ 380 void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *), 381 void *userdata) 382 { 383 struct pci_dev *dev; 384 struct pci_bus *bus; 385 struct list_head *next; 386 int retval; 387 388 bus = top; 389 down_read(&pci_bus_sem); 390 next = top->devices.next; 391 for (;;) { 392 if (next == &bus->devices) { 393 /* end of this bus, go up or finish */ 394 if (bus == top) 395 break; 396 next = bus->self->bus_list.next; 397 bus = bus->self->bus; 398 continue; 399 } 400 dev = list_entry(next, struct pci_dev, bus_list); 401 if (dev->subordinate) { 402 /* this is a pci-pci bridge, do its devices next */ 403 next = dev->subordinate->devices.next; 404 bus = dev->subordinate; 405 } else 406 next = dev->bus_list.next; 407 408 retval = cb(dev, userdata); 409 if (retval) 410 break; 411 } 412 up_read(&pci_bus_sem); 413 } 414 EXPORT_SYMBOL_GPL(pci_walk_bus); 415 416 struct pci_bus *pci_bus_get(struct pci_bus *bus) 417 { 418 if (bus) 419 get_device(&bus->dev); 420 return bus; 421 } 422 EXPORT_SYMBOL(pci_bus_get); 423 424 void pci_bus_put(struct pci_bus *bus) 425 { 426 if (bus) 427 put_device(&bus->dev); 428 } 429 EXPORT_SYMBOL(pci_bus_put); 430