]>
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 | ||
1da177e4 LT |
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 | ||
70b52b38 | 99 | static void apm_notify_sleep(struct pmu_sleep_notifier *self, int when); |
1da177e4 LT |
100 | static struct pmu_sleep_notifier apm_sleep_notifier = { |
101 | apm_notify_sleep, | |
102 | SLEEP_LEVEL_USERLAND, | |
103 | }; | |
104 | ||
87275856 | 105 | static const char driver_version[] = "0.5"; /* no spaces */ |
1da177e4 LT |
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 | ||
5cbded58 | 324 | as = kmalloc(sizeof(*as), GFP_KERNEL); |
1da177e4 LT |
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 | */ | |
70b52b38 | 355 | static void wait_all_suspend(void) |
1da177e4 LT |
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"); | |
1da177e4 LT |
369 | } |
370 | ||
70b52b38 | 371 | static void apm_notify_sleep(struct pmu_sleep_notifier *self, int when) |
1da177e4 LT |
372 | { |
373 | switch(when) { | |
374 | case PBOOK_SLEEP_REQUEST: | |
375 | queue_event(APM_SYS_SUSPEND, NULL); | |
70b52b38 | 376 | wait_all_suspend(); |
1da177e4 | 377 | break; |
1da177e4 LT |
378 | case PBOOK_WAKE: |
379 | queue_event(APM_NORMAL_RESUME, NULL); | |
380 | break; | |
381 | } | |
1da177e4 LT |
382 | } |
383 | ||
384 | #define APM_CRITICAL 10 | |
385 | #define APM_LOW 30 | |
386 | ||
387 | static int apm_emu_get_info(char *buf, char **start, off_t fpos, int length) | |
388 | { | |
389 | /* Arguments, with symbols from linux/apm_bios.h. Information is | |
390 | from the Get Power Status (0x0a) call unless otherwise noted. | |
391 | ||
392 | 0) Linux driver version (this will change if format changes) | |
393 | 1) APM BIOS Version. Usually 1.0, 1.1 or 1.2. | |
394 | 2) APM flags from APM Installation Check (0x00): | |
395 | bit 0: APM_16_BIT_SUPPORT | |
396 | bit 1: APM_32_BIT_SUPPORT | |
397 | bit 2: APM_IDLE_SLOWS_CLOCK | |
398 | bit 3: APM_BIOS_DISABLED | |
399 | bit 4: APM_BIOS_DISENGAGED | |
400 | 3) AC line status | |
401 | 0x00: Off-line | |
402 | 0x01: On-line | |
403 | 0x02: On backup power (BIOS >= 1.1 only) | |
404 | 0xff: Unknown | |
405 | 4) Battery status | |
406 | 0x00: High | |
407 | 0x01: Low | |
408 | 0x02: Critical | |
409 | 0x03: Charging | |
410 | 0x04: Selected battery not present (BIOS >= 1.2 only) | |
411 | 0xff: Unknown | |
412 | 5) Battery flag | |
413 | bit 0: High | |
414 | bit 1: Low | |
415 | bit 2: Critical | |
416 | bit 3: Charging | |
417 | bit 7: No system battery | |
418 | 0xff: Unknown | |
419 | 6) Remaining battery life (percentage of charge): | |
420 | 0-100: valid | |
421 | -1: Unknown | |
422 | 7) Remaining battery life (time units): | |
423 | Number of remaining minutes or seconds | |
424 | -1: Unknown | |
425 | 8) min = minutes; sec = seconds */ | |
426 | ||
08124f95 OH |
427 | unsigned short ac_line_status; |
428 | unsigned short battery_status = 0; | |
1da177e4 LT |
429 | unsigned short battery_flag = 0xff; |
430 | int percentage = -1; | |
431 | int time_units = -1; | |
432 | int real_count = 0; | |
433 | int i; | |
434 | char * p = buf; | |
435 | char charging = 0; | |
436 | long charge = -1; | |
437 | long amperage = 0; | |
438 | unsigned long btype = 0; | |
439 | ||
440 | ac_line_status = ((pmu_power_flags & PMU_PWR_AC_PRESENT) != 0); | |
441 | for (i=0; i<pmu_battery_count; i++) { | |
442 | if (pmu_batteries[i].flags & PMU_BATT_PRESENT) { | |
08124f95 | 443 | battery_status++; |
1da177e4 LT |
444 | if (percentage < 0) |
445 | percentage = 0; | |
446 | if (charge < 0) | |
447 | charge = 0; | |
448 | percentage += (pmu_batteries[i].charge * 100) / | |
449 | pmu_batteries[i].max_charge; | |
450 | charge += pmu_batteries[i].charge; | |
451 | amperage += pmu_batteries[i].amperage; | |
452 | if (btype == 0) | |
453 | btype = (pmu_batteries[i].flags & PMU_BATT_TYPE_MASK); | |
454 | real_count++; | |
455 | if ((pmu_batteries[i].flags & PMU_BATT_CHARGING)) | |
456 | charging++; | |
457 | } | |
458 | } | |
08124f95 OH |
459 | if (0 == battery_status) |
460 | ac_line_status = 1; | |
461 | battery_status = 0xff; | |
1da177e4 LT |
462 | if (real_count) { |
463 | if (amperage < 0) { | |
464 | if (btype == PMU_BATT_TYPE_SMART) | |
465 | time_units = (charge * 59) / (amperage * -1); | |
466 | else | |
467 | time_units = (charge * 16440) / (amperage * -60); | |
468 | } | |
469 | percentage /= real_count; | |
470 | if (charging > 0) { | |
471 | battery_status = 0x03; | |
472 | battery_flag = 0x08; | |
473 | } else if (percentage <= APM_CRITICAL) { | |
474 | battery_status = 0x02; | |
475 | battery_flag = 0x04; | |
476 | } else if (percentage <= APM_LOW) { | |
477 | battery_status = 0x01; | |
478 | battery_flag = 0x02; | |
479 | } else { | |
480 | battery_status = 0x00; | |
481 | battery_flag = 0x01; | |
482 | } | |
483 | } | |
484 | p += sprintf(p, "%s %d.%d 0x%02x 0x%02x 0x%02x 0x%02x %d%% %d %s\n", | |
485 | driver_version, | |
486 | (FAKE_APM_BIOS_VERSION >> 8) & 0xff, | |
487 | FAKE_APM_BIOS_VERSION & 0xff, | |
488 | 0, | |
489 | ac_line_status, | |
490 | battery_status, | |
491 | battery_flag, | |
492 | percentage, | |
493 | time_units, | |
494 | "min"); | |
495 | ||
496 | return p - buf; | |
497 | } | |
498 | ||
fa027c2a | 499 | static const struct file_operations apm_bios_fops = { |
1da177e4 LT |
500 | .owner = THIS_MODULE, |
501 | .read = do_read, | |
502 | .poll = do_poll, | |
503 | .ioctl = do_ioctl, | |
504 | .open = do_open, | |
505 | .release = do_release, | |
506 | }; | |
507 | ||
508 | static struct miscdevice apm_device = { | |
509 | APM_MINOR_DEV, | |
510 | "apm_bios", | |
511 | &apm_bios_fops | |
512 | }; | |
513 | ||
514 | static int __init apm_emu_init(void) | |
515 | { | |
516 | struct proc_dir_entry *apm_proc; | |
517 | ||
518 | if (sys_ctrler != SYS_CTRLER_PMU) { | |
519 | printk(KERN_INFO "apm_emu: Requires a machine with a PMU.\n"); | |
520 | return -ENODEV; | |
521 | } | |
522 | ||
523 | apm_proc = create_proc_info_entry("apm", 0, NULL, apm_emu_get_info); | |
524 | if (apm_proc) | |
525 | apm_proc->owner = THIS_MODULE; | |
526 | ||
5d469ec0 NH |
527 | if (misc_register(&apm_device) != 0) |
528 | printk(KERN_INFO "Could not create misc. device for apm\n"); | |
1da177e4 LT |
529 | |
530 | pmu_register_sleep_notifier(&apm_sleep_notifier); | |
531 | ||
532 | printk(KERN_INFO "apm_emu: APM Emulation %s initialized.\n", driver_version); | |
533 | ||
534 | return 0; | |
535 | } | |
536 | ||
537 | static void __exit apm_emu_exit(void) | |
538 | { | |
539 | pmu_unregister_sleep_notifier(&apm_sleep_notifier); | |
540 | misc_deregister(&apm_device); | |
541 | remove_proc_entry("apm", NULL); | |
542 | ||
543 | printk(KERN_INFO "apm_emu: APM Emulation removed.\n"); | |
544 | } | |
545 | ||
546 | module_init(apm_emu_init); | |
547 | module_exit(apm_emu_exit); | |
548 | ||
549 | MODULE_AUTHOR("Benjamin Herrenschmidt"); | |
550 | MODULE_DESCRIPTION("APM emulation layer for PowerMac"); | |
551 | MODULE_LICENSE("GPL"); | |
552 |