blob: 217814fef4ef4c7e5b3e4b54b96b1e70c7e2b7d4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Zhang Yanmind71374d2006-06-02 12:35:43 +080016DECLARE_RWSEM(pci_bus_sem);
Keshavamurthy, Anil S994a65e2007-10-21 16:41:46 -070017/*
18 * find the upstream PCIE-to-PCI bridge of a PCI device
19 * if the device is PCIE, return NULL
20 * if the device isn't connected to a PCIE bridge (that is its parent is a
21 * legacy PCI bridge and the bridge is directly connected to bus 0), return its
22 * parent
23 */
24struct pci_dev *
25pci_find_upstream_pcie_bridge(struct pci_dev *pdev)
26{
27 struct pci_dev *tmp = NULL;
28
29 if (pdev->is_pcie)
30 return NULL;
31 while (1) {
32 if (!pdev->bus->self)
33 break;
34 pdev = pdev->bus->self;
35 /* a p2p bridge */
36 if (!pdev->is_pcie) {
37 tmp = pdev;
38 continue;
39 }
40 /* PCI device should connect to a PCIE bridge */
41 if (pdev->pcie_type != PCI_EXP_TYPE_PCI_BRIDGE) {
42 /* Busted hardware? */
43 WARN_ON_ONCE(1);
44 return NULL;
45 }
46 return pdev;
47 }
48
49 return tmp;
50}
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Sam Ravnborg96bde062007-03-26 21:53:30 -080052static struct pci_bus *pci_do_find_bus(struct pci_bus *bus, unsigned char busnr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070053{
54 struct pci_bus* child;
55 struct list_head *tmp;
56
57 if(bus->number == busnr)
58 return bus;
59
60 list_for_each(tmp, &bus->children) {
61 child = pci_do_find_bus(pci_bus_b(tmp), busnr);
62 if(child)
63 return child;
64 }
65 return NULL;
66}
67
68/**
69 * pci_find_bus - locate PCI bus from a given domain and bus number
70 * @domain: number of PCI domain to search
71 * @busnr: number of desired PCI bus
72 *
73 * Given a PCI bus number and domain number, the desired PCI bus is located
74 * in the global list of PCI buses. If the bus is found, a pointer to its
75 * data structure is returned. If no bus is found, %NULL is returned.
76 */
Randy Dunlapc8439cfc2006-07-18 14:33:16 -070077struct pci_bus * pci_find_bus(int domain, int busnr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070078{
79 struct pci_bus *bus = NULL;
80 struct pci_bus *tmp_bus;
81
82 while ((bus = pci_find_next_bus(bus)) != NULL) {
83 if (pci_domain_nr(bus) != domain)
84 continue;
85 tmp_bus = pci_do_find_bus(bus, busnr);
86 if (tmp_bus)
87 return tmp_bus;
88 }
89 return NULL;
90}
91
92/**
93 * pci_find_next_bus - begin or continue searching for a PCI bus
94 * @from: Previous PCI bus found, or %NULL for new search.
95 *
96 * Iterates through the list of known PCI busses. A new search is
Randy Dunlapd75763d2006-07-30 03:03:41 -070097 * initiated by passing %NULL as the @from argument. Otherwise if
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 * @from is not %NULL, searches continue from next device on the
99 * global list.
100 */
101struct pci_bus *
102pci_find_next_bus(const struct pci_bus *from)
103{
104 struct list_head *n;
105 struct pci_bus *b = NULL;
106
107 WARN_ON(in_interrupt());
Zhang Yanmind71374d2006-06-02 12:35:43 +0800108 down_read(&pci_bus_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 n = from ? from->node.next : pci_root_buses.next;
110 if (n != &pci_root_buses)
111 b = pci_bus_b(n);
Zhang Yanmind71374d2006-06-02 12:35:43 +0800112 up_read(&pci_bus_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 return b;
114}
115
Jeff Garzikbd3989e2007-10-29 09:48:09 -0400116#ifdef CONFIG_PCI_LEGACY
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117/**
118 * pci_find_slot - locate PCI device from a given PCI slot
119 * @bus: number of PCI bus on which desired PCI device resides
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800120 * @devfn: encodes number of PCI slot in which the desired PCI
121 * device resides and the logical device number within that slot
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 * in case of multi-function devices.
123 *
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800124 * Given a PCI bus and slot/function number, the desired PCI device
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 * is located in system global list of PCI devices. If the device
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800126 * is found, a pointer to its data structure is returned. If no
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 * device is found, %NULL is returned.
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800128 *
129 * NOTE: Do not use this function any more; use pci_get_slot() instead, as
130 * the PCI device returned by this function can disappear at any moment in
131 * time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 */
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800133struct pci_dev *pci_find_slot(unsigned int bus, unsigned int devfn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134{
135 struct pci_dev *dev = NULL;
136
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800137 while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
138 if (dev->bus->number == bus && dev->devfn == devfn) {
139 pci_dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 return dev;
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800141 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 }
143 return NULL;
144}
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800145EXPORT_SYMBOL(pci_find_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800147/**
148 * pci_find_device - begin or continue searching for a PCI device by vendor/device id
149 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
150 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
151 * @from: Previous PCI device found in search, or %NULL for new search.
152 *
153 * Iterates through the list of known PCI devices. If a PCI device is found
154 * with a matching @vendor and @device, a pointer to its device structure is
155 * returned. Otherwise, %NULL is returned.
156 * A new search is initiated by passing %NULL as the @from argument.
157 * Otherwise if @from is not %NULL, searches continue from next device
158 * on the global list.
159 *
160 * NOTE: Do not use this function any more; use pci_get_device() instead, as
161 * the PCI device returned by this function can disappear at any moment in
162 * time.
163 */
164struct pci_dev *pci_find_device(unsigned int vendor, unsigned int device,
165 const struct pci_dev *from)
166{
167 struct pci_dev *pdev;
168
169 pdev = pci_get_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from);
170 pci_dev_put(pdev);
171 return pdev;
172}
173EXPORT_SYMBOL(pci_find_device);
Jeff Garzikbd3989e2007-10-29 09:48:09 -0400174#endif /* CONFIG_PCI_LEGACY */
175
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176/**
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 */
190struct pci_dev * pci_get_slot(struct pci_bus *bus, unsigned int devfn)
191{
192 struct list_head *tmp;
193 struct pci_dev *dev;
194
195 WARN_ON(in_interrupt());
Zhang Yanmind71374d2006-06-02 12:35:43 +0800196 down_read(&pci_bus_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198 list_for_each(tmp, &bus->devices) {
199 dev = pci_dev_b(tmp);
200 if (dev->devfn == devfn)
201 goto out;
202 }
203
204 dev = NULL;
205 out:
206 pci_dev_get(dev);
Zhang Yanmind71374d2006-06-02 12:35:43 +0800207 up_read(&pci_bus_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 return dev;
209}
210
211/**
Randy Dunlap5463d9f2007-06-28 16:04:21 -0700212 * pci_get_bus_and_slot - locate PCI device from a given PCI bus & slot
Alan Cox29f3eb62006-10-16 16:20:21 -0700213 * @bus: number of PCI bus on which desired PCI device resides
214 * @devfn: encodes number of PCI slot in which the desired PCI
215 * device resides and the logical device number within that slot
216 * in case of multi-function devices.
217 *
Randy Dunlap5463d9f2007-06-28 16:04:21 -0700218 * Note: the bus/slot search is limited to PCI domain (segment) 0.
219 *
Alan Cox29f3eb62006-10-16 16:20:21 -0700220 * Given a PCI bus and slot/function number, the desired PCI device
221 * is located in system global list of PCI devices. If the device
222 * is found, a pointer to its data structure is returned. If no
223 * device is found, %NULL is returned. The returned device has its
224 * reference count bumped by one.
225 */
226
227struct pci_dev * pci_get_bus_and_slot(unsigned int bus, unsigned int devfn)
228{
229 struct pci_dev *dev = NULL;
230
231 while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
Randy Dunlap5463d9f2007-06-28 16:04:21 -0700232 if (pci_domain_nr(dev->bus) == 0 &&
233 (dev->bus->number == bus && dev->devfn == devfn))
Alan Cox29f3eb62006-10-16 16:20:21 -0700234 return dev;
235 }
236 return NULL;
237}
238
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800239static int match_pci_dev_by_id(struct device *dev, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800241 struct pci_dev *pdev = to_pci_dev(dev);
242 struct pci_device_id *id = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800244 if (pci_match_one_device(id, pdev))
245 return 1;
246 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247}
248
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800249/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 * @from: Previous PCI device found in search, or %NULL for new search.
253 *
Randy Dunlapd75763d2006-07-30 03:03:41 -0700254 * Iterates through the list of known PCI devices. If a PCI device is found
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800255 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 */
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800265static struct pci_dev *pci_get_dev_by_id(const struct pci_device_id *id,
266 const struct pci_dev *from)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267{
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800268 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 /* FIXME
275 * take the cast off, when bus_find_device is made const.
276 */
277 dev_start = (struct device *)&from->dev;
278 }
279 dev = bus_find_device(&pci_bus_type, dev_start, (void *)id,
280 match_pci_dev_by_id);
281 if (dev)
282 pdev = to_pci_dev(dev);
283 return pdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284}
285
286/**
287 * pci_get_subsys - begin or continue searching for a PCI device by vendor/subvendor/device/subdevice id
288 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
289 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
290 * @ss_vendor: PCI subsystem vendor id to match, or %PCI_ANY_ID to match all vendor ids
291 * @ss_device: PCI subsystem device id to match, or %PCI_ANY_ID to match all device ids
292 * @from: Previous PCI device found in search, or %NULL for new search.
293 *
Randy Dunlapd75763d2006-07-30 03:03:41 -0700294 * Iterates through the list of known PCI devices. If a PCI device is found
295 * with a matching @vendor, @device, @ss_vendor and @ss_device, a pointer to its
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 * device structure is returned, and the reference count to the device is
297 * incremented. Otherwise, %NULL is returned. A new search is initiated by
Randy Dunlapd75763d2006-07-30 03:03:41 -0700298 * passing %NULL as the @from argument. Otherwise if @from is not %NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 * searches continue from next device on the global list.
300 * The reference count for @from is always decremented if it is not %NULL.
301 */
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800302struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,
303 unsigned int ss_vendor, unsigned int ss_device,
304 const struct pci_dev *from)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305{
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800306 struct pci_dev *pdev;
307 struct pci_device_id *id;
Ard van Breemen6ae4adf2007-01-05 16:36:21 -0800308
309 /*
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800310 * pci_find_subsys() can be called on the ide_setup() path,
311 * super-early in boot. But the down_read() will enable local
312 * interrupts, which can cause some machines to crash. So here we
313 * detect and flag that situation and bail out early.
Ard van Breemen6ae4adf2007-01-05 16:36:21 -0800314 */
Andrew Morton35ef63f2007-07-15 23:39:40 -0700315 if (unlikely(no_pci_devices()))
Ard van Breemen6ae4adf2007-01-05 16:36:21 -0800316 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800318 id = kzalloc(sizeof(*id), GFP_KERNEL);
319 if (!id)
320 return NULL;
321 id->vendor = vendor;
322 id->device = device;
323 id->subvendor = ss_vendor;
324 id->subdevice = ss_device;
325
326 pdev = pci_get_dev_by_id(id, from);
327 kfree(id);
328
329 return pdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330}
331
332/**
333 * pci_get_device - begin or continue searching for a PCI device by vendor/device id
334 * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
335 * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
336 * @from: Previous PCI device found in search, or %NULL for new search.
337 *
338 * Iterates through the list of known PCI devices. If a PCI device is
339 * found with a matching @vendor and @device, the reference count to the
340 * device is incremented and a pointer to its device structure is returned.
341 * Otherwise, %NULL is returned. A new search is initiated by passing %NULL
Randy Dunlapd75763d2006-07-30 03:03:41 -0700342 * as the @from argument. Otherwise if @from is not %NULL, searches continue
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 * from next device on the global list. The reference count for @from is
344 * always decremented if it is not %NULL.
345 */
346struct pci_dev *
347pci_get_device(unsigned int vendor, unsigned int device, struct pci_dev *from)
348{
349 return pci_get_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from);
350}
351
Alan Cox29f3eb62006-10-16 16:20:21 -0700352/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 * pci_get_class - begin or continue searching for a PCI device by class
354 * @class: search for a PCI device with this class designation
355 * @from: Previous PCI device found in search, or %NULL for new search.
356 *
357 * Iterates through the list of known PCI devices. If a PCI device is
358 * found with a matching @class, the reference count to the device is
359 * incremented and a pointer to its device structure is returned.
360 * Otherwise, %NULL is returned.
Randy Dunlapd75763d2006-07-30 03:03:41 -0700361 * A new search is initiated by passing %NULL as the @from argument.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 * Otherwise if @from is not %NULL, searches continue from next device
363 * on the global list. The reference count for @from is always decremented
364 * if it is not %NULL.
365 */
366struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from)
367{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 struct pci_dev *dev;
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800369 struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800371 id = kzalloc(sizeof(*id), GFP_KERNEL);
372 if (!id)
373 return NULL;
374 id->vendor = id->device = id->subvendor = id->subdevice = PCI_ANY_ID;
375 id->class_mask = PCI_ANY_ID;
376 id->class = class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800378 dev = pci_get_dev_by_id(id, from);
379 kfree(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 return dev;
381}
382
Greg Kroah-Hartman448432c2008-02-12 13:36:20 -0800383/**
384 * pci_dev_present - Returns 1 if device matching the device list is present, 0 if not.
385 * @ids: A pointer to a null terminated list of struct pci_device_id structures
386 * that describe the type of PCI device the caller is trying to find.
387 *
388 * Obvious fact: You do not have a reference to any device that might be found
389 * by this function, so if that device is removed from the system right after
390 * this function is finished, the value will be stale. Use this function to
391 * find devices that are usually built into a system, or for a general hint as
392 * to if another device happens to be present at this specific moment in time.
393 */
394int pci_dev_present(const struct pci_device_id *ids)
Alan Coxd86f90f2006-12-04 15:14:44 -0800395{
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800396 struct pci_dev *found = NULL;
Alan Coxd86f90f2006-12-04 15:14:44 -0800397
398 WARN_ON(in_interrupt());
Alan Coxd86f90f2006-12-04 15:14:44 -0800399 while (ids->vendor || ids->subvendor || ids->class_mask) {
Greg Kroah-Hartman95247b52008-02-13 11:03:58 -0800400 found = pci_get_dev_by_id(ids, NULL);
401 if (found)
402 goto exit;
Alan Coxd86f90f2006-12-04 15:14:44 -0800403 ids++;
404 }
Ben Gardner3c92c572007-05-10 22:58:58 -0700405exit:
Greg Kroah-Hartman448432c2008-02-12 13:36:20 -0800406 if (found)
407 return 1;
408 return 0;
Alan Coxd86f90f2006-12-04 15:14:44 -0800409}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410EXPORT_SYMBOL(pci_dev_present);
411
Alan Cox29f3eb62006-10-16 16:20:21 -0700412/* For boot time work */
413EXPORT_SYMBOL(pci_find_bus);
414EXPORT_SYMBOL(pci_find_next_bus);
415/* For everyone */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416EXPORT_SYMBOL(pci_get_device);
417EXPORT_SYMBOL(pci_get_subsys);
418EXPORT_SYMBOL(pci_get_slot);
Alan Cox29f3eb62006-10-16 16:20:21 -0700419EXPORT_SYMBOL(pci_get_bus_and_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420EXPORT_SYMBOL(pci_get_class);