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/init.h> 17 #include <linux/slab.h> 18 19 #include "pci.h" 20 21 void pci_add_resource_offset(struct list_head *resources, struct resource *res, 22 resource_size_t offset) 23 { 24 struct pci_host_bridge_window *window; 25 26 window = kzalloc(sizeof(struct pci_host_bridge_window), GFP_KERNEL); 27 if (!window) { 28 printk(KERN_ERR "PCI: can't add host bridge window %pR\n", res); 29 return; 30 } 31 32 window->res = res; 33 window->offset = offset; 34 list_add_tail(&window->list, resources); 35 } 36 EXPORT_SYMBOL(pci_add_resource_offset); 37 38 void pci_add_resource(struct list_head *resources, struct resource *res) 39 { 40 pci_add_resource_offset(resources, res, 0); 41 } 42 EXPORT_SYMBOL(pci_add_resource); 43 44 void pci_free_resource_list(struct list_head *resources) 45 { 46 struct pci_host_bridge_window *window, *tmp; 47 48 list_for_each_entry_safe(window, tmp, resources, list) { 49 list_del(&window->list); 50 kfree(window); 51 } 52 } 53 EXPORT_SYMBOL(pci_free_resource_list); 54 55 void pci_bus_add_resource(struct pci_bus *bus, struct resource *res, 56 unsigned int flags) 57 { 58 struct pci_bus_resource *bus_res; 59 60 bus_res = kzalloc(sizeof(struct pci_bus_resource), GFP_KERNEL); 61 if (!bus_res) { 62 dev_err(&bus->dev, "can't add %pR resource\n", res); 63 return; 64 } 65 66 bus_res->res = res; 67 bus_res->flags = flags; 68 list_add_tail(&bus_res->list, &bus->resources); 69 } 70 71 struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n) 72 { 73 struct pci_bus_resource *bus_res; 74 75 if (n < PCI_BRIDGE_RESOURCE_NUM) 76 return bus->resource[n]; 77 78 n -= PCI_BRIDGE_RESOURCE_NUM; 79 list_for_each_entry(bus_res, &bus->resources, list) { 80 if (n-- == 0) 81 return bus_res->res; 82 } 83 return NULL; 84 } 85 EXPORT_SYMBOL_GPL(pci_bus_resource_n); 86 87 void pci_bus_remove_resources(struct pci_bus *bus) 88 { 89 int i; 90 struct pci_bus_resource *bus_res, *tmp; 91 92 for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) 93 bus->resource[i] = NULL; 94 95 list_for_each_entry_safe(bus_res, tmp, &bus->resources, list) { 96 list_del(&bus_res->list); 97 kfree(bus_res); 98 } 99 } 100 101 /** 102 * pci_bus_alloc_resource - allocate a resource from a parent bus 103 * @bus: PCI bus 104 * @res: resource to allocate 105 * @size: size of resource to allocate 106 * @align: alignment of resource to allocate 107 * @min: minimum /proc/iomem address to allocate 108 * @type_mask: IORESOURCE_* type flags 109 * @alignf: resource alignment function 110 * @alignf_data: data argument for resource alignment function 111 * 112 * Given the PCI bus a device resides on, the size, minimum address, 113 * alignment and type, try to find an acceptable resource allocation 114 * for a specific device resource. 115 */ 116 int 117 pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res, 118 resource_size_t size, resource_size_t align, 119 resource_size_t min, unsigned int type_mask, 120 resource_size_t (*alignf)(void *, 121 const struct resource *, 122 resource_size_t, 123 resource_size_t), 124 void *alignf_data) 125 { 126 int i, ret = -ENOMEM; 127 struct resource *r; 128 resource_size_t max = -1; 129 130 type_mask |= IORESOURCE_IO | IORESOURCE_MEM; 131 132 /* don't allocate too high if the pref mem doesn't support 64bit*/ 133 if (!(res->flags & IORESOURCE_MEM_64)) 134 max = PCIBIOS_MAX_MEM_32; 135 136 pci_bus_for_each_resource(bus, r, i) { 137 if (!r) 138 continue; 139 140 /* type_mask must match */ 141 if ((res->flags ^ r->flags) & type_mask) 142 continue; 143 144 /* We cannot allocate a non-prefetching resource 145 from a pre-fetching area */ 146 if ((r->flags & IORESOURCE_PREFETCH) && 147 !(res->flags & IORESOURCE_PREFETCH)) 148 continue; 149 150 /* Ok, try it out.. */ 151 ret = allocate_resource(r, res, size, 152 r->start ? : min, 153 max, align, 154 alignf, alignf_data); 155 if (ret == 0) 156 break; 157 } 158 return ret; 159 } 160 161 void __weak pcibios_resource_survey_bus(struct pci_bus *bus) { } 162 163 /** 164 * pci_bus_add_device - start driver for a single device 165 * @dev: device to add 166 * 167 * This adds add sysfs entries and start device drivers 168 */ 169 int pci_bus_add_device(struct pci_dev *dev) 170 { 171 int retval; 172 173 /* 174 * Can not put in pci_device_add yet because resources 175 * are not assigned yet for some devices. 176 */ 177 pci_fixup_device(pci_fixup_final, dev); 178 pci_create_sysfs_dev_files(dev); 179 180 dev->match_driver = true; 181 retval = device_attach(&dev->dev); 182 WARN_ON(retval < 0); 183 184 dev->is_added = 1; 185 186 return 0; 187 } 188 189 /** 190 * pci_bus_add_devices - start driver for PCI devices 191 * @bus: bus to check for new devices 192 * 193 * Start driver for PCI devices and add some sysfs entries. 194 */ 195 void pci_bus_add_devices(const struct pci_bus *bus) 196 { 197 struct pci_dev *dev; 198 struct pci_bus *child; 199 int retval; 200 201 list_for_each_entry(dev, &bus->devices, bus_list) { 202 /* Skip already-added devices */ 203 if (dev->is_added) 204 continue; 205 retval = pci_bus_add_device(dev); 206 if (retval) 207 dev_err(&dev->dev, "Error adding device (%d)\n", 208 retval); 209 } 210 211 list_for_each_entry(dev, &bus->devices, bus_list) { 212 BUG_ON(!dev->is_added); 213 child = dev->subordinate; 214 if (child) 215 pci_bus_add_devices(child); 216 } 217 } 218 219 void pci_enable_bridges(struct pci_bus *bus) 220 { 221 struct pci_dev *dev; 222 int retval; 223 224 list_for_each_entry(dev, &bus->devices, bus_list) { 225 if (dev->subordinate) { 226 if (!pci_is_enabled(dev)) { 227 retval = pci_enable_device(dev); 228 if (retval) 229 dev_err(&dev->dev, "Error enabling bridge (%d), continuing\n", retval); 230 pci_set_master(dev); 231 } 232 pci_enable_bridges(dev->subordinate); 233 } 234 } 235 } 236 237 /** pci_walk_bus - walk devices on/under bus, calling callback. 238 * @top bus whose devices should be walked 239 * @cb callback to be called for each device found 240 * @userdata arbitrary pointer to be passed to callback. 241 * 242 * Walk the given bus, including any bridged devices 243 * on buses under this bus. Call the provided callback 244 * on each device found. 245 * 246 * We check the return of @cb each time. If it returns anything 247 * other than 0, we break out. 248 * 249 */ 250 void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *), 251 void *userdata) 252 { 253 struct pci_dev *dev; 254 struct pci_bus *bus; 255 struct list_head *next; 256 int retval; 257 258 bus = top; 259 down_read(&pci_bus_sem); 260 next = top->devices.next; 261 for (;;) { 262 if (next == &bus->devices) { 263 /* end of this bus, go up or finish */ 264 if (bus == top) 265 break; 266 next = bus->self->bus_list.next; 267 bus = bus->self->bus; 268 continue; 269 } 270 dev = list_entry(next, struct pci_dev, bus_list); 271 if (dev->subordinate) { 272 /* this is a pci-pci bridge, do its devices next */ 273 next = dev->subordinate->devices.next; 274 bus = dev->subordinate; 275 } else 276 next = dev->bus_list.next; 277 278 retval = cb(dev, userdata); 279 if (retval) 280 break; 281 } 282 up_read(&pci_bus_sem); 283 } 284 EXPORT_SYMBOL_GPL(pci_walk_bus); 285 286 EXPORT_SYMBOL(pci_bus_alloc_resource); 287 EXPORT_SYMBOL_GPL(pci_bus_add_device); 288 EXPORT_SYMBOL(pci_bus_add_devices); 289 EXPORT_SYMBOL(pci_enable_bridges); 290