1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * drivers/base/power/wakeup.c - System wakeup events framework
   4 *
   5 * Copyright (c) 2010 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
 
 
   6 */
   7#define pr_fmt(fmt) "PM: " fmt
   8
   9#include <linux/device.h>
  10#include <linux/slab.h>
  11#include <linux/sched/signal.h>
  12#include <linux/capability.h>
  13#include <linux/export.h>
  14#include <linux/suspend.h>
  15#include <linux/seq_file.h>
  16#include <linux/debugfs.h>
  17#include <linux/pm_wakeirq.h>
  18#include <trace/events/power.h>
  19
  20#include "power.h"
  21
  22#define list_for_each_entry_rcu_locked(pos, head, member) \
  23	list_for_each_entry_rcu(pos, head, member, \
  24		srcu_read_lock_held(&wakeup_srcu))
  25/*
  26 * If set, the suspend/hibernate code will abort transitions to a sleep state
  27 * if wakeup events are registered during or immediately before the transition.
  28 */
  29bool events_check_enabled __read_mostly;
  30
  31/* First wakeup IRQ seen by the kernel in the last cycle. */
  32static unsigned int wakeup_irq[2] __read_mostly;
  33static DEFINE_RAW_SPINLOCK(wakeup_irq_lock);
  34
  35/* If greater than 0 and the system is suspending, terminate the suspend. */
  36static atomic_t pm_abort_suspend __read_mostly;
  37
  38/*
  39 * Combined counters of registered wakeup events and wakeup events in progress.
  40 * They need to be modified together atomically, so it's better to use one
  41 * atomic variable to hold them both.
  42 */
  43static atomic_t combined_event_count = ATOMIC_INIT(0);
  44
  45#define IN_PROGRESS_BITS	(sizeof(int) * 4)
  46#define MAX_IN_PROGRESS		((1 << IN_PROGRESS_BITS) - 1)
  47
  48static void split_counters(unsigned int *cnt, unsigned int *inpr)
  49{
  50	unsigned int comb = atomic_read(&combined_event_count);
  51
  52	*cnt = (comb >> IN_PROGRESS_BITS);
  53	*inpr = comb & MAX_IN_PROGRESS;
  54}
  55
  56/* A preserved old value of the events counter. */
  57static unsigned int saved_count;
  58
  59static DEFINE_RAW_SPINLOCK(events_lock);
  60
  61static void pm_wakeup_timer_fn(struct timer_list *t);
  62
  63static LIST_HEAD(wakeup_sources);
  64
  65static DECLARE_WAIT_QUEUE_HEAD(wakeup_count_wait_queue);
  66
  67DEFINE_STATIC_SRCU(wakeup_srcu);
  68
  69static struct wakeup_source deleted_ws = {
  70	.name = "deleted",
  71	.lock =  __SPIN_LOCK_UNLOCKED(deleted_ws.lock),
  72};
  73
  74static DEFINE_IDA(wakeup_ida);
  75
  76/**
  77 * wakeup_source_create - Create a struct wakeup_source object.
  78 * @name: Name of the new wakeup source.
  79 */
  80struct wakeup_source *wakeup_source_create(const char *name)
  81{
  82	struct wakeup_source *ws;
  83	const char *ws_name;
  84	int id;
  85
  86	ws = kzalloc(sizeof(*ws), GFP_KERNEL);
  87	if (!ws)
  88		goto err_ws;
  89
  90	ws_name = kstrdup_const(name, GFP_KERNEL);
  91	if (!ws_name)
  92		goto err_name;
  93	ws->name = ws_name;
  94
  95	id = ida_alloc(&wakeup_ida, GFP_KERNEL);
  96	if (id < 0)
  97		goto err_id;
  98	ws->id = id;
  99
 100	return ws;
 101
 102err_id:
 103	kfree_const(ws->name);
 104err_name:
 105	kfree(ws);
 106err_ws:
 107	return NULL;
 108}
 109EXPORT_SYMBOL_GPL(wakeup_source_create);
 110
 111/*
 112 * Record wakeup_source statistics being deleted into a dummy wakeup_source.
 113 */
 114static void wakeup_source_record(struct wakeup_source *ws)
 115{
 116	unsigned long flags;
 117
 118	spin_lock_irqsave(&deleted_ws.lock, flags);
 119
 120	if (ws->event_count) {
 121		deleted_ws.total_time =
 122			ktime_add(deleted_ws.total_time, ws->total_time);
 123		deleted_ws.prevent_sleep_time =
 124			ktime_add(deleted_ws.prevent_sleep_time,
 125				  ws->prevent_sleep_time);
 126		deleted_ws.max_time =
 127			ktime_compare(deleted_ws.max_time, ws->max_time) > 0 ?
 128				deleted_ws.max_time : ws->max_time;
 129		deleted_ws.event_count += ws->event_count;
 130		deleted_ws.active_count += ws->active_count;
 131		deleted_ws.relax_count += ws->relax_count;
 132		deleted_ws.expire_count += ws->expire_count;
 133		deleted_ws.wakeup_count += ws->wakeup_count;
 134	}
 135
 136	spin_unlock_irqrestore(&deleted_ws.lock, flags);
 137}
 138
 139static void wakeup_source_free(struct wakeup_source *ws)
 140{
 141	ida_free(&wakeup_ida, ws->id);
 142	kfree_const(ws->name);
 143	kfree(ws);
 144}
 145
 146/**
 147 * wakeup_source_destroy - Destroy a struct wakeup_source object.
 148 * @ws: Wakeup source to destroy.
 149 *
 150 * Use only for wakeup source objects created with wakeup_source_create().
 151 */
 152void wakeup_source_destroy(struct wakeup_source *ws)
 153{
 154	if (!ws)
 155		return;
 156
 157	__pm_relax(ws);
 158	wakeup_source_record(ws);
 159	wakeup_source_free(ws);
 
 
 
 
 
 
 
 
 
 160}
 161EXPORT_SYMBOL_GPL(wakeup_source_destroy);
 162
 163/**
 164 * wakeup_source_add - Add given object to the list of wakeup sources.
 165 * @ws: Wakeup source object to add to the list.
 166 */
 167void wakeup_source_add(struct wakeup_source *ws)
 168{
 169	unsigned long flags;
 170
 171	if (WARN_ON(!ws))
 172		return;
 173
 174	spin_lock_init(&ws->lock);
 175	timer_setup(&ws->timer, pm_wakeup_timer_fn, 0);
 176	ws->active = false;
 177
 178	raw_spin_lock_irqsave(&events_lock, flags);
 179	list_add_rcu(&ws->entry, &wakeup_sources);
 180	raw_spin_unlock_irqrestore(&events_lock, flags);
 181}
 182EXPORT_SYMBOL_GPL(wakeup_source_add);
 183
 184/**
 185 * wakeup_source_remove - Remove given object from the wakeup sources list.
 186 * @ws: Wakeup source object to remove from the list.
 187 */
 188void wakeup_source_remove(struct wakeup_source *ws)
 189{
 190	unsigned long flags;
 191
 192	if (WARN_ON(!ws))
 193		return;
 194
 195	raw_spin_lock_irqsave(&events_lock, flags);
 196	list_del_rcu(&ws->entry);
 197	raw_spin_unlock_irqrestore(&events_lock, flags);
 198	synchronize_srcu(&wakeup_srcu);
 199
 200	del_timer_sync(&ws->timer);
 201	/*
 202	 * Clear timer.function to make wakeup_source_not_registered() treat
 203	 * this wakeup source as not registered.
 204	 */
 205	ws->timer.function = NULL;
 206}
 207EXPORT_SYMBOL_GPL(wakeup_source_remove);
 208
 209/**
 210 * wakeup_source_register - Create wakeup source and add it to the list.
 211 * @dev: Device this wakeup source is associated with (or NULL if virtual).
 212 * @name: Name of the wakeup source to register.
 213 */
 214struct wakeup_source *wakeup_source_register(struct device *dev,
 215					     const char *name)
 216{
 217	struct wakeup_source *ws;
 218	int ret;
 219
 220	ws = wakeup_source_create(name);
 221	if (ws) {
 222		if (!dev || device_is_registered(dev)) {
 223			ret = wakeup_source_sysfs_add(dev, ws);
 224			if (ret) {
 225				wakeup_source_free(ws);
 226				return NULL;
 227			}
 228		}
 229		wakeup_source_add(ws);
 230	}
 231	return ws;
 232}
 233EXPORT_SYMBOL_GPL(wakeup_source_register);
 234
 235/**
 236 * wakeup_source_unregister - Remove wakeup source from the list and remove it.
 237 * @ws: Wakeup source object to unregister.
 238 */
 239void wakeup_source_unregister(struct wakeup_source *ws)
 240{
 241	if (ws) {
 242		wakeup_source_remove(ws);
 243		if (ws->dev)
 244			wakeup_source_sysfs_remove(ws);
 245
 246		wakeup_source_destroy(ws);
 247	}
 248}
 249EXPORT_SYMBOL_GPL(wakeup_source_unregister);
 250
 251/**
 252 * wakeup_sources_read_lock - Lock wakeup source list for read.
 253 *
 254 * Returns an index of srcu lock for struct wakeup_srcu.
 255 * This index must be passed to the matching wakeup_sources_read_unlock().
 256 */
 257int wakeup_sources_read_lock(void)
 258{
 259	return srcu_read_lock(&wakeup_srcu);
 260}
 261EXPORT_SYMBOL_GPL(wakeup_sources_read_lock);
 262
 263/**
 264 * wakeup_sources_read_unlock - Unlock wakeup source list.
 265 * @idx: return value from corresponding wakeup_sources_read_lock()
 266 */
 267void wakeup_sources_read_unlock(int idx)
 268{
 269	srcu_read_unlock(&wakeup_srcu, idx);
 270}
 271EXPORT_SYMBOL_GPL(wakeup_sources_read_unlock);
 272
 273/**
 274 * wakeup_sources_walk_start - Begin a walk on wakeup source list
 275 *
 276 * Returns first object of the list of wakeup sources.
 277 *
 278 * Note that to be safe, wakeup sources list needs to be locked by calling
 279 * wakeup_source_read_lock() for this.
 280 */
 281struct wakeup_source *wakeup_sources_walk_start(void)
 282{
 283	struct list_head *ws_head = &wakeup_sources;
 284
 285	return list_entry_rcu(ws_head->next, struct wakeup_source, entry);
 286}
 287EXPORT_SYMBOL_GPL(wakeup_sources_walk_start);
 288
 289/**
 290 * wakeup_sources_walk_next - Get next wakeup source from the list
 291 * @ws: Previous wakeup source object
 292 *
 293 * Note that to be safe, wakeup sources list needs to be locked by calling
 294 * wakeup_source_read_lock() for this.
 295 */
 296struct wakeup_source *wakeup_sources_walk_next(struct wakeup_source *ws)
 297{
 298	struct list_head *ws_head = &wakeup_sources;
 299
 300	return list_next_or_null_rcu(ws_head, &ws->entry,
 301				struct wakeup_source, entry);
 302}
 303EXPORT_SYMBOL_GPL(wakeup_sources_walk_next);
 304
 305/**
 306 * device_wakeup_attach - Attach a wakeup source object to a device object.
 307 * @dev: Device to handle.
 308 * @ws: Wakeup source object to attach to @dev.
 309 *
 310 * This causes @dev to be treated as a wakeup device.
 311 */
 312static int device_wakeup_attach(struct device *dev, struct wakeup_source *ws)
 313{
 314	spin_lock_irq(&dev->power.lock);
 315	if (dev->power.wakeup) {
 316		spin_unlock_irq(&dev->power.lock);
 317		return -EEXIST;
 318	}
 319	dev->power.wakeup = ws;
 320	if (dev->power.wakeirq)
 321		device_wakeup_attach_irq(dev, dev->power.wakeirq);
 322	spin_unlock_irq(&dev->power.lock);
 323	return 0;
 324}
 325
 326/**
 327 * device_wakeup_enable - Enable given device to be a wakeup source.
 328 * @dev: Device to handle.
 329 *
 330 * Create a wakeup source object, register it and attach it to @dev.
 331 */
 332int device_wakeup_enable(struct device *dev)
 333{
 334	struct wakeup_source *ws;
 335	int ret;
 336
 337	if (!dev || !dev->power.can_wakeup)
 338		return -EINVAL;
 339
 340	if (pm_suspend_target_state != PM_SUSPEND_ON)
 341		dev_dbg(dev, "Suspicious %s() during system transition!\n", __func__);
 342
 343	ws = wakeup_source_register(dev, dev_name(dev));
 344	if (!ws)
 345		return -ENOMEM;
 346
 347	ret = device_wakeup_attach(dev, ws);
 348	if (ret)
 349		wakeup_source_unregister(ws);
 350
 351	return ret;
 352}
 353EXPORT_SYMBOL_GPL(device_wakeup_enable);
 354
 355/**
 356 * device_wakeup_attach_irq - Attach a wakeirq to a wakeup source
 357 * @dev: Device to handle
 358 * @wakeirq: Device specific wakeirq entry
 359 *
 360 * Attach a device wakeirq to the wakeup source so the device
 361 * wake IRQ can be configured automatically for suspend and
 362 * resume.
 363 *
 364 * Call under the device's power.lock lock.
 365 */
 366void device_wakeup_attach_irq(struct device *dev,
 367			     struct wake_irq *wakeirq)
 368{
 369	struct wakeup_source *ws;
 370
 371	ws = dev->power.wakeup;
 372	if (!ws)
 373		return;
 374
 375	if (ws->wakeirq)
 376		dev_err(dev, "Leftover wakeup IRQ found, overriding\n");
 377
 378	ws->wakeirq = wakeirq;
 379}
 380
 381/**
 382 * device_wakeup_detach_irq - Detach a wakeirq from a wakeup source
 383 * @dev: Device to handle
 384 *
 385 * Removes a device wakeirq from the wakeup source.
 386 *
 387 * Call under the device's power.lock lock.
 388 */
 389void device_wakeup_detach_irq(struct device *dev)
 390{
 391	struct wakeup_source *ws;
 392
 393	ws = dev->power.wakeup;
 394	if (ws)
 395		ws->wakeirq = NULL;
 396}
 397
 398/**
 399 * device_wakeup_arm_wake_irqs -
 400 *
 401 * Iterates over the list of device wakeirqs to arm them.
 402 */
 403void device_wakeup_arm_wake_irqs(void)
 404{
 405	struct wakeup_source *ws;
 406	int srcuidx;
 407
 408	srcuidx = srcu_read_lock(&wakeup_srcu);
 409	list_for_each_entry_rcu_locked(ws, &wakeup_sources, entry)
 410		dev_pm_arm_wake_irq(ws->wakeirq);
 411	srcu_read_unlock(&wakeup_srcu, srcuidx);
 412}
 413
 414/**
 415 * device_wakeup_disarm_wake_irqs -
 416 *
 417 * Iterates over the list of device wakeirqs to disarm them.
 418 */
 419void device_wakeup_disarm_wake_irqs(void)
 420{
 421	struct wakeup_source *ws;
 422	int srcuidx;
 423
 424	srcuidx = srcu_read_lock(&wakeup_srcu);
 425	list_for_each_entry_rcu_locked(ws, &wakeup_sources, entry)
 426		dev_pm_disarm_wake_irq(ws->wakeirq);
 427	srcu_read_unlock(&wakeup_srcu, srcuidx);
 428}
 429
 430/**
 431 * device_wakeup_detach - Detach a device's wakeup source object from it.
 432 * @dev: Device to detach the wakeup source object from.
 433 *
 434 * After it returns, @dev will not be treated as a wakeup device any more.
 435 */
 436static struct wakeup_source *device_wakeup_detach(struct device *dev)
 437{
 438	struct wakeup_source *ws;
 439
 440	spin_lock_irq(&dev->power.lock);
 441	ws = dev->power.wakeup;
 442	dev->power.wakeup = NULL;
 443	spin_unlock_irq(&dev->power.lock);
 444	return ws;
 445}
 446
 447/**
 448 * device_wakeup_disable - Do not regard a device as a wakeup source any more.
 449 * @dev: Device to handle.
 450 *
 451 * Detach the @dev's wakeup source object from it, unregister this wakeup source
 452 * object and destroy it.
 453 */
 454int device_wakeup_disable(struct device *dev)
 455{
 456	struct wakeup_source *ws;
 457
 458	if (!dev || !dev->power.can_wakeup)
 459		return -EINVAL;
 460
 461	ws = device_wakeup_detach(dev);
 462	wakeup_source_unregister(ws);
 
 
 463	return 0;
 464}
 465EXPORT_SYMBOL_GPL(device_wakeup_disable);
 466
 467/**
 468 * device_set_wakeup_capable - Set/reset device wakeup capability flag.
 469 * @dev: Device to handle.
 470 * @capable: Whether or not @dev is capable of waking up the system from sleep.
 471 *
 472 * If @capable is set, set the @dev's power.can_wakeup flag and add its
 473 * wakeup-related attributes to sysfs.  Otherwise, unset the @dev's
 474 * power.can_wakeup flag and remove its wakeup-related attributes from sysfs.
 475 *
 476 * This function may sleep and it can't be called from any context where
 477 * sleeping is not allowed.
 478 */
 479void device_set_wakeup_capable(struct device *dev, bool capable)
 480{
 481	if (!!dev->power.can_wakeup == !!capable)
 482		return;
 483
 484	dev->power.can_wakeup = capable;
 485	if (device_is_registered(dev) && !list_empty(&dev->power.entry)) {
 486		if (capable) {
 487			int ret = wakeup_sysfs_add(dev);
 488
 489			if (ret)
 490				dev_info(dev, "Wakeup sysfs attributes not added\n");
 491		} else {
 492			wakeup_sysfs_remove(dev);
 493		}
 494	}
 
 495}
 496EXPORT_SYMBOL_GPL(device_set_wakeup_capable);
 497
 498/**
 499 * device_set_wakeup_enable - Enable or disable a device to wake up the system.
 500 * @dev: Device to handle.
 501 * @enable: enable/disable flag
 
 
 
 
 502 */
 503int device_set_wakeup_enable(struct device *dev, bool enable)
 504{
 505	return enable ? device_wakeup_enable(dev) : device_wakeup_disable(dev);
 
 
 
 
 
 
 
 
 
 506}
 507EXPORT_SYMBOL_GPL(device_set_wakeup_enable);
 508
 509/**
 510 * wakeup_source_not_registered - validate the given wakeup source.
 511 * @ws: Wakeup source to be validated.
 512 */
 513static bool wakeup_source_not_registered(struct wakeup_source *ws)
 514{
 515	/*
 516	 * Use timer struct to check if the given source is initialized
 517	 * by wakeup_source_add.
 518	 */
 519	return ws->timer.function != pm_wakeup_timer_fn;
 520}
 
 521
 522/*
 523 * The functions below use the observation that each wakeup event starts a
 524 * period in which the system should not be suspended.  The moment this period
 525 * will end depends on how the wakeup event is going to be processed after being
 526 * detected and all of the possible cases can be divided into two distinct
 527 * groups.
 528 *
 529 * First, a wakeup event may be detected by the same functional unit that will
 530 * carry out the entire processing of it and possibly will pass it to user space
 531 * for further processing.  In that case the functional unit that has detected
 532 * the event may later "close" the "no suspend" period associated with it
 533 * directly as soon as it has been dealt with.  The pair of pm_stay_awake() and
 534 * pm_relax(), balanced with each other, is supposed to be used in such
 535 * situations.
 536 *
 537 * Second, a wakeup event may be detected by one functional unit and processed
 538 * by another one.  In that case the unit that has detected it cannot really
 539 * "close" the "no suspend" period associated with it, unless it knows in
 540 * advance what's going to happen to the event during processing.  This
 541 * knowledge, however, may not be available to it, so it can simply specify time
 542 * to wait before the system can be suspended and pass it as the second
 543 * argument of pm_wakeup_event().
 544 *
 545 * It is valid to call pm_relax() after pm_wakeup_event(), in which case the
 546 * "no suspend" period will be ended either by the pm_relax(), or by the timer
 547 * function executed when the timer expires, whichever comes first.
 548 */
 549
 550/**
 551 * wakeup_source_activate - Mark given wakeup source as active.
 552 * @ws: Wakeup source to handle.
 553 *
 554 * Update the @ws' statistics and, if @ws has just been activated, notify the PM
 555 * core of the event by incrementing the counter of the wakeup events being
 556 * processed.
 557 */
 558static void wakeup_source_activate(struct wakeup_source *ws)
 559{
 560	unsigned int cec;
 561
 562	if (WARN_ONCE(wakeup_source_not_registered(ws),
 563			"unregistered wakeup source\n"))
 564		return;
 565
 566	ws->active = true;
 567	ws->active_count++;
 
 568	ws->last_time = ktime_get();
 569	if (ws->autosleep_enabled)
 570		ws->start_prevent_time = ws->last_time;
 571
 572	/* Increment the counter of events in progress. */
 573	cec = atomic_inc_return(&combined_event_count);
 574
 575	trace_wakeup_source_activate(ws->name, cec);
 576}
 577
 578/**
 579 * wakeup_source_report_event - Report wakeup event using the given source.
 580 * @ws: Wakeup source to report the event for.
 581 * @hard: If set, abort suspends in progress and wake up from suspend-to-idle.
 582 */
 583static void wakeup_source_report_event(struct wakeup_source *ws, bool hard)
 584{
 585	ws->event_count++;
 586	/* This is racy, but the counter is approximate anyway. */
 587	if (events_check_enabled)
 588		ws->wakeup_count++;
 589
 590	if (!ws->active)
 591		wakeup_source_activate(ws);
 592
 593	if (hard)
 594		pm_system_wakeup();
 595}
 596
 597/**
 598 * __pm_stay_awake - Notify the PM core of a wakeup event.
 599 * @ws: Wakeup source object associated with the source of the event.
 600 *
 601 * It is safe to call this function from interrupt context.
 602 */
 603void __pm_stay_awake(struct wakeup_source *ws)
 604{
 605	unsigned long flags;
 606
 607	if (!ws)
 608		return;
 609
 610	spin_lock_irqsave(&ws->lock, flags);
 611
 612	wakeup_source_report_event(ws, false);
 613	del_timer(&ws->timer);
 614	ws->timer_expires = 0;
 615
 616	spin_unlock_irqrestore(&ws->lock, flags);
 617}
 618EXPORT_SYMBOL_GPL(__pm_stay_awake);
 619
 620/**
 621 * pm_stay_awake - Notify the PM core that a wakeup event is being processed.
 622 * @dev: Device the wakeup event is related to.
 623 *
 624 * Notify the PM core of a wakeup event (signaled by @dev) by calling
 625 * __pm_stay_awake for the @dev's wakeup source object.
 626 *
 627 * Call this function after detecting of a wakeup event if pm_relax() is going
 628 * to be called directly after processing the event (and possibly passing it to
 629 * user space for further processing).
 630 */
 631void pm_stay_awake(struct device *dev)
 632{
 633	unsigned long flags;
 634
 635	if (!dev)
 636		return;
 637
 638	spin_lock_irqsave(&dev->power.lock, flags);
 639	__pm_stay_awake(dev->power.wakeup);
 640	spin_unlock_irqrestore(&dev->power.lock, flags);
 641}
 642EXPORT_SYMBOL_GPL(pm_stay_awake);
 643
 644#ifdef CONFIG_PM_AUTOSLEEP
 645static void update_prevent_sleep_time(struct wakeup_source *ws, ktime_t now)
 646{
 647	ktime_t delta = ktime_sub(now, ws->start_prevent_time);
 648	ws->prevent_sleep_time = ktime_add(ws->prevent_sleep_time, delta);
 649}
 650#else
 651static inline void update_prevent_sleep_time(struct wakeup_source *ws,
 652					     ktime_t now) {}
 653#endif
 654
 655/**
 656 * wakeup_source_deactivate - Mark given wakeup source as inactive.
 657 * @ws: Wakeup source to handle.
 658 *
 659 * Update the @ws' statistics and notify the PM core that the wakeup source has
 660 * become inactive by decrementing the counter of wakeup events being processed
 661 * and incrementing the counter of registered wakeup events.
 662 */
 663static void wakeup_source_deactivate(struct wakeup_source *ws)
 664{
 665	unsigned int cnt, inpr, cec;
 666	ktime_t duration;
 667	ktime_t now;
 668
 669	ws->relax_count++;
 670	/*
 671	 * __pm_relax() may be called directly or from a timer function.
 672	 * If it is called directly right after the timer function has been
 673	 * started, but before the timer function calls __pm_relax(), it is
 674	 * possible that __pm_stay_awake() will be called in the meantime and
 675	 * will set ws->active.  Then, ws->active may be cleared immediately
 676	 * by the __pm_relax() called from the timer function, but in such a
 677	 * case ws->relax_count will be different from ws->active_count.
 678	 */
 679	if (ws->relax_count != ws->active_count) {
 680		ws->relax_count--;
 681		return;
 682	}
 683
 684	ws->active = false;
 685
 686	now = ktime_get();
 687	duration = ktime_sub(now, ws->last_time);
 688	ws->total_time = ktime_add(ws->total_time, duration);
 689	if (ktime_to_ns(duration) > ktime_to_ns(ws->max_time))
 690		ws->max_time = duration;
 691
 692	ws->last_time = now;
 693	del_timer(&ws->timer);
 694	ws->timer_expires = 0;
 695
 696	if (ws->autosleep_enabled)
 697		update_prevent_sleep_time(ws, now);
 698
 699	/*
 700	 * Increment the counter of registered wakeup events and decrement the
 701	 * counter of wakeup events in progress simultaneously.
 702	 */
 703	cec = atomic_add_return(MAX_IN_PROGRESS, &combined_event_count);
 704	trace_wakeup_source_deactivate(ws->name, cec);
 705
 706	split_counters(&cnt, &inpr);
 707	if (!inpr && waitqueue_active(&wakeup_count_wait_queue))
 708		wake_up(&wakeup_count_wait_queue);
 709}
 710
 711/**
 712 * __pm_relax - Notify the PM core that processing of a wakeup event has ended.
 713 * @ws: Wakeup source object associated with the source of the event.
 714 *
 715 * Call this function for wakeup events whose processing started with calling
 716 * __pm_stay_awake().
 717 *
 718 * It is safe to call it from interrupt context.
 719 */
 720void __pm_relax(struct wakeup_source *ws)
 721{
 722	unsigned long flags;
 723
 724	if (!ws)
 725		return;
 726
 727	spin_lock_irqsave(&ws->lock, flags);
 728	if (ws->active)
 729		wakeup_source_deactivate(ws);
 730	spin_unlock_irqrestore(&ws->lock, flags);
 731}
 732EXPORT_SYMBOL_GPL(__pm_relax);
 733
 734/**
 735 * pm_relax - Notify the PM core that processing of a wakeup event has ended.
 736 * @dev: Device that signaled the event.
 737 *
 738 * Execute __pm_relax() for the @dev's wakeup source object.
 739 */
 740void pm_relax(struct device *dev)
 741{
 742	unsigned long flags;
 743
 744	if (!dev)
 745		return;
 746
 747	spin_lock_irqsave(&dev->power.lock, flags);
 748	__pm_relax(dev->power.wakeup);
 749	spin_unlock_irqrestore(&dev->power.lock, flags);
 750}
 751EXPORT_SYMBOL_GPL(pm_relax);
 752
 753/**
 754 * pm_wakeup_timer_fn - Delayed finalization of a wakeup event.
 755 * @t: timer list
 756 *
 757 * Call wakeup_source_deactivate() for the wakeup source whose address is stored
 758 * in @data if it is currently active and its timer has not been canceled and
 759 * the expiration time of the timer is not in future.
 760 */
 761static void pm_wakeup_timer_fn(struct timer_list *t)
 762{
 763	struct wakeup_source *ws = from_timer(ws, t, timer);
 764	unsigned long flags;
 765
 766	spin_lock_irqsave(&ws->lock, flags);
 767
 768	if (ws->active && ws->timer_expires
 769	    && time_after_eq(jiffies, ws->timer_expires)) {
 770		wakeup_source_deactivate(ws);
 771		ws->expire_count++;
 772	}
 773
 774	spin_unlock_irqrestore(&ws->lock, flags);
 775}
 776
 777/**
 778 * pm_wakeup_ws_event - Notify the PM core of a wakeup event.
 779 * @ws: Wakeup source object associated with the event source.
 780 * @msec: Anticipated event processing time (in milliseconds).
 781 * @hard: If set, abort suspends in progress and wake up from suspend-to-idle.
 782 *
 783 * Notify the PM core of a wakeup event whose source is @ws that will take
 784 * approximately @msec milliseconds to be processed by the kernel.  If @ws is
 785 * not active, activate it.  If @msec is nonzero, set up the @ws' timer to
 786 * execute pm_wakeup_timer_fn() in future.
 787 *
 788 * It is safe to call this function from interrupt context.
 789 */
 790void pm_wakeup_ws_event(struct wakeup_source *ws, unsigned int msec, bool hard)
 791{
 792	unsigned long flags;
 793	unsigned long expires;
 794
 795	if (!ws)
 796		return;
 797
 798	spin_lock_irqsave(&ws->lock, flags);
 799
 800	wakeup_source_report_event(ws, hard);
 
 
 801
 802	if (!msec) {
 803		wakeup_source_deactivate(ws);
 804		goto unlock;
 805	}
 806
 807	expires = jiffies + msecs_to_jiffies(msec);
 808	if (!expires)
 809		expires = 1;
 810
 811	if (!ws->timer_expires || time_after(expires, ws->timer_expires)) {
 812		mod_timer(&ws->timer, expires);
 813		ws->timer_expires = expires;
 814	}
 815
 816 unlock:
 817	spin_unlock_irqrestore(&ws->lock, flags);
 818}
 819EXPORT_SYMBOL_GPL(pm_wakeup_ws_event);
 
 820
 821/**
 822 * pm_wakeup_dev_event - Notify the PM core of a wakeup event.
 823 * @dev: Device the wakeup event is related to.
 824 * @msec: Anticipated event processing time (in milliseconds).
 825 * @hard: If set, abort suspends in progress and wake up from suspend-to-idle.
 826 *
 827 * Call pm_wakeup_ws_event() for the @dev's wakeup source object.
 828 */
 829void pm_wakeup_dev_event(struct device *dev, unsigned int msec, bool hard)
 830{
 831	unsigned long flags;
 832
 833	if (!dev)
 834		return;
 835
 836	spin_lock_irqsave(&dev->power.lock, flags);
 837	pm_wakeup_ws_event(dev->power.wakeup, msec, hard);
 838	spin_unlock_irqrestore(&dev->power.lock, flags);
 839}
 840EXPORT_SYMBOL_GPL(pm_wakeup_dev_event);
 841
 842void pm_print_active_wakeup_sources(void)
 
 
 
 843{
 
 844	struct wakeup_source *ws;
 845	int srcuidx, active = 0;
 846	struct wakeup_source *last_activity_ws = NULL;
 847
 848	srcuidx = srcu_read_lock(&wakeup_srcu);
 849	list_for_each_entry_rcu_locked(ws, &wakeup_sources, entry) {
 850		if (ws->active) {
 851			pm_pr_dbg("active wakeup source: %s\n", ws->name);
 852			active = 1;
 853		} else if (!active &&
 854			   (!last_activity_ws ||
 855			    ktime_to_ns(ws->last_time) >
 856			    ktime_to_ns(last_activity_ws->last_time))) {
 857			last_activity_ws = ws;
 858		}
 859	}
 860
 861	if (!active && last_activity_ws)
 862		pm_pr_dbg("last active wakeup source: %s\n",
 863			last_activity_ws->name);
 864	srcu_read_unlock(&wakeup_srcu, srcuidx);
 865}
 866EXPORT_SYMBOL_GPL(pm_print_active_wakeup_sources);
 867
 868/**
 869 * pm_wakeup_pending - Check if power transition in progress should be aborted.
 870 *
 871 * Compare the current number of registered wakeup events with its preserved
 872 * value from the past and return true if new wakeup events have been registered
 873 * since the old value was stored.  Also return true if the current number of
 874 * wakeup events being processed is different from zero.
 875 */
 876bool pm_wakeup_pending(void)
 877{
 878	unsigned long flags;
 879	bool ret = false;
 880
 881	raw_spin_lock_irqsave(&events_lock, flags);
 882	if (events_check_enabled) {
 883		unsigned int cnt, inpr;
 884
 885		split_counters(&cnt, &inpr);
 886		ret = (cnt != saved_count || inpr > 0);
 887		events_check_enabled = !ret;
 888	}
 889	raw_spin_unlock_irqrestore(&events_lock, flags);
 890
 891	if (ret) {
 892		pm_pr_dbg("Wakeup pending, aborting suspend\n");
 893		pm_print_active_wakeup_sources();
 894	}
 895
 896	return ret || atomic_read(&pm_abort_suspend) > 0;
 897}
 898EXPORT_SYMBOL_GPL(pm_wakeup_pending);
 899
 900void pm_system_wakeup(void)
 901{
 902	atomic_inc(&pm_abort_suspend);
 903	s2idle_wake();
 904}
 905EXPORT_SYMBOL_GPL(pm_system_wakeup);
 906
 907void pm_system_cancel_wakeup(void)
 908{
 909	atomic_dec_if_positive(&pm_abort_suspend);
 910}
 911
 912void pm_wakeup_clear(unsigned int irq_number)
 913{
 914	raw_spin_lock_irq(&wakeup_irq_lock);
 915
 916	if (irq_number && wakeup_irq[0] == irq_number)
 917		wakeup_irq[0] = wakeup_irq[1];
 918	else
 919		wakeup_irq[0] = 0;
 920
 921	wakeup_irq[1] = 0;
 922
 923	raw_spin_unlock_irq(&wakeup_irq_lock);
 924
 925	if (!irq_number)
 926		atomic_set(&pm_abort_suspend, 0);
 927}
 928
 929void pm_system_irq_wakeup(unsigned int irq_number)
 930{
 931	unsigned long flags;
 932
 933	raw_spin_lock_irqsave(&wakeup_irq_lock, flags);
 934
 935	if (wakeup_irq[0] == 0)
 936		wakeup_irq[0] = irq_number;
 937	else if (wakeup_irq[1] == 0)
 938		wakeup_irq[1] = irq_number;
 939	else
 940		irq_number = 0;
 941
 942	pm_pr_dbg("Triggering wakeup from IRQ %d\n", irq_number);
 943
 944	raw_spin_unlock_irqrestore(&wakeup_irq_lock, flags);
 945
 946	if (irq_number)
 947		pm_system_wakeup();
 948}
 949
 950unsigned int pm_wakeup_irq(void)
 951{
 952	return wakeup_irq[0];
 953}
 954
 955/**
 956 * pm_get_wakeup_count - Read the number of registered wakeup events.
 957 * @count: Address to store the value at.
 958 * @block: Whether or not to block.
 959 *
 960 * Store the number of registered wakeup events at the address in @count.  If
 961 * @block is set, block until the current number of wakeup events being
 962 * processed is zero.
 963 *
 964 * Return 'false' if the current number of wakeup events being processed is
 965 * nonzero.  Otherwise return 'true'.
 
 966 */
 967bool pm_get_wakeup_count(unsigned int *count, bool block)
 968{
 969	unsigned int cnt, inpr;
 970
 971	if (block) {
 972		DEFINE_WAIT(wait);
 973
 974		for (;;) {
 975			prepare_to_wait(&wakeup_count_wait_queue, &wait,
 976					TASK_INTERRUPTIBLE);
 977			split_counters(&cnt, &inpr);
 978			if (inpr == 0 || signal_pending(current))
 979				break;
 980			pm_print_active_wakeup_sources();
 981			schedule();
 982		}
 983		finish_wait(&wakeup_count_wait_queue, &wait);
 984	}
 985
 986	split_counters(&cnt, &inpr);
 987	*count = cnt;
 988	return !inpr;
 989}
 990
 991/**
 992 * pm_save_wakeup_count - Save the current number of registered wakeup events.
 993 * @count: Value to compare with the current number of registered wakeup events.
 994 *
 995 * If @count is equal to the current number of registered wakeup events and the
 996 * current number of wakeup events being processed is zero, store @count as the
 997 * old number of registered wakeup events for pm_check_wakeup_events(), enable
 998 * wakeup events detection and return 'true'.  Otherwise disable wakeup events
 999 * detection and return 'false'.
1000 */
1001bool pm_save_wakeup_count(unsigned int count)
1002{
1003	unsigned int cnt, inpr;
1004	unsigned long flags;
1005
1006	events_check_enabled = false;
1007	raw_spin_lock_irqsave(&events_lock, flags);
1008	split_counters(&cnt, &inpr);
1009	if (cnt == count && inpr == 0) {
1010		saved_count = count;
1011		events_check_enabled = true;
1012	}
1013	raw_spin_unlock_irqrestore(&events_lock, flags);
 
 
1014	return events_check_enabled;
1015}
1016
1017#ifdef CONFIG_PM_AUTOSLEEP
1018/**
1019 * pm_wakep_autosleep_enabled - Modify autosleep_enabled for all wakeup sources.
1020 * @set: Whether to set or to clear the autosleep_enabled flags.
1021 */
1022void pm_wakep_autosleep_enabled(bool set)
1023{
1024	struct wakeup_source *ws;
1025	ktime_t now = ktime_get();
1026	int srcuidx;
1027
1028	srcuidx = srcu_read_lock(&wakeup_srcu);
1029	list_for_each_entry_rcu_locked(ws, &wakeup_sources, entry) {
1030		spin_lock_irq(&ws->lock);
1031		if (ws->autosleep_enabled != set) {
1032			ws->autosleep_enabled = set;
1033			if (ws->active) {
1034				if (set)
1035					ws->start_prevent_time = now;
1036				else
1037					update_prevent_sleep_time(ws, now);
1038			}
1039		}
1040		spin_unlock_irq(&ws->lock);
1041	}
1042	srcu_read_unlock(&wakeup_srcu, srcuidx);
1043}
1044#endif /* CONFIG_PM_AUTOSLEEP */
1045
1046/**
1047 * print_wakeup_source_stats - Print wakeup source statistics information.
1048 * @m: seq_file to print the statistics into.
1049 * @ws: Wakeup source object to print the statistics for.
1050 */
1051static int print_wakeup_source_stats(struct seq_file *m,
1052				     struct wakeup_source *ws)
1053{
1054	unsigned long flags;
1055	ktime_t total_time;
1056	ktime_t max_time;
1057	unsigned long active_count;
1058	ktime_t active_time;
1059	ktime_t prevent_sleep_time;
1060
1061	spin_lock_irqsave(&ws->lock, flags);
1062
1063	total_time = ws->total_time;
1064	max_time = ws->max_time;
1065	prevent_sleep_time = ws->prevent_sleep_time;
1066	active_count = ws->active_count;
1067	if (ws->active) {
1068		ktime_t now = ktime_get();
1069
1070		active_time = ktime_sub(now, ws->last_time);
1071		total_time = ktime_add(total_time, active_time);
1072		if (active_time > max_time)
1073			max_time = active_time;
1074
1075		if (ws->autosleep_enabled)
1076			prevent_sleep_time = ktime_add(prevent_sleep_time,
1077				ktime_sub(now, ws->start_prevent_time));
1078	} else {
1079		active_time = 0;
1080	}
1081
1082	seq_printf(m, "%-12s\t%lu\t\t%lu\t\t%lu\t\t%lu\t\t%lld\t\t%lld\t\t%lld\t\t%lld\t\t%lld\n",
1083		   ws->name, active_count, ws->event_count,
1084		   ws->wakeup_count, ws->expire_count,
1085		   ktime_to_ms(active_time), ktime_to_ms(total_time),
1086		   ktime_to_ms(max_time), ktime_to_ms(ws->last_time),
1087		   ktime_to_ms(prevent_sleep_time));
1088
1089	spin_unlock_irqrestore(&ws->lock, flags);
1090
1091	return 0;
1092}
1093
1094static void *wakeup_sources_stats_seq_start(struct seq_file *m,
1095					loff_t *pos)
1096{
1097	struct wakeup_source *ws;
1098	loff_t n = *pos;
1099	int *srcuidx = m->private;
1100
1101	if (n == 0) {
1102		seq_puts(m, "name\t\tactive_count\tevent_count\twakeup_count\t"
1103			"expire_count\tactive_since\ttotal_time\tmax_time\t"
1104			"last_change\tprevent_suspend_time\n");
1105	}
1106
1107	*srcuidx = srcu_read_lock(&wakeup_srcu);
1108	list_for_each_entry_rcu_locked(ws, &wakeup_sources, entry) {
1109		if (n-- <= 0)
1110			return ws;
1111	}
1112
1113	return NULL;
1114}
1115
1116static void *wakeup_sources_stats_seq_next(struct seq_file *m,
1117					void *v, loff_t *pos)
1118{
1119	struct wakeup_source *ws = v;
1120	struct wakeup_source *next_ws = NULL;
1121
1122	++(*pos);
1123
1124	list_for_each_entry_continue_rcu(ws, &wakeup_sources, entry) {
1125		next_ws = ws;
1126		break;
1127	}
1128
1129	if (!next_ws)
1130		print_wakeup_source_stats(m, &deleted_ws);
1131
1132	return next_ws;
1133}
1134
1135static void wakeup_sources_stats_seq_stop(struct seq_file *m, void *v)
1136{
1137	int *srcuidx = m->private;
1138
1139	srcu_read_unlock(&wakeup_srcu, *srcuidx);
1140}
1141
1142/**
1143 * wakeup_sources_stats_seq_show - Print wakeup sources statistics information.
1144 * @m: seq_file to print the statistics into.
1145 * @v: wakeup_source of each iteration
1146 */
1147static int wakeup_sources_stats_seq_show(struct seq_file *m, void *v)
1148{
1149	struct wakeup_source *ws = v;
 
 
 
1150
1151	print_wakeup_source_stats(m, ws);
 
 
 
1152
1153	return 0;
1154}
1155
1156static const struct seq_operations wakeup_sources_stats_seq_ops = {
1157	.start = wakeup_sources_stats_seq_start,
1158	.next  = wakeup_sources_stats_seq_next,
1159	.stop  = wakeup_sources_stats_seq_stop,
1160	.show  = wakeup_sources_stats_seq_show,
1161};
1162
1163static int wakeup_sources_stats_open(struct inode *inode, struct file *file)
1164{
1165	return seq_open_private(file, &wakeup_sources_stats_seq_ops, sizeof(int));
1166}
1167
1168static const struct file_operations wakeup_sources_stats_fops = {
1169	.owner = THIS_MODULE,
1170	.open = wakeup_sources_stats_open,
1171	.read = seq_read,
1172	.llseek = seq_lseek,
1173	.release = seq_release_private,
1174};
1175
1176static int __init wakeup_sources_debugfs_init(void)
1177{
1178	debugfs_create_file("wakeup_sources", 0444, NULL, NULL,
1179			    &wakeup_sources_stats_fops);
1180	return 0;
1181}
1182
1183postcore_initcall(wakeup_sources_debugfs_init);