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