pci_root.c revision dc1544ea5d6dfdf29440295788e639e4b44c605a 
1/*
2 *  pci_root.c - ACPI PCI Root Bridge Driver ($Revision: 40 $)
3 *
4 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
5 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
6 *
7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8 *
9 *  This program is free software; you can redistribute it and/or modify
10 *  it under the terms of the GNU General Public License as published by
11 *  the Free Software Foundation; either version 2 of the License, or (at
12 *  your option) any later version.
13 *
14 *  This program is distributed in the hope that it will be useful, but
15 *  WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 *  General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License along
20 *  with this program; if not, write to the Free Software Foundation, Inc.,
21 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
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/pm_runtime.h>
34#include <linux/pci.h>
35#include <linux/pci-acpi.h>
36#include <linux/acpi.h>
37#include <linux/slab.h>
38#include <acpi/acpi_bus.h>
39#include <acpi/acpi_drivers.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
51static const struct acpi_device_id root_device_ids[] = {
52	{"PNP0A03", 0},
53	{"", 0},
54};
55MODULE_DEVICE_TABLE(acpi, root_device_ids);
56
57static struct acpi_driver acpi_pci_root_driver = {
58	.name = "pci_root",
59	.class = ACPI_PCI_ROOT_CLASS,
60	.ids = root_device_ids,
61	.ops = {
62		.add = acpi_pci_root_add,
63		.remove = acpi_pci_root_remove,
64		.start = acpi_pci_root_start,
65		},
66};
67
68static LIST_HEAD(acpi_pci_roots);
69
70static struct acpi_pci_driver *sub_driver;
71static DEFINE_MUTEX(osc_lock);
72
73int acpi_pci_register_driver(struct acpi_pci_driver *driver)
74{
75	int n = 0;
76	struct acpi_pci_root *root;
77
78	struct acpi_pci_driver **pptr = &sub_driver;
79	while (*pptr)
80		pptr = &(*pptr)->next;
81	*pptr = driver;
82
83	if (!driver->add)
84		return 0;
85
86	list_for_each_entry(root, &acpi_pci_roots, node) {
87		driver->add(root->device->handle);
88		n++;
89	}
90
91	return n;
92}
93
94EXPORT_SYMBOL(acpi_pci_register_driver);
95
96void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
97{
98	struct acpi_pci_root *root;
99
100	struct acpi_pci_driver **pptr = &sub_driver;
101	while (*pptr) {
102		if (*pptr == driver)
103			break;
104		pptr = &(*pptr)->next;
105	}
106	BUG_ON(!*pptr);
107	*pptr = (*pptr)->next;
108
109	if (!driver->remove)
110		return;
111
112	list_for_each_entry(root, &acpi_pci_roots, node)
113		driver->remove(root->device->handle);
114}
115
116EXPORT_SYMBOL(acpi_pci_unregister_driver);
117
118acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
119{
120	struct acpi_pci_root *root;
121
122	list_for_each_entry(root, &acpi_pci_roots, node)
123		if ((root->segment == (u16) seg) &&
124		    (root->secondary.start == (u16) bus))
125			return root->device->handle;
126	return NULL;
127}
128
129EXPORT_SYMBOL_GPL(acpi_get_pci_rootbridge_handle);
130
131/**
132 * acpi_is_root_bridge - determine whether an ACPI CA node is a PCI root bridge
133 * @handle - the ACPI CA node in question.
134 *
135 * Note: we could make this API take a struct acpi_device * instead, but
136 * for now, it's more convenient to operate on an acpi_handle.
137 */
138int acpi_is_root_bridge(acpi_handle handle)
139{
140	int ret;
141	struct acpi_device *device;
142
143	ret = acpi_bus_get_device(handle, &device);
144	if (ret)
145		return 0;
146
147	ret = acpi_match_device_ids(device, root_device_ids);
148	if (ret)
149		return 0;
150	else
151		return 1;
152}
153EXPORT_SYMBOL_GPL(acpi_is_root_bridge);
154
155static acpi_status
156get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
157{
158	struct resource *res = data;
159	struct acpi_resource_address64 address;
160
161	if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
162	    resource->type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
163	    resource->type != ACPI_RESOURCE_TYPE_ADDRESS64)
164		return AE_OK;
165
166	acpi_resource_to_address64(resource, &address);
167	if ((address.address_length > 0) &&
168	    (address.resource_type == ACPI_BUS_NUMBER_RANGE)) {
169		res->start = address.minimum;
170		res->end = address.minimum + address.address_length - 1;
171	}
172
173	return AE_OK;
174}
175
176static acpi_status try_get_root_bridge_busnr(acpi_handle handle,
177					     struct resource *res)
178{
179	acpi_status status;
180
181	res->start = -1;
182	status =
183	    acpi_walk_resources(handle, METHOD_NAME__CRS,
184				get_root_bridge_busnr_callback, res);
185	if (ACPI_FAILURE(status))
186		return status;
187	if (res->start == -1)
188		return AE_ERROR;
189	return AE_OK;
190}
191
192static void acpi_pci_bridge_scan(struct acpi_device *device)
193{
194	int status;
195	struct acpi_device *child = NULL;
196
197	if (device->flags.bus_address)
198		if (device->parent && device->parent->ops.bind) {
199			status = device->parent->ops.bind(device);
200			if (!status) {
201				list_for_each_entry(child, &device->children, node)
202					acpi_pci_bridge_scan(child);
203			}
204		}
205}
206
207static u8 pci_osc_uuid_str[] = "33DB4D5B-1FF7-401C-9657-7441C03DD766";
208
209static acpi_status acpi_pci_run_osc(acpi_handle handle,
210				    const u32 *capbuf, u32 *retval)
211{
212	struct acpi_osc_context context = {
213		.uuid_str = pci_osc_uuid_str,
214		.rev = 1,
215		.cap.length = 12,
216		.cap.pointer = (void *)capbuf,
217	};
218	acpi_status status;
219
220	status = acpi_run_osc(handle, &context);
221	if (ACPI_SUCCESS(status)) {
222		*retval = *((u32 *)(context.ret.pointer + 8));
223		kfree(context.ret.pointer);
224	}
225	return status;
226}
227
228static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root, u32 flags)
229{
230	acpi_status status;
231	u32 support_set, result, capbuf[3];
232
233	/* do _OSC query for all possible controls */
234	support_set = root->osc_support_set | (flags & OSC_PCI_SUPPORT_MASKS);
235	capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
236	capbuf[OSC_SUPPORT_TYPE] = support_set;
237	capbuf[OSC_CONTROL_TYPE] = OSC_PCI_CONTROL_MASKS;
238
239	status = acpi_pci_run_osc(root->device->handle, capbuf, &result);
240	if (ACPI_SUCCESS(status)) {
241		root->osc_support_set = support_set;
242		root->osc_control_qry = result;
243		root->osc_queried = 1;
244	}
245	return status;
246}
247
248static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags)
249{
250	acpi_status status;
251	acpi_handle tmp;
252
253	status = acpi_get_handle(root->device->handle, "_OSC", &tmp);
254	if (ACPI_FAILURE(status))
255		return status;
256	mutex_lock(&osc_lock);
257	status = acpi_pci_query_osc(root, flags);
258	mutex_unlock(&osc_lock);
259	return status;
260}
261
262struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle)
263{
264	struct acpi_pci_root *root;
265
266	list_for_each_entry(root, &acpi_pci_roots, node) {
267		if (root->device->handle == handle)
268			return root;
269	}
270	return NULL;
271}
272EXPORT_SYMBOL_GPL(acpi_pci_find_root);
273
274struct acpi_handle_node {
275	struct list_head node;
276	acpi_handle handle;
277};
278
279/**
280 * acpi_get_pci_dev - convert ACPI CA handle to struct pci_dev
281 * @handle: the handle in question
282 *
283 * Given an ACPI CA handle, the desired PCI device is located in the
284 * list of PCI devices.
285 *
286 * If the device is found, its reference count is increased and this
287 * function returns a pointer to its data structure.  The caller must
288 * decrement the reference count by calling pci_dev_put().
289 * If no device is found, %NULL is returned.
290 */
291struct pci_dev *acpi_get_pci_dev(acpi_handle handle)
292{
293	int dev, fn;
294	unsigned long long adr;
295	acpi_status status;
296	acpi_handle phandle;
297	struct pci_bus *pbus;
298	struct pci_dev *pdev = NULL;
299	struct acpi_handle_node *node, *tmp;
300	struct acpi_pci_root *root;
301	LIST_HEAD(device_list);
302
303	/*
304	 * Walk up the ACPI CA namespace until we reach a PCI root bridge.
305	 */
306	phandle = handle;
307	while (!acpi_is_root_bridge(phandle)) {
308		node = kzalloc(sizeof(struct acpi_handle_node), GFP_KERNEL);
309		if (!node)
310			goto out;
311
312		INIT_LIST_HEAD(&node->node);
313		node->handle = phandle;
314		list_add(&node->node, &device_list);
315
316		status = acpi_get_parent(phandle, &phandle);
317		if (ACPI_FAILURE(status))
318			goto out;
319	}
320
321	root = acpi_pci_find_root(phandle);
322	if (!root)
323		goto out;
324
325	pbus = root->bus;
326
327	/*
328	 * Now, walk back down the PCI device tree until we return to our
329	 * original handle. Assumes that everything between the PCI root
330	 * bridge and the device we're looking for must be a P2P bridge.
331	 */
332	list_for_each_entry(node, &device_list, node) {
333		acpi_handle hnd = node->handle;
334		status = acpi_evaluate_integer(hnd, "_ADR", NULL, &adr);
335		if (ACPI_FAILURE(status))
336			goto out;
337		dev = (adr >> 16) & 0xffff;
338		fn  = adr & 0xffff;
339
340		pdev = pci_get_slot(pbus, PCI_DEVFN(dev, fn));
341		if (!pdev || hnd == handle)
342			break;
343
344		pbus = pdev->subordinate;
345		pci_dev_put(pdev);
346
347		/*
348		 * This function may be called for a non-PCI device that has a
349		 * PCI parent (eg. a disk under a PCI SATA controller).  In that
350		 * case pdev->subordinate will be NULL for the parent.
351		 */
352		if (!pbus) {
353			dev_dbg(&pdev->dev, "Not a PCI-to-PCI bridge\n");
354			pdev = NULL;
355			break;
356		}
357	}
358out:
359	list_for_each_entry_safe(node, tmp, &device_list, node)
360		kfree(node);
361
362	return pdev;
363}
364EXPORT_SYMBOL_GPL(acpi_get_pci_dev);
365
366/**
367 * acpi_pci_osc_control_set - commit requested control to Firmware
368 * @handle: acpi_handle for the target ACPI object
369 * @flags: driver's requested control bits
370 *
371 * Attempt to take control from Firmware on requested control bits.
372 **/
373acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 flags)
374{
375	acpi_status status;
376	u32 control_req, result, capbuf[3];
377	acpi_handle tmp;
378	struct acpi_pci_root *root;
379
380	status = acpi_get_handle(handle, "_OSC", &tmp);
381	if (ACPI_FAILURE(status))
382		return status;
383
384	control_req = (flags & OSC_PCI_CONTROL_MASKS);
385	if (!control_req)
386		return AE_TYPE;
387
388	root = acpi_pci_find_root(handle);
389	if (!root)
390		return AE_NOT_EXIST;
391
392	mutex_lock(&osc_lock);
393	/* No need to evaluate _OSC if the control was already granted. */
394	if ((root->osc_control_set & control_req) == control_req)
395		goto out;
396
397	/* Need to query controls first before requesting them */
398	if (!root->osc_queried) {
399		status = acpi_pci_query_osc(root, root->osc_support_set);
400		if (ACPI_FAILURE(status))
401			goto out;
402	}
403	if ((root->osc_control_qry & control_req) != control_req) {
404		printk(KERN_DEBUG
405		       "Firmware did not grant requested _OSC control\n");
406		status = AE_SUPPORT;
407		goto out;
408	}
409
410	capbuf[OSC_QUERY_TYPE] = 0;
411	capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set;
412	capbuf[OSC_CONTROL_TYPE] = root->osc_control_set | control_req;
413	status = acpi_pci_run_osc(handle, capbuf, &result);
414	if (ACPI_SUCCESS(status))
415		root->osc_control_set = result;
416out:
417	mutex_unlock(&osc_lock);
418	return status;
419}
420EXPORT_SYMBOL(acpi_pci_osc_control_set);
421
422static int __devinit acpi_pci_root_add(struct acpi_device *device)
423{
424	unsigned long long segment, bus;
425	acpi_status status;
426	int result;
427	struct acpi_pci_root *root;
428	acpi_handle handle;
429	struct acpi_device *child;
430	u32 flags, base_flags;
431
432	root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
433	if (!root)
434		return -ENOMEM;
435
436	segment = 0;
437	status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
438				       &segment);
439	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
440		printk(KERN_ERR PREFIX "can't evaluate _SEG\n");
441		result = -ENODEV;
442		goto end;
443	}
444
445	/* Check _CRS first, then _BBN.  If no _BBN, default to zero. */
446	root->secondary.flags = IORESOURCE_BUS;
447	status = try_get_root_bridge_busnr(device->handle, &root->secondary);
448	if (ACPI_FAILURE(status)) {
449		/*
450		 * We need both the start and end of the downstream bus range
451		 * to interpret _CBA (MMCONFIG base address), so it really is
452		 * supposed to be in _CRS.  If we don't find it there, all we
453		 * can do is assume [_BBN-0xFF] or [0-0xFF].
454		 */
455		root->secondary.end = 0xFF;
456		printk(KERN_WARNING FW_BUG PREFIX
457		       "no secondary bus range in _CRS\n");
458		status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,					       NULL, &bus);
459		if (ACPI_SUCCESS(status))
460			root->secondary.start = bus;
461		else if (status == AE_NOT_FOUND)
462			root->secondary.start = 0;
463		else {
464			printk(KERN_ERR PREFIX "can't evaluate _BBN\n");
465			result = -ENODEV;
466			goto end;
467		}
468	}
469
470	INIT_LIST_HEAD(&root->node);
471	root->device = device;
472	root->segment = segment & 0xFFFF;
473	strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
474	strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
475	device->driver_data = root;
476
477	/*
478	 * All supported architectures that use ACPI have support for
479	 * PCI domains, so we indicate this in _OSC support capabilities.
480	 */
481	flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
482	acpi_pci_osc_support(root, flags);
483
484	/*
485	 * TBD: Need PCI interface for enumeration/configuration of roots.
486	 */
487
488	/* TBD: Locking */
489	list_add_tail(&root->node, &acpi_pci_roots);
490
491	printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",
492	       acpi_device_name(device), acpi_device_bid(device),
493	       root->segment, &root->secondary);
494
495	/*
496	 * Scan the Root Bridge
497	 * --------------------
498	 * Must do this prior to any attempt to bind the root device, as the
499	 * PCI namespace does not get created until this call is made (and
500	 * thus the root bridge's pci_dev does not exist).
501	 */
502	root->bus = pci_acpi_scan_root(root);
503	if (!root->bus) {
504		printk(KERN_ERR PREFIX
505			    "Bus %04x:%02x not present in PCI namespace\n",
506			    root->segment, (unsigned int)root->secondary.start);
507		result = -ENODEV;
508		goto end;
509	}
510
511	/*
512	 * Attach ACPI-PCI Context
513	 * -----------------------
514	 * Thus binding the ACPI and PCI devices.
515	 */
516	result = acpi_pci_bind_root(device);
517	if (result)
518		goto end;
519
520	/*
521	 * PCI Routing Table
522	 * -----------------
523	 * Evaluate and parse _PRT, if exists.
524	 */
525	status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
526	if (ACPI_SUCCESS(status))
527		result = acpi_pci_irq_add_prt(device->handle, root->bus);
528
529	/*
530	 * Scan and bind all _ADR-Based Devices
531	 */
532	list_for_each_entry(child, &device->children, node)
533		acpi_pci_bridge_scan(child);
534
535	/* Indicate support for various _OSC capabilities. */
536	if (pci_ext_cfg_avail(root->bus->self))
537		flags |= OSC_EXT_PCI_CONFIG_SUPPORT;
538	if (pcie_aspm_enabled())
539		flags |= OSC_ACTIVE_STATE_PWR_SUPPORT |
540			OSC_CLOCK_PWR_CAPABILITY_SUPPORT;
541	if (pci_msi_enabled())
542		flags |= OSC_MSI_SUPPORT;
543	if (flags != base_flags)
544		acpi_pci_osc_support(root, flags);
545
546	pci_acpi_add_bus_pm_notifier(device, root->bus);
547	if (device->wakeup.flags.run_wake)
548		device_set_run_wake(root->bus->bridge, true);
549
550	return 0;
551
552end:
553	if (!list_empty(&root->node))
554		list_del(&root->node);
555	kfree(root);
556	return result;
557}
558
559static int acpi_pci_root_start(struct acpi_device *device)
560{
561	struct acpi_pci_root *root = acpi_driver_data(device);
562
563	pci_bus_add_devices(root->bus);
564	return 0;
565}
566
567static int acpi_pci_root_remove(struct acpi_device *device, int type)
568{
569	struct acpi_pci_root *root = acpi_driver_data(device);
570
571	device_set_run_wake(root->bus->bridge, false);
572	pci_acpi_remove_bus_pm_notifier(device);
573
574	kfree(root);
575	return 0;
576}
577
578static int __init acpi_pci_root_init(void)
579{
580	if (acpi_pci_disabled)
581		return 0;
582
583	pci_acpi_crs_quirks();
584	if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0)
585		return -ENODEV;
586
587	return 0;
588}
589
590subsys_initcall(acpi_pci_root_init);
591