Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 |