~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/i386/kernel/apm.c

Version: ~ [ linux-5.0-rc6 ] ~ [ linux-4.20.7 ] ~ [ linux-4.19.20 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.98 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.155 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.174 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.134 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.62 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 replacment 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 complier/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@suse.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@redhat.com>).
164  *   1.14ac: If the BIOS says "I slowed the CPU down" then don't spin
165  *         calling it - instead idle. (Alan Cox <alan@redhat.com>)
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 <jdthood@mail.com>)
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 <jdthood@mail.com>)
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 via anonymous ftp from
193  * ftp://ftp.intel.com/pub/IAL/software_specs/apmv11.doc.  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/hwdev/busbios/amp_12.htm]
202  */
203 
204 #include <linux/config.h>
205 #include <linux/module.h>
206 
207 #include <linux/poll.h>
208 #include <linux/types.h>
209 #include <linux/stddef.h>
210 #include <linux/timer.h>
211 #include <linux/fcntl.h>
212 #include <linux/slab.h>
213 #include <linux/stat.h>
214 #include <linux/proc_fs.h>
215 #include <linux/miscdevice.h>
216 #include <linux/apm_bios.h>
217 #include <linux/init.h>
218 #include <linux/time.h>
219 #include <linux/sched.h>
220 #include <linux/pm.h>
221 #include <linux/device.h>
222 #include <linux/kernel.h>
223 #include <linux/smp.h>
224 #include <linux/smp_lock.h>
225 
226 #include <asm/system.h>
227 #include <asm/uaccess.h>
228 #include <asm/desc.h>
229 #include <asm/suspend.h>
230 
231 #include "io_ports.h"
232 
233 extern spinlock_t i8253_lock;
234 extern unsigned long get_cmos_time(void);
235 extern void machine_real_restart(unsigned char *, int);
236 
237 #if defined(CONFIG_APM_DISPLAY_BLANK) && defined(CONFIG_VT)
238 extern int (*console_blank_hook)(int);
239 #endif
240 
241 /*
242  * The apm_bios device is one of the misc char devices.
243  * This is its minor number.
244  */
245 #define APM_MINOR_DEV   134
246 
247 /*
248  * See Documentation/Config.help for the configuration options.
249  *
250  * Various options can be changed at boot time as follows:
251  * (We allow underscores for compatibility with the modules code)
252  *      apm=on/off                      enable/disable APM
253  *          [no-]allow[-_]ints          allow interrupts during BIOS calls
254  *          [no-]broken[-_]psr          BIOS has a broken GetPowerStatus call
255  *          [no-]realmode[-_]power[-_]off       switch to real mode before
256  *                                              powering off
257  *          [no-]debug                  log some debugging messages
258  *          [no-]power[-_]off           power off on shutdown
259  *          [no-]smp                    Use apm even on an SMP box
260  *          bounce[-_]interval=<n>      number of ticks to ignore suspend
261  *                                      bounces
262  *          idle[-_]threshold=<n>       System idle percentage above which to
263  *                                      make APM BIOS idle calls. Set it to
264  *                                      100 to disable.
265  *          idle[-_]period=<n>          Period (in 1/100s of a second) over
266  *                                      which the idle percentage is
267  *                                      calculated.
268  */
269 
270 /* KNOWN PROBLEM MACHINES:
271  *
272  * U: TI 4000M TravelMate: BIOS is *NOT* APM compliant
273  *                         [Confirmed by TI representative]
274  * ?: ACER 486DX4/75: uses dseg 0040, in violation of APM specification
275  *                    [Confirmed by BIOS disassembly]
276  *                    [This may work now ...]
277  * P: Toshiba 1950S: battery life information only gets updated after resume
278  * P: Midwest Micro Soundbook Elite DX2/66 monochrome: screen blanking
279  *      broken in BIOS [Reported by Garst R. Reese <reese@isn.net>]
280  * ?: AcerNote-950: oops on reading /proc/apm - workaround is a WIP
281  *      Neale Banks <neale@lowendale.com.au> December 2000
282  *
283  * Legend: U = unusable with APM patches
284  *         P = partially usable with APM patches
285  */
286 
287 /*
288  * Define as 1 to make the driver always call the APM BIOS busy
289  * routine even if the clock was not reported as slowed by the
290  * idle routine.  Otherwise, define as 0.
291  */
292 #define ALWAYS_CALL_BUSY   1
293 
294 /*
295  * Define to make the APM BIOS calls zero all data segment registers (so
296  * that an incorrect BIOS implementation will cause a kernel panic if it
297  * tries to write to arbitrary memory).
298  */
299 #define APM_ZERO_SEGS
300 
301 #include "apm.h"
302 
303 /*
304  * Define to make all _set_limit calls use 64k limits.  The APM 1.1 BIOS is
305  * supposed to provide limit information that it recognizes.  Many machines
306  * do this correctly, but many others do not restrict themselves to their
307  * claimed limit.  When this happens, they will cause a segmentation
308  * violation in the kernel at boot time.  Most BIOS's, however, will
309  * respect a 64k limit, so we use that.  If you want to be pedantic and
310  * hold your BIOS to its claims, then undefine this.
311  */
312 #define APM_RELAX_SEGMENTS
313 
314 /*
315  * Define to re-initialize the interrupt 0 timer to 100 Hz after a suspend.
316  * This patched by Chad Miller <cmiller@surfsouth.com>, original code by
317  * David Chen <chen@ctpa04.mit.edu>
318  */
319 #undef INIT_TIMER_AFTER_SUSPEND
320 
321 #ifdef INIT_TIMER_AFTER_SUSPEND
322 #include <linux/timex.h>
323 #include <asm/io.h>
324 #include <linux/delay.h>
325 #endif
326 
327 /*
328  * Need to poll the APM BIOS every second
329  */
330 #define APM_CHECK_TIMEOUT       (HZ)
331 
332 /*
333  * Ignore suspend events for this amount of time after a resume
334  */
335 #define DEFAULT_BOUNCE_INTERVAL         (3 * HZ)
336 
337 /*
338  * Maximum number of events stored
339  */
340 #define APM_MAX_EVENTS          20
341 
342 /*
343  * The per-file APM data
344  */
345 struct apm_user {
346         int             magic;
347         struct apm_user *       next;
348         int             suser: 1;
349         int             writer: 1;
350         int             reader: 1;
351         int             suspend_wait: 1;
352         int             suspend_result;
353         int             suspends_pending;
354         int             standbys_pending;
355         int             suspends_read;
356         int             standbys_read;
357         int             event_head;
358         int             event_tail;
359         apm_event_t     events[APM_MAX_EVENTS];
360 };
361 
362 /*
363  * The magic number in apm_user
364  */
365 #define APM_BIOS_MAGIC          0x4101
366 
367 /*
368  * idle percentage above which bios idle calls are done
369  */
370 #ifdef CONFIG_APM_CPU_IDLE
371 #define DEFAULT_IDLE_THRESHOLD  95
372 #else
373 #define DEFAULT_IDLE_THRESHOLD  100
374 #endif
375 #define DEFAULT_IDLE_PERIOD     (100 / 3)
376 
377 /*
378  * Local variables
379  */
380 static struct {
381         unsigned long   offset;
382         unsigned short  segment;
383 }                               apm_bios_entry;
384 static int                      clock_slowed;
385 static int                      idle_threshold = DEFAULT_IDLE_THRESHOLD;
386 static int                      idle_period = DEFAULT_IDLE_PERIOD;
387 static int                      set_pm_idle;
388 static int                      suspends_pending;
389 static int                      standbys_pending;
390 static int                      ignore_sys_suspend;
391 static int                      ignore_normal_resume;
392 static int                      bounce_interval = DEFAULT_BOUNCE_INTERVAL;
393 
394 #ifdef CONFIG_APM_RTC_IS_GMT
395 #       define  clock_cmos_diff 0
396 #       define  got_clock_diff  1
397 #else
398 static long                     clock_cmos_diff;
399 static int                      got_clock_diff;
400 #endif
401 static int                      debug;
402 static int                      smp;
403 static int                      apm_disabled = -1;
404 #ifdef CONFIG_SMP
405 static int                      power_off;
406 #else
407 static int                      power_off = 1;
408 #endif
409 #ifdef CONFIG_APM_REAL_MODE_POWER_OFF
410 static int                      realmode_power_off = 1;
411 #else
412 static int                      realmode_power_off;
413 #endif
414 static int                      exit_kapmd;
415 static int                      kapmd_running;
416 #ifdef CONFIG_APM_ALLOW_INTS
417 static int                      allow_ints = 1;
418 #else
419 static int                      allow_ints;
420 #endif
421 static int                      broken_psr;
422 
423 static DECLARE_WAIT_QUEUE_HEAD(apm_waitqueue);
424 static DECLARE_WAIT_QUEUE_HEAD(apm_suspend_waitqueue);
425 static struct apm_user *        user_list;
426 static spinlock_t               user_list_lock = SPIN_LOCK_UNLOCKED;
427 static struct desc_struct       bad_bios_desc = { 0, 0x00409200 };
428 
429 static char                     driver_version[] = "1.16ac";    /* no spaces */
430 
431 /*
432  *      APM event names taken from the APM 1.2 specification. These are
433  *      the message codes that the BIOS uses to tell us about events
434  */
435 static char *   apm_event_name[] = {
436         "system standby",
437         "system suspend",
438         "normal resume",
439         "critical resume",
440         "low battery",
441         "power status change",
442         "update time",
443         "critical suspend",
444         "user standby",
445         "user suspend",
446         "system standby resume",
447         "capabilities change"
448 };
449 #define NR_APM_EVENT_NAME       \
450                 (sizeof(apm_event_name) / sizeof(apm_event_name[0]))
451 
452 typedef struct lookup_t {
453         int     key;
454         char *  msg;
455 } lookup_t;
456 
457 /*
458  *      The BIOS returns a set of standard error codes in AX when the
459  *      carry flag is set.
460  */
461  
462 static const lookup_t error_table[] = {
463 /* N/A  { APM_SUCCESS,          "Operation succeeded" }, */
464         { APM_DISABLED,         "Power management disabled" },
465         { APM_CONNECTED,        "Real mode interface already connected" },
466         { APM_NOT_CONNECTED,    "Interface not connected" },
467         { APM_16_CONNECTED,     "16 bit interface already connected" },
468 /* N/A  { APM_16_UNSUPPORTED,   "16 bit interface not supported" }, */
469         { APM_32_CONNECTED,     "32 bit interface already connected" },
470         { APM_32_UNSUPPORTED,   "32 bit interface not supported" },
471         { APM_BAD_DEVICE,       "Unrecognized device ID" },
472         { APM_BAD_PARAM,        "Parameter out of range" },
473         { APM_NOT_ENGAGED,      "Interface not engaged" },
474         { APM_BAD_FUNCTION,     "Function not supported" },
475         { APM_RESUME_DISABLED,  "Resume timer disabled" },
476         { APM_BAD_STATE,        "Unable to enter requested state" },
477 /* N/A  { APM_NO_EVENTS,        "No events pending" }, */
478         { APM_NO_ERROR,         "BIOS did not set a return code" },
479         { APM_NOT_PRESENT,      "No APM present" }
480 };
481 #define ERROR_COUNT     (sizeof(error_table)/sizeof(lookup_t))
482 
483 /**
484  *      apm_error       -       display an APM error
485  *      @str: information string
486  *      @err: APM BIOS return code
487  *
488  *      Write a meaningful log entry to the kernel log in the event of
489  *      an APM error.
490  */
491  
492 static void apm_error(char *str, int err)
493 {
494         int     i;
495 
496         for (i = 0; i < ERROR_COUNT; i++)
497                 if (error_table[i].key == err) break;
498         if (i < ERROR_COUNT)
499                 printk(KERN_NOTICE "apm: %s: %s\n", str, error_table[i].msg);
500         else
501                 printk(KERN_NOTICE "apm: %s: unknown error code %#2.2x\n",
502                         str, err);
503 }
504 
505 /*
506  * Lock APM functionality to physical CPU 0
507  */
508  
509 #ifdef CONFIG_SMP
510 
511 static cpumask_t apm_save_cpus(void)
512 {
513         cpumask_t x = current->cpus_allowed;
514         /* Some bioses don't like being called from CPU != 0 */
515         set_cpus_allowed(current, cpumask_of_cpu(0));
516         BUG_ON(smp_processor_id() != 0);
517         return x;
518 }
519 
520 static inline void apm_restore_cpus(cpumask_t mask)
521 {
522         set_cpus_allowed(current, mask);
523 }
524 
525 #else
526 
527 /*
528  *      No CPU lockdown needed on a uniprocessor
529  */
530  
531 #define apm_save_cpus()         (current->cpus_allowed)
532 #define apm_restore_cpus(x)     (void)(x)
533 
534 #endif
535 
536 /*
537  * These are the actual BIOS calls.  Depending on APM_ZERO_SEGS and
538  * apm_info.allow_ints, we are being really paranoid here!  Not only
539  * are interrupts disabled, but all the segment registers (except SS)
540  * are saved and zeroed this means that if the BIOS tries to reference
541  * any data without explicitly loading the segment registers, the kernel
542  * will fault immediately rather than have some unforeseen circumstances
543  * for the rest of the kernel.  And it will be very obvious!  :-) Doing
544  * this depends on CS referring to the same physical memory as DS so that
545  * DS can be zeroed before the call. Unfortunately, we can't do anything
546  * about the stack segment/pointer.  Also, we tell the compiler that
547  * everything could change.
548  *
549  * Also, we KNOW that for the non error case of apm_bios_call, there
550  * is no useful data returned in the low order 8 bits of eax.
551  */
552 #define APM_DO_CLI      \
553         if (apm_info.allow_ints) \
554                 local_irq_enable(); \
555         else \
556                 local_irq_disable();
557 
558 #ifdef APM_ZERO_SEGS
559 #       define APM_DECL_SEGS \
560                 unsigned int saved_fs; unsigned int saved_gs;
561 #       define APM_DO_SAVE_SEGS \
562                 savesegment(fs, saved_fs); savesegment(gs, saved_gs)
563 #       define APM_DO_RESTORE_SEGS \
564                 loadsegment(fs, saved_fs); loadsegment(gs, saved_gs)
565 #else
566 #       define APM_DECL_SEGS
567 #       define APM_DO_SAVE_SEGS
568 #       define APM_DO_RESTORE_SEGS
569 #endif
570 
571 /**
572  *      apm_bios_call   -       Make an APM BIOS 32bit call
573  *      @func: APM function to execute
574  *      @ebx_in: EBX register for call entry
575  *      @ecx_in: ECX register for call entry
576  *      @eax: EAX register return
577  *      @ebx: EBX register return
578  *      @ecx: ECX register return
579  *      @edx: EDX register return
580  *      @esi: ESI register return
581  *
582  *      Make an APM call using the 32bit protected mode interface. The
583  *      caller is responsible for knowing if APM BIOS is configured and
584  *      enabled. This call can disable interrupts for a long period of
585  *      time on some laptops.  The return value is in AH and the carry
586  *      flag is loaded into AL.  If there is an error, then the error
587  *      code is returned in AH (bits 8-15 of eax) and this function
588  *      returns non-zero.
589  */
590  
591 static u8 apm_bios_call(u32 func, u32 ebx_in, u32 ecx_in,
592         u32 *eax, u32 *ebx, u32 *ecx, u32 *edx, u32 *esi)
593 {
594         APM_DECL_SEGS
595         unsigned long           flags;
596         cpumask_t               cpus;
597         int                     cpu;
598         struct desc_struct      save_desc_40;
599 
600         cpus = apm_save_cpus();
601         
602         cpu = get_cpu();
603         save_desc_40 = cpu_gdt_table[cpu][0x40 / 8];
604         cpu_gdt_table[cpu][0x40 / 8] = bad_bios_desc;
605 
606         local_save_flags(flags);
607         APM_DO_CLI;
608         APM_DO_SAVE_SEGS;
609         apm_bios_call_asm(func, ebx_in, ecx_in, eax, ebx, ecx, edx, esi);
610         APM_DO_RESTORE_SEGS;
611         local_irq_restore(flags);
612         cpu_gdt_table[cpu][0x40 / 8] = save_desc_40;
613         put_cpu();
614         apm_restore_cpus(cpus);
615         
616         return *eax & 0xff;
617 }
618 
619 /**
620  *      apm_bios_call_simple    -       make a simple APM BIOS 32bit call
621  *      @func: APM function to invoke
622  *      @ebx_in: EBX register value for BIOS call
623  *      @ecx_in: ECX register value for BIOS call
624  *      @eax: EAX register on return from the BIOS call
625  *
626  *      Make a BIOS call that does only returns one value, or just status.
627  *      If there is an error, then the error code is returned in AH
628  *      (bits 8-15 of eax) and this function returns non-zero. This is
629  *      used for simpler BIOS operations. This call may hold interrupts
630  *      off for a long time on some laptops.
631  */
632 
633 static u8 apm_bios_call_simple(u32 func, u32 ebx_in, u32 ecx_in, u32 *eax)
634 {
635         u8                      error;
636         APM_DECL_SEGS
637         unsigned long           flags;
638         cpumask_t               cpus;
639         int                     cpu;
640         struct desc_struct      save_desc_40;
641 
642 
643         cpus = apm_save_cpus();
644         
645         cpu = get_cpu();
646         save_desc_40 = cpu_gdt_table[cpu][0x40 / 8];
647         cpu_gdt_table[cpu][0x40 / 8] = bad_bios_desc;
648 
649         local_save_flags(flags);
650         APM_DO_CLI;
651         APM_DO_SAVE_SEGS;
652         error = apm_bios_call_simple_asm(func, ebx_in, ecx_in, eax);
653         APM_DO_RESTORE_SEGS;
654         local_irq_restore(flags);
655         cpu_gdt_table[smp_processor_id()][0x40 / 8] = save_desc_40;
656         put_cpu();
657         apm_restore_cpus(cpus);
658         return error;
659 }
660 
661 /**
662  *      apm_driver_version      -       APM driver version
663  *      @val:   loaded with the APM version on return
664  *
665  *      Retrieve the APM version supported by the BIOS. This is only
666  *      supported for APM 1.1 or higher. An error indicates APM 1.0 is
667  *      probably present.
668  *
669  *      On entry val should point to a value indicating the APM driver
670  *      version with the high byte being the major and the low byte the
671  *      minor number both in BCD
672  *
673  *      On return it will hold the BIOS revision supported in the
674  *      same format.
675  */
676 
677 static int apm_driver_version(u_short *val)
678 {
679         u32     eax;
680 
681         if (apm_bios_call_simple(APM_FUNC_VERSION, 0, *val, &eax))
682                 return (eax >> 8) & 0xff;
683         *val = eax;
684         return APM_SUCCESS;
685 }
686 
687 /**
688  *      apm_get_event   -       get an APM event from the BIOS
689  *      @event: pointer to the event
690  *      @info: point to the event information
691  *
692  *      The APM BIOS provides a polled information for event
693  *      reporting. The BIOS expects to be polled at least every second
694  *      when events are pending. When a message is found the caller should
695  *      poll until no more messages are present.  However, this causes
696  *      problems on some laptops where a suspend event notification is
697  *      not cleared until it is acknowledged.
698  *
699  *      Additional information is returned in the info pointer, providing
700  *      that APM 1.2 is in use. If no messges are pending the value 0x80
701  *      is returned (No power management events pending).
702  */
703  
704 static int apm_get_event(apm_event_t *event, apm_eventinfo_t *info)
705 {
706         u32     eax;
707         u32     ebx;
708         u32     ecx;
709         u32     dummy;
710 
711         if (apm_bios_call(APM_FUNC_GET_EVENT, 0, 0, &eax, &ebx, &ecx,
712                         &dummy, &dummy))
713                 return (eax >> 8) & 0xff;
714         *event = ebx;
715         if (apm_info.connection_version < 0x0102)
716                 *info = ~0; /* indicate info not valid */
717         else
718                 *info = ecx;
719         return APM_SUCCESS;
720 }
721 
722 /**
723  *      set_power_state -       set the power management state
724  *      @what: which items to transition
725  *      @state: state to transition to
726  *
727  *      Request an APM change of state for one or more system devices. The
728  *      processor state must be transitioned last of all. what holds the
729  *      class of device in the upper byte and the device number (0xFF for
730  *      all) for the object to be transitioned.
731  *
732  *      The state holds the state to transition to, which may in fact
733  *      be an acceptance of a BIOS requested state change.
734  */
735  
736 static int set_power_state(u_short what, u_short state)
737 {
738         u32     eax;
739 
740         if (apm_bios_call_simple(APM_FUNC_SET_STATE, what, state, &eax))
741                 return (eax >> 8) & 0xff;
742         return APM_SUCCESS;
743 }
744 
745 /**
746  *      set_system_power_state - set system wide power state
747  *      @state: which state to enter
748  *
749  *      Transition the entire system into a new APM power state.
750  */
751  
752 static int set_system_power_state(u_short state)
753 {
754         return set_power_state(APM_DEVICE_ALL, state);
755 }
756 
757 /**
758  *      apm_do_idle     -       perform power saving
759  *
760  *      This function notifies the BIOS that the processor is (in the view
761  *      of the OS) idle. It returns -1 in the event that the BIOS refuses
762  *      to handle the idle request. On a success the function returns 1
763  *      if the BIOS did clock slowing or 0 otherwise.
764  */
765  
766 static int apm_do_idle(void)
767 {
768         u32     eax;
769 
770         if (apm_bios_call_simple(APM_FUNC_IDLE, 0, 0, &eax)) {
771                 static unsigned long t;
772 
773                 /* This always fails on some SMP boards running UP kernels.
774                  * Only report the failure the first 5 times.
775                  */
776                 if (++t < 5)
777                 {
778                         printk(KERN_DEBUG "apm_do_idle failed (%d)\n",
779                                         (eax >> 8) & 0xff);
780                         t = jiffies;
781                 }
782                 return -1;
783         }
784         clock_slowed = (apm_info.bios.flags & APM_IDLE_SLOWS_CLOCK) != 0;
785         return clock_slowed;
786 }
787 
788 /**
789  *      apm_do_busy     -       inform the BIOS the CPU is busy
790  *
791  *      Request that the BIOS brings the CPU back to full performance. 
792  */
793  
794 static void apm_do_busy(void)
795 {
796         u32     dummy;
797 
798         if (clock_slowed || ALWAYS_CALL_BUSY) {
799                 (void) apm_bios_call_simple(APM_FUNC_BUSY, 0, 0, &dummy);
800                 clock_slowed = 0;
801         }
802 }
803 
804 /*
805  * If no process has really been interested in
806  * the CPU for some time, we want to call BIOS
807  * power management - we probably want
808  * to conserve power.
809  */
810 #define IDLE_CALC_LIMIT   (HZ * 100)
811 #define IDLE_LEAKY_MAX    16
812 
813 static void (*original_pm_idle)(void);
814 
815 extern void default_idle(void);
816 
817 /**
818  * apm_cpu_idle         -       cpu idling for APM capable Linux
819  *
820  * This is the idling function the kernel executes when APM is available. It 
821  * tries to do BIOS powermanagement based on the average system idle time.
822  * Furthermore it calls the system default idle routine.
823  */
824 
825 static void apm_cpu_idle(void)
826 {
827         static int use_apm_idle; /* = 0 */
828         static unsigned int last_jiffies; /* = 0 */
829         static unsigned int last_stime; /* = 0 */
830 
831         int apm_idle_done = 0;
832         unsigned int jiffies_since_last_check = jiffies - last_jiffies;
833         unsigned int bucket;
834 
835 recalc:
836         if (jiffies_since_last_check > IDLE_CALC_LIMIT) {
837                 use_apm_idle = 0;
838                 last_jiffies = jiffies;
839                 last_stime = current->stime;
840         } else if (jiffies_since_last_check > idle_period) {
841                 unsigned int idle_percentage;
842 
843                 idle_percentage = current->stime - last_stime;
844                 idle_percentage *= 100;
845                 idle_percentage /= jiffies_since_last_check;
846                 use_apm_idle = (idle_percentage > idle_threshold);
847                 last_jiffies = jiffies;
848                 last_stime = current->stime;
849         }
850 
851         bucket = IDLE_LEAKY_MAX;
852 
853         while (!need_resched()) {
854                 if (use_apm_idle) {
855                         unsigned int t;
856 
857                         t = jiffies;
858                         switch (apm_do_idle()) {
859                         case 0: apm_idle_done = 1;
860                                 if (t != jiffies) {
861                                         if (bucket) {
862                                                 bucket = IDLE_LEAKY_MAX;
863                                                 continue;
864                                         }
865                                 } else if (bucket) {
866                                         bucket--;
867                                         continue;
868                                 }
869                                 break;
870                         case 1: apm_idle_done = 1;
871                                 break;
872                         default: /* BIOS refused */
873                                 break;
874                         }
875                 }
876                 if (original_pm_idle)
877                         original_pm_idle();
878                 else
879                         default_idle();
880                 jiffies_since_last_check = jiffies - last_jiffies;
881                 if (jiffies_since_last_check > idle_period)
882                         goto recalc;
883         }
884 
885         if (apm_idle_done)
886                 apm_do_busy();
887 }
888 
889 /**
890  *      apm_power_off   -       ask the BIOS to power off
891  *
892  *      Handle the power off sequence. This is the one piece of code we
893  *      will execute even on SMP machines. In order to deal with BIOS
894  *      bugs we support real mode APM BIOS power off calls. We also make
895  *      the SMP call on CPU0 as some systems will only honour this call
896  *      on their first cpu.
897  */
898  
899 static void apm_power_off(void)
900 {
901         unsigned char   po_bios_call[] = {
902                 0xb8, 0x00, 0x10,       /* movw  $0x1000,ax  */
903                 0x8e, 0xd0,             /* movw  ax,ss       */
904                 0xbc, 0x00, 0xf0,       /* movw  $0xf000,sp  */
905                 0xb8, 0x07, 0x53,       /* movw  $0x5307,ax  */
906                 0xbb, 0x01, 0x00,       /* movw  $0x0001,bx  */
907                 0xb9, 0x03, 0x00,       /* movw  $0x0003,cx  */
908                 0xcd, 0x15              /* int   $0x15       */
909         };
910 
911         /*
912          * This may be called on an SMP machine.
913          */
914 #ifdef CONFIG_SMP
915         /* Some bioses don't like being called from CPU != 0 */
916         set_cpus_allowed(current, cpumask_of_cpu(0));
917         BUG_ON(smp_processor_id() != 0);
918 #endif
919         if (apm_info.realmode_power_off)
920         {
921                 (void)apm_save_cpus();
922                 machine_real_restart(po_bios_call, sizeof(po_bios_call));
923         }
924         else
925                 (void) set_system_power_state(APM_STATE_OFF);
926 }
927 
928 #ifdef CONFIG_APM_DO_ENABLE
929 
930 /**
931  *      apm_enable_power_management - enable BIOS APM power management
932  *      @enable: enable yes/no
933  *
934  *      Enable or disable the APM BIOS power services. 
935  */
936  
937 static int apm_enable_power_management(int enable)
938 {
939         u32     eax;
940 
941         if ((enable == 0) && (apm_info.bios.flags & APM_BIOS_DISENGAGED))
942                 return APM_NOT_ENGAGED;
943         if (apm_bios_call_simple(APM_FUNC_ENABLE_PM, APM_DEVICE_BALL,
944                         enable, &eax))
945                 return (eax >> 8) & 0xff;
946         if (enable)
947                 apm_info.bios.flags &= ~APM_BIOS_DISABLED;
948         else
949                 apm_info.bios.flags |= APM_BIOS_DISABLED;
950         return APM_SUCCESS;
951 }
952 #endif
953 
954 /**
955  *      apm_get_power_status    -       get current power state
956  *      @status: returned status
957  *      @bat: battery info
958  *      @life: estimated life
959  *
960  *      Obtain the current power status from the APM BIOS. We return a
961  *      status which gives the rough battery status, and current power
962  *      source. The bat value returned give an estimate as a percentage
963  *      of life and a status value for the battery. The estimated life
964  *      if reported is a lifetime in secodnds/minutes at current powwer
965  *      consumption.
966  */
967  
968 static int apm_get_power_status(u_short *status, u_short *bat, u_short *life)
969 {
970         u32     eax;
971         u32     ebx;
972         u32     ecx;
973         u32     edx;
974         u32     dummy;
975 
976         if (apm_info.get_power_status_broken)
977                 return APM_32_UNSUPPORTED;
978         if (apm_bios_call(APM_FUNC_GET_STATUS, APM_DEVICE_ALL, 0,
979                         &eax, &ebx, &ecx, &edx, &dummy))
980                 return (eax >> 8) & 0xff;
981         *status = ebx;
982         *bat = ecx;
983         if (apm_info.get_power_status_swabinminutes) {
984                 *life = swab16((u16)edx);
985                 *life |= 0x8000;
986         } else
987                 *life = edx;
988         return APM_SUCCESS;
989 }
990 
991 #if 0
992 static int apm_get_battery_status(u_short which, u_short *status,
993                                   u_short *bat, u_short *life, u_short *nbat)
994 {
995         u32     eax;
996         u32     ebx;
997         u32     ecx;
998         u32     edx;
999         u32     esi;
1000 
1001         if (apm_info.connection_version < 0x0102) {
1002                 /* pretend we only have one battery. */
1003                 if (which != 1)
1004                         return APM_BAD_DEVICE;
1005                 *nbat = 1;
1006                 return apm_get_power_status(status, bat, life);
1007         }
1008 
1009         if (apm_bios_call(APM_FUNC_GET_STATUS, (0x8000 | (which)), 0, &eax,
1010                         &ebx, &ecx, &edx, &esi))
1011                 return (eax >> 8) & 0xff;
1012         *status = ebx;
1013         *bat = ecx;
1014         *life = edx;
1015         *nbat = esi;
1016         return APM_SUCCESS;
1017 }
1018 #endif
1019 
1020 /**
1021  *      apm_engage_power_management     -       enable PM on a device
1022  *      @device: identity of device
1023  *      @enable: on/off
1024  *
1025  *      Activate or deactive power management on either a specific device
1026  *      or the entire system (%APM_DEVICE_ALL).
1027  */
1028  
1029 static int apm_engage_power_management(u_short device, int enable)
1030 {
1031         u32     eax;
1032 
1033         if ((enable == 0) && (device == APM_DEVICE_ALL)
1034             && (apm_info.bios.flags & APM_BIOS_DISABLED))
1035                 return APM_DISABLED;
1036         if (apm_bios_call_simple(APM_FUNC_ENGAGE_PM, device, enable, &eax))
1037                 return (eax >> 8) & 0xff;
1038         if (device == APM_DEVICE_ALL) {
1039                 if (enable)
1040                         apm_info.bios.flags &= ~APM_BIOS_DISENGAGED;
1041                 else
1042                         apm_info.bios.flags |= APM_BIOS_DISENGAGED;
1043         }
1044         return APM_SUCCESS;
1045 }
1046 
1047 #if defined(CONFIG_APM_DISPLAY_BLANK) && defined(CONFIG_VT)
1048 
1049 /**
1050  *      apm_console_blank       -       blank the display
1051  *      @blank: on/off
1052  *
1053  *      Attempt to blank the console, firstly by blanking just video device
1054  *      zero, and if that fails (some BIOSes don't support it) then it blanks
1055  *      all video devices. Typically the BIOS will do laptop backlight and
1056  *      monitor powerdown for us.
1057  */
1058  
1059 static int apm_console_blank(int blank)
1060 {
1061         int     error;
1062         u_short state;
1063 
1064         state = blank ? APM_STATE_STANDBY : APM_STATE_READY;
1065         /* Blank the first display device */
1066         error = set_power_state(0x100, state);
1067         if ((error != APM_SUCCESS) && (error != APM_NO_ERROR)) {
1068                 /* try to blank them all instead */
1069                 error = set_power_state(0x1ff, state);
1070                 if ((error != APM_SUCCESS) && (error != APM_NO_ERROR))
1071                         /* try to blank device one instead */
1072                         error = set_power_state(0x101, state);
1073         }
1074         if ((error == APM_SUCCESS) || (error == APM_NO_ERROR))
1075                 return 1;
1076         if (error == APM_NOT_ENGAGED) {
1077                 static int tried;
1078                 int eng_error;
1079                 if (tried++ == 0) {
1080                         eng_error = apm_engage_power_management(APM_DEVICE_ALL, 1);
1081                         if (eng_error) {
1082                                 apm_error("set display", error);
1083                                 apm_error("engage interface", eng_error);
1084                                 return 0;
1085                         } else
1086                                 return apm_console_blank(blank);
1087                 }
1088         }
1089         apm_error("set display", error);
1090         return 0;
1091 }
1092 #endif
1093 
1094 static int queue_empty(struct apm_user *as)
1095 {
1096         return as->event_head == as->event_tail;
1097 }
1098 
1099 static apm_event_t get_queued_event(struct apm_user *as)
1100 {
1101         as->event_tail = (as->event_tail + 1) % APM_MAX_EVENTS;
1102         return as->events[as->event_tail];
1103 }
1104 
1105 static void queue_event(apm_event_t event, struct apm_user *sender)
1106 {
1107         struct apm_user *       as;
1108 
1109         spin_lock(&user_list_lock);
1110         if (user_list == NULL)
1111                 goto out;
1112         for (as = user_list; as != NULL; as = as->next) {
1113                 if ((as == sender) || (!as->reader))
1114                         continue;
1115                 as->event_head = (as->event_head + 1) % APM_MAX_EVENTS;
1116                 if (as->event_head == as->event_tail) {
1117                         static int notified;
1118 
1119                         if (notified++ == 0)
1120                             printk(KERN_ERR "apm: an event queue overflowed\n");
1121                         as->event_tail = (as->event_tail + 1) % APM_MAX_EVENTS;
1122                 }
1123                 as->events[as->event_head] = event;
1124                 if ((!as->suser) || (!as->writer))
1125                         continue;
1126                 switch (event) {
1127                 case APM_SYS_SUSPEND:
1128                 case APM_USER_SUSPEND:
1129                         as->suspends_pending++;
1130                         suspends_pending++;
1131                         break;
1132 
1133                 case APM_SYS_STANDBY:
1134                 case APM_USER_STANDBY:
1135                         as->standbys_pending++;
1136                         standbys_pending++;
1137                         break;
1138                 }
1139         }
1140         wake_up_interruptible(&apm_waitqueue);
1141 out:
1142         spin_unlock(&user_list_lock);
1143 }
1144 
1145 static void set_time(void)
1146 {
1147         if (got_clock_diff) {   /* Must know time zone in order to set clock */
1148                 xtime.tv_sec = get_cmos_time() + clock_cmos_diff;
1149                 xtime.tv_nsec = 0; 
1150         } 
1151 }
1152 
1153 static void get_time_diff(void)
1154 {
1155 #ifndef CONFIG_APM_RTC_IS_GMT
1156         /*
1157          * Estimate time zone so that set_time can update the clock
1158          */
1159         clock_cmos_diff = -get_cmos_time();
1160         clock_cmos_diff += get_seconds();
1161         got_clock_diff = 1;
1162 #endif
1163 }
1164 
1165 static void reinit_timer(void)
1166 {
1167 #ifdef INIT_TIMER_AFTER_SUSPEND
1168         unsigned long   flags;
1169         extern spinlock_t i8253_lock;
1170 
1171         spin_lock_irqsave(&i8253_lock, flags);
1172         /* set the clock to 100 Hz */
1173         outb_p(0x34, PIT_MODE);         /* binary, mode 2, LSB/MSB, ch 0 */
1174         udelay(10);
1175         outb_p(LATCH & 0xff, PIT_CH0);  /* LSB */
1176         udelay(10);
1177         outb(LATCH >> 8, PIT_CH0);      /* MSB */
1178         udelay(10);
1179         spin_unlock_irqrestore(&i8253_lock, flags);
1180 #endif
1181 }
1182 
1183 static int suspend(int vetoable)
1184 {
1185         int             err;
1186         struct apm_user *as;
1187 
1188         if (pm_send_all(PM_SUSPEND, (void *)3)) {
1189                 /* Vetoed */
1190                 if (vetoable) {
1191                         if (apm_info.connection_version > 0x100)
1192                                 set_system_power_state(APM_STATE_REJECT);
1193                         err = -EBUSY;
1194                         ignore_sys_suspend = 0;
1195                         printk(KERN_WARNING "apm: suspend was vetoed.\n");
1196                         goto out;
1197                 }
1198                 printk(KERN_CRIT "apm: suspend was vetoed, but suspending anyway.\n");
1199         }
1200 
1201         device_suspend(3);
1202 
1203         /* serialize with the timer interrupt */
1204         write_seqlock_irq(&xtime_lock);
1205 
1206         /* protect against access to timer chip registers */
1207         spin_lock(&i8253_lock);
1208 
1209         get_time_diff();
1210         /*
1211          * Irq spinlock must be dropped around set_system_power_state.
1212          * We'll undo any timer changes due to interrupts below.
1213          */
1214         spin_unlock(&i8253_lock);
1215         write_sequnlock_irq(&xtime_lock);
1216 
1217         save_processor_state();
1218         err = set_system_power_state(APM_STATE_SUSPEND);
1219         restore_processor_state();
1220 
1221         write_seqlock_irq(&xtime_lock);
1222         spin_lock(&i8253_lock);
1223         reinit_timer();
1224         set_time();
1225         ignore_normal_resume = 1;
1226 
1227         spin_unlock(&i8253_lock);
1228         write_sequnlock_irq(&xtime_lock);
1229 
1230         if (err == APM_NO_ERROR)
1231                 err = APM_SUCCESS;
1232         if (err != APM_SUCCESS)
1233                 apm_error("suspend", err);
1234         err = (err == APM_SUCCESS) ? 0 : -EIO;
1235         device_resume();
1236         pm_send_all(PM_RESUME, (void *)0);
1237         queue_event(APM_NORMAL_RESUME, NULL);
1238  out:
1239         spin_lock(&user_list_lock);
1240         for (as = user_list; as != NULL; as = as->next) {
1241                 as->suspend_wait = 0;
1242                 as->suspend_result = err;
1243         }
1244         spin_unlock(&user_list_lock);
1245         wake_up_interruptible(&apm_suspend_waitqueue);
1246         return err;
1247 }
1248 
1249 static void standby(void)
1250 {
1251         int     err;
1252 
1253         /* serialize with the timer interrupt */
1254         write_seqlock_irq(&xtime_lock);
1255         /* If needed, notify drivers here */
1256         get_time_diff();
1257         write_sequnlock_irq(&xtime_lock);
1258 
1259         err = set_system_power_state(APM_STATE_STANDBY);
1260         if ((err != APM_SUCCESS) && (err != APM_NO_ERROR))
1261                 apm_error("standby", err);
1262 }
1263 
1264 static apm_event_t get_event(void)
1265 {
1266         int             error;
1267         apm_event_t     event;
1268         apm_eventinfo_t info;
1269 
1270         static int notified;
1271 
1272         /* we don't use the eventinfo */
1273         error = apm_get_event(&event, &info);
1274         if (error == APM_SUCCESS)
1275                 return event;
1276 
1277         if ((error != APM_NO_EVENTS) && (notified++ == 0))
1278                 apm_error("get_event", error);
1279 
1280         return 0;
1281 }
1282 
1283 static void check_events(void)
1284 {
1285         apm_event_t             event;
1286         static unsigned long    last_resume;
1287         static int              ignore_bounce;
1288 
1289         while ((event = get_event()) != 0) {
1290                 if (debug) {
1291                         if (event <= NR_APM_EVENT_NAME)
1292                                 printk(KERN_DEBUG "apm: received %s notify\n",
1293                                        apm_event_name[event - 1]);
1294                         else
1295                                 printk(KERN_DEBUG "apm: received unknown "
1296                                        "event 0x%02x\n", event);
1297                 }
1298                 if (ignore_bounce
1299                     && ((jiffies - last_resume) > bounce_interval))
1300                         ignore_bounce = 0;
1301 
1302                 switch (event) {
1303                 case APM_SYS_STANDBY:
1304                 case APM_USER_STANDBY:
1305                         queue_event(event, NULL);
1306                         if (standbys_pending <= 0)
1307                                 standby();
1308                         break;
1309 
1310                 case APM_USER_SUSPEND:
1311 #ifdef CONFIG_APM_IGNORE_USER_SUSPEND
1312                         if (apm_info.connection_version > 0x100)
1313                                 set_system_power_state(APM_STATE_REJECT);
1314                         break;
1315 #endif
1316                 case APM_SYS_SUSPEND:
1317                         if (ignore_bounce) {
1318                                 if (apm_info.connection_version > 0x100)
1319                                         set_system_power_state(APM_STATE_REJECT);
1320                                 break;
1321                         }
1322                         /*
1323                          * If we are already processing a SUSPEND,
1324                          * then further SUSPEND events from the BIOS
1325                          * will be ignored.  We also return here to
1326                          * cope with the fact that the Thinkpads keep
1327                          * sending a SUSPEND event until something else
1328                          * happens!
1329                          */
1330                         if (ignore_sys_suspend)
1331                                 return;
1332                         ignore_sys_suspend = 1;
1333                         queue_event(event, NULL);
1334                         if (suspends_pending <= 0)
1335                                 (void) suspend(1);
1336                         break;
1337 
1338                 case APM_NORMAL_RESUME:
1339                 case APM_CRITICAL_RESUME:
1340                 case APM_STANDBY_RESUME:
1341                         ignore_sys_suspend = 0;
1342                         last_resume = jiffies;
1343                         ignore_bounce = 1;
1344                         if ((event != APM_NORMAL_RESUME)
1345                             || (ignore_normal_resume == 0)) {
1346                                 write_seqlock_irq(&xtime_lock);
1347                                 set_time();
1348                                 write_sequnlock_irq(&xtime_lock);
1349                                 device_resume();
1350                                 pm_send_all(PM_RESUME, (void *)0);
1351                                 queue_event(event, NULL);
1352                         }
1353                         ignore_normal_resume = 0;
1354                         break;
1355 
1356                 case APM_CAPABILITY_CHANGE:
1357                 case APM_LOW_BATTERY:
1358                 case APM_POWER_STATUS_CHANGE:
1359                         queue_event(event, NULL);
1360                         /* If needed, notify drivers here */
1361                         break;
1362 
1363                 case APM_UPDATE_TIME:
1364                         write_seqlock_irq(&xtime_lock);
1365                         set_time();
1366                         write_sequnlock_irq(&xtime_lock);
1367                         break;
1368 
1369                 case APM_CRITICAL_SUSPEND:
1370                         /*
1371                          * We are not allowed to reject a critical suspend.
1372                          */
1373                         (void) suspend(0);
1374                         break;
1375                 }
1376         }
1377 }
1378 
1379 static void apm_event_handler(void)
1380 {
1381         static int      pending_count = 4;
1382         int             err;
1383 
1384         if ((standbys_pending > 0) || (suspends_pending > 0)) {
1385                 if ((apm_info.connection_version > 0x100) &&
1386                                 (pending_count-- <= 0)) {
1387                         pending_count = 4;
1388                         if (debug)
1389                                 printk(KERN_DEBUG "apm: setting state busy\n");
1390                         err = set_system_power_state(APM_STATE_BUSY);
1391                         if (err)
1392                                 apm_error("busy", err);
1393                 }
1394         } else
1395                 pending_count = 4;
1396         check_events();
1397 }
1398 
1399 /*
1400  * This is the APM thread main loop.
1401  */
1402 
1403 static void apm_mainloop(void)
1404 {
1405         DECLARE_WAITQUEUE(wait, current);
1406 
1407         add_wait_queue(&apm_waitqueue, &wait);
1408         set_current_state(TASK_INTERRUPTIBLE);
1409         for (;;) {
1410                 schedule_timeout(APM_CHECK_TIMEOUT);
1411                 if (exit_kapmd)
1412                         break;
1413                 /*
1414                  * Ok, check all events, check for idle (and mark us sleeping
1415                  * so as not to count towards the load average)..
1416                  */
1417                 set_current_state(TASK_INTERRUPTIBLE);
1418                 apm_event_handler();
1419         }
1420         remove_wait_queue(&apm_waitqueue, &wait);
1421 }
1422 
1423 static int check_apm_user(struct apm_user *as, const char *func)
1424 {
1425         if ((as == NULL) || (as->magic != APM_BIOS_MAGIC)) {
1426                 printk(KERN_ERR "apm: %s passed bad filp\n", func);
1427                 return 1;
1428         }
1429         return 0;
1430 }
1431 
1432 static ssize_t do_read(struct file *fp, char *buf, size_t count, loff_t *ppos)
1433 {
1434         struct apm_user *       as;
1435         int                     i;
1436         apm_event_t             event;
1437 
1438         as = fp->private_data;
1439         if (check_apm_user(as, "read"))
1440                 return -EIO;
1441         if ((int)count < sizeof(apm_event_t))
1442                 return -EINVAL;
1443         if ((queue_empty(as)) && (fp->f_flags & O_NONBLOCK))
1444                 return -EAGAIN;
1445         wait_event_interruptible(apm_waitqueue, !queue_empty(as));
1446         i = count;
1447         while ((i >= sizeof(event)) && !queue_empty(as)) {
1448                 event = get_queued_event(as);
1449                 if (copy_to_user(buf, &event, sizeof(event))) {
1450                         if (i < count)
1451                                 break;
1452                         return -EFAULT;
1453                 }
1454                 switch (event) {
1455                 case APM_SYS_SUSPEND:
1456                 case APM_USER_SUSPEND:
1457                         as->suspends_read++;
1458                         break;
1459 
1460                 case APM_SYS_STANDBY:
1461                 case APM_USER_STANDBY:
1462                         as->standbys_read++;
1463                         break;
1464                 }
1465                 buf += sizeof(event);
1466                 i -= sizeof(event);
1467         }
1468         if (i < count)
1469                 return count - i;
1470         if (signal_pending(current))
1471                 return -ERESTARTSYS;
1472         return 0;
1473 }
1474 
1475 static unsigned int do_poll(struct file *fp, poll_table * wait)
1476 {
1477         struct apm_user * as;
1478 
1479         as = fp->private_data;
1480         if (check_apm_user(as, "poll"))
1481                 return 0;
1482         poll_wait(fp, &apm_waitqueue, wait);
1483         if (!queue_empty(as))
1484                 return POLLIN | POLLRDNORM;
1485         return 0;
1486 }
1487 
1488 static int do_ioctl(struct inode * inode, struct file *filp,
1489                     u_int cmd, u_long arg)
1490 {
1491         struct apm_user *       as;
1492 
1493         as = filp->private_data;
1494         if (check_apm_user(as, "ioctl"))
1495                 return -EIO;
1496         if ((!as->suser) || (!as->writer))
1497                 return -EPERM;
1498         switch (cmd) {
1499         case APM_IOC_STANDBY:
1500                 if (as->standbys_read > 0) {
1501                         as->standbys_read--;
1502                         as->standbys_pending--;
1503                         standbys_pending--;
1504                 } else
1505                         queue_event(APM_USER_STANDBY, as);
1506                 if (standbys_pending <= 0)
1507                         standby();
1508                 break;
1509         case APM_IOC_SUSPEND:
1510                 if (as->suspends_read > 0) {
1511                         as->suspends_read--;
1512                         as->suspends_pending--;
1513                         suspends_pending--;
1514                 } else
1515                         queue_event(APM_USER_SUSPEND, as);
1516                 if (suspends_pending <= 0) {
1517                         return suspend(1);
1518                 } else {
1519                         as->suspend_wait = 1;
1520                         wait_event_interruptible(apm_suspend_waitqueue,
1521                                         as->suspend_wait == 0);
1522                         return as->suspend_result;
1523                 }
1524                 break;
1525         default:
1526                 return -EINVAL;
1527         }
1528         return 0;
1529 }
1530 
1531 static int do_release(struct inode * inode, struct file * filp)
1532 {
1533         struct apm_user *       as;
1534 
1535         as = filp->private_data;
1536         if (check_apm_user(as, "release"))
1537                 return 0;
1538         filp->private_data = NULL;
1539         if (as->standbys_pending > 0) {
1540                 standbys_pending -= as->standbys_pending;
1541                 if (standbys_pending <= 0)
1542                         standby();
1543         }
1544         if (as->suspends_pending > 0) {
1545                 suspends_pending -= as->suspends_pending;
1546                 if (suspends_pending <= 0)
1547                         (void) suspend(1);
1548         }
1549         spin_lock(&user_list_lock);
1550         if (user_list == as)
1551                 user_list = as->next;
1552         else {
1553                 struct apm_user *       as1;
1554 
1555                 for (as1 = user_list;
1556                      (as1 != NULL) && (as1->next != as);
1557                      as1 = as1->next)
1558                         ;
1559                 if (as1 == NULL)
1560                         printk(KERN_ERR "apm: filp not in user list\n");
1561                 else
1562                         as1->next = as->next;
1563         }
1564         spin_unlock(&user_list_lock);
1565         kfree(as);
1566         return 0;
1567 }
1568 
1569 static int do_open(struct inode * inode, struct file * filp)
1570 {
1571         struct apm_user *       as;
1572 
1573         as = (struct apm_user *)kmalloc(sizeof(*as), GFP_KERNEL);
1574         if (as == NULL) {
1575                 printk(KERN_ERR "apm: cannot allocate struct of size %d bytes\n",
1576                        sizeof(*as));
1577                 return -ENOMEM;
1578         }
1579         as->magic = APM_BIOS_MAGIC;
1580         as->event_tail = as->event_head = 0;
1581         as->suspends_pending = as->standbys_pending = 0;
1582         as->suspends_read = as->standbys_read = 0;
1583         /*
1584          * XXX - this is a tiny bit broken, when we consider BSD
1585          * process accounting. If the device is opened by root, we
1586          * instantly flag that we used superuser privs. Who knows,
1587          * we might close the device immediately without doing a
1588          * privileged operation -- cevans
1589          */
1590         as->suser = capable(CAP_SYS_ADMIN);
1591         as->writer = (filp->f_mode & FMODE_WRITE) == FMODE_WRITE;
1592         as->reader = (filp->f_mode & FMODE_READ) == FMODE_READ;
1593         spin_lock(&user_list_lock);
1594         as->next = user_list;
1595         user_list = as;
1596         spin_unlock(&user_list_lock);
1597         filp->private_data = as;
1598         return 0;
1599 }
1600 
1601 static int apm_get_info(char *buf, char **start, off_t fpos, int length)
1602 {
1603         char *          p;
1604         unsigned short  bx;
1605         unsigned short  cx;
1606         unsigned short  dx;
1607         int             error;
1608         unsigned short  ac_line_status = 0xff;
1609         unsigned short  battery_status = 0xff;
1610         unsigned short  battery_flag   = 0xff;
1611         int             percentage     = -1;
1612         int             time_units     = -1;
1613         char            *units         = "?";
1614 
1615         p = buf;
1616 
1617         if ((num_online_cpus() == 1) &&
1618             !(error = apm_get_power_status(&bx, &cx, &dx))) {
1619                 ac_line_status = (bx >> 8) & 0xff;
1620                 battery_status = bx & 0xff;
1621                 if ((cx & 0xff) != 0xff)
1622                         percentage = cx & 0xff;
1623 
1624                 if (apm_info.connection_version > 0x100) {
1625                         battery_flag = (cx >> 8) & 0xff;
1626                         if (dx != 0xffff) {
1627                                 units = (dx & 0x8000) ? "min" : "sec";
1628                                 time_units = dx & 0x7fff;
1629                         }
1630                 }
1631         }
1632         /* Arguments, with symbols from linux/apm_bios.h.  Information is
1633            from the Get Power Status (0x0a) call unless otherwise noted.
1634 
1635            0) Linux driver version (this will change if format changes)
1636            1) APM BIOS Version.  Usually 1.0, 1.1 or 1.2.
1637            2) APM flags from APM Installation Check (0x00):
1638               bit 0: APM_16_BIT_SUPPORT
1639               bit 1: APM_32_BIT_SUPPORT
1640               bit 2: APM_IDLE_SLOWS_CLOCK
1641               bit 3: APM_BIOS_DISABLED
1642               bit 4: APM_BIOS_DISENGAGED
1643            3) AC line status
1644               0x00: Off-line
1645               0x01: On-line
1646               0x02: On backup power (BIOS >= 1.1 only)
1647               0xff: Unknown
1648            4) Battery status
1649               0x00: High
1650               0x01: Low
1651               0x02: Critical
1652               0x03: Charging
1653               0x04: Selected battery not present (BIOS >= 1.2 only)
1654               0xff: Unknown
1655            5) Battery flag
1656               bit 0: High
1657               bit 1: Low
1658               bit 2: Critical
1659               bit 3: Charging
1660               bit 7: No system battery
1661               0xff: Unknown
1662            6) Remaining battery life (percentage of charge):
1663               0-100: valid
1664               -1: Unknown
1665            7) Remaining battery life (time units):
1666               Number of remaining minutes or seconds
1667               -1: Unknown
1668            8) min = minutes; sec = seconds */
1669 
1670         p += sprintf(p, "%s %d.%d 0x%02x 0x%02x 0x%02x 0x%02x %d%% %d %s\n",
1671                      driver_version,
1672                      (apm_info.bios.version >> 8) & 0xff,
1673                      apm_info.bios.version & 0xff,
1674                      apm_info.bios.flags,
1675                      ac_line_status,
1676                      battery_status,
1677                      battery_flag,
1678                      percentage,
1679                      time_units,
1680                      units);
1681 
1682         return p - buf;
1683 }
1684 
1685 static int apm(void *unused)
1686 {
1687         unsigned short  bx;
1688         unsigned short  cx;
1689         unsigned short  dx;
1690         int             error;
1691         char *          power_stat;
1692         char *          bat_stat;
1693 
1694         kapmd_running = 1;
1695 
1696         daemonize("kapmd");
1697 
1698         current->flags |= PF_IOTHREAD;
1699 
1700 #ifdef CONFIG_SMP
1701         /* 2002/08/01 - WT
1702          * This is to avoid random crashes at boot time during initialization
1703          * on SMP systems in case of "apm=power-off" mode. Seen on ASUS A7M266D.
1704          * Some bioses don't like being called from CPU != 0.
1705          * Method suggested by Ingo Molnar.
1706          */
1707         set_cpus_allowed(current, cpumask_of_cpu(0));
1708         BUG_ON(smp_processor_id() != 0);
1709 #endif
1710 
1711         if (apm_info.connection_version == 0) {
1712                 apm_info.connection_version = apm_info.bios.version;
1713                 if (apm_info.connection_version > 0x100) {
1714                         /*
1715                          * We only support BIOSs up to version 1.2
1716                          */
1717                         if (apm_info.connection_version > 0x0102)
1718                                 apm_info.connection_version = 0x0102;
1719                         error = apm_driver_version(&apm_info.connection_version);
1720                         if (error != APM_SUCCESS) {
1721                                 apm_error("driver version", error);
1722                                 /* Fall back to an APM 1.0 connection. */
1723                                 apm_info.connection_version = 0x100;
1724                         }
1725                 }
1726         }
1727 
1728         if (debug)
1729                 printk(KERN_INFO "apm: Connection version %d.%d\n",
1730                         (apm_info.connection_version >> 8) & 0xff,
1731                         apm_info.connection_version & 0xff);
1732 
1733 #ifdef CONFIG_APM_DO_ENABLE
1734         if (apm_info.bios.flags & APM_BIOS_DISABLED) {
1735                 /*
1736                  * This call causes my NEC UltraLite Versa 33/C to hang if it
1737                  * is booted with PM disabled but not in the docking station.
1738                  * Unfortunate ...
1739                  */
1740                 error = apm_enable_power_management(1);
1741                 if (error) {
1742                         apm_error("enable power management", error);
1743                         return -1;
1744                 }
1745         }
1746 #endif
1747 
1748         if ((apm_info.bios.flags & APM_BIOS_DISENGAGED)
1749             && (apm_info.connection_version > 0x0100)) {
1750                 error = apm_engage_power_management(APM_DEVICE_ALL, 1);
1751                 if (error) {
1752                         apm_error("engage power management", error);
1753                         return -1;
1754                 }
1755         }
1756 
1757         if (debug && (num_online_cpus() == 1 || smp )) {
1758                 error = apm_get_power_status(&bx, &cx, &dx);
1759                 if (error)
1760                         printk(KERN_INFO "apm: power status not available\n");
1761                 else {
1762                         switch ((bx >> 8) & 0xff) {
1763                         case 0: power_stat = "off line"; break;
1764                         case 1: power_stat = "on line"; break;
1765                         case 2: power_stat = "on backup power"; break;
1766                         default: power_stat = "unknown"; break;
1767                         }
1768                         switch (bx & 0xff) {
1769                         case 0: bat_stat = "high"; break;
1770                         case 1: bat_stat = "low"; break;
1771                         case 2: bat_stat = "critical"; break;
1772                         case 3: bat_stat = "charging"; break;
1773                         default: bat_stat = "unknown"; break;
1774                         }
1775                         printk(KERN_INFO
1776                                "apm: AC %s, battery status %s, battery life ",
1777                                power_stat, bat_stat);
1778                         if ((cx & 0xff) == 0xff)
1779                                 printk("unknown\n");
1780                         else
1781                                 printk("%d%%\n", cx & 0xff);
1782                         if (apm_info.connection_version > 0x100) {
1783                                 printk(KERN_INFO
1784                                        "apm: battery flag 0x%02x, battery life ",
1785                                        (cx >> 8) & 0xff);
1786                                 if (dx == 0xffff)
1787                                         printk("unknown\n");
1788                                 else
1789                                         printk("%d %s\n", dx & 0x7fff,
1790                                                 (dx & 0x8000) ?
1791                                                 "minutes" : "seconds");
1792                         }
1793                 }
1794         }
1795 
1796         /* Install our power off handler.. */
1797         if (power_off)
1798                 pm_power_off = apm_power_off;
1799 
1800         if (num_online_cpus() == 1 || smp) {
1801 #if defined(CONFIG_APM_DISPLAY_BLANK) && defined(CONFIG_VT)
1802                 console_blank_hook = apm_console_blank;
1803 #endif
1804                 apm_mainloop();
1805 #if defined(CONFIG_APM_DISPLAY_BLANK) && defined(CONFIG_VT)
1806                 console_blank_hook = NULL;
1807 #endif
1808         }
1809         kapmd_running = 0;
1810 
1811         return 0;
1812 }
1813 
1814 #ifndef MODULE
1815 static int __init apm_setup(char *str)
1816 {
1817         int     invert;
1818 
1819         while ((str != NULL) && (*str != '\0')) {
1820                 if (strncmp(str, "off", 3) == 0)
1821                         apm_disabled = 1;
1822                 if (strncmp(str, "on", 2) == 0)
1823                         apm_disabled = 0;
1824                 if ((strncmp(str, "bounce-interval=", 16) == 0) ||
1825                     (strncmp(str, "bounce_interval=", 16) == 0))
1826                         bounce_interval = simple_strtol(str + 16, NULL, 0);
1827                 if ((strncmp(str, "idle-threshold=", 15) == 0) ||
1828                     (strncmp(str, "idle_threshold=", 15) == 0))
1829                         idle_threshold = simple_strtol(str + 15, NULL, 0);
1830                 if ((strncmp(str, "idle-period=", 12) == 0) ||
1831                     (strncmp(str, "idle_period=", 12) == 0))
1832                         idle_period = simple_strtol(str + 12, NULL, 0);
1833                 invert = (strncmp(str, "no-", 3) == 0) ||
1834                         (strncmp(str, "no_", 3) == 0);
1835                 if (invert)
1836                         str += 3;
1837                 if (strncmp(str, "debug", 5) == 0)
1838                         debug = !invert;
1839                 if ((strncmp(str, "power-off", 9) == 0) ||
1840                     (strncmp(str, "power_off", 9) == 0))
1841                         power_off = !invert;
1842                 if (strncmp(str, "smp", 3) == 0)
1843                 {
1844                         smp = !invert;
1845                         idle_threshold = 100;
1846                 }
1847                 if ((strncmp(str, "allow-ints", 10) == 0) ||
1848                     (strncmp(str, "allow_ints", 10) == 0))
1849                         apm_info.allow_ints = !invert;
1850                 if ((strncmp(str, "broken-psr", 10) == 0) ||
1851                     (strncmp(str, "broken_psr", 10) == 0))
1852                         apm_info.get_power_status_broken = !invert;
1853                 if ((strncmp(str, "realmode-power-off", 18) == 0) ||
1854                     (strncmp(str, "realmode_power_off", 18) == 0))
1855                         apm_info.realmode_power_off = !invert;
1856                 str = strchr(str, ',');
1857                 if (str != NULL)
1858                         str += strspn(str, ", \t");
1859         }
1860         return 1;
1861 }
1862 
1863 __setup("apm=", apm_setup);
1864 #endif
1865 
1866 static struct file_operations apm_bios_fops = {
1867         .owner          = THIS_MODULE,
1868         .read           = do_read,
1869         .poll           = do_poll,
1870         .ioctl          = do_ioctl,
1871         .open           = do_open,
1872         .release        = do_release,
1873 };
1874 
1875 static struct miscdevice apm_device = {
1876         APM_MINOR_DEV,
1877         "apm_bios",
1878         &apm_bios_fops
1879 };
1880 
1881 /*
1882  * Just start the APM thread. We do NOT want to do APM BIOS
1883  * calls from anything but the APM thread, if for no other reason
1884  * than the fact that we don't trust the APM BIOS. This way,
1885  * most common APM BIOS problems that lead to protection errors
1886  * etc will have at least some level of being contained...
1887  *
1888  * In short, if something bad happens, at least we have a choice
1889  * of just killing the apm thread..
1890  */
1891 static int __init apm_init(void)
1892 {
1893         struct proc_dir_entry *apm_proc;
1894         int i;
1895 
1896         if (apm_info.bios.version == 0) {
1897                 printk(KERN_INFO "apm: BIOS not found.\n");
1898                 return -ENODEV;
1899         }
1900         printk(KERN_INFO
1901                 "apm: BIOS version %d.%d Flags 0x%02x (Driver version %s)\n",
1902                 ((apm_info.bios.version >> 8) & 0xff),
1903                 (apm_info.bios.version & 0xff),
1904                 apm_info.bios.flags,
1905                 driver_version);
1906         if ((apm_info.bios.flags & APM_32_BIT_SUPPORT) == 0) {
1907                 printk(KERN_INFO "apm: no 32 bit BIOS support\n");
1908                 return -ENODEV;
1909         }
1910 
1911         if (allow_ints)
1912                 apm_info.allow_ints = 1;
1913         if (broken_psr)
1914                 apm_info.get_power_status_broken = 1;
1915         if (realmode_power_off)
1916                 apm_info.realmode_power_off = 1;
1917         /* User can override, but default is to trust DMI */
1918         if (apm_disabled != -1)
1919                 apm_info.disabled = apm_disabled;
1920 
1921         /*
1922          * Fix for the Compaq Contura 3/25c which reports BIOS version 0.1
1923          * but is reportedly a 1.0 BIOS.
1924          */
1925         if (apm_info.bios.version == 0x001)
1926                 apm_info.bios.version = 0x100;
1927 
1928         /* BIOS < 1.2 doesn't set cseg_16_len */
1929         if (apm_info.bios.version < 0x102)
1930                 apm_info.bios.cseg_16_len = 0; /* 64k */
1931 
1932         if (debug) {
1933                 printk(KERN_INFO "apm: entry %x:%lx cseg16 %x dseg %x",
1934                         apm_info.bios.cseg, apm_info.bios.offset,
1935                         apm_info.bios.cseg_16, apm_info.bios.dseg);
1936                 if (apm_info.bios.version > 0x100)
1937                         printk(" cseg len %x, dseg len %x",
1938                                 apm_info.bios.cseg_len,
1939                                 apm_info.bios.dseg_len);
1940                 if (apm_info.bios.version > 0x101)
1941                         printk(" cseg16 len %x", apm_info.bios.cseg_16_len);
1942                 printk("\n");
1943         }
1944 
1945         if (apm_info.disabled) {
1946                 printk(KERN_NOTICE "apm: disabled on user request.\n");
1947                 return -ENODEV;
1948         }
1949         if ((num_online_cpus() > 1) && !power_off && !smp) {
1950                 printk(KERN_NOTICE "apm: disabled - APM is not SMP safe.\n");
1951                 return -ENODEV;
1952         }
1953         if (PM_IS_ACTIVE()) {
1954                 printk(KERN_NOTICE "apm: overridden by ACPI.\n");
1955                 return -ENODEV;
1956         }
1957         pm_active = 1;
1958 
1959         /*
1960          * Set up a segment that references the real mode segment 0x40
1961          * that extends up to the end of page zero (that we have reserved).
1962          * This is for buggy BIOS's that refer to (real mode) segment 0x40
1963          * even though they are called in protected mode.
1964          */
1965         set_base(bad_bios_desc, __va((unsigned long)0x40 << 4));
1966         _set_limit((char *)&bad_bios_desc, 4095 - (0x40 << 4));
1967 
1968         apm_bios_entry.offset = apm_info.bios.offset;
1969         apm_bios_entry.segment = APM_CS;
1970 
1971         for (i = 0; i < NR_CPUS; i++) {
1972                 set_base(cpu_gdt_table[i][APM_CS >> 3],
1973                          __va((unsigned long)apm_info.bios.cseg << 4));
1974                 set_base(cpu_gdt_table[i][APM_CS_16 >> 3],
1975                          __va((unsigned long)apm_info.bios.cseg_16 << 4));
1976                 set_base(cpu_gdt_table[i][APM_DS >> 3],
1977                          __va((unsigned long)apm_info.bios.dseg << 4));
1978 #ifndef APM_RELAX_SEGMENTS
1979                 if (apm_info.bios.version == 0x100) {
1980 #endif
1981                         /* For ASUS motherboard, Award BIOS rev 110 (and others?) */
1982                         _set_limit((char *)&cpu_gdt_table[i][APM_CS >> 3], 64 * 1024 - 1);
1983                         /* For some unknown machine. */
1984                         _set_limit((char *)&cpu_gdt_table[i][APM_CS_16 >> 3], 64 * 1024 - 1);
1985                         /* For the DEC Hinote Ultra CT475 (and others?) */
1986                         _set_limit((char *)&cpu_gdt_table[i][APM_DS >> 3], 64 * 1024 - 1);
1987 #ifndef APM_RELAX_SEGMENTS
1988                 } else {
1989                         _set_limit((char *)&cpu_gdt_table[i][APM_CS >> 3],
1990                                 (apm_info.bios.cseg_len - 1) & 0xffff);
1991                         _set_limit((char *)&cpu_gdt_table[i][APM_CS_16 >> 3],
1992                                 (apm_info.bios.cseg_16_len - 1) & 0xffff);
1993                         _set_limit((char *)&cpu_gdt_table[i][APM_DS >> 3],
1994                                 (apm_info.bios.dseg_len - 1) & 0xffff);
1995                       /* workaround for broken BIOSes */
1996                         if (apm_info.bios.cseg_len <= apm_info.bios.offset)
1997                                 _set_limit((char *)&cpu_gdt_table[i][APM_CS >> 3], 64 * 1024 -1);
1998                        if (apm_info.bios.dseg_len <= 0x40) { /* 0x40 * 4kB == 64kB */
1999                                 /* for the BIOS that assumes granularity = 1 */
2000                                 cpu_gdt_table[i][APM_DS >> 3].b |= 0x800000;
2001                                 printk(KERN_NOTICE "apm: we set the granularity of dseg.\n");
2002                         }
2003                 }
2004 #endif
2005         }
2006 
2007         apm_proc = create_proc_info_entry("apm", 0, NULL, apm_get_info);
2008         if (apm_proc)
2009                 apm_proc->owner = THIS_MODULE;
2010 
2011         kernel_thread(apm, NULL, CLONE_KERNEL | SIGCHLD);
2012 
2013         if (num_online_cpus() > 1 && !smp ) {
2014                 printk(KERN_NOTICE
2015                    "apm: disabled - APM is not SMP safe (power off active).\n");
2016                 return 0;
2017         }
2018 
2019         misc_register(&apm_device);
2020 
2021         if (HZ != 100)
2022                 idle_period = (idle_period * HZ) / 100;
2023         if (idle_threshold < 100) {
2024                 original_pm_idle = pm_idle;
2025                 pm_idle  = apm_cpu_idle;
2026                 set_pm_idle = 1;
2027         }
2028 
2029         return 0;
2030 }
2031 
2032 static void __exit apm_exit(void)
2033 {
2034         int     error;
2035 
2036         if (set_pm_idle)
2037                 pm_idle = original_pm_idle;
2038         if (((apm_info.bios.flags & APM_BIOS_DISENGAGED) == 0)
2039             && (apm_info.connection_version > 0x0100)) {
2040                 error = apm_engage_power_management(APM_DEVICE_ALL, 0);
2041                 if (error)
2042                         apm_error("disengage power management", error);
2043         }
2044         misc_deregister(&apm_device);
2045         remove_proc_entry("apm", NULL);
2046         if (power_off)
2047                 pm_power_off = NULL;
2048         exit_kapmd = 1;
2049         while (kapmd_running)
2050                 schedule();
2051         pm_active = 0;
2052 }
2053 
2054 module_init(apm_init);
2055 module_exit(apm_exit);
2056 
2057 MODULE_AUTHOR("Stephen Rothwell");
2058 MODULE_DESCRIPTION("Advanced Power Management");
2059 MODULE_LICENSE("GPL");
2060 MODULE_PARM(debug, "i");
2061 MODULE_PARM_DESC(debug, "Enable debug mode");
2062 MODULE_PARM(power_off, "i");
2063 MODULE_PARM_DESC(power_off, "Enable power off");
2064 MODULE_PARM(bounce_interval, "i");
2065 MODULE_PARM_DESC(bounce_interval,
2066                 "Set the number of ticks to ignore suspend bounces");
2067 MODULE_PARM(allow_ints, "i");
2068 MODULE_PARM_DESC(allow_ints, "Allow interrupts during BIOS calls");
2069 MODULE_PARM(broken_psr, "i");
2070 MODULE_PARM_DESC(broken_psr, "BIOS has a broken GetPowerStatus call");
2071 MODULE_PARM(realmode_power_off, "i");
2072 MODULE_PARM_DESC(realmode_power_off,
2073                 "Switch to real mode before powering off");
2074 MODULE_PARM(idle_threshold, "i");
2075 MODULE_PARM_DESC(idle_threshold,
2076         "System idle percentage above which to make APM BIOS idle calls");
2077 MODULE_PARM(idle_period, "i");
2078 MODULE_PARM_DESC(idle_period,
2079         "Period (in sec/100) over which to caculate the idle percentage");
2080 MODULE_PARM(smp, "i");
2081 MODULE_PARM_DESC(smp,
2082         "Set this to enable APM use on an SMP platform. Use with caution on older systems");
2083 MODULE_ALIAS_MISCDEV(APM_MINOR_DEV);
2084 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp