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