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