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