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