ACPI: pci_root: pass acpi_pci_root to arch-specific scan
[linux-2.6.git] / 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         struct acpi_device *bridge;
11         char *name;
12         unsigned int res_num;
13         struct resource *res;
14         struct pci_bus *bus;
15         int busnum;
16 };
17
18 static bool pci_use_crs = true;
19
20 static int __init set_use_crs(const struct dmi_system_id *id)
21 {
22         pci_use_crs = true;
23         return 0;
24 }
25
26 static const struct dmi_system_id pci_use_crs_table[] __initconst = {
27         /* http://bugzilla.kernel.org/show_bug.cgi?id=14183 */
28         {
29                 .callback = set_use_crs,
30                 .ident = "IBM System x3800",
31                 .matches = {
32                         DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
33                         DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
34                 },
35         },
36         {}
37 };
38
39 void __init pci_acpi_crs_quirks(void)
40 {
41         int year;
42
43         if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year < 2008)
44                 pci_use_crs = false;
45
46         dmi_check_system(pci_use_crs_table);
47
48         /*
49          * If the user specifies "pci=use_crs" or "pci=nocrs" explicitly, that
50          * takes precedence over anything we figured out above.
51          */
52         if (pci_probe & PCI_ROOT_NO_CRS)
53                 pci_use_crs = false;
54         else if (pci_probe & PCI_USE__CRS)
55                 pci_use_crs = true;
56
57         printk(KERN_INFO "PCI: %s host bridge windows from ACPI; "
58                "if necessary, use \"pci=%s\" and report a bug\n",
59                pci_use_crs ? "Using" : "Ignoring",
60                pci_use_crs ? "nocrs" : "use_crs");
61 }
62
63 static acpi_status
64 resource_to_addr(struct acpi_resource *resource,
65                         struct acpi_resource_address64 *addr)
66 {
67         acpi_status status;
68
69         status = acpi_resource_to_address64(resource, addr);
70         if (ACPI_SUCCESS(status) &&
71             (addr->resource_type == ACPI_MEMORY_RANGE ||
72             addr->resource_type == ACPI_IO_RANGE) &&
73             addr->address_length > 0 &&
74             addr->producer_consumer == ACPI_PRODUCER) {
75                 return AE_OK;
76         }
77         return AE_ERROR;
78 }
79
80 static acpi_status
81 count_resource(struct acpi_resource *acpi_res, void *data)
82 {
83         struct pci_root_info *info = data;
84         struct acpi_resource_address64 addr;
85         acpi_status status;
86
87         status = resource_to_addr(acpi_res, &addr);
88         if (ACPI_SUCCESS(status))
89                 info->res_num++;
90         return AE_OK;
91 }
92
93 static void
94 align_resource(struct acpi_device *bridge, struct resource *res)
95 {
96         int align = (res->flags & IORESOURCE_MEM) ? 16 : 4;
97
98         /*
99          * Host bridge windows are not BARs, but the decoders on the PCI side
100          * that claim this address space have starting alignment and length
101          * constraints, so fix any obvious BIOS goofs.
102          */
103         if (!IS_ALIGNED(res->start, align)) {
104                 dev_printk(KERN_DEBUG, &bridge->dev,
105                            "host bridge window %pR invalid; "
106                            "aligning start to %d-byte boundary\n", res, align);
107                 res->start &= ~(align - 1);
108         }
109         if (!IS_ALIGNED(res->end + 1, align)) {
110                 dev_printk(KERN_DEBUG, &bridge->dev,
111                            "host bridge window %pR invalid; "
112                            "aligning end to %d-byte boundary\n", res, align);
113                 res->end = ALIGN(res->end, align) - 1;
114         }
115 }
116
117 static acpi_status
118 setup_resource(struct acpi_resource *acpi_res, void *data)
119 {
120         struct pci_root_info *info = data;
121         struct resource *res;
122         struct acpi_resource_address64 addr;
123         acpi_status status;
124         unsigned long flags;
125         struct resource *root, *conflict;
126         u64 start, end, max_len;
127
128         status = resource_to_addr(acpi_res, &addr);
129         if (!ACPI_SUCCESS(status))
130                 return AE_OK;
131
132         if (addr.resource_type == ACPI_MEMORY_RANGE) {
133                 root = &iomem_resource;
134                 flags = IORESOURCE_MEM;
135                 if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY)
136                         flags |= IORESOURCE_PREFETCH;
137         } else if (addr.resource_type == ACPI_IO_RANGE) {
138                 root = &ioport_resource;
139                 flags = IORESOURCE_IO;
140         } else
141                 return AE_OK;
142
143         max_len = addr.maximum - addr.minimum + 1;
144         if (addr.address_length > max_len) {
145                 dev_printk(KERN_DEBUG, &info->bridge->dev,
146                            "host bridge window length %#llx doesn't fit in "
147                            "%#llx-%#llx, trimming\n",
148                            (unsigned long long) addr.address_length,
149                            (unsigned long long) addr.minimum,
150                            (unsigned long long) addr.maximum);
151                 addr.address_length = max_len;
152         }
153
154         start = addr.minimum + addr.translation_offset;
155         end = start + addr.address_length - 1;
156
157         res = &info->res[info->res_num];
158         res->name = info->name;
159         res->flags = flags;
160         res->start = start;
161         res->end = end;
162         res->child = NULL;
163         align_resource(info->bridge, res);
164
165         if (!pci_use_crs) {
166                 dev_printk(KERN_DEBUG, &info->bridge->dev,
167                            "host bridge window %pR (ignored)\n", res);
168                 return AE_OK;
169         }
170
171         conflict = insert_resource_conflict(root, res);
172         if (conflict) {
173                 dev_err(&info->bridge->dev,
174                         "address space collision: host bridge window %pR "
175                         "conflicts with %s %pR\n",
176                         res, conflict->name, conflict);
177         } else {
178                 pci_bus_add_resource(info->bus, res, 0);
179                 info->res_num++;
180                 if (addr.translation_offset)
181                         dev_info(&info->bridge->dev, "host bridge window %pR "
182                                  "(PCI address [%#llx-%#llx])\n",
183                                  res, res->start - addr.translation_offset,
184                                  res->end - addr.translation_offset);
185                 else
186                         dev_info(&info->bridge->dev,
187                                  "host bridge window %pR\n", res);
188         }
189         return AE_OK;
190 }
191
192 static void
193 get_current_resources(struct acpi_device *device, int busnum,
194                         int domain, struct pci_bus *bus)
195 {
196         struct pci_root_info info;
197         size_t size;
198
199         if (pci_use_crs)
200                 pci_bus_remove_resources(bus);
201
202         info.bridge = device;
203         info.bus = bus;
204         info.res_num = 0;
205         acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource,
206                                 &info);
207         if (!info.res_num)
208                 return;
209
210         size = sizeof(*info.res) * info.res_num;
211         info.res = kmalloc(size, GFP_KERNEL);
212         if (!info.res)
213                 goto res_alloc_fail;
214
215         info.name = kmalloc(16, GFP_KERNEL);
216         if (!info.name)
217                 goto name_alloc_fail;
218         sprintf(info.name, "PCI Bus %04x:%02x", domain, busnum);
219
220         info.res_num = 0;
221         acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource,
222                                 &info);
223
224         return;
225
226 name_alloc_fail:
227         kfree(info.res);
228 res_alloc_fail:
229         return;
230 }
231
232 struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_pci_root *root)
233 {
234         struct acpi_device *device = root->device;
235         int domain = root->segment;
236         int busnum = root->secondary.start;
237         struct pci_bus *bus;
238         struct pci_sysdata *sd;
239         int node;
240 #ifdef CONFIG_ACPI_NUMA
241         int pxm;
242 #endif
243
244         if (domain && !pci_domains_supported) {
245                 printk(KERN_WARNING "pci_bus %04x:%02x: "
246                        "ignored (multiple domains not supported)\n",
247                        domain, busnum);
248                 return NULL;
249         }
250
251         node = -1;
252 #ifdef CONFIG_ACPI_NUMA
253         pxm = acpi_get_pxm(device->handle);
254         if (pxm >= 0)
255                 node = pxm_to_node(pxm);
256         if (node != -1)
257                 set_mp_bus_to_node(busnum, node);
258         else
259 #endif
260                 node = get_mp_bus_to_node(busnum);
261
262         if (node != -1 && !node_online(node))
263                 node = -1;
264
265         /* Allocate per-root-bus (not per bus) arch-specific data.
266          * TODO: leak; this memory is never freed.
267          * It's arguable whether it's worth the trouble to care.
268          */
269         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
270         if (!sd) {
271                 printk(KERN_WARNING "pci_bus %04x:%02x: "
272                        "ignored (out of memory)\n", domain, busnum);
273                 return NULL;
274         }
275
276         sd->domain = domain;
277         sd->node = node;
278         /*
279          * Maybe the desired pci bus has been already scanned. In such case
280          * it is unnecessary to scan the pci bus with the given domain,busnum.
281          */
282         bus = pci_find_bus(domain, busnum);
283         if (bus) {
284                 /*
285                  * If the desired bus exits, the content of bus->sysdata will
286                  * be replaced by sd.
287                  */
288                 memcpy(bus->sysdata, sd, sizeof(*sd));
289                 kfree(sd);
290         } else {
291                 bus = pci_create_bus(NULL, busnum, &pci_root_ops, sd);
292                 if (bus) {
293                         get_current_resources(device, busnum, domain, bus);
294                         bus->subordinate = pci_scan_child_bus(bus);
295                 }
296         }
297
298         if (!bus)
299                 kfree(sd);
300
301         if (bus && node != -1) {
302 #ifdef CONFIG_ACPI_NUMA
303                 if (pxm >= 0)
304                         dev_printk(KERN_DEBUG, &bus->dev,
305                                    "on NUMA node %d (pxm %d)\n", node, pxm);
306 #else
307                 dev_printk(KERN_DEBUG, &bus->dev, "on NUMA node %d\n", node);
308 #endif
309         }
310
311         return bus;
312 }
313
314 int __init pci_acpi_init(void)
315 {
316         struct pci_dev *dev = NULL;
317
318         if (acpi_noirq)
319                 return -ENODEV;
320
321         printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
322         acpi_irq_penalty_init();
323         pcibios_enable_irq = acpi_pci_irq_enable;
324         pcibios_disable_irq = acpi_pci_irq_disable;
325         x86_init.pci.init_irq = x86_init_noop;
326
327         if (pci_routeirq) {
328                 /*
329                  * PCI IRQ routing is set up by pci_enable_device(), but we
330                  * also do it here in case there are still broken drivers that
331                  * don't use pci_enable_device().
332                  */
333                 printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
334                 for_each_pci_dev(dev)
335                         acpi_pci_irq_enable(dev);
336         }
337
338         return 0;
339 }