pci_root.c 16.7 KB
Newer Older
L
Linus Torvalds 已提交
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 27 28 29 30 31
/*
 *  pci_root.c - ACPI PCI Root Bridge Driver ($Revision: 40 $)
 *
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or (at
 *  your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/spinlock.h>
#include <linux/pm.h>
32
#include <linux/pm_runtime.h>
L
Linus Torvalds 已提交
33
#include <linux/pci.h>
34
#include <linux/pci-acpi.h>
L
Linus Torvalds 已提交
35
#include <linux/acpi.h>
36
#include <linux/slab.h>
L
Linus Torvalds 已提交
37 38
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
39
#include <acpi/apei.h>
L
Linus Torvalds 已提交
40

41 42
#define PREFIX "ACPI: "

L
Linus Torvalds 已提交
43
#define _COMPONENT		ACPI_PCI_COMPONENT
44
ACPI_MODULE_NAME("pci_root");
L
Linus Torvalds 已提交
45 46
#define ACPI_PCI_ROOT_CLASS		"pci_bridge"
#define ACPI_PCI_ROOT_DEVICE_NAME	"PCI Root Bridge"
L
Len Brown 已提交
47 48 49
static int acpi_pci_root_add(struct acpi_device *device);
static int acpi_pci_root_remove(struct acpi_device *device, int type);
static int acpi_pci_root_start(struct acpi_device *device);
L
Linus Torvalds 已提交
50

51 52 53 54 55
#define ACPI_PCIE_REQ_SUPPORT (OSC_EXT_PCI_CONFIG_SUPPORT \
				| OSC_ACTIVE_STATE_PWR_SUPPORT \
				| OSC_CLOCK_PWR_CAPABILITY_SUPPORT \
				| OSC_MSI_SUPPORT)

56
static const struct acpi_device_id root_device_ids[] = {
57 58 59 60 61
	{"PNP0A03", 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, root_device_ids);

L
Linus Torvalds 已提交
62
static struct acpi_driver acpi_pci_root_driver = {
L
Len Brown 已提交
63
	.name = "pci_root",
L
Len Brown 已提交
64
	.class = ACPI_PCI_ROOT_CLASS,
65
	.ids = root_device_ids,
L
Len Brown 已提交
66 67 68 69 70
	.ops = {
		.add = acpi_pci_root_add,
		.remove = acpi_pci_root_remove,
		.start = acpi_pci_root_start,
		},
L
Linus Torvalds 已提交
71 72 73 74 75
};

static LIST_HEAD(acpi_pci_roots);

static struct acpi_pci_driver *sub_driver;
76
static DEFINE_MUTEX(osc_lock);
L
Linus Torvalds 已提交
77 78 79 80

int acpi_pci_register_driver(struct acpi_pci_driver *driver)
{
	int n = 0;
81
	struct acpi_pci_root *root;
L
Linus Torvalds 已提交
82 83 84 85 86 87 88 89 90

	struct acpi_pci_driver **pptr = &sub_driver;
	while (*pptr)
		pptr = &(*pptr)->next;
	*pptr = driver;

	if (!driver->add)
		return 0;

91
	list_for_each_entry(root, &acpi_pci_roots, node) {
92
		driver->add(root->device->handle);
L
Linus Torvalds 已提交
93 94 95 96 97
		n++;
	}

	return n;
}
L
Len Brown 已提交
98

L
Linus Torvalds 已提交
99 100 101 102
EXPORT_SYMBOL(acpi_pci_register_driver);

void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
{
103
	struct acpi_pci_root *root;
L
Linus Torvalds 已提交
104 105 106

	struct acpi_pci_driver **pptr = &sub_driver;
	while (*pptr) {
107 108 109
		if (*pptr == driver)
			break;
		pptr = &(*pptr)->next;
L
Linus Torvalds 已提交
110
	}
111 112
	BUG_ON(!*pptr);
	*pptr = (*pptr)->next;
L
Linus Torvalds 已提交
113 114 115 116

	if (!driver->remove)
		return;

117
	list_for_each_entry(root, &acpi_pci_roots, node)
118
		driver->remove(root->device->handle);
L
Linus Torvalds 已提交
119
}
L
Len Brown 已提交
120

L
Linus Torvalds 已提交
121 122
EXPORT_SYMBOL(acpi_pci_unregister_driver);

123 124
acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
{
125
	struct acpi_pci_root *root;
126
	
127
	list_for_each_entry(root, &acpi_pci_roots, node)
128 129
		if ((root->segment == (u16) seg) &&
		    (root->secondary.start == (u16) bus))
130
			return root->device->handle;
131 132 133 134 135
	return NULL;		
}

EXPORT_SYMBOL_GPL(acpi_get_pci_rootbridge_handle);

136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
/**
 * acpi_is_root_bridge - determine whether an ACPI CA node is a PCI root bridge
 * @handle - the ACPI CA node in question.
 *
 * Note: we could make this API take a struct acpi_device * instead, but
 * for now, it's more convenient to operate on an acpi_handle.
 */
int acpi_is_root_bridge(acpi_handle handle)
{
	int ret;
	struct acpi_device *device;

	ret = acpi_bus_get_device(handle, &device);
	if (ret)
		return 0;

	ret = acpi_match_device_ids(device, root_device_ids);
	if (ret)
		return 0;
	else
		return 1;
}
EXPORT_SYMBOL_GPL(acpi_is_root_bridge);

L
Linus Torvalds 已提交
160
static acpi_status
L
Len Brown 已提交
161
get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
L
Linus Torvalds 已提交
162
{
163
	struct resource *res = data;
L
Linus Torvalds 已提交
164 165
	struct acpi_resource_address64 address;

B
Bob Moore 已提交
166 167 168
	if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
	    resource->type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
	    resource->type != ACPI_RESOURCE_TYPE_ADDRESS64)
L
Linus Torvalds 已提交
169 170 171
		return AE_OK;

	acpi_resource_to_address64(resource, &address);
L
Len Brown 已提交
172
	if ((address.address_length > 0) &&
173 174 175 176
	    (address.resource_type == ACPI_BUS_NUMBER_RANGE)) {
		res->start = address.minimum;
		res->end = address.minimum + address.address_length - 1;
	}
L
Linus Torvalds 已提交
177 178 179 180

	return AE_OK;
}

181
static acpi_status try_get_root_bridge_busnr(acpi_handle handle,
182
					     struct resource *res)
L
Linus Torvalds 已提交
183 184 185
{
	acpi_status status;

186
	res->start = -1;
L
Len Brown 已提交
187 188
	status =
	    acpi_walk_resources(handle, METHOD_NAME__CRS,
189
				get_root_bridge_busnr_callback, res);
L
Linus Torvalds 已提交
190 191
	if (ACPI_FAILURE(status))
		return status;
192
	if (res->start == -1)
L
Linus Torvalds 已提交
193 194 195 196
		return AE_ERROR;
	return AE_OK;
}

197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
static void acpi_pci_bridge_scan(struct acpi_device *device)
{
	int status;
	struct acpi_device *child = NULL;

	if (device->flags.bus_address)
		if (device->parent && device->parent->ops.bind) {
			status = device->parent->ops.bind(device);
			if (!status) {
				list_for_each_entry(child, &device->children, node)
					acpi_pci_bridge_scan(child);
			}
		}
}

S
Shaohua Li 已提交
212
static u8 pci_osc_uuid_str[] = "33DB4D5B-1FF7-401C-9657-7441C03DD766";
213 214 215 216

static acpi_status acpi_pci_run_osc(acpi_handle handle,
				    const u32 *capbuf, u32 *retval)
{
S
Shaohua Li 已提交
217 218 219 220 221 222
	struct acpi_osc_context context = {
		.uuid_str = pci_osc_uuid_str,
		.rev = 1,
		.cap.length = 12,
		.cap.pointer = (void *)capbuf,
	};
223 224
	acpi_status status;

S
Shaohua Li 已提交
225 226 227 228
	status = acpi_run_osc(handle, &context);
	if (ACPI_SUCCESS(status)) {
		*retval = *((u32 *)(context.ret.pointer + 8));
		kfree(context.ret.pointer);
229 230 231 232
	}
	return status;
}

233 234 235
static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root,
					u32 support,
					u32 *control)
236 237
{
	acpi_status status;
238 239 240 241
	u32 result, capbuf[3];

	support &= OSC_PCI_SUPPORT_MASKS;
	support |= root->osc_support_set;
242 243

	capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
244 245 246 247 248 249 250 251
	capbuf[OSC_SUPPORT_TYPE] = support;
	if (control) {
		*control &= OSC_PCI_CONTROL_MASKS;
		capbuf[OSC_CONTROL_TYPE] = *control | root->osc_control_set;
	} else {
		/* Run _OSC query for all possible controls. */
		capbuf[OSC_CONTROL_TYPE] = OSC_PCI_CONTROL_MASKS;
	}
252 253 254

	status = acpi_pci_run_osc(root->device->handle, capbuf, &result);
	if (ACPI_SUCCESS(status)) {
255
		root->osc_support_set = support;
256
		if (control)
257
			*control = result;
258 259 260 261 262 263 264 265 266 267 268 269 270
	}
	return status;
}

static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags)
{
	acpi_status status;
	acpi_handle tmp;

	status = acpi_get_handle(root->device->handle, "_OSC", &tmp);
	if (ACPI_FAILURE(status))
		return status;
	mutex_lock(&osc_lock);
271
	status = acpi_pci_query_osc(root, flags, NULL);
272 273 274 275
	mutex_unlock(&osc_lock);
	return status;
}

276
struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle)
277 278
{
	struct acpi_pci_root *root;
279

280 281 282 283 284 285
	list_for_each_entry(root, &acpi_pci_roots, node) {
		if (root->device->handle == handle)
			return root;
	}
	return NULL;
}
286
EXPORT_SYMBOL_GPL(acpi_pci_find_root);
287

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
struct acpi_handle_node {
	struct list_head node;
	acpi_handle handle;
};

/**
 * acpi_get_pci_dev - convert ACPI CA handle to struct pci_dev
 * @handle: the handle in question
 *
 * Given an ACPI CA handle, the desired PCI device is located in the
 * list of PCI devices.
 *
 * If the device is found, its reference count is increased and this
 * function returns a pointer to its data structure.  The caller must
 * decrement the reference count by calling pci_dev_put().
 * If no device is found, %NULL is returned.
 */
struct pci_dev *acpi_get_pci_dev(acpi_handle handle)
{
	int dev, fn;
	unsigned long long adr;
	acpi_status status;
	acpi_handle phandle;
	struct pci_bus *pbus;
	struct pci_dev *pdev = NULL;
	struct acpi_handle_node *node, *tmp;
	struct acpi_pci_root *root;
	LIST_HEAD(device_list);

	/*
	 * Walk up the ACPI CA namespace until we reach a PCI root bridge.
	 */
	phandle = handle;
	while (!acpi_is_root_bridge(phandle)) {
		node = kzalloc(sizeof(struct acpi_handle_node), GFP_KERNEL);
		if (!node)
			goto out;

		INIT_LIST_HEAD(&node->node);
		node->handle = phandle;
		list_add(&node->node, &device_list);

		status = acpi_get_parent(phandle, &phandle);
		if (ACPI_FAILURE(status))
			goto out;
	}

	root = acpi_pci_find_root(phandle);
	if (!root)
		goto out;

	pbus = root->bus;

	/*
	 * Now, walk back down the PCI device tree until we return to our
	 * original handle. Assumes that everything between the PCI root
	 * bridge and the device we're looking for must be a P2P bridge.
	 */
	list_for_each_entry(node, &device_list, node) {
		acpi_handle hnd = node->handle;
		status = acpi_evaluate_integer(hnd, "_ADR", NULL, &adr);
		if (ACPI_FAILURE(status))
			goto out;
		dev = (adr >> 16) & 0xffff;
		fn  = adr & 0xffff;

		pdev = pci_get_slot(pbus, PCI_DEVFN(dev, fn));
355
		if (!pdev || hnd == handle)
356 357 358 359
			break;

		pbus = pdev->subordinate;
		pci_dev_put(pdev);
360 361 362 363 364 365 366 367 368 369 370

		/*
		 * This function may be called for a non-PCI device that has a
		 * PCI parent (eg. a disk under a PCI SATA controller).  In that
		 * case pdev->subordinate will be NULL for the parent.
		 */
		if (!pbus) {
			dev_dbg(&pdev->dev, "Not a PCI-to-PCI bridge\n");
			pdev = NULL;
			break;
		}
371 372 373 374 375 376 377 378 379
	}
out:
	list_for_each_entry_safe(node, tmp, &device_list, node)
		kfree(node);

	return pdev;
}
EXPORT_SYMBOL_GPL(acpi_get_pci_dev);

380
/**
381 382 383 384
 * acpi_pci_osc_control_set - Request control of PCI root _OSC features.
 * @handle: ACPI handle of a PCI root bridge (or PCIe Root Complex).
 * @mask: Mask of _OSC bits to request control of, place to store control mask.
 * @req: Mask of _OSC bits the control of is essential to the caller.
385
 *
386 387 388 389 390 391 392 393
 * Run _OSC query for @mask and if that is successful, compare the returned
 * mask of control bits with @req.  If all of the @req bits are set in the
 * returned mask, run _OSC request for it.
 *
 * The variable at the @mask address may be modified regardless of whether or
 * not the function returns success.  On success it will contain the mask of
 * _OSC bits the BIOS has granted control of, but its contents are meaningless
 * on failure.
394
 **/
395
acpi_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 401
	acpi_handle tmp;

402 403 404 405 406
	if (!mask)
		return AE_BAD_PARAMETER;

	ctrl = *mask & OSC_PCI_CONTROL_MASKS;
	if ((ctrl & req) != req)
407 408 409 410 411 412
		return AE_TYPE;

	root = acpi_pci_find_root(handle);
	if (!root)
		return AE_NOT_EXIST;

413 414 415 416
	status = acpi_get_handle(handle, "_OSC", &tmp);
	if (ACPI_FAILURE(status))
		return status;

417
	mutex_lock(&osc_lock);
418 419

	*mask = ctrl | root->osc_control_set;
420
	/* No need to evaluate _OSC if the control was already granted. */
421
	if ((root->osc_control_set & ctrl) == ctrl)
422 423
		goto out;

424 425 426 427 428 429 430 431 432
	/* Need to check the available controls bits before requesting them. */
	while (*mask) {
		status = acpi_pci_query_osc(root, root->osc_support_set, mask);
		if (ACPI_FAILURE(status))
			goto out;
		if (ctrl == *mask)
			break;
		ctrl = *mask;
	}
433

434
	if ((ctrl & req) != req) {
435 436 437 438 439 440
		status = AE_SUPPORT;
		goto out;
	}

	capbuf[OSC_QUERY_TYPE] = 0;
	capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set;
441 442
	capbuf[OSC_CONTROL_TYPE] = ctrl;
	status = acpi_pci_run_osc(handle, capbuf, mask);
443
	if (ACPI_SUCCESS(status))
444
		root->osc_control_set = *mask;
445 446 447 448
out:
	mutex_unlock(&osc_lock);
	return status;
}
449
EXPORT_SYMBOL(acpi_pci_osc_control_set);
450

451
static int __devinit acpi_pci_root_add(struct acpi_device *device)
L
Linus Torvalds 已提交
452
{
453 454 455 456 457
	unsigned long long segment, bus;
	acpi_status status;
	int result;
	struct acpi_pci_root *root;
	acpi_handle handle;
458
	struct acpi_device *child;
459
	u32 flags, base_flags;
L
Linus Torvalds 已提交
460

461 462 463 464
	root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
	if (!root)
		return -ENOMEM;

465 466 467 468 469
	segment = 0;
	status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
				       &segment);
	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
		printk(KERN_ERR PREFIX "can't evaluate _SEG\n");
470 471
		result = -ENODEV;
		goto end;
472
	}
L
Linus Torvalds 已提交
473

474
	/* Check _CRS first, then _BBN.  If no _BBN, default to zero. */
475 476
	root->secondary.flags = IORESOURCE_BUS;
	status = try_get_root_bridge_busnr(device->handle, &root->secondary);
477
	if (ACPI_FAILURE(status)) {
478 479 480 481 482 483 484 485 486
		/*
		 * We need both the start and end of the downstream bus range
		 * to interpret _CBA (MMCONFIG base address), so it really is
		 * supposed to be in _CRS.  If we don't find it there, all we
		 * can do is assume [_BBN-0xFF] or [0-0xFF].
		 */
		root->secondary.end = 0xFF;
		printk(KERN_WARNING FW_BUG PREFIX
		       "no secondary bus range in _CRS\n");
487
		status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,					       NULL, &bus);
488 489 490 491 492 493 494 495
		if (ACPI_SUCCESS(status))
			root->secondary.start = bus;
		else if (status == AE_NOT_FOUND)
			root->secondary.start = 0;
		else {
			printk(KERN_ERR PREFIX "can't evaluate _BBN\n");
			result = -ENODEV;
			goto end;
496 497
		}
	}
L
Linus Torvalds 已提交
498

499
	INIT_LIST_HEAD(&root->node);
500
	root->device = device;
501
	root->segment = segment & 0xFFFF;
L
Linus Torvalds 已提交
502 503
	strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
504
	device->driver_data = root;
L
Linus Torvalds 已提交
505

506 507 508 509
	/*
	 * All supported architectures that use ACPI have support for
	 * PCI domains, so we indicate this in _OSC support capabilities.
	 */
510
	flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
511
	acpi_pci_osc_support(root, flags);
512

L
Linus Torvalds 已提交
513 514 515 516
	/*
	 * TBD: Need PCI interface for enumeration/configuration of roots.
	 */

L
Len Brown 已提交
517 518
	/* TBD: Locking */
	list_add_tail(&root->node, &acpi_pci_roots);
L
Linus Torvalds 已提交
519

520
	printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",
L
Len Brown 已提交
521
	       acpi_device_name(device), acpi_device_bid(device),
522
	       root->segment, &root->secondary);
L
Linus Torvalds 已提交
523 524 525 526 527 528 529 530

	/*
	 * Scan the Root Bridge
	 * --------------------
	 * Must do this prior to any attempt to bind the root device, as the
	 * PCI namespace does not get created until this call is made (and 
	 * thus the root bridge's pci_dev does not exist).
	 */
531
	root->bus = pci_acpi_scan_root(root);
L
Linus Torvalds 已提交
532
	if (!root->bus) {
533 534
		printk(KERN_ERR PREFIX
			    "Bus %04x:%02x not present in PCI namespace\n",
535
			    root->segment, (unsigned int)root->secondary.start);
L
Linus Torvalds 已提交
536 537 538 539 540 541 542 543 544
		result = -ENODEV;
		goto end;
	}

	/*
	 * Attach ACPI-PCI Context
	 * -----------------------
	 * Thus binding the ACPI and PCI devices.
	 */
A
Alexander Chiang 已提交
545
	result = acpi_pci_bind_root(device);
L
Linus Torvalds 已提交
546 547 548 549 550 551 552 553
	if (result)
		goto end;

	/*
	 * PCI Routing Table
	 * -----------------
	 * Evaluate and parse _PRT, if exists.
	 */
554
	status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
L
Linus Torvalds 已提交
555
	if (ACPI_SUCCESS(status))
556
		result = acpi_pci_irq_add_prt(device->handle, root->bus);
L
Linus Torvalds 已提交
557

558 559 560 561 562 563
	/*
	 * Scan and bind all _ADR-Based Devices
	 */
	list_for_each_entry(child, &device->children, node)
		acpi_pci_bridge_scan(child);

564 565 566
	/* Indicate support for various _OSC capabilities. */
	if (pci_ext_cfg_avail(root->bus->self))
		flags |= OSC_EXT_PCI_CONFIG_SUPPORT;
567 568 569
	if (pcie_aspm_enabled())
		flags |= OSC_ACTIVE_STATE_PWR_SUPPORT |
			OSC_CLOCK_PWR_CAPABILITY_SUPPORT;
570 571
	if (pci_msi_enabled())
		flags |= OSC_MSI_SUPPORT;
572
	if (flags != base_flags)
573
		acpi_pci_osc_support(root, flags);
574

575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
	if (!pcie_ports_disabled
	    && (flags & ACPI_PCIE_REQ_SUPPORT) == ACPI_PCIE_REQ_SUPPORT) {
		flags = OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL
			| OSC_PCI_EXPRESS_NATIVE_HP_CONTROL
			| OSC_PCI_EXPRESS_PME_CONTROL;

		if (pci_aer_available()) {
			if (aer_acpi_firmware_first())
				dev_dbg(root->bus->bridge,
					"PCIe errors handled by BIOS.\n");
			else
				flags |= OSC_PCI_EXPRESS_AER_CONTROL;
		}

		dev_info(root->bus->bridge,
			"Requesting ACPI _OSC control (0x%02x)\n", flags);

		status = acpi_pci_osc_control_set(device->handle, &flags,
					OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);
		if (ACPI_SUCCESS(status))
			dev_info(root->bus->bridge,
				"ACPI _OSC control (0x%02x) granted\n", flags);
		else
			dev_dbg(root->bus->bridge,
				"ACPI _OSC request failed (code %d)\n", status);
	}

602 603 604 605
	pci_acpi_add_bus_pm_notifier(device, root->bus);
	if (device->wakeup.flags.run_wake)
		device_set_run_wake(root->bus->bridge, true);

606
	return 0;
L
Linus Torvalds 已提交
607

608 609 610 611
end:
	if (!list_empty(&root->node))
		list_del(&root->node);
	kfree(root);
612
	return result;
L
Linus Torvalds 已提交
613 614
}

L
Len Brown 已提交
615
static int acpi_pci_root_start(struct acpi_device *device)
616
{
617
	struct acpi_pci_root *root = acpi_driver_data(device);
618

619 620
	pci_bus_add_devices(root->bus);
	return 0;
621
}
L
Linus Torvalds 已提交
622

L
Len Brown 已提交
623
static int acpi_pci_root_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
624
{
625
	struct acpi_pci_root *root = acpi_driver_data(device);
L
Linus Torvalds 已提交
626

627 628 629
	device_set_run_wake(root->bus->bridge, false);
	pci_acpi_remove_bus_pm_notifier(device);

L
Linus Torvalds 已提交
630
	kfree(root);
631
	return 0;
L
Linus Torvalds 已提交
632 633
}

L
Len Brown 已提交
634
static int __init acpi_pci_root_init(void)
L
Linus Torvalds 已提交
635 636
{
	if (acpi_pci_disabled)
637
		return 0;
L
Linus Torvalds 已提交
638

639 640
	acpi_hest_init();

641
	pci_acpi_crs_quirks();
L
Linus Torvalds 已提交
642
	if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0)
643
		return -ENODEV;
L
Linus Torvalds 已提交
644

645
	return 0;
L
Linus Torvalds 已提交
646 647 648
}

subsys_initcall(acpi_pci_root_init);