e31160216efb382c0541dd838298c59d7702ac55
[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_device *device, int domain, int busnum)
233 {
234         struct pci_bus *bus;
235         struct pci_sysdata *sd;
236         int node;
237 #ifdef CONFIG_ACPI_NUMA
238         int pxm;
239 #endif
240
241         if (domain && !pci_domains_supported) {
242                 printk(KERN_WARNING "pci_bus %04x:%02x: "
243                        "ignored (multiple domains not supported)\n",
244                        domain, busnum);
245                 return NULL;
246         }
247
248         node = -1;
249 #ifdef CONFIG_ACPI_NUMA
250         pxm = acpi_get_pxm(device->handle);
251         if (pxm >= 0)
252                 node = pxm_to_node(pxm);
253         if (node != -1)
254                 set_mp_bus_to_node(busnum, node);
255         else
256 #endif
257                 node = get_mp_bus_to_node(busnum);
258
259         if (node != -1 && !node_online(node))
260                 node = -1;
261
262         /* Allocate per-root-bus (not per bus) arch-specific data.
263          * TODO: leak; this memory is never freed.
264          * It's arguable whether it's worth the trouble to care.
265          */
266         sd = kzalloc(sizeof(*sd), GFP_KERNEL);
267         if (!sd) {
268                 printk(KERN_WARNING "pci_bus %04x:%02x: "
269                        "ignored (out of memory)\n", domain, busnum);
270                 return NULL;
271         }
272
273         sd->domain = domain;
274         sd->node = node;
275         /*
276          * Maybe the desired pci bus has been already scanned. In such case
277          * it is unnecessary to scan the pci bus with the given domain,busnum.
278          */
279         bus = pci_find_bus(domain, busnum);
280         if (bus) {
281                 /*
282                  * If the desired bus exits, the content of bus->sysdata will
283                  * be replaced by sd.
284                  */
285                 memcpy(bus->sysdata, sd, sizeof(*sd));
286                 kfree(sd);
287         } else {
288                 bus = pci_create_bus(NULL, busnum, &pci_root_ops, sd);
289                 if (bus) {
290                         get_current_resources(device, busnum, domain, bus);
291                         bus->subordinate = pci_scan_child_bus(bus);
292                 }
293         }
294
295         if (!bus)
296                 kfree(sd);
297
298         if (bus && node != -1) {
299 #ifdef CONFIG_ACPI_NUMA
300                 if (pxm >= 0)
301                         dev_printk(KERN_DEBUG, &bus->dev,
302                                    "on NUMA node %d (pxm %d)\n", node, pxm);
303 #else
304                 dev_printk(KERN_DEBUG, &bus->dev, "on NUMA node %d\n", node);
305 #endif
306         }
307
308         return bus;
309 }
310
311 int __init pci_acpi_init(void)
312 {
313         struct pci_dev *dev = NULL;
314
315         if (acpi_noirq)
316                 return -ENODEV;
317
318         printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
319         acpi_irq_penalty_init();
320         pcibios_enable_irq = acpi_pci_irq_enable;
321         pcibios_disable_irq = acpi_pci_irq_disable;
322         x86_init.pci.init_irq = x86_init_noop;
323
324         if (pci_routeirq) {
325                 /*
326                  * PCI IRQ routing is set up by pci_enable_device(), but we
327                  * also do it here in case there are still broken drivers that
328                  * don't use pci_enable_device().
329                  */
330                 printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
331                 for_each_pci_dev(dev)
332                         acpi_pci_irq_enable(dev);
333         }
334
335         return 0;
336 }