pci: do not mark exported functions as __devinit
[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 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  * Given a PCI bus and slot/function number, the desired PCI device
149  * is located in system global list of PCI devices.  If the device
150  * is found, a pointer to its data structure is returned.  If no
151  * device is found, %NULL is returned. The returned device has its
152  * reference count bumped by one.
153  */
154
155 struct pci_dev * pci_get_bus_and_slot(unsigned int bus, unsigned int devfn)
156 {
157         struct pci_dev *dev = NULL;
158
159         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
160                 if (dev->bus->number == bus && dev->devfn == devfn)
161                         return dev;
162         }
163         return NULL;
164 }
165
166 /**
167  * pci_find_subsys - begin or continue searching for a PCI device by vendor/subvendor/device/subdevice id
168  * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
169  * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
170  * @ss_vendor: PCI subsystem vendor id to match, or %PCI_ANY_ID to match all vendor ids
171  * @ss_device: PCI subsystem device id to match, or %PCI_ANY_ID to match all device ids
172  * @from: Previous PCI device found in search, or %NULL for new search.
173  *
174  * Iterates through the list of known PCI devices.  If a PCI device is
175  * found with a matching @vendor, @device, @ss_vendor and @ss_device, a
176  * pointer to its device structure is returned.  Otherwise, %NULL is returned.
177  * A new search is initiated by passing %NULL as the @from argument.
178  * Otherwise if @from is not %NULL, searches continue from next device
179  * on the global list.
180  *
181  * NOTE: Do not use this function any more; use pci_get_subsys() instead, as
182  * the PCI device returned by this function can disappear at any moment in
183  * time.
184  */
185 static struct pci_dev * pci_find_subsys(unsigned int vendor,
186                                         unsigned int device,
187                                         unsigned int ss_vendor,
188                                         unsigned int ss_device,
189                                         const struct pci_dev *from)
190 {
191         struct list_head *n;
192         struct pci_dev *dev;
193
194         WARN_ON(in_interrupt());
195
196         /*
197          * pci_find_subsys() can be called on the ide_setup() path, super-early
198          * in boot.  But the down_read() will enable local interrupts, which
199          * can cause some machines to crash.  So here we detect and flag that
200          * situation and bail out early.
201          */
202         if (unlikely(list_empty(&pci_devices)))
203                 return NULL;
204         down_read(&pci_bus_sem);
205         n = from ? from->global_list.next : pci_devices.next;
206
207         while (n && (n != &pci_devices)) {
208                 dev = pci_dev_g(n);
209                 if ((vendor == PCI_ANY_ID || dev->vendor == vendor) &&
210                     (device == PCI_ANY_ID || dev->device == device) &&
211                     (ss_vendor == PCI_ANY_ID || dev->subsystem_vendor == ss_vendor) &&
212                     (ss_device == PCI_ANY_ID || dev->subsystem_device == ss_device))
213                         goto exit;
214                 n = n->next;
215         }
216         dev = NULL;
217 exit:
218         up_read(&pci_bus_sem);
219         return dev;
220 }
221
222 /**
223  * pci_find_device - begin or continue searching for a PCI device by vendor/device id
224  * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
225  * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
226  * @from: Previous PCI device found in search, or %NULL for new search.
227  *
228  * Iterates through the list of known PCI devices.  If a PCI device is found
229  * with a matching @vendor and @device, a pointer to its device structure is
230  * returned.  Otherwise, %NULL is returned.
231  * A new search is initiated by passing %NULL as the @from argument.
232  * Otherwise if @from is not %NULL, searches continue from next device
233  * on the global list.
234  * 
235  * NOTE: Do not use this function any more; use pci_get_device() instead, as
236  * the PCI device returned by this function can disappear at any moment in
237  * time.
238  */
239 struct pci_dev *
240 pci_find_device(unsigned int vendor, unsigned int device, const struct pci_dev *from)
241 {
242         return pci_find_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from);
243 }
244
245 /**
246  * pci_get_subsys - begin or continue searching for a PCI device by vendor/subvendor/device/subdevice id
247  * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
248  * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
249  * @ss_vendor: PCI subsystem vendor id to match, or %PCI_ANY_ID to match all vendor ids
250  * @ss_device: PCI subsystem device id to match, or %PCI_ANY_ID to match all device ids
251  * @from: Previous PCI device found in search, or %NULL for new search.
252  *
253  * Iterates through the list of known PCI devices.  If a PCI device is found
254  * with a matching @vendor, @device, @ss_vendor and @ss_device, a pointer to its
255  * device structure is returned, and the reference count to the device is
256  * incremented.  Otherwise, %NULL is returned.  A new search is initiated by
257  * passing %NULL as the @from argument.  Otherwise if @from is not %NULL,
258  * searches continue from next device on the global list.
259  * The reference count for @from is always decremented if it is not %NULL.
260  */
261 struct pci_dev * 
262 pci_get_subsys(unsigned int vendor, unsigned int device,
263                unsigned int ss_vendor, unsigned int ss_device,
264                struct pci_dev *from)
265 {
266         struct list_head *n;
267         struct pci_dev *dev;
268
269         WARN_ON(in_interrupt());
270
271         /*
272          * pci_get_subsys() can potentially be called by drivers super-early
273          * in boot.  But the down_read() will enable local interrupts, which
274          * can cause some machines to crash.  So here we detect and flag that
275          * situation and bail out early.
276          */
277         if (unlikely(list_empty(&pci_devices)))
278                 return NULL;
279         down_read(&pci_bus_sem);
280         n = from ? from->global_list.next : pci_devices.next;
281
282         while (n && (n != &pci_devices)) {
283                 dev = pci_dev_g(n);
284                 if ((vendor == PCI_ANY_ID || dev->vendor == vendor) &&
285                     (device == PCI_ANY_ID || dev->device == device) &&
286                     (ss_vendor == PCI_ANY_ID || dev->subsystem_vendor == ss_vendor) &&
287                     (ss_device == PCI_ANY_ID || dev->subsystem_device == ss_device))
288                         goto exit;
289                 n = n->next;
290         }
291         dev = NULL;
292 exit:
293         dev = pci_dev_get(dev);
294         up_read(&pci_bus_sem);
295         pci_dev_put(from);
296         return dev;
297 }
298
299 /**
300  * pci_get_device - begin or continue searching for a PCI device by vendor/device id
301  * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
302  * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
303  * @from: Previous PCI device found in search, or %NULL for new search.
304  *
305  * Iterates through the list of known PCI devices.  If a PCI device is
306  * found with a matching @vendor and @device, the reference count to the
307  * device is incremented and a pointer to its device structure is returned.
308  * Otherwise, %NULL is returned.  A new search is initiated by passing %NULL
309  * as the @from argument.  Otherwise if @from is not %NULL, searches continue
310  * from next device on the global list.  The reference count for @from is
311  * always decremented if it is not %NULL.
312  */
313 struct pci_dev *
314 pci_get_device(unsigned int vendor, unsigned int device, struct pci_dev *from)
315 {
316         return pci_get_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from);
317 }
318
319 /**
320  * pci_get_device_reverse - begin or continue searching for a PCI device by vendor/device id
321  * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
322  * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
323  * @from: Previous PCI device found in search, or %NULL for new search.
324  *
325  * Iterates through the list of known PCI devices in the reverse order of
326  * pci_get_device.
327  * If a PCI device is found with a matching @vendor and @device, the reference
328  * count to the  device is incremented and a pointer to its device structure
329  * is returned Otherwise, %NULL is returned.  A new search is initiated by
330  * passing %NULL as the @from argument.  Otherwise if @from is not %NULL,
331  * searches continue from next device on the global list.  The reference
332  * count for @from is always decremented if it is not %NULL.
333  */
334 struct pci_dev *
335 pci_get_device_reverse(unsigned int vendor, unsigned int device, struct pci_dev *from)
336 {
337         struct list_head *n;
338         struct pci_dev *dev;
339
340         WARN_ON(in_interrupt());
341         down_read(&pci_bus_sem);
342         n = from ? from->global_list.prev : pci_devices.prev;
343
344         while (n && (n != &pci_devices)) {
345                 dev = pci_dev_g(n);
346                 if ((vendor == PCI_ANY_ID || dev->vendor == vendor) &&
347                     (device == PCI_ANY_ID || dev->device == device))
348                         goto exit;
349                 n = n->prev;
350         }
351         dev = NULL;
352 exit:
353         dev = pci_dev_get(dev);
354         up_read(&pci_bus_sem);
355         pci_dev_put(from);
356         return dev;
357 }
358
359 /**
360  * pci_get_class - begin or continue searching for a PCI device by class
361  * @class: search for a PCI device with this class designation
362  * @from: Previous PCI device found in search, or %NULL for new search.
363  *
364  * Iterates through the list of known PCI devices.  If a PCI device is
365  * found with a matching @class, the reference count to the device is
366  * incremented and a pointer to its device structure is returned.
367  * Otherwise, %NULL is returned.
368  * A new search is initiated by passing %NULL as the @from argument.
369  * Otherwise if @from is not %NULL, searches continue from next device
370  * on the global list.  The reference count for @from is always decremented
371  * if it is not %NULL.
372  */
373 struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from)
374 {
375         struct list_head *n;
376         struct pci_dev *dev;
377
378         WARN_ON(in_interrupt());
379         down_read(&pci_bus_sem);
380         n = from ? from->global_list.next : pci_devices.next;
381
382         while (n && (n != &pci_devices)) {
383                 dev = pci_dev_g(n);
384                 if (dev->class == class)
385                         goto exit;
386                 n = n->next;
387         }
388         dev = NULL;
389 exit:
390         dev = pci_dev_get(dev);
391         up_read(&pci_bus_sem);
392         pci_dev_put(from);
393         return dev;
394 }
395
396 const struct pci_device_id *pci_find_present(const struct pci_device_id *ids)
397 {
398         struct pci_dev *dev;
399         const struct pci_device_id *found = NULL;
400
401         WARN_ON(in_interrupt());
402         down_read(&pci_bus_sem);
403         while (ids->vendor || ids->subvendor || ids->class_mask) {
404                 list_for_each_entry(dev, &pci_devices, global_list) {
405                         if ((found = pci_match_one_device(ids, dev)) != NULL)
406                                 break;
407                 }
408                 ids++;
409         }
410         up_read(&pci_bus_sem);
411         return found;
412 }
413
414 /**
415  * pci_dev_present - Returns 1 if device matching the device list is present, 0 if not.
416  * @ids: A pointer to a null terminated list of struct pci_device_id structures
417  * that describe the type of PCI device the caller is trying to find.
418  *
419  * Obvious fact: You do not have a reference to any device that might be found
420  * by this function, so if that device is removed from the system right after
421  * this function is finished, the value will be stale.  Use this function to
422  * find devices that are usually built into a system, or for a general hint as
423  * to if another device happens to be present at this specific moment in time.
424  */
425 int pci_dev_present(const struct pci_device_id *ids)
426 {
427         return pci_find_present(ids) == NULL ? 0 : 1;
428 }
429
430 EXPORT_SYMBOL(pci_dev_present);
431 EXPORT_SYMBOL(pci_find_present);
432
433 EXPORT_SYMBOL(pci_find_device);
434 EXPORT_SYMBOL(pci_find_slot);
435 /* For boot time work */
436 EXPORT_SYMBOL(pci_find_bus);
437 EXPORT_SYMBOL(pci_find_next_bus);
438 /* For everyone */
439 EXPORT_SYMBOL(pci_get_device);
440 EXPORT_SYMBOL(pci_get_device_reverse);
441 EXPORT_SYMBOL(pci_get_subsys);
442 EXPORT_SYMBOL(pci_get_slot);
443 EXPORT_SYMBOL(pci_get_bus_and_slot);
444 EXPORT_SYMBOL(pci_get_class);