drivers/pci/bus.c

   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_bus_add_resource(struct pci_bus *bus, struct resource *res,
  22                           unsigned int flags)
  23 {
  24         struct pci_bus_resource *bus_res;
  25
  26         bus_res = kzalloc(sizeof(struct pci_bus_resource), GFP_KERNEL);
  27         if (!bus_res) {
  28                 dev_err(&bus->dev, "can't add %pR resource\n", res);
  29                 return;
  30         }
  31
  32         bus_res->res = res;
  33         bus_res->flags = flags;
  34         list_add_tail(&bus_res->list, &bus->resources);
  35 }
  36
  37 struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n)
  38 {
  39         struct pci_bus_resource *bus_res;
  40
  41         if (n < PCI_BRIDGE_RESOURCE_NUM)
  42                 return bus->resource[n];
  43
  44         n -= PCI_BRIDGE_RESOURCE_NUM;
  45         list_for_each_entry(bus_res, &bus->resources, list) {
  46                 if (n-- == 0)
  47                         return bus_res->res;
  48         }
  49         return NULL;
  50 }
  51 EXPORT_SYMBOL_GPL(pci_bus_resource_n);
  52
  53 void pci_bus_remove_resources(struct pci_bus *bus)
  54 {
  55         struct pci_bus_resource *bus_res, *tmp;
  56         int i;
  57
  58         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
  59                 bus->resource[i] = NULL;
  60
  61         list_for_each_entry_safe(bus_res, tmp, &bus->resources, list) {
  62                 list_del(&bus_res->list);
  63                 kfree(bus_res);
  64         }
  65 }
  66
  67 /*
  68  * Find the highest-address bus resource below the cursor "res".  If the
  69  * cursor is NULL, return the highest resource.
  70  */
  71 static struct resource *pci_bus_find_resource_prev(struct pci_bus *bus,
  72                                                    unsigned int type,
  73                                                    struct resource *res)
  74 {
  75         struct resource *r, *prev = NULL;
  76         int i;
  77
  78         pci_bus_for_each_resource(bus, r, i) {
  79                 if (!r)
  80                         continue;
  81
  82                 if ((r->flags & IORESOURCE_TYPE_BITS) != type)
  83                         continue;
  84
  85                 /* If this resource is at or past the cursor, skip it */
  86                 if (res) {
  87                         if (r == res)
  88                                 continue;
  89                         if (r->end > res->end)
  90                                 continue;
  91                         if (r->end == res->end && r->start > res->start)
  92                                 continue;
  93                 }
  94
  95                 if (!prev)
  96                         prev = r;
  97
  98                 /*
  99                  * A small resource is higher than a large one that ends at
 100                  * the same address.
 101                  */
 102                 if (r->end > prev->end ||
 103                     (r->end == prev->end && r->start > prev->start))
 104                         prev = r;
 105         }
 106
 107         return prev;
 108 }
 109
 110 /**
 111  * pci_bus_alloc_resource - allocate a resource from a parent bus
 112  * @bus: PCI bus
 113  * @res: resource to allocate
 114  * @size: size of resource to allocate
 115  * @align: alignment of resource to allocate
 116  * @min: minimum /proc/iomem address to allocate
 117  * @type_mask: IORESOURCE_* type flags
 118  * @alignf: resource alignment function
 119  * @alignf_data: data argument for resource alignment function
 120  *
 121  * Given the PCI bus a device resides on, the size, minimum address,
 122  * alignment and type, try to find an acceptable resource allocation
 123  * for a specific device resource.
 124  */
 125 int
 126 pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res,
 127                 resource_size_t size, resource_size_t align,
 128                 resource_size_t min, unsigned int type_mask,
 129                 resource_size_t (*alignf)(void *,
 130                                           const struct resource *,
 131                                           resource_size_t,
 132                                           resource_size_t),
 133                 void *alignf_data)
 134 {
 135         int ret = -ENOMEM;
 136         struct resource *r;
 137         resource_size_t max = -1;
 138         unsigned int type = res->flags & IORESOURCE_TYPE_BITS;
 139
 140         type_mask |= IORESOURCE_IO | IORESOURCE_MEM;
 141
 142         /* don't allocate too high if the pref mem doesn't support 64bit*/
 143         if (!(res->flags & IORESOURCE_MEM_64))
 144                 max = PCIBIOS_MAX_MEM_32;
 145
 146         /* Look for space at highest addresses first */
 147         r = pci_bus_find_resource_prev(bus, type, NULL);
 148         for ( ; r; r = pci_bus_find_resource_prev(bus, type, r)) {
 149                 /* type_mask must match */
 150                 if ((res->flags ^ r->flags) & type_mask)
 151                         continue;
 152
 153                 /* We cannot allocate a non-prefetching resource
 154                    from a pre-fetching area */
 155                 if ((r->flags & IORESOURCE_PREFETCH) &&
 156                     !(res->flags & IORESOURCE_PREFETCH))
 157                         continue;
 158
 159                 /* Ok, try it out.. */
 160                 ret = allocate_resource(r, res, size,
 161                                         r->start ? : min,
 162                                         max, align,
 163                                         alignf, alignf_data);
 164                 if (ret == 0)
 165                         break;
 166         }
 167         return ret;
 168 }
 169
 170 /**
 171  * pci_bus_add_device - add a single device
 172  * @dev: device to add
 173  *
 174  * This adds a single pci device to the global
 175  * device list and adds sysfs and procfs entries
 176  */
 177 int pci_bus_add_device(struct pci_dev *dev)
 178 {
 179         int retval;
 180         retval = device_add(&dev->dev);
 181         if (retval)
 182                 return retval;
 183
 184         dev->is_added = 1;
 185         pci_proc_attach_device(dev);
 186         pci_create_sysfs_dev_files(dev);
 187         return 0;
 188 }
 189
 190 /**
 191  * pci_bus_add_child - add a child bus
 192  * @bus: bus to add
 193  *
 194  * This adds sysfs entries for a single bus
 195  */
 196 int pci_bus_add_child(struct pci_bus *bus)
 197 {
 198         int retval;
 199
 200         if (bus->bridge)
 201                 bus->dev.parent = bus->bridge;
 202
 203         retval = device_register(&bus->dev);
 204         if (retval)
 205                 return retval;
 206
 207         bus->is_added = 1;
 208
 209         retval = device_create_file(&bus->dev, &dev_attr_cpuaffinity);
 210         if (retval)
 211                 return retval;
 212
 213         retval = device_create_file(&bus->dev, &dev_attr_cpulistaffinity);
 214
 215         /* Create legacy_io and legacy_mem files for this bus */
 216         pci_create_legacy_files(bus);
 217
 218         return retval;
 219 }
 220
 221 /**
 222  * pci_bus_add_devices - insert newly discovered PCI devices
 223  * @bus: bus to check for new devices
 224  *
 225  * Add newly discovered PCI devices (which are on the bus->devices
 226  * list) to the global PCI device list, add the sysfs and procfs
 227  * entries.  Where a bridge is found, add the discovered bus to
 228  * the parents list of child buses, and recurse (breadth-first
 229  * to be compatible with 2.4)
 230  *
 231  * Call hotplug for each new devices.
 232  */
 233 void pci_bus_add_devices(const struct pci_bus *bus)
 234 {
 235         struct pci_dev *dev;
 236         struct pci_bus *child;
 237         int retval;
 238
 239         list_for_each_entry(dev, &bus->devices, bus_list) {
 240                 /* Skip already-added devices */
 241                 if (dev->is_added)
 242                         continue;
 243                 retval = pci_bus_add_device(dev);
 244                 if (retval)
 245                         dev_err(&dev->dev, "Error adding device, continuing\n");
 246         }
 247
 248         list_for_each_entry(dev, &bus->devices, bus_list) {
 249                 BUG_ON(!dev->is_added);
 250
 251                 child = dev->subordinate;
 252                 /*
 253                  * If there is an unattached subordinate bus, attach
 254                  * it and then scan for unattached PCI devices.
 255                  */
 256                 if (!child)
 257                         continue;
 258                 if (list_empty(&child->node)) {
 259                         down_write(&pci_bus_sem);
 260                         list_add_tail(&child->node, &dev->bus->children);
 261                         up_write(&pci_bus_sem);
 262                 }
 263                 pci_bus_add_devices(child);
 264
 265                 /*
 266                  * register the bus with sysfs as the parent is now
 267                  * properly registered.
 268                  */
 269                 if (child->is_added)
 270                         continue;
 271                 retval = pci_bus_add_child(child);
 272                 if (retval)
 273                         dev_err(&dev->dev, "Error adding bus, continuing\n");
 274         }
 275 }
 276
 277 void pci_enable_bridges(struct pci_bus *bus)
 278 {
 279         struct pci_dev *dev;
 280         int retval;
 281
 282         list_for_each_entry(dev, &bus->devices, bus_list) {
 283                 if (dev->subordinate) {
 284                         if (!pci_is_enabled(dev)) {
 285                                 retval = pci_enable_device(dev);
 286                                 if (retval)
 287                                         dev_err(&dev->dev, "Error enabling bridge (%d), continuing\n", retval);
 288                                 pci_set_master(dev);
 289                         }
 290                         pci_enable_bridges(dev->subordinate);
 291                 }
 292         }
 293 }
 294
 295 /** pci_walk_bus - walk devices on/under bus, calling callback.
 296  *  @top      bus whose devices should be walked
 297  *  @cb       callback to be called for each device found
 298  *  @userdata arbitrary pointer to be passed to callback.
 299  *
 300  *  Walk the given bus, including any bridged devices
 301  *  on buses under this bus.  Call the provided callback
 302  *  on each device found.
 303  *
 304  *  We check the return of @cb each time. If it returns anything
 305  *  other than 0, we break out.
 306  *
 307  */
 308 void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *),
 309                   void *userdata)
 310 {
 311         struct pci_dev *dev;
 312         struct pci_bus *bus;
 313         struct list_head *next;
 314         int retval;
 315
 316         bus = top;
 317         down_read(&pci_bus_sem);
 318         next = top->devices.next;
 319         for (;;) {
 320                 if (next == &bus->devices) {
 321                         /* end of this bus, go up or finish */
 322                         if (bus == top)
 323                                 break;
 324                         next = bus->self->bus_list.next;
 325                         bus = bus->self->bus;
 326                         continue;
 327                 }
 328                 dev = list_entry(next, struct pci_dev, bus_list);
 329                 if (dev->subordinate) {
 330                         /* this is a pci-pci bridge, do its devices next */
 331                         next = dev->subordinate->devices.next;
 332                         bus = dev->subordinate;
 333                 } else
 334                         next = dev->bus_list.next;
 335
 336                 /* Run device routines with the device locked */
 337                 device_lock(&dev->dev);
 338                 retval = cb(dev, userdata);
 339                 device_unlock(&dev->dev);
 340                 if (retval)
 341                         break;
 342         }
 343         up_read(&pci_bus_sem);
 344 }
 345 EXPORT_SYMBOL_GPL(pci_walk_bus);
 346
 347 EXPORT_SYMBOL(pci_bus_alloc_resource);
 348 EXPORT_SYMBOL_GPL(pci_bus_add_device);
 349 EXPORT_SYMBOL(pci_bus_add_devices);
 350 EXPORT_SYMBOL(pci_enable_bridges);