pci-acpi.c 9.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 * File:	pci-acpi.c
3
 * Purpose:	Provide PCI support in ACPI
L
Linus Torvalds 已提交
4
 *
5 6 7
 * Copyright (C) 2005 David Shaohua Li <shaohua.li@intel.com>
 * Copyright (C) 2004 Tom Long Nguyen <tom.l.nguyen@intel.com>
 * Copyright (C) 2004 Intel Corp.
L
Linus Torvalds 已提交
8 9 10 11 12 13
 */

#include <linux/delay.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/module.h>
14
#include <linux/pci-aspm.h>
L
Linus Torvalds 已提交
15 16 17 18
#include <acpi/acpi.h>
#include <acpi/acpi_bus.h>

#include <linux/pci-acpi.h>
19
#include <linux/pm_runtime.h>
20
#include "pci.h"
L
Linus Torvalds 已提交
21

22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
static DEFINE_MUTEX(pci_acpi_pm_notify_mtx);

/**
 * pci_acpi_wake_bus - Wake-up notification handler for root buses.
 * @handle: ACPI handle of a device the notification is for.
 * @event: Type of the signaled event.
 * @context: PCI root bus to wake up devices on.
 */
static void pci_acpi_wake_bus(acpi_handle handle, u32 event, void *context)
{
	struct pci_bus *pci_bus = context;

	if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_bus)
		pci_pme_wakeup_bus(pci_bus);
}

/**
 * pci_acpi_wake_dev - Wake-up notification handler for PCI devices.
 * @handle: ACPI handle of a device the notification is for.
 * @event: Type of the signaled event.
 * @context: PCI device object to wake up.
 */
static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context)
{
	struct pci_dev *pci_dev = context;

48 49 50 51 52
	if (event != ACPI_NOTIFY_DEVICE_WAKE || !pci_dev)
		return;

	if (!pci_dev->pm_cap || !pci_dev->pme_support
	     || pci_check_pme_status(pci_dev)) {
53 54 55
		if (pci_dev->pme_poll)
			pci_dev->pme_poll = false;

56
		pci_wakeup_event(pci_dev);
57 58
		pm_runtime_resume(&pci_dev->dev);
	}
59 60 61

	if (pci_dev->subordinate)
		pci_pme_wakeup_bus(pci_dev->subordinate);
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
}

/**
 * add_pm_notifier - Register PM notifier for given ACPI device.
 * @dev: ACPI device to add the notifier for.
 * @context: PCI device or bus to check for PME status if an event is signaled.
 *
 * NOTE: @dev need not be a run-wake or wake-up device to be a valid source of
 * PM wake-up events.  For example, wake-up events may be generated for bridges
 * if one of the devices below the bridge is signaling PME, even if the bridge
 * itself doesn't have a wake-up GPE associated with it.
 */
static acpi_status add_pm_notifier(struct acpi_device *dev,
				   acpi_notify_handler handler,
				   void *context)
{
	acpi_status status = AE_ALREADY_EXISTS;

	mutex_lock(&pci_acpi_pm_notify_mtx);

	if (dev->wakeup.flags.notifier_present)
		goto out;

	status = acpi_install_notify_handler(dev->handle,
					     ACPI_SYSTEM_NOTIFY,
					     handler, context);
	if (ACPI_FAILURE(status))
		goto out;

	dev->wakeup.flags.notifier_present = true;

 out:
	mutex_unlock(&pci_acpi_pm_notify_mtx);
	return status;
}

/**
 * remove_pm_notifier - Unregister PM notifier from given ACPI device.
 * @dev: ACPI device to remove the notifier from.
 */
static acpi_status remove_pm_notifier(struct acpi_device *dev,
				      acpi_notify_handler handler)
{
	acpi_status status = AE_BAD_PARAMETER;

	mutex_lock(&pci_acpi_pm_notify_mtx);

	if (!dev->wakeup.flags.notifier_present)
		goto out;

	status = acpi_remove_notify_handler(dev->handle,
					    ACPI_SYSTEM_NOTIFY,
					    handler);
	if (ACPI_FAILURE(status))
		goto out;

	dev->wakeup.flags.notifier_present = false;

 out:
	mutex_unlock(&pci_acpi_pm_notify_mtx);
	return status;
}

/**
 * pci_acpi_add_bus_pm_notifier - Register PM notifier for given PCI bus.
 * @dev: ACPI device to add the notifier for.
 * @pci_bus: PCI bus to walk checking for PME status if an event is signaled.
 */
acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev,
					 struct pci_bus *pci_bus)
{
	return add_pm_notifier(dev, pci_acpi_wake_bus, pci_bus);
}

/**
 * pci_acpi_remove_bus_pm_notifier - Unregister PCI bus PM notifier.
 * @dev: ACPI device to remove the notifier from.
 */
acpi_status pci_acpi_remove_bus_pm_notifier(struct acpi_device *dev)
{
	return remove_pm_notifier(dev, pci_acpi_wake_bus);
}

/**
 * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device.
 * @dev: ACPI device to add the notifier for.
 * @pci_dev: PCI device to check for the PME status if an event is signaled.
 */
acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev,
				     struct pci_dev *pci_dev)
{
	return add_pm_notifier(dev, pci_acpi_wake_dev, pci_dev);
}

/**
 * pci_acpi_remove_pm_notifier - Unregister PCI device PM notifier.
 * @dev: ACPI device to remove the notifier from.
 */
acpi_status pci_acpi_remove_pm_notifier(struct acpi_device *dev)
{
	return remove_pm_notifier(dev, pci_acpi_wake_dev);
}

165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
/*
 * _SxD returns the D-state with the highest power
 * (lowest D-state number) supported in the S-state "x".
 *
 * If the devices does not have a _PRW
 * (Power Resources for Wake) supporting system wakeup from "x"
 * then the OS is free to choose a lower power (higher number
 * D-state) than the return value from _SxD.
 *
 * But if _PRW is enabled at S-state "x", the OS
 * must not choose a power lower than _SxD --
 * unless the device has an _SxW method specifying
 * the lowest power (highest D-state number) the device
 * may enter while still able to wake the system.
 *
 * ie. depending on global OS policy:
 *
 * if (_PRW at S-state x)
 *	choose from highest power _SxD to lowest power _SxW
 * else // no _PRW at S-state x
 * 	choose highest power _SxD or any lower power
 */

188
static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
189
{
190
	int acpi_state;
191

192
	acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL);
193 194 195 196 197 198 199 200 201 202
	if (acpi_state < 0)
		return PCI_POWER_ERROR;

	switch (acpi_state) {
	case ACPI_STATE_D0:
		return PCI_D0;
	case ACPI_STATE_D1:
		return PCI_D1;
	case ACPI_STATE_D2:
		return PCI_D2;
L
Lin Ming 已提交
203
	case ACPI_STATE_D3_HOT:
204
		return PCI_D3hot;
L
Lin Ming 已提交
205 206
	case ACPI_STATE_D3_COLD:
		return PCI_D3cold;
207 208
	}
	return PCI_POWER_ERROR;
209
}
210 211 212 213 214 215 216

static bool acpi_pci_power_manageable(struct pci_dev *dev)
{
	acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);

	return handle ? acpi_bus_power_manageable(handle) : false;
}
217

218 219 220
static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
{
	acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
221
	acpi_handle tmp;
222 223 224 225
	static const u8 state_conv[] = {
		[PCI_D0] = ACPI_STATE_D0,
		[PCI_D1] = ACPI_STATE_D1,
		[PCI_D2] = ACPI_STATE_D2,
L
Lin Ming 已提交
226
		[PCI_D3hot] = ACPI_STATE_D3_HOT,
227
		[PCI_D3cold] = ACPI_STATE_D3
228
	};
229
	int error = -EINVAL;
230

231
	/* If the ACPI device has _EJ0, ignore the device */
232 233
	if (!handle || ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp)))
		return -ENODEV;
234 235 236 237 238 239 240

	switch (state) {
	case PCI_D0:
	case PCI_D1:
	case PCI_D2:
	case PCI_D3hot:
	case PCI_D3cold:
241
		error = acpi_bus_set_power(handle, state_conv[state]);
242
	}
243 244 245 246 247 248

	if (!error)
		dev_printk(KERN_INFO, &dev->dev,
				"power state changed by ACPI to D%d\n", state);

	return error;
249 250
}

251 252 253 254 255 256 257
static bool acpi_pci_can_wakeup(struct pci_dev *dev)
{
	acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);

	return handle ? acpi_bus_can_wakeup(handle) : false;
}

258 259 260
static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable)
{
	while (bus->parent) {
261
		if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable))
262 263 264 265 266 267 268 269 270
			return;
		bus = bus->parent;
	}

	/* We have reached the root bus. */
	if (bus->bridge)
		acpi_pm_device_sleep_wake(bus->bridge, enable);
}

271 272
static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
{
273 274 275
	if (acpi_pci_can_wakeup(dev))
		return acpi_pm_device_sleep_wake(&dev->dev, enable);

276
	acpi_pci_propagate_wakeup_enable(dev->bus, enable);
277
	return 0;
278 279
}

280 281 282 283 284 285 286
static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable)
{
	while (bus->parent) {
		struct pci_dev *bridge = bus->self;

		if (bridge->pme_interrupt)
			return;
287
		if (!acpi_pm_device_run_wake(&bridge->dev, enable))
288 289 290 291 292 293
			return;
		bus = bus->parent;
	}

	/* We have reached the root bus. */
	if (bus->bridge)
294
		acpi_pm_device_run_wake(bus->bridge, enable);
295 296 297 298 299 300 301
}

static int acpi_pci_run_wake(struct pci_dev *dev, bool enable)
{
	if (dev->pme_interrupt)
		return 0;

302
	if (!acpi_pm_device_run_wake(&dev->dev, enable))
303 304 305 306 307 308
		return 0;

	acpi_pci_propagate_run_wake(dev->bus, enable);
	return 0;
}

309 310 311 312
static struct pci_platform_pm_ops acpi_pci_platform_pm = {
	.is_manageable = acpi_pci_power_manageable,
	.set_state = acpi_pci_set_power_state,
	.choose_state = acpi_pci_choose_state,
313 314
	.can_wakeup = acpi_pci_can_wakeup,
	.sleep_wake = acpi_pci_sleep_wake,
315
	.run_wake = acpi_pci_run_wake,
316
};
317

318
/* ACPI bus type */
319
static int acpi_pci_find_device(struct device *dev, acpi_handle *handle)
320 321
{
	struct pci_dev * pci_dev;
L
Lin Ming 已提交
322
	u64	addr;
323 324 325 326 327 328 329 330 331 332

	pci_dev = to_pci_dev(dev);
	/* Please ref to ACPI spec for the syntax of _ADR */
	addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
	*handle = acpi_get_child(DEVICE_ACPI_HANDLE(dev->parent), addr);
	if (!*handle)
		return -ENODEV;
	return 0;
}

333
static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle)
334 335 336 337 338 339 340 341
{
	int num;
	unsigned int seg, bus;

	/*
	 * The string should be the same as root bridge's name
	 * Please look at 'pci_scan_bus_parented'
	 */
342
	num = sscanf(dev_name(dev), "pci%04x:%02x", &seg, &bus);
343 344 345 346 347 348 349 350
	if (num != 2)
		return -ENODEV;
	*handle = acpi_get_pci_rootbridge_handle(seg, bus);
	if (!*handle)
		return -ENODEV;
	return 0;
}

351
static struct acpi_bus_type acpi_pci_bus = {
352
	.bus = &pci_bus_type,
353 354
	.find_device = acpi_pci_find_device,
	.find_bridge = acpi_pci_find_root_bridge,
355 356
};

357
static int __init acpi_pci_init(void)
358 359 360
{
	int ret;

B
Bob Moore 已提交
361
	if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) {
362 363 364
		printk(KERN_INFO"ACPI FADT declares the system doesn't support MSI, so disable it\n");
		pci_no_msi();
	}
365

B
Bob Moore 已提交
366
	if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
367 368 369 370
		printk(KERN_INFO"ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
		pcie_no_aspm();
	}

371
	ret = register_acpi_bus_type(&acpi_pci_bus);
372 373
	if (ret)
		return 0;
374
	pci_set_platform_pm(&acpi_pci_platform_pm);
375 376
	return 0;
}
377
arch_initcall(acpi_pci_init);