blob: 4f25ec0775526f45133d9087bc13fd4f76dfb24e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#include <linux/pci.h>
2#include <linux/acpi.h>
3#include <linux/init.h>
Nick Pigginb33fa1f2005-10-01 02:34:42 +10004#include <linux/irq.h>
Gary Hade036fff42007-10-03 15:56:14 -07005#include <linux/dmi.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09006#include <linux/slab.h>
Andi Kleen69e1a332005-09-12 18:49:24 +02007#include <asm/numa.h>
Jaswinder Singh Rajput82487712008-12-27 18:32:28 +05308#include <asm/pci_x86.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009
Gary Hade62f420f2007-10-03 15:56:51 -070010struct pci_root_info {
Bjorn Helgaas42887b22009-10-06 15:33:49 -060011 struct acpi_device *bridge;
Yinghai Lufe057252012-04-02 18:31:53 -070012 char name[16];
Gary Hade62f420f2007-10-03 15:56:51 -070013 unsigned int res_num;
14 struct resource *res;
Mike Yoknisb4873932012-11-07 15:52:20 -070015 resource_size_t *res_offset;
Yinghai Lu35cb05e2012-04-02 18:31:53 -070016 struct pci_sysdata sd;
Jiang Liuc0fa4072012-06-22 14:55:17 +080017#ifdef CONFIG_PCI_MMCONFIG
18 bool mcfg_added;
19 u16 segment;
20 u8 start_bus;
21 u8 end_bus;
22#endif
Gary Hade62f420f2007-10-03 15:56:51 -070023};
24
Bjorn Helgaas7bc5e3f2010-02-23 10:24:41 -070025static bool pci_use_crs = true;
Bjorn Helgaas1f09b092012-10-29 17:26:54 -060026static bool pci_ignore_seg = false;
Bjorn Helgaas7bc5e3f2010-02-23 10:24:41 -070027
28static int __init set_use_crs(const struct dmi_system_id *id)
29{
30 pci_use_crs = true;
31 return 0;
32}
33
Dave Jones28c3c052011-12-30 14:37:05 -050034static int __init set_nouse_crs(const struct dmi_system_id *id)
35{
36 pci_use_crs = false;
37 return 0;
38}
39
Bjorn Helgaas1f09b092012-10-29 17:26:54 -060040static int __init set_ignore_seg(const struct dmi_system_id *id)
41{
42 printk(KERN_INFO "PCI: %s detected: ignoring ACPI _SEG\n", id->ident);
43 pci_ignore_seg = true;
44 return 0;
45}
46
47static const struct dmi_system_id pci_crs_quirks[] __initconst = {
Bjorn Helgaas7bc5e3f2010-02-23 10:24:41 -070048 /* http://bugzilla.kernel.org/show_bug.cgi?id=14183 */
49 {
50 .callback = set_use_crs,
51 .ident = "IBM System x3800",
52 .matches = {
53 DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
54 DMI_MATCH(DMI_PRODUCT_NAME, "x3800"),
55 },
56 },
Bjorn Helgaas24917622010-07-23 12:53:27 -060057 /* https://bugzilla.kernel.org/show_bug.cgi?id=16007 */
58 /* 2006 AMD HT/VIA system with two host bridges */
59 {
60 .callback = set_use_crs,
61 .ident = "ASRock ALiveSATA2-GLAN",
62 .matches = {
63 DMI_MATCH(DMI_PRODUCT_NAME, "ALiveSATA2-GLAN"),
64 },
65 },
Paul Menzel29cf7a302011-08-31 17:07:10 +020066 /* https://bugzilla.kernel.org/show_bug.cgi?id=30552 */
67 /* 2006 AMD HT/VIA system with two host bridges */
68 {
69 .callback = set_use_crs,
70 .ident = "ASUS M2V-MX SE",
71 .matches = {
72 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
73 DMI_MATCH(DMI_BOARD_NAME, "M2V-MX SE"),
74 DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
75 },
76 },
Jonathan Nieder841137172012-02-28 11:51:10 -070077 /* https://bugzilla.kernel.org/show_bug.cgi?id=42619 */
78 {
79 .callback = set_use_crs,
80 .ident = "MSI MS-7253",
81 .matches = {
82 DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"),
83 DMI_MATCH(DMI_BOARD_NAME, "MS-7253"),
84 DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
Jonathan Nieder841137172012-02-28 11:51:10 -070085 },
86 },
Dave Jones28c3c052011-12-30 14:37:05 -050087
Dave Jonese7027812012-01-04 11:33:12 -050088 /* Now for the blacklist.. */
89
90 /* https://bugzilla.redhat.com/show_bug.cgi?id=769657 */
91 {
92 .callback = set_nouse_crs,
93 .ident = "Dell Studio 1557",
94 .matches = {
95 DMI_MATCH(DMI_BOARD_VENDOR, "Dell Inc."),
96 DMI_MATCH(DMI_PRODUCT_NAME, "Studio 1557"),
97 DMI_MATCH(DMI_BIOS_VERSION, "A09"),
98 },
99 },
Dave Jones8b6a5af2012-01-04 11:30:52 -0500100 /* https://bugzilla.redhat.com/show_bug.cgi?id=769657 */
101 {
102 .callback = set_nouse_crs,
103 .ident = "Thinkpad SL510",
104 .matches = {
105 DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
106 DMI_MATCH(DMI_BOARD_NAME, "2847DFG"),
107 DMI_MATCH(DMI_BIOS_VERSION, "6JET85WW (1.43 )"),
108 },
109 },
Bjorn Helgaas1f09b092012-10-29 17:26:54 -0600110
111 /* https://bugzilla.kernel.org/show_bug.cgi?id=15362 */
112 {
113 .callback = set_ignore_seg,
114 .ident = "HP xw9300",
115 .matches = {
116 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
117 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw9300 Workstation"),
118 },
119 },
Bjorn Helgaas7bc5e3f2010-02-23 10:24:41 -0700120 {}
121};
122
123void __init pci_acpi_crs_quirks(void)
124{
125 int year;
126
127 if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year < 2008)
128 pci_use_crs = false;
129
Bjorn Helgaas1f09b092012-10-29 17:26:54 -0600130 dmi_check_system(pci_crs_quirks);
Bjorn Helgaas7bc5e3f2010-02-23 10:24:41 -0700131
132 /*
133 * If the user specifies "pci=use_crs" or "pci=nocrs" explicitly, that
134 * takes precedence over anything we figured out above.
135 */
136 if (pci_probe & PCI_ROOT_NO_CRS)
137 pci_use_crs = false;
138 else if (pci_probe & PCI_USE__CRS)
139 pci_use_crs = true;
140
141 printk(KERN_INFO "PCI: %s host bridge windows from ACPI; "
142 "if necessary, use \"pci=%s\" and report a bug\n",
143 pci_use_crs ? "Using" : "Ignoring",
144 pci_use_crs ? "nocrs" : "use_crs");
145}
146
Jiang Liuc0fa4072012-06-22 14:55:17 +0800147#ifdef CONFIG_PCI_MMCONFIG
Greg Kroah-Hartmana18e3692012-12-21 14:02:53 -0800148static int check_segment(u16 seg, struct device *dev, char *estr)
Jiang Liuc0fa4072012-06-22 14:55:17 +0800149{
150 if (seg) {
151 dev_err(dev,
152 "%s can't access PCI configuration "
153 "space under this host bridge.\n",
154 estr);
155 return -EIO;
156 }
157
158 /*
159 * Failure in adding MMCFG information is not fatal,
160 * just can't access extended configuration space of
161 * devices under this host bridge.
162 */
163 dev_warn(dev,
164 "%s can't access extended PCI configuration "
165 "space under this bridge.\n",
166 estr);
167
168 return 0;
169}
170
Greg Kroah-Hartmana18e3692012-12-21 14:02:53 -0800171static int setup_mcfg_map(struct pci_root_info *info, u16 seg, u8 start,
172 u8 end, phys_addr_t addr)
Jiang Liuc0fa4072012-06-22 14:55:17 +0800173{
174 int result;
175 struct device *dev = &info->bridge->dev;
176
177 info->start_bus = start;
178 info->end_bus = end;
179 info->mcfg_added = false;
180
181 /* return success if MMCFG is not in use */
182 if (raw_pci_ext_ops && raw_pci_ext_ops != &pci_mmcfg)
183 return 0;
184
185 if (!(pci_probe & PCI_PROBE_MMCONF))
186 return check_segment(seg, dev, "MMCONFIG is disabled,");
187
188 result = pci_mmconfig_insert(dev, seg, start, end, addr);
189 if (result == 0) {
190 /* enable MMCFG if it hasn't been enabled yet */
191 if (raw_pci_ext_ops == NULL)
192 raw_pci_ext_ops = &pci_mmcfg;
193 info->mcfg_added = true;
194 } else if (result != -EEXIST)
195 return check_segment(seg, dev,
196 "fail to add MMCONFIG information,");
197
198 return 0;
199}
200
201static void teardown_mcfg_map(struct pci_root_info *info)
202{
203 if (info->mcfg_added) {
204 pci_mmconfig_delete(info->segment, info->start_bus,
205 info->end_bus);
206 info->mcfg_added = false;
207 }
208}
209#else
Greg Kroah-Hartmana18e3692012-12-21 14:02:53 -0800210static int setup_mcfg_map(struct pci_root_info *info,
Jiang Liuc0fa4072012-06-22 14:55:17 +0800211 u16 seg, u8 start, u8 end,
212 phys_addr_t addr)
213{
214 return 0;
215}
216static void teardown_mcfg_map(struct pci_root_info *info)
217{
218}
219#endif
220
Gary Hade62f420f2007-10-03 15:56:51 -0700221static acpi_status
222resource_to_addr(struct acpi_resource *resource,
223 struct acpi_resource_address64 *addr)
224{
225 acpi_status status;
Bjorn Helgaas66528fd2010-04-20 13:52:41 -0600226 struct acpi_resource_memory24 *memory24;
227 struct acpi_resource_memory32 *memory32;
228 struct acpi_resource_fixed_memory32 *fixed_memory32;
Gary Hade62f420f2007-10-03 15:56:51 -0700229
Bjorn Helgaas66528fd2010-04-20 13:52:41 -0600230 memset(addr, 0, sizeof(*addr));
231 switch (resource->type) {
232 case ACPI_RESOURCE_TYPE_MEMORY24:
233 memory24 = &resource->data.memory24;
234 addr->resource_type = ACPI_MEMORY_RANGE;
235 addr->minimum = memory24->minimum;
236 addr->address_length = memory24->address_length;
237 addr->maximum = addr->minimum + addr->address_length - 1;
Gary Hade62f420f2007-10-03 15:56:51 -0700238 return AE_OK;
Bjorn Helgaas66528fd2010-04-20 13:52:41 -0600239 case ACPI_RESOURCE_TYPE_MEMORY32:
240 memory32 = &resource->data.memory32;
241 addr->resource_type = ACPI_MEMORY_RANGE;
242 addr->minimum = memory32->minimum;
243 addr->address_length = memory32->address_length;
244 addr->maximum = addr->minimum + addr->address_length - 1;
245 return AE_OK;
246 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
247 fixed_memory32 = &resource->data.fixed_memory32;
248 addr->resource_type = ACPI_MEMORY_RANGE;
249 addr->minimum = fixed_memory32->address;
250 addr->address_length = fixed_memory32->address_length;
251 addr->maximum = addr->minimum + addr->address_length - 1;
252 return AE_OK;
253 case ACPI_RESOURCE_TYPE_ADDRESS16:
254 case ACPI_RESOURCE_TYPE_ADDRESS32:
255 case ACPI_RESOURCE_TYPE_ADDRESS64:
256 status = acpi_resource_to_address64(resource, addr);
257 if (ACPI_SUCCESS(status) &&
258 (addr->resource_type == ACPI_MEMORY_RANGE ||
259 addr->resource_type == ACPI_IO_RANGE) &&
260 addr->address_length > 0) {
261 return AE_OK;
262 }
263 break;
Gary Hade62f420f2007-10-03 15:56:51 -0700264 }
265 return AE_ERROR;
266}
267
268static acpi_status
269count_resource(struct acpi_resource *acpi_res, void *data)
270{
271 struct pci_root_info *info = data;
272 struct acpi_resource_address64 addr;
273 acpi_status status;
274
275 status = resource_to_addr(acpi_res, &addr);
276 if (ACPI_SUCCESS(status))
277 info->res_num++;
278 return AE_OK;
279}
280
281static acpi_status
282setup_resource(struct acpi_resource *acpi_res, void *data)
283{
284 struct pci_root_info *info = data;
285 struct resource *res;
286 struct acpi_resource_address64 addr;
287 acpi_status status;
288 unsigned long flags;
Gary Hadeae5cd862011-11-14 15:42:16 -0800289 u64 start, orig_end, end;
Yinghai Lu2cdb3f12009-06-24 19:01:19 -0700290
Gary Hade62f420f2007-10-03 15:56:51 -0700291 status = resource_to_addr(acpi_res, &addr);
292 if (!ACPI_SUCCESS(status))
293 return AE_OK;
294
295 if (addr.resource_type == ACPI_MEMORY_RANGE) {
Gary Hade62f420f2007-10-03 15:56:51 -0700296 flags = IORESOURCE_MEM;
297 if (addr.info.mem.caching == ACPI_PREFETCHABLE_MEMORY)
298 flags |= IORESOURCE_PREFETCH;
299 } else if (addr.resource_type == ACPI_IO_RANGE) {
Gary Hade62f420f2007-10-03 15:56:51 -0700300 flags = IORESOURCE_IO;
301 } else
302 return AE_OK;
303
Yinghai Lu2cdb3f12009-06-24 19:01:19 -0700304 start = addr.minimum + addr.translation_offset;
Gary Hadeae5cd862011-11-14 15:42:16 -0800305 orig_end = end = addr.maximum + addr.translation_offset;
306
307 /* Exclude non-addressable range or non-addressable portion of range */
308 end = min(end, (u64)iomem_resource.end);
309 if (end <= start) {
310 dev_info(&info->bridge->dev,
311 "host bridge window [%#llx-%#llx] "
312 "(ignored, not CPU addressable)\n", start, orig_end);
313 return AE_OK;
314 } else if (orig_end != end) {
315 dev_info(&info->bridge->dev,
316 "host bridge window [%#llx-%#llx] "
317 "([%#llx-%#llx] ignored, not CPU addressable)\n",
318 start, orig_end, end + 1, orig_end);
319 }
Gary Hadef9cde5f2009-05-27 12:41:44 -0700320
Yinghai Lu2cdb3f12009-06-24 19:01:19 -0700321 res = &info->res[info->res_num];
322 res->name = info->name;
323 res->flags = flags;
324 res->start = start;
325 res->end = end;
Mike Yoknisb4873932012-11-07 15:52:20 -0700326 info->res_offset[info->res_num] = addr.translation_offset;
Yijing Wangea221e62013-05-28 10:55:09 +0800327 info->res_num++;
Yinghai Lu2cdb3f12009-06-24 19:01:19 -0700328
Yijing Wangea221e62013-05-28 10:55:09 +0800329 if (!pci_use_crs)
Bjorn Helgaasf1db6fd2009-11-04 10:39:13 -0700330 dev_printk(KERN_DEBUG, &info->bridge->dev,
331 "host bridge window %pR (ignored)\n", res);
Bjorn Helgaas4723d0f2010-09-22 11:09:19 -0600332
Gary Hade62f420f2007-10-03 15:56:51 -0700333 return AE_OK;
334}
335
Márton Németh6e33a852011-05-14 19:27:33 +0200336static void coalesce_windows(struct pci_root_info *info, unsigned long type)
Bjorn Helgaas4723d0f2010-09-22 11:09:19 -0600337{
338 int i, j;
339 struct resource *res1, *res2;
340
341 for (i = 0; i < info->res_num; i++) {
342 res1 = &info->res[i];
343 if (!(res1->flags & type))
344 continue;
345
346 for (j = i + 1; j < info->res_num; j++) {
347 res2 = &info->res[j];
348 if (!(res2->flags & type))
349 continue;
350
351 /*
352 * I don't like throwing away windows because then
353 * our resources no longer match the ACPI _CRS, but
354 * the kernel resource tree doesn't allow overlaps.
355 */
Wei Yang74d24b22012-04-26 15:32:55 +0800356 if (resource_overlaps(res1, res2)) {
Alexey Neyman3ad674d2013-10-09 16:16:38 -0600357 res2->start = min(res1->start, res2->start);
358 res2->end = max(res1->end, res2->end);
Bjorn Helgaas4723d0f2010-09-22 11:09:19 -0600359 dev_info(&info->bridge->dev,
360 "host bridge window expanded to %pR; %pR ignored\n",
Alexey Neyman3ad674d2013-10-09 16:16:38 -0600361 res2, res1);
362 res1->flags = 0;
Bjorn Helgaas4723d0f2010-09-22 11:09:19 -0600363 }
364 }
365 }
366}
367
Yinghai Lu9a03d282012-04-02 18:31:53 -0700368static void add_resources(struct pci_root_info *info,
369 struct list_head *resources)
Bjorn Helgaas4723d0f2010-09-22 11:09:19 -0600370{
371 int i;
372 struct resource *res, *root, *conflict;
373
Bjorn Helgaas4723d0f2010-09-22 11:09:19 -0600374 coalesce_windows(info, IORESOURCE_MEM);
375 coalesce_windows(info, IORESOURCE_IO);
376
377 for (i = 0; i < info->res_num; i++) {
378 res = &info->res[i];
379
380 if (res->flags & IORESOURCE_MEM)
381 root = &iomem_resource;
382 else if (res->flags & IORESOURCE_IO)
383 root = &ioport_resource;
384 else
385 continue;
386
387 conflict = insert_resource_conflict(root, res);
388 if (conflict)
Bjorn Helgaas43d786e2011-07-02 10:47:12 -0600389 dev_info(&info->bridge->dev,
390 "ignoring host bridge window %pR (conflicts with %s %pR)\n",
391 res, conflict->name, conflict);
Bjorn Helgaas4723d0f2010-09-22 11:09:19 -0600392 else
Mike Yoknisb4873932012-11-07 15:52:20 -0700393 pci_add_resource_offset(resources, res,
394 info->res_offset[i]);
Bjorn Helgaas4723d0f2010-09-22 11:09:19 -0600395 }
396}
397
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700398static void free_pci_root_info_res(struct pci_root_info *info)
Yinghai Lubaa495d2012-04-02 18:31:53 -0700399{
Yinghai Lubaa495d2012-04-02 18:31:53 -0700400 kfree(info->res);
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700401 info->res = NULL;
Mike Yoknisb4873932012-11-07 15:52:20 -0700402 kfree(info->res_offset);
403 info->res_offset = NULL;
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700404 info->res_num = 0;
405}
406
407static void __release_pci_root_info(struct pci_root_info *info)
408{
409 int i;
410 struct resource *res;
411
412 for (i = 0; i < info->res_num; i++) {
413 res = &info->res[i];
414
415 if (!res->parent)
416 continue;
417
418 if (!(res->flags & (IORESOURCE_MEM | IORESOURCE_IO)))
419 continue;
420
421 release_resource(res);
422 }
423
424 free_pci_root_info_res(info);
425
Jiang Liuc0fa4072012-06-22 14:55:17 +0800426 teardown_mcfg_map(info);
427
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700428 kfree(info);
429}
Jiang Liuc0fa4072012-06-22 14:55:17 +0800430
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700431static void release_pci_root_info(struct pci_host_bridge *bridge)
432{
433 struct pci_root_info *info = bridge->release_data;
434
435 __release_pci_root_info(info);
Yinghai Lubaa495d2012-04-02 18:31:53 -0700436}
437
Gary Hade62f420f2007-10-03 15:56:51 -0700438static void
Yinghai Lu9a03d282012-04-02 18:31:53 -0700439probe_pci_root_info(struct pci_root_info *info, struct acpi_device *device,
440 int busnum, int domain)
Gary Hade62f420f2007-10-03 15:56:51 -0700441{
Gary Hade62f420f2007-10-03 15:56:51 -0700442 size_t size;
443
Yinghai Lu5c1d81d2012-05-17 18:51:12 -0700444 sprintf(info->name, "PCI Bus %04x:%02x", domain, busnum);
Yinghai Lubaa495d2012-04-02 18:31:53 -0700445 info->bridge = device;
Yinghai Lu5c1d81d2012-05-17 18:51:12 -0700446
Yinghai Lubaa495d2012-04-02 18:31:53 -0700447 info->res_num = 0;
Gary Hade62f420f2007-10-03 15:56:51 -0700448 acpi_walk_resources(device->handle, METHOD_NAME__CRS, count_resource,
Yinghai Lubaa495d2012-04-02 18:31:53 -0700449 info);
450 if (!info->res_num)
Gary Hade62f420f2007-10-03 15:56:51 -0700451 return;
452
Yinghai Lubaa495d2012-04-02 18:31:53 -0700453 size = sizeof(*info->res) * info->res_num;
Yinghai Lu4cd8daf2012-09-19 10:49:00 -0700454 info->res = kzalloc(size, GFP_KERNEL);
Mike Yoknisb4873932012-11-07 15:52:20 -0700455 if (!info->res) {
456 info->res_num = 0;
Bjorn Helgaas2cd69752011-10-28 16:28:14 -0600457 return;
Mike Yoknisb4873932012-11-07 15:52:20 -0700458 }
459
460 size = sizeof(*info->res_offset) * info->res_num;
461 info->res_num = 0;
462 info->res_offset = kzalloc(size, GFP_KERNEL);
463 if (!info->res_offset) {
464 kfree(info->res);
465 info->res = NULL;
466 return;
467 }
Gary Hade62f420f2007-10-03 15:56:51 -0700468
Gary Hade62f420f2007-10-03 15:56:51 -0700469 acpi_walk_resources(device->handle, METHOD_NAME__CRS, setup_resource,
Yinghai Lubaa495d2012-04-02 18:31:53 -0700470 info);
Gary Hade62f420f2007-10-03 15:56:51 -0700471}
472
Greg Kroah-Hartmana18e3692012-12-21 14:02:53 -0800473struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474{
Bjorn Helgaas57283772010-03-11 12:20:11 -0700475 struct acpi_device *device = root->device;
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700476 struct pci_root_info *info = NULL;
Bjorn Helgaas57283772010-03-11 12:20:11 -0700477 int domain = root->segment;
478 int busnum = root->secondary.start;
Bjorn Helgaas2cd69752011-10-28 16:28:14 -0600479 LIST_HEAD(resources);
Jiang Liuc0fa4072012-06-22 14:55:17 +0800480 struct pci_bus *bus = NULL;
Muli Ben-Yehuda08f1c192007-07-22 00:23:39 +0300481 struct pci_sysdata *sd;
Yinghai Lu871d5f82008-02-19 03:20:09 -0800482 int node;
483#ifdef CONFIG_ACPI_NUMA
Muli Ben-Yehuda08f1c192007-07-22 00:23:39 +0300484 int pxm;
Yinghai Lu871d5f82008-02-19 03:20:09 -0800485#endif
Andi Kleen69e1a332005-09-12 18:49:24 +0200486
Bjorn Helgaas1f09b092012-10-29 17:26:54 -0600487 if (pci_ignore_seg)
488 domain = 0;
489
Jeff Garzika79e4192007-10-11 16:58:30 -0400490 if (domain && !pci_domains_supported) {
Bjorn Helgaas2a6bed82009-11-04 10:32:47 -0700491 printk(KERN_WARNING "pci_bus %04x:%02x: "
492 "ignored (multiple domains not supported)\n",
493 domain, busnum);
Jeff Garzika79e4192007-10-11 16:58:30 -0400494 return NULL;
495 }
496
Yinghai Lu871d5f82008-02-19 03:20:09 -0800497 node = -1;
498#ifdef CONFIG_ACPI_NUMA
499 pxm = acpi_get_pxm(device->handle);
500 if (pxm >= 0)
501 node = pxm_to_node(pxm);
502 if (node != -1)
503 set_mp_bus_to_node(busnum, node);
504 else
Yinghai Lu871d5f82008-02-19 03:20:09 -0800505#endif
Yinghai Lu871d5f82008-02-19 03:20:09 -0800506 node = get_mp_bus_to_node(busnum);
Yinghai Lub755de82008-02-20 12:41:52 -0800507
508 if (node != -1 && !node_online(node))
509 node = -1;
Yinghai Lu871d5f82008-02-19 03:20:09 -0800510
Yinghai Lu35cb05e2012-04-02 18:31:53 -0700511 info = kzalloc(sizeof(*info), GFP_KERNEL);
512 if (!info) {
Bjorn Helgaas2a6bed82009-11-04 10:32:47 -0700513 printk(KERN_WARNING "pci_bus %04x:%02x: "
514 "ignored (out of memory)\n", domain, busnum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 return NULL;
516 }
517
Yinghai Lu35cb05e2012-04-02 18:31:53 -0700518 sd = &info->sd;
Jeff Garzika79e4192007-10-11 16:58:30 -0400519 sd->domain = domain;
Yinghai Lu871d5f82008-02-19 03:20:09 -0800520 sd->node = node;
Rafael J. Wysocki7b199812013-11-11 22:41:56 +0100521 sd->companion = device;
yakui.zhao@intel.comb87e81e2008-04-15 14:34:49 -0700522 /*
523 * Maybe the desired pci bus has been already scanned. In such case
524 * it is unnecessary to scan the pci bus with the given domain,busnum.
525 */
526 bus = pci_find_bus(domain, busnum);
527 if (bus) {
528 /*
529 * If the desired bus exits, the content of bus->sysdata will
530 * be replaced by sd.
531 */
532 memcpy(bus->sysdata, sd, sizeof(*sd));
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700533 kfree(info);
Yinghai Lu626fdfe2009-06-24 20:00:12 -0700534 } else {
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700535 probe_pci_root_info(info, device, busnum, domain);
Bjorn Helgaas316d86f2012-01-17 17:41:21 -0700536
Yinghai Lu5c1d81d2012-05-17 18:51:12 -0700537 /* insert busn res at first */
538 pci_add_resource(&resources, &root->secondary);
Bjorn Helgaas316d86f2012-01-17 17:41:21 -0700539 /*
540 * _CRS with no apertures is normal, so only fall back to
541 * defaults or native bridge info if we're ignoring _CRS.
542 */
Yinghai Lu9a03d282012-04-02 18:31:53 -0700543 if (pci_use_crs)
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700544 add_resources(info, &resources);
Yinghai Lu9a03d282012-04-02 18:31:53 -0700545 else {
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700546 free_pci_root_info_res(info);
Bjorn Helgaas2cd69752011-10-28 16:28:14 -0600547 x86_pci_root_bus_resources(busnum, &resources);
Yinghai Lu9a03d282012-04-02 18:31:53 -0700548 }
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700549
Jiang Liuc0fa4072012-06-22 14:55:17 +0800550 if (!setup_mcfg_map(info, domain, (u8)root->secondary.start,
551 (u8)root->secondary.end, root->mcfg_addr))
552 bus = pci_create_root_bus(NULL, busnum, &pci_root_ops,
553 sd, &resources);
554
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700555 if (bus) {
Yinghai Lu5c1d81d2012-05-17 18:51:12 -0700556 pci_scan_child_bus(bus);
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700557 pci_set_host_bridge_release(
558 to_pci_host_bridge(bus->bridge),
559 release_pci_root_info, info);
560 } else {
Bjorn Helgaas2cd69752011-10-28 16:28:14 -0600561 pci_free_resource_list(&resources);
Yinghai Lufd3b0c12012-04-02 18:31:53 -0700562 __release_pci_root_info(info);
563 }
Yinghai Lu626fdfe2009-06-24 20:00:12 -0700564 }
Muli Ben-Yehuda08f1c192007-07-22 00:23:39 +0300565
Jon Masonb03e7492011-07-20 15:20:54 -0500566 /* After the PCI-E bus has been walked and all devices discovered,
567 * configure any settings of the fabric that might be necessary.
568 */
569 if (bus) {
570 struct pci_bus *child;
Bjorn Helgaasa58674f2013-08-22 11:24:44 +0800571 list_for_each_entry(child, &bus->children, node)
572 pcie_bus_configure_settings(child);
Jon Masonb03e7492011-07-20 15:20:54 -0500573 }
574
Yinghai Ludbb61522008-04-19 01:30:16 -0700575 if (bus && node != -1) {
Andi Kleen69e1a332005-09-12 18:49:24 +0200576#ifdef CONFIG_ACPI_NUMA
Yinghai Ludbb61522008-04-19 01:30:16 -0700577 if (pxm >= 0)
Bjorn Helgaas2b8c2ef2008-12-18 16:34:51 -0700578 dev_printk(KERN_DEBUG, &bus->dev,
579 "on NUMA node %d (pxm %d)\n", node, pxm);
Yinghai Ludbb61522008-04-19 01:30:16 -0700580#else
Bjorn Helgaas2b8c2ef2008-12-18 16:34:51 -0700581 dev_printk(KERN_DEBUG, &bus->dev, "on NUMA node %d\n", node);
Andi Kleen69e1a332005-09-12 18:49:24 +0200582#endif
Yinghai Ludbb61522008-04-19 01:30:16 -0700583 }
Gary Hade62f420f2007-10-03 15:56:51 -0700584
Andi Kleen69e1a332005-09-12 18:49:24 +0200585 return bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586}
587
Rafael J. Wysocki6c0cc952013-01-09 22:33:37 +0100588int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge)
589{
590 struct pci_sysdata *sd = bridge->bus->sysdata;
591
Rafael J. Wysocki7b199812013-11-11 22:41:56 +0100592 ACPI_COMPANION_SET(&bridge->dev, sd->companion);
Rafael J. Wysocki6c0cc952013-01-09 22:33:37 +0100593 return 0;
594}
595
Robert Richter8dd779b2008-07-02 22:50:29 +0200596int __init pci_acpi_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597{
598 struct pci_dev *dev = NULL;
599
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 if (acpi_noirq)
Thomas Gleixnerb72d0db2009-08-29 16:24:51 +0200601 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603 printk(KERN_INFO "PCI: Using ACPI for IRQ routing\n");
604 acpi_irq_penalty_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 pcibios_enable_irq = acpi_pci_irq_enable;
David Shaohua Li87bec662005-07-27 23:02:00 -0400606 pcibios_disable_irq = acpi_pci_irq_disable;
Thomas Gleixnerab3b3792009-08-29 17:47:33 +0200607 x86_init.pci.init_irq = x86_init_noop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
609 if (pci_routeirq) {
610 /*
611 * PCI IRQ routing is set up by pci_enable_device(), but we
612 * also do it here in case there are still broken drivers that
613 * don't use pci_enable_device().
614 */
615 printk(KERN_INFO "PCI: Routing PCI interrupts for all devices because \"pci=routeirq\" specified\n");
Hanna Linderfb37fb92005-11-06 23:39:36 -0800616 for_each_pci_dev(dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 acpi_pci_irq_enable(dev);
Bjorn Helgaas657472e92008-02-18 09:44:13 -0700618 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 return 0;
621}