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