arch/i386/kernel/apm.c

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