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/mutex.h> 17 #include <linux/proc_fs.h> 18 #include <linux/seq_file.h> 19 #include <linux/miscdevice.h> 20 #include <linux/apm_bios.h> 21 #include <linux/capability.h> 22 #include <linux/sched.h> 23 #include <linux/suspend.h> 24 #include <linux/apm-emulation.h> 25 #include <linux/freezer.h> 26 #include <linux/device.h> 27 #include <linux/kernel.h> 28 #include <linux/list.h> 29 #include <linux/init.h> 30 #include <linux/completion.h> 31 #include <linux/kthread.h> 32 #include <linux/delay.h> 33 34 #include <asm/system.h> 35 36 /* 37 * The apm_bios device is one of the misc char devices. 38 * This is its minor number. 39 */ 40 #define APM_MINOR_DEV 134 41 42 /* 43 * See Documentation/Config.help for the configuration options. 44 * 45 * Various options can be changed at boot time as follows: 46 * (We allow underscores for compatibility with the modules code) 47 * apm=on/off enable/disable APM 48 */ 49 50 /* 51 * Maximum number of events stored 52 */ 53 #define APM_MAX_EVENTS 16 54 55 struct apm_queue { 56 unsigned int event_head; 57 unsigned int event_tail; 58 apm_event_t events[APM_MAX_EVENTS]; 59 }; 60 61 /* 62 * thread states (for threads using a writable /dev/apm_bios fd): 63 * 64 * SUSPEND_NONE: nothing happening 65 * SUSPEND_PENDING: suspend event queued for thread and pending to be read 66 * SUSPEND_READ: suspend event read, pending acknowledgement 67 * SUSPEND_ACKED: acknowledgement received from thread (via ioctl), 68 * waiting for resume 69 * SUSPEND_ACKTO: acknowledgement timeout 70 * SUSPEND_DONE: thread had acked suspend and is now notified of 71 * resume 72 * 73 * SUSPEND_WAIT: this thread invoked suspend and is waiting for resume 74 * 75 * A thread migrates in one of three paths: 76 * NONE -1-> PENDING -2-> READ -3-> ACKED -4-> DONE -5-> NONE 77 * -6-> ACKTO -7-> NONE 78 * NONE -8-> WAIT -9-> NONE 79 * 80 * While in PENDING or READ, the thread is accounted for in the 81 * suspend_acks_pending counter. 82 * 83 * The transitions are invoked as follows: 84 * 1: suspend event is signalled from the core PM code 85 * 2: the suspend event is read from the fd by the userspace thread 86 * 3: userspace thread issues the APM_IOC_SUSPEND ioctl (as ack) 87 * 4: core PM code signals that we have resumed 88 * 5: APM_IOC_SUSPEND ioctl returns 89 * 90 * 6: the notifier invoked from the core PM code timed out waiting 91 * for all relevant threds to enter ACKED state and puts those 92 * that haven't into ACKTO 93 * 7: those threads issue APM_IOC_SUSPEND ioctl too late, 94 * get an error 95 * 96 * 8: userspace thread issues the APM_IOC_SUSPEND ioctl (to suspend), 97 * ioctl code invokes pm_suspend() 98 * 9: pm_suspend() returns indicating resume 99 */ 100 enum apm_suspend_state { 101 SUSPEND_NONE, 102 SUSPEND_PENDING, 103 SUSPEND_READ, 104 SUSPEND_ACKED, 105 SUSPEND_ACKTO, 106 SUSPEND_WAIT, 107 SUSPEND_DONE, 108 }; 109 110 /* 111 * The per-file APM data 112 */ 113 struct apm_user { 114 struct list_head list; 115 116 unsigned int suser: 1; 117 unsigned int writer: 1; 118 unsigned int reader: 1; 119 120 int suspend_result; 121 enum apm_suspend_state suspend_state; 122 123 struct apm_queue queue; 124 }; 125 126 /* 127 * Local variables 128 */ 129 static DEFINE_MUTEX(apm_mutex); 130 static atomic_t suspend_acks_pending = ATOMIC_INIT(0); 131 static atomic_t userspace_notification_inhibit = ATOMIC_INIT(0); 132 static int apm_disabled; 133 static struct task_struct *kapmd_tsk; 134 135 static DECLARE_WAIT_QUEUE_HEAD(apm_waitqueue); 136 static DECLARE_WAIT_QUEUE_HEAD(apm_suspend_waitqueue); 137 138 /* 139 * This is a list of everyone who has opened /dev/apm_bios 140 */ 141 static DECLARE_RWSEM(user_list_lock); 142 static LIST_HEAD(apm_user_list); 143 144 /* 145 * kapmd info. kapmd provides us a process context to handle 146 * "APM" events within - specifically necessary if we're going 147 * to be suspending the system. 148 */ 149 static DECLARE_WAIT_QUEUE_HEAD(kapmd_wait); 150 static DEFINE_SPINLOCK(kapmd_queue_lock); 151 static struct apm_queue kapmd_queue; 152 153 static DEFINE_MUTEX(state_lock); 154 155 static const char driver_version[] = "1.13"; /* no spaces */ 156 157 158 159 /* 160 * Compatibility cruft until the IPAQ people move over to the new 161 * interface. 162 */ 163 static void __apm_get_power_status(struct apm_power_info *info) 164 { 165 } 166 167 /* 168 * This allows machines to provide their own "apm get power status" function. 169 */ 170 void (*apm_get_power_status)(struct apm_power_info *) = __apm_get_power_status; 171 EXPORT_SYMBOL(apm_get_power_status); 172 173 174 /* 175 * APM event queue management. 176 */ 177 static inline int queue_empty(struct apm_queue *q) 178 { 179 return q->event_head == q->event_tail; 180 } 181 182 static inline apm_event_t queue_get_event(struct apm_queue *q) 183 { 184 q->event_tail = (q->event_tail + 1) % APM_MAX_EVENTS; 185 return q->events[q->event_tail]; 186 } 187 188 static void queue_add_event(struct apm_queue *q, apm_event_t event) 189 { 190 q->event_head = (q->event_head + 1) % APM_MAX_EVENTS; 191 if (q->event_head == q->event_tail) { 192 static int notified; 193 194 if (notified++ == 0) 195 printk(KERN_ERR "apm: an event queue overflowed\n"); 196 q->event_tail = (q->event_tail + 1) % APM_MAX_EVENTS; 197 } 198 q->events[q->event_head] = event; 199 } 200 201 static void queue_event(apm_event_t event) 202 { 203 struct apm_user *as; 204 205 down_read(&user_list_lock); 206 list_for_each_entry(as, &apm_user_list, list) { 207 if (as->reader) 208 queue_add_event(&as->queue, event); 209 } 210 up_read(&user_list_lock); 211 wake_up_interruptible(&apm_waitqueue); 212 } 213 214 static ssize_t apm_read(struct file *fp, char __user *buf, size_t count, loff_t *ppos) 215 { 216 struct apm_user *as = fp->private_data; 217 apm_event_t event; 218 int i = count, ret = 0; 219 220 if (count < sizeof(apm_event_t)) 221 return -EINVAL; 222 223 if (queue_empty(&as->queue) && fp->f_flags & O_NONBLOCK) 224 return -EAGAIN; 225 226 wait_event_interruptible(apm_waitqueue, !queue_empty(&as->queue)); 227 228 while ((i >= sizeof(event)) && !queue_empty(&as->queue)) { 229 event = queue_get_event(&as->queue); 230 231 ret = -EFAULT; 232 if (copy_to_user(buf, &event, sizeof(event))) 233 break; 234 235 mutex_lock(&state_lock); 236 if (as->suspend_state == SUSPEND_PENDING && 237 (event == APM_SYS_SUSPEND || event == APM_USER_SUSPEND)) 238 as->suspend_state = SUSPEND_READ; 239 mutex_unlock(&state_lock); 240 241 buf += sizeof(event); 242 i -= sizeof(event); 243 } 244 245 if (i < count) 246 ret = count - i; 247 248 return ret; 249 } 250 251 static unsigned int apm_poll(struct file *fp, poll_table * wait) 252 { 253 struct apm_user *as = fp->private_data; 254 255 poll_wait(fp, &apm_waitqueue, wait); 256 return queue_empty(&as->queue) ? 0 : POLLIN | POLLRDNORM; 257 } 258 259 /* 260 * apm_ioctl - handle APM ioctl 261 * 262 * APM_IOC_SUSPEND 263 * This IOCTL is overloaded, and performs two functions. It is used to: 264 * - initiate a suspend 265 * - acknowledge a suspend read from /dev/apm_bios. 266 * Only when everyone who has opened /dev/apm_bios with write permission 267 * has acknowledge does the actual suspend happen. 268 */ 269 static long 270 apm_ioctl(struct file *filp, u_int cmd, u_long arg) 271 { 272 struct apm_user *as = filp->private_data; 273 int err = -EINVAL; 274 275 if (!as->suser || !as->writer) 276 return -EPERM; 277 278 mutex_lock(&apm_mutex); 279 switch (cmd) { 280 case APM_IOC_SUSPEND: 281 mutex_lock(&state_lock); 282 283 as->suspend_result = -EINTR; 284 285 switch (as->suspend_state) { 286 case SUSPEND_READ: 287 /* 288 * If we read a suspend command from /dev/apm_bios, 289 * then the corresponding APM_IOC_SUSPEND ioctl is 290 * interpreted as an acknowledge. 291 */ 292 as->suspend_state = SUSPEND_ACKED; 293 atomic_dec(&suspend_acks_pending); 294 mutex_unlock(&state_lock); 295 296 /* 297 * suspend_acks_pending changed, the notifier needs to 298 * be woken up for this 299 */ 300 wake_up(&apm_suspend_waitqueue); 301 302 /* 303 * Wait for the suspend/resume to complete. If there 304 * are pending acknowledges, we wait here for them. 305 */ 306 freezer_do_not_count(); 307 308 wait_event(apm_suspend_waitqueue, 309 as->suspend_state == SUSPEND_DONE); 310 311 /* 312 * Since we are waiting until the suspend is done, the 313 * try_to_freeze() in freezer_count() will not trigger 314 */ 315 freezer_count(); 316 break; 317 case SUSPEND_ACKTO: 318 as->suspend_result = -ETIMEDOUT; 319 mutex_unlock(&state_lock); 320 break; 321 default: 322 as->suspend_state = SUSPEND_WAIT; 323 mutex_unlock(&state_lock); 324 325 /* 326 * Otherwise it is a request to suspend the system. 327 * Just invoke pm_suspend(), we'll handle it from 328 * there via the notifier. 329 */ 330 as->suspend_result = pm_suspend(PM_SUSPEND_MEM); 331 } 332 333 mutex_lock(&state_lock); 334 err = as->suspend_result; 335 as->suspend_state = SUSPEND_NONE; 336 mutex_unlock(&state_lock); 337 break; 338 } 339 mutex_unlock(&apm_mutex); 340 341 return err; 342 } 343 344 static int apm_release(struct inode * inode, struct file * filp) 345 { 346 struct apm_user *as = filp->private_data; 347 348 filp->private_data = NULL; 349 350 down_write(&user_list_lock); 351 list_del(&as->list); 352 up_write(&user_list_lock); 353 354 /* 355 * We are now unhooked from the chain. As far as new 356 * events are concerned, we no longer exist. 357 */ 358 mutex_lock(&state_lock); 359 if (as->suspend_state == SUSPEND_PENDING || 360 as->suspend_state == SUSPEND_READ) 361 atomic_dec(&suspend_acks_pending); 362 mutex_unlock(&state_lock); 363 364 wake_up(&apm_suspend_waitqueue); 365 366 kfree(as); 367 return 0; 368 } 369 370 static int apm_open(struct inode * inode, struct file * filp) 371 { 372 struct apm_user *as; 373 374 mutex_lock(&apm_mutex); 375 as = kzalloc(sizeof(*as), GFP_KERNEL); 376 if (as) { 377 /* 378 * XXX - this is a tiny bit broken, when we consider BSD 379 * process accounting. If the device is opened by root, we 380 * instantly flag that we used superuser privs. Who knows, 381 * we might close the device immediately without doing a 382 * privileged operation -- cevans 383 */ 384 as->suser = capable(CAP_SYS_ADMIN); 385 as->writer = (filp->f_mode & FMODE_WRITE) == FMODE_WRITE; 386 as->reader = (filp->f_mode & FMODE_READ) == FMODE_READ; 387 388 down_write(&user_list_lock); 389 list_add(&as->list, &apm_user_list); 390 up_write(&user_list_lock); 391 392 filp->private_data = as; 393 } 394 mutex_unlock(&apm_mutex); 395 396 return as ? 0 : -ENOMEM; 397 } 398 399 static const struct file_operations apm_bios_fops = { 400 .owner = THIS_MODULE, 401 .read = apm_read, 402 .poll = apm_poll, 403 .unlocked_ioctl = apm_ioctl, 404 .open = apm_open, 405 .release = apm_release, 406 }; 407 408 static struct miscdevice apm_device = { 409 .minor = APM_MINOR_DEV, 410 .name = "apm_bios", 411 .fops = &apm_bios_fops 412 }; 413 414 415 #ifdef CONFIG_PROC_FS 416 /* 417 * Arguments, with symbols from linux/apm_bios.h. 418 * 419 * 0) Linux driver version (this will change if format changes) 420 * 1) APM BIOS Version. Usually 1.0, 1.1 or 1.2. 421 * 2) APM flags from APM Installation Check (0x00): 422 * bit 0: APM_16_BIT_SUPPORT 423 * bit 1: APM_32_BIT_SUPPORT 424 * bit 2: APM_IDLE_SLOWS_CLOCK 425 * bit 3: APM_BIOS_DISABLED 426 * bit 4: APM_BIOS_DISENGAGED 427 * 3) AC line status 428 * 0x00: Off-line 429 * 0x01: On-line 430 * 0x02: On backup power (BIOS >= 1.1 only) 431 * 0xff: Unknown 432 * 4) Battery status 433 * 0x00: High 434 * 0x01: Low 435 * 0x02: Critical 436 * 0x03: Charging 437 * 0x04: Selected battery not present (BIOS >= 1.2 only) 438 * 0xff: Unknown 439 * 5) Battery flag 440 * bit 0: High 441 * bit 1: Low 442 * bit 2: Critical 443 * bit 3: Charging 444 * bit 7: No system battery 445 * 0xff: Unknown 446 * 6) Remaining battery life (percentage of charge): 447 * 0-100: valid 448 * -1: Unknown 449 * 7) Remaining battery life (time units): 450 * Number of remaining minutes or seconds 451 * -1: Unknown 452 * 8) min = minutes; sec = seconds 453 */ 454 static int proc_apm_show(struct seq_file *m, void *v) 455 { 456 struct apm_power_info info; 457 char *units; 458 459 info.ac_line_status = 0xff; 460 info.battery_status = 0xff; 461 info.battery_flag = 0xff; 462 info.battery_life = -1; 463 info.time = -1; 464 info.units = -1; 465 466 if (apm_get_power_status) 467 apm_get_power_status(&info); 468 469 switch (info.units) { 470 default: units = "?"; break; 471 case 0: units = "min"; break; 472 case 1: units = "sec"; break; 473 } 474 475 seq_printf(m, "%s 1.2 0x%02x 0x%02x 0x%02x 0x%02x %d%% %d %s\n", 476 driver_version, APM_32_BIT_SUPPORT, 477 info.ac_line_status, info.battery_status, 478 info.battery_flag, info.battery_life, 479 info.time, units); 480 481 return 0; 482 } 483 484 static int proc_apm_open(struct inode *inode, struct file *file) 485 { 486 return single_open(file, proc_apm_show, NULL); 487 } 488 489 static const struct file_operations apm_proc_fops = { 490 .owner = THIS_MODULE, 491 .open = proc_apm_open, 492 .read = seq_read, 493 .llseek = seq_lseek, 494 .release = single_release, 495 }; 496 #endif 497 498 static int kapmd(void *arg) 499 { 500 do { 501 apm_event_t event; 502 503 wait_event_interruptible(kapmd_wait, 504 !queue_empty(&kapmd_queue) || kthread_should_stop()); 505 506 if (kthread_should_stop()) 507 break; 508 509 spin_lock_irq(&kapmd_queue_lock); 510 event = 0; 511 if (!queue_empty(&kapmd_queue)) 512 event = queue_get_event(&kapmd_queue); 513 spin_unlock_irq(&kapmd_queue_lock); 514 515 switch (event) { 516 case 0: 517 break; 518 519 case APM_LOW_BATTERY: 520 case APM_POWER_STATUS_CHANGE: 521 queue_event(event); 522 break; 523 524 case APM_USER_SUSPEND: 525 case APM_SYS_SUSPEND: 526 pm_suspend(PM_SUSPEND_MEM); 527 break; 528 529 case APM_CRITICAL_SUSPEND: 530 atomic_inc(&userspace_notification_inhibit); 531 pm_suspend(PM_SUSPEND_MEM); 532 atomic_dec(&userspace_notification_inhibit); 533 break; 534 } 535 } while (1); 536 537 return 0; 538 } 539 540 static int apm_suspend_notifier(struct notifier_block *nb, 541 unsigned long event, 542 void *dummy) 543 { 544 struct apm_user *as; 545 int err; 546 547 /* short-cut emergency suspends */ 548 if (atomic_read(&userspace_notification_inhibit)) 549 return NOTIFY_DONE; 550 551 switch (event) { 552 case PM_SUSPEND_PREPARE: 553 /* 554 * Queue an event to all "writer" users that we want 555 * to suspend and need their ack. 556 */ 557 mutex_lock(&state_lock); 558 down_read(&user_list_lock); 559 560 list_for_each_entry(as, &apm_user_list, list) { 561 if (as->suspend_state != SUSPEND_WAIT && as->reader && 562 as->writer && as->suser) { 563 as->suspend_state = SUSPEND_PENDING; 564 atomic_inc(&suspend_acks_pending); 565 queue_add_event(&as->queue, APM_USER_SUSPEND); 566 } 567 } 568 569 up_read(&user_list_lock); 570 mutex_unlock(&state_lock); 571 wake_up_interruptible(&apm_waitqueue); 572 573 /* 574 * Wait for the the suspend_acks_pending variable to drop to 575 * zero, meaning everybody acked the suspend event (or the 576 * process was killed.) 577 * 578 * If the app won't answer within a short while we assume it 579 * locked up and ignore it. 580 */ 581 err = wait_event_interruptible_timeout( 582 apm_suspend_waitqueue, 583 atomic_read(&suspend_acks_pending) == 0, 584 5*HZ); 585 586 /* timed out */ 587 if (err == 0) { 588 /* 589 * Move anybody who timed out to "ack timeout" state. 590 * 591 * We could time out and the userspace does the ACK 592 * right after we time out but before we enter the 593 * locked section here, but that's fine. 594 */ 595 mutex_lock(&state_lock); 596 down_read(&user_list_lock); 597 list_for_each_entry(as, &apm_user_list, list) { 598 if (as->suspend_state == SUSPEND_PENDING || 599 as->suspend_state == SUSPEND_READ) { 600 as->suspend_state = SUSPEND_ACKTO; 601 atomic_dec(&suspend_acks_pending); 602 } 603 } 604 up_read(&user_list_lock); 605 mutex_unlock(&state_lock); 606 } 607 608 /* let suspend proceed */ 609 if (err >= 0) 610 return NOTIFY_OK; 611 612 /* interrupted by signal */ 613 return NOTIFY_BAD; 614 615 case PM_POST_SUSPEND: 616 /* 617 * Anyone on the APM queues will think we're still suspended. 618 * Send a message so everyone knows we're now awake again. 619 */ 620 queue_event(APM_NORMAL_RESUME); 621 622 /* 623 * Finally, wake up anyone who is sleeping on the suspend. 624 */ 625 mutex_lock(&state_lock); 626 down_read(&user_list_lock); 627 list_for_each_entry(as, &apm_user_list, list) { 628 if (as->suspend_state == SUSPEND_ACKED) { 629 /* 630 * TODO: maybe grab error code, needs core 631 * changes to push the error to the notifier 632 * chain (could use the second parameter if 633 * implemented) 634 */ 635 as->suspend_result = 0; 636 as->suspend_state = SUSPEND_DONE; 637 } 638 } 639 up_read(&user_list_lock); 640 mutex_unlock(&state_lock); 641 642 wake_up(&apm_suspend_waitqueue); 643 return NOTIFY_OK; 644 645 default: 646 return NOTIFY_DONE; 647 } 648 } 649 650 static struct notifier_block apm_notif_block = { 651 .notifier_call = apm_suspend_notifier, 652 }; 653 654 static int __init apm_init(void) 655 { 656 int ret; 657 658 if (apm_disabled) { 659 printk(KERN_NOTICE "apm: disabled on user request.\n"); 660 return -ENODEV; 661 } 662 663 kapmd_tsk = kthread_create(kapmd, NULL, "kapmd"); 664 if (IS_ERR(kapmd_tsk)) { 665 ret = PTR_ERR(kapmd_tsk); 666 kapmd_tsk = NULL; 667 goto out; 668 } 669 wake_up_process(kapmd_tsk); 670 671 #ifdef CONFIG_PROC_FS 672 proc_create("apm", 0, NULL, &apm_proc_fops); 673 #endif 674 675 ret = misc_register(&apm_device); 676 if (ret) 677 goto out_stop; 678 679 ret = register_pm_notifier(&apm_notif_block); 680 if (ret) 681 goto out_unregister; 682 683 return 0; 684 685 out_unregister: 686 misc_deregister(&apm_device); 687 out_stop: 688 remove_proc_entry("apm", NULL); 689 kthread_stop(kapmd_tsk); 690 out: 691 return ret; 692 } 693 694 static void __exit apm_exit(void) 695 { 696 unregister_pm_notifier(&apm_notif_block); 697 misc_deregister(&apm_device); 698 remove_proc_entry("apm", NULL); 699 700 kthread_stop(kapmd_tsk); 701 } 702 703 module_init(apm_init); 704 module_exit(apm_exit); 705 706 MODULE_AUTHOR("Stephen Rothwell"); 707 MODULE_DESCRIPTION("Advanced Power Management"); 708 MODULE_LICENSE("GPL"); 709 710 #ifndef MODULE 711 static int __init apm_setup(char *str) 712 { 713 while ((str != NULL) && (*str != '\0')) { 714 if (strncmp(str, "off", 3) == 0) 715 apm_disabled = 1; 716 if (strncmp(str, "on", 2) == 0) 717 apm_disabled = 0; 718 str = strchr(str, ','); 719 if (str != NULL) 720 str += strspn(str, ", \t"); 721 } 722 return 1; 723 } 724 725 __setup("apm=", apm_setup); 726 #endif 727 728 /** 729 * apm_queue_event - queue an APM event for kapmd 730 * @event: APM event 731 * 732 * Queue an APM event for kapmd to process and ultimately take the 733 * appropriate action. Only a subset of events are handled: 734 * %APM_LOW_BATTERY 735 * %APM_POWER_STATUS_CHANGE 736 * %APM_USER_SUSPEND 737 * %APM_SYS_SUSPEND 738 * %APM_CRITICAL_SUSPEND 739 */ 740 void apm_queue_event(apm_event_t event) 741 { 742 unsigned long flags; 743 744 spin_lock_irqsave(&kapmd_queue_lock, flags); 745 queue_add_event(&kapmd_queue, event); 746 spin_unlock_irqrestore(&kapmd_queue_lock, flags); 747 748 wake_up_interruptible(&kapmd_wait); 749 } 750 EXPORT_SYMBOL(apm_queue_event); 751