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