Attachment #14164 for bug #9226





int (*platform_enable_wakeup)(struct device *dev, int is_on);

#ifdef CONFIG_PM_VERBOSE
unsigned int dpm_active_cnt;
unsigned int dpm_fail;

static unsigned int dpm_off_cnt;

static void debug_inc_active_count(void)
{
	dpm_active_cnt++;
}

static void debug_dec_active_count(void)
{
	dpm_active_cnt--;
}

static void debug_inc_inactive_count(void)
{
	dpm_off_cnt++;
}

static void debug_dec_inactive_count(void)
{
	dpm_off_cnt--;
}

static int debug_fake_suspend_failure(void)
{
	return dpm_active_cnt <= dpm_fail;
}

static void debug_print_counts(void)
{
	printk(KERN_DEBUG "PM: Active devices: %d\n", dpm_active_cnt);
	printk(KERN_DEBUG "PM: Inactive devices: %d\n", dpm_off_cnt);
}
#else /* !CONFIG_PM_VERBOSE */
static inline void debug_inc_active_count(void) {}
static inline void debug_dec_active_count(void) {}
static inline void debug_inc_inactive_count(void) {}
static inline void debug_dec_inactive_count(void) {}
static inline int debug_fake_suspend_failure(void) { return false; }
static inline void debug_print_counts(void) {}
#endif /* !CONFIG_PM_VERBOSE */

void device_pm_add(struct device *dev)
{

		 kobject_name(&dev->kobj));
	mutex_lock(&dpm_list_mtx);
	list_add_tail(&dev->power.entry, &dpm_active);
	debug_inc_active_count();
	mutex_unlock(&dpm_list_mtx);
}


	mutex_lock(&dpm_list_mtx);
	dpm_sysfs_remove(dev);
	list_del_init(&dev->power.entry);
	debug_dec_active_count();
	mutex_unlock(&dpm_list_mtx);
}


static void dpm_resume(void)
{
	mutex_lock(&dpm_list_mtx);
	debug_print_counts();
	while(!list_empty(&dpm_off)) {
		struct list_head * entry = dpm_off.next;
		struct device * dev = to_device(entry);

		get_device(dev);
		list_move_tail(entry, &dpm_active);
		debug_dec_inactive_count();
		debug_inc_active_count();

		mutex_unlock(&dpm_list_mtx);
		resume_device(dev);
		mutex_lock(&dpm_list_mtx);
		put_device(dev);
	}
	debug_print_counts();
	mutex_unlock(&dpm_list_mtx);
}


		struct device * dev = to_device(entry);

		list_move_tail(entry, &dpm_off);
		debug_inc_inactive_count();
		resume_device_early(dev);
	}
}

{
	int error = 0;

	if (debug_fake_suspend_failure())
		return -ECANCELED;

	down(&dev->sem);

	pr_debug("PM: Suspending device %s:%s\n",
		 dev->bus ? dev->bus->name : "No Bus",
		 kobject_name(&dev->kobj));

	if (dev->power.power_state.event) {
		dev_dbg(dev, "PM: suspend %d-->%d\n",
			dev->power.power_state.event, state.event);

	might_sleep();
	mutex_lock(&dpm_mtx);
	mutex_lock(&dpm_list_mtx);
	debug_print_counts();
	while (!list_empty(&dpm_active) && error == 0) {
		struct list_head * entry = dpm_active.prev;
		struct device * dev = to_device(entry);

		/* Check if the device got removed */
		if (!list_empty(&dev->power.entry)) {
			/* Move it to the dpm_off list */
			if (!error) {
				list_move(&dev->power.entry, &dpm_off);
				debug_dec_active_count();
				debug_inc_inactive_count();
			}
		}
		if (error)
			printk(KERN_ERR "Could not suspend device %s: "

				error == -EAGAIN ? " (please convert to suspend_late)" : "");
		put_device(dev);
	}
	debug_print_counts();
	mutex_unlock(&dpm_list_mtx);
	if (error)
		dpm_resume();

		if (error)
			goto Error;
		list_move(&dev->power.entry, &dpm_off_irq);
		debug_dec_inactive_count();
	}

	error = sysdev_suspend(state);




static inline int suspend_test(int level) { return 0; }
#endif /* !CONFIG_PM_DEBUG */

#ifdef CONFIG_PM_VERBOSE
static ssize_t pm_drivers_show(struct kset *kset, char *buf)
{
	return sprintf(buf, "%u %u\n", dpm_fail, dpm_active_cnt);
}

static ssize_t pm_drivers_store(struct kset *kset, const char *buf, size_t n)
{
	unsigned int nr;

	if (sscanf(buf, "%u", &nr) == 1 && nr <= dpm_active_cnt) {
		dpm_fail = nr;
		return n;
	}

	return -EINVAL;
}

power_attr(pm_drivers);
#endif /* CONFIG_PM_VERBOSE */

#endif /* CONFIG_PM_SLEEP */

#ifdef CONFIG_SUSPEND

#ifdef CONFIG_PM_TRACE
	&pm_trace_attr.attr,
#endif
#ifdef CONFIG_PM_SLEEP
#ifdef CONFIG_PM_DEBUG
	&pm_test_attr.attr,
#endif /* CONFIG_PM_DEBUG */
#ifdef CONFIG_PM_VERBOSE
	&pm_drivers_attr.attr,
#endif /* CONFIG_PM_VERBOSE */
#endif /* CONFIG_PM_SLEEP */
	NULL,
};


Return to bug 9226

Lines 37-42 static DEFINE_MUTEX(dpm_list_mtx); Link Here

(-)linux-2.6/drivers/base/power/main.c (-1 / +66 lines)
37		37
38	int (platform_enable_wakeup)(struct device dev, int is_on);	38	int (platform_enable_wakeup)(struct device dev, int is_on);
39		39
		40	#ifdef CONFIG_PM_VERBOSE
		41	unsigned int dpm_active_cnt;
		42	unsigned int dpm_fail;
		43
		44	static unsigned int dpm_off_cnt;
		45
		46	static void debug_inc_active_count(void)
		47	{
		48	dpm_active_cnt++;
		49	}
		50
		51	static void debug_dec_active_count(void)
		52	{
		53	dpm_active_cnt--;
		54	}
		55
		56	static void debug_inc_inactive_count(void)
		57	{
		58	dpm_off_cnt++;
		59	}
		60
		61	static void debug_dec_inactive_count(void)
		62	{
		63	dpm_off_cnt--;
		64	}
		65
		66	static int debug_fake_suspend_failure(void)
		67	{
		68	return dpm_active_cnt <= dpm_fail;
		69	}
		70
		71	static void debug_print_counts(void)
		72	{
		73	printk(KERN_DEBUG "PM: Active devices: %d\n", dpm_active_cnt);
		74	printk(KERN_DEBUG "PM: Inactive devices: %d\n", dpm_off_cnt);
		75	}
		76	#else /* !CONFIG_PM_VERBOSE */
		77	static inline void debug_inc_active_count(void) {}
		78	static inline void debug_dec_active_count(void) {}
		79	static inline void debug_inc_inactive_count(void) {}
		80	static inline void debug_dec_inactive_count(void) {}
		81	static inline int debug_fake_suspend_failure(void) { return false; }
		82	static inline void debug_print_counts(void) {}
		83	#endif /* !CONFIG_PM_VERBOSE */
40		84
41	void device_pm_add(struct device *dev)	85	void device_pm_add(struct device *dev)
42	{	86	{
Lines 45-50 void device_pm_add(struct device *dev) Link Here
45	kobject_name(&dev->kobj));	89	kobject_name(&dev->kobj));
46	mutex_lock(&dpm_list_mtx);	90	mutex_lock(&dpm_list_mtx);
47	list_add_tail(&dev->power.entry, &dpm_active);	91	list_add_tail(&dev->power.entry, &dpm_active);
		92	debug_inc_active_count();
48	mutex_unlock(&dpm_list_mtx);	93	mutex_unlock(&dpm_list_mtx);
49	}	94	}
50		95
Lines 56-61 void device_pm_remove(struct device *dev Link Here
56	mutex_lock(&dpm_list_mtx);	101	mutex_lock(&dpm_list_mtx);
57	dpm_sysfs_remove(dev);	102	dpm_sysfs_remove(dev);
58	list_del_init(&dev->power.entry);	103	list_del_init(&dev->power.entry);
		104	debug_dec_active_count();
59	mutex_unlock(&dpm_list_mtx);	105	mutex_unlock(&dpm_list_mtx);
60	}	106	}
61		107
Lines 121-138 static int resume_device_early(struct de Link Here
121	static void dpm_resume(void)	167	static void dpm_resume(void)
122	{	168	{
123	mutex_lock(&dpm_list_mtx);	169	mutex_lock(&dpm_list_mtx);
		170	debug_print_counts();
124	while(!list_empty(&dpm_off)) {	171	while(!list_empty(&dpm_off)) {
125	struct list_head * entry = dpm_off.next;	172	struct list_head * entry = dpm_off.next;
126	struct device * dev = to_device(entry);	173	struct device * dev = to_device(entry);
127		174
128	get_device(dev);	175	get_device(dev);
129	list_move_tail(entry, &dpm_active);	176	list_move_tail(entry, &dpm_active);
		177	debug_dec_inactive_count();
		178	debug_inc_active_count();
130		179
131	mutex_unlock(&dpm_list_mtx);	180	mutex_unlock(&dpm_list_mtx);
132	resume_device(dev);	181	resume_device(dev);
133	mutex_lock(&dpm_list_mtx);	182	mutex_lock(&dpm_list_mtx);
134	put_device(dev);	183	put_device(dev);
135	}	184	}
		185	debug_print_counts();
136	mutex_unlock(&dpm_list_mtx);	186	mutex_unlock(&dpm_list_mtx);
137	}	187	}
138		188
Lines 173-178 static void dpm_power_up(void) Link Here
173	struct device * dev = to_device(entry);	223	struct device * dev = to_device(entry);
174		224
175	list_move_tail(entry, &dpm_off);	225	list_move_tail(entry, &dpm_off);
		226	debug_inc_inactive_count();
176	resume_device_early(dev);	227	resume_device_early(dev);
177	}	228	}
178	}	229	}
Lines 241-247 static int suspend_device(struct device Link Here
241	{	292	{
242	int error = 0;	293	int error = 0;
243		294
		295	if (debug_fake_suspend_failure())
		296	return -ECANCELED;
		297
244	down(&dev->sem);	298	down(&dev->sem);
		299
		300	pr_debug("PM: Suspending device %s:%s\n",
		301	dev->bus ? dev->bus->name : "No Bus",
		302	kobject_name(&dev->kobj));
		303
245	if (dev->power.power_state.event) {	304	if (dev->power.power_state.event) {
246	dev_dbg(dev, "PM: suspend %d-->%d\n",	305	dev_dbg(dev, "PM: suspend %d-->%d\n",
247	dev->power.power_state.event, state.event);	306	dev->power.power_state.event, state.event);
Lines 312-317 int device_suspend(pm_message_t state) Link Here
312	might_sleep();	371	might_sleep();
313	mutex_lock(&dpm_mtx);	372	mutex_lock(&dpm_mtx);
314	mutex_lock(&dpm_list_mtx);	373	mutex_lock(&dpm_list_mtx);
		374	debug_print_counts();
315	while (!list_empty(&dpm_active) && error == 0) {	375	while (!list_empty(&dpm_active) && error == 0) {
316	struct list_head * entry = dpm_active.prev;	376	struct list_head * entry = dpm_active.prev;
317	struct device * dev = to_device(entry);	377	struct device * dev = to_device(entry);
Lines 326-333 int device_suspend(pm_message_t state) Link Here
326	/* Check if the device got removed */	386	/* Check if the device got removed */
327	if (!list_empty(&dev->power.entry)) {	387	if (!list_empty(&dev->power.entry)) {
328	/* Move it to the dpm_off list */	388	/* Move it to the dpm_off list */
329	if (!error)	389	if (!error) {
330	list_move(&dev->power.entry, &dpm_off);	390	list_move(&dev->power.entry, &dpm_off);
		391	debug_dec_active_count();
		392	debug_inc_inactive_count();
		393	}
331	}	394	}
332	if (error)	395	if (error)
333	printk(KERN_ERR "Could not suspend device %s: "	396	printk(KERN_ERR "Could not suspend device %s: "
Lines 336-341 int device_suspend(pm_message_t state) Link Here
336	error == -EAGAIN ? " (please convert to suspend_late)" : "");	399	error == -EAGAIN ? " (please convert to suspend_late)" : "");
337	put_device(dev);	400	put_device(dev);
338	}	401	}
		402	debug_print_counts();
339	mutex_unlock(&dpm_list_mtx);	403	mutex_unlock(&dpm_list_mtx);
340	if (error)	404	if (error)
341	dpm_resume();	405	dpm_resume();
Lines 368-373 int device_power_down(pm_message_t state Link Here
368	if (error)	432	if (error)
369	goto Error;	433	goto Error;
370	list_move(&dev->power.entry, &dpm_off_irq);	434	list_move(&dev->power.entry, &dpm_off_irq);
		435	debug_dec_inactive_count();
371	}	436	}
372		437
373	error = sysdev_suspend(state);	438	error = sysdev_suspend(state);

Lines 126-131 power_attr(pm_test); Link Here

(-)linux-2.6/kernel/power/main.c (-2 / +28 lines)
126	static inline int suspend_test(int level) { return 0; }	126	static inline int suspend_test(int level) { return 0; }
127	#endif /* !CONFIG_PM_DEBUG */	127	#endif /* !CONFIG_PM_DEBUG */
128		128
		129	#ifdef CONFIG_PM_VERBOSE
		130	static ssize_t pm_drivers_show(struct kset kset, char buf)
		131	{
		132	return sprintf(buf, "%u %u\n", dpm_fail, dpm_active_cnt);
		133	}
		134
		135	static ssize_t pm_drivers_store(struct kset kset, const char buf, size_t n)
		136	{
		137	unsigned int nr;
		138
		139	if (sscanf(buf, "%u", &nr) == 1 && nr <= dpm_active_cnt) {
		140	dpm_fail = nr;
		141	return n;
		142	}
		143
		144	return -EINVAL;
		145	}
		146
		147	power_attr(pm_drivers);
		148	#endif /* CONFIG_PM_VERBOSE */
		149
129	#endif /* CONFIG_PM_SLEEP */	150	#endif /* CONFIG_PM_SLEEP */
130		151
131	#ifdef CONFIG_SUSPEND	152	#ifdef CONFIG_SUSPEND
Lines 487-495 static struct attribute * g[] = { Link Here
487	#ifdef CONFIG_PM_TRACE	508	#ifdef CONFIG_PM_TRACE
488	&pm_trace_attr.attr,	509	&pm_trace_attr.attr,
489	#endif	510	#endif
490	#if defined(CONFIG_PM_SLEEP) && defined(CONFIG_PM_DEBUG)	511	#ifdef CONFIG_PM_SLEEP
		512	#ifdef CONFIG_PM_DEBUG
491	&pm_test_attr.attr,	513	&pm_test_attr.attr,
492	#endif	514	#endif /* CONFIG_PM_DEBUG */
		515	#ifdef CONFIG_PM_VERBOSE
		516	&pm_drivers_attr.attr,
		517	#endif /* CONFIG_PM_VERBOSE */
		518	#endif /* CONFIG_PM_SLEEP */
493	NULL,	519	NULL,
494	};	520	};
495		521