Merge branch 'perfcounters-fixes-for-linus' of git://git.kernel.org/pub/scm/linux...
[linux-2.6] / arch / x86 / pci / acpi.c
1 #include <linux/pci.h>
2 #include <linux/acpi.h>
3 #include <linux/init.h>
4 #include <linux/irq.h>
5 #include <linux/dmi.h>
6 #include <asm/numa.h>
7 #include <asm/pci_x86.h>
8
9 struct pci_root_info {
10         char *name;
11         unsigned int res_num;
12         struct resource *res;
13         struct pci_bus *bus;
14         int busnum;
15 };
16
17 static acpi_status
18 resource_to_addr(struct acpi_resource *resource,
19                         struct acpi_resource_address64 *addr)
20 {
21         acpi_status status;
22
23         status = acpi_resource_to_address64(resource, addr);
24         if (ACPI_SUCCESS(status) &&
25             (addr->resource_type == ACPI_MEMORY_RANGE ||
26             addr->resource_type == ACPI_IO_RANGE) &&
27             addr->address_length > 0 &&
28             addr->producer_consumer == ACPI_PRODUCER) {
29                 return AE_OK;
30         }
31         return AE_ERROR;
32 }
33
34 static acpi_status
35 count_resource(struct acpi_resource *acpi_res, void *data)
36 {
37         struct pci_root_info *info = data;
38         struct acpi_resource_address64 addr;
39         acpi_status status;
40
41         status = resource_to_addr(acpi_res, &addr);
42         if (ACPI_SUCCESS(status))
43                 info->res_num++;
44         return AE_OK;
45 }
46
47 static int
48 bus_has_transparent_bridge(struct pci_bus *bus)
49 {
50         struct pci_dev *dev;
51
52         list_for_each_entry(dev, &bus->devices, bus_list) {
53                 u16 class = dev->class >> 8;
54
55                 if (class == PCI_CLASS_BRIDGE_PCI && dev->transparent)
56                         return true;
57         }
58         return false;
59 }
60
61 static acpi_status
62 setup_resource(struct acpi_resource *acpi_res, void *data)
63 {
64         struct pci_root_info *info = data;
65         struct resource *res;
66         struct acpi_resource_address64 addr;
67         acpi_status status;
68         unsigned long flags;
69         struct resource *root;
70         int max_root_bus_resources = PCI_BUS_NUM_RESOURCES;
71
72         status = resource_to_addr(acpi_res, &addr);
73         if (!ACPI_SUCCESS(status))
74                 return AE_OK;
75
76         if (addr.resource_type == ACPI_MEMORY_RANGE) {
77                 root = &iomem_resource;
78                 flags = IORESOURCE_MEM;
79                 if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY)
80                         flags |= IORESOURCE_PREFETCH;
81         } else if (addr.resource_type == ACPI_IO_RANGE) {
82                 root = &ioport_resource;
83                 flags = IORESOURCE_IO;
84         } else
85                 return AE_OK;
86
87         res = &info->res[info->res_num];
88         res->name = info->name;
89         res->flags = flags;
90         res->start = addr.minimum + addr.translation_offset;
91         res->end = res->start + addr.address_length - 1;
92         res->child = NULL;
93
94         if (bus_has_transparent_bridge(info->bus))
95                 max_root_bus_resources -= 3;
96         if (info->res_num >= max_root_bus_resources) {
97                 printk(KERN_WARNING "PCI: Failed to allocate 0x%lx-0x%lx "
98                         "from %s for %s due to _CRS returning more than "
99                         "%d resource descriptors\n", (unsigned long) res->start,
100                         (unsigned long) res->end, root->name, info->name,
101                         max_root_bus_resources);
102                 info->res_num++;
103                 return AE_OK;
104         }
105
106         if (insert_resource(root, res)) {
107                 printk(KERN_ERR "PCI: Failed to allocate 0x%lx-0x%lx "
108                         "from %s for %s\n", (unsigned long) res->start,
109                         (unsigned long) res->end, root->name, info->name);
110         } else {
111                 info->bus->resource[info->res_num] = res;
112                 info->res_num++;
113         }
114         return AE_OK;
115 }
116
117 static void
118 adjust_transparent_bridge_resources(struct pci_bus *bus)
119 {
120         struct pci_dev *dev;
121
122         list_for_each_entry(dev, &bus->devices, bus_list) {
123                 int i;
124                 u16 class = dev->class >> 8;
125
126                 if (class == PCI_CLASS_BRIDGE_PCI && dev->transparent) {
127                         for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
128                                 dev->subordinate->resource[i] =
129                                                 dev->bus->resource[i - 3];
130                 }
131         }
132 }
133
134 static void
135 get_current_resources(struct acpi_device *device, int busnum,
136                         int domain, struct pci_bus *bus)
137 {
138         struct pci_root_info info;
139         size_t size;
140
141         info.bus = bus;
142         info.res_num = 0;
143         acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource,
144                                 &info);
145         if (!info.res_num)
146                 return;
147
148         size = sizeof(*info.res) * info.res_num;
149         info.res = kmalloc(size, GFP_KERNEL);
150         if (!info.res)
151                 goto res_alloc_fail;
152
153         info.name = kmalloc(16, GFP_KERNEL);
154         if (!info.name)
155                 goto name_alloc_fail;
156         sprintf(info.name, "PCI Bus %04x:%02x", domain, busnum);
157
158         info.res_num = 0;
159         acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource,
160                                 &info);
161         if (info.res_num)
162                 adjust_transparent_bridge_resources(bus);
163
164         return;
165
166 name_alloc_fail:
167         kfree(info.res);
168 res_alloc_fail:
169         return;
170 }
171
172 struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_device *device, int domain, int busnum)
173 {
174         struct pci_bus *bus;
175         struct pci_sysdata *sd;
176         int node;
177 #ifdef CONFIG_ACPI_NUMA
178         int pxm;
179 #endif
180
181         if (domain && !pci_domains_supported) {
182                 printk(KERN_WARNING "PCI: Multiple domains not supported "
183                        "(dom %d, bus %d)\n", domain, busnum);
184                 return NULL;
185         }
186
187         node = -1;
188 #ifdef CONFIG_ACPI_NUMA
189         pxm = acpi_get_pxm(device->handle);
190         if (pxm >= 0)
191                 node = pxm_to_node(pxm);
192         if (node != -1)
193                 set_mp_bus_to_node(busnum, node);
194         else
195 #endif
196                 node = get_mp_bus_to_node(busnum);
197
198         if (node != -1 && !node_online(node))
199                 node = -1;
200
201         /* Allocate per-root-bus (not per bus) arch-specific data.
202          * TODO: leak; this memory is never freed.
203          * It's arguable whether it's worth the trouble to care.
204          */
205         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
206         if (!sd) {
207                 printk(KERN_ERR "PCI: OOM, not probing PCI bus %02x\n", busnum);
208                 return NULL;
209         }
210
211         sd->domain = domain;
212         sd->node = node;
213         /*
214          * Maybe the desired pci bus has been already scanned. In such case
215          * it is unnecessary to scan the pci bus with the given domain,busnum.
216          */
217         bus = pci_find_bus(domain, busnum);
218         if (bus) {
219                 /*
220                  * If the desired bus exits, the content of bus->sysdata will
221                  * be replaced by sd.
222                  */
223                 memcpy(bus->sysdata, sd, sizeof(*sd));
224                 kfree(sd);
225         } else
226                 bus = pci_scan_bus_parented(NULL, busnum, &pci_root_ops, sd);
227
228         if (!bus)
229                 kfree(sd);
230
231         if (bus && node != -1) {
232 #ifdef CONFIG_ACPI_NUMA
233                 if (pxm >= 0)
234                         dev_printk(KERN_DEBUG, &bus->dev,
235                                    "on NUMA node %d (pxm %d)\n", node, pxm);
236 #else
237                 dev_printk(KERN_DEBUG, &bus->dev, "on NUMA node %d\n", node);
238 #endif
239         }
240
241         if (bus && (pci_probe & PCI_USE__CRS))
242                 get_current_resources(device, busnum, domain, bus);
243         return bus;
244 }
245
246 int __init pci_acpi_init(void)
247 {
248         struct pci_dev *dev = NULL;
249
250         if (pcibios_scanned)
251                 return 0;
252
253         if (acpi_noirq)
254                 return 0;
255
256         printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
257         acpi_irq_penalty_init();
258         pcibios_scanned++;
259         pcibios_enable_irq = acpi_pci_irq_enable;
260         pcibios_disable_irq = acpi_pci_irq_disable;
261
262         if (pci_routeirq) {
263                 /*
264                  * PCI IRQ routing is set up by pci_enable_device(), but we
265                  * also do it here in case there are still broken drivers that
266                  * don't use pci_enable_device().
267                  */
268                 printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
269                 for_each_pci_dev(dev)
270                         acpi_pci_irq_enable(dev);
271         }
272
273         return 0;
274 }