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/pci.h> 11 #include <linux/slab.h> 12 #include <linux/module.h> 13 #include <linux/interrupt.h> 14 #include "pci.h" 15 16 DECLARE_RWSEM(pci_bus_sem); 17 EXPORT_SYMBOL_GPL(pci_bus_sem); 18 19 /* 20 * pci_for_each_dma_alias - Iterate over DMA aliases for a device 21 * @pdev: starting downstream device 22 * @fn: function to call for each alias 23 * @data: opaque data to pass to @fn 24 * 25 * Starting @pdev, walk up the bus calling @fn for each possible alias 26 * of @pdev at the root bus. 27 */ 28 int pci_for_each_dma_alias(struct pci_dev *pdev, 29 int (*fn)(struct pci_dev *pdev, 30 u16 alias, void *data), void *data) 31 { 32 struct pci_bus *bus; 33 int ret; 34 35 ret = fn(pdev, PCI_DEVID(pdev->bus->number, pdev->devfn), data); 36 if (ret) 37 return ret; 38 39 /* 40 * If the device is broken and uses an alias requester ID for 41 * DMA, iterate over that too. 42 */ 43 if (unlikely(pdev->dev_flags & PCI_DEV_FLAGS_DMA_ALIAS_DEVFN)) { 44 ret = fn(pdev, PCI_DEVID(pdev->bus->number, 45 pdev->dma_alias_devfn), data); 46 if (ret) 47 return ret; 48 } 49 50 for (bus = pdev->bus; !pci_is_root_bus(bus); bus = bus->parent) { 51 struct pci_dev *tmp; 52 53 /* Skip virtual buses */ 54 if (!bus->self) 55 continue; 56 57 tmp = bus->self; 58 59 /* 60 * PCIe-to-PCI/X bridges alias transactions from downstream 61 * devices using the subordinate bus number (PCI Express to 62 * PCI/PCI-X Bridge Spec, rev 1.0, sec 2.3). For all cases 63 * where the upstream bus is PCI/X we alias to the bridge 64 * (there are various conditions in the previous reference 65 * where the bridge may take ownership of transactions, even 66 * when the secondary interface is PCI-X). 67 */ 68 if (pci_is_pcie(tmp)) { 69 switch (pci_pcie_type(tmp)) { 70 case PCI_EXP_TYPE_ROOT_PORT: 71 case PCI_EXP_TYPE_UPSTREAM: 72 case PCI_EXP_TYPE_DOWNSTREAM: 73 continue; 74 case PCI_EXP_TYPE_PCI_BRIDGE: 75 ret = fn(tmp, 76 PCI_DEVID(tmp->subordinate->number, 77 PCI_DEVFN(0, 0)), data); 78 if (ret) 79 return ret; 80 continue; 81 case PCI_EXP_TYPE_PCIE_BRIDGE: 82 ret = fn(tmp, 83 PCI_DEVID(tmp->bus->number, 84 tmp->devfn), data); 85 if (ret) 86 return ret; 87 continue; 88 } 89 } else { 90 if (tmp->dev_flags & PCI_DEV_FLAG_PCIE_BRIDGE_ALIAS) 91 ret = fn(tmp, 92 PCI_DEVID(tmp->subordinate->number, 93 PCI_DEVFN(0, 0)), data); 94 else 95 ret = fn(tmp, 96 PCI_DEVID(tmp->bus->number, 97 tmp->devfn), data); 98 if (ret) 99 return ret; 100 } 101 } 102 103 return ret; 104 } 105 106 /* 107 * find the upstream PCIe-to-PCI bridge of a PCI device 108 * if the device is PCIE, return NULL 109 * if the device isn't connected to a PCIe bridge (that is its parent is a 110 * legacy PCI bridge and the bridge is directly connected to bus 0), return its 111 * parent 112 */ 113 struct pci_dev *pci_find_upstream_pcie_bridge(struct pci_dev *pdev) 114 { 115 struct pci_dev *tmp = NULL; 116 117 if (pci_is_pcie(pdev)) 118 return NULL; 119 while (1) { 120 if (pci_is_root_bus(pdev->bus)) 121 break; 122 pdev = pdev->bus->self; 123 /* a p2p bridge */ 124 if (!pci_is_pcie(pdev)) { 125 tmp = pdev; 126 continue; 127 } 128 /* PCI device should connect to a PCIe bridge */ 129 if (pci_pcie_type(pdev) != PCI_EXP_TYPE_PCI_BRIDGE) { 130 /* Busted hardware? */ 131 WARN_ON_ONCE(1); 132 return NULL; 133 } 134 return pdev; 135 } 136 137 return tmp; 138 } 139 140 static struct pci_bus *pci_do_find_bus(struct pci_bus *bus, unsigned char busnr) 141 { 142 struct pci_bus *child; 143 struct pci_bus *tmp; 144 145 if (bus->number == busnr) 146 return bus; 147 148 list_for_each_entry(tmp, &bus->children, node) { 149 child = pci_do_find_bus(tmp, busnr); 150 if (child) 151 return child; 152 } 153 return NULL; 154 } 155 156 /** 157 * pci_find_bus - locate PCI bus from a given domain and bus number 158 * @domain: number of PCI domain to search 159 * @busnr: number of desired PCI bus 160 * 161 * Given a PCI bus number and domain number, the desired PCI bus is located 162 * in the global list of PCI buses. If the bus is found, a pointer to its 163 * data structure is returned. If no bus is found, %NULL is returned. 164 */ 165 struct pci_bus *pci_find_bus(int domain, int busnr) 166 { 167 struct pci_bus *bus = NULL; 168 struct pci_bus *tmp_bus; 169 170 while ((bus = pci_find_next_bus(bus)) != NULL) { 171 if (pci_domain_nr(bus) != domain) 172 continue; 173 tmp_bus = pci_do_find_bus(bus, busnr); 174 if (tmp_bus) 175 return tmp_bus; 176 } 177 return NULL; 178 } 179 EXPORT_SYMBOL(pci_find_bus); 180 181 /** 182 * pci_find_next_bus - begin or continue searching for a PCI bus 183 * @from: Previous PCI bus found, or %NULL for new search. 184 * 185 * Iterates through the list of known PCI buses. A new search is 186 * initiated by passing %NULL as the @from argument. Otherwise if 187 * @from is not %NULL, searches continue from next device on the 188 * global list. 189 */ 190 struct pci_bus *pci_find_next_bus(const struct pci_bus *from) 191 { 192 struct list_head *n; 193 struct pci_bus *b = NULL; 194 195 WARN_ON(in_interrupt()); 196 down_read(&pci_bus_sem); 197 n = from ? from->node.next : pci_root_buses.next; 198 if (n != &pci_root_buses) 199 b = list_entry(n, struct pci_bus, node); 200 up_read(&pci_bus_sem); 201 return b; 202 } 203 EXPORT_SYMBOL(pci_find_next_bus); 204 205 /** 206 * pci_get_slot - locate PCI device for a given PCI slot 207 * @bus: PCI bus on which desired PCI device resides 208 * @devfn: encodes number of PCI slot in which the desired PCI 209 * device resides and the logical device number within that slot 210 * in case of multi-function devices. 211 * 212 * Given a PCI bus and slot/function number, the desired PCI device 213 * is located in the list of PCI devices. 214 * If the device is found, its reference count is increased and this 215 * function returns a pointer to its data structure. The caller must 216 * decrement the reference count by calling pci_dev_put(). 217 * If no device is found, %NULL is returned. 218 */ 219 struct pci_dev *pci_get_slot(struct pci_bus *bus, unsigned int devfn) 220 { 221 struct pci_dev *dev; 222 223 WARN_ON(in_interrupt()); 224 down_read(&pci_bus_sem); 225 226 list_for_each_entry(dev, &bus->devices, bus_list) { 227 if (dev->devfn == devfn) 228 goto out; 229 } 230 231 dev = NULL; 232 out: 233 pci_dev_get(dev); 234 up_read(&pci_bus_sem); 235 return dev; 236 } 237 EXPORT_SYMBOL(pci_get_slot); 238 239 /** 240 * pci_get_domain_bus_and_slot - locate PCI device for a given PCI domain (segment), bus, and slot 241 * @domain: PCI domain/segment on which the PCI device resides. 242 * @bus: PCI bus on which desired PCI device resides 243 * @devfn: encodes number of PCI slot in which the desired PCI device 244 * resides and the logical device number within that slot in case of 245 * multi-function devices. 246 * 247 * Given a PCI domain, bus, and slot/function number, the desired PCI 248 * device is located in the list of PCI devices. If the device is 249 * found, its reference count is increased and this function returns a 250 * pointer to its data structure. The caller must decrement the 251 * reference count by calling pci_dev_put(). If no device is found, 252 * %NULL is returned. 253 */ 254 struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus, 255 unsigned int devfn) 256 { 257 struct pci_dev *dev = NULL; 258 259 for_each_pci_dev(dev) { 260 if (pci_domain_nr(dev->bus) == domain && 261 (dev->bus->number == bus && dev->devfn == devfn)) 262 return dev; 263 } 264 return NULL; 265 } 266 EXPORT_SYMBOL(pci_get_domain_bus_and_slot); 267 268 static int match_pci_dev_by_id(struct device *dev, void *data) 269 { 270 struct pci_dev *pdev = to_pci_dev(dev); 271 struct pci_device_id *id = data; 272 273 if (pci_match_one_device(id, pdev)) 274 return 1; 275 return 0; 276 } 277 278 /* 279 * pci_get_dev_by_id - begin or continue searching for a PCI device by id 280 * @id: pointer to struct pci_device_id to match for the device 281 * @from: Previous PCI device found in search, or %NULL for new search. 282 * 283 * Iterates through the list of known PCI devices. If a PCI device is found 284 * with a matching id a pointer to its device structure is returned, and the 285 * reference count to the device is incremented. Otherwise, %NULL is returned. 286 * A new search is initiated by passing %NULL as the @from argument. Otherwise 287 * if @from is not %NULL, searches continue from next device on the global 288 * list. The reference count for @from is always decremented if it is not 289 * %NULL. 290 * 291 * This is an internal function for use by the other search functions in 292 * this file. 293 */ 294 static struct pci_dev *pci_get_dev_by_id(const struct pci_device_id *id, 295 struct pci_dev *from) 296 { 297 struct device *dev; 298 struct device *dev_start = NULL; 299 struct pci_dev *pdev = NULL; 300 301 WARN_ON(in_interrupt()); 302 if (from) 303 dev_start = &from->dev; 304 dev = bus_find_device(&pci_bus_type, dev_start, (void *)id, 305 match_pci_dev_by_id); 306 if (dev) 307 pdev = to_pci_dev(dev); 308 if (from) 309 pci_dev_put(from); 310 return pdev; 311 } 312 313 /** 314 * pci_get_subsys - begin or continue searching for a PCI device by vendor/subvendor/device/subdevice id 315 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids 316 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids 317 * @ss_vendor: PCI subsystem vendor id to match, or %PCI_ANY_ID to match all vendor ids 318 * @ss_device: PCI subsystem device id to match, or %PCI_ANY_ID to match all device ids 319 * @from: Previous PCI device found in search, or %NULL for new search. 320 * 321 * Iterates through the list of known PCI devices. If a PCI device is found 322 * with a matching @vendor, @device, @ss_vendor and @ss_device, a pointer to its 323 * device structure is returned, and the reference count to the device is 324 * incremented. Otherwise, %NULL is returned. A new search is initiated by 325 * passing %NULL as the @from argument. Otherwise if @from is not %NULL, 326 * searches continue from next device on the global list. 327 * The reference count for @from is always decremented if it is not %NULL. 328 */ 329 struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device, 330 unsigned int ss_vendor, unsigned int ss_device, 331 struct pci_dev *from) 332 { 333 struct pci_device_id id = { 334 .vendor = vendor, 335 .device = device, 336 .subvendor = ss_vendor, 337 .subdevice = ss_device, 338 }; 339 340 return pci_get_dev_by_id(&id, from); 341 } 342 EXPORT_SYMBOL(pci_get_subsys); 343 344 /** 345 * pci_get_device - begin or continue searching for a PCI device by vendor/device id 346 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids 347 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids 348 * @from: Previous PCI device found in search, or %NULL for new search. 349 * 350 * Iterates through the list of known PCI devices. If a PCI device is 351 * found with a matching @vendor and @device, the reference count to the 352 * device is incremented and a pointer to its device structure is returned. 353 * Otherwise, %NULL is returned. A new search is initiated by passing %NULL 354 * as the @from argument. Otherwise if @from is not %NULL, searches continue 355 * from next device on the global list. The reference count for @from is 356 * always decremented if it is not %NULL. 357 */ 358 struct pci_dev *pci_get_device(unsigned int vendor, unsigned int device, 359 struct pci_dev *from) 360 { 361 return pci_get_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from); 362 } 363 EXPORT_SYMBOL(pci_get_device); 364 365 /** 366 * pci_get_class - begin or continue searching for a PCI device by class 367 * @class: search for a PCI device with this class designation 368 * @from: Previous PCI device found in search, or %NULL for new search. 369 * 370 * Iterates through the list of known PCI devices. If a PCI device is 371 * found with a matching @class, the reference count to the device is 372 * incremented and a pointer to its device structure is returned. 373 * Otherwise, %NULL is returned. 374 * A new search is initiated by passing %NULL as the @from argument. 375 * Otherwise if @from is not %NULL, searches continue from next device 376 * on the global list. The reference count for @from is always decremented 377 * if it is not %NULL. 378 */ 379 struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from) 380 { 381 struct pci_device_id id = { 382 .vendor = PCI_ANY_ID, 383 .device = PCI_ANY_ID, 384 .subvendor = PCI_ANY_ID, 385 .subdevice = PCI_ANY_ID, 386 .class_mask = PCI_ANY_ID, 387 .class = class, 388 }; 389 390 return pci_get_dev_by_id(&id, from); 391 } 392 EXPORT_SYMBOL(pci_get_class); 393 394 /** 395 * pci_dev_present - Returns 1 if device matching the device list is present, 0 if not. 396 * @ids: A pointer to a null terminated list of struct pci_device_id structures 397 * that describe the type of PCI device the caller is trying to find. 398 * 399 * Obvious fact: You do not have a reference to any device that might be found 400 * by this function, so if that device is removed from the system right after 401 * this function is finished, the value will be stale. Use this function to 402 * find devices that are usually built into a system, or for a general hint as 403 * to if another device happens to be present at this specific moment in time. 404 */ 405 int pci_dev_present(const struct pci_device_id *ids) 406 { 407 struct pci_dev *found = NULL; 408 409 WARN_ON(in_interrupt()); 410 while (ids->vendor || ids->subvendor || ids->class_mask) { 411 found = pci_get_dev_by_id(ids, NULL); 412 if (found) { 413 pci_dev_put(found); 414 return 1; 415 } 416 ids++; 417 } 418 419 return 0; 420 } 421 EXPORT_SYMBOL(pci_dev_present); 422