blob: c99e43b837f5ce50010fefb57259699884a79418 [file] [log] [blame]
Ralf Baechle77269422007-02-09 17:08:57 +00001/*
2 * bios-less APM driver for ARM Linux
3 * Jamey Hicks <jamey@crl.dec.com>
4 * adapted from the APM BIOS driver for Linux by Stephen Rothwell (sfr@linuxcare.com)
5 *
6 * APM 1.2 Reference:
7 * Intel Corporation, Microsoft Corporation. Advanced Power Management
8 * (APM) BIOS Interface Specification, Revision 1.2, February 1996.
9 *
10 * [This document is available from Microsoft at:
11 * http://www.microsoft.com/hwdev/busbios/amp_12.htm]
12 */
13#include <linux/module.h>
14#include <linux/poll.h>
15#include <linux/slab.h>
16#include <linux/proc_fs.h>
17#include <linux/miscdevice.h>
18#include <linux/apm_bios.h>
19#include <linux/capability.h>
20#include <linux/sched.h>
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -070021#include <linux/suspend.h>
Ralf Baechle77269422007-02-09 17:08:57 +000022#include <linux/apm-emulation.h>
Rafael J. Wysocki83144182007-07-17 04:03:35 -070023#include <linux/freezer.h>
Ralf Baechle77269422007-02-09 17:08:57 +000024#include <linux/device.h>
25#include <linux/kernel.h>
26#include <linux/list.h>
27#include <linux/init.h>
28#include <linux/completion.h>
29#include <linux/kthread.h>
30#include <linux/delay.h>
31
32#include <asm/system.h>
33
34/*
35 * The apm_bios device is one of the misc char devices.
36 * This is its minor number.
37 */
38#define APM_MINOR_DEV 134
39
40/*
41 * See Documentation/Config.help for the configuration options.
42 *
43 * Various options can be changed at boot time as follows:
44 * (We allow underscores for compatibility with the modules code)
45 * apm=on/off enable/disable APM
46 */
47
48/*
49 * Maximum number of events stored
50 */
51#define APM_MAX_EVENTS 16
52
53struct apm_queue {
54 unsigned int event_head;
55 unsigned int event_tail;
56 apm_event_t events[APM_MAX_EVENTS];
57};
58
59/*
60 * The per-file APM data
61 */
62struct apm_user {
63 struct list_head list;
64
65 unsigned int suser: 1;
66 unsigned int writer: 1;
67 unsigned int reader: 1;
68
69 int suspend_result;
70 unsigned int suspend_state;
71#define SUSPEND_NONE 0 /* no suspend pending */
72#define SUSPEND_PENDING 1 /* suspend pending read */
73#define SUSPEND_READ 2 /* suspend read, pending ack */
74#define SUSPEND_ACKED 3 /* suspend acked */
75#define SUSPEND_WAIT 4 /* waiting for suspend */
76#define SUSPEND_DONE 5 /* suspend completed */
77
78 struct apm_queue queue;
79};
80
81/*
82 * Local variables
83 */
84static int suspends_pending;
85static int apm_disabled;
86static struct task_struct *kapmd_tsk;
87
88static DECLARE_WAIT_QUEUE_HEAD(apm_waitqueue);
89static DECLARE_WAIT_QUEUE_HEAD(apm_suspend_waitqueue);
90
91/*
92 * This is a list of everyone who has opened /dev/apm_bios
93 */
94static DECLARE_RWSEM(user_list_lock);
95static LIST_HEAD(apm_user_list);
96
97/*
98 * kapmd info. kapmd provides us a process context to handle
99 * "APM" events within - specifically necessary if we're going
100 * to be suspending the system.
101 */
102static DECLARE_WAIT_QUEUE_HEAD(kapmd_wait);
103static DEFINE_SPINLOCK(kapmd_queue_lock);
104static struct apm_queue kapmd_queue;
105
106static DEFINE_MUTEX(state_lock);
107
108static const char driver_version[] = "1.13"; /* no spaces */
109
110
111
112/*
113 * Compatibility cruft until the IPAQ people move over to the new
114 * interface.
115 */
116static void __apm_get_power_status(struct apm_power_info *info)
117{
118}
119
120/*
121 * This allows machines to provide their own "apm get power status" function.
122 */
123void (*apm_get_power_status)(struct apm_power_info *) = __apm_get_power_status;
124EXPORT_SYMBOL(apm_get_power_status);
125
126
127/*
128 * APM event queue management.
129 */
130static inline int queue_empty(struct apm_queue *q)
131{
132 return q->event_head == q->event_tail;
133}
134
135static inline apm_event_t queue_get_event(struct apm_queue *q)
136{
137 q->event_tail = (q->event_tail + 1) % APM_MAX_EVENTS;
138 return q->events[q->event_tail];
139}
140
141static void queue_add_event(struct apm_queue *q, apm_event_t event)
142{
143 q->event_head = (q->event_head + 1) % APM_MAX_EVENTS;
144 if (q->event_head == q->event_tail) {
145 static int notified;
146
147 if (notified++ == 0)
148 printk(KERN_ERR "apm: an event queue overflowed\n");
149 q->event_tail = (q->event_tail + 1) % APM_MAX_EVENTS;
150 }
151 q->events[q->event_head] = event;
152}
153
154static void queue_event(apm_event_t event)
155{
156 struct apm_user *as;
157
158 down_read(&user_list_lock);
159 list_for_each_entry(as, &apm_user_list, list) {
160 if (as->reader)
161 queue_add_event(&as->queue, event);
162 }
163 up_read(&user_list_lock);
164 wake_up_interruptible(&apm_waitqueue);
165}
166
167/*
168 * queue_suspend_event - queue an APM suspend event.
169 *
170 * Check that we're in a state where we can suspend. If not,
171 * return -EBUSY. Otherwise, queue an event to all "writer"
172 * users. If there are no "writer" users, return '1' to
173 * indicate that we can immediately suspend.
174 */
175static int queue_suspend_event(apm_event_t event, struct apm_user *sender)
176{
177 struct apm_user *as;
178 int ret = 1;
179
180 mutex_lock(&state_lock);
181 down_read(&user_list_lock);
182
183 /*
184 * If a thread is still processing, we can't suspend, so reject
185 * the request.
186 */
187 list_for_each_entry(as, &apm_user_list, list) {
188 if (as != sender && as->reader && as->writer && as->suser &&
189 as->suspend_state != SUSPEND_NONE) {
190 ret = -EBUSY;
191 goto out;
192 }
193 }
194
195 list_for_each_entry(as, &apm_user_list, list) {
196 if (as != sender && as->reader && as->writer && as->suser) {
197 as->suspend_state = SUSPEND_PENDING;
198 suspends_pending++;
199 queue_add_event(&as->queue, event);
200 ret = 0;
201 }
202 }
203 out:
204 up_read(&user_list_lock);
205 mutex_unlock(&state_lock);
206 wake_up_interruptible(&apm_waitqueue);
207 return ret;
208}
209
210static void apm_suspend(void)
211{
212 struct apm_user *as;
213 int err = pm_suspend(PM_SUSPEND_MEM);
214
215 /*
216 * Anyone on the APM queues will think we're still suspended.
217 * Send a message so everyone knows we're now awake again.
218 */
219 queue_event(APM_NORMAL_RESUME);
220
221 /*
222 * Finally, wake up anyone who is sleeping on the suspend.
223 */
224 mutex_lock(&state_lock);
225 down_read(&user_list_lock);
226 list_for_each_entry(as, &apm_user_list, list) {
227 if (as->suspend_state == SUSPEND_WAIT ||
228 as->suspend_state == SUSPEND_ACKED) {
229 as->suspend_result = err;
230 as->suspend_state = SUSPEND_DONE;
231 }
232 }
233 up_read(&user_list_lock);
234 mutex_unlock(&state_lock);
235
236 wake_up(&apm_suspend_waitqueue);
237}
238
239static ssize_t apm_read(struct file *fp, char __user *buf, size_t count, loff_t *ppos)
240{
241 struct apm_user *as = fp->private_data;
242 apm_event_t event;
243 int i = count, ret = 0;
244
245 if (count < sizeof(apm_event_t))
246 return -EINVAL;
247
248 if (queue_empty(&as->queue) && fp->f_flags & O_NONBLOCK)
249 return -EAGAIN;
250
251 wait_event_interruptible(apm_waitqueue, !queue_empty(&as->queue));
252
253 while ((i >= sizeof(event)) && !queue_empty(&as->queue)) {
254 event = queue_get_event(&as->queue);
255
256 ret = -EFAULT;
257 if (copy_to_user(buf, &event, sizeof(event)))
258 break;
259
260 mutex_lock(&state_lock);
261 if (as->suspend_state == SUSPEND_PENDING &&
262 (event == APM_SYS_SUSPEND || event == APM_USER_SUSPEND))
263 as->suspend_state = SUSPEND_READ;
264 mutex_unlock(&state_lock);
265
266 buf += sizeof(event);
267 i -= sizeof(event);
268 }
269
270 if (i < count)
271 ret = count - i;
272
273 return ret;
274}
275
276static unsigned int apm_poll(struct file *fp, poll_table * wait)
277{
278 struct apm_user *as = fp->private_data;
279
280 poll_wait(fp, &apm_waitqueue, wait);
281 return queue_empty(&as->queue) ? 0 : POLLIN | POLLRDNORM;
282}
283
284/*
285 * apm_ioctl - handle APM ioctl
286 *
287 * APM_IOC_SUSPEND
288 * This IOCTL is overloaded, and performs two functions. It is used to:
289 * - initiate a suspend
290 * - acknowledge a suspend read from /dev/apm_bios.
291 * Only when everyone who has opened /dev/apm_bios with write permission
292 * has acknowledge does the actual suspend happen.
293 */
294static int
295apm_ioctl(struct inode * inode, struct file *filp, u_int cmd, u_long arg)
296{
297 struct apm_user *as = filp->private_data;
298 unsigned long flags;
299 int err = -EINVAL;
300
301 if (!as->suser || !as->writer)
302 return -EPERM;
303
304 switch (cmd) {
305 case APM_IOC_SUSPEND:
306 mutex_lock(&state_lock);
307
308 as->suspend_result = -EINTR;
309
310 if (as->suspend_state == SUSPEND_READ) {
311 int pending;
312
313 /*
314 * If we read a suspend command from /dev/apm_bios,
315 * then the corresponding APM_IOC_SUSPEND ioctl is
316 * interpreted as an acknowledge.
317 */
318 as->suspend_state = SUSPEND_ACKED;
319 suspends_pending--;
320 pending = suspends_pending == 0;
321 mutex_unlock(&state_lock);
322
323 /*
324 * If there are no further acknowledges required,
325 * suspend the system.
326 */
327 if (pending)
328 apm_suspend();
329
330 /*
331 * Wait for the suspend/resume to complete. If there
332 * are pending acknowledges, we wait here for them.
Ralf Baechle77269422007-02-09 17:08:57 +0000333 */
334 flags = current->flags;
Ralf Baechle77269422007-02-09 17:08:57 +0000335
336 wait_event(apm_suspend_waitqueue,
337 as->suspend_state == SUSPEND_DONE);
338 } else {
339 as->suspend_state = SUSPEND_WAIT;
340 mutex_unlock(&state_lock);
341
342 /*
343 * Otherwise it is a request to suspend the system.
344 * Queue an event for all readers, and expect an
345 * acknowledge from all writers who haven't already
346 * acknowledged.
347 */
348 err = queue_suspend_event(APM_USER_SUSPEND, as);
349 if (err < 0) {
350 /*
351 * Avoid taking the lock here - this
352 * should be fine.
353 */
354 as->suspend_state = SUSPEND_NONE;
355 break;
356 }
357
358 if (err > 0)
359 apm_suspend();
360
361 /*
362 * Wait for the suspend/resume to complete. If there
363 * are pending acknowledges, we wait here for them.
Ralf Baechle77269422007-02-09 17:08:57 +0000364 */
365 flags = current->flags;
Ralf Baechle77269422007-02-09 17:08:57 +0000366
367 wait_event_interruptible(apm_suspend_waitqueue,
368 as->suspend_state == SUSPEND_DONE);
369 }
370
371 current->flags = flags;
372
373 mutex_lock(&state_lock);
374 err = as->suspend_result;
375 as->suspend_state = SUSPEND_NONE;
376 mutex_unlock(&state_lock);
377 break;
378 }
379
380 return err;
381}
382
383static int apm_release(struct inode * inode, struct file * filp)
384{
385 struct apm_user *as = filp->private_data;
386 int pending = 0;
387
388 filp->private_data = NULL;
389
390 down_write(&user_list_lock);
391 list_del(&as->list);
392 up_write(&user_list_lock);
393
394 /*
395 * We are now unhooked from the chain. As far as new
396 * events are concerned, we no longer exist. However, we
397 * need to balance suspends_pending, which means the
398 * possibility of sleeping.
399 */
400 mutex_lock(&state_lock);
401 if (as->suspend_state != SUSPEND_NONE) {
402 suspends_pending -= 1;
403 pending = suspends_pending == 0;
404 }
405 mutex_unlock(&state_lock);
406 if (pending)
407 apm_suspend();
408
409 kfree(as);
410 return 0;
411}
412
413static int apm_open(struct inode * inode, struct file * filp)
414{
415 struct apm_user *as;
416
417 as = kzalloc(sizeof(*as), GFP_KERNEL);
418 if (as) {
419 /*
420 * XXX - this is a tiny bit broken, when we consider BSD
421 * process accounting. If the device is opened by root, we
422 * instantly flag that we used superuser privs. Who knows,
423 * we might close the device immediately without doing a
424 * privileged operation -- cevans
425 */
426 as->suser = capable(CAP_SYS_ADMIN);
427 as->writer = (filp->f_mode & FMODE_WRITE) == FMODE_WRITE;
428 as->reader = (filp->f_mode & FMODE_READ) == FMODE_READ;
429
430 down_write(&user_list_lock);
431 list_add(&as->list, &apm_user_list);
432 up_write(&user_list_lock);
433
434 filp->private_data = as;
435 }
436
437 return as ? 0 : -ENOMEM;
438}
439
440static struct file_operations apm_bios_fops = {
441 .owner = THIS_MODULE,
442 .read = apm_read,
443 .poll = apm_poll,
444 .ioctl = apm_ioctl,
445 .open = apm_open,
446 .release = apm_release,
447};
448
449static struct miscdevice apm_device = {
450 .minor = APM_MINOR_DEV,
451 .name = "apm_bios",
452 .fops = &apm_bios_fops
453};
454
455
456#ifdef CONFIG_PROC_FS
457/*
458 * Arguments, with symbols from linux/apm_bios.h.
459 *
460 * 0) Linux driver version (this will change if format changes)
461 * 1) APM BIOS Version. Usually 1.0, 1.1 or 1.2.
462 * 2) APM flags from APM Installation Check (0x00):
463 * bit 0: APM_16_BIT_SUPPORT
464 * bit 1: APM_32_BIT_SUPPORT
465 * bit 2: APM_IDLE_SLOWS_CLOCK
466 * bit 3: APM_BIOS_DISABLED
467 * bit 4: APM_BIOS_DISENGAGED
468 * 3) AC line status
469 * 0x00: Off-line
470 * 0x01: On-line
471 * 0x02: On backup power (BIOS >= 1.1 only)
472 * 0xff: Unknown
473 * 4) Battery status
474 * 0x00: High
475 * 0x01: Low
476 * 0x02: Critical
477 * 0x03: Charging
478 * 0x04: Selected battery not present (BIOS >= 1.2 only)
479 * 0xff: Unknown
480 * 5) Battery flag
481 * bit 0: High
482 * bit 1: Low
483 * bit 2: Critical
484 * bit 3: Charging
485 * bit 7: No system battery
486 * 0xff: Unknown
487 * 6) Remaining battery life (percentage of charge):
488 * 0-100: valid
489 * -1: Unknown
490 * 7) Remaining battery life (time units):
491 * Number of remaining minutes or seconds
492 * -1: Unknown
493 * 8) min = minutes; sec = seconds
494 */
495static int apm_get_info(char *buf, char **start, off_t fpos, int length)
496{
497 struct apm_power_info info;
498 char *units;
499 int ret;
500
501 info.ac_line_status = 0xff;
502 info.battery_status = 0xff;
503 info.battery_flag = 0xff;
504 info.battery_life = -1;
505 info.time = -1;
506 info.units = -1;
507
508 if (apm_get_power_status)
509 apm_get_power_status(&info);
510
511 switch (info.units) {
512 default: units = "?"; break;
513 case 0: units = "min"; break;
514 case 1: units = "sec"; break;
515 }
516
517 ret = sprintf(buf, "%s 1.2 0x%02x 0x%02x 0x%02x 0x%02x %d%% %d %s\n",
518 driver_version, APM_32_BIT_SUPPORT,
519 info.ac_line_status, info.battery_status,
520 info.battery_flag, info.battery_life,
521 info.time, units);
522
523 return ret;
524}
525#endif
526
527static int kapmd(void *arg)
528{
529 do {
530 apm_event_t event;
531 int ret;
532
533 wait_event_interruptible(kapmd_wait,
534 !queue_empty(&kapmd_queue) || kthread_should_stop());
535
536 if (kthread_should_stop())
537 break;
538
539 spin_lock_irq(&kapmd_queue_lock);
540 event = 0;
541 if (!queue_empty(&kapmd_queue))
542 event = queue_get_event(&kapmd_queue);
543 spin_unlock_irq(&kapmd_queue_lock);
544
545 switch (event) {
546 case 0:
547 break;
548
549 case APM_LOW_BATTERY:
550 case APM_POWER_STATUS_CHANGE:
551 queue_event(event);
552 break;
553
554 case APM_USER_SUSPEND:
555 case APM_SYS_SUSPEND:
556 ret = queue_suspend_event(event, NULL);
557 if (ret < 0) {
558 /*
559 * We were busy. Try again in 50ms.
560 */
561 queue_add_event(&kapmd_queue, event);
562 msleep(50);
563 }
564 if (ret > 0)
565 apm_suspend();
566 break;
567
568 case APM_CRITICAL_SUSPEND:
569 apm_suspend();
570 break;
571 }
572 } while (1);
573
574 return 0;
575}
576
577static int __init apm_init(void)
578{
579 int ret;
580
581 if (apm_disabled) {
582 printk(KERN_NOTICE "apm: disabled on user request.\n");
583 return -ENODEV;
584 }
585
586 kapmd_tsk = kthread_create(kapmd, NULL, "kapmd");
587 if (IS_ERR(kapmd_tsk)) {
588 ret = PTR_ERR(kapmd_tsk);
589 kapmd_tsk = NULL;
590 return ret;
591 }
Ralf Baechle77269422007-02-09 17:08:57 +0000592 wake_up_process(kapmd_tsk);
593
594#ifdef CONFIG_PROC_FS
595 create_proc_info_entry("apm", 0, NULL, apm_get_info);
596#endif
597
598 ret = misc_register(&apm_device);
599 if (ret != 0) {
600 remove_proc_entry("apm", NULL);
601 kthread_stop(kapmd_tsk);
602 }
603
604 return ret;
605}
606
607static void __exit apm_exit(void)
608{
609 misc_deregister(&apm_device);
610 remove_proc_entry("apm", NULL);
611
612 kthread_stop(kapmd_tsk);
613}
614
615module_init(apm_init);
616module_exit(apm_exit);
617
618MODULE_AUTHOR("Stephen Rothwell");
619MODULE_DESCRIPTION("Advanced Power Management");
620MODULE_LICENSE("GPL");
621
622#ifndef MODULE
623static int __init apm_setup(char *str)
624{
625 while ((str != NULL) && (*str != '\0')) {
626 if (strncmp(str, "off", 3) == 0)
627 apm_disabled = 1;
628 if (strncmp(str, "on", 2) == 0)
629 apm_disabled = 0;
630 str = strchr(str, ',');
631 if (str != NULL)
632 str += strspn(str, ", \t");
633 }
634 return 1;
635}
636
637__setup("apm=", apm_setup);
638#endif
639
640/**
641 * apm_queue_event - queue an APM event for kapmd
642 * @event: APM event
643 *
644 * Queue an APM event for kapmd to process and ultimately take the
645 * appropriate action. Only a subset of events are handled:
646 * %APM_LOW_BATTERY
647 * %APM_POWER_STATUS_CHANGE
648 * %APM_USER_SUSPEND
649 * %APM_SYS_SUSPEND
650 * %APM_CRITICAL_SUSPEND
651 */
652void apm_queue_event(apm_event_t event)
653{
654 unsigned long flags;
655
656 spin_lock_irqsave(&kapmd_queue_lock, flags);
657 queue_add_event(&kapmd_queue, event);
658 spin_unlock_irqrestore(&kapmd_queue_lock, flags);
659
660 wake_up_interruptible(&kapmd_wait);
661}
662EXPORT_SYMBOL(apm_queue_event);