git.oblomov.eu Git - linux-2.6/blob - arch/i386/kernel/apm.c

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