use no_pci_devices() in pci/search.c
[linux-2.6.git] / drivers / pci / search.c
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);