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