linux/drivers/pci/search.c
<<
>>
Prefs
   1/*
   2 *      PCI searching functions.
   3 *
   4 *      Copyright (C) 1993 -- 1997 Drew Eckhardt, Frederic Potter,
   5 *                                      David Mosberger-Tang
   6 *      Copyright (C) 1997 -- 2000 Martin Mares <mj@ucw.cz>
   7 *      Copyright (C) 2003 -- 2004 Greg Kroah-Hartman <greg@kroah.com>
   8 */
   9
  10#include <linux/init.h>
  11#include <linux/pci.h>
  12#include <linux/slab.h>
  13#include <linux/module.h>
  14#include <linux/interrupt.h>
  15#include "pci.h"
  16
  17DECLARE_RWSEM(pci_bus_sem);
  18/*
  19 * find the upstream PCIe-to-PCI bridge of a PCI device
  20 * if the device is PCIE, return NULL
  21 * if the device isn't connected to a PCIe bridge (that is its parent is a
  22 * legacy PCI bridge and the bridge is directly connected to bus 0), return its
  23 * parent
  24 */
  25struct pci_dev *
  26pci_find_upstream_pcie_bridge(struct pci_dev *pdev)
  27{
  28        struct pci_dev *tmp = NULL;
  29
  30        if (pci_is_pcie(pdev))
  31                return NULL;
  32        while (1) {
  33                if (pci_is_root_bus(pdev->bus))
  34                        break;
  35                pdev = pdev->bus->self;
  36                /* a p2p bridge */
  37                if (!pci_is_pcie(pdev)) {
  38                        tmp = pdev;
  39                        continue;
  40                }
  41                /* PCI device should connect to a PCIe bridge */
  42                if (pdev->pcie_type != PCI_EXP_TYPE_PCI_BRIDGE) {
  43                        /* Busted hardware? */
  44                        WARN_ON_ONCE(1);
  45                        return NULL;
  46                }
  47                return pdev;
  48        }
  49
  50        return tmp;
  51}
  52
  53static struct pci_bus *pci_do_find_bus(struct pci_bus *bus, unsigned char busnr)
  54{
  55        struct pci_bus* child;
  56        struct list_head *tmp;
  57
  58        if(bus->number == busnr)
  59                return bus;
  60
  61        list_for_each(tmp, &bus->children) {
  62                child = pci_do_find_bus(pci_bus_b(tmp), busnr);
  63                if(child)
  64                        return child;
  65        }
  66        return NULL;
  67}
  68
  69/**
  70 * pci_find_bus - locate PCI bus from a given domain and bus number
  71 * @domain: number of PCI domain to search
  72 * @busnr: number of desired PCI bus
  73 *
  74 * Given a PCI bus number and domain number, the desired PCI bus is located
  75 * in the global list of PCI buses.  If the bus is found, a pointer to its
  76 * data structure is returned.  If no bus is found, %NULL is returned.
  77 */
  78struct pci_bus * pci_find_bus(int domain, int busnr)
  79{
  80        struct pci_bus *bus = NULL;
  81        struct pci_bus *tmp_bus;
  82
  83        while ((bus = pci_find_next_bus(bus)) != NULL)  {
  84                if (pci_domain_nr(bus) != domain)
  85                        continue;
  86                tmp_bus = pci_do_find_bus(bus, busnr);
  87                if (tmp_bus)
  88                        return tmp_bus;
  89        }
  90        return NULL;
  91}
  92
  93/**
  94 * pci_find_next_bus - begin or continue searching for a PCI bus
  95 * @from: Previous PCI bus found, or %NULL for new search.
  96 *
  97 * Iterates through the list of known PCI busses.  A new search is
  98 * initiated by passing %NULL as the @from argument.  Otherwise if
  99 * @from is not %NULL, searches continue from next device on the
 100 * global list.
 101 */
 102struct pci_bus * 
 103pci_find_next_bus(const struct pci_bus *from)
 104{
 105        struct list_head *n;
 106        struct pci_bus *b = NULL;
 107
 108        WARN_ON(in_interrupt());
 109        down_read(&pci_bus_sem);
 110        n = from ? from->node.next : pci_root_buses.next;
 111        if (n != &pci_root_buses)
 112                b = pci_bus_b(n);
 113        up_read(&pci_bus_sem);
 114        return b;
 115}
 116
 117/**
 118 * pci_get_slot - locate PCI device for a given PCI slot
 119 * @bus: PCI bus on which desired PCI device resides
 120 * @devfn: encodes number of PCI slot in which the desired PCI 
 121 * device resides and the logical device number within that slot 
 122 * in case of multi-function devices.
 123 *
 124 * Given a PCI bus and slot/function number, the desired PCI device 
 125 * is located in the list of PCI devices.
 126 * If the device is found, its reference count is increased and this
 127 * function returns a pointer to its data structure.  The caller must
 128 * decrement the reference count by calling pci_dev_put().
 129 * If no device is found, %NULL is returned.
 130 */
 131struct pci_dev * pci_get_slot(struct pci_bus *bus, unsigned int devfn)
 132{
 133        struct list_head *tmp;
 134        struct pci_dev *dev;
 135
 136        WARN_ON(in_interrupt());
 137        down_read(&pci_bus_sem);
 138
 139        list_for_each(tmp, &bus->devices) {
 140                dev = pci_dev_b(tmp);
 141                if (dev->devfn == devfn)
 142                        goto out;
 143        }
 144
 145        dev = NULL;
 146 out:
 147        pci_dev_get(dev);
 148        up_read(&pci_bus_sem);
 149        return dev;
 150}
 151
 152/**
 153 * pci_get_domain_bus_and_slot - locate PCI device for a given PCI domain (segment), bus, and slot
 154 * @domain: PCI domain/segment on which the PCI device resides.
 155 * @bus: PCI bus on which desired PCI device resides
 156 * @devfn: encodes number of PCI slot in which the desired PCI device
 157 * resides and the logical device number within that slot in case of
 158 * multi-function devices.
 159 *
 160 * Given a PCI domain, bus, and slot/function number, the desired PCI
 161 * device is located in the list of PCI devices. If the device is
 162 * found, its reference count is increased and this function returns a
 163 * pointer to its data structure.  The caller must decrement the
 164 * reference count by calling pci_dev_put().  If no device is found,
 165 * %NULL is returned.
 166 */
 167struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus,
 168                                            unsigned int devfn)
 169{
 170        struct pci_dev *dev = NULL;
 171
 172        for_each_pci_dev(dev) {
 173                if (pci_domain_nr(dev->bus) == domain &&
 174                    (dev->bus->number == bus && dev->devfn == devfn))
 175                        return dev;
 176        }
 177        return NULL;
 178}
 179EXPORT_SYMBOL(pci_get_domain_bus_and_slot);
 180
 181static int match_pci_dev_by_id(struct device *dev, void *data)
 182{
 183        struct pci_dev *pdev = to_pci_dev(dev);
 184        struct pci_device_id *id = data;
 185
 186        if (pci_match_one_device(id, pdev))
 187                return 1;
 188        return 0;
 189}
 190
 191/*
 192 * pci_get_dev_by_id - begin or continue searching for a PCI device by id
 193 * @id: pointer to struct pci_device_id to match for the device
 194 * @from: Previous PCI device found in search, or %NULL for new search.
 195 *
 196 * Iterates through the list of known PCI devices.  If a PCI device is found
 197 * with a matching id a pointer to its device structure is returned, and the
 198 * reference count to the device is incremented.  Otherwise, %NULL is returned.
 199 * A new search is initiated by passing %NULL as the @from argument.  Otherwise
 200 * if @from is not %NULL, searches continue from next device on the global
 201 * list.  The reference count for @from is always decremented if it is not
 202 * %NULL.
 203 *
 204 * This is an internal function for use by the other search functions in
 205 * this file.
 206 */
 207static struct pci_dev *pci_get_dev_by_id(const struct pci_device_id *id,
 208                                         struct pci_dev *from)
 209{
 210        struct device *dev;
 211        struct device *dev_start = NULL;
 212        struct pci_dev *pdev = NULL;
 213
 214        WARN_ON(in_interrupt());
 215        if (from)
 216                dev_start = &from->dev;
 217        dev = bus_find_device(&pci_bus_type, dev_start, (void *)id,
 218                              match_pci_dev_by_id);
 219        if (dev)
 220                pdev = to_pci_dev(dev);
 221        if (from)
 222                pci_dev_put(from);
 223        return pdev;
 224}
 225
 226/**
 227 * pci_get_subsys - begin or continue searching for a PCI device by vendor/subvendor/device/subdevice id
 228 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
 229 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
 230 * @ss_vendor: PCI subsystem vendor id to match, or %PCI_ANY_ID to match all vendor ids
 231 * @ss_device: PCI subsystem device id to match, or %PCI_ANY_ID to match all device ids
 232 * @from: Previous PCI device found in search, or %NULL for new search.
 233 *
 234 * Iterates through the list of known PCI devices.  If a PCI device is found
 235 * with a matching @vendor, @device, @ss_vendor and @ss_device, a pointer to its
 236 * device structure is returned, and the reference count to the device is
 237 * incremented.  Otherwise, %NULL is returned.  A new search is initiated by
 238 * passing %NULL as the @from argument.  Otherwise if @from is not %NULL,
 239 * searches continue from next device on the global list.
 240 * The reference count for @from is always decremented if it is not %NULL.
 241 */
 242struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,
 243                               unsigned int ss_vendor, unsigned int ss_device,
 244                               struct pci_dev *from)
 245{
 246        struct pci_dev *pdev;
 247        struct pci_device_id *id;
 248
 249        /*
 250         * pci_find_subsys() can be called on the ide_setup() path,
 251         * super-early in boot.  But the down_read() will enable local
 252         * interrupts, which can cause some machines to crash.  So here we
 253         * detect and flag that situation and bail out early.
 254         */
 255        if (unlikely(no_pci_devices()))
 256                return NULL;
 257
 258        id = kzalloc(sizeof(*id), GFP_KERNEL);
 259        if (!id)
 260                return NULL;
 261        id->vendor = vendor;
 262        id->device = device;
 263        id->subvendor = ss_vendor;
 264        id->subdevice = ss_device;
 265
 266        pdev = pci_get_dev_by_id(id, from);
 267        kfree(id);
 268
 269        return pdev;
 270}
 271
 272/**
 273 * pci_get_device - begin or continue searching for a PCI device by vendor/device id
 274 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
 275 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
 276 * @from: Previous PCI device found in search, or %NULL for new search.
 277 *
 278 * Iterates through the list of known PCI devices.  If a PCI device is
 279 * found with a matching @vendor and @device, the reference count to the
 280 * device is incremented and a pointer to its device structure is returned.
 281 * Otherwise, %NULL is returned.  A new search is initiated by passing %NULL
 282 * as the @from argument.  Otherwise if @from is not %NULL, searches continue
 283 * from next device on the global list.  The reference count for @from is
 284 * always decremented if it is not %NULL.
 285 */
 286struct pci_dev *
 287pci_get_device(unsigned int vendor, unsigned int device, struct pci_dev *from)
 288{
 289        return pci_get_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from);
 290}
 291
 292/**
 293 * pci_get_class - begin or continue searching for a PCI device by class
 294 * @class: search for a PCI device with this class designation
 295 * @from: Previous PCI device found in search, or %NULL for new search.
 296 *
 297 * Iterates through the list of known PCI devices.  If a PCI device is
 298 * found with a matching @class, the reference count to the device is
 299 * incremented and a pointer to its device structure is returned.
 300 * Otherwise, %NULL is returned.
 301 * A new search is initiated by passing %NULL as the @from argument.
 302 * Otherwise if @from is not %NULL, searches continue from next device
 303 * on the global list.  The reference count for @from is always decremented
 304 * if it is not %NULL.
 305 */
 306struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from)
 307{
 308        struct pci_dev *dev;
 309        struct pci_device_id *id;
 310
 311        id = kzalloc(sizeof(*id), GFP_KERNEL);
 312        if (!id)
 313                return NULL;
 314        id->vendor = id->device = id->subvendor = id->subdevice = PCI_ANY_ID;
 315        id->class_mask = PCI_ANY_ID;
 316        id->class = class;
 317
 318        dev = pci_get_dev_by_id(id, from);
 319        kfree(id);
 320        return dev;
 321}
 322
 323/**
 324 * pci_dev_present - Returns 1 if device matching the device list is present, 0 if not.
 325 * @ids: A pointer to a null terminated list of struct pci_device_id structures
 326 * that describe the type of PCI device the caller is trying to find.
 327 *
 328 * Obvious fact: You do not have a reference to any device that might be found
 329 * by this function, so if that device is removed from the system right after
 330 * this function is finished, the value will be stale.  Use this function to
 331 * find devices that are usually built into a system, or for a general hint as
 332 * to if another device happens to be present at this specific moment in time.
 333 */
 334int pci_dev_present(const struct pci_device_id *ids)
 335{
 336        struct pci_dev *found = NULL;
 337
 338        WARN_ON(in_interrupt());
 339        while (ids->vendor || ids->subvendor || ids->class_mask) {
 340                found = pci_get_dev_by_id(ids, NULL);
 341                if (found)
 342                        goto exit;
 343                ids++;
 344        }
 345exit:
 346        if (found)
 347                return 1;
 348        return 0;
 349}
 350EXPORT_SYMBOL(pci_dev_present);
 351
 352/* For boot time work */
 353EXPORT_SYMBOL(pci_find_bus);
 354EXPORT_SYMBOL(pci_find_next_bus);
 355/* For everyone */
 356EXPORT_SYMBOL(pci_get_device);
 357EXPORT_SYMBOL(pci_get_subsys);
 358EXPORT_SYMBOL(pci_get_slot);
 359EXPORT_SYMBOL(pci_get_class);
 360
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.