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