git.oblomov.eu Git - linux-2.6/blob - arch/arm/kernel/apm.c

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