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