PNP: Add missing casts in printk() arguments
[linux-2.6] / drivers / macintosh / apm_emu.c
1 /* APM emulation layer for PowerMac
2  * 
3  * Copyright 2001 Benjamin Herrenschmidt (benh@kernel.crashing.org)
4  *
5  * Lots of code inherited from apm.c, see appropriate notice in
6  *  arch/i386/kernel/apm.c
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  *
19  */
20
21 #include <linux/module.h>
22
23 #include <linux/poll.h>
24 #include <linux/types.h>
25 #include <linux/stddef.h>
26 #include <linux/timer.h>
27 #include <linux/fcntl.h>
28 #include <linux/slab.h>
29 #include <linux/stat.h>
30 #include <linux/proc_fs.h>
31 #include <linux/miscdevice.h>
32 #include <linux/apm_bios.h>
33 #include <linux/init.h>
34 #include <linux/sched.h>
35 #include <linux/pm.h>
36 #include <linux/kernel.h>
37 #include <linux/smp_lock.h>
38
39 #include <linux/adb.h>
40 #include <linux/pmu.h>
41
42 #include <asm/system.h>
43 #include <asm/uaccess.h>
44 #include <asm/machdep.h>
45
46 #undef DEBUG
47
48 #ifdef DEBUG
49 #define DBG(args...) printk(KERN_DEBUG args)
50 //#define DBG(args...) xmon_printf(args)
51 #else
52 #define DBG(args...) do { } while (0)
53 #endif
54
55 /*
56  * The apm_bios device is one of the misc char devices.
57  * This is its minor number.
58  */
59 #define APM_MINOR_DEV   134
60
61 /*
62  * Maximum number of events stored
63  */
64 #define APM_MAX_EVENTS          20
65
66 #define FAKE_APM_BIOS_VERSION   0x0101
67
68 #define APM_USER_NOTIFY_TIMEOUT (5*HZ)
69
70 /*
71  * The per-file APM data
72  */
73 struct apm_user {
74         int             magic;
75         struct apm_user *       next;
76         int             suser: 1;
77         int             suspend_waiting: 1;
78         int             suspends_pending;
79         int             suspends_read;
80         int             event_head;
81         int             event_tail;
82         apm_event_t     events[APM_MAX_EVENTS];
83 };
84
85 /*
86  * The magic number in apm_user
87  */
88 #define APM_BIOS_MAGIC          0x4101
89
90 /*
91  * Local variables
92  */
93 static int                      suspends_pending;
94
95 static DECLARE_WAIT_QUEUE_HEAD(apm_waitqueue);
96 static DECLARE_WAIT_QUEUE_HEAD(apm_suspend_waitqueue);
97 static struct apm_user *        user_list;
98
99 static int apm_notify_sleep(struct pmu_sleep_notifier *self, int when);
100 static struct pmu_sleep_notifier apm_sleep_notifier = {
101         apm_notify_sleep,
102         SLEEP_LEVEL_USERLAND,
103 };
104
105 static char                     driver_version[] = "0.5";       /* no spaces */
106
107 #ifdef DEBUG
108 static char *   apm_event_name[] = {
109         "system standby",
110         "system suspend",
111         "normal resume",
112         "critical resume",
113         "low battery",
114         "power status change",
115         "update time",
116         "critical suspend",
117         "user standby",
118         "user suspend",
119         "system standby resume",
120         "capabilities change"
121 };
122 #define NR_APM_EVENT_NAME       \
123                 (sizeof(apm_event_name) / sizeof(apm_event_name[0]))
124
125 #endif
126
127 static int queue_empty(struct apm_user *as)
128 {
129         return as->event_head == as->event_tail;
130 }
131
132 static apm_event_t get_queued_event(struct apm_user *as)
133 {
134         as->event_tail = (as->event_tail + 1) % APM_MAX_EVENTS;
135         return as->events[as->event_tail];
136 }
137
138 static void queue_event(apm_event_t event, struct apm_user *sender)
139 {
140         struct apm_user *       as;
141
142         DBG("apm_emu: queue_event(%s)\n", apm_event_name[event-1]);
143         if (user_list == NULL)
144                 return;
145         for (as = user_list; as != NULL; as = as->next) {
146                 if (as == sender)
147                         continue;
148                 as->event_head = (as->event_head + 1) % APM_MAX_EVENTS;
149                 if (as->event_head == as->event_tail) {
150                         static int notified;
151
152                         if (notified++ == 0)
153                             printk(KERN_ERR "apm_emu: an event queue overflowed\n");
154                         as->event_tail = (as->event_tail + 1) % APM_MAX_EVENTS;
155                 }
156                 as->events[as->event_head] = event;
157                 if (!as->suser)
158                         continue;
159                 switch (event) {
160                 case APM_SYS_SUSPEND:
161                 case APM_USER_SUSPEND:
162                         as->suspends_pending++;
163                         suspends_pending++;
164                         break;
165                 case APM_NORMAL_RESUME:
166                         as->suspend_waiting = 0;
167                         break;
168                 }
169         }
170         wake_up_interruptible(&apm_waitqueue);
171 }
172
173 static int check_apm_user(struct apm_user *as, const char *func)
174 {
175         if ((as == NULL) || (as->magic != APM_BIOS_MAGIC)) {
176                 printk(KERN_ERR "apm_emu: %s passed bad filp\n", func);
177                 return 1;
178         }
179         return 0;
180 }
181
182 static ssize_t do_read(struct file *fp, char __user *buf, size_t count, loff_t *ppos)
183 {
184         struct apm_user *       as;
185         size_t                  i;
186         apm_event_t             event;
187         DECLARE_WAITQUEUE(wait, current);
188
189         as = fp->private_data;
190         if (check_apm_user(as, "read"))
191                 return -EIO;
192         if (count < sizeof(apm_event_t))
193                 return -EINVAL;
194         if (queue_empty(as)) {
195                 if (fp->f_flags & O_NONBLOCK)
196                         return -EAGAIN;
197                 add_wait_queue(&apm_waitqueue, &wait);
198 repeat:
199                 set_current_state(TASK_INTERRUPTIBLE);
200                 if (queue_empty(as) && !signal_pending(current)) {
201                         schedule();
202                         goto repeat;
203                 }
204                 set_current_state(TASK_RUNNING);
205                 remove_wait_queue(&apm_waitqueue, &wait);
206         }
207         i = count;
208         while ((i >= sizeof(event)) && !queue_empty(as)) {
209                 event = get_queued_event(as);
210                 DBG("apm_emu: do_read, returning: %s\n", apm_event_name[event-1]);
211                 if (copy_to_user(buf, &event, sizeof(event))) {
212                         if (i < count)
213                                 break;
214                         return -EFAULT;
215                 }
216                 switch (event) {
217                 case APM_SYS_SUSPEND:
218                 case APM_USER_SUSPEND:
219                         as->suspends_read++;
220                         break;
221                 }
222                 buf += sizeof(event);
223                 i -= sizeof(event);
224         }
225         if (i < count)
226                 return count - i;
227         if (signal_pending(current))
228                 return -ERESTARTSYS;
229         return 0;
230 }
231
232 static unsigned int do_poll(struct file *fp, poll_table * wait)
233 {
234         struct apm_user * as;
235
236         as = fp->private_data;
237         if (check_apm_user(as, "poll"))
238                 return 0;
239         poll_wait(fp, &apm_waitqueue, wait);
240         if (!queue_empty(as))
241                 return POLLIN | POLLRDNORM;
242         return 0;
243 }
244
245 static int do_ioctl(struct inode * inode, struct file *filp,
246                     u_int cmd, u_long arg)
247 {
248         struct apm_user *       as;
249         DECLARE_WAITQUEUE(wait, current);
250
251         as = filp->private_data;
252         if (check_apm_user(as, "ioctl"))
253                 return -EIO;
254         if (!as->suser)
255                 return -EPERM;
256         switch (cmd) {
257         case APM_IOC_SUSPEND:
258                 /* If a suspend message was sent to userland, we
259                  * consider this as a confirmation message
260                  */
261                 if (as->suspends_read > 0) {
262                         as->suspends_read--;
263                         as->suspends_pending--;
264                         suspends_pending--;
265                 } else {
266                         // Route to PMU suspend ?
267                         break;
268                 }
269                 as->suspend_waiting = 1;
270                 add_wait_queue(&apm_waitqueue, &wait);
271                 DBG("apm_emu: ioctl waking up sleep waiter !\n");
272                 wake_up(&apm_suspend_waitqueue);
273                 mb();
274                 while(as->suspend_waiting && !signal_pending(current)) {
275                         set_current_state(TASK_INTERRUPTIBLE);
276                         schedule();
277                 }
278                 set_current_state(TASK_RUNNING);
279                 remove_wait_queue(&apm_waitqueue, &wait);
280                 break;
281         default:
282                 return -EINVAL;
283         }
284         return 0;
285 }
286
287 static int do_release(struct inode * inode, struct file * filp)
288 {
289         struct apm_user *       as;
290
291         as = filp->private_data;
292         if (check_apm_user(as, "release"))
293                 return 0;
294         filp->private_data = NULL;
295         lock_kernel();
296         if (as->suspends_pending > 0) {
297                 suspends_pending -= as->suspends_pending;
298                 if (suspends_pending <= 0)
299                         wake_up(&apm_suspend_waitqueue);
300         }
301         if (user_list == as)
302                 user_list = as->next;
303         else {
304                 struct apm_user *       as1;
305
306                 for (as1 = user_list;
307                      (as1 != NULL) && (as1->next != as);
308                      as1 = as1->next)
309                         ;
310                 if (as1 == NULL)
311                         printk(KERN_ERR "apm: filp not in user list\n");
312                 else
313                         as1->next = as->next;
314         }
315         unlock_kernel();
316         kfree(as);
317         return 0;
318 }
319
320 static int do_open(struct inode * inode, struct file * filp)
321 {
322         struct apm_user *       as;
323
324         as = (struct apm_user *)kmalloc(sizeof(*as), GFP_KERNEL);
325         if (as == NULL) {
326                 printk(KERN_ERR "apm: cannot allocate struct of size %d bytes\n",
327                        sizeof(*as));
328                 return -ENOMEM;
329         }
330         as->magic = APM_BIOS_MAGIC;
331         as->event_tail = as->event_head = 0;
332         as->suspends_pending = 0;
333         as->suspends_read = 0;
334         /*
335          * XXX - this is a tiny bit broken, when we consider BSD
336          * process accounting. If the device is opened by root, we
337          * instantly flag that we used superuser privs. Who knows,
338          * we might close the device immediately without doing a
339          * privileged operation -- cevans
340          */
341         as->suser = capable(CAP_SYS_ADMIN);
342         as->next = user_list;
343         user_list = as;
344         filp->private_data = as;
345
346         DBG("apm_emu: opened by %s, suser: %d\n", current->comm, (int)as->suser);
347
348         return 0;
349 }
350
351 /* Wait for all clients to ack the suspend request. APM API
352  * doesn't provide a way to NAK, but this could be added
353  * here.
354  */
355 static int wait_all_suspend(void)
356 {
357         DECLARE_WAITQUEUE(wait, current);
358
359         add_wait_queue(&apm_suspend_waitqueue, &wait);
360         DBG("apm_emu: wait_all_suspend(), suspends_pending: %d\n", suspends_pending);
361         while(suspends_pending > 0) {
362                 set_current_state(TASK_UNINTERRUPTIBLE);
363                 schedule();
364         }
365         set_current_state(TASK_RUNNING);
366         remove_wait_queue(&apm_suspend_waitqueue, &wait);
367
368         DBG("apm_emu: wait_all_suspend() - complete !\n");
369         
370         return 1;
371 }
372
373 static int apm_notify_sleep(struct pmu_sleep_notifier *self, int when)
374 {
375         switch(when) {
376                 case PBOOK_SLEEP_REQUEST:
377                         queue_event(APM_SYS_SUSPEND, NULL);
378                         if (!wait_all_suspend())
379                                 return PBOOK_SLEEP_REFUSE;
380                         break;
381                 case PBOOK_SLEEP_REJECT:
382                 case PBOOK_WAKE:
383                         queue_event(APM_NORMAL_RESUME, NULL);
384                         break;
385         }
386         return PBOOK_SLEEP_OK;
387 }
388
389 #define APM_CRITICAL            10
390 #define APM_LOW                 30
391
392 static int apm_emu_get_info(char *buf, char **start, off_t fpos, int length)
393 {
394         /* Arguments, with symbols from linux/apm_bios.h.  Information is
395            from the Get Power Status (0x0a) call unless otherwise noted.
396
397            0) Linux driver version (this will change if format changes)
398            1) APM BIOS Version.  Usually 1.0, 1.1 or 1.2.
399            2) APM flags from APM Installation Check (0x00):
400               bit 0: APM_16_BIT_SUPPORT
401               bit 1: APM_32_BIT_SUPPORT
402               bit 2: APM_IDLE_SLOWS_CLOCK
403               bit 3: APM_BIOS_DISABLED
404               bit 4: APM_BIOS_DISENGAGED
405            3) AC line status
406               0x00: Off-line
407               0x01: On-line
408               0x02: On backup power (BIOS >= 1.1 only)
409               0xff: Unknown
410            4) Battery status
411               0x00: High
412               0x01: Low
413               0x02: Critical
414               0x03: Charging
415               0x04: Selected battery not present (BIOS >= 1.2 only)
416               0xff: Unknown
417            5) Battery flag
418               bit 0: High
419               bit 1: Low
420               bit 2: Critical
421               bit 3: Charging
422               bit 7: No system battery
423               0xff: Unknown
424            6) Remaining battery life (percentage of charge):
425               0-100: valid
426               -1: Unknown
427            7) Remaining battery life (time units):
428               Number of remaining minutes or seconds
429               -1: Unknown
430            8) min = minutes; sec = seconds */
431
432         unsigned short  ac_line_status;
433         unsigned short  battery_status = 0;
434         unsigned short  battery_flag   = 0xff;
435         int             percentage     = -1;
436         int             time_units     = -1;
437         int             real_count     = 0;
438         int             i;
439         char *          p = buf;
440         char            charging       = 0;
441         long            charge         = -1;
442         long            amperage       = 0;
443         unsigned long   btype          = 0;
444
445         ac_line_status = ((pmu_power_flags & PMU_PWR_AC_PRESENT) != 0);
446         for (i=0; i<pmu_battery_count; i++) {
447                 if (pmu_batteries[i].flags & PMU_BATT_PRESENT) {
448                         battery_status++;
449                         if (percentage < 0)
450                                 percentage = 0;
451                         if (charge < 0)
452                                 charge = 0;
453                         percentage += (pmu_batteries[i].charge * 100) /
454                                 pmu_batteries[i].max_charge;
455                         charge += pmu_batteries[i].charge;
456                         amperage += pmu_batteries[i].amperage;
457                         if (btype == 0)
458                                 btype = (pmu_batteries[i].flags & PMU_BATT_TYPE_MASK);
459                         real_count++;
460                         if ((pmu_batteries[i].flags & PMU_BATT_CHARGING))
461                                 charging++;
462                 }
463         }
464         if (0 == battery_status)
465                 ac_line_status = 1;
466         battery_status = 0xff;
467         if (real_count) {
468                 if (amperage < 0) {
469                         if (btype == PMU_BATT_TYPE_SMART)
470                                 time_units = (charge * 59) / (amperage * -1);
471                         else
472                                 time_units = (charge * 16440) / (amperage * -60);
473                 }
474                 percentage /= real_count;
475                 if (charging > 0) {
476                         battery_status = 0x03;
477                         battery_flag = 0x08;
478                 } else if (percentage <= APM_CRITICAL) {
479                         battery_status = 0x02;
480                         battery_flag = 0x04;
481                 } else if (percentage <= APM_LOW) {
482                         battery_status = 0x01;
483                         battery_flag = 0x02;
484                 } else {
485                         battery_status = 0x00;
486                         battery_flag = 0x01;
487                 }
488         }
489         p += sprintf(p, "%s %d.%d 0x%02x 0x%02x 0x%02x 0x%02x %d%% %d %s\n",
490                      driver_version,
491                      (FAKE_APM_BIOS_VERSION >> 8) & 0xff,
492                      FAKE_APM_BIOS_VERSION & 0xff,
493                      0,
494                      ac_line_status,
495                      battery_status,
496                      battery_flag,
497                      percentage,
498                      time_units,
499                      "min");
500
501         return p - buf;
502 }
503
504 static struct file_operations apm_bios_fops = {
505         .owner          = THIS_MODULE,
506         .read           = do_read,
507         .poll           = do_poll,
508         .ioctl          = do_ioctl,
509         .open           = do_open,
510         .release        = do_release,
511 };
512
513 static struct miscdevice apm_device = {
514         APM_MINOR_DEV,
515         "apm_bios",
516         &apm_bios_fops
517 };
518
519 static int __init apm_emu_init(void)
520 {
521         struct proc_dir_entry *apm_proc;
522
523         if (sys_ctrler != SYS_CTRLER_PMU) {
524                 printk(KERN_INFO "apm_emu: Requires a machine with a PMU.\n");
525                 return -ENODEV;
526         }
527                 
528         apm_proc = create_proc_info_entry("apm", 0, NULL, apm_emu_get_info);
529         if (apm_proc)
530                 apm_proc->owner = THIS_MODULE;
531
532         misc_register(&apm_device);
533
534         pmu_register_sleep_notifier(&apm_sleep_notifier);
535
536         printk(KERN_INFO "apm_emu: APM Emulation %s initialized.\n", driver_version);
537
538         return 0;
539 }
540
541 static void __exit apm_emu_exit(void)
542 {
543         pmu_unregister_sleep_notifier(&apm_sleep_notifier);
544         misc_deregister(&apm_device);
545         remove_proc_entry("apm", NULL);
546
547         printk(KERN_INFO "apm_emu: APM Emulation removed.\n");
548 }
549
550 module_init(apm_emu_init);
551 module_exit(apm_emu_exit);
552
553 MODULE_AUTHOR("Benjamin Herrenschmidt");
554 MODULE_DESCRIPTION("APM emulation layer for PowerMac");
555 MODULE_LICENSE("GPL");
556