Return to power.c CVS log

Up to [Apple Darwin 0.x] / kernel / kern

Annotation of kernel/kern/power.c, revision 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: }

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