1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/kernel.h>
27#include <linux/module.h>
28#include <linux/init.h>
29#include <linux/types.h>
30#include <linux/spinlock.h>
31#include <linux/pm.h>
32#include <linux/pm_runtime.h>
33#include <linux/pci.h>
34#include <linux/pci-acpi.h>
35#include <linux/acpi.h>
36#include <linux/slab.h>
37#include <acpi/acpi_bus.h>
38#include <acpi/acpi_drivers.h>
39#include <acpi/apei.h>
40
41#define PREFIX "ACPI: "
42
43#define _COMPONENT ACPI_PCI_COMPONENT
44ACPI_MODULE_NAME("pci_root");
45#define ACPI_PCI_ROOT_CLASS "pci_bridge"
46#define ACPI_PCI_ROOT_DEVICE_NAME "PCI Root Bridge"
47static int acpi_pci_root_add(struct acpi_device *device);
48static int acpi_pci_root_remove(struct acpi_device *device, int type);
49static int acpi_pci_root_start(struct acpi_device *device);
50
51#define ACPI_PCIE_REQ_SUPPORT (OSC_EXT_PCI_CONFIG_SUPPORT \
52 | OSC_ACTIVE_STATE_PWR_SUPPORT \
53 | OSC_CLOCK_PWR_CAPABILITY_SUPPORT \
54 | OSC_MSI_SUPPORT)
55
56static const struct acpi_device_id root_device_ids[] = {
57 {"PNP0A03", 0},
58 {"", 0},
59};
60MODULE_DEVICE_TABLE(acpi, root_device_ids);
61
62static struct acpi_driver acpi_pci_root_driver = {
63 .name = "pci_root",
64 .class = ACPI_PCI_ROOT_CLASS,
65 .ids = root_device_ids,
66 .ops = {
67 .add = acpi_pci_root_add,
68 .remove = acpi_pci_root_remove,
69 .start = acpi_pci_root_start,
70 },
71};
72
73static LIST_HEAD(acpi_pci_roots);
74
75static struct acpi_pci_driver *sub_driver;
76static DEFINE_MUTEX(osc_lock);
77
78int acpi_pci_register_driver(struct acpi_pci_driver *driver)
79{
80 int n = 0;
81 struct acpi_pci_root *root;
82
83 struct acpi_pci_driver **pptr = &sub_driver;
84 while (*pptr)
85 pptr = &(*pptr)->next;
86 *pptr = driver;
87
88 if (!driver->add)
89 return 0;
90
91 list_for_each_entry(root, &acpi_pci_roots, node) {
92 driver->add(root->device->handle);
93 n++;
94 }
95
96 return n;
97}
98
99EXPORT_SYMBOL(acpi_pci_register_driver);
100
101void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
102{
103 struct acpi_pci_root *root;
104
105 struct acpi_pci_driver **pptr = &sub_driver;
106 while (*pptr) {
107 if (*pptr == driver)
108 break;
109 pptr = &(*pptr)->next;
110 }
111 BUG_ON(!*pptr);
112 *pptr = (*pptr)->next;
113
114 if (!driver->remove)
115 return;
116
117 list_for_each_entry(root, &acpi_pci_roots, node)
118 driver->remove(root->device->handle);
119}
120
121EXPORT_SYMBOL(acpi_pci_unregister_driver);
122
123acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
124{
125 struct acpi_pci_root *root;
126
127 list_for_each_entry(root, &acpi_pci_roots, node)
128 if ((root->segment == (u16) seg) &&
129 (root->secondary.start == (u16) bus))
130 return root->device->handle;
131 return NULL;
132}
133
134EXPORT_SYMBOL_GPL(acpi_get_pci_rootbridge_handle);
135
136
137
138
139
140
141
142
143int acpi_is_root_bridge(acpi_handle handle)
144{
145 int ret;
146 struct acpi_device *device;
147
148 ret = acpi_bus_get_device(handle, &device);
149 if (ret)
150 return 0;
151
152 ret = acpi_match_device_ids(device, root_device_ids);
153 if (ret)
154 return 0;
155 else
156 return 1;
157}
158EXPORT_SYMBOL_GPL(acpi_is_root_bridge);
159
160static acpi_status
161get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
162{
163 struct resource *res = data;
164 struct acpi_resource_address64 address;
165
166 if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
167 resource->type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
168 resource->type != ACPI_RESOURCE_TYPE_ADDRESS64)
169 return AE_OK;
170
171 acpi_resource_to_address64(resource, &address);
172 if ((address.address_length > 0) &&
173 (address.resource_type == ACPI_BUS_NUMBER_RANGE)) {
174 res->start = address.minimum;
175 res->end = address.minimum + address.address_length - 1;
176 }
177
178 return AE_OK;
179}
180
181static acpi_status try_get_root_bridge_busnr(acpi_handle handle,
182 struct resource *res)
183{
184 acpi_status status;
185
186 res->start = -1;
187 status =
188 acpi_walk_resources(handle, METHOD_NAME__CRS,
189 get_root_bridge_busnr_callback, res);
190 if (ACPI_FAILURE(status))
191 return status;
192 if (res->start == -1)
193 return AE_ERROR;
194 return AE_OK;
195}
196
197static void acpi_pci_bridge_scan(struct acpi_device *device)
198{
199 int status;
200 struct acpi_device *child = NULL;
201
202 if (device->flags.bus_address)
203 if (device->parent && device->parent->ops.bind) {
204 status = device->parent->ops.bind(device);
205 if (!status) {
206 list_for_each_entry(child, &device->children, node)
207 acpi_pci_bridge_scan(child);
208 }
209 }
210}
211
212static u8 pci_osc_uuid_str[] = "33DB4D5B-1FF7-401C-9657-7441C03DD766";
213
214static acpi_status acpi_pci_run_osc(acpi_handle handle,
215 const u32 *capbuf, u32 *retval)
216{
217 struct acpi_osc_context context = {
218 .uuid_str = pci_osc_uuid_str,
219 .rev = 1,
220 .cap.length = 12,
221 .cap.pointer = (void *)capbuf,
222 };
223 acpi_status status;
224
225 status = acpi_run_osc(handle, &context);
226 if (ACPI_SUCCESS(status)) {
227 *retval = *((u32 *)(context.ret.pointer + 8));
228 kfree(context.ret.pointer);
229 }
230 return status;
231}
232
233static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root,
234 u32 support,
235 u32 *control)
236{
237 acpi_status status;
238 u32 result, capbuf[3];
239
240 support &= OSC_PCI_SUPPORT_MASKS;
241 support |= root->osc_support_set;
242
243 capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
244 capbuf[OSC_SUPPORT_TYPE] = support;
245 if (control) {
246 *control &= OSC_PCI_CONTROL_MASKS;
247 capbuf[OSC_CONTROL_TYPE] = *control | root->osc_control_set;
248 } else {
249
250 capbuf[OSC_CONTROL_TYPE] = OSC_PCI_CONTROL_MASKS;
251 }
252
253 status = acpi_pci_run_osc(root->device->handle, capbuf, &result);
254 if (ACPI_SUCCESS(status)) {
255 root->osc_support_set = support;
256 if (control)
257 *control = result;
258 }
259 return status;
260}
261
262static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags)
263{
264 acpi_status status;
265 acpi_handle tmp;
266
267 status = acpi_get_handle(root->device->handle, "_OSC", &tmp);
268 if (ACPI_FAILURE(status))
269 return status;
270 mutex_lock(&osc_lock);
271 status = acpi_pci_query_osc(root, flags, NULL);
272 mutex_unlock(&osc_lock);
273 return status;
274}
275
276struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle)
277{
278 struct acpi_pci_root *root;
279
280 list_for_each_entry(root, &acpi_pci_roots, node) {
281 if (root->device->handle == handle)
282 return root;
283 }
284 return NULL;
285}
286EXPORT_SYMBOL_GPL(acpi_pci_find_root);
287
288struct acpi_handle_node {
289 struct list_head node;
290 acpi_handle handle;
291};
292
293
294
295
296
297
298
299
300
301
302
303
304
305struct pci_dev *acpi_get_pci_dev(acpi_handle handle)
306{
307 int dev, fn;
308 unsigned long long adr;
309 acpi_status status;
310 acpi_handle phandle;
311 struct pci_bus *pbus;
312 struct pci_dev *pdev = NULL;
313 struct acpi_handle_node *node, *tmp;
314 struct acpi_pci_root *root;
315 LIST_HEAD(device_list);
316
317
318
319
320 phandle = handle;
321 while (!acpi_is_root_bridge(phandle)) {
322 node = kzalloc(sizeof(struct acpi_handle_node), GFP_KERNEL);
323 if (!node)
324 goto out;
325
326 INIT_LIST_HEAD(&node->node);
327 node->handle = phandle;
328 list_add(&node->node, &device_list);
329
330 status = acpi_get_parent(phandle, &phandle);
331 if (ACPI_FAILURE(status))
332 goto out;
333 }
334
335 root = acpi_pci_find_root(phandle);
336 if (!root)
337 goto out;
338
339 pbus = root->bus;
340
341
342
343
344
345
346 list_for_each_entry(node, &device_list, node) {
347 acpi_handle hnd = node->handle;
348 status = acpi_evaluate_integer(hnd, "_ADR", NULL, &adr);
349 if (ACPI_FAILURE(status))
350 goto out;
351 dev = (adr >> 16) & 0xffff;
352 fn = adr & 0xffff;
353
354 pdev = pci_get_slot(pbus, PCI_DEVFN(dev, fn));
355 if (!pdev || hnd == handle)
356 break;
357
358 pbus = pdev->subordinate;
359 pci_dev_put(pdev);
360
361
362
363
364
365
366 if (!pbus) {
367 dev_dbg(&pdev->dev, "Not a PCI-to-PCI bridge\n");
368 pdev = NULL;
369 break;
370 }
371 }
372out:
373 list_for_each_entry_safe(node, tmp, &device_list, node)
374 kfree(node);
375
376 return pdev;
377}
378EXPORT_SYMBOL_GPL(acpi_get_pci_dev);
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req)
396{
397 struct acpi_pci_root *root;
398 acpi_status status;
399 u32 ctrl, capbuf[3];
400 acpi_handle tmp;
401
402 if (!mask)
403 return AE_BAD_PARAMETER;
404
405 ctrl = *mask & OSC_PCI_CONTROL_MASKS;
406 if ((ctrl & req) != req)
407 return AE_TYPE;
408
409 root = acpi_pci_find_root(handle);
410 if (!root)
411 return AE_NOT_EXIST;
412
413 status = acpi_get_handle(handle, "_OSC", &tmp);
414 if (ACPI_FAILURE(status))
415 return status;
416
417 mutex_lock(&osc_lock);
418
419 *mask = ctrl | root->osc_control_set;
420
421 if ((root->osc_control_set & ctrl) == ctrl)
422 goto out;
423
424
425 while (*mask) {
426 status = acpi_pci_query_osc(root, root->osc_support_set, mask);
427 if (ACPI_FAILURE(status))
428 goto out;
429 if (ctrl == *mask)
430 break;
431 ctrl = *mask;
432 }
433
434 if ((ctrl & req) != req) {
435 status = AE_SUPPORT;
436 goto out;
437 }
438
439 capbuf[OSC_QUERY_TYPE] = 0;
440 capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set;
441 capbuf[OSC_CONTROL_TYPE] = ctrl;
442 status = acpi_pci_run_osc(handle, capbuf, mask);
443 if (ACPI_SUCCESS(status))
444 root->osc_control_set = *mask;
445out:
446 mutex_unlock(&osc_lock);
447 return status;
448}
449EXPORT_SYMBOL(acpi_pci_osc_control_set);
450
451static int __devinit acpi_pci_root_add(struct acpi_device *device)
452{
453 unsigned long long segment, bus;
454 acpi_status status;
455 int result;
456 struct acpi_pci_root *root;
457 acpi_handle handle;
458 struct acpi_device *child;
459 u32 flags, base_flags;
460
461 root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
462 if (!root)
463 return -ENOMEM;
464
465 segment = 0;
466 status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
467 &segment);
468 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
469 printk(KERN_ERR PREFIX "can't evaluate _SEG\n");
470 result = -ENODEV;
471 goto end;
472 }
473
474
475 root->secondary.flags = IORESOURCE_BUS;
476 status = try_get_root_bridge_busnr(device->handle, &root->secondary);
477 if (ACPI_FAILURE(status)) {
478
479
480
481
482
483
484 root->secondary.end = 0xFF;
485 printk(KERN_WARNING FW_BUG PREFIX
486 "no secondary bus range in _CRS\n");
487 status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN, NULL, &bus);
488 if (ACPI_SUCCESS(status))
489 root->secondary.start = bus;
490 else if (status == AE_NOT_FOUND)
491 root->secondary.start = 0;
492 else {
493 printk(KERN_ERR PREFIX "can't evaluate _BBN\n");
494 result = -ENODEV;
495 goto end;
496 }
497 }
498
499 INIT_LIST_HEAD(&root->node);
500 root->device = device;
501 root->segment = segment & 0xFFFF;
502 strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
503 strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
504 device->driver_data = root;
505
506
507
508
509
510 flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
511 acpi_pci_osc_support(root, flags);
512
513
514
515
516
517
518 list_add_tail(&root->node, &acpi_pci_roots);
519
520 printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",
521 acpi_device_name(device), acpi_device_bid(device),
522 root->segment, &root->secondary);
523
524
525
526
527
528
529
530
531 root->bus = pci_acpi_scan_root(root);
532 if (!root->bus) {
533 printk(KERN_ERR PREFIX
534 "Bus %04x:%02x not present in PCI namespace\n",
535 root->segment, (unsigned int)root->secondary.start);
536 result = -ENODEV;
537 goto end;
538 }
539
540
541
542
543
544
545 result = acpi_pci_bind_root(device);
546 if (result)
547 goto end;
548
549
550
551
552
553
554 status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
555 if (ACPI_SUCCESS(status))
556 result = acpi_pci_irq_add_prt(device->handle, root->bus);
557
558
559
560
561 list_for_each_entry(child, &device->children, node)
562 acpi_pci_bridge_scan(child);
563
564
565 if (pci_ext_cfg_avail(root->bus->self))
566 flags |= OSC_EXT_PCI_CONFIG_SUPPORT;
567 if (pcie_aspm_enabled())
568 flags |= OSC_ACTIVE_STATE_PWR_SUPPORT |
569 OSC_CLOCK_PWR_CAPABILITY_SUPPORT;
570 if (pci_msi_enabled())
571 flags |= OSC_MSI_SUPPORT;
572 if (flags != base_flags)
573 acpi_pci_osc_support(root, flags);
574
575 if (!pcie_ports_disabled
576 && (flags & ACPI_PCIE_REQ_SUPPORT) == ACPI_PCIE_REQ_SUPPORT) {
577 flags = OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL
578 | OSC_PCI_EXPRESS_NATIVE_HP_CONTROL
579 | OSC_PCI_EXPRESS_PME_CONTROL;
580
581 if (pci_aer_available()) {
582 if (aer_acpi_firmware_first())
583 dev_dbg(root->bus->bridge,
584 "PCIe errors handled by BIOS.\n");
585 else
586 flags |= OSC_PCI_EXPRESS_AER_CONTROL;
587 }
588
589 dev_info(root->bus->bridge,
590 "Requesting ACPI _OSC control (0x%02x)\n", flags);
591
592 status = acpi_pci_osc_control_set(device->handle, &flags,
593 OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);
594 if (ACPI_SUCCESS(status))
595 dev_info(root->bus->bridge,
596 "ACPI _OSC control (0x%02x) granted\n", flags);
597 else
598 dev_dbg(root->bus->bridge,
599 "ACPI _OSC request failed (code %d)\n", status);
600 }
601
602 pci_acpi_add_bus_pm_notifier(device, root->bus);
603 if (device->wakeup.flags.run_wake)
604 device_set_run_wake(root->bus->bridge, true);
605
606 return 0;
607
608end:
609 if (!list_empty(&root->node))
610 list_del(&root->node);
611 kfree(root);
612 return result;
613}
614
615static int acpi_pci_root_start(struct acpi_device *device)
616{
617 struct acpi_pci_root *root = acpi_driver_data(device);
618
619 pci_bus_add_devices(root->bus);
620 return 0;
621}
622
623static int acpi_pci_root_remove(struct acpi_device *device, int type)
624{
625 struct acpi_pci_root *root = acpi_driver_data(device);
626
627 device_set_run_wake(root->bus->bridge, false);
628 pci_acpi_remove_bus_pm_notifier(device);
629
630 kfree(root);
631 return 0;
632}
633
634static int __init acpi_pci_root_init(void)
635{
636 acpi_hest_init();
637
638 if (acpi_pci_disabled)
639 return 0;
640
641 pci_acpi_crs_quirks();
642 if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0)
643 return -ENODEV;
644
645 return 0;
646}
647
648subsys_initcall(acpi_pci_root_init);
649