Annotation of kernel/kern/power.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
                      3:  *
                      4:  * @APPLE_LICENSE_HEADER_START@
                      5:  * 
                      6:  * Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
                      7:  * Reserved.  This file contains Original Code and/or Modifications of
                      8:  * Original Code as defined in and that are subject to the Apple Public
                      9:  * Source License Version 1.1 (the "License").  You may not use this file
                     10:  * except in compliance with the License.  Please obtain a copy of the
                     11:  * License at http://www.apple.com/publicsource and read it before using
                     12:  * this file.
                     13:  * 
                     14:  * The Original Code and all software distributed under the License are
                     15:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
                     16:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
                     17:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
                     18:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
                     19:  * License for the specific language governing rights and limitations
                     20:  * under the License.
                     21:  * 
                     22:  * @APPLE_LICENSE_HEADER_END@
                     23:  */
                     24: 
                     25: /*
                     26:  * Copyright 1994 NeXT Computer, Inc.
                     27:  * All rights reserved.
                     28:  */
                     29: 
                     30: #import <mach/mach_types.h>
                     31: #import <kern/power.h>
                     32: #import <kern/thread_call.h>
                     33: 
                     34: /*
                     35:  * Power Management (PM) callout function.
                     36:  */
                     37: 
                     38: #define CYCLE_TIME     ((tvalspec_t) { 1, 10000000 } ) /* 1.01 seconds */
                     39: 
                     40: static PMPowerState systemState;
                     41: 
                     42: static PMReturn
                     43: get_power_event(PMPowerEvent *ev_p)
                     44: {
                     45:     PMPowerEvent event;
                     46:     PMReturn ret;
                     47:     
                     48:     if ((ret = PMGetPowerEvent(&event)) == PM_R_SUCCESS) {
                     49:        switch (event) {
                     50:        case PM_STANDBY_REQUEST:
                     51:        case PM_USER_STANDBY_REQUEST:
                     52:            systemState = PM_STANDBY;
                     53:            PMSetPowerState(PM_SYSTEM_DEVICE, PM_STANDBY);
                     54:            break;
                     55:        case PM_CRITICAL_SUSPEND:
                     56:        case PM_SUSPEND_REQUEST:
                     57:        case PM_USER_SUSPEND_REQUEST:
                     58:            systemState = PM_SUSPENDED;
                     59:            PMSetPowerState(PM_SYSTEM_DEVICE, PM_SUSPENDED);
                     60:            systemState = PM_READY;
                     61:            PMSetPowerState(PM_SYSTEM_DEVICE, PM_READY);
                     62:            break;
                     63:        case PM_NORMAL_RESUME:
                     64:        case PM_CRITICAL_RESUME:
                     65:        case PM_STANDBY_RESUME:
                     66:            if (systemState != PM_READY) {
                     67:                systemState = PM_READY;
                     68:                PMSetPowerState(PM_SYSTEM_DEVICE, PM_READY);
                     69:            }
                     70:            /* fall through to update time */
                     71:        case PM_UPDATE_TIME:
                     72:            /* Must read time from RTC */
                     73:            PMUpdateClock();
                     74:            break;
                     75:        case PM_BATTERY_LOW:
                     76:        case PM_POWER_STATUS_CHANGE:
                     77:            break;
                     78:        }
                     79:        if (ev_p)
                     80:            *ev_p = event;
                     81:     }
                     82:     return ret;
                     83: }
                     84: 
                     85: void
                     86: power_callout(
                     87:     thread_call_spec_t argument,
                     88:     thread_call_t      callout
                     89: )
                     90: {
                     91:     PMPowerEvent event;
                     92:     
                     93:     get_power_event(0);
                     94:     if (callout == 0)
                     95:        callout = thread_call_allocate(power_callout, 0);
                     96:        
                     97:     thread_call_enter_delayed(callout, deadline_from_interval(CYCLE_TIME));
                     98: }
                     99: 
                    100: void
                    101: power_init()
                    102: {
                    103:     kern_return_t      result;
                    104:     static boolean_t   initialized = FALSE;
                    105:     
                    106:     if (initialized == FALSE) {
                    107:        if (PMConnect() == PM_R_SUCCESS)
                    108:            (void) power_callout(0, 0);
                    109:        
                    110:        systemState = PM_READY;
                    111:        initialized = TRUE;
                    112:     }
                    113: }
                    114: 
                    115: 
                    116: /*
                    117:  * Kernel server side of power management MIG interface.
                    118:  */
                    119: 
                    120: kern_return_t
                    121: kern_PMSetPowerState(
                    122:     host_t             host,
                    123:     PMDeviceID                 device,
                    124:     PMPowerState       state
                    125: )
                    126: {
                    127:     if (host != &realhost)
                    128:        return KERN_INVALID_HOST;
                    129: 
                    130:     return PMSetPowerState(device, state);
                    131: }
                    132: 
                    133: kern_return_t
                    134: kern_PMGetPowerEvent(
                    135:     host_t             host,
                    136:     PMPowerEvent       *event
                    137: )
                    138: {
                    139:     if (host != &realhost)
                    140:        return KERN_INVALID_HOST;
                    141: 
                    142:     return get_power_event(event);
                    143: }
                    144: 
                    145: kern_return_t
                    146: kern_PMGetPowerStatus(
                    147:     host_t             host,
                    148:     PMPowerStatus      *status
                    149: )
                    150: {
                    151:     if (host != &realhost)
                    152:        return KERN_INVALID_HOST;
                    153: 
                    154:     return PMGetPowerStatus(status);
                    155: }
                    156: 
                    157: kern_return_t
                    158: kern_PMSetPowerManagement(
                    159:     host_t             host,
                    160:     PMDeviceID         device,
                    161:     PMPowerManagementState
                    162:                        state
                    163: )
                    164: {
                    165:     if (host != &realhost)
                    166:        return KERN_INVALID_HOST;
                    167: 
                    168:     return PMSetPowerManagement(device, state);
                    169: }
                    170: 
                    171: kern_return_t
                    172: kern_PMRestoreDefaults(
                    173:     host_t             host
                    174: )
                    175: {
                    176:     if (host != &realhost)
                    177:        return KERN_INVALID_HOST;
                    178: 
                    179:     return PMRestoreDefaults();
                    180: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.