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/module.h> 13 #include <linux/interrupt.h> 14 #include "pci.h" 15 16 DECLARE_RWSEM(pci_bus_sem); 17 18 static struct pci_bus *pci_do_find_bus(struct pci_bus *bus, unsigned char busnr) 19 { 20 struct pci_bus* child; 21 struct list_head *tmp; 22 23 if(bus->number == busnr) 24 return bus; 25 26 list_for_each(tmp, &bus->children) { 27 child = pci_do_find_bus(pci_bus_b(tmp), busnr); 28 if(child) 29 return child; 30 } 31 return NULL; 32 } 33 34 /** 35 * pci_find_bus - locate PCI bus from a given domain and bus number 36 * @domain: number of PCI domain to search 37 * @busnr: number of desired PCI bus 38 * 39 * Given a PCI bus number and domain number, the desired PCI bus is located 40 * in the global list of PCI buses. If the bus is found, a pointer to its 41 * data structure is returned. If no bus is found, %NULL is returned. 42 */ 43 struct pci_bus * pci_find_bus(int domain, int busnr) 44 { 45 struct pci_bus *bus = NULL; 46 struct pci_bus *tmp_bus; 47 48 while ((bus = pci_find_next_bus(bus)) != NULL) { 49 if (pci_domain_nr(bus) != domain) 50 continue; 51 tmp_bus = pci_do_find_bus(bus, busnr); 52 if (tmp_bus) 53 return tmp_bus; 54 } 55 return NULL; 56 } 57 58 /** 59 * pci_find_next_bus - begin or continue searching for a PCI bus 60 * @from: Previous PCI bus found, or %NULL for new search. 61 * 62 * Iterates through the list of known PCI busses. A new search is 63 * initiated by passing %NULL as the @from argument. Otherwise if 64 * @from is not %NULL, searches continue from next device on the 65 * global list. 66 */ 67 struct pci_bus * 68 pci_find_next_bus(const struct pci_bus *from) 69 { 70 struct list_head *n; 71 struct pci_bus *b = NULL; 72 73 WARN_ON(in_interrupt()); 74 down_read(&pci_bus_sem); 75 n = from ? from->node.next : pci_root_buses.next; 76 if (n != &pci_root_buses) 77 b = pci_bus_b(n); 78 up_read(&pci_bus_sem); 79 return b; 80 } 81 82 /** 83 * pci_find_slot - locate PCI device from a given PCI slot 84 * @bus: number of PCI bus on which desired PCI device resides 85 * @devfn: encodes number of PCI slot in which the desired PCI 86 * device resides and the logical device number within that slot 87 * in case of multi-function devices. 88 * 89 * Given a PCI bus and slot/function number, the desired PCI device 90 * is located in system global list of PCI devices. If the device 91 * is found, a pointer to its data structure is returned. If no 92 * device is found, %NULL is returned. 93 */ 94 struct pci_dev * 95 pci_find_slot(unsigned int bus, unsigned int devfn) 96 { 97 struct pci_dev *dev = NULL; 98 99 while ((dev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) { 100 if (dev->bus->number == bus && dev->devfn == devfn) 101 return dev; 102 } 103 return NULL; 104 } 105 106 /** 107 * pci_get_slot - locate PCI device for a given PCI slot 108 * @bus: PCI bus on which desired PCI device resides 109 * @devfn: encodes number of PCI slot in which the desired PCI 110 * device resides and the logical device number within that slot 111 * in case of multi-function devices. 112 * 113 * Given a PCI bus and slot/function number, the desired PCI device 114 * is located in the list of PCI devices. 115 * If the device is found, its reference count is increased and this 116 * function returns a pointer to its data structure. The caller must 117 * decrement the reference count by calling pci_dev_put(). 118 * If no device is found, %NULL is returned. 119 */ 120 struct pci_dev * pci_get_slot(struct pci_bus *bus, unsigned int devfn) 121 { 122 struct list_head *tmp; 123 struct pci_dev *dev; 124 125 WARN_ON(in_interrupt()); 126 down_read(&pci_bus_sem); 127 128 list_for_each(tmp, &bus->devices) { 129 dev = pci_dev_b(tmp); 130 if (dev->devfn == devfn) 131 goto out; 132 } 133 134 dev = NULL; 135 out: 136 pci_dev_get(dev); 137 up_read(&pci_bus_sem); 138 return dev; 139 } 140 141 /** 142 * pci_get_bus_and_slot - locate PCI device from a given PCI bus & slot 143 * @bus: number of PCI bus on which desired PCI device resides 144 * @devfn: encodes number of PCI slot in which the desired PCI 145 * device resides and the logical device number within that slot 146 * in case of multi-function devices. 147 * 148 * Note: the bus/slot search is limited to PCI domain (segment) 0. 149 * 150 * Given a PCI bus and slot/function number, the desired PCI device 151 * is located in system global list of PCI devices. If the device 152 * is found, a pointer to its data structure is returned. If no 153 * device is found, %NULL is returned. The returned device has its 154 * reference count bumped by one. 155 */ 156 157 struct pci_dev * pci_get_bus_and_slot(unsigned int bus, unsigned int devfn) 158 { 159 struct pci_dev *dev = NULL; 160 161 while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) { 162 if (pci_domain_nr(dev->bus) == 0 && 163 (dev->bus->number == bus && dev->devfn == devfn)) 164 return dev; 165 } 166 return NULL; 167 } 168 169 /** 170 * pci_find_subsys - begin or continue searching for a PCI device by vendor/subvendor/device/subdevice id 171 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids 172 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids 173 * @ss_vendor: PCI subsystem vendor id to match, or %PCI_ANY_ID to match all vendor ids 174 * @ss_device: PCI subsystem device id to match, or %PCI_ANY_ID to match all device ids 175 * @from: Previous PCI device found in search, or %NULL for new search. 176 * 177 * Iterates through the list of known PCI devices. If a PCI device is 178 * found with a matching @vendor, @device, @ss_vendor and @ss_device, a 179 * pointer to its device structure is returned. Otherwise, %NULL is returned. 180 * A new search is initiated by passing %NULL as the @from argument. 181 * Otherwise if @from is not %NULL, searches continue from next device 182 * on the global list. 183 * 184 * NOTE: Do not use this function any more; use pci_get_subsys() instead, as 185 * the PCI device returned by this function can disappear at any moment in 186 * time. 187 */ 188 static struct pci_dev * pci_find_subsys(unsigned int vendor, 189 unsigned int device, 190 unsigned int ss_vendor, 191 unsigned int ss_device, 192 const struct pci_dev *from) 193 { 194 struct list_head *n; 195 struct pci_dev *dev; 196 197 WARN_ON(in_interrupt()); 198 199 /* 200 * pci_find_subsys() can be called on the ide_setup() path, super-early 201 * in boot. But the down_read() will enable local interrupts, which 202 * can cause some machines to crash. So here we detect and flag that 203 * situation and bail out early. 204 */ 205 if (unlikely(no_pci_devices())) 206 return NULL; 207 down_read(&pci_bus_sem); 208 n = from ? from->global_list.next : pci_devices.next; 209 210 while (n && (n != &pci_devices)) { 211 dev = pci_dev_g(n); 212 if ((vendor == PCI_ANY_ID || dev->vendor == vendor) && 213 (device == PCI_ANY_ID || dev->device == device) && 214 (ss_vendor == PCI_ANY_ID || dev->subsystem_vendor == ss_vendor) && 215 (ss_device == PCI_ANY_ID || dev->subsystem_device == ss_device)) 216 goto exit; 217 n = n->next; 218 } 219 dev = NULL; 220 exit: 221 up_read(&pci_bus_sem); 222 return dev; 223 } 224 225 /** 226 * pci_find_device - begin or continue searching for a PCI device by vendor/device id 227 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids 228 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids 229 * @from: Previous PCI device found in search, or %NULL for new search. 230 * 231 * Iterates through the list of known PCI devices. If a PCI device is found 232 * with a matching @vendor and @device, a pointer to its device structure is 233 * returned. Otherwise, %NULL is returned. 234 * A new search is initiated by passing %NULL as the @from argument. 235 * Otherwise if @from is not %NULL, searches continue from next device 236 * on the global list. 237 * 238 * NOTE: Do not use this function any more; use pci_get_device() instead, as 239 * the PCI device returned by this function can disappear at any moment in 240 * time. 241 */ 242 struct pci_dev * 243 pci_find_device(unsigned int vendor, unsigned int device, const struct pci_dev *from) 244 { 245 return pci_find_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from); 246 } 247 248 /** 249 * pci_get_subsys - begin or continue searching for a PCI device by vendor/subvendor/device/subdevice id 250 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids 251 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids 252 * @ss_vendor: PCI subsystem vendor id to match, or %PCI_ANY_ID to match all vendor ids 253 * @ss_device: PCI subsystem device id to match, or %PCI_ANY_ID to match all device ids 254 * @from: Previous PCI device found in search, or %NULL for new search. 255 * 256 * Iterates through the list of known PCI devices. If a PCI device is found 257 * with a matching @vendor, @device, @ss_vendor and @ss_device, a pointer to its 258 * device structure is returned, and the reference count to the device is 259 * incremented. Otherwise, %NULL is returned. A new search is initiated by 260 * passing %NULL as the @from argument. Otherwise if @from is not %NULL, 261 * searches continue from next device on the global list. 262 * The reference count for @from is always decremented if it is not %NULL. 263 */ 264 struct pci_dev * 265 pci_get_subsys(unsigned int vendor, unsigned int device, 266 unsigned int ss_vendor, unsigned int ss_device, 267 struct pci_dev *from) 268 { 269 struct list_head *n; 270 struct pci_dev *dev; 271 272 WARN_ON(in_interrupt()); 273 274 /* 275 * pci_get_subsys() can potentially be called by drivers super-early 276 * in boot. But the down_read() will enable local interrupts, which 277 * can cause some machines to crash. So here we detect and flag that 278 * situation and bail out early. 279 */ 280 if (unlikely(no_pci_devices())) 281 return NULL; 282 down_read(&pci_bus_sem); 283 n = from ? from->global_list.next : pci_devices.next; 284 285 while (n && (n != &pci_devices)) { 286 dev = pci_dev_g(n); 287 if ((vendor == PCI_ANY_ID || dev->vendor == vendor) && 288 (device == PCI_ANY_ID || dev->device == device) && 289 (ss_vendor == PCI_ANY_ID || dev->subsystem_vendor == ss_vendor) && 290 (ss_device == PCI_ANY_ID || dev->subsystem_device == ss_device)) 291 goto exit; 292 n = n->next; 293 } 294 dev = NULL; 295 exit: 296 dev = pci_dev_get(dev); 297 up_read(&pci_bus_sem); 298 pci_dev_put(from); 299 return dev; 300 } 301 302 /** 303 * pci_get_device - begin or continue searching for a PCI device by vendor/device id 304 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids 305 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids 306 * @from: Previous PCI device found in search, or %NULL for new search. 307 * 308 * Iterates through the list of known PCI devices. If a PCI device is 309 * found with a matching @vendor and @device, the reference count to the 310 * device is incremented and a pointer to its device structure is returned. 311 * Otherwise, %NULL is returned. A new search is initiated by passing %NULL 312 * as the @from argument. Otherwise if @from is not %NULL, searches continue 313 * from next device on the global list. The reference count for @from is 314 * always decremented if it is not %NULL. 315 */ 316 struct pci_dev * 317 pci_get_device(unsigned int vendor, unsigned int device, struct pci_dev *from) 318 { 319 return pci_get_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from); 320 } 321 322 /** 323 * pci_get_device_reverse - begin or continue searching for a PCI device by vendor/device id 324 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids 325 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids 326 * @from: Previous PCI device found in search, or %NULL for new search. 327 * 328 * Iterates through the list of known PCI devices in the reverse order of 329 * pci_get_device. 330 * If a PCI device is found with a matching @vendor and @device, the reference 331 * count to the device is incremented and a pointer to its device structure 332 * is returned Otherwise, %NULL is returned. A new search is initiated by 333 * passing %NULL as the @from argument. Otherwise if @from is not %NULL, 334 * searches continue from next device on the global list. The reference 335 * count for @from is always decremented if it is not %NULL. 336 */ 337 struct pci_dev * 338 pci_get_device_reverse(unsigned int vendor, unsigned int device, struct pci_dev *from) 339 { 340 struct list_head *n; 341 struct pci_dev *dev; 342 343 WARN_ON(in_interrupt()); 344 down_read(&pci_bus_sem); 345 n = from ? from->global_list.prev : pci_devices.prev; 346 347 while (n && (n != &pci_devices)) { 348 dev = pci_dev_g(n); 349 if ((vendor == PCI_ANY_ID || dev->vendor == vendor) && 350 (device == PCI_ANY_ID || dev->device == device)) 351 goto exit; 352 n = n->prev; 353 } 354 dev = NULL; 355 exit: 356 dev = pci_dev_get(dev); 357 up_read(&pci_bus_sem); 358 pci_dev_put(from); 359 return dev; 360 } 361 362 /** 363 * pci_get_class - begin or continue searching for a PCI device by class 364 * @class: search for a PCI device with this class designation 365 * @from: Previous PCI device found in search, or %NULL for new search. 366 * 367 * Iterates through the list of known PCI devices. If a PCI device is 368 * found with a matching @class, the reference count to the device is 369 * incremented and a pointer to its device structure is returned. 370 * Otherwise, %NULL is returned. 371 * A new search is initiated by passing %NULL as the @from argument. 372 * Otherwise if @from is not %NULL, searches continue from next device 373 * on the global list. The reference count for @from is always decremented 374 * if it is not %NULL. 375 */ 376 struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from) 377 { 378 struct list_head *n; 379 struct pci_dev *dev; 380 381 WARN_ON(in_interrupt()); 382 down_read(&pci_bus_sem); 383 n = from ? from->global_list.next : pci_devices.next; 384 385 while (n && (n != &pci_devices)) { 386 dev = pci_dev_g(n); 387 if (dev->class == class) 388 goto exit; 389 n = n->next; 390 } 391 dev = NULL; 392 exit: 393 dev = pci_dev_get(dev); 394 up_read(&pci_bus_sem); 395 pci_dev_put(from); 396 return dev; 397 } 398 399 const struct pci_device_id *pci_find_present(const struct pci_device_id *ids) 400 { 401 struct pci_dev *dev; 402 const struct pci_device_id *found = NULL; 403 404 WARN_ON(in_interrupt()); 405 down_read(&pci_bus_sem); 406 while (ids->vendor || ids->subvendor || ids->class_mask) { 407 list_for_each_entry(dev, &pci_devices, global_list) { 408 if ((found = pci_match_one_device(ids, dev)) != NULL) 409 goto exit; 410 } 411 ids++; 412 } 413 exit: 414 up_read(&pci_bus_sem); 415 return found; 416 } 417 418 /** 419 * pci_dev_present - Returns 1 if device matching the device list is present, 0 if not. 420 * @ids: A pointer to a null terminated list of struct pci_device_id structures 421 * that describe the type of PCI device the caller is trying to find. 422 * 423 * Obvious fact: You do not have a reference to any device that might be found 424 * by this function, so if that device is removed from the system right after 425 * this function is finished, the value will be stale. Use this function to 426 * find devices that are usually built into a system, or for a general hint as 427 * to if another device happens to be present at this specific moment in time. 428 */ 429 int pci_dev_present(const struct pci_device_id *ids) 430 { 431 return pci_find_present(ids) == NULL ? 0 : 1; 432 } 433 434 EXPORT_SYMBOL(pci_dev_present); 435 EXPORT_SYMBOL(pci_find_present); 436 437 EXPORT_SYMBOL(pci_find_device); 438 EXPORT_SYMBOL(pci_find_slot); 439 /* For boot time work */ 440 EXPORT_SYMBOL(pci_find_bus); 441 EXPORT_SYMBOL(pci_find_next_bus); 442 /* For everyone */ 443 EXPORT_SYMBOL(pci_get_device); 444 EXPORT_SYMBOL(pci_get_device_reverse); 445 EXPORT_SYMBOL(pci_get_subsys); 446 EXPORT_SYMBOL(pci_get_slot); 447 EXPORT_SYMBOL(pci_get_bus_and_slot); 448 EXPORT_SYMBOL(pci_get_class); 449