• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* -*- linux-c -*-
2  * APM BIOS driver for Linux
3  * Copyright 1994-2001 Stephen Rothwell (sfr@canb.auug.org.au)
4  *
5  * Initial development of this driver was funded by NEC Australia P/L
6  *	and NEC Corporation
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by the
10  * Free Software Foundation; either version 2, or (at your option) any
11  * later version.
12  *
13  * This program is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * October 1995, Rik Faith (faith@cs.unc.edu):
19  *    Minor enhancements and updates (to the patch set) for 1.3.x
20  *    Documentation
21  * January 1996, Rik Faith (faith@cs.unc.edu):
22  *    Make /proc/apm easy to format (bump driver version)
23  * March 1996, Rik Faith (faith@cs.unc.edu):
24  *    Prohibit APM BIOS calls unless apm_enabled.
25  *    (Thanks to Ulrich Windl <Ulrich.Windl@rz.uni-regensburg.de>)
26  * April 1996, Stephen Rothwell (sfr@canb.auug.org.au)
27  *    Version 1.0 and 1.1
28  * May 1996, Version 1.2
29  * Feb 1998, Version 1.3
30  * Feb 1998, Version 1.4
31  * Aug 1998, Version 1.5
32  * Sep 1998, Version 1.6
33  * Nov 1998, Version 1.7
34  * Jan 1999, Version 1.8
35  * Jan 1999, Version 1.9
36  * Oct 1999, Version 1.10
37  * Nov 1999, Version 1.11
38  * Jan 2000, Version 1.12
39  * Feb 2000, Version 1.13
40  * Nov 2000, Version 1.14
41  * Oct 2001, Version 1.15
42  * Jan 2002, Version 1.16
43  * Oct 2002, Version 1.16ac
44  *
45  * History:
46  *    0.6b: first version in official kernel, Linux 1.3.46
47  *    0.7: changed /proc/apm format, Linux 1.3.58
48  *    0.8: fixed gcc 2.7.[12] compilation problems, Linux 1.3.59
49  *    0.9: only call bios if bios is present, Linux 1.3.72
50  *    1.0: use fixed device number, consolidate /proc/apm into this file,
51  *         Linux 1.3.85
52  *    1.1: support user-space standby and suspend, power off after system
53  *         halted, Linux 1.3.98
54  *    1.2: When resetting RTC after resume, take care so that the time
55  *         is only incorrect by 30-60mS (vs. 1S previously) (Gabor J. Toth
56  *         <jtoth@princeton.edu>); improve interaction between
57  *         screen-blanking and gpm (Stephen Rothwell); Linux 1.99.4
58  *    1.2a:Simple change to stop mysterious bug reports with SMP also added
59  *	   levels to the printk calls. APM is not defined for SMP machines.
60  *         The new replacement for it is, but Linux doesn't yet support this.
61  *         Alan Cox Linux 2.1.55
62  *    1.3: Set up a valid data descriptor 0x40 for buggy BIOS's
63  *    1.4: Upgraded to support APM 1.2. Integrated ThinkPad suspend patch by
64  *         Dean Gaudet <dgaudet@arctic.org>.
65  *         C. Scott Ananian <cananian@alumni.princeton.edu> Linux 2.1.87
66  *    1.5: Fix segment register reloading (in case of bad segments saved
67  *         across BIOS call).
68  *         Stephen Rothwell
69  *    1.6: Cope with compiler/assembler differences.
70  *         Only try to turn off the first display device.
71  *         Fix OOPS at power off with no APM BIOS by Jan Echternach
72  *                   <echter@informatik.uni-rostock.de>
73  *         Stephen Rothwell
74  *    1.7: Modify driver's cached copy of the disabled/disengaged flags
75  *         to reflect current state of APM BIOS.
76  *         Chris Rankin <rankinc@bellsouth.net>
77  *         Reset interrupt 0 timer to 100Hz after suspend
78  *         Chad Miller <cmiller@surfsouth.com>
79  *         Add CONFIG_APM_IGNORE_SUSPEND_BOUNCE
80  *         Richard Gooch <rgooch@atnf.csiro.au>
81  *         Allow boot time disabling of APM
82  *         Make boot messages far less verbose by default
83  *         Make asm safer
84  *         Stephen Rothwell
85  *    1.8: Add CONFIG_APM_RTC_IS_GMT
86  *         Richard Gooch <rgooch@atnf.csiro.au>
87  *         change APM_NOINTS to CONFIG_APM_ALLOW_INTS
88  *         remove dependency on CONFIG_PROC_FS
89  *         Stephen Rothwell
90  *    1.9: Fix small typo.  <laslo@wodip.opole.pl>
91  *         Try to cope with BIOS's that need to have all display
92  *         devices blanked and not just the first one.
93  *         Ross Paterson <ross@soi.city.ac.uk>
94  *         Fix segment limit setting it has always been wrong as
95  *         the segments needed to have byte granularity.
96  *         Mark a few things __init.
97  *         Add hack to allow power off of SMP systems by popular request.
98  *         Use CONFIG_SMP instead of __SMP__
99  *         Ignore BOUNCES for three seconds.
100  *         Stephen Rothwell
101  *   1.10: Fix for Thinkpad return code.
102  *         Merge 2.2 and 2.3 drivers.
103  *         Remove APM dependencies in arch/i386/kernel/process.c
104  *         Remove APM dependencies in drivers/char/sysrq.c
105  *         Reset time across standby.
106  *         Allow more inititialisation on SMP.
107  *         Remove CONFIG_APM_POWER_OFF and make it boot time
108  *         configurable (default on).
109  *         Make debug only a boot time parameter (remove APM_DEBUG).
110  *         Try to blank all devices on any error.
111  *   1.11: Remove APM dependencies in drivers/char/console.c
112  *         Check nr_running to detect if we are idle (from
113  *         Borislav Deianov <borislav@lix.polytechnique.fr>)
114  *         Fix for bioses that don't zero the top part of the
115  *         entrypoint offset (Mario Sitta <sitta@al.unipmn.it>)
116  *         (reported by Panos Katsaloulis <teras@writeme.com>).
117  *         Real mode power off patch (Walter Hofmann
118  *         <Walter.Hofmann@physik.stud.uni-erlangen.de>).
119  *   1.12: Remove CONFIG_SMP as the compiler will optimize
120  *         the code away anyway (smp_num_cpus == 1 in UP)
121  *         noted by Artur Skawina <skawina@geocities.com>.
122  *         Make power off under SMP work again.
123  *         Fix thinko with initial engaging of BIOS.
124  *         Make sure power off only happens on CPU 0
125  *         (Paul "Rusty" Russell <rusty@rustcorp.com.au>).
126  *         Do error notification to user mode if BIOS calls fail.
127  *         Move entrypoint offset fix to ...boot/setup.S
128  *         where it belongs (Cosmos <gis88564@cis.nctu.edu.tw>).
129  *         Remove smp-power-off. SMP users must now specify
130  *         "apm=power-off" on the kernel command line. Suggested
131  *         by Jim Avera <jima@hal.com>, modified by Alan Cox
132  *         <alan@lxorguk.ukuu.org.uk>.
133  *         Register the /proc/apm entry even on SMP so that
134  *         scripts that check for it before doing power off
135  *         work (Jim Avera <jima@hal.com>).
136  *   1.13: Changes for new pm_ interfaces (Andy Henroid
137  *         <andy_henroid@yahoo.com>).
138  *         Modularize the code.
139  *         Fix the Thinkpad (again) :-( (CONFIG_APM_IGNORE_MULTIPLE_SUSPENDS
140  *         is now the way life works).
141  *         Fix thinko in suspend() (wrong return).
142  *         Notify drivers on critical suspend.
143  *         Make kapmd absorb more idle time (Pavel Machek <pavel@ucw.cz>
144  *         modified by sfr).
145  *         Disable interrupts while we are suspended (Andy Henroid
146  *         <andy_henroid@yahoo.com> fixed by sfr).
147  *         Make power off work on SMP again (Tony Hoyle
148  *         <tmh@magenta-logic.com> and <zlatko@iskon.hr>) modified by sfr.
149  *         Remove CONFIG_APM_SUSPEND_BOUNCE.  The bounce ignore
150  *         interval is now configurable.
151  *   1.14: Make connection version persist across module unload/load.
152  *         Enable and engage power management earlier.
153  *         Disengage power management on module unload.
154  *         Changed to use the sysrq-register hack for registering the
155  *         power off function called by magic sysrq based upon discussions
156  *         in irc://irc.openprojects.net/#kernelnewbies
157  *         (Crutcher Dunnavant <crutcher+kernel@datastacks.com>).
158  *         Make CONFIG_APM_REAL_MODE_POWER_OFF run time configurable.
159  *         (Arjan van de Ven <arjanv@redhat.com>) modified by sfr.
160  *         Work around byte swap bug in one of the Vaio's BIOS's
161  *         (Marc Boucher <marc@mbsi.ca>).
162  *         Exposed the disable flag to dmi so that we can handle known
163  *         broken APM (Alan Cox <alan@lxorguk.ukuu.org.uk>).
164  *   1.14ac: If the BIOS says "I slowed the CPU down" then don't spin
165  *         calling it - instead idle. (Alan Cox <alan@lxorguk.ukuu.org.uk>)
166  *         If an APM idle fails log it and idle sensibly
167  *   1.15: Don't queue events to clients who open the device O_WRONLY.
168  *         Don't expect replies from clients who open the device O_RDONLY.
169  *         (Idea from Thomas Hood)
170  *         Minor waitqueue cleanups. (John Fremlin <chief@bandits.org>)
171  *   1.16: Fix idle calling. (Andreas Steinmetz <ast@domdv.de> et al.)
172  *         Notify listeners of standby or suspend events before notifying
173  *         drivers. Return EBUSY to ioctl() if suspend is rejected.
174  *         (Russell King <rmk@arm.linux.org.uk> and Thomas Hood)
175  *         Ignore first resume after we generate our own resume event
176  *         after a suspend (Thomas Hood)
177  *         Daemonize now gets rid of our controlling terminal (sfr).
178  *         CONFIG_APM_CPU_IDLE now just affects the default value of
179  *         idle_threshold (sfr).
180  *         Change name of kernel apm daemon (as it no longer idles) (sfr).
181  *   1.16ac: Fix up SMP support somewhat. You can now force SMP on and we
182  *	   make _all_ APM calls on the CPU#0. Fix unsafe sign bug.
183  *	   TODO: determine if its "boot CPU" or "CPU0" we want to lock to.
184  *
185  * APM 1.1 Reference:
186  *
187  *   Intel Corporation, Microsoft Corporation. Advanced Power Management
188  *   (APM) BIOS Interface Specification, Revision 1.1, September 1993.
189  *   Intel Order Number 241704-001.  Microsoft Part Number 781-110-X01.
190  *
191  * [This document is available free from Intel by calling 800.628.8686 (fax
192  * 916.356.6100) or 800.548.4725; or from
193  * http://www.microsoft.com/whdc/archive/amp_12.mspx  It is also
194  * available from Microsoft by calling 206.882.8080.]
195  *
196  * APM 1.2 Reference:
197  *   Intel Corporation, Microsoft Corporation. Advanced Power Management
198  *   (APM) BIOS Interface Specification, Revision 1.2, February 1996.
199  *
200  * [This document is available from Microsoft at:
201  *    http://www.microsoft.com/whdc/archive/amp_12.mspx]
202  */
203 
204 #define pr_fmt(fmt) "apm: " fmt
205 
206 #include <linux/module.h>
207 
208 #include <linux/poll.h>
209 #include <linux/types.h>
210 #include <linux/stddef.h>
211 #include <linux/timer.h>
212 #include <linux/fcntl.h>
213 #include <linux/slab.h>
214 #include <linux/stat.h>
215 #include <linux/proc_fs.h>
216 #include <linux/seq_file.h>
217 #include <linux/miscdevice.h>
218 #include <linux/apm_bios.h>
219 #include <linux/init.h>
220 #include <linux/time.h>
221 #include <linux/sched.h>
222 #include <linux/pm.h>
223 #include <linux/capability.h>
224 #include <linux/device.h>
225 #include <linux/kernel.h>
226 #include <linux/freezer.h>
227 #include <linux/smp.h>
228 #include <linux/dmi.h>
229 #include <linux/suspend.h>
230 #include <linux/kthread.h>
231 #include <linux/jiffies.h>
232 #include <linux/acpi.h>
233 #include <linux/syscore_ops.h>
234 #include <linux/i8253.h>
235 #include <linux/cpuidle.h>
236 
237 #include <asm/uaccess.h>
238 #include <asm/desc.h>
239 #include <asm/olpc.h>
240 #include <asm/paravirt.h>
241 #include <asm/reboot.h>
242 
243 #if defined(CONFIG_APM_DISPLAY_BLANK) && defined(CONFIG_VT)
244 extern int (*console_blank_hook)(int);
245 #endif
246 
247 /*
248  * The apm_bios device is one of the misc char devices.
249  * This is its minor number.
250  */
251 #define	APM_MINOR_DEV	134
252 
253 /*
254  * Various options can be changed at boot time as follows:
255  * (We allow underscores for compatibility with the modules code)
256  *	apm=on/off			enable/disable APM
257  *	    [no-]allow[-_]ints		allow interrupts during BIOS calls
258  *	    [no-]broken[-_]psr		BIOS has a broken GetPowerStatus call
259  *	    [no-]realmode[-_]power[-_]off	switch to real mode before
260  *	    					powering off
261  *	    [no-]debug			log some debugging messages
262  *	    [no-]power[-_]off		power off on shutdown
263  *	    [no-]smp			Use apm even on an SMP box
264  *	    bounce[-_]interval=<n>	number of ticks to ignore suspend
265  *	    				bounces
266  *          idle[-_]threshold=<n>       System idle percentage above which to
267  *                                      make APM BIOS idle calls. Set it to
268  *                                      100 to disable.
269  *          idle[-_]period=<n>          Period (in 1/100s of a second) over
270  *                                      which the idle percentage is
271  *                                      calculated.
272  */
273 
274 /* KNOWN PROBLEM MACHINES:
275  *
276  * U: TI 4000M TravelMate: BIOS is *NOT* APM compliant
277  *                         [Confirmed by TI representative]
278  * ?: ACER 486DX4/75: uses dseg 0040, in violation of APM specification
279  *                    [Confirmed by BIOS disassembly]
280  *                    [This may work now ...]
281  * P: Toshiba 1950S: battery life information only gets updated after resume
282  * P: Midwest Micro Soundbook Elite DX2/66 monochrome: screen blanking
283  * 	broken in BIOS [Reported by Garst R. Reese <reese@isn.net>]
284  * ?: AcerNote-950: oops on reading /proc/apm - workaround is a WIP
285  * 	Neale Banks <neale@lowendale.com.au> December 2000
286  *
287  * Legend: U = unusable with APM patches
288  *         P = partially usable with APM patches
289  */
290 
291 /*
292  * Define as 1 to make the driver always call the APM BIOS busy
293  * routine even if the clock was not reported as slowed by the
294  * idle routine.  Otherwise, define as 0.
295  */
296 #define ALWAYS_CALL_BUSY   1
297 
298 /*
299  * Define to make the APM BIOS calls zero all data segment registers (so
300  * that an incorrect BIOS implementation will cause a kernel panic if it
301  * tries to write to arbitrary memory).
302  */
303 #define APM_ZERO_SEGS
304 
305 #include <asm/apm.h>
306 
307 /*
308  * Define to re-initialize the interrupt 0 timer to 100 Hz after a suspend.
309  * This patched by Chad Miller <cmiller@surfsouth.com>, original code by
310  * David Chen <chen@ctpa04.mit.edu>
311  */
312 #undef INIT_TIMER_AFTER_SUSPEND
313 
314 #ifdef INIT_TIMER_AFTER_SUSPEND
315 #include <linux/timex.h>
316 #include <asm/io.h>
317 #include <linux/delay.h>
318 #endif
319 
320 /*
321  * Need to poll the APM BIOS every second
322  */
323 #define APM_CHECK_TIMEOUT	(HZ)
324 
325 /*
326  * Ignore suspend events for this amount of time after a resume
327  */
328 #define DEFAULT_BOUNCE_INTERVAL	(3 * HZ)
329 
330 /*
331  * Maximum number of events stored
332  */
333 #define APM_MAX_EVENTS		20
334 
335 /*
336  * The per-file APM data
337  */
338 struct apm_user {
339 	int		magic;
340 	struct apm_user *next;
341 	unsigned int	suser: 1;
342 	unsigned int	writer: 1;
343 	unsigned int	reader: 1;
344 	unsigned int	suspend_wait: 1;
345 	int		suspend_result;
346 	int		suspends_pending;
347 	int		standbys_pending;
348 	int		suspends_read;
349 	int		standbys_read;
350 	int		event_head;
351 	int		event_tail;
352 	apm_event_t	events[APM_MAX_EVENTS];
353 };
354 
355 /*
356  * The magic number in apm_user
357  */
358 #define APM_BIOS_MAGIC		0x4101
359 
360 /*
361  * idle percentage above which bios idle calls are done
362  */
363 #ifdef CONFIG_APM_CPU_IDLE
364 #define DEFAULT_IDLE_THRESHOLD	95
365 #else
366 #define DEFAULT_IDLE_THRESHOLD	100
367 #endif
368 #define DEFAULT_IDLE_PERIOD	(100 / 3)
369 
370 static int apm_cpu_idle(struct cpuidle_device *dev,
371 			struct cpuidle_driver *drv, int index);
372 
373 static struct cpuidle_driver apm_idle_driver = {
374 	.name = "apm_idle",
375 	.owner = THIS_MODULE,
376 	.states = {
377 		{ /* entry 0 is for polling */ },
378 		{ /* entry 1 is for APM idle */
379 			.name = "APM",
380 			.desc = "APM idle",
381 			.flags = CPUIDLE_FLAG_TIME_VALID,
382 			.exit_latency = 250,	/* WAG */
383 			.target_residency = 500,	/* WAG */
384 			.enter = &apm_cpu_idle
385 		},
386 	},
387 	.state_count = 2,
388 };
389 
390 static struct cpuidle_device apm_cpuidle_device;
391 
392 /*
393  * Local variables
394  */
395 __visible struct {
396 	unsigned long	offset;
397 	unsigned short	segment;
398 } apm_bios_entry;
399 static int clock_slowed;
400 static int idle_threshold __read_mostly = DEFAULT_IDLE_THRESHOLD;
401 static int idle_period __read_mostly = DEFAULT_IDLE_PERIOD;
402 static int suspends_pending;
403 static int standbys_pending;
404 static int ignore_sys_suspend;
405 static int ignore_normal_resume;
406 static int bounce_interval __read_mostly = DEFAULT_BOUNCE_INTERVAL;
407 
408 static bool debug __read_mostly;
409 static bool smp __read_mostly;
410 static int apm_disabled = -1;
411 #ifdef CONFIG_SMP
412 static bool power_off;
413 #else
414 static bool power_off = 1;
415 #endif
416 static bool realmode_power_off;
417 #ifdef CONFIG_APM_ALLOW_INTS
418 static bool allow_ints = 1;
419 #else
420 static bool allow_ints;
421 #endif
422 static bool broken_psr;
423 
424 static DECLARE_WAIT_QUEUE_HEAD(apm_waitqueue);
425 static DECLARE_WAIT_QUEUE_HEAD(apm_suspend_waitqueue);
426 static struct apm_user *user_list;
427 static DEFINE_SPINLOCK(user_list_lock);
428 static DEFINE_MUTEX(apm_mutex);
429 
430 /*
431  * Set up a segment that references the real mode segment 0x40
432  * that extends up to the end of page zero (that we have reserved).
433  * This is for buggy BIOS's that refer to (real mode) segment 0x40
434  * even though they are called in protected mode.
435  */
436 static struct desc_struct bad_bios_desc = GDT_ENTRY_INIT(0x4092,
437 			(unsigned long)__va(0x400UL), PAGE_SIZE - 0x400 - 1);
438 
439 static const char driver_version[] = "1.16ac";	/* no spaces */
440 
441 static struct task_struct *kapmd_task;
442 
443 /*
444  *	APM event names taken from the APM 1.2 specification. These are
445  *	the message codes that the BIOS uses to tell us about events
446  */
447 static const char * const apm_event_name[] = {
448 	"system standby",
449 	"system suspend",
450 	"normal resume",
451 	"critical resume",
452 	"low battery",
453 	"power status change",
454 	"update time",
455 	"critical suspend",
456 	"user standby",
457 	"user suspend",
458 	"system standby resume",
459 	"capabilities change"
460 };
461 #define NR_APM_EVENT_NAME ARRAY_SIZE(apm_event_name)
462 
463 typedef struct lookup_t {
464 	int	key;
465 	char 	*msg;
466 } lookup_t;
467 
468 /*
469  *	The BIOS returns a set of standard error codes in AX when the
470  *	carry flag is set.
471  */
472 
473 static const lookup_t error_table[] = {
474 /* N/A	{ APM_SUCCESS,		"Operation succeeded" }, */
475 	{ APM_DISABLED,		"Power management disabled" },
476 	{ APM_CONNECTED,	"Real mode interface already connected" },
477 	{ APM_NOT_CONNECTED,	"Interface not connected" },
478 	{ APM_16_CONNECTED,	"16 bit interface already connected" },
479 /* N/A	{ APM_16_UNSUPPORTED,	"16 bit interface not supported" }, */
480 	{ APM_32_CONNECTED,	"32 bit interface already connected" },
481 	{ APM_32_UNSUPPORTED,	"32 bit interface not supported" },
482 	{ APM_BAD_DEVICE,	"Unrecognized device ID" },
483 	{ APM_BAD_PARAM,	"Parameter out of range" },
484 	{ APM_NOT_ENGAGED,	"Interface not engaged" },
485 	{ APM_BAD_FUNCTION,     "Function not supported" },
486 	{ APM_RESUME_DISABLED,	"Resume timer disabled" },
487 	{ APM_BAD_STATE,	"Unable to enter requested state" },
488 /* N/A	{ APM_NO_EVENTS,	"No events pending" }, */
489 	{ APM_NO_ERROR,		"BIOS did not set a return code" },
490 	{ APM_NOT_PRESENT,	"No APM present" }
491 };
492 #define ERROR_COUNT	ARRAY_SIZE(error_table)
493 
494 /**
495  *	apm_error	-	display an APM error
496  *	@str: information string
497  *	@err: APM BIOS return code
498  *
499  *	Write a meaningful log entry to the kernel log in the event of
500  *	an APM error.  Note that this also handles (negative) kernel errors.
501  */
502 
apm_error(char * str,int err)503 static void apm_error(char *str, int err)
504 {
505 	int i;
506 
507 	for (i = 0; i < ERROR_COUNT; i++)
508 		if (error_table[i].key == err)
509 			break;
510 	if (i < ERROR_COUNT)
511 		pr_notice("%s: %s\n", str, error_table[i].msg);
512 	else if (err < 0)
513 		pr_notice("%s: linux error code %i\n", str, err);
514 	else
515 		pr_notice("%s: unknown error code %#2.2x\n",
516 		       str, err);
517 }
518 
519 /*
520  * These are the actual BIOS calls.  Depending on APM_ZERO_SEGS and
521  * apm_info.allow_ints, we are being really paranoid here!  Not only
522  * are interrupts disabled, but all the segment registers (except SS)
523  * are saved and zeroed this means that if the BIOS tries to reference
524  * any data without explicitly loading the segment registers, the kernel
525  * will fault immediately rather than have some unforeseen circumstances
526  * for the rest of the kernel.  And it will be very obvious!  :-) Doing
527  * this depends on CS referring to the same physical memory as DS so that
528  * DS can be zeroed before the call. Unfortunately, we can't do anything
529  * about the stack segment/pointer.  Also, we tell the compiler that
530  * everything could change.
531  *
532  * Also, we KNOW that for the non error case of apm_bios_call, there
533  * is no useful data returned in the low order 8 bits of eax.
534  */
535 
__apm_irq_save(void)536 static inline unsigned long __apm_irq_save(void)
537 {
538 	unsigned long flags;
539 	local_save_flags(flags);
540 	if (apm_info.allow_ints) {
541 		if (irqs_disabled_flags(flags))
542 			local_irq_enable();
543 	} else
544 		local_irq_disable();
545 
546 	return flags;
547 }
548 
549 #define apm_irq_save(flags) \
550 	do { flags = __apm_irq_save(); } while (0)
551 
apm_irq_restore(unsigned long flags)552 static inline void apm_irq_restore(unsigned long flags)
553 {
554 	if (irqs_disabled_flags(flags))
555 		local_irq_disable();
556 	else if (irqs_disabled())
557 		local_irq_enable();
558 }
559 
560 #ifdef APM_ZERO_SEGS
561 #	define APM_DECL_SEGS \
562 		unsigned int saved_fs; unsigned int saved_gs;
563 #	define APM_DO_SAVE_SEGS \
564 		savesegment(fs, saved_fs); savesegment(gs, saved_gs)
565 #	define APM_DO_RESTORE_SEGS \
566 		loadsegment(fs, saved_fs); loadsegment(gs, saved_gs)
567 #else
568 #	define APM_DECL_SEGS
569 #	define APM_DO_SAVE_SEGS
570 #	define APM_DO_RESTORE_SEGS
571 #endif
572 
573 struct apm_bios_call {
574 	u32 func;
575 	/* In and out */
576 	u32 ebx;
577 	u32 ecx;
578 	/* Out only */
579 	u32 eax;
580 	u32 edx;
581 	u32 esi;
582 
583 	/* Error: -ENOMEM, or bits 8-15 of eax */
584 	int err;
585 };
586 
587 /**
588  *	__apm_bios_call - Make an APM BIOS 32bit call
589  *	@_call: pointer to struct apm_bios_call.
590  *
591  *	Make an APM call using the 32bit protected mode interface. The
592  *	caller is responsible for knowing if APM BIOS is configured and
593  *	enabled. This call can disable interrupts for a long period of
594  *	time on some laptops.  The return value is in AH and the carry
595  *	flag is loaded into AL.  If there is an error, then the error
596  *	code is returned in AH (bits 8-15 of eax) and this function
597  *	returns non-zero.
598  *
599  *	Note: this makes the call on the current CPU.
600  */
__apm_bios_call(void * _call)601 static long __apm_bios_call(void *_call)
602 {
603 	APM_DECL_SEGS
604 	unsigned long		flags;
605 	int			cpu;
606 	struct desc_struct	save_desc_40;
607 	struct desc_struct	*gdt;
608 	struct apm_bios_call	*call = _call;
609 
610 	cpu = get_cpu();
611 	BUG_ON(cpu != 0);
612 	gdt = get_cpu_gdt_table(cpu);
613 	save_desc_40 = gdt[0x40 / 8];
614 	gdt[0x40 / 8] = bad_bios_desc;
615 
616 	apm_irq_save(flags);
617 	APM_DO_SAVE_SEGS;
618 	apm_bios_call_asm(call->func, call->ebx, call->ecx,
619 			  &call->eax, &call->ebx, &call->ecx, &call->edx,
620 			  &call->esi);
621 	APM_DO_RESTORE_SEGS;
622 	apm_irq_restore(flags);
623 	gdt[0x40 / 8] = save_desc_40;
624 	put_cpu();
625 
626 	return call->eax & 0xff;
627 }
628 
629 /* Run __apm_bios_call or __apm_bios_call_simple on CPU 0 */
on_cpu0(long (* fn)(void *),struct apm_bios_call * call)630 static int on_cpu0(long (*fn)(void *), struct apm_bios_call *call)
631 {
632 	int ret;
633 
634 	/* Don't bother with work_on_cpu in the common case, so we don't
635 	 * have to worry about OOM or overhead. */
636 	if (get_cpu() == 0) {
637 		ret = fn(call);
638 		put_cpu();
639 	} else {
640 		put_cpu();
641 		ret = work_on_cpu(0, fn, call);
642 	}
643 
644 	/* work_on_cpu can fail with -ENOMEM */
645 	if (ret < 0)
646 		call->err = ret;
647 	else
648 		call->err = (call->eax >> 8) & 0xff;
649 
650 	return ret;
651 }
652 
653 /**
654  *	apm_bios_call	-	Make an APM BIOS 32bit call (on CPU 0)
655  *	@call: the apm_bios_call registers.
656  *
657  *	If there is an error, it is returned in @call.err.
658  */
apm_bios_call(struct apm_bios_call * call)659 static int apm_bios_call(struct apm_bios_call *call)
660 {
661 	return on_cpu0(__apm_bios_call, call);
662 }
663 
664 /**
665  *	__apm_bios_call_simple - Make an APM BIOS 32bit call (on CPU 0)
666  *	@_call: pointer to struct apm_bios_call.
667  *
668  *	Make a BIOS call that returns one value only, or just status.
669  *	If there is an error, then the error code is returned in AH
670  *	(bits 8-15 of eax) and this function returns non-zero (it can
671  *	also return -ENOMEM). This is used for simpler BIOS operations.
672  *	This call may hold interrupts off for a long time on some laptops.
673  *
674  *	Note: this makes the call on the current CPU.
675  */
__apm_bios_call_simple(void * _call)676 static long __apm_bios_call_simple(void *_call)
677 {
678 	u8			error;
679 	APM_DECL_SEGS
680 	unsigned long		flags;
681 	int			cpu;
682 	struct desc_struct	save_desc_40;
683 	struct desc_struct	*gdt;
684 	struct apm_bios_call	*call = _call;
685 
686 	cpu = get_cpu();
687 	BUG_ON(cpu != 0);
688 	gdt = get_cpu_gdt_table(cpu);
689 	save_desc_40 = gdt[0x40 / 8];
690 	gdt[0x40 / 8] = bad_bios_desc;
691 
692 	apm_irq_save(flags);
693 	APM_DO_SAVE_SEGS;
694 	error = apm_bios_call_simple_asm(call->func, call->ebx, call->ecx,
695 					 &call->eax);
696 	APM_DO_RESTORE_SEGS;
697 	apm_irq_restore(flags);
698 	gdt[0x40 / 8] = save_desc_40;
699 	put_cpu();
700 	return error;
701 }
702 
703 /**
704  *	apm_bios_call_simple	-	make a simple APM BIOS 32bit call
705  *	@func: APM function to invoke
706  *	@ebx_in: EBX register value for BIOS call
707  *	@ecx_in: ECX register value for BIOS call
708  *	@eax: EAX register on return from the BIOS call
709  *	@err: bits
710  *
711  *	Make a BIOS call that returns one value only, or just status.
712  *	If there is an error, then the error code is returned in @err
713  *	and this function returns non-zero. This is used for simpler
714  *	BIOS operations.  This call may hold interrupts off for a long
715  *	time on some laptops.
716  */
apm_bios_call_simple(u32 func,u32 ebx_in,u32 ecx_in,u32 * eax,int * err)717 static int apm_bios_call_simple(u32 func, u32 ebx_in, u32 ecx_in, u32 *eax,
718 				int *err)
719 {
720 	struct apm_bios_call call;
721 	int ret;
722 
723 	call.func = func;
724 	call.ebx = ebx_in;
725 	call.ecx = ecx_in;
726 
727 	ret = on_cpu0(__apm_bios_call_simple, &call);
728 	*eax = call.eax;
729 	*err = call.err;
730 	return ret;
731 }
732 
733 /**
734  *	apm_driver_version	-	APM driver version
735  *	@val:	loaded with the APM version on return
736  *
737  *	Retrieve the APM version supported by the BIOS. This is only
738  *	supported for APM 1.1 or higher. An error indicates APM 1.0 is
739  *	probably present.
740  *
741  *	On entry val should point to a value indicating the APM driver
742  *	version with the high byte being the major and the low byte the
743  *	minor number both in BCD
744  *
745  *	On return it will hold the BIOS revision supported in the
746  *	same format.
747  */
748 
apm_driver_version(u_short * val)749 static int apm_driver_version(u_short *val)
750 {
751 	u32 eax;
752 	int err;
753 
754 	if (apm_bios_call_simple(APM_FUNC_VERSION, 0, *val, &eax, &err))
755 		return err;
756 	*val = eax;
757 	return APM_SUCCESS;
758 }
759 
760 /**
761  *	apm_get_event	-	get an APM event from the BIOS
762  *	@event: pointer to the event
763  *	@info: point to the event information
764  *
765  *	The APM BIOS provides a polled information for event
766  *	reporting. The BIOS expects to be polled at least every second
767  *	when events are pending. When a message is found the caller should
768  *	poll until no more messages are present.  However, this causes
769  *	problems on some laptops where a suspend event notification is
770  *	not cleared until it is acknowledged.
771  *
772  *	Additional information is returned in the info pointer, providing
773  *	that APM 1.2 is in use. If no messges are pending the value 0x80
774  *	is returned (No power management events pending).
775  */
apm_get_event(apm_event_t * event,apm_eventinfo_t * info)776 static int apm_get_event(apm_event_t *event, apm_eventinfo_t *info)
777 {
778 	struct apm_bios_call call;
779 
780 	call.func = APM_FUNC_GET_EVENT;
781 	call.ebx = call.ecx = 0;
782 
783 	if (apm_bios_call(&call))
784 		return call.err;
785 
786 	*event = call.ebx;
787 	if (apm_info.connection_version < 0x0102)
788 		*info = ~0; /* indicate info not valid */
789 	else
790 		*info = call.ecx;
791 	return APM_SUCCESS;
792 }
793 
794 /**
795  *	set_power_state	-	set the power management state
796  *	@what: which items to transition
797  *	@state: state to transition to
798  *
799  *	Request an APM change of state for one or more system devices. The
800  *	processor state must be transitioned last of all. what holds the
801  *	class of device in the upper byte and the device number (0xFF for
802  *	all) for the object to be transitioned.
803  *
804  *	The state holds the state to transition to, which may in fact
805  *	be an acceptance of a BIOS requested state change.
806  */
807 
set_power_state(u_short what,u_short state)808 static int set_power_state(u_short what, u_short state)
809 {
810 	u32 eax;
811 	int err;
812 
813 	if (apm_bios_call_simple(APM_FUNC_SET_STATE, what, state, &eax, &err))
814 		return err;
815 	return APM_SUCCESS;
816 }
817 
818 /**
819  *	set_system_power_state - set system wide power state
820  *	@state: which state to enter
821  *
822  *	Transition the entire system into a new APM power state.
823  */
824 
set_system_power_state(u_short state)825 static int set_system_power_state(u_short state)
826 {
827 	return set_power_state(APM_DEVICE_ALL, state);
828 }
829 
830 /**
831  *	apm_do_idle	-	perform power saving
832  *
833  *	This function notifies the BIOS that the processor is (in the view
834  *	of the OS) idle. It returns -1 in the event that the BIOS refuses
835  *	to handle the idle request. On a success the function returns 1
836  *	if the BIOS did clock slowing or 0 otherwise.
837  */
838 
apm_do_idle(void)839 static int apm_do_idle(void)
840 {
841 	u32 eax;
842 	u8 ret = 0;
843 	int idled = 0;
844 	int err = 0;
845 
846 	if (!need_resched()) {
847 		idled = 1;
848 		ret = apm_bios_call_simple(APM_FUNC_IDLE, 0, 0, &eax, &err);
849 	}
850 
851 	if (!idled)
852 		return 0;
853 
854 	if (ret) {
855 		static unsigned long t;
856 
857 		/* This always fails on some SMP boards running UP kernels.
858 		 * Only report the failure the first 5 times.
859 		 */
860 		if (++t < 5) {
861 			printk(KERN_DEBUG "apm_do_idle failed (%d)\n", err);
862 			t = jiffies;
863 		}
864 		return -1;
865 	}
866 	clock_slowed = (apm_info.bios.flags & APM_IDLE_SLOWS_CLOCK) != 0;
867 	return clock_slowed;
868 }
869 
870 /**
871  *	apm_do_busy	-	inform the BIOS the CPU is busy
872  *
873  *	Request that the BIOS brings the CPU back to full performance.
874  */
875 
apm_do_busy(void)876 static void apm_do_busy(void)
877 {
878 	u32 dummy;
879 	int err;
880 
881 	if (clock_slowed || ALWAYS_CALL_BUSY) {
882 		(void)apm_bios_call_simple(APM_FUNC_BUSY, 0, 0, &dummy, &err);
883 		clock_slowed = 0;
884 	}
885 }
886 
887 /*
888  * If no process has really been interested in
889  * the CPU for some time, we want to call BIOS
890  * power management - we probably want
891  * to conserve power.
892  */
893 #define IDLE_CALC_LIMIT	(HZ * 100)
894 #define IDLE_LEAKY_MAX	16
895 
896 /**
897  * apm_cpu_idle		-	cpu idling for APM capable Linux
898  *
899  * This is the idling function the kernel executes when APM is available. It
900  * tries to do BIOS powermanagement based on the average system idle time.
901  * Furthermore it calls the system default idle routine.
902  */
903 
apm_cpu_idle(struct cpuidle_device * dev,struct cpuidle_driver * drv,int index)904 static int apm_cpu_idle(struct cpuidle_device *dev,
905 	struct cpuidle_driver *drv, int index)
906 {
907 	static int use_apm_idle; /* = 0 */
908 	static unsigned int last_jiffies; /* = 0 */
909 	static unsigned int last_stime; /* = 0 */
910 	cputime_t stime;
911 
912 	int apm_idle_done = 0;
913 	unsigned int jiffies_since_last_check = jiffies - last_jiffies;
914 	unsigned int bucket;
915 
916 recalc:
917 	task_cputime(current, NULL, &stime);
918 	if (jiffies_since_last_check > IDLE_CALC_LIMIT) {
919 		use_apm_idle = 0;
920 	} else if (jiffies_since_last_check > idle_period) {
921 		unsigned int idle_percentage;
922 
923 		idle_percentage = stime - last_stime;
924 		idle_percentage *= 100;
925 		idle_percentage /= jiffies_since_last_check;
926 		use_apm_idle = (idle_percentage > idle_threshold);
927 		if (apm_info.forbid_idle)
928 			use_apm_idle = 0;
929 	}
930 
931 	last_jiffies = jiffies;
932 	last_stime = stime;
933 
934 	bucket = IDLE_LEAKY_MAX;
935 
936 	while (!need_resched()) {
937 		if (use_apm_idle) {
938 			unsigned int t;
939 
940 			t = jiffies;
941 			switch (apm_do_idle()) {
942 			case 0:
943 				apm_idle_done = 1;
944 				if (t != jiffies) {
945 					if (bucket) {
946 						bucket = IDLE_LEAKY_MAX;
947 						continue;
948 					}
949 				} else if (bucket) {
950 					bucket--;
951 					continue;
952 				}
953 				break;
954 			case 1:
955 				apm_idle_done = 1;
956 				break;
957 			default: /* BIOS refused */
958 				break;
959 			}
960 		}
961 		default_idle();
962 		local_irq_disable();
963 		jiffies_since_last_check = jiffies - last_jiffies;
964 		if (jiffies_since_last_check > idle_period)
965 			goto recalc;
966 	}
967 
968 	if (apm_idle_done)
969 		apm_do_busy();
970 
971 	return index;
972 }
973 
974 /**
975  *	apm_power_off	-	ask the BIOS to power off
976  *
977  *	Handle the power off sequence. This is the one piece of code we
978  *	will execute even on SMP machines. In order to deal with BIOS
979  *	bugs we support real mode APM BIOS power off calls. We also make
980  *	the SMP call on CPU0 as some systems will only honour this call
981  *	on their first cpu.
982  */
983 
apm_power_off(void)984 static void apm_power_off(void)
985 {
986 	/* Some bioses don't like being called from CPU != 0 */
987 	if (apm_info.realmode_power_off) {
988 		set_cpus_allowed_ptr(current, cpumask_of(0));
989 		machine_real_restart(MRR_APM);
990 	} else {
991 		(void)set_system_power_state(APM_STATE_OFF);
992 	}
993 }
994 
995 #ifdef CONFIG_APM_DO_ENABLE
996 
997 /**
998  *	apm_enable_power_management - enable BIOS APM power management
999  *	@enable: enable yes/no
1000  *
1001  *	Enable or disable the APM BIOS power services.
1002  */
1003 
apm_enable_power_management(int enable)1004 static int apm_enable_power_management(int enable)
1005 {
1006 	u32 eax;
1007 	int err;
1008 
1009 	if ((enable == 0) && (apm_info.bios.flags & APM_BIOS_DISENGAGED))
1010 		return APM_NOT_ENGAGED;
1011 	if (apm_bios_call_simple(APM_FUNC_ENABLE_PM, APM_DEVICE_BALL,
1012 				 enable, &eax, &err))
1013 		return err;
1014 	if (enable)
1015 		apm_info.bios.flags &= ~APM_BIOS_DISABLED;
1016 	else
1017 		apm_info.bios.flags |= APM_BIOS_DISABLED;
1018 	return APM_SUCCESS;
1019 }
1020 #endif
1021 
1022 /**
1023  *	apm_get_power_status	-	get current power state
1024  *	@status: returned status
1025  *	@bat: battery info
1026  *	@life: estimated life
1027  *
1028  *	Obtain the current power status from the APM BIOS. We return a
1029  *	status which gives the rough battery status, and current power
1030  *	source. The bat value returned give an estimate as a percentage
1031  *	of life and a status value for the battery. The estimated life
1032  *	if reported is a lifetime in secodnds/minutes at current powwer
1033  *	consumption.
1034  */
1035 
apm_get_power_status(u_short * status,u_short * bat,u_short * life)1036 static int apm_get_power_status(u_short *status, u_short *bat, u_short *life)
1037 {
1038 	struct apm_bios_call call;
1039 
1040 	call.func = APM_FUNC_GET_STATUS;
1041 	call.ebx = APM_DEVICE_ALL;
1042 	call.ecx = 0;
1043 
1044 	if (apm_info.get_power_status_broken)
1045 		return APM_32_UNSUPPORTED;
1046 	if (apm_bios_call(&call))
1047 		return call.err;
1048 	*status = call.ebx;
1049 	*bat = call.ecx;
1050 	if (apm_info.get_power_status_swabinminutes) {
1051 		*life = swab16((u16)call.edx);
1052 		*life |= 0x8000;
1053 	} else
1054 		*life = call.edx;
1055 	return APM_SUCCESS;
1056 }
1057 
1058 #if 0
1059 static int apm_get_battery_status(u_short which, u_short *status,
1060 				  u_short *bat, u_short *life, u_short *nbat)
1061 {
1062 	u32 eax;
1063 	u32 ebx;
1064 	u32 ecx;
1065 	u32 edx;
1066 	u32 esi;
1067 
1068 	if (apm_info.connection_version < 0x0102) {
1069 		/* pretend we only have one battery. */
1070 		if (which != 1)
1071 			return APM_BAD_DEVICE;
1072 		*nbat = 1;
1073 		return apm_get_power_status(status, bat, life);
1074 	}
1075 
1076 	if (apm_bios_call(APM_FUNC_GET_STATUS, (0x8000 | (which)), 0, &eax,
1077 			  &ebx, &ecx, &edx, &esi))
1078 		return (eax >> 8) & 0xff;
1079 	*status = ebx;
1080 	*bat = ecx;
1081 	*life = edx;
1082 	*nbat = esi;
1083 	return APM_SUCCESS;
1084 }
1085 #endif
1086 
1087 /**
1088  *	apm_engage_power_management	-	enable PM on a device
1089  *	@device: identity of device
1090  *	@enable: on/off
1091  *
1092  *	Activate or deactive power management on either a specific device
1093  *	or the entire system (%APM_DEVICE_ALL).
1094  */
1095 
apm_engage_power_management(u_short device,int enable)1096 static int apm_engage_power_management(u_short device, int enable)
1097 {
1098 	u32 eax;
1099 	int err;
1100 
1101 	if ((enable == 0) && (device == APM_DEVICE_ALL)
1102 	    && (apm_info.bios.flags & APM_BIOS_DISABLED))
1103 		return APM_DISABLED;
1104 	if (apm_bios_call_simple(APM_FUNC_ENGAGE_PM, device, enable,
1105 				 &eax, &err))
1106 		return err;
1107 	if (device == APM_DEVICE_ALL) {
1108 		if (enable)
1109 			apm_info.bios.flags &= ~APM_BIOS_DISENGAGED;
1110 		else
1111 			apm_info.bios.flags |= APM_BIOS_DISENGAGED;
1112 	}
1113 	return APM_SUCCESS;
1114 }
1115 
1116 #if defined(CONFIG_APM_DISPLAY_BLANK) && defined(CONFIG_VT)
1117 
1118 /**
1119  *	apm_console_blank	-	blank the display
1120  *	@blank: on/off
1121  *
1122  *	Attempt to blank the console, firstly by blanking just video device
1123  *	zero, and if that fails (some BIOSes don't support it) then it blanks
1124  *	all video devices. Typically the BIOS will do laptop backlight and
1125  *	monitor powerdown for us.
1126  */
1127 
apm_console_blank(int blank)1128 static int apm_console_blank(int blank)
1129 {
1130 	int error = APM_NOT_ENGAGED; /* silence gcc */
1131 	int i;
1132 	u_short state;
1133 	static const u_short dev[3] = { 0x100, 0x1FF, 0x101 };
1134 
1135 	state = blank ? APM_STATE_STANDBY : APM_STATE_READY;
1136 
1137 	for (i = 0; i < ARRAY_SIZE(dev); i++) {
1138 		error = set_power_state(dev[i], state);
1139 
1140 		if ((error == APM_SUCCESS) || (error == APM_NO_ERROR))
1141 			return 1;
1142 
1143 		if (error == APM_NOT_ENGAGED)
1144 			break;
1145 	}
1146 
1147 	if (error == APM_NOT_ENGAGED) {
1148 		static int tried;
1149 		int eng_error;
1150 		if (tried++ == 0) {
1151 			eng_error = apm_engage_power_management(APM_DEVICE_ALL, 1);
1152 			if (eng_error) {
1153 				apm_error("set display", error);
1154 				apm_error("engage interface", eng_error);
1155 				return 0;
1156 			} else
1157 				return apm_console_blank(blank);
1158 		}
1159 	}
1160 	apm_error("set display", error);
1161 	return 0;
1162 }
1163 #endif
1164 
queue_empty(struct apm_user * as)1165 static int queue_empty(struct apm_user *as)
1166 {
1167 	return as->event_head == as->event_tail;
1168 }
1169 
get_queued_event(struct apm_user * as)1170 static apm_event_t get_queued_event(struct apm_user *as)
1171 {
1172 	if (++as->event_tail >= APM_MAX_EVENTS)
1173 		as->event_tail = 0;
1174 	return as->events[as->event_tail];
1175 }
1176 
queue_event(apm_event_t event,struct apm_user * sender)1177 static void queue_event(apm_event_t event, struct apm_user *sender)
1178 {
1179 	struct apm_user *as;
1180 
1181 	spin_lock(&user_list_lock);
1182 	if (user_list == NULL)
1183 		goto out;
1184 	for (as = user_list; as != NULL; as = as->next) {
1185 		if ((as == sender) || (!as->reader))
1186 			continue;
1187 		if (++as->event_head >= APM_MAX_EVENTS)
1188 			as->event_head = 0;
1189 
1190 		if (as->event_head == as->event_tail) {
1191 			static int notified;
1192 
1193 			if (notified++ == 0)
1194 				pr_err("an event queue overflowed\n");
1195 			if (++as->event_tail >= APM_MAX_EVENTS)
1196 				as->event_tail = 0;
1197 		}
1198 		as->events[as->event_head] = event;
1199 		if (!as->suser || !as->writer)
1200 			continue;
1201 		switch (event) {
1202 		case APM_SYS_SUSPEND:
1203 		case APM_USER_SUSPEND:
1204 			as->suspends_pending++;
1205 			suspends_pending++;
1206 			break;
1207 
1208 		case APM_SYS_STANDBY:
1209 		case APM_USER_STANDBY:
1210 			as->standbys_pending++;
1211 			standbys_pending++;
1212 			break;
1213 		}
1214 	}
1215 	wake_up_interruptible(&apm_waitqueue);
1216 out:
1217 	spin_unlock(&user_list_lock);
1218 }
1219 
reinit_timer(void)1220 static void reinit_timer(void)
1221 {
1222 #ifdef INIT_TIMER_AFTER_SUSPEND
1223 	unsigned long flags;
1224 
1225 	raw_spin_lock_irqsave(&i8253_lock, flags);
1226 	/* set the clock to HZ */
1227 	outb_p(0x34, PIT_MODE);		/* binary, mode 2, LSB/MSB, ch 0 */
1228 	udelay(10);
1229 	outb_p(LATCH & 0xff, PIT_CH0);	/* LSB */
1230 	udelay(10);
1231 	outb_p(LATCH >> 8, PIT_CH0);	/* MSB */
1232 	udelay(10);
1233 	raw_spin_unlock_irqrestore(&i8253_lock, flags);
1234 #endif
1235 }
1236 
suspend(int vetoable)1237 static int suspend(int vetoable)
1238 {
1239 	int err;
1240 	struct apm_user	*as;
1241 
1242 	dpm_suspend_start(PMSG_SUSPEND);
1243 	dpm_suspend_end(PMSG_SUSPEND);
1244 
1245 	local_irq_disable();
1246 	syscore_suspend();
1247 
1248 	local_irq_enable();
1249 
1250 	save_processor_state();
1251 	err = set_system_power_state(APM_STATE_SUSPEND);
1252 	ignore_normal_resume = 1;
1253 	restore_processor_state();
1254 
1255 	local_irq_disable();
1256 	reinit_timer();
1257 
1258 	if (err == APM_NO_ERROR)
1259 		err = APM_SUCCESS;
1260 	if (err != APM_SUCCESS)
1261 		apm_error("suspend", err);
1262 	err = (err == APM_SUCCESS) ? 0 : -EIO;
1263 
1264 	syscore_resume();
1265 	local_irq_enable();
1266 
1267 	dpm_resume_start(PMSG_RESUME);
1268 	dpm_resume_end(PMSG_RESUME);
1269 
1270 	queue_event(APM_NORMAL_RESUME, NULL);
1271 	spin_lock(&user_list_lock);
1272 	for (as = user_list; as != NULL; as = as->next) {
1273 		as->suspend_wait = 0;
1274 		as->suspend_result = err;
1275 	}
1276 	spin_unlock(&user_list_lock);
1277 	wake_up_interruptible(&apm_suspend_waitqueue);
1278 	return err;
1279 }
1280 
standby(void)1281 static void standby(void)
1282 {
1283 	int err;
1284 
1285 	dpm_suspend_end(PMSG_SUSPEND);
1286 
1287 	local_irq_disable();
1288 	syscore_suspend();
1289 	local_irq_enable();
1290 
1291 	err = set_system_power_state(APM_STATE_STANDBY);
1292 	if ((err != APM_SUCCESS) && (err != APM_NO_ERROR))
1293 		apm_error("standby", err);
1294 
1295 	local_irq_disable();
1296 	syscore_resume();
1297 	local_irq_enable();
1298 
1299 	dpm_resume_start(PMSG_RESUME);
1300 }
1301 
get_event(void)1302 static apm_event_t get_event(void)
1303 {
1304 	int error;
1305 	apm_event_t event = APM_NO_EVENTS; /* silence gcc */
1306 	apm_eventinfo_t	info;
1307 
1308 	static int notified;
1309 
1310 	/* we don't use the eventinfo */
1311 	error = apm_get_event(&event, &info);
1312 	if (error == APM_SUCCESS)
1313 		return event;
1314 
1315 	if ((error != APM_NO_EVENTS) && (notified++ == 0))
1316 		apm_error("get_event", error);
1317 
1318 	return 0;
1319 }
1320 
check_events(void)1321 static void check_events(void)
1322 {
1323 	apm_event_t event;
1324 	static unsigned long last_resume;
1325 	static int ignore_bounce;
1326 
1327 	while ((event = get_event()) != 0) {
1328 		if (debug) {
1329 			if (event <= NR_APM_EVENT_NAME)
1330 				printk(KERN_DEBUG "apm: received %s notify\n",
1331 				       apm_event_name[event - 1]);
1332 			else
1333 				printk(KERN_DEBUG "apm: received unknown "
1334 				       "event 0x%02x\n", event);
1335 		}
1336 		if (ignore_bounce
1337 		    && (time_after(jiffies, last_resume + bounce_interval)))
1338 			ignore_bounce = 0;
1339 
1340 		switch (event) {
1341 		case APM_SYS_STANDBY:
1342 		case APM_USER_STANDBY:
1343 			queue_event(event, NULL);
1344 			if (standbys_pending <= 0)
1345 				standby();
1346 			break;
1347 
1348 		case APM_USER_SUSPEND:
1349 #ifdef CONFIG_APM_IGNORE_USER_SUSPEND
1350 			if (apm_info.connection_version > 0x100)
1351 				set_system_power_state(APM_STATE_REJECT);
1352 			break;
1353 #endif
1354 		case APM_SYS_SUSPEND:
1355 			if (ignore_bounce) {
1356 				if (apm_info.connection_version > 0x100)
1357 					set_system_power_state(APM_STATE_REJECT);
1358 				break;
1359 			}
1360 			/*
1361 			 * If we are already processing a SUSPEND,
1362 			 * then further SUSPEND events from the BIOS
1363 			 * will be ignored.  We also return here to
1364 			 * cope with the fact that the Thinkpads keep
1365 			 * sending a SUSPEND event until something else
1366 			 * happens!
1367 			 */
1368 			if (ignore_sys_suspend)
1369 				return;
1370 			ignore_sys_suspend = 1;
1371 			queue_event(event, NULL);
1372 			if (suspends_pending <= 0)
1373 				(void) suspend(1);
1374 			break;
1375 
1376 		case APM_NORMAL_RESUME:
1377 		case APM_CRITICAL_RESUME:
1378 		case APM_STANDBY_RESUME:
1379 			ignore_sys_suspend = 0;
1380 			last_resume = jiffies;
1381 			ignore_bounce = 1;
1382 			if ((event != APM_NORMAL_RESUME)
1383 			    || (ignore_normal_resume == 0)) {
1384 				dpm_resume_end(PMSG_RESUME);
1385 				queue_event(event, NULL);
1386 			}
1387 			ignore_normal_resume = 0;
1388 			break;
1389 
1390 		case APM_CAPABILITY_CHANGE:
1391 		case APM_LOW_BATTERY:
1392 		case APM_POWER_STATUS_CHANGE:
1393 			queue_event(event, NULL);
1394 			/* If needed, notify drivers here */
1395 			break;
1396 
1397 		case APM_UPDATE_TIME:
1398 			break;
1399 
1400 		case APM_CRITICAL_SUSPEND:
1401 			/*
1402 			 * We are not allowed to reject a critical suspend.
1403 			 */
1404 			(void)suspend(0);
1405 			break;
1406 		}
1407 	}
1408 }
1409 
apm_event_handler(void)1410 static void apm_event_handler(void)
1411 {
1412 	static int pending_count = 4;
1413 	int err;
1414 
1415 	if ((standbys_pending > 0) || (suspends_pending > 0)) {
1416 		if ((apm_info.connection_version > 0x100) &&
1417 		    (pending_count-- <= 0)) {
1418 			pending_count = 4;
1419 			if (debug)
1420 				printk(KERN_DEBUG "apm: setting state busy\n");
1421 			err = set_system_power_state(APM_STATE_BUSY);
1422 			if (err)
1423 				apm_error("busy", err);
1424 		}
1425 	} else
1426 		pending_count = 4;
1427 	check_events();
1428 }
1429 
1430 /*
1431  * This is the APM thread main loop.
1432  */
1433 
apm_mainloop(void)1434 static void apm_mainloop(void)
1435 {
1436 	DECLARE_WAITQUEUE(wait, current);
1437 
1438 	add_wait_queue(&apm_waitqueue, &wait);
1439 	set_current_state(TASK_INTERRUPTIBLE);
1440 	for (;;) {
1441 		schedule_timeout(APM_CHECK_TIMEOUT);
1442 		if (kthread_should_stop())
1443 			break;
1444 		/*
1445 		 * Ok, check all events, check for idle (and mark us sleeping
1446 		 * so as not to count towards the load average)..
1447 		 */
1448 		set_current_state(TASK_INTERRUPTIBLE);
1449 		apm_event_handler();
1450 	}
1451 	remove_wait_queue(&apm_waitqueue, &wait);
1452 }
1453 
check_apm_user(struct apm_user * as,const char * func)1454 static int check_apm_user(struct apm_user *as, const char *func)
1455 {
1456 	if (as == NULL || as->magic != APM_BIOS_MAGIC) {
1457 		pr_err("%s passed bad filp\n", func);
1458 		return 1;
1459 	}
1460 	return 0;
1461 }
1462 
do_read(struct file * fp,char __user * buf,size_t count,loff_t * ppos)1463 static ssize_t do_read(struct file *fp, char __user *buf, size_t count, loff_t *ppos)
1464 {
1465 	struct apm_user *as;
1466 	int i;
1467 	apm_event_t event;
1468 
1469 	as = fp->private_data;
1470 	if (check_apm_user(as, "read"))
1471 		return -EIO;
1472 	if ((int)count < sizeof(apm_event_t))
1473 		return -EINVAL;
1474 	if ((queue_empty(as)) && (fp->f_flags & O_NONBLOCK))
1475 		return -EAGAIN;
1476 	wait_event_interruptible(apm_waitqueue, !queue_empty(as));
1477 	i = count;
1478 	while ((i >= sizeof(event)) && !queue_empty(as)) {
1479 		event = get_queued_event(as);
1480 		if (copy_to_user(buf, &event, sizeof(event))) {
1481 			if (i < count)
1482 				break;
1483 			return -EFAULT;
1484 		}
1485 		switch (event) {
1486 		case APM_SYS_SUSPEND:
1487 		case APM_USER_SUSPEND:
1488 			as->suspends_read++;
1489 			break;
1490 
1491 		case APM_SYS_STANDBY:
1492 		case APM_USER_STANDBY:
1493 			as->standbys_read++;
1494 			break;
1495 		}
1496 		buf += sizeof(event);
1497 		i -= sizeof(event);
1498 	}
1499 	if (i < count)
1500 		return count - i;
1501 	if (signal_pending(current))
1502 		return -ERESTARTSYS;
1503 	return 0;
1504 }
1505 
do_poll(struct file * fp,poll_table * wait)1506 static unsigned int do_poll(struct file *fp, poll_table *wait)
1507 {
1508 	struct apm_user *as;
1509 
1510 	as = fp->private_data;
1511 	if (check_apm_user(as, "poll"))
1512 		return 0;
1513 	poll_wait(fp, &apm_waitqueue, wait);
1514 	if (!queue_empty(as))
1515 		return POLLIN | POLLRDNORM;
1516 	return 0;
1517 }
1518 
do_ioctl(struct file * filp,u_int cmd,u_long arg)1519 static long do_ioctl(struct file *filp, u_int cmd, u_long arg)
1520 {
1521 	struct apm_user *as;
1522 	int ret;
1523 
1524 	as = filp->private_data;
1525 	if (check_apm_user(as, "ioctl"))
1526 		return -EIO;
1527 	if (!as->suser || !as->writer)
1528 		return -EPERM;
1529 	switch (cmd) {
1530 	case APM_IOC_STANDBY:
1531 		mutex_lock(&apm_mutex);
1532 		if (as->standbys_read > 0) {
1533 			as->standbys_read--;
1534 			as->standbys_pending--;
1535 			standbys_pending--;
1536 		} else
1537 			queue_event(APM_USER_STANDBY, as);
1538 		if (standbys_pending <= 0)
1539 			standby();
1540 		mutex_unlock(&apm_mutex);
1541 		break;
1542 	case APM_IOC_SUSPEND:
1543 		mutex_lock(&apm_mutex);
1544 		if (as->suspends_read > 0) {
1545 			as->suspends_read--;
1546 			as->suspends_pending--;
1547 			suspends_pending--;
1548 		} else
1549 			queue_event(APM_USER_SUSPEND, as);
1550 		if (suspends_pending <= 0) {
1551 			ret = suspend(1);
1552 			mutex_unlock(&apm_mutex);
1553 		} else {
1554 			as->suspend_wait = 1;
1555 			mutex_unlock(&apm_mutex);
1556 			wait_event_interruptible(apm_suspend_waitqueue,
1557 					as->suspend_wait == 0);
1558 			ret = as->suspend_result;
1559 		}
1560 		return ret;
1561 	default:
1562 		return -ENOTTY;
1563 	}
1564 	return 0;
1565 }
1566 
do_release(struct inode * inode,struct file * filp)1567 static int do_release(struct inode *inode, struct file *filp)
1568 {
1569 	struct apm_user *as;
1570 
1571 	as = filp->private_data;
1572 	if (check_apm_user(as, "release"))
1573 		return 0;
1574 	filp->private_data = NULL;
1575 	if (as->standbys_pending > 0) {
1576 		standbys_pending -= as->standbys_pending;
1577 		if (standbys_pending <= 0)
1578 			standby();
1579 	}
1580 	if (as->suspends_pending > 0) {
1581 		suspends_pending -= as->suspends_pending;
1582 		if (suspends_pending <= 0)
1583 			(void) suspend(1);
1584 	}
1585 	spin_lock(&user_list_lock);
1586 	if (user_list == as)
1587 		user_list = as->next;
1588 	else {
1589 		struct apm_user *as1;
1590 
1591 		for (as1 = user_list;
1592 		     (as1 != NULL) && (as1->next != as);
1593 		     as1 = as1->next)
1594 			;
1595 		if (as1 == NULL)
1596 			pr_err("filp not in user list\n");
1597 		else
1598 			as1->next = as->next;
1599 	}
1600 	spin_unlock(&user_list_lock);
1601 	kfree(as);
1602 	return 0;
1603 }
1604 
do_open(struct inode * inode,struct file * filp)1605 static int do_open(struct inode *inode, struct file *filp)
1606 {
1607 	struct apm_user *as;
1608 
1609 	as = kmalloc(sizeof(*as), GFP_KERNEL);
1610 	if (as == NULL)
1611 		return -ENOMEM;
1612 
1613 	as->magic = APM_BIOS_MAGIC;
1614 	as->event_tail = as->event_head = 0;
1615 	as->suspends_pending = as->standbys_pending = 0;
1616 	as->suspends_read = as->standbys_read = 0;
1617 	/*
1618 	 * XXX - this is a tiny bit broken, when we consider BSD
1619 	 * process accounting. If the device is opened by root, we
1620 	 * instantly flag that we used superuser privs. Who knows,
1621 	 * we might close the device immediately without doing a
1622 	 * privileged operation -- cevans
1623 	 */
1624 	as->suser = capable(CAP_SYS_ADMIN);
1625 	as->writer = (filp->f_mode & FMODE_WRITE) == FMODE_WRITE;
1626 	as->reader = (filp->f_mode & FMODE_READ) == FMODE_READ;
1627 	spin_lock(&user_list_lock);
1628 	as->next = user_list;
1629 	user_list = as;
1630 	spin_unlock(&user_list_lock);
1631 	filp->private_data = as;
1632 	return 0;
1633 }
1634 
proc_apm_show(struct seq_file * m,void * v)1635 static int proc_apm_show(struct seq_file *m, void *v)
1636 {
1637 	unsigned short	bx;
1638 	unsigned short	cx;
1639 	unsigned short	dx;
1640 	int		error;
1641 	unsigned short  ac_line_status = 0xff;
1642 	unsigned short  battery_status = 0xff;
1643 	unsigned short  battery_flag   = 0xff;
1644 	int		percentage     = -1;
1645 	int             time_units     = -1;
1646 	char            *units         = "?";
1647 
1648 	if ((num_online_cpus() == 1) &&
1649 	    !(error = apm_get_power_status(&bx, &cx, &dx))) {
1650 		ac_line_status = (bx >> 8) & 0xff;
1651 		battery_status = bx & 0xff;
1652 		if ((cx & 0xff) != 0xff)
1653 			percentage = cx & 0xff;
1654 
1655 		if (apm_info.connection_version > 0x100) {
1656 			battery_flag = (cx >> 8) & 0xff;
1657 			if (dx != 0xffff) {
1658 				units = (dx & 0x8000) ? "min" : "sec";
1659 				time_units = dx & 0x7fff;
1660 			}
1661 		}
1662 	}
1663 	/* Arguments, with symbols from linux/apm_bios.h.  Information is
1664 	   from the Get Power Status (0x0a) call unless otherwise noted.
1665 
1666 	   0) Linux driver version (this will change if format changes)
1667 	   1) APM BIOS Version.  Usually 1.0, 1.1 or 1.2.
1668 	   2) APM flags from APM Installation Check (0x00):
1669 	      bit 0: APM_16_BIT_SUPPORT
1670 	      bit 1: APM_32_BIT_SUPPORT
1671 	      bit 2: APM_IDLE_SLOWS_CLOCK
1672 	      bit 3: APM_BIOS_DISABLED
1673 	      bit 4: APM_BIOS_DISENGAGED
1674 	   3) AC line status
1675 	      0x00: Off-line
1676 	      0x01: On-line
1677 	      0x02: On backup power (BIOS >= 1.1 only)
1678 	      0xff: Unknown
1679 	   4) Battery status
1680 	      0x00: High
1681 	      0x01: Low
1682 	      0x02: Critical
1683 	      0x03: Charging
1684 	      0x04: Selected battery not present (BIOS >= 1.2 only)
1685 	      0xff: Unknown
1686 	   5) Battery flag
1687 	      bit 0: High
1688 	      bit 1: Low
1689 	      bit 2: Critical
1690 	      bit 3: Charging
1691 	      bit 7: No system battery
1692 	      0xff: Unknown
1693 	   6) Remaining battery life (percentage of charge):
1694 	      0-100: valid
1695 	      -1: Unknown
1696 	   7) Remaining battery life (time units):
1697 	      Number of remaining minutes or seconds
1698 	      -1: Unknown
1699 	   8) min = minutes; sec = seconds */
1700 
1701 	seq_printf(m, "%s %d.%d 0x%02x 0x%02x 0x%02x 0x%02x %d%% %d %s\n",
1702 		   driver_version,
1703 		   (apm_info.bios.version >> 8) & 0xff,
1704 		   apm_info.bios.version & 0xff,
1705 		   apm_info.bios.flags,
1706 		   ac_line_status,
1707 		   battery_status,
1708 		   battery_flag,
1709 		   percentage,
1710 		   time_units,
1711 		   units);
1712 	return 0;
1713 }
1714 
proc_apm_open(struct inode * inode,struct file * file)1715 static int proc_apm_open(struct inode *inode, struct file *file)
1716 {
1717 	return single_open(file, proc_apm_show, NULL);
1718 }
1719 
1720 static const struct file_operations apm_file_ops = {
1721 	.owner		= THIS_MODULE,
1722 	.open		= proc_apm_open,
1723 	.read		= seq_read,
1724 	.llseek		= seq_lseek,
1725 	.release	= single_release,
1726 };
1727 
apm(void * unused)1728 static int apm(void *unused)
1729 {
1730 	unsigned short	bx;
1731 	unsigned short	cx;
1732 	unsigned short	dx;
1733 	int		error;
1734 	char 		*power_stat;
1735 	char 		*bat_stat;
1736 
1737 	/* 2002/08/01 - WT
1738 	 * This is to avoid random crashes at boot time during initialization
1739 	 * on SMP systems in case of "apm=power-off" mode. Seen on ASUS A7M266D.
1740 	 * Some bioses don't like being called from CPU != 0.
1741 	 * Method suggested by Ingo Molnar.
1742 	 */
1743 	set_cpus_allowed_ptr(current, cpumask_of(0));
1744 	BUG_ON(smp_processor_id() != 0);
1745 
1746 	if (apm_info.connection_version == 0) {
1747 		apm_info.connection_version = apm_info.bios.version;
1748 		if (apm_info.connection_version > 0x100) {
1749 			/*
1750 			 * We only support BIOSs up to version 1.2
1751 			 */
1752 			if (apm_info.connection_version > 0x0102)
1753 				apm_info.connection_version = 0x0102;
1754 			error = apm_driver_version(&apm_info.connection_version);
1755 			if (error != APM_SUCCESS) {
1756 				apm_error("driver version", error);
1757 				/* Fall back to an APM 1.0 connection. */
1758 				apm_info.connection_version = 0x100;
1759 			}
1760 		}
1761 	}
1762 
1763 	if (debug)
1764 		printk(KERN_INFO "apm: Connection version %d.%d\n",
1765 			(apm_info.connection_version >> 8) & 0xff,
1766 			apm_info.connection_version & 0xff);
1767 
1768 #ifdef CONFIG_APM_DO_ENABLE
1769 	if (apm_info.bios.flags & APM_BIOS_DISABLED) {
1770 		/*
1771 		 * This call causes my NEC UltraLite Versa 33/C to hang if it
1772 		 * is booted with PM disabled but not in the docking station.
1773 		 * Unfortunate ...
1774 		 */
1775 		error = apm_enable_power_management(1);
1776 		if (error) {
1777 			apm_error("enable power management", error);
1778 			return -1;
1779 		}
1780 	}
1781 #endif
1782 
1783 	if ((apm_info.bios.flags & APM_BIOS_DISENGAGED)
1784 	    && (apm_info.connection_version > 0x0100)) {
1785 		error = apm_engage_power_management(APM_DEVICE_ALL, 1);
1786 		if (error) {
1787 			apm_error("engage power management", error);
1788 			return -1;
1789 		}
1790 	}
1791 
1792 	if (debug && (num_online_cpus() == 1 || smp)) {
1793 		error = apm_get_power_status(&bx, &cx, &dx);
1794 		if (error)
1795 			printk(KERN_INFO "apm: power status not available\n");
1796 		else {
1797 			switch ((bx >> 8) & 0xff) {
1798 			case 0:
1799 				power_stat = "off line";
1800 				break;
1801 			case 1:
1802 				power_stat = "on line";
1803 				break;
1804 			case 2:
1805 				power_stat = "on backup power";
1806 				break;
1807 			default:
1808 				power_stat = "unknown";
1809 				break;
1810 			}
1811 			switch (bx & 0xff) {
1812 			case 0:
1813 				bat_stat = "high";
1814 				break;
1815 			case 1:
1816 				bat_stat = "low";
1817 				break;
1818 			case 2:
1819 				bat_stat = "critical";
1820 				break;
1821 			case 3:
1822 				bat_stat = "charging";
1823 				break;
1824 			default:
1825 				bat_stat = "unknown";
1826 				break;
1827 			}
1828 			printk(KERN_INFO
1829 			       "apm: AC %s, battery status %s, battery life ",
1830 			       power_stat, bat_stat);
1831 			if ((cx & 0xff) == 0xff)
1832 				printk("unknown\n");
1833 			else
1834 				printk("%d%%\n", cx & 0xff);
1835 			if (apm_info.connection_version > 0x100) {
1836 				printk(KERN_INFO
1837 				       "apm: battery flag 0x%02x, battery life ",
1838 				       (cx >> 8) & 0xff);
1839 				if (dx == 0xffff)
1840 					printk("unknown\n");
1841 				else
1842 					printk("%d %s\n", dx & 0x7fff,
1843 					       (dx & 0x8000) ?
1844 					       "minutes" : "seconds");
1845 			}
1846 		}
1847 	}
1848 
1849 	/* Install our power off handler.. */
1850 	if (power_off)
1851 		pm_power_off = apm_power_off;
1852 
1853 	if (num_online_cpus() == 1 || smp) {
1854 #if defined(CONFIG_APM_DISPLAY_BLANK) && defined(CONFIG_VT)
1855 		console_blank_hook = apm_console_blank;
1856 #endif
1857 		apm_mainloop();
1858 #if defined(CONFIG_APM_DISPLAY_BLANK) && defined(CONFIG_VT)
1859 		console_blank_hook = NULL;
1860 #endif
1861 	}
1862 
1863 	return 0;
1864 }
1865 
1866 #ifndef MODULE
apm_setup(char * str)1867 static int __init apm_setup(char *str)
1868 {
1869 	int invert;
1870 
1871 	while ((str != NULL) && (*str != '\0')) {
1872 		if (strncmp(str, "off", 3) == 0)
1873 			apm_disabled = 1;
1874 		if (strncmp(str, "on", 2) == 0)
1875 			apm_disabled = 0;
1876 		if ((strncmp(str, "bounce-interval=", 16) == 0) ||
1877 		    (strncmp(str, "bounce_interval=", 16) == 0))
1878 			bounce_interval = simple_strtol(str + 16, NULL, 0);
1879 		if ((strncmp(str, "idle-threshold=", 15) == 0) ||
1880 		    (strncmp(str, "idle_threshold=", 15) == 0))
1881 			idle_threshold = simple_strtol(str + 15, NULL, 0);
1882 		if ((strncmp(str, "idle-period=", 12) == 0) ||
1883 		    (strncmp(str, "idle_period=", 12) == 0))
1884 			idle_period = simple_strtol(str + 12, NULL, 0);
1885 		invert = (strncmp(str, "no-", 3) == 0) ||
1886 			(strncmp(str, "no_", 3) == 0);
1887 		if (invert)
1888 			str += 3;
1889 		if (strncmp(str, "debug", 5) == 0)
1890 			debug = !invert;
1891 		if ((strncmp(str, "power-off", 9) == 0) ||
1892 		    (strncmp(str, "power_off", 9) == 0))
1893 			power_off = !invert;
1894 		if (strncmp(str, "smp", 3) == 0) {
1895 			smp = !invert;
1896 			idle_threshold = 100;
1897 		}
1898 		if ((strncmp(str, "allow-ints", 10) == 0) ||
1899 		    (strncmp(str, "allow_ints", 10) == 0))
1900 			apm_info.allow_ints = !invert;
1901 		if ((strncmp(str, "broken-psr", 10) == 0) ||
1902 		    (strncmp(str, "broken_psr", 10) == 0))
1903 			apm_info.get_power_status_broken = !invert;
1904 		if ((strncmp(str, "realmode-power-off", 18) == 0) ||
1905 		    (strncmp(str, "realmode_power_off", 18) == 0))
1906 			apm_info.realmode_power_off = !invert;
1907 		str = strchr(str, ',');
1908 		if (str != NULL)
1909 			str += strspn(str, ", \t");
1910 	}
1911 	return 1;
1912 }
1913 
1914 __setup("apm=", apm_setup);
1915 #endif
1916 
1917 static const struct file_operations apm_bios_fops = {
1918 	.owner		= THIS_MODULE,
1919 	.read		= do_read,
1920 	.poll		= do_poll,
1921 	.unlocked_ioctl	= do_ioctl,
1922 	.open		= do_open,
1923 	.release	= do_release,
1924 	.llseek		= noop_llseek,
1925 };
1926 
1927 static struct miscdevice apm_device = {
1928 	APM_MINOR_DEV,
1929 	"apm_bios",
1930 	&apm_bios_fops
1931 };
1932 
1933 
1934 /* Simple "print if true" callback */
print_if_true(const struct dmi_system_id * d)1935 static int __init print_if_true(const struct dmi_system_id *d)
1936 {
1937 	printk("%s\n", d->ident);
1938 	return 0;
1939 }
1940 
1941 /*
1942  * Some Bioses enable the PS/2 mouse (touchpad) at resume, even if it was
1943  * disabled before the suspend. Linux used to get terribly confused by that.
1944  */
broken_ps2_resume(const struct dmi_system_id * d)1945 static int __init broken_ps2_resume(const struct dmi_system_id *d)
1946 {
1947 	printk(KERN_INFO "%s machine detected. Mousepad Resume Bug "
1948 	       "workaround hopefully not needed.\n", d->ident);
1949 	return 0;
1950 }
1951 
1952 /* Some bioses have a broken protected mode poweroff and need to use realmode */
set_realmode_power_off(const struct dmi_system_id * d)1953 static int __init set_realmode_power_off(const struct dmi_system_id *d)
1954 {
1955 	if (apm_info.realmode_power_off == 0) {
1956 		apm_info.realmode_power_off = 1;
1957 		printk(KERN_INFO "%s bios detected. "
1958 		       "Using realmode poweroff only.\n", d->ident);
1959 	}
1960 	return 0;
1961 }
1962 
1963 /* Some laptops require interrupts to be enabled during APM calls */
set_apm_ints(const struct dmi_system_id * d)1964 static int __init set_apm_ints(const struct dmi_system_id *d)
1965 {
1966 	if (apm_info.allow_ints == 0) {
1967 		apm_info.allow_ints = 1;
1968 		printk(KERN_INFO "%s machine detected. "
1969 		       "Enabling interrupts during APM calls.\n", d->ident);
1970 	}
1971 	return 0;
1972 }
1973 
1974 /* Some APM bioses corrupt memory or just plain do not work */
apm_is_horked(const struct dmi_system_id * d)1975 static int __init apm_is_horked(const struct dmi_system_id *d)
1976 {
1977 	if (apm_info.disabled == 0) {
1978 		apm_info.disabled = 1;
1979 		printk(KERN_INFO "%s machine detected. "
1980 		       "Disabling APM.\n", d->ident);
1981 	}
1982 	return 0;
1983 }
1984 
apm_is_horked_d850md(const struct dmi_system_id * d)1985 static int __init apm_is_horked_d850md(const struct dmi_system_id *d)
1986 {
1987 	if (apm_info.disabled == 0) {
1988 		apm_info.disabled = 1;
1989 		printk(KERN_INFO "%s machine detected. "
1990 		       "Disabling APM.\n", d->ident);
1991 		printk(KERN_INFO "This bug is fixed in bios P15 which is available for\n");
1992 		printk(KERN_INFO "download from support.intel.com\n");
1993 	}
1994 	return 0;
1995 }
1996 
1997 /* Some APM bioses hang on APM idle calls */
apm_likes_to_melt(const struct dmi_system_id * d)1998 static int __init apm_likes_to_melt(const struct dmi_system_id *d)
1999 {
2000 	if (apm_info.forbid_idle == 0) {
2001 		apm_info.forbid_idle = 1;
2002 		printk(KERN_INFO "%s machine detected. "
2003 		       "Disabling APM idle calls.\n", d->ident);
2004 	}
2005 	return 0;
2006 }
2007 
2008 /*
2009  *  Check for clue free BIOS implementations who use
2010  *  the following QA technique
2011  *
2012  *      [ Write BIOS Code ]<------
2013  *               |                ^
2014  *      < Does it Compile >----N--
2015  *               |Y               ^
2016  *	< Does it Boot Win98 >-N--
2017  *               |Y
2018  *           [Ship It]
2019  *
2020  *	Phoenix A04  08/24/2000 is known bad (Dell Inspiron 5000e)
2021  *	Phoenix A07  09/29/2000 is known good (Dell Inspiron 5000)
2022  */
broken_apm_power(const struct dmi_system_id * d)2023 static int __init broken_apm_power(const struct dmi_system_id *d)
2024 {
2025 	apm_info.get_power_status_broken = 1;
2026 	printk(KERN_WARNING "BIOS strings suggest APM bugs, "
2027 	       "disabling power status reporting.\n");
2028 	return 0;
2029 }
2030 
2031 /*
2032  * This bios swaps the APM minute reporting bytes over (Many sony laptops
2033  * have this problem).
2034  */
swab_apm_power_in_minutes(const struct dmi_system_id * d)2035 static int __init swab_apm_power_in_minutes(const struct dmi_system_id *d)
2036 {
2037 	apm_info.get_power_status_swabinminutes = 1;
2038 	printk(KERN_WARNING "BIOS strings suggest APM reports battery life "
2039 	       "in minutes and wrong byte order.\n");
2040 	return 0;
2041 }
2042 
2043 static struct dmi_system_id __initdata apm_dmi_table[] = {
2044 	{
2045 		print_if_true,
2046 		KERN_WARNING "IBM T23 - BIOS 1.03b+ and controller firmware 1.02+ may be needed for Linux APM.",
2047 		{	DMI_MATCH(DMI_SYS_VENDOR, "IBM"),
2048 			DMI_MATCH(DMI_BIOS_VERSION, "1AET38WW (1.01b)"), },
2049 	},
2050 	{	/* Handle problems with APM on the C600 */
2051 		broken_ps2_resume, "Dell Latitude C600",
2052 		{	DMI_MATCH(DMI_SYS_VENDOR, "Dell"),
2053 			DMI_MATCH(DMI_PRODUCT_NAME, "Latitude C600"), },
2054 	},
2055 	{	/* Allow interrupts during suspend on Dell Latitude laptops*/
2056 		set_apm_ints, "Dell Latitude",
2057 		{	DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
2058 			DMI_MATCH(DMI_PRODUCT_NAME, "Latitude C510"), }
2059 	},
2060 	{	/* APM crashes */
2061 		apm_is_horked, "Dell Inspiron 2500",
2062 		{	DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
2063 			DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 2500"),
2064 			DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2065 			DMI_MATCH(DMI_BIOS_VERSION, "A11"), },
2066 	},
2067 	{	/* Allow interrupts during suspend on Dell Inspiron laptops*/
2068 		set_apm_ints, "Dell Inspiron", {
2069 			DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
2070 			DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 4000"), },
2071 	},
2072 	{	/* Handle problems with APM on Inspiron 5000e */
2073 		broken_apm_power, "Dell Inspiron 5000e",
2074 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2075 			DMI_MATCH(DMI_BIOS_VERSION, "A04"),
2076 			DMI_MATCH(DMI_BIOS_DATE, "08/24/2000"), },
2077 	},
2078 	{	/* Handle problems with APM on Inspiron 2500 */
2079 		broken_apm_power, "Dell Inspiron 2500",
2080 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2081 			DMI_MATCH(DMI_BIOS_VERSION, "A12"),
2082 			DMI_MATCH(DMI_BIOS_DATE, "02/04/2002"), },
2083 	},
2084 	{	/* APM crashes */
2085 		apm_is_horked, "Dell Dimension 4100",
2086 		{	DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
2087 			DMI_MATCH(DMI_PRODUCT_NAME, "XPS-Z"),
2088 			DMI_MATCH(DMI_BIOS_VENDOR, "Intel Corp."),
2089 			DMI_MATCH(DMI_BIOS_VERSION, "A11"), },
2090 	},
2091 	{	/* Allow interrupts during suspend on Compaq Laptops*/
2092 		set_apm_ints, "Compaq 12XL125",
2093 		{	DMI_MATCH(DMI_SYS_VENDOR, "Compaq"),
2094 			DMI_MATCH(DMI_PRODUCT_NAME, "Compaq PC"),
2095 			DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2096 			DMI_MATCH(DMI_BIOS_VERSION, "4.06"), },
2097 	},
2098 	{	/* Allow interrupts during APM or the clock goes slow */
2099 		set_apm_ints, "ASUSTeK",
2100 		{	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
2101 			DMI_MATCH(DMI_PRODUCT_NAME, "L8400K series Notebook PC"), },
2102 	},
2103 	{	/* APM blows on shutdown */
2104 		apm_is_horked, "ABIT KX7-333[R]",
2105 		{	DMI_MATCH(DMI_BOARD_VENDOR, "ABIT"),
2106 			DMI_MATCH(DMI_BOARD_NAME, "VT8367-8233A (KX7-333[R])"), },
2107 	},
2108 	{	/* APM crashes */
2109 		apm_is_horked, "Trigem Delhi3",
2110 		{	DMI_MATCH(DMI_SYS_VENDOR, "TriGem Computer, Inc"),
2111 			DMI_MATCH(DMI_PRODUCT_NAME, "Delhi3"), },
2112 	},
2113 	{	/* APM crashes */
2114 		apm_is_horked, "Fujitsu-Siemens",
2115 		{	DMI_MATCH(DMI_BIOS_VENDOR, "hoenix/FUJITSU SIEMENS"),
2116 			DMI_MATCH(DMI_BIOS_VERSION, "Version1.01"), },
2117 	},
2118 	{	/* APM crashes */
2119 		apm_is_horked_d850md, "Intel D850MD",
2120 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Intel Corp."),
2121 			DMI_MATCH(DMI_BIOS_VERSION, "MV85010A.86A.0016.P07.0201251536"), },
2122 	},
2123 	{	/* APM crashes */
2124 		apm_is_horked, "Intel D810EMO",
2125 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Intel Corp."),
2126 			DMI_MATCH(DMI_BIOS_VERSION, "MO81010A.86A.0008.P04.0004170800"), },
2127 	},
2128 	{	/* APM crashes */
2129 		apm_is_horked, "Dell XPS-Z",
2130 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Intel Corp."),
2131 			DMI_MATCH(DMI_BIOS_VERSION, "A11"),
2132 			DMI_MATCH(DMI_PRODUCT_NAME, "XPS-Z"), },
2133 	},
2134 	{	/* APM crashes */
2135 		apm_is_horked, "Sharp PC-PJ/AX",
2136 		{	DMI_MATCH(DMI_SYS_VENDOR, "SHARP"),
2137 			DMI_MATCH(DMI_PRODUCT_NAME, "PC-PJ/AX"),
2138 			DMI_MATCH(DMI_BIOS_VENDOR, "SystemSoft"),
2139 			DMI_MATCH(DMI_BIOS_VERSION, "Version R2.08"), },
2140 	},
2141 	{	/* APM crashes */
2142 		apm_is_horked, "Dell Inspiron 2500",
2143 		{	DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"),
2144 			DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 2500"),
2145 			DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2146 			DMI_MATCH(DMI_BIOS_VERSION, "A11"), },
2147 	},
2148 	{	/* APM idle hangs */
2149 		apm_likes_to_melt, "Jabil AMD",
2150 		{	DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
2151 			DMI_MATCH(DMI_BIOS_VERSION, "0AASNP06"), },
2152 	},
2153 	{	/* APM idle hangs */
2154 		apm_likes_to_melt, "AMI Bios",
2155 		{	DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
2156 			DMI_MATCH(DMI_BIOS_VERSION, "0AASNP05"), },
2157 	},
2158 	{	/* Handle problems with APM on Sony Vaio PCG-N505X(DE) */
2159 		swab_apm_power_in_minutes, "Sony VAIO",
2160 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2161 			DMI_MATCH(DMI_BIOS_VERSION, "R0206H"),
2162 			DMI_MATCH(DMI_BIOS_DATE, "08/23/99"), },
2163 	},
2164 	{	/* Handle problems with APM on Sony Vaio PCG-N505VX */
2165 		swab_apm_power_in_minutes, "Sony VAIO",
2166 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2167 			DMI_MATCH(DMI_BIOS_VERSION, "W2K06H0"),
2168 			DMI_MATCH(DMI_BIOS_DATE, "02/03/00"), },
2169 	},
2170 	{	/* Handle problems with APM on Sony Vaio PCG-XG29 */
2171 		swab_apm_power_in_minutes, "Sony VAIO",
2172 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2173 			DMI_MATCH(DMI_BIOS_VERSION, "R0117A0"),
2174 			DMI_MATCH(DMI_BIOS_DATE, "04/25/00"), },
2175 	},
2176 	{	/* Handle problems with APM on Sony Vaio PCG-Z600NE */
2177 		swab_apm_power_in_minutes, "Sony VAIO",
2178 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2179 			DMI_MATCH(DMI_BIOS_VERSION, "R0121Z1"),
2180 			DMI_MATCH(DMI_BIOS_DATE, "05/11/00"), },
2181 	},
2182 	{	/* Handle problems with APM on Sony Vaio PCG-Z600NE */
2183 		swab_apm_power_in_minutes, "Sony VAIO",
2184 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2185 			DMI_MATCH(DMI_BIOS_VERSION, "WME01Z1"),
2186 			DMI_MATCH(DMI_BIOS_DATE, "08/11/00"), },
2187 	},
2188 	{	/* Handle problems with APM on Sony Vaio PCG-Z600LEK(DE) */
2189 		swab_apm_power_in_minutes, "Sony VAIO",
2190 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2191 			DMI_MATCH(DMI_BIOS_VERSION, "R0206Z3"),
2192 			DMI_MATCH(DMI_BIOS_DATE, "12/25/00"), },
2193 	},
2194 	{	/* Handle problems with APM on Sony Vaio PCG-Z505LS */
2195 		swab_apm_power_in_minutes, "Sony VAIO",
2196 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2197 			DMI_MATCH(DMI_BIOS_VERSION, "R0203D0"),
2198 			DMI_MATCH(DMI_BIOS_DATE, "05/12/00"), },
2199 	},
2200 	{	/* Handle problems with APM on Sony Vaio PCG-Z505LS */
2201 		swab_apm_power_in_minutes, "Sony VAIO",
2202 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2203 			DMI_MATCH(DMI_BIOS_VERSION, "R0203Z3"),
2204 			DMI_MATCH(DMI_BIOS_DATE, "08/25/00"), },
2205 	},
2206 	{	/* Handle problems with APM on Sony Vaio PCG-Z505LS (with updated BIOS) */
2207 		swab_apm_power_in_minutes, "Sony VAIO",
2208 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2209 			DMI_MATCH(DMI_BIOS_VERSION, "R0209Z3"),
2210 			DMI_MATCH(DMI_BIOS_DATE, "05/12/01"), },
2211 	},
2212 	{	/* Handle problems with APM on Sony Vaio PCG-F104K */
2213 		swab_apm_power_in_minutes, "Sony VAIO",
2214 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2215 			DMI_MATCH(DMI_BIOS_VERSION, "R0204K2"),
2216 			DMI_MATCH(DMI_BIOS_DATE, "08/28/00"), },
2217 	},
2218 
2219 	{	/* Handle problems with APM on Sony Vaio PCG-C1VN/C1VE */
2220 		swab_apm_power_in_minutes, "Sony VAIO",
2221 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2222 			DMI_MATCH(DMI_BIOS_VERSION, "R0208P1"),
2223 			DMI_MATCH(DMI_BIOS_DATE, "11/09/00"), },
2224 	},
2225 	{	/* Handle problems with APM on Sony Vaio PCG-C1VE */
2226 		swab_apm_power_in_minutes, "Sony VAIO",
2227 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2228 			DMI_MATCH(DMI_BIOS_VERSION, "R0204P1"),
2229 			DMI_MATCH(DMI_BIOS_DATE, "09/12/00"), },
2230 	},
2231 	{	/* Handle problems with APM on Sony Vaio PCG-C1VE */
2232 		swab_apm_power_in_minutes, "Sony VAIO",
2233 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies LTD"),
2234 			DMI_MATCH(DMI_BIOS_VERSION, "WXPO1Z3"),
2235 			DMI_MATCH(DMI_BIOS_DATE, "10/26/01"), },
2236 	},
2237 	{	/* broken PM poweroff bios */
2238 		set_realmode_power_off, "Award Software v4.60 PGMA",
2239 		{	DMI_MATCH(DMI_BIOS_VENDOR, "Award Software International, Inc."),
2240 			DMI_MATCH(DMI_BIOS_VERSION, "4.60 PGMA"),
2241 			DMI_MATCH(DMI_BIOS_DATE, "134526184"), },
2242 	},
2243 
2244 	/* Generic per vendor APM settings  */
2245 
2246 	{	/* Allow interrupts during suspend on IBM laptops */
2247 		set_apm_ints, "IBM",
2248 		{	DMI_MATCH(DMI_SYS_VENDOR, "IBM"), },
2249 	},
2250 
2251 	{ }
2252 };
2253 
2254 /*
2255  * Just start the APM thread. We do NOT want to do APM BIOS
2256  * calls from anything but the APM thread, if for no other reason
2257  * than the fact that we don't trust the APM BIOS. This way,
2258  * most common APM BIOS problems that lead to protection errors
2259  * etc will have at least some level of being contained...
2260  *
2261  * In short, if something bad happens, at least we have a choice
2262  * of just killing the apm thread..
2263  */
apm_init(void)2264 static int __init apm_init(void)
2265 {
2266 	struct desc_struct *gdt;
2267 	int err;
2268 
2269 	dmi_check_system(apm_dmi_table);
2270 
2271 	if (apm_info.bios.version == 0 || paravirt_enabled() || machine_is_olpc()) {
2272 		printk(KERN_INFO "apm: BIOS not found.\n");
2273 		return -ENODEV;
2274 	}
2275 	printk(KERN_INFO
2276 	       "apm: BIOS version %d.%d Flags 0x%02x (Driver version %s)\n",
2277 	       ((apm_info.bios.version >> 8) & 0xff),
2278 	       (apm_info.bios.version & 0xff),
2279 	       apm_info.bios.flags,
2280 	       driver_version);
2281 	if ((apm_info.bios.flags & APM_32_BIT_SUPPORT) == 0) {
2282 		printk(KERN_INFO "apm: no 32 bit BIOS support\n");
2283 		return -ENODEV;
2284 	}
2285 
2286 	if (allow_ints)
2287 		apm_info.allow_ints = 1;
2288 	if (broken_psr)
2289 		apm_info.get_power_status_broken = 1;
2290 	if (realmode_power_off)
2291 		apm_info.realmode_power_off = 1;
2292 	/* User can override, but default is to trust DMI */
2293 	if (apm_disabled != -1)
2294 		apm_info.disabled = apm_disabled;
2295 
2296 	/*
2297 	 * Fix for the Compaq Contura 3/25c which reports BIOS version 0.1
2298 	 * but is reportedly a 1.0 BIOS.
2299 	 */
2300 	if (apm_info.bios.version == 0x001)
2301 		apm_info.bios.version = 0x100;
2302 
2303 	/* BIOS < 1.2 doesn't set cseg_16_len */
2304 	if (apm_info.bios.version < 0x102)
2305 		apm_info.bios.cseg_16_len = 0; /* 64k */
2306 
2307 	if (debug) {
2308 		printk(KERN_INFO "apm: entry %x:%x cseg16 %x dseg %x",
2309 			apm_info.bios.cseg, apm_info.bios.offset,
2310 			apm_info.bios.cseg_16, apm_info.bios.dseg);
2311 		if (apm_info.bios.version > 0x100)
2312 			printk(" cseg len %x, dseg len %x",
2313 				apm_info.bios.cseg_len,
2314 				apm_info.bios.dseg_len);
2315 		if (apm_info.bios.version > 0x101)
2316 			printk(" cseg16 len %x", apm_info.bios.cseg_16_len);
2317 		printk("\n");
2318 	}
2319 
2320 	if (apm_info.disabled) {
2321 		pr_notice("disabled on user request.\n");
2322 		return -ENODEV;
2323 	}
2324 	if ((num_online_cpus() > 1) && !power_off && !smp) {
2325 		pr_notice("disabled - APM is not SMP safe.\n");
2326 		apm_info.disabled = 1;
2327 		return -ENODEV;
2328 	}
2329 	if (!acpi_disabled) {
2330 		pr_notice("overridden by ACPI.\n");
2331 		apm_info.disabled = 1;
2332 		return -ENODEV;
2333 	}
2334 
2335 	/*
2336 	 * Set up the long jump entry point to the APM BIOS, which is called
2337 	 * from inline assembly.
2338 	 */
2339 	apm_bios_entry.offset = apm_info.bios.offset;
2340 	apm_bios_entry.segment = APM_CS;
2341 
2342 	/*
2343 	 * The APM 1.1 BIOS is supposed to provide limit information that it
2344 	 * recognizes.  Many machines do this correctly, but many others do
2345 	 * not restrict themselves to their claimed limit.  When this happens,
2346 	 * they will cause a segmentation violation in the kernel at boot time.
2347 	 * Most BIOS's, however, will respect a 64k limit, so we use that.
2348 	 *
2349 	 * Note we only set APM segments on CPU zero, since we pin the APM
2350 	 * code to that CPU.
2351 	 */
2352 	gdt = get_cpu_gdt_table(0);
2353 	set_desc_base(&gdt[APM_CS >> 3],
2354 		 (unsigned long)__va((unsigned long)apm_info.bios.cseg << 4));
2355 	set_desc_base(&gdt[APM_CS_16 >> 3],
2356 		 (unsigned long)__va((unsigned long)apm_info.bios.cseg_16 << 4));
2357 	set_desc_base(&gdt[APM_DS >> 3],
2358 		 (unsigned long)__va((unsigned long)apm_info.bios.dseg << 4));
2359 
2360 	proc_create("apm", 0, NULL, &apm_file_ops);
2361 
2362 	kapmd_task = kthread_create(apm, NULL, "kapmd");
2363 	if (IS_ERR(kapmd_task)) {
2364 		pr_err("disabled - Unable to start kernel thread\n");
2365 		err = PTR_ERR(kapmd_task);
2366 		kapmd_task = NULL;
2367 		remove_proc_entry("apm", NULL);
2368 		return err;
2369 	}
2370 	wake_up_process(kapmd_task);
2371 
2372 	if (num_online_cpus() > 1 && !smp) {
2373 		printk(KERN_NOTICE
2374 		       "apm: disabled - APM is not SMP safe (power off active).\n");
2375 		return 0;
2376 	}
2377 
2378 	/*
2379 	 * Note we don't actually care if the misc_device cannot be registered.
2380 	 * this driver can do its job without it, even if userspace can't
2381 	 * control it.  just log the error
2382 	 */
2383 	if (misc_register(&apm_device))
2384 		printk(KERN_WARNING "apm: Could not register misc device.\n");
2385 
2386 	if (HZ != 100)
2387 		idle_period = (idle_period * HZ) / 100;
2388 	if (idle_threshold < 100) {
2389 		if (!cpuidle_register_driver(&apm_idle_driver))
2390 			if (cpuidle_register_device(&apm_cpuidle_device))
2391 				cpuidle_unregister_driver(&apm_idle_driver);
2392 	}
2393 
2394 	return 0;
2395 }
2396 
apm_exit(void)2397 static void __exit apm_exit(void)
2398 {
2399 	int error;
2400 
2401 	cpuidle_unregister_device(&apm_cpuidle_device);
2402 	cpuidle_unregister_driver(&apm_idle_driver);
2403 
2404 	if (((apm_info.bios.flags & APM_BIOS_DISENGAGED) == 0)
2405 	    && (apm_info.connection_version > 0x0100)) {
2406 		error = apm_engage_power_management(APM_DEVICE_ALL, 0);
2407 		if (error)
2408 			apm_error("disengage power management", error);
2409 	}
2410 	misc_deregister(&apm_device);
2411 	remove_proc_entry("apm", NULL);
2412 	if (power_off)
2413 		pm_power_off = NULL;
2414 	if (kapmd_task) {
2415 		kthread_stop(kapmd_task);
2416 		kapmd_task = NULL;
2417 	}
2418 }
2419 
2420 module_init(apm_init);
2421 module_exit(apm_exit);
2422 
2423 MODULE_AUTHOR("Stephen Rothwell");
2424 MODULE_DESCRIPTION("Advanced Power Management");
2425 MODULE_LICENSE("GPL");
2426 module_param(debug, bool, 0644);
2427 MODULE_PARM_DESC(debug, "Enable debug mode");
2428 module_param(power_off, bool, 0444);
2429 MODULE_PARM_DESC(power_off, "Enable power off");
2430 module_param(bounce_interval, int, 0444);
2431 MODULE_PARM_DESC(bounce_interval,
2432 		"Set the number of ticks to ignore suspend bounces");
2433 module_param(allow_ints, bool, 0444);
2434 MODULE_PARM_DESC(allow_ints, "Allow interrupts during BIOS calls");
2435 module_param(broken_psr, bool, 0444);
2436 MODULE_PARM_DESC(broken_psr, "BIOS has a broken GetPowerStatus call");
2437 module_param(realmode_power_off, bool, 0444);
2438 MODULE_PARM_DESC(realmode_power_off,
2439 		"Switch to real mode before powering off");
2440 module_param(idle_threshold, int, 0444);
2441 MODULE_PARM_DESC(idle_threshold,
2442 	"System idle percentage above which to make APM BIOS idle calls");
2443 module_param(idle_period, int, 0444);
2444 MODULE_PARM_DESC(idle_period,
2445 	"Period (in sec/100) over which to caculate the idle percentage");
2446 module_param(smp, bool, 0444);
2447 MODULE_PARM_DESC(smp,
2448 	"Set this to enable APM use on an SMP platform. Use with caution on older systems");
2449 MODULE_ALIAS_MISCDEV(APM_MINOR_DEV);
2450