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