pci_root.c 17.8 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
/*
 *  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>
30
#include <linux/mutex.h>
L
Linus Torvalds 已提交
31
#include <linux/pm.h>
32
#include <linux/pm_runtime.h>
L
Linus Torvalds 已提交
33
#include <linux/pci.h>
34
#include <linux/pci-acpi.h>
35
#include <linux/pci-aspm.h>
L
Linus Torvalds 已提交
36
#include <linux/acpi.h>
37
#include <linux/slab.h>
L
Linus Torvalds 已提交
38 39
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
40
#include <acpi/apei.h>
L
Linus Torvalds 已提交
41

42 43
#define PREFIX "ACPI: "

L
Linus Torvalds 已提交
44
#define _COMPONENT		ACPI_PCI_COMPONENT
45
ACPI_MODULE_NAME("pci_root");
L
Linus Torvalds 已提交
46 47
#define ACPI_PCI_ROOT_CLASS		"pci_bridge"
#define ACPI_PCI_ROOT_DEVICE_NAME	"PCI Root Bridge"
L
Len Brown 已提交
48 49
static int acpi_pci_root_add(struct acpi_device *device);
static int acpi_pci_root_remove(struct acpi_device *device, int type);
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
	.ops = {
		.add = acpi_pci_root_add,
		.remove = acpi_pci_root_remove,
		},
L
Linus Torvalds 已提交
70 71
};

72 73
/* Lock to protect both acpi_pci_roots and acpi_pci_drivers lists */
static DEFINE_MUTEX(acpi_pci_root_lock);
L
Linus Torvalds 已提交
74
static LIST_HEAD(acpi_pci_roots);
75
static LIST_HEAD(acpi_pci_drivers);
L
Linus Torvalds 已提交
76

77
static DEFINE_MUTEX(osc_lock);
L
Linus Torvalds 已提交
78 79 80 81

int acpi_pci_register_driver(struct acpi_pci_driver *driver)
{
	int n = 0;
82
	struct acpi_pci_root *root;
L
Linus Torvalds 已提交
83

84
	mutex_lock(&acpi_pci_root_lock);
85
	list_add_tail(&driver->node, &acpi_pci_drivers);
86 87
	if (driver->add)
		list_for_each_entry(root, &acpi_pci_roots, node) {
88
			driver->add(root);
89 90 91
			n++;
		}
	mutex_unlock(&acpi_pci_root_lock);
L
Linus Torvalds 已提交
92 93 94 95 96 97 98

	return n;
}
EXPORT_SYMBOL(acpi_pci_register_driver);

void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
{
99
	struct acpi_pci_root *root;
L
Linus Torvalds 已提交
100

101
	mutex_lock(&acpi_pci_root_lock);
102
	list_del(&driver->node);
103 104
	if (driver->remove)
		list_for_each_entry(root, &acpi_pci_roots, node)
105
			driver->remove(root);
106
	mutex_unlock(&acpi_pci_root_lock);
L
Linus Torvalds 已提交
107 108 109
}
EXPORT_SYMBOL(acpi_pci_unregister_driver);

110 111
acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
{
112
	struct acpi_pci_root *root;
113
	acpi_handle handle = NULL;
114
	
115
	mutex_lock(&acpi_pci_root_lock);
116
	list_for_each_entry(root, &acpi_pci_roots, node)
117
		if ((root->segment == (u16) seg) &&
118 119 120 121 122 123
		    (root->secondary.start == (u16) bus)) {
			handle = root->device->handle;
			break;
		}
	mutex_unlock(&acpi_pci_root_lock);
	return handle;
124 125 126 127
}

EXPORT_SYMBOL_GPL(acpi_get_pci_rootbridge_handle);

128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
/**
 * 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 已提交
152
static acpi_status
L
Len Brown 已提交
153
get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
L
Linus Torvalds 已提交
154
{
155
	struct resource *res = data;
L
Linus Torvalds 已提交
156 157
	struct acpi_resource_address64 address;

B
Bob Moore 已提交
158 159 160
	if (resource->type != ACPI_RESOURCE_TYPE_ADDRESS16 &&
	    resource->type != ACPI_RESOURCE_TYPE_ADDRESS32 &&
	    resource->type != ACPI_RESOURCE_TYPE_ADDRESS64)
L
Linus Torvalds 已提交
161 162 163
		return AE_OK;

	acpi_resource_to_address64(resource, &address);
L
Len Brown 已提交
164
	if ((address.address_length > 0) &&
165 166 167 168
	    (address.resource_type == ACPI_BUS_NUMBER_RANGE)) {
		res->start = address.minimum;
		res->end = address.minimum + address.address_length - 1;
	}
L
Linus Torvalds 已提交
169 170 171 172

	return AE_OK;
}

173
static acpi_status try_get_root_bridge_busnr(acpi_handle handle,
174
					     struct resource *res)
L
Linus Torvalds 已提交
175 176 177
{
	acpi_status status;

178
	res->start = -1;
L
Len Brown 已提交
179 180
	status =
	    acpi_walk_resources(handle, METHOD_NAME__CRS,
181
				get_root_bridge_busnr_callback, res);
L
Linus Torvalds 已提交
182 183
	if (ACPI_FAILURE(status))
		return status;
184
	if (res->start == -1)
L
Linus Torvalds 已提交
185 186 187 188
		return AE_ERROR;
	return AE_OK;
}

S
Shaohua Li 已提交
189
static u8 pci_osc_uuid_str[] = "33DB4D5B-1FF7-401C-9657-7441C03DD766";
190 191 192 193

static acpi_status acpi_pci_run_osc(acpi_handle handle,
				    const u32 *capbuf, u32 *retval)
{
S
Shaohua Li 已提交
194 195 196 197 198 199
	struct acpi_osc_context context = {
		.uuid_str = pci_osc_uuid_str,
		.rev = 1,
		.cap.length = 12,
		.cap.pointer = (void *)capbuf,
	};
200 201
	acpi_status status;

S
Shaohua Li 已提交
202 203 204 205
	status = acpi_run_osc(handle, &context);
	if (ACPI_SUCCESS(status)) {
		*retval = *((u32 *)(context.ret.pointer + 8));
		kfree(context.ret.pointer);
206 207 208 209
	}
	return status;
}

210 211 212
static acpi_status acpi_pci_query_osc(struct acpi_pci_root *root,
					u32 support,
					u32 *control)
213 214
{
	acpi_status status;
215 216 217 218
	u32 result, capbuf[3];

	support &= OSC_PCI_SUPPORT_MASKS;
	support |= root->osc_support_set;
219 220

	capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE;
221 222 223 224 225 226 227 228
	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;
	}
229 230 231

	status = acpi_pci_run_osc(root->device->handle, capbuf, &result);
	if (ACPI_SUCCESS(status)) {
232
		root->osc_support_set = support;
233
		if (control)
234
			*control = result;
235 236 237 238 239 240 241 242 243 244 245 246 247
	}
	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);
248
	status = acpi_pci_query_osc(root, flags, NULL);
249 250 251 252
	mutex_unlock(&osc_lock);
	return status;
}

253
struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle)
254 255
{
	struct acpi_pci_root *root;
256
	struct acpi_device *device;
257

258 259 260 261 262 263 264
	if (acpi_bus_get_device(handle, &device) ||
	    acpi_match_device_ids(device, root_device_ids))
		return NULL;

	root = acpi_driver_data(device);

	return root;
265
}
266
EXPORT_SYMBOL_GPL(acpi_pci_find_root);
267

268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 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
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));
335
		if (!pdev || hnd == handle)
336 337 338 339
			break;

		pbus = pdev->subordinate;
		pci_dev_put(pdev);
340 341 342 343 344 345 346 347 348 349 350

		/*
		 * 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;
		}
351 352 353 354 355 356 357 358 359
	}
out:
	list_for_each_entry_safe(node, tmp, &device_list, node)
		kfree(node);

	return pdev;
}
EXPORT_SYMBOL_GPL(acpi_get_pci_dev);

360
/**
361 362 363 364
 * 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.
365
 *
366 367 368 369 370 371 372 373
 * 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.
374
 **/
375
acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 *mask, u32 req)
376
{
377
	struct acpi_pci_root *root;
378
	acpi_status status;
379
	u32 ctrl, capbuf[3];
380 381
	acpi_handle tmp;

382 383 384 385 386
	if (!mask)
		return AE_BAD_PARAMETER;

	ctrl = *mask & OSC_PCI_CONTROL_MASKS;
	if ((ctrl & req) != req)
387 388 389 390 391 392
		return AE_TYPE;

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

393 394 395 396
	status = acpi_get_handle(handle, "_OSC", &tmp);
	if (ACPI_FAILURE(status))
		return status;

397
	mutex_lock(&osc_lock);
398 399

	*mask = ctrl | root->osc_control_set;
400
	/* No need to evaluate _OSC if the control was already granted. */
401
	if ((root->osc_control_set & ctrl) == ctrl)
402 403
		goto out;

404 405 406 407 408 409 410 411 412
	/* 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;
	}
413

414
	if ((ctrl & req) != req) {
415 416 417 418 419 420
		status = AE_SUPPORT;
		goto out;
	}

	capbuf[OSC_QUERY_TYPE] = 0;
	capbuf[OSC_SUPPORT_TYPE] = root->osc_support_set;
421 422
	capbuf[OSC_CONTROL_TYPE] = ctrl;
	status = acpi_pci_run_osc(handle, capbuf, mask);
423
	if (ACPI_SUCCESS(status))
424
		root->osc_control_set = *mask;
425 426 427 428
out:
	mutex_unlock(&osc_lock);
	return status;
}
429
EXPORT_SYMBOL(acpi_pci_osc_control_set);
430

B
Bill Pemberton 已提交
431
static int acpi_pci_root_add(struct acpi_device *device)
L
Linus Torvalds 已提交
432
{
433 434 435 436 437
	unsigned long long segment, bus;
	acpi_status status;
	int result;
	struct acpi_pci_root *root;
	acpi_handle handle;
438
	struct acpi_pci_driver *driver;
439
	u32 flags, base_flags;
440
	bool is_osc_granted = false;
L
Linus Torvalds 已提交
441

442 443 444 445
	root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
	if (!root)
		return -ENOMEM;

446 447 448 449 450
	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");
451 452
		result = -ENODEV;
		goto end;
453
	}
L
Linus Torvalds 已提交
454

455
	/* Check _CRS first, then _BBN.  If no _BBN, default to zero. */
456 457
	root->secondary.flags = IORESOURCE_BUS;
	status = try_get_root_bridge_busnr(device->handle, &root->secondary);
458
	if (ACPI_FAILURE(status)) {
459 460 461 462 463 464 465 466 467
		/*
		 * 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");
J
Jon Mason 已提交
468 469
		status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,
					       NULL, &bus);
470 471 472 473 474 475 476 477
		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;
478 479
		}
	}
L
Linus Torvalds 已提交
480

481
	INIT_LIST_HEAD(&root->node);
482
	root->device = device;
483
	root->segment = segment & 0xFFFF;
L
Linus Torvalds 已提交
484 485
	strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
486
	device->driver_data = root;
L
Linus Torvalds 已提交
487

488
	printk(KERN_INFO PREFIX "%s [%s] (domain %04x %pR)\n",
L
Len Brown 已提交
489
	       acpi_device_name(device), acpi_device_bid(device),
490
	       root->segment, &root->secondary);
L
Linus Torvalds 已提交
491 492 493 494 495 496

	/*
	 * PCI Routing Table
	 * -----------------
	 * Evaluate and parse _PRT, if exists.
	 */
497
	status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
L
Linus Torvalds 已提交
498
	if (ACPI_SUCCESS(status))
499 500 501
		result = acpi_pci_irq_add_prt(device->handle, root->segment,
					      root->secondary.start);

502
	root->mcfg_addr = acpi_pci_root_get_mcfg_addr(device->handle);
L
Linus Torvalds 已提交
503

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

511
	/* Indicate support for various _OSC capabilities. */
512
	if (pci_ext_cfg_avail())
513
		flags |= OSC_EXT_PCI_CONFIG_SUPPORT;
514
	if (pcie_aspm_support_enabled()) {
515
		flags |= OSC_ACTIVE_STATE_PWR_SUPPORT |
516 517
		OSC_CLOCK_PWR_CAPABILITY_SUPPORT;
	}
518 519
	if (pci_msi_enabled())
		flags |= OSC_MSI_SUPPORT;
520 521 522
	if (flags != base_flags) {
		status = acpi_pci_osc_support(root, flags);
		if (ACPI_FAILURE(status)) {
523
			dev_info(&device->dev, "ACPI _OSC support "
524 525 526 527 528
				"notification failed, disabling PCIe ASPM\n");
			pcie_no_aspm();
			flags = base_flags;
		}
	}
529 530 531 532 533 534 535 536
	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())
537
				dev_dbg(&device->dev,
538 539 540 541 542
					"PCIe errors handled by BIOS.\n");
			else
				flags |= OSC_PCI_EXPRESS_AER_CONTROL;
		}

543
		dev_info(&device->dev,
544 545 546
			"Requesting ACPI _OSC control (0x%02x)\n", flags);

		status = acpi_pci_osc_control_set(device->handle, &flags,
547
				       OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);
548
		if (ACPI_SUCCESS(status)) {
549 550
			is_osc_granted = true;
			dev_info(&device->dev,
551
				"ACPI _OSC control (0x%02x) granted\n", flags);
552
		} else {
553 554
			is_osc_granted = false;
			dev_info(&device->dev,
555 556 557
				"ACPI _OSC request failed (%s), "
				"returned control mask: 0x%02x\n",
				acpi_format_exception(status), flags);
558
		}
559
	} else {
560 561 562 563 564
		dev_info(&device->dev,
			"Unable to request _OSC control "
			"(_OSC support mask: 0x%02x)\n", flags);
	}

L
Linus Torvalds 已提交
565 566 567 568
	/*
	 * TBD: Need PCI interface for enumeration/configuration of roots.
	 */

569
	mutex_lock(&acpi_pci_root_lock);
L
Len Brown 已提交
570
	list_add_tail(&root->node, &acpi_pci_roots);
571
	mutex_unlock(&acpi_pci_root_lock);
L
Linus Torvalds 已提交
572 573 574 575 576 577 578 579

	/*
	 * 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).
	 */
580
	root->bus = pci_acpi_scan_root(root);
L
Linus Torvalds 已提交
581
	if (!root->bus) {
582 583
		printk(KERN_ERR PREFIX
			    "Bus %04x:%02x not present in PCI namespace\n",
584
			    root->segment, (unsigned int)root->secondary.start);
L
Linus Torvalds 已提交
585
		result = -ENODEV;
586
		goto out_del_root;
L
Linus Torvalds 已提交
587 588
	}

589 590 591 592
	/* ASPM setting */
	if (is_osc_granted) {
		if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM)
			pcie_clear_aspm(root->bus);
593
	} else {
594 595 596
		pr_info("ACPI _OSC control for PCIe not granted, "
			"disabling ASPM\n");
		pcie_no_aspm();
597 598
	}

599 600 601 602
	pci_acpi_add_bus_pm_notifier(device, root->bus);
	if (device->wakeup.flags.run_wake)
		device_set_run_wake(root->bus->bridge, true);

603 604 605
	if (system_state != SYSTEM_BOOTING)
		pci_assign_unassigned_bus_resources(root->bus);

606
	mutex_lock(&acpi_pci_root_lock);
607 608
	list_for_each_entry(driver, &acpi_pci_drivers, node)
		if (driver->add)
609
			driver->add(root);
610
	mutex_unlock(&acpi_pci_root_lock);
611

612 613 614 615
	/* need to after hot-added ioapic is registered */
	if (system_state != SYSTEM_BOOTING)
		pci_enable_bridges(root->bus);

616 617
	pci_bus_add_devices(root->bus);
	return 0;
618 619 620 621 622 623 624 625 626 627

out_del_root:
	mutex_lock(&acpi_pci_root_lock);
	list_del(&root->node);
	mutex_unlock(&acpi_pci_root_lock);

	acpi_pci_irq_del_prt(root->segment, root->secondary.start);
end:
	kfree(root);
	return result;
628
}
L
Linus Torvalds 已提交
629

L
Len Brown 已提交
630
static int acpi_pci_root_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
631
{
632 633
	acpi_status status;
	acpi_handle handle;
634
	struct acpi_pci_root *root = acpi_driver_data(device);
635 636
	struct acpi_pci_driver *driver;

637 638
	pci_stop_root_bus(root->bus);

639
	mutex_lock(&acpi_pci_root_lock);
640
	list_for_each_entry_reverse(driver, &acpi_pci_drivers, node)
641
		if (driver->remove)
642
			driver->remove(root);
643
	mutex_unlock(&acpi_pci_root_lock);
L
Linus Torvalds 已提交
644

645 646 647
	device_set_run_wake(root->bus->bridge, false);
	pci_acpi_remove_bus_pm_notifier(device);

648 649
	status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
	if (ACPI_SUCCESS(status))
650
		acpi_pci_irq_del_prt(root->segment, root->secondary.start);
651

652 653 654
	pci_remove_root_bus(root->bus);

	mutex_lock(&acpi_pci_root_lock);
655 656
	list_del(&root->node);
	mutex_unlock(&acpi_pci_root_lock);
L
Linus Torvalds 已提交
657
	kfree(root);
658
	return 0;
L
Linus Torvalds 已提交
659 660
}

661
int __init acpi_pci_root_init(void)
L
Linus Torvalds 已提交
662
{
663 664
	acpi_hest_init();

L
Linus Torvalds 已提交
665
	if (acpi_pci_disabled)
666
		return 0;
L
Linus Torvalds 已提交
667

668
	pci_acpi_crs_quirks();
L
Linus Torvalds 已提交
669
	if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0)
670
		return -ENODEV;
L
Linus Torvalds 已提交
671

672
	return 0;
L
Linus Torvalds 已提交
673
}