PM: Move definition of struct pm_ops to suspend.h
[linux-2.6.git] / drivers / char / apm-emulation.c
1 /*
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>
21 #include <linux/suspend.h>
22 #include <linux/apm-emulation.h>
23 #include <linux/freezer.h>
24 #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
53 struct 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  */
62 struct 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  */
84 static int suspends_pending;
85 static int apm_disabled;
86 static struct task_struct *kapmd_tsk;
87
88 static DECLARE_WAIT_QUEUE_HEAD(apm_waitqueue);
89 static DECLARE_WAIT_QUEUE_HEAD(apm_suspend_waitqueue);
90
91 /*
92  * This is a list of everyone who has opened /dev/apm_bios
93  */
94 static DECLARE_RWSEM(user_list_lock);
95 static 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  */
102 static DECLARE_WAIT_QUEUE_HEAD(kapmd_wait);
103 static DEFINE_SPINLOCK(kapmd_queue_lock);
104 static struct apm_queue kapmd_queue;
105
106 static DEFINE_MUTEX(state_lock);
107
108 static 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  */
116 static 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  */
123 void (*apm_get_power_status)(struct apm_power_info *) = __apm_get_power_status;
124 EXPORT_SYMBOL(apm_get_power_status);
125
126
127 /*
128  * APM event queue management.
129  */
130 static inline int queue_empty(struct apm_queue *q)
131 {
132         return q->event_head == q->event_tail;
133 }
134
135 static 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
141 static 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
154 static 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  */
175 static 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
210 static 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
239 static 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
276 static 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  */
294 static int
295 apm_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.
333                          */
334                         flags = current->flags;
335
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.
364                          */
365                         flags = current->flags;
366
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
383 static 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
413 static 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
440 static 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
449 static 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  */
495 static 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
527 static 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
577 static 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         }
592         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
607 static 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
615 module_init(apm_init);
616 module_exit(apm_exit);
617
618 MODULE_AUTHOR("Stephen Rothwell");
619 MODULE_DESCRIPTION("Advanced Power Management");
620 MODULE_LICENSE("GPL");
621
622 #ifndef MODULE
623 static 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  */
652 void 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 }
662 EXPORT_SYMBOL(apm_queue_event);