arch/x86/kernel/apm_32.c

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