@include/linux/pm_wakeup.h/** * struct wakeup_source - Representation of wakeup sources * * @name: Name of the wakeup source * @id: Wakeup source id * @entry: Wakeup source list entry * @lock: Wakeup source lock * @wakeirq: Optional device specific wakeirq * @timer: Wakeup timer list * @timer_expires: Wakeup timer expiration * @total_time: Total time this wakeup source has been active. * @max_time: Maximum time this wakeup source has been continuously active. * @last_time: Monotonic clock when the wakeup source's was touched last time. * @prevent_sleep_time: Total time this source has been preventing autosleep. * @event_count: Number of signaled wakeup events. * @active_count: Number of times the wakeup source was activated. * @relax_count: Number of times the wakeup source was deactivated. * @expire_count: Number of times the wakeup source's timeout has expired. * @wakeup_count: Number of times the wakeup source might abort suspend. * @dev: Struct device for sysfs statistics about the wakeup source. * @active: Status of the wakeup source. * @autosleep_enabled: Autosleep is active, so update @prevent_sleep_time. */struct wakeup_source {	const char 		*name; //ws 名称	int			id;  //WS系统给本ws分配的ID	struct list_head	entry; //用于把本ws节点维护到WS系统的全局链表中	spinlock_t		lock;	struct wake_irq		*wakeirq; //与本ws节点绑定的唤醒中断相关的结构体，用户可自行把指定中断与ws绑定	struct timer_list	timer; //超时锁使用，如定义本ws为超时锁，指定在一定时间后释放锁	unsigned long		timer_expires;//超时锁超时时间	ktime_t total_time; //本ws激活的总时长	ktime_t max_time;   //在ws激活历史中，最长一次的激活时间	ktime_t last_time;  //最后一次访问本ws的时间	ktime_t start_prevent_time; //本ws最近一次阻止autosleep进入休眠的时间戳	ktime_t prevent_sleep_time; //因本ws导致的阻止autosleep进入休眠的总时间	unsigned long		event_count; //事件次数，本ws被持锁（不考虑是否已持锁），则加1并作记录	unsigned long		active_count;//激活次数，本ws仅在首次持锁（激活）时加1（已持锁则不加1，锁释放后再次持锁则加1）	unsigned long		relax_count; //释放次数，与 active_count 相对	unsigned long		expire_count; //超时锁超时次数	unsigned long		wakeup_count; //与event_count一样，但受events_check_enabled 使能标记控制	struct device		*dev; //与本ws绑定的设备	bool			active:1; //标记是否处于激活状态	bool			autosleep_enabled:1; //标记是否使能autosleep};

@drivers/base/power/wakeup.c/** * wakeup_source_register - Create wakeup source and add it to the list. * @dev: Device this wakeup source is associated with (or NULL if virtual). * @name: Name of the wakeup source to register. */struct wakeup_source *wakeup_source_register(struct device *dev,					     const char *name){	struct wakeup_source *ws;	int ret;
	ws = wakeup_source_create(name); //分配内存，设置ws的name和id	if (ws) {		if (!dev || device_is_registered(dev)) {			//在sysfs下为该ws创建dev, /sys/class/wakeup/wakeup<id>/			ret = wakeup_source_sysfs_add(dev, ws);			if (ret) {				wakeup_source_free(ws);				return NULL;			}		}		wakeup_source_add(ws); //设置超时回调函数并将ws添加到wakeup_sources链表	}	return ws;}@drivers/base/power/wakeup_stats.cstatic struct device *wakeup_source_device_create(struct device *parent,						  struct wakeup_source *ws){	struct device *dev = NULL;	int retval = -ENODEV;
	dev = kzalloc(sizeof(*dev), GFP_KERNEL);	device_initialize(dev);	dev->devt = MKDEV(0, 0);	dev->class = wakeup_class; //ws dev挂于wakeup类	dev->parent = parent;	dev->groups = wakeup_source_groups;	dev->release = device_create_release;	dev_set_drvdata(dev, ws);	device_set_pm_not_required(dev);	retval = kobject_set_name(&dev->kobj, "wakeup%d", ws->id);	retval = device_add(dev);	return dev;}//ws dev存在的属性： /sys/class/wakeup/wakeup<id>/static struct attribute *wakeup_source_attrs[] = {	&dev_attr_name.attr, //RO, ws 名称	&dev_attr_active_count.attr, //RO, 激活次数	&dev_attr_event_count.attr, //RO, 持锁次数	&dev_attr_wakeup_count.attr, //RO, 同event_count，但受events_check_enabled使能标记	&dev_attr_expire_count.attr, //RO, 超时次数	&dev_attr_active_time_ms.attr, //RO, 如当前处于激活状态，显示已激活时间	&dev_attr_total_time_ms.attr, //RO, 总激活时间	&dev_attr_max_time_ms.attr, //RO, 最长激活时间	&dev_attr_last_change_ms.attr, //RO, 最近一次激活时的时间戳	&dev_attr_prevent_suspend_time_ms.attr, //RO, 阻止autosleep进入休眠的总时间	NULL,};ATTRIBUTE_GROUPS(wakeup_source);

@drivers/base/power/wakeup.cvoid wakeup_source_unregister(struct wakeup_source *ws){	if (ws) {		wakeup_source_remove(ws); //从wakeup_sources队列移除并删除其定时器		if (ws->dev)			wakeup_source_sysfs_remove(ws);//移除该ws在sysfs系统中的信息
		wakeup_source_destroy(ws);	}}void wakeup_source_destroy(struct wakeup_source *ws){	__pm_relax(ws); //释放该ws	wakeup_source_record(ws);//如果该ws被持锁过，则将其记录叠加到deleted_ws这个ws上	wakeup_source_free(ws);//释放内存资源}
static struct wakeup_source deleted_ws = {//用于保存已移除ws的记录	.name = "deleted",	.lock =  __SPIN_LOCK_UNLOCKED(deleted_ws.lock),};
static void wakeup_source_record(struct wakeup_source *ws){	unsigned long flags;
	spin_lock_irqsave(&deleted_ws.lock, flags);
	if (ws->event_count) {//如果该ws被持锁过，则将记录都叠加到deleted_ws这个ws上		deleted_ws.total_time =			ktime_add(deleted_ws.total_time, ws->total_time);		deleted_ws.prevent_sleep_time =			ktime_add(deleted_ws.prevent_sleep_time,				  ws->prevent_sleep_time);		deleted_ws.max_time =			ktime_compare(deleted_ws.max_time, ws->max_time) > 0 ?				deleted_ws.max_time : ws->max_time;		deleted_ws.event_count += ws->event_count;		deleted_ws.active_count += ws->active_count;		deleted_ws.relax_count += ws->relax_count;		deleted_ws.expire_count += ws->expire_count;		deleted_ws.wakeup_count += ws->wakeup_count;	}
	spin_unlock_irqrestore(&deleted_ws.lock, flags);}

@drivers/base/power/wakeup.cvoid __pm_stay_awake(struct wakeup_source *ws){	unsigned long flags;
	if (!ws)		return;
	spin_lock_irqsave(&ws->lock, flags);
	wakeup_source_report_event(ws, false);//纪录该ws的信息	del_timer(&ws->timer);	ws->timer_expires = 0;
	spin_unlock_irqrestore(&ws->lock, flags);}static void wakeup_source_report_event(struct wakeup_source *ws, bool hard){	ws->event_count++;  //持锁次数加1	/* This is racy, but the counter is approximate anyway. */	if (events_check_enabled)		ws->wakeup_count++;
	if (!ws->active) //ws还未激活情况下，激活ws		wakeup_source_activate(ws);
	if (hard)  //如果需要，可以强制阻止系统休眠		pm_system_wakeup();}static void wakeup_source_activate(struct wakeup_source *ws){	unsigned int cec;
	if (WARN_ONCE(wakeup_source_not_registered(ws),			"unregistered wakeup source\n"))		return;
	ws->active = true;	ws->active_count++;  //激活次数加1	ws->last_time = ktime_get(); //纪录最后操作该锁的时间戳	if (ws->autosleep_enabled) //如果autosleep已使能，则记录该ws阻止休眠时时间戳		ws->start_prevent_time = ws->last_time;
	/* Increment the counter of events in progress. */	cec = atomic_inc_return(&combined_event_count); //combined_event_count低16位加1
	trace_wakeup_source_activate(ws->name, cec);}

@drivers/base/power/wakeup.cvoid __pm_relax(struct wakeup_source *ws){	unsigned long flags;
	if (!ws)		return;
	spin_lock_irqsave(&ws->lock, flags);	if (ws->active) //如果ws已激活，则去激活该ws		wakeup_source_deactivate(ws);	spin_unlock_irqrestore(&ws->lock, flags);}
static void wakeup_source_deactivate(struct wakeup_source *ws){	unsigned int cnt, inpr, cec;	ktime_t duration;	ktime_t now;
	ws->relax_count++; //释放次数加1	/*	 * __pm_relax() may be called directly or from a timer function.	 * If it is called directly right after the timer function has been	 * started, but before the timer function calls __pm_relax(), it is	 * possible that __pm_stay_awake() will be called in the meantime and	 * will set ws->active.  Then, ws->active may be cleared immediately	 * by the __pm_relax() called from the timer function, but in such a	 * case ws->relax_count will be different from ws->active_count.	 */	if (ws->relax_count != ws->active_count) {		ws->relax_count--; //未解决定时锁与主动调用释放锁并发操作时出现冲突做的处理		return;	}
	ws->active = false;
	now = ktime_get();	duration = ktime_sub(now, ws->last_time);	ws->total_time = ktime_add(ws->total_time, duration); //叠加总的持锁时间	if (ktime_to_ns(duration) > ktime_to_ns(ws->max_time))		ws->max_time = duration;  //更新最长持锁时间
	ws->last_time = now; //纪录最后操作该锁的时间戳	del_timer(&ws->timer);	ws->timer_expires = 0;
	if (ws->autosleep_enabled)//如果autosleep已使能，更新该ws阻止系统休眠的时长		update_prevent_sleep_time(ws, now);
	/*	 * Increment the counter of registered wakeup events and decrement the	 * couter of wakeup events in progress simultaneously.	 */	cec = atomic_add_return(MAX_IN_PROGRESS, &combined_event_count);//combined_event_count高16位加1	trace_wakeup_source_deactivate(ws->name, cec);
	split_counters(&cnt, &inpr);//拆分出combined_event_count高16位和低16位	if (!inpr && waitqueue_active(&wakeup_count_wait_queue))//如果该ws已经无正在处理的唤醒事件，则通知PM core		wake_up(&wakeup_count_wait_queue);}

bool pm_get_wakeup_count(unsigned int *count, bool block){	unsigned int cnt, inpr;
	if (block) { 		DEFINE_WAIT(wait); //定义名为wait的等待队列入口
		for (;;) {			prepare_to_wait(&wakeup_count_wait_queue, &wait,					TASK_INTERRUPTIBLE); //准备 wakeup_count_wait_queue 等待队列			split_counters(&cnt, &inpr);			if (inpr == 0 || signal_pending(current))				break;			pm_print_active_wakeup_sources();			schedule(); //调度到其他线程		}		 //__pm_relax() 里wake_up(&wakeup_count_wait_queue);会触发调度到此处		finish_wait(&wakeup_count_wait_queue, &wait);	}
	split_counters(&cnt, &inpr);	*count = cnt;	return !inpr; //返回0表示有待处理事件，返回1表示无待处理事件}

bool pm_wakeup_pending(void){	unsigned long flags;	bool ret = false;
	raw_spin_lock_irqsave(&events_lock, flags);	if (events_check_enabled) {		unsigned int cnt, inpr;
		split_counters(&cnt, &inpr);		ret = (cnt != saved_count || inpr > 0);		events_check_enabled = !ret;	}	raw_spin_unlock_irqrestore(&events_lock, flags);
	if (ret) {		pm_pr_dbg("Wakeup pending, aborting suspend\n");		pm_print_active_wakeup_sources();	}
	return ret || atomic_read(&pm_abort_suspend) > 0;}

//代码格式错误，仅为呈现数据结构，请忽略格式。struct device {	// @power:	For device power management.	struct dev_pm_info	power {		unsigned int		can_wakeup:1; //需置1才允许使用wakeup source		struct wakeup_source	*wakeup; 	};};

static struct attribute *wakeup_attrs[] = {#ifdef CONFIG_PM_SLEEP	&dev_attr_wakeup.attr, //RW，可写入enabled/disabled动态配置是否支持wakeup	&dev_attr_wakeup_count.attr, //RO, 读取该dev ws的wakeup_count	&dev_attr_wakeup_active_count.attr, //RO, 读取该dev ws的active_count	&dev_attr_wakeup_abort_count.attr, //RO, 读取该dev ws的wakeup_count	&dev_attr_wakeup_expire_count.attr, //RO, 读取该dev ws的expire_count	&dev_attr_wakeup_active.attr, //RO, 读取该dev ws的active状态	&dev_attr_wakeup_total_time_ms.attr, //RO, 读取该dev ws的total_time	&dev_attr_wakeup_max_time_ms.attr, //RO, 读取该dev ws的max_time	&dev_attr_wakeup_last_time_ms.attr, //RO, 读取该dev ws的last_time#ifdef CONFIG_PM_AUTOSLEEP	&dev_attr_wakeup_prevent_sleep_time_ms.attr, //RO, 读取该dev ws的prevent_sleep_time#endif#endif	NULL,};

int device_init_wakeup(struct device *dev, bool enable){	int ret = 0;
	if (enable) {		device_set_wakeup_capable(dev, true);		ret = device_wakeup_enable(dev);	} else {		device_wakeup_disable(dev);		device_set_wakeup_capable(dev, false); 	}
	return ret;}

int device_set_wakeup_enable(struct device *dev, bool enable){	return enable ? device_wakeup_enable(dev) : device_wakeup_disable(dev);}