[PATCH] DocBook: fix some descriptions
[linux-2.6.git] / drivers / pci / hotplug.c
1 #include <linux/kernel.h>
2 #include <linux/pci.h>
3 #include <linux/module.h>
4 #include "pci.h"
5
6 int pci_hotplug (struct device *dev, char **envp, int num_envp,
7                  char *buffer, int buffer_size)
8 {
9         struct pci_dev *pdev;
10         char *scratch;
11         int i = 0;
12         int length = 0;
13
14         if (!dev)
15                 return -ENODEV;
16
17         pdev = to_pci_dev(dev);
18         if (!pdev)
19                 return -ENODEV;
20
21         scratch = buffer;
22
23         /* stuff we want to pass to /sbin/hotplug */
24         envp[i++] = scratch;
25         length += scnprintf (scratch, buffer_size - length, "PCI_CLASS=%04X",
26                             pdev->class);
27         if ((buffer_size - length <= 0) || (i >= num_envp))
28                 return -ENOMEM;
29         ++length;
30         scratch += length;
31
32         envp[i++] = scratch;
33         length += scnprintf (scratch, buffer_size - length, "PCI_ID=%04X:%04X",
34                             pdev->vendor, pdev->device);
35         if ((buffer_size - length <= 0) || (i >= num_envp))
36                 return -ENOMEM;
37         ++length;
38         scratch += length;
39
40         envp[i++] = scratch;
41         length += scnprintf (scratch, buffer_size - length,
42                             "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
43                             pdev->subsystem_device);
44         if ((buffer_size - length <= 0) || (i >= num_envp))
45                 return -ENOMEM;
46         ++length;
47         scratch += length;
48
49         envp[i++] = scratch;
50         length += scnprintf (scratch, buffer_size - length, "PCI_SLOT_NAME=%s",
51                             pci_name(pdev));
52         if ((buffer_size - length <= 0) || (i >= num_envp))
53                 return -ENOMEM;
54
55         envp[i] = NULL;
56
57         return 0;
58 }
59
60 static int pci_visit_bus (struct pci_visit * fn, struct pci_bus_wrapped *wrapped_bus, struct pci_dev_wrapped *wrapped_parent)
61 {
62         struct list_head *ln;
63         struct pci_dev *dev;
64         struct pci_dev_wrapped wrapped_dev;
65         int result = 0;
66
67         pr_debug("PCI: Scanning bus %04x:%02x\n", pci_domain_nr(wrapped_bus->bus),
68                 wrapped_bus->bus->number);
69
70         if (fn->pre_visit_pci_bus) {
71                 result = fn->pre_visit_pci_bus(wrapped_bus, wrapped_parent);
72                 if (result)
73                         return result;
74         }
75
76         ln = wrapped_bus->bus->devices.next; 
77         while (ln != &wrapped_bus->bus->devices) {
78                 dev = pci_dev_b(ln);
79                 ln = ln->next;
80
81                 memset(&wrapped_dev, 0, sizeof(struct pci_dev_wrapped));
82                 wrapped_dev.dev = dev;
83
84                 result = pci_visit_dev(fn, &wrapped_dev, wrapped_bus);
85                 if (result)
86                         return result;
87         }
88
89         if (fn->post_visit_pci_bus)
90                 result = fn->post_visit_pci_bus(wrapped_bus, wrapped_parent);
91
92         return result;
93 }
94
95 static int pci_visit_bridge (struct pci_visit * fn,
96                              struct pci_dev_wrapped *wrapped_dev,
97                              struct pci_bus_wrapped *wrapped_parent)
98 {
99         struct pci_bus *bus;
100         struct pci_bus_wrapped wrapped_bus;
101         int result = 0;
102
103         pr_debug("PCI: Scanning bridge %s\n", pci_name(wrapped_dev->dev));
104
105         if (fn->visit_pci_dev) {
106                 result = fn->visit_pci_dev(wrapped_dev, wrapped_parent);
107                 if (result)
108                         return result;
109         }
110
111         bus = wrapped_dev->dev->subordinate;
112         if (bus) {
113                 memset(&wrapped_bus, 0, sizeof(struct pci_bus_wrapped));
114                 wrapped_bus.bus = bus;
115
116                 result = pci_visit_bus(fn, &wrapped_bus, wrapped_dev);
117         }
118         return result;
119 }
120
121 /**
122  * pci_visit_dev - scans the pci buses.
123  * @fn: callback functions that are called while visiting
124  * @wrapped_dev: the device to scan
125  * @wrapped_parent: the bus where @wrapped_dev is connected to
126  *
127  * Every bus and every function is presented to a custom
128  * function that can act upon it.
129  */
130 int pci_visit_dev(struct pci_visit *fn, struct pci_dev_wrapped *wrapped_dev,
131                   struct pci_bus_wrapped *wrapped_parent)
132 {
133         struct pci_dev* dev = wrapped_dev ? wrapped_dev->dev : NULL;
134         int result = 0;
135
136         if (!dev)
137                 return 0;
138
139         if (fn->pre_visit_pci_dev) {
140                 result = fn->pre_visit_pci_dev(wrapped_dev, wrapped_parent);
141                 if (result)
142                         return result;
143         }
144
145         switch (dev->class >> 8) {
146                 case PCI_CLASS_BRIDGE_PCI:
147                         result = pci_visit_bridge(fn, wrapped_dev,
148                                                   wrapped_parent);
149                         if (result)
150                                 return result;
151                         break;
152                 default:
153                         pr_debug("PCI: Scanning device %s\n", pci_name(dev));
154                         if (fn->visit_pci_dev) {
155                                 result = fn->visit_pci_dev (wrapped_dev,
156                                                             wrapped_parent);
157                                 if (result)
158                                         return result;
159                         }
160         }
161
162         if (fn->post_visit_pci_dev)
163                 result = fn->post_visit_pci_dev(wrapped_dev, wrapped_parent);
164
165         return result;
166 }
167 EXPORT_SYMBOL(pci_visit_dev);