1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * drivers/acpi/device_pm.c - ACPI device power management routines.
   4 *
   5 * Copyright (C) 2012, Intel Corp.
   6 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
   7 *
   8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9 *
  10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  11 */
  12
 
 
  13#include <linux/acpi.h>
  14#include <linux/export.h>
  15#include <linux/mutex.h>
  16#include <linux/pm_qos.h>
  17#include <linux/pm_domain.h>
  18#include <linux/pm_runtime.h>
  19#include <linux/suspend.h>
  20
 
  21#include "internal.h"
  22
  23#define _COMPONENT	ACPI_POWER_COMPONENT
  24ACPI_MODULE_NAME("device_pm");
  25
  26/**
  27 * acpi_power_state_string - String representation of ACPI device power state.
  28 * @state: ACPI device power state to return the string representation of.
  29 */
  30const char *acpi_power_state_string(int state)
  31{
  32	switch (state) {
  33	case ACPI_STATE_D0:
  34		return "D0";
  35	case ACPI_STATE_D1:
  36		return "D1";
  37	case ACPI_STATE_D2:
  38		return "D2";
  39	case ACPI_STATE_D3_HOT:
  40		return "D3hot";
  41	case ACPI_STATE_D3_COLD:
  42		return "D3cold";
  43	default:
  44		return "(unknown)";
  45	}
  46}
  47
  48static int acpi_dev_pm_explicit_get(struct acpi_device *device, int *state)
  49{
  50	unsigned long long psc;
  51	acpi_status status;
  52
  53	status = acpi_evaluate_integer(device->handle, "_PSC", NULL, &psc);
  54	if (ACPI_FAILURE(status))
  55		return -ENODEV;
  56
  57	*state = psc;
  58	return 0;
  59}
  60
  61/**
  62 * acpi_device_get_power - Get power state of an ACPI device.
  63 * @device: Device to get the power state of.
  64 * @state: Place to store the power state of the device.
  65 *
  66 * This function does not update the device's power.state field, but it may
  67 * update its parent's power.state field (when the parent's power state is
  68 * unknown and the device's power state turns out to be D0).
  69 *
  70 * Also, it does not update power resource reference counters to ensure that
  71 * the power state returned by it will be persistent and it may return a power
  72 * state shallower than previously set by acpi_device_set_power() for @device
  73 * (if that power state depends on any power resources).
  74 */
  75int acpi_device_get_power(struct acpi_device *device, int *state)
  76{
  77	int result = ACPI_STATE_UNKNOWN;
 
  78	int error;
  79
  80	if (!device || !state)
  81		return -EINVAL;
  82
 
 
  83	if (!device->flags.power_manageable) {
  84		/* TBD: Non-recursive algorithm for walking up hierarchy. */
  85		*state = device->parent ?
  86			device->parent->power.state : ACPI_STATE_D0;
  87		goto out;
  88	}
  89
  90	/*
  91	 * Get the device's power state from power resources settings and _PSC,
  92	 * if available.
  93	 */
  94	if (device->power.flags.power_resources) {
  95		error = acpi_power_get_inferred_state(device, &result);
  96		if (error)
  97			return error;
  98	}
  99	if (device->power.flags.explicit_get) {
 100		int psc;
 101
 102		error = acpi_dev_pm_explicit_get(device, &psc);
 103		if (error)
 104			return error;
 105
 106		/*
 107		 * The power resources settings may indicate a power state
 108		 * shallower than the actual power state of the device, because
 109		 * the same power resources may be referenced by other devices.
 110		 *
 111		 * For systems predating ACPI 4.0 we assume that D3hot is the
 112		 * deepest state that can be supported.
 113		 */
 114		if (psc > result && psc < ACPI_STATE_D3_COLD)
 115			result = psc;
 116		else if (result == ACPI_STATE_UNKNOWN)
 117			result = psc > ACPI_STATE_D2 ? ACPI_STATE_D3_HOT : psc;
 118	}
 119
 120	/*
 121	 * If we were unsure about the device parent's power state up to this
 122	 * point, the fact that the device is in D0 implies that the parent has
 123	 * to be in D0 too, except if ignore_parent is set.
 124	 */
 125	if (!device->power.flags.ignore_parent && device->parent
 126	    && device->parent->power.state == ACPI_STATE_UNKNOWN
 127	    && result == ACPI_STATE_D0)
 128		device->parent->power.state = ACPI_STATE_D0;
 129
 130	*state = result;
 131
 132 out:
 133	ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is %s\n",
 134			  device->pnp.bus_id, acpi_power_state_string(*state)));
 135
 136	return 0;
 137}
 138
 139static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state)
 140{
 141	if (adev->power.states[state].flags.explicit_set) {
 142		char method[5] = { '_', 'P', 'S', '0' + state, '\0' };
 143		acpi_status status;
 144
 145		status = acpi_evaluate_object(adev->handle, method, NULL, NULL);
 146		if (ACPI_FAILURE(status))
 147			return -ENODEV;
 148	}
 149	return 0;
 150}
 151
 152/**
 153 * acpi_device_set_power - Set power state of an ACPI device.
 154 * @device: Device to set the power state of.
 155 * @state: New power state to set.
 156 *
 157 * Callers must ensure that the device is power manageable before using this
 158 * function.
 159 */
 160int acpi_device_set_power(struct acpi_device *device, int state)
 161{
 162	int target_state = state;
 163	int result = 0;
 164
 165	if (!device || !device->flags.power_manageable
 166	    || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
 167		return -EINVAL;
 168
 169	acpi_handle_debug(device->handle, "Power state change: %s -> %s\n",
 170			  acpi_power_state_string(device->power.state),
 171			  acpi_power_state_string(state));
 172
 173	/* Make sure this is a valid target state */
 174
 175	/* There is a special case for D0 addressed below. */
 176	if (state > ACPI_STATE_D0 && state == device->power.state) {
 177		ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already in %s\n",
 178				  device->pnp.bus_id,
 179				  acpi_power_state_string(state)));
 180		return 0;
 181	}
 182
 183	if (state == ACPI_STATE_D3_COLD) {
 184		/*
 185		 * For transitions to D3cold we need to execute _PS3 and then
 186		 * possibly drop references to the power resources in use.
 187		 */
 188		state = ACPI_STATE_D3_HOT;
 189		/* If D3cold is not supported, use D3hot as the target state. */
 190		if (!device->power.states[ACPI_STATE_D3_COLD].flags.valid)
 191			target_state = state;
 192	} else if (!device->power.states[state].flags.valid) {
 193		dev_warn(&device->dev, "Power state %s not supported\n",
 194			 acpi_power_state_string(state));
 195		return -ENODEV;
 196	}
 197
 198	if (!device->power.flags.ignore_parent &&
 199	    device->parent && (state < device->parent->power.state)) {
 200		dev_warn(&device->dev,
 201			 "Cannot transition to power state %s for parent in %s\n",
 202			 acpi_power_state_string(state),
 203			 acpi_power_state_string(device->parent->power.state));
 204		return -ENODEV;
 
 
 
 
 205	}
 206
 207	/*
 208	 * Transition Power
 209	 * ----------------
 210	 * In accordance with ACPI 6, _PSx is executed before manipulating power
 211	 * resources, unless the target state is D0, in which case _PS0 is
 212	 * supposed to be executed after turning the power resources on.
 213	 */
 214	if (state > ACPI_STATE_D0) {
 215		/*
 216		 * According to ACPI 6, devices cannot go from lower-power
 217		 * (deeper) states to higher-power (shallower) states.
 218		 */
 219		if (state < device->power.state) {
 220			dev_warn(&device->dev, "Cannot transition from %s to %s\n",
 221				 acpi_power_state_string(device->power.state),
 222				 acpi_power_state_string(state));
 
 223			return -ENODEV;
 224		}
 225
 226		/*
 227		 * If the device goes from D3hot to D3cold, _PS3 has been
 228		 * evaluated for it already, so skip it in that case.
 229		 */
 230		if (device->power.state < ACPI_STATE_D3_HOT) {
 231			result = acpi_dev_pm_explicit_set(device, state);
 232			if (result)
 233				goto end;
 234		}
 235
 236		if (device->power.flags.power_resources)
 237			result = acpi_power_transition(device, target_state);
 238	} else {
 239		int cur_state = device->power.state;
 240
 241		if (device->power.flags.power_resources) {
 242			result = acpi_power_transition(device, ACPI_STATE_D0);
 243			if (result)
 244				goto end;
 245		}
 246
 247		if (cur_state == ACPI_STATE_D0) {
 248			int psc;
 249
 250			/* Nothing to do here if _PSC is not present. */
 251			if (!device->power.flags.explicit_get)
 252				return 0;
 253
 254			/*
 255			 * The power state of the device was set to D0 last
 256			 * time, but that might have happened before a
 257			 * system-wide transition involving the platform
 258			 * firmware, so it may be necessary to evaluate _PS0
 259			 * for the device here.  However, use extra care here
 260			 * and evaluate _PSC to check the device's current power
 261			 * state, and only invoke _PS0 if the evaluation of _PSC
 262			 * is successful and it returns a power state different
 263			 * from D0.
 264			 */
 265			result = acpi_dev_pm_explicit_get(device, &psc);
 266			if (result || psc == ACPI_STATE_D0)
 267				return 0;
 268		}
 269
 270		result = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
 271	}
 272
 273 end:
 274	if (result) {
 275		dev_warn(&device->dev, "Failed to change power state to %s\n",
 276			 acpi_power_state_string(target_state));
 
 277	} else {
 278		device->power.state = target_state;
 279		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 280				  "Device [%s] transitioned to %s\n",
 281				  device->pnp.bus_id,
 282				  acpi_power_state_string(target_state)));
 283	}
 284
 285	return result;
 
 
 
 
 
 286}
 287EXPORT_SYMBOL(acpi_device_set_power);
 288
 289int acpi_bus_set_power(acpi_handle handle, int state)
 290{
 291	struct acpi_device *device;
 292	int result;
 293
 294	result = acpi_bus_get_device(handle, &device);
 295	if (result)
 296		return result;
 297
 298	return acpi_device_set_power(device, state);
 299}
 300EXPORT_SYMBOL(acpi_bus_set_power);
 301
 302int acpi_bus_init_power(struct acpi_device *device)
 303{
 304	int state;
 305	int result;
 306
 307	if (!device)
 308		return -EINVAL;
 309
 310	device->power.state = ACPI_STATE_UNKNOWN;
 311	if (!acpi_device_is_present(device)) {
 312		device->flags.initialized = false;
 313		return -ENXIO;
 314	}
 315
 316	result = acpi_device_get_power(device, &state);
 317	if (result)
 318		return result;
 319
 320	if (state < ACPI_STATE_D3_COLD && device->power.flags.power_resources) {
 321		/* Reference count the power resources. */
 322		result = acpi_power_on_resources(device, state);
 323		if (result)
 324			return result;
 325
 326		if (state == ACPI_STATE_D0) {
 327			/*
 328			 * If _PSC is not present and the state inferred from
 329			 * power resources appears to be D0, it still may be
 330			 * necessary to execute _PS0 at this point, because
 331			 * another device using the same power resources may
 332			 * have been put into D0 previously and that's why we
 333			 * see D0 here.
 334			 */
 335			result = acpi_dev_pm_explicit_set(device, state);
 336			if (result)
 337				return result;
 338		}
 339	} else if (state == ACPI_STATE_UNKNOWN) {
 340		/*
 341		 * No power resources and missing _PSC?  Cross fingers and make
 342		 * it D0 in hope that this is what the BIOS put the device into.
 343		 * [We tried to force D0 here by executing _PS0, but that broke
 344		 * Toshiba P870-303 in a nasty way.]
 345		 */
 346		state = ACPI_STATE_D0;
 347	}
 348	device->power.state = state;
 349	return 0;
 350}
 351
 352/**
 353 * acpi_device_fix_up_power - Force device with missing _PSC into D0.
 354 * @device: Device object whose power state is to be fixed up.
 355 *
 356 * Devices without power resources and _PSC, but having _PS0 and _PS3 defined,
 357 * are assumed to be put into D0 by the BIOS.  However, in some cases that may
 358 * not be the case and this function should be used then.
 359 */
 360int acpi_device_fix_up_power(struct acpi_device *device)
 361{
 362	int ret = 0;
 363
 364	if (!device->power.flags.power_resources
 365	    && !device->power.flags.explicit_get
 366	    && device->power.state == ACPI_STATE_D0)
 367		ret = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
 368
 369	return ret;
 370}
 371EXPORT_SYMBOL_GPL(acpi_device_fix_up_power);
 372
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 373int acpi_device_update_power(struct acpi_device *device, int *state_p)
 374{
 375	int state;
 376	int result;
 377
 378	if (device->power.state == ACPI_STATE_UNKNOWN) {
 379		result = acpi_bus_init_power(device);
 380		if (!result && state_p)
 381			*state_p = device->power.state;
 382
 383		return result;
 384	}
 385
 386	result = acpi_device_get_power(device, &state);
 387	if (result)
 388		return result;
 389
 390	if (state == ACPI_STATE_UNKNOWN) {
 391		state = ACPI_STATE_D0;
 392		result = acpi_device_set_power(device, state);
 393		if (result)
 394			return result;
 395	} else {
 396		if (device->power.flags.power_resources) {
 397			/*
 398			 * We don't need to really switch the state, bu we need
 399			 * to update the power resources' reference counters.
 400			 */
 401			result = acpi_power_transition(device, state);
 402			if (result)
 403				return result;
 404		}
 405		device->power.state = state;
 406	}
 407	if (state_p)
 408		*state_p = state;
 409
 410	return 0;
 411}
 412EXPORT_SYMBOL_GPL(acpi_device_update_power);
 413
 414int acpi_bus_update_power(acpi_handle handle, int *state_p)
 415{
 416	struct acpi_device *device;
 417	int result;
 
 
 418
 419	result = acpi_bus_get_device(handle, &device);
 420	return result ? result : acpi_device_update_power(device, state_p);
 421}
 422EXPORT_SYMBOL_GPL(acpi_bus_update_power);
 423
 424bool acpi_bus_power_manageable(acpi_handle handle)
 425{
 426	struct acpi_device *device;
 427	int result;
 428
 429	result = acpi_bus_get_device(handle, &device);
 430	return result ? false : device->flags.power_manageable;
 431}
 432EXPORT_SYMBOL(acpi_bus_power_manageable);
 433
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 434#ifdef CONFIG_PM
 435static DEFINE_MUTEX(acpi_pm_notifier_lock);
 436static DEFINE_MUTEX(acpi_pm_notifier_install_lock);
 437
 438void acpi_pm_wakeup_event(struct device *dev)
 439{
 440	pm_wakeup_dev_event(dev, 0, acpi_s2idle_wakeup());
 441}
 442EXPORT_SYMBOL_GPL(acpi_pm_wakeup_event);
 443
 444static void acpi_pm_notify_handler(acpi_handle handle, u32 val, void *not_used)
 445{
 446	struct acpi_device *adev;
 447
 448	if (val != ACPI_NOTIFY_DEVICE_WAKE)
 449		return;
 450
 451	acpi_handle_debug(handle, "Wake notify\n");
 452
 453	adev = acpi_bus_get_acpi_device(handle);
 454	if (!adev)
 455		return;
 456
 457	mutex_lock(&acpi_pm_notifier_lock);
 458
 459	if (adev->wakeup.flags.notifier_present) {
 460		pm_wakeup_ws_event(adev->wakeup.ws, 0, acpi_s2idle_wakeup());
 461		if (adev->wakeup.context.func) {
 462			acpi_handle_debug(handle, "Running %pS for %s\n",
 463					  adev->wakeup.context.func,
 464					  dev_name(adev->wakeup.context.dev));
 465			adev->wakeup.context.func(&adev->wakeup.context);
 466		}
 467	}
 468
 469	mutex_unlock(&acpi_pm_notifier_lock);
 470
 471	acpi_bus_put_acpi_device(adev);
 472}
 473
 474/**
 475 * acpi_add_pm_notifier - Register PM notify handler for given ACPI device.
 476 * @adev: ACPI device to add the notify handler for.
 477 * @dev: Device to generate a wakeup event for while handling the notification.
 478 * @func: Work function to execute when handling the notification.
 479 *
 480 * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of
 481 * PM wakeup events.  For example, wakeup events may be generated for bridges
 482 * if one of the devices below the bridge is signaling wakeup, even if the
 483 * bridge itself doesn't have a wakeup GPE associated with it.
 484 */
 485acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,
 486			void (*func)(struct acpi_device_wakeup_context *context))
 487{
 488	acpi_status status = AE_ALREADY_EXISTS;
 489
 490	if (!dev && !func)
 491		return AE_BAD_PARAMETER;
 492
 493	mutex_lock(&acpi_pm_notifier_install_lock);
 494
 495	if (adev->wakeup.flags.notifier_present)
 496		goto out;
 497
 498	status = acpi_install_notify_handler(adev->handle, ACPI_SYSTEM_NOTIFY,
 499					     acpi_pm_notify_handler, NULL);
 500	if (ACPI_FAILURE(status))
 501		goto out;
 502
 503	mutex_lock(&acpi_pm_notifier_lock);
 504	adev->wakeup.ws = wakeup_source_register(&adev->dev,
 505						 dev_name(&adev->dev));
 506	adev->wakeup.context.dev = dev;
 507	adev->wakeup.context.func = func;
 508	adev->wakeup.flags.notifier_present = true;
 509	mutex_unlock(&acpi_pm_notifier_lock);
 510
 511 out:
 512	mutex_unlock(&acpi_pm_notifier_install_lock);
 513	return status;
 514}
 515
 516/**
 517 * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device.
 518 * @adev: ACPI device to remove the notifier from.
 519 */
 520acpi_status acpi_remove_pm_notifier(struct acpi_device *adev)
 521{
 522	acpi_status status = AE_BAD_PARAMETER;
 523
 524	mutex_lock(&acpi_pm_notifier_install_lock);
 525
 526	if (!adev->wakeup.flags.notifier_present)
 527		goto out;
 528
 529	status = acpi_remove_notify_handler(adev->handle,
 530					    ACPI_SYSTEM_NOTIFY,
 531					    acpi_pm_notify_handler);
 532	if (ACPI_FAILURE(status))
 533		goto out;
 534
 535	mutex_lock(&acpi_pm_notifier_lock);
 536	adev->wakeup.context.func = NULL;
 537	adev->wakeup.context.dev = NULL;
 538	wakeup_source_unregister(adev->wakeup.ws);
 539	adev->wakeup.flags.notifier_present = false;
 540	mutex_unlock(&acpi_pm_notifier_lock);
 541
 542 out:
 543	mutex_unlock(&acpi_pm_notifier_install_lock);
 544	return status;
 545}
 546
 547bool acpi_bus_can_wakeup(acpi_handle handle)
 548{
 549	struct acpi_device *device;
 550	int result;
 551
 552	result = acpi_bus_get_device(handle, &device);
 553	return result ? false : device->wakeup.flags.valid;
 554}
 555EXPORT_SYMBOL(acpi_bus_can_wakeup);
 556
 557bool acpi_pm_device_can_wakeup(struct device *dev)
 558{
 559	struct acpi_device *adev = ACPI_COMPANION(dev);
 560
 561	return adev ? acpi_device_can_wakeup(adev) : false;
 562}
 563
 564/**
 565 * acpi_dev_pm_get_state - Get preferred power state of ACPI device.
 566 * @dev: Device whose preferred target power state to return.
 567 * @adev: ACPI device node corresponding to @dev.
 568 * @target_state: System state to match the resultant device state.
 569 * @d_min_p: Location to store the highest power state available to the device.
 570 * @d_max_p: Location to store the lowest power state available to the device.
 571 *
 572 * Find the lowest power (highest number) and highest power (lowest number) ACPI
 573 * device power states that the device can be in while the system is in the
 574 * state represented by @target_state.  Store the integer numbers representing
 575 * those stats in the memory locations pointed to by @d_max_p and @d_min_p,
 576 * respectively.
 577 *
 578 * Callers must ensure that @dev and @adev are valid pointers and that @adev
 579 * actually corresponds to @dev before using this function.
 580 *
 581 * Returns 0 on success or -ENODATA when one of the ACPI methods fails or
 582 * returns a value that doesn't make sense.  The memory locations pointed to by
 583 * @d_max_p and @d_min_p are only modified on success.
 584 */
 585static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev,
 586				 u32 target_state, int *d_min_p, int *d_max_p)
 587{
 588	char method[] = { '_', 'S', '0' + target_state, 'D', '\0' };
 589	acpi_handle handle = adev->handle;
 590	unsigned long long ret;
 591	int d_min, d_max;
 592	bool wakeup = false;
 593	bool has_sxd = false;
 594	acpi_status status;
 595
 596	/*
 597	 * If the system state is S0, the lowest power state the device can be
 598	 * in is D3cold, unless the device has _S0W and is supposed to signal
 599	 * wakeup, in which case the return value of _S0W has to be used as the
 600	 * lowest power state available to the device.
 601	 */
 602	d_min = ACPI_STATE_D0;
 603	d_max = ACPI_STATE_D3_COLD;
 604
 605	/*
 606	 * If present, _SxD methods return the minimum D-state (highest power
 607	 * state) we can use for the corresponding S-states.  Otherwise, the
 608	 * minimum D-state is D0 (ACPI 3.x).
 609	 */
 610	if (target_state > ACPI_STATE_S0) {
 611		/*
 612		 * We rely on acpi_evaluate_integer() not clobbering the integer
 613		 * provided if AE_NOT_FOUND is returned.
 614		 */
 615		ret = d_min;
 616		status = acpi_evaluate_integer(handle, method, NULL, &ret);
 617		if ((ACPI_FAILURE(status) && status != AE_NOT_FOUND)
 618		    || ret > ACPI_STATE_D3_COLD)
 619			return -ENODATA;
 620
 621		/*
 622		 * We need to handle legacy systems where D3hot and D3cold are
 623		 * the same and 3 is returned in both cases, so fall back to
 624		 * D3cold if D3hot is not a valid state.
 625		 */
 626		if (!adev->power.states[ret].flags.valid) {
 627			if (ret == ACPI_STATE_D3_HOT)
 628				ret = ACPI_STATE_D3_COLD;
 629			else
 630				return -ENODATA;
 631		}
 632
 633		if (status == AE_OK)
 634			has_sxd = true;
 635
 636		d_min = ret;
 637		wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid
 638			&& adev->wakeup.sleep_state >= target_state;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 639	} else {
 
 640		wakeup = adev->wakeup.flags.valid;
 641	}
 642
 643	/*
 644	 * If _PRW says we can wake up the system from the target sleep state,
 645	 * the D-state returned by _SxD is sufficient for that (we assume a
 646	 * wakeup-aware driver if wake is set).  Still, if _SxW exists
 647	 * (ACPI 3.x), it should return the maximum (lowest power) D-state that
 648	 * can wake the system.  _S0W may be valid, too.
 649	 */
 650	if (wakeup) {
 651		method[3] = 'W';
 652		status = acpi_evaluate_integer(handle, method, NULL, &ret);
 653		if (status == AE_NOT_FOUND) {
 654			/* No _SxW. In this case, the ACPI spec says that we
 655			 * must not go into any power state deeper than the
 656			 * value returned from _SxD.
 657			 */
 658			if (has_sxd && target_state > ACPI_STATE_S0)
 659				d_max = d_min;
 660		} else if (ACPI_SUCCESS(status) && ret <= ACPI_STATE_D3_COLD) {
 661			/* Fall back to D3cold if ret is not a valid state. */
 662			if (!adev->power.states[ret].flags.valid)
 663				ret = ACPI_STATE_D3_COLD;
 664
 665			d_max = ret > d_min ? ret : d_min;
 666		} else {
 667			return -ENODATA;
 668		}
 669	}
 670
 671	if (d_min_p)
 672		*d_min_p = d_min;
 673
 674	if (d_max_p)
 675		*d_max_p = d_max;
 676
 677	return 0;
 678}
 679
 680/**
 681 * acpi_pm_device_sleep_state - Get preferred power state of ACPI device.
 682 * @dev: Device whose preferred target power state to return.
 683 * @d_min_p: Location to store the upper limit of the allowed states range.
 684 * @d_max_in: Deepest low-power state to take into consideration.
 685 * Return value: Preferred power state of the device on success, -ENODEV
 686 * if there's no 'struct acpi_device' for @dev, -EINVAL if @d_max_in is
 687 * incorrect, or -ENODATA on ACPI method failure.
 688 *
 689 * The caller must ensure that @dev is valid before using this function.
 690 */
 691int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)
 692{
 693	struct acpi_device *adev;
 694	int ret, d_min, d_max;
 695
 696	if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3_COLD)
 697		return -EINVAL;
 698
 699	if (d_max_in > ACPI_STATE_D2) {
 700		enum pm_qos_flags_status stat;
 701
 702		stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF);
 703		if (stat == PM_QOS_FLAGS_ALL)
 704			d_max_in = ACPI_STATE_D2;
 705	}
 706
 707	adev = ACPI_COMPANION(dev);
 708	if (!adev) {
 709		dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
 710		return -ENODEV;
 711	}
 712
 713	ret = acpi_dev_pm_get_state(dev, adev, acpi_target_system_state(),
 714				    &d_min, &d_max);
 715	if (ret)
 716		return ret;
 717
 718	if (d_max_in < d_min)
 719		return -EINVAL;
 720
 721	if (d_max > d_max_in) {
 722		for (d_max = d_max_in; d_max > d_min; d_max--) {
 723			if (adev->power.states[d_max].flags.valid)
 724				break;
 725		}
 726	}
 727
 728	if (d_min_p)
 729		*d_min_p = d_min;
 730
 731	return d_max;
 732}
 733EXPORT_SYMBOL(acpi_pm_device_sleep_state);
 734
 735/**
 736 * acpi_pm_notify_work_func - ACPI devices wakeup notification work function.
 737 * @context: Device wakeup context.
 738 */
 739static void acpi_pm_notify_work_func(struct acpi_device_wakeup_context *context)
 740{
 741	struct device *dev = context->dev;
 742
 743	if (dev) {
 744		pm_wakeup_event(dev, 0);
 745		pm_request_resume(dev);
 746	}
 747}
 748
 749static DEFINE_MUTEX(acpi_wakeup_lock);
 750
 751static int __acpi_device_wakeup_enable(struct acpi_device *adev,
 752				       u32 target_state, int max_count)
 753{
 754	struct acpi_device_wakeup *wakeup = &adev->wakeup;
 755	acpi_status status;
 756	int error = 0;
 757
 758	mutex_lock(&acpi_wakeup_lock);
 759
 760	if (wakeup->enable_count >= max_count)
 761		goto out;
 762
 
 
 
 763	if (wakeup->enable_count > 0)
 764		goto inc;
 765
 766	error = acpi_enable_wakeup_device_power(adev, target_state);
 767	if (error)
 
 
 
 
 768		goto out;
 
 
 
 
 769
 770	status = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
 771	if (ACPI_FAILURE(status)) {
 772		acpi_disable_wakeup_device_power(adev);
 773		error = -EIO;
 774		goto out;
 775	}
 776
 777	acpi_handle_debug(adev->handle, "GPE%2X enabled for wakeup\n",
 778			  (unsigned int)wakeup->gpe_number);
 779
 780inc:
 781	wakeup->enable_count++;
 
 
 
 782
 783out:
 784	mutex_unlock(&acpi_wakeup_lock);
 785	return error;
 786}
 787
 788/**
 789 * acpi_device_wakeup_enable - Enable wakeup functionality for device.
 790 * @adev: ACPI device to enable wakeup functionality for.
 791 * @target_state: State the system is transitioning into.
 792 *
 793 * Enable the GPE associated with @adev so that it can generate wakeup signals
 794 * for the device in response to external (remote) events and enable wakeup
 795 * power for it.
 796 *
 797 * Callers must ensure that @adev is a valid ACPI device node before executing
 798 * this function.
 799 */
 800static int acpi_device_wakeup_enable(struct acpi_device *adev, u32 target_state)
 801{
 802	return __acpi_device_wakeup_enable(adev, target_state, 1);
 803}
 804
 805/**
 806 * acpi_device_wakeup_disable - Disable wakeup functionality for device.
 807 * @adev: ACPI device to disable wakeup functionality for.
 808 *
 809 * Disable the GPE associated with @adev and disable wakeup power for it.
 810 *
 811 * Callers must ensure that @adev is a valid ACPI device node before executing
 812 * this function.
 813 */
 814static void acpi_device_wakeup_disable(struct acpi_device *adev)
 815{
 816	struct acpi_device_wakeup *wakeup = &adev->wakeup;
 817
 818	mutex_lock(&acpi_wakeup_lock);
 819
 820	if (!wakeup->enable_count)
 821		goto out;
 822
 823	acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
 824	acpi_disable_wakeup_device_power(adev);
 825
 826	wakeup->enable_count--;
 827
 828out:
 829	mutex_unlock(&acpi_wakeup_lock);
 830}
 831
 832static int __acpi_pm_set_device_wakeup(struct device *dev, bool enable,
 833				       int max_count)
 
 
 
 
 834{
 835	struct acpi_device *adev;
 836	int error;
 837
 838	adev = ACPI_COMPANION(dev);
 839	if (!adev) {
 840		dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
 841		return -ENODEV;
 842	}
 843
 844	if (!acpi_device_can_wakeup(adev))
 845		return -EINVAL;
 846
 847	if (!enable) {
 848		acpi_device_wakeup_disable(adev);
 849		dev_dbg(dev, "Wakeup disabled by ACPI\n");
 850		return 0;
 851	}
 852
 853	error = __acpi_device_wakeup_enable(adev, acpi_target_system_state(),
 854					    max_count);
 855	if (!error)
 856		dev_dbg(dev, "Wakeup enabled by ACPI\n");
 857
 858	return error;
 859}
 860
 861/**
 862 * acpi_pm_set_device_wakeup - Enable/disable remote wakeup for given device.
 863 * @dev: Device to enable/disable to generate wakeup events.
 864 * @enable: Whether to enable or disable the wakeup functionality.
 865 */
 866int acpi_pm_set_device_wakeup(struct device *dev, bool enable)
 867{
 868	return __acpi_pm_set_device_wakeup(dev, enable, 1);
 869}
 870EXPORT_SYMBOL_GPL(acpi_pm_set_device_wakeup);
 871
 872/**
 873 * acpi_pm_set_bridge_wakeup - Enable/disable remote wakeup for given bridge.
 874 * @dev: Bridge device to enable/disable to generate wakeup events.
 875 * @enable: Whether to enable or disable the wakeup functionality.
 876 */
 877int acpi_pm_set_bridge_wakeup(struct device *dev, bool enable)
 878{
 879	return __acpi_pm_set_device_wakeup(dev, enable, INT_MAX);
 880}
 881EXPORT_SYMBOL_GPL(acpi_pm_set_bridge_wakeup);
 882
 883/**
 884 * acpi_dev_pm_low_power - Put ACPI device into a low-power state.
 885 * @dev: Device to put into a low-power state.
 886 * @adev: ACPI device node corresponding to @dev.
 887 * @system_state: System state to choose the device state for.
 888 */
 889static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev,
 890				 u32 system_state)
 891{
 892	int ret, state;
 893
 894	if (!acpi_device_power_manageable(adev))
 895		return 0;
 896
 897	ret = acpi_dev_pm_get_state(dev, adev, system_state, NULL, &state);
 898	return ret ? ret : acpi_device_set_power(adev, state);
 899}
 900
 901/**
 902 * acpi_dev_pm_full_power - Put ACPI device into the full-power state.
 903 * @adev: ACPI device node to put into the full-power state.
 904 */
 905static int acpi_dev_pm_full_power(struct acpi_device *adev)
 906{
 907	return acpi_device_power_manageable(adev) ?
 908		acpi_device_set_power(adev, ACPI_STATE_D0) : 0;
 909}
 910
 911/**
 912 * acpi_dev_suspend - Put device into a low-power state using ACPI.
 913 * @dev: Device to put into a low-power state.
 914 * @wakeup: Whether or not to enable wakeup for the device.
 915 *
 916 * Put the given device into a low-power state using the standard ACPI
 917 * mechanism.  Set up remote wakeup if desired, choose the state to put the
 918 * device into (this checks if remote wakeup is expected to work too), and set
 919 * the power state of the device.
 920 */
 921int acpi_dev_suspend(struct device *dev, bool wakeup)
 922{
 923	struct acpi_device *adev = ACPI_COMPANION(dev);
 924	u32 target_state = acpi_target_system_state();
 925	int error;
 926
 927	if (!adev)
 928		return 0;
 929
 930	if (wakeup && acpi_device_can_wakeup(adev)) {
 931		error = acpi_device_wakeup_enable(adev, target_state);
 932		if (error)
 933			return -EAGAIN;
 934	} else {
 935		wakeup = false;
 936	}
 937
 938	error = acpi_dev_pm_low_power(dev, adev, target_state);
 939	if (error && wakeup)
 940		acpi_device_wakeup_disable(adev);
 941
 942	return error;
 943}
 944EXPORT_SYMBOL_GPL(acpi_dev_suspend);
 945
 946/**
 947 * acpi_dev_resume - Put device into the full-power state using ACPI.
 948 * @dev: Device to put into the full-power state.
 949 *
 950 * Put the given device into the full-power state using the standard ACPI
 951 * mechanism.  Set the power state of the device to ACPI D0 and disable wakeup.
 952 */
 953int acpi_dev_resume(struct device *dev)
 954{
 955	struct acpi_device *adev = ACPI_COMPANION(dev);
 956	int error;
 957
 958	if (!adev)
 959		return 0;
 960
 961	error = acpi_dev_pm_full_power(adev);
 962	acpi_device_wakeup_disable(adev);
 963	return error;
 964}
 965EXPORT_SYMBOL_GPL(acpi_dev_resume);
 966
 967/**
 968 * acpi_subsys_runtime_suspend - Suspend device using ACPI.
 969 * @dev: Device to suspend.
 970 *
 971 * Carry out the generic runtime suspend procedure for @dev and use ACPI to put
 972 * it into a runtime low-power state.
 973 */
 974int acpi_subsys_runtime_suspend(struct device *dev)
 975{
 976	int ret = pm_generic_runtime_suspend(dev);
 
 977	return ret ? ret : acpi_dev_suspend(dev, true);
 978}
 979EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend);
 980
 981/**
 982 * acpi_subsys_runtime_resume - Resume device using ACPI.
 983 * @dev: Device to Resume.
 984 *
 985 * Use ACPI to put the given device into the full-power state and carry out the
 986 * generic runtime resume procedure for it.
 987 */
 988int acpi_subsys_runtime_resume(struct device *dev)
 989{
 990	int ret = acpi_dev_resume(dev);
 
 991	return ret ? ret : pm_generic_runtime_resume(dev);
 992}
 993EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume);
 994
 995#ifdef CONFIG_PM_SLEEP
 996static bool acpi_dev_needs_resume(struct device *dev, struct acpi_device *adev)
 997{
 998	u32 sys_target = acpi_target_system_state();
 999	int ret, state;
1000
1001	if (!pm_runtime_suspended(dev) || !adev || (adev->wakeup.flags.valid &&
1002	    device_may_wakeup(dev) != !!adev->wakeup.prepare_count))
1003		return true;
1004
1005	if (sys_target == ACPI_STATE_S0)
1006		return false;
1007
1008	if (adev->power.flags.dsw_present)
1009		return true;
1010
1011	ret = acpi_dev_pm_get_state(dev, adev, sys_target, NULL, &state);
1012	if (ret)
1013		return true;
1014
1015	return state != adev->power.state;
1016}
1017
1018/**
1019 * acpi_subsys_prepare - Prepare device for system transition to a sleep state.
1020 * @dev: Device to prepare.
1021 */
1022int acpi_subsys_prepare(struct device *dev)
1023{
1024	struct acpi_device *adev = ACPI_COMPANION(dev);
1025
1026	if (dev->driver && dev->driver->pm && dev->driver->pm->prepare) {
1027		int ret = dev->driver->pm->prepare(dev);
1028
1029		if (ret < 0)
1030			return ret;
1031
1032		if (!ret && dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_PREPARE))
1033			return 0;
1034	}
1035
1036	return !acpi_dev_needs_resume(dev, adev);
1037}
1038EXPORT_SYMBOL_GPL(acpi_subsys_prepare);
1039
1040/**
1041 * acpi_subsys_complete - Finalize device's resume during system resume.
1042 * @dev: Device to handle.
1043 */
1044void acpi_subsys_complete(struct device *dev)
1045{
1046	pm_generic_complete(dev);
1047	/*
1048	 * If the device had been runtime-suspended before the system went into
1049	 * the sleep state it is going out of and it has never been resumed till
1050	 * now, resume it in case the firmware powered it up.
1051	 */
1052	if (pm_runtime_suspended(dev) && pm_resume_via_firmware())
1053		pm_request_resume(dev);
1054}
1055EXPORT_SYMBOL_GPL(acpi_subsys_complete);
1056
1057/**
1058 * acpi_subsys_suspend - Run the device driver's suspend callback.
1059 * @dev: Device to handle.
1060 *
1061 * Follow PCI and resume devices from runtime suspend before running their
1062 * system suspend callbacks, unless the driver can cope with runtime-suspended
1063 * devices during system suspend and there are no ACPI-specific reasons for
1064 * resuming them.
1065 */
1066int acpi_subsys_suspend(struct device *dev)
1067{
1068	if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
1069	    acpi_dev_needs_resume(dev, ACPI_COMPANION(dev)))
1070		pm_runtime_resume(dev);
1071
1072	return pm_generic_suspend(dev);
1073}
1074EXPORT_SYMBOL_GPL(acpi_subsys_suspend);
1075
1076/**
1077 * acpi_subsys_suspend_late - Suspend device using ACPI.
1078 * @dev: Device to suspend.
1079 *
1080 * Carry out the generic late suspend procedure for @dev and use ACPI to put
1081 * it into a low-power state during system transition into a sleep state.
1082 */
1083int acpi_subsys_suspend_late(struct device *dev)
1084{
1085	int ret;
1086
1087	if (dev_pm_skip_suspend(dev))
1088		return 0;
1089
1090	ret = pm_generic_suspend_late(dev);
1091	return ret ? ret : acpi_dev_suspend(dev, device_may_wakeup(dev));
1092}
1093EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late);
1094
1095/**
1096 * acpi_subsys_suspend_noirq - Run the device driver's "noirq" suspend callback.
1097 * @dev: Device to suspend.
1098 */
1099int acpi_subsys_suspend_noirq(struct device *dev)
1100{
1101	int ret;
1102
1103	if (dev_pm_skip_suspend(dev))
1104		return 0;
1105
1106	ret = pm_generic_suspend_noirq(dev);
1107	if (ret)
1108		return ret;
1109
1110	/*
1111	 * If the target system sleep state is suspend-to-idle, it is sufficient
1112	 * to check whether or not the device's wakeup settings are good for
1113	 * runtime PM.  Otherwise, the pm_resume_via_firmware() check will cause
1114	 * acpi_subsys_complete() to take care of fixing up the device's state
1115	 * anyway, if need be.
1116	 */
1117	if (device_can_wakeup(dev) && !device_may_wakeup(dev))
1118		dev->power.may_skip_resume = false;
1119
1120	return 0;
1121}
1122EXPORT_SYMBOL_GPL(acpi_subsys_suspend_noirq);
1123
1124/**
1125 * acpi_subsys_resume_noirq - Run the device driver's "noirq" resume callback.
1126 * @dev: Device to handle.
1127 */
1128static int acpi_subsys_resume_noirq(struct device *dev)
1129{
1130	if (dev_pm_skip_resume(dev))
1131		return 0;
1132
1133	return pm_generic_resume_noirq(dev);
1134}
1135
1136/**
1137 * acpi_subsys_resume_early - Resume device using ACPI.
1138 * @dev: Device to Resume.
1139 *
1140 * Use ACPI to put the given device into the full-power state and carry out the
1141 * generic early resume procedure for it during system transition into the
1142 * working state.
 
 
1143 */
1144static int acpi_subsys_resume_early(struct device *dev)
1145{
 
1146	int ret;
1147
1148	if (dev_pm_skip_resume(dev))
1149		return 0;
1150
 
 
 
 
 
1151	ret = acpi_dev_resume(dev);
1152	return ret ? ret : pm_generic_resume_early(dev);
1153}
1154
1155/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1156 * acpi_subsys_freeze - Run the device driver's freeze callback.
1157 * @dev: Device to handle.
1158 */
1159int acpi_subsys_freeze(struct device *dev)
1160{
1161	/*
1162	 * Resume all runtime-suspended devices before creating a snapshot
1163	 * image of system memory, because the restore kernel generally cannot
1164	 * be expected to always handle them consistently and they need to be
1165	 * put into the runtime-active metastate during system resume anyway,
1166	 * so it is better to ensure that the state saved in the image will be
1167	 * always consistent with that.
1168	 */
1169	pm_runtime_resume(dev);
1170
1171	return pm_generic_freeze(dev);
1172}
1173EXPORT_SYMBOL_GPL(acpi_subsys_freeze);
1174
1175/**
1176 * acpi_subsys_restore_early - Restore device using ACPI.
1177 * @dev: Device to restore.
1178 */
1179int acpi_subsys_restore_early(struct device *dev)
1180{
1181	int ret = acpi_dev_resume(dev);
 
1182	return ret ? ret : pm_generic_restore_early(dev);
1183}
1184EXPORT_SYMBOL_GPL(acpi_subsys_restore_early);
1185
1186/**
1187 * acpi_subsys_poweroff - Run the device driver's poweroff callback.
1188 * @dev: Device to handle.
1189 *
1190 * Follow PCI and resume devices from runtime suspend before running their
1191 * system poweroff callbacks, unless the driver can cope with runtime-suspended
1192 * devices during system suspend and there are no ACPI-specific reasons for
1193 * resuming them.
1194 */
1195int acpi_subsys_poweroff(struct device *dev)
1196{
1197	if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
1198	    acpi_dev_needs_resume(dev, ACPI_COMPANION(dev)))
1199		pm_runtime_resume(dev);
1200
1201	return pm_generic_poweroff(dev);
1202}
1203EXPORT_SYMBOL_GPL(acpi_subsys_poweroff);
1204
1205/**
1206 * acpi_subsys_poweroff_late - Run the device driver's poweroff callback.
1207 * @dev: Device to handle.
1208 *
1209 * Carry out the generic late poweroff procedure for @dev and use ACPI to put
1210 * it into a low-power state during system transition into a sleep state.
1211 */
1212static int acpi_subsys_poweroff_late(struct device *dev)
1213{
1214	int ret;
1215
1216	if (dev_pm_skip_suspend(dev))
1217		return 0;
1218
1219	ret = pm_generic_poweroff_late(dev);
1220	if (ret)
1221		return ret;
1222
1223	return acpi_dev_suspend(dev, device_may_wakeup(dev));
1224}
1225
1226/**
1227 * acpi_subsys_poweroff_noirq - Run the driver's "noirq" poweroff callback.
1228 * @dev: Device to suspend.
1229 */
1230static int acpi_subsys_poweroff_noirq(struct device *dev)
1231{
1232	if (dev_pm_skip_suspend(dev))
1233		return 0;
1234
1235	return pm_generic_poweroff_noirq(dev);
1236}
1237#endif /* CONFIG_PM_SLEEP */
1238
1239static struct dev_pm_domain acpi_general_pm_domain = {
1240	.ops = {
1241		.runtime_suspend = acpi_subsys_runtime_suspend,
1242		.runtime_resume = acpi_subsys_runtime_resume,
1243#ifdef CONFIG_PM_SLEEP
1244		.prepare = acpi_subsys_prepare,
1245		.complete = acpi_subsys_complete,
1246		.suspend = acpi_subsys_suspend,
 
1247		.suspend_late = acpi_subsys_suspend_late,
1248		.suspend_noirq = acpi_subsys_suspend_noirq,
1249		.resume_noirq = acpi_subsys_resume_noirq,
1250		.resume_early = acpi_subsys_resume_early,
1251		.freeze = acpi_subsys_freeze,
1252		.poweroff = acpi_subsys_poweroff,
1253		.poweroff_late = acpi_subsys_poweroff_late,
1254		.poweroff_noirq = acpi_subsys_poweroff_noirq,
1255		.restore_early = acpi_subsys_restore_early,
1256#endif
1257	},
1258};
1259
1260/**
1261 * acpi_dev_pm_detach - Remove ACPI power management from the device.
1262 * @dev: Device to take care of.
1263 * @power_off: Whether or not to try to remove power from the device.
1264 *
1265 * Remove the device from the general ACPI PM domain and remove its wakeup
1266 * notifier.  If @power_off is set, additionally remove power from the device if
1267 * possible.
1268 *
1269 * Callers must ensure proper synchronization of this function with power
1270 * management callbacks.
1271 */
1272static void acpi_dev_pm_detach(struct device *dev, bool power_off)
1273{
1274	struct acpi_device *adev = ACPI_COMPANION(dev);
1275
1276	if (adev && dev->pm_domain == &acpi_general_pm_domain) {
1277		dev_pm_domain_set(dev, NULL);
1278		acpi_remove_pm_notifier(adev);
1279		if (power_off) {
1280			/*
1281			 * If the device's PM QoS resume latency limit or flags
1282			 * have been exposed to user space, they have to be
1283			 * hidden at this point, so that they don't affect the
1284			 * choice of the low-power state to put the device into.
1285			 */
1286			dev_pm_qos_hide_latency_limit(dev);
1287			dev_pm_qos_hide_flags(dev);
1288			acpi_device_wakeup_disable(adev);
1289			acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
1290		}
1291	}
1292}
1293
1294/**
1295 * acpi_dev_pm_attach - Prepare device for ACPI power management.
1296 * @dev: Device to prepare.
1297 * @power_on: Whether or not to power on the device.
1298 *
1299 * If @dev has a valid ACPI handle that has a valid struct acpi_device object
1300 * attached to it, install a wakeup notification handler for the device and
1301 * add it to the general ACPI PM domain.  If @power_on is set, the device will
1302 * be put into the ACPI D0 state before the function returns.
1303 *
1304 * This assumes that the @dev's bus type uses generic power management callbacks
1305 * (or doesn't use any power management callbacks at all).
1306 *
1307 * Callers must ensure proper synchronization of this function with power
1308 * management callbacks.
1309 */
1310int acpi_dev_pm_attach(struct device *dev, bool power_on)
1311{
1312	/*
1313	 * Skip devices whose ACPI companions match the device IDs below,
1314	 * because they require special power management handling incompatible
1315	 * with the generic ACPI PM domain.
1316	 */
1317	static const struct acpi_device_id special_pm_ids[] = {
1318		{"PNP0C0B", }, /* Generic ACPI fan */
1319		{"INT3404", }, /* Fan */
1320		{"INTC1044", }, /* Fan for Tiger Lake generation */
1321		{}
1322	};
1323	struct acpi_device *adev = ACPI_COMPANION(dev);
1324
1325	if (!adev || !acpi_match_device_ids(adev, special_pm_ids))
1326		return 0;
1327
1328	/*
1329	 * Only attach the power domain to the first device if the
1330	 * companion is shared by multiple. This is to prevent doing power
1331	 * management twice.
1332	 */
1333	if (!acpi_device_is_first_physical_node(adev, dev))
1334		return 0;
1335
1336	acpi_add_pm_notifier(adev, dev, acpi_pm_notify_work_func);
1337	dev_pm_domain_set(dev, &acpi_general_pm_domain);
1338	if (power_on) {
1339		acpi_dev_pm_full_power(adev);
1340		acpi_device_wakeup_disable(adev);
1341	}
1342
1343	dev->pm_domain->detach = acpi_dev_pm_detach;
1344	return 1;
1345}
1346EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1347#endif /* CONFIG_PM */