![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOServicePM.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Kernel|
Return to IOServicePM.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Kernel |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: #include <IOKit/IOService.h>
23: #include <IOKit/IOLib.h>
24: #include <IOKit/IOCommandQueue.h>
25: #include <IOKit/IOTimerEventSource.h>
26: #include <IOKit/IOWorkLoop.h>
27: #include <IOKit/IOPlatformExpert.h>
28: #include <IOKit/assert.h>
29: #include "IOKit/pwr_mgt/IOPMpmChild.h"
30: #include "IOKit/pwr_mgt/IOPMinformeeList.h"
31: #include "IOKit/pwr_mgt/IOPMchangeNoteList.h"
32: #include "IOKit/pwr_mgt/IOPMlog.h"
33:
34: static void ack_timer_expired(thread_call_param_t, thread_call_param_t);
35: static void settle_timer_expired(thread_call_param_t, thread_call_param_t);
36: void PMreceiveCmd ( OSObject *, void *, void *, void *, void * );
37: static void PM_idle_timer_expired(OSObject *, IOTimerEventSource *);
38:
39: extern const IORegistryPlane * gIOPowerPlane;
40:
41:
42: // and there's 1000 nanosecons in a microsecond:
43: #define ns_per_us 1000
44:
45:
46: // The current change note is processed by a state machine.
47: // Inputs are acks from interested parties, ack from the controlling driver,
48: // ack timeouts, settle timeout, and powerStateDidChange from the parent.
49: // These are the states:
50:
51: #define IOPMour_prechange_1 1
52: #define IOPMour_prechange_2 2
53: #define IOPMour_prechange_3 3
54: #define IOPMour_prechange_4 4
55: #define IOPMparent_prechange_down_3 5
56: #define IOPMparent_prechange_down_4 6
57: #define IOPMparent_prechange_down_5 7
58: #define IOPMparent_postchange_down_1 8
59: #define IOPMparent_postchange_down_2 9
60: #define IOPMparent_prechange_up_1 10
61: #define IOPMparent_postchange_up_1 11
62: #define IOPMparent_postchange_up_4 12
63: #define IOPMparent_postchange_up_5 13
64: #define IOPMparent_postchange_up_6 14
65: #define IOPMparent_postchange_null 15
66: #define IOPMfinished 16
67:
68: /*
69: There are two different kinds of power state changes. One is initiated by a subclassed device object which has either
70: decided to change power state, or its controlling driver has suggested it, or some other driver wants to use the
71: idle device and has asked it to become usable. The second kind of power state change is initiated by the power
72: domain parent. The two are handled slightly differently.
73:
74: There is a queue of so-called change notifications, or change notes for short. Usually the queue is empty, and when
75: it isn't, usually there is one change note in it, but since it's possible to have more than one power state change pending
76: at one time, a queue is implemented. Example: the subclass device decides it's idle and initiates a change to a lower
77: power state. This causes interested parties to be notified, but they don't all acknowledge right away. This causes the
78: change note to sit in the queue until all the acks are received. During this time, the device decides it isn't idle anymore and
79: wants to raise power back up again. This change can't be started, however, because the previous one isn't complete yet,
80: so the second one waits in the queue. During this time, the parent decides to lower or raise the power state of the entire
81: power domain and notifies the device, and that notification goes into the queue, too, and can't be actioned until the
82: others are.
83:
84: This is how a power change initiated by the subclass device is handled:
85: First, all interested parties are notified of the change via their powerStateWillChangeTo method. If they all don't
86: acknowledge via return code, then we have to wait. If they do, or when they finally all acknowledge via our
87: acknowledgePowerChange method, then we can continue. We call the controlling driver, instructing it to change to
88: the new state. Then we wait for power to settle. If there is no settling-time, or after it has passed, we notify
89: interested parties again, this time via their powerStateDidChangeTo methods. When they have all acked, we're done.
90: If we lowered power and don't need the power domain to be in its current power state, we suggest to the parent that
91: it lower the power domain state.
92:
93: This is how a change to a lower power domain state initiated by the parent is handled:
94: First, we figure out what power state we will be in when the new domain state is reached. Then all interested parties are
95: notified that we are moving to that new state. When they have acknowledged, we call the controlling driver to assume
96: that state and we wait for power to settle. Then we acknowledge our preparedness to our parent. When all its interested
97: parties have acknowledged, it lowers power and then notifies its interested parties again. When we get this call, we notify
98: our interested parties that the power state has changed, and when they have all acknowledged, we're done.
99:
100: This is how a change to a higher power domain state initiated by the parent is handled:
101: We figure out what power state we will be in when the new domain state is reached. If it is different from our current
102: state we notify all our interested parties. When they have all acknowledged, we acknowledge the parent. When all the
103: parent's interested parties have acknowledged, it raises power in the domain and waits for power to settle. Then it
104: notifies everyone that the new state has been reached. When we get this call, we call the controlling driver, instructing it
105: to assume the new state, and wait for power to settle. Then we notify our interested parties. When they all acknowledge
106: we are done.
107:
108: In either of the two cases above, it is possible that we will not be changing state even though the domain is. Examples:
109: A change to a lower domain state may not affect us because we are already in a low enough state, and
110: We will not take advantage of a change to a higher domain state, because we have no need of the higher power.
111: In such a case, there is nothing to do but acknowledge the parent. So when the parent calls our powerDomainWillChange
112: method, and we decide that we will not be changing state, we merely acknowledge the parent, via return code, and wait.
113: When the parent subsequently calls powerStateDidChange, we acknowledge again via return code, and the change is complete.
114:
115: Power state changes are processed in a state machine, and since there are four varieties of power state changes, there are
116: four major paths through the state machine:
117:
118: The fourth is nearly trivial. In this path, the parent is changing the domain state, but we are not changing the device state.
119: The change starts when the parent calls powerDomainWillChange. All we do is acknowledge the parent and enter the "IOPMparent_postchange" state. We wait there until the parent calls powerStateDidChange. Then we acknowledge the parent
120: again, and we're done.
121:
122: The first is fairly simple. It starts when a power domain child calls requestDomainState and we decide to change power states
123: to accomodate the child, or if our power-controlling driver calls changeStateTo, or if some other driver which is using our
124: device calls makeUsable, or if a subclassed object calls changeStateToPriv. These are all power changes initiated by us, not
125: forced upon us by the parent. We start by notifying interested parties. If they all acknowledge via return code, we can go
126: on to state "our_prechange_1". Otherwise, we start the ack timer and wait for the stragglers to acknowlege by calling
127: acknowledgePowerChange. We move on to state "our_prechange_1" when all the stragglers have acknowledged,
128: or when the ack timer expires on all those which didn't acknowledge. In "our_prechange_1" we call the power-controlling
129: driver to change the power state of the hardware. If it returns saying it has done so, we go on to state "our_prechange_2".
130: Otherwise, we have to wait for it, so we set the ack timer and wait. When it calls acknowledgeSetPowerState, or when the
131: ack timer expires, we go on. In "our_prechange_2", we look in the power state array to see if there is any settle time required
132: when changing from our current state to the new state. If not, we go right away to "our_prechange_3". Otherwise, we
133: set the settle timer and wait. When it expires, we move on. In "our_prechange_3" state, we notify all our interested parties
134: via their powerStateDidChange methods that we have finished changing power state. If they all acknowledge via return
135: code, we move on to "our_prechange_4". Otherwise we set the ack timer and wait. When they have all acknowledged, or
136: when the ack timer has expired for those that didn't, we move on to "our_prechange_4", where we remove the used
137: change note from the head of the queue and start the next one if one exists.
138:
139: Parent-initiated changes are more complex in the state machine. First, power going up and power going down are handled
140: differently, so they have different paths throught the state machine. Second, we can acknowledge the parent's notification
141: in two different ways, so each of the parent paths is really two.
142:
143: When the parent calls our powerDomainWillChange method, notifying us that it will lower power in the domain, we decide
144: what state that will put our device in. Then we embark on the state machine path "IOPMparent_prechange_down_1"
145: and "IOPMparent_prechange_down_2", in which we notify interested parties of the upcoming change,
146: instruct our driver to make the change, and check for settle time. If we get to the end of this path without
147: stalling due to an interested party which didn't acknowledge via return code, due to the controlling driver not able to change
148: state right away, or due to a non-zero settling time, then we return IOPMAckImplied to the parent and enter
149: "IOPMparent_postchange_down_1". If we do stall in any of those states, we return IOPMWillAckLater to the parent
150: and enter the parallel path "IOPMparent_prechange_down_4", "IOPMparent_prechange_down_5", and "IOPMparent_prechange_down_3", where we continue with the same processing, except that at the end we
151: acknowledge the parent explicitly via acknowledgePowerChange and enter "IOPMparent_postchange_down_1".
152: In "IOPMparent_postchange_down_1" we wait for the parent to lower power in the domain. When it calls us at
153: powerStateDidChange, we notify all our interested parties of the new power state. If they all acknowledge via return
154: code, we return to the parent, also acknowledging via return code. Otherwise we enter "parent_postchange_down_2",
155: waiting for acknowledgements. When they all arrive, or when the acknowledgement timer expires for all stragglers, we
156: explicitly acknowledge the parent via acknowledgePowerChange. In either case, we are done, and we remove the used
157: change note from the head of the queue and start on the next one.
158:
159: The case of the parent raising power in the domain is handled similarly in that there are parallel paths, one for no-stall
160: that ends in implicit acknowleging the parent, and one that has stalled at least once that ends in explicit acknowledging
161: the parent. This case is different, though in that our device changes state in the second half, after the parent calls
162: powerStateDidChange rather than before, as in the power-lowering case.
163:
164: As usual, we start by notifying our interested parties. If they all acknowledge via return code, we acknowledge the parent
165: via return code and enter "IOPMparent_postchange_up_1". If they don't, we wait in "parent_prechange_up_1" for them to
166: acknowledge or for the ack timer to expire on the stragglers. Then we acknowledge the parent via acknowledgePowerChange
167: and enter "IOPMparent_postchange_up_1", waiting for the parent to raise power and notify us. When the parent calls us
168: at powerStateDidChange, we instruct the power-controlling driver to change to the new higher state, we check for any
169: necessary settling time in "IOPMparent_postchange_up_2", and we notify all interested parties that power has changed
170: in "IOPMparent_postchange_up_3". If none of these operations stall, we acknowledge the parent via return code, release
171: the change note, and start the next, if there is one. If one of them does stall, we enter the parallel path
172: "IOPMparent_postchange_up_4", "IOPMparent_postchange_up_5", and "IOPMparent_postchange_up_6", which ends with
173: our explicit acknowledgement to the parent.
174:
175: */
176:
177:
178: const char priv_key[ ] = "Power Management private data";
179: const char prot_key[ ] = "Power Management protected data";
180:
181:
182: void IOService::PMinit ( void )
183: {
184: if ( ! initialized ) {
185:
186: pm_vars = new IOPMprot; // make space for our variables
187: priv = new IOPMpriv;
188: pm_vars->init();
189: priv->init();
190:
191: setProperty(prot_key, (OSObject *) pm_vars); // add these to the properties
192: setProperty(priv_key, (OSObject *) priv);
193:
194: initialized = true;
195: priv->owner = this;
196: pm_vars->theNumberOfPowerStates = 0; // then initialize them
197: pm_vars->myParent = NULL;
198: priv->we_are_root = false;
199: pm_vars->theControllingDriver = NULL;
200: priv->our_lock = IOLockAlloc();
201: priv->interestedDrivers = new IOPMinformeeList;
202: priv->interestedDrivers->initialize();
203: priv->children = new IOPMinformeeList;
204: priv->children->initialize();
205: priv->numberOfInformees = 0;
206: priv->changeList = new IOPMchangeNoteList;
207: priv->changeList->initialize();
208: pm_vars->aggressiveness = 0;
209: pm_vars->myCurrentState = 0;
210: priv->imminentState = 0;
211: priv->askingFor = 0;
212: priv->ourDesiredPowerState = 0;
213: pm_vars->parentCurrentPowerFlags = 0;
214: pm_vars->maxCapability = 0;
215: priv->driverDesire = 0;
216: priv->deviceDesire = 0;
217: priv->initial_change = true;
218: priv->need_to_become_usable = false;
219: priv->previousRequest = 0;
220: priv->device_overrides = false;
221: priv->machine_state = IOPMfinished;
222: pm_vars->commandQueue = NULL;
223: priv->timerEventSrc = NULL;
224: pm_vars->PMworkloop = NULL;
225: priv->activityLock = NULL;
226: pm_vars->ourName = getName();
227: pm_vars->thePlatform = getPlatform();
228: assert( pm_vars->thePlatform != 0 );
229: }
230: }
231:
232:
233: //*********************************************************************************
234: // PMstop
235: //
236: // Free up the data created in PMinit.
237: //*********************************************************************************
238: void IOService::PMstop ( void )
239: {
240: initialized = false;
241:
242: removeProperty(prot_key); // remove the properties
243: removeProperty(priv_key);
244: priv->interestedDrivers->release(); // remove lists
245: priv->children->release();
246: priv->changeList->release();
247: pm_vars->release(); // remove the instance variables
248: priv->release();
249: pm_vars = NULL;
250: priv = NULL;
251: }
252:
253:
254: //*********************************************************************************
255: // joinPMtree
256: //
257: // A policy-maker calls its nub here when initializing, to be attached into
258: // the power management hierarchy. The default function is to call the
259: // platform expert, which knows how to do it. This method is overridden
260: // by a nub subclass which may either know how to do it, or may need
261: // to take other action.
262: //
263: // This may be the only "power management" method used in a nub,
264: // meaning it may not be initialized for power management.
265: //*********************************************************************************
266: void IOService::joinPMtree ( IOService * driver )
267: {
268: IOPlatformExpert * thePlatform;
269:
270: thePlatform = getPlatform();
271: assert(thePlatform != 0 );
272: thePlatform->PMRegisterDevice(this,driver);
273: }
274:
275:
276: //*********************************************************************************
277: // youAreRoot
278: //
279: // Power Managment is informing us that we are the root power domain.
280: // The only difference between us and any other power domain is that
281: // we have no parent and therefore never call it.
282: //*********************************************************************************
283: IOReturn IOService::youAreRoot ( void )
284: {
285: priv-> we_are_root = true;
286: pm_vars->myParent = (IOService *)1; // we won't use this, but keep it non-NULL
287: return IOPMNoErr;
288: }
289:
290:
291: //*********************************************************************************
292: // setParent
293: //
294: // Power Management is informing us who our parent is.
295: // If we have a controlling driver, find out, given our newly-informed
296: // power domain state, what state it would be in, and then tell it
297: // to assume that state.
298: //*********************************************************************************
299: IOReturn IOService::setParent ( IOService * theParent, IOPMPowerFlags currentState )
300: {
301: unsigned long tempDesire;
302:
303: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogSetParent,(unsigned long)currentState,0);
304:
305: attachToParent( theParent, gIOPowerPlane);
306: pm_vars->myParent = theParent;
307: pm_vars->parentCurrentPowerFlags = currentState;
308: if ( pm_vars->theControllingDriver != NULL ) {
309: pm_vars->maxCapability = pm_vars->theControllingDriver->maxCapabilityForDomainState(pm_vars->parentCurrentPowerFlags);
310: tempDesire = priv->deviceDesire; // initially change into the state we are already in
311: priv->deviceDesire = pm_vars->theControllingDriver->initialPowerStateForDomainState(pm_vars->parentCurrentPowerFlags);
312: changeState();
313: priv->deviceDesire = tempDesire; // put this back like before
314: }
315: return IOPMNoErr;
316: }
317:
318:
319: //*********************************************************************************
320: // addChild
321: //
322: // Power Management is informing us who our children are.
323: //*********************************************************************************
324: IOReturn IOService::addChild ( IOService * theChild )
325: {
326: IOPMinformee * newChild;
327: IOPMPowerFlags capability;
328:
329: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAddChild,0,0);
330:
331: theChild->retain();
332:
333: newChild = new IOPMpmChild;
334: newChild->initialize(theChild); // make a new child
335: priv->children->addToList(newChild); // add it to list of children
336: priv->numberOfInformees = priv->children->numberOfItems() + priv->interestedDrivers->numberOfItems();
337: if ( pm_vars->theControllingDriver == NULL ) { // tell it the current state of the power domain
338: capability = 0;
339: }
340: else {
341: capability = pm_vars->thePowerStates[pm_vars->myCurrentState].outputPowerCharacter;
342: }
343: theChild->setParent(this,capability);
344: theChild->setAggressiveness (kPMGeneralAggressiveness,pm_vars->aggressiveness); // tell it the current aggressiveness
345: add_to_active_change(newChild, true); // catch it up if change is in progress
346: return IOPMNoErr;
347: }
348:
349:
350: //*********************************************************************************
351: // removeChild
352: //
353: //*********************************************************************************
354: IOReturn IOService::removeChild ( IOService * theChild )
355: {
356: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRemoveChild,0,0);
357:
358: priv->children->removeFromList(theChild); // remove the departing child
359: priv->numberOfInformees = priv->children->numberOfItems() + priv->interestedDrivers->numberOfItems();
360:
361: if ( (pm_vars->theControllingDriver == NULL) || // if not fully initialized
362: (pm_vars->myParent == NULL) ) {
363: return IOPMNoErr; // we can do no more
364: }
365:
366: changeState(); // change state if we can now tolerate lower power
367:
368: return IOPMNoErr;
369: }
370:
371:
372: //*********************************************************************************
373: // registerControllingDriver
374: //
375: // A driver has called us volunteering to control power to our device.
376: // If the power state array it provides is richer than the one we already
377: // know about (supplied by an earlier volunteer), then accept the offer.
378: // Notify all interested parties of our power state, which we now know.
379: //*********************************************************************************
380:
381: IOReturn IOService::registerControllingDriver ( IOService * controllingDriver, IOPMPowerState* powerStates, unsigned long numberOfStates )
382: {
383: unsigned long i;
384: unsigned long tempDesire;
385:
386: if ( (numberOfStates > pm_vars->theNumberOfPowerStates) && (numberOfStates > 1) ) {
387: if ( priv->changeList->currentChange() == -1 ) {
388: if ( controllingDriver != NULL ) {
389: if ( numberOfStates <= IOPMMaxPowerStates ) {
390: switch ( powerStates[0].version ) {
391: case 1:
392: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriver,
393: (unsigned long)numberOfStates, (unsigned long)powerStates[0].version);
394: for ( i = 0; i < numberOfStates; i++ ) {
395: pm_vars->thePowerStates[i] = powerStates[i];
396: }
397: break;
398: case 2:
399: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriver,
400: (unsigned long) numberOfStates,(unsigned long) powerStates[0].version);
401: for ( i = 0; i < numberOfStates; i++ ) {
402: pm_vars->thePowerStates[i].version = powerStates[i].version;
403: pm_vars->thePowerStates[i].capabilityFlags = powerStates[i].capabilityFlags;
404: pm_vars->thePowerStates[i].outputPowerCharacter = powerStates[i].outputPowerCharacter;
405: pm_vars->thePowerStates[i].inputPowerRequirement = powerStates[i].inputPowerRequirement;
406: pm_vars->thePowerStates[i].staticPower = powerStates[i].staticPower;
407: pm_vars->thePowerStates[i].unbudgetedPower = powerStates[i].unbudgetedPower;
408: pm_vars->thePowerStates[i].powerToAttain = powerStates[i].powerToAttain;
409: pm_vars->thePowerStates[i].timeToAttain = powerStates[i].timeToAttain;
410: pm_vars->thePowerStates[i].settleUpTime = powerStates[i].settleUpTime;
411: pm_vars->thePowerStates[i].timeToLower = powerStates[i].timeToLower;
412: pm_vars->thePowerStates[i].settleDownTime = powerStates[i].settleDownTime;
413: pm_vars->thePowerStates[i].powerDomainBudget = powerStates[i].powerDomainBudget;
414: }
415: break;
416: default:
417: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr1,
418: (unsigned long)powerStates[0].version,0);
419: return IOPMNoErr;
420: }
421:
422: pm_vars->theNumberOfPowerStates = numberOfStates;
423: pm_vars->theControllingDriver = controllingDriver;
424: if ( priv->interestedDrivers->findItem(controllingDriver) == NULL ) { // register it as interested
425: registerInterestedDriver (controllingDriver ); // unless already done
426: }
427: if ( priv->need_to_become_usable ) {
428: priv->need_to_become_usable = false;
429: priv->deviceDesire = pm_vars->theNumberOfPowerStates - 1;
430: }
431: if ( pm_vars->myParent != NULL ) {
432: pm_vars->maxCapability = pm_vars->theControllingDriver->maxCapabilityForDomainState(pm_vars->parentCurrentPowerFlags);
433: tempDesire = priv->deviceDesire; // initially change into the state we are already in
434: priv->deviceDesire = pm_vars->theControllingDriver->initialPowerStateForDomainState(pm_vars->parentCurrentPowerFlags);
435: changeState();
436: priv->deviceDesire = tempDesire; // put this back like before
437: }
438: }
439: else {
440: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr2,(unsigned long)numberOfStates,0);
441: }
442: }
443: else {
444: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr4,0,0);
445: }
446: }
447: }
448: else {
449: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr5,(unsigned long)numberOfStates,0);
450: }
451: return IOPMNoErr;
452: }
453:
454: //*********************************************************************************
455: // registerInterestedDriver
456: //
457: // Add the caller to our list of interested drivers and return our current
458: // power state. If we don't have a power-controlling driver yet, we will
459: // call this interested driver again later when we do get a driver and find
460: // out what the current power state of the device is.
461: //*********************************************************************************
462:
463: IOPMPowerFlags IOService::registerInterestedDriver ( IOService * theDriver )
464: {
465: IOPMinformee * newInformee;
466: IOPMPowerFlags futureCapability;
467:
468: if (theDriver == NULL ) {
469: return 0; // can't tell it a state yet
470: }
471:
472: theDriver->retain();
473:
474: newInformee = new IOPMinformee; // make new driver node
475: newInformee->initialize(theDriver);
476: priv->interestedDrivers->addToList(newInformee); // add it to list of drivers
477: priv->numberOfInformees = priv->children->numberOfItems() + priv->interestedDrivers->numberOfItems();
478:
479: if ( (pm_vars->theControllingDriver == NULL) || (pm_vars->myParent == NULL) ) {
480: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInterestedDriver,0,0);
481: return 0; // can't tell it a state yet
482: }
483:
484: switch (priv->machine_state) { // can we notify new driver of a change in progress?
485: case IOPMour_prechange_1:
486: case IOPMour_prechange_4:
487: case IOPMparent_prechange_down_4:
488: case IOPMparent_postchange_down_2:
489: case IOPMparent_prechange_up_1:
490: case IOPMparent_postchange_up_6:
491: futureCapability = priv->head_note_capabilityFlags; // yes, remember what we tell it
492: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInterestedDriver,(unsigned long)futureCapability,0);
493: add_to_active_change(newInformee,false); // notify it
494: return futureCapability; // and return the same thing
495: }
496: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInterestedDriver,
497: (unsigned long) pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags,0);
498: return pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags; // no, return current capability
499: }
500:
501:
502: //*********************************************************************************
503: // deRegisterInterestedDriver
504: //
505: //*********************************************************************************
506: IOReturn IOService::deRegisterInterestedDriver ( IOService * theDriver )
507: {
508: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRemoveDriver,0,0);
509:
510: priv->interestedDrivers->removeFromList(theDriver); // remove the departing driver
511: priv->numberOfInformees = priv->children->numberOfItems() + priv->interestedDrivers->numberOfItems();
512:
513: theDriver->release();
514:
515: return IOPMNoErr;
516: }
517:
518:
519: //*********************************************************************************
520: // acknowledgePowerChange
521: //
522: // After we notified one of the interested drivers or a power-domain child
523: // of an impending change in power, it has called to say it is now
524: // prepared for the change. If this object is the last to
525: // acknowledge this change, we take whatever action we have been waiting
526: // for.
527: // That may include acknowledging to our parent. In this case, we do it
528: // last of all to insure that this doesn't cause the parent to call us some-
529: // where else and alter data we are relying on here (like the very existance
530: // of a "current change note".)
531: //*********************************************************************************
532:
533: IOReturn IOService::acknowledgePowerChange ( IOService * whichObject )
534: {
535: IOPMinformee * ackingObject;
536:
537: ackingObject = priv->interestedDrivers->findItem(whichObject); // one of our interested drivers?
538: if ( ackingObject == NULL ) {
539: ackingObject = priv->children->findItem(whichObject); // no, one of our children?
540: if ( ackingObject == NULL ) {
541: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr1,0,0);
542: return IOPMNoErr; // no, just return
543: }
544: else {
545: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChildAcknowledge,0,0);
546: }
547: }
548: else {
549: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogDriverAcknowledge,0,0);
550: }
551:
552: if (! acquire_lock() ) {
553: return IOPMNoErr;
554: }
555:
556: if (priv->head_note_pendingAcks != 0 ) { // yes, make sure we're expecting acks
557: if ( ackingObject->timer != 0 ) { // make sure we're expecting this ack
558: ackingObject->timer = 0; // mark it acked
559: priv->head_note_pendingAcks -= 1; // that's one fewer to worry about
560: if ( priv->head_note_pendingAcks == 0 ) { // is that the last?
561: stop_ack_timer(); // yes, stop the timer
562: IOUnlock(priv->our_lock);
563: all_acked(); // and now we can continue
564: return IOPMNoErr;
565: }
566: }
567: else {
568: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr2,0,0); // this object has already acked
569: }
570: }
571: else {
572: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr3,0,0); // not expecting anybody to ack
573: }
574: IOUnlock(priv->our_lock);
575: return IOPMNoErr;
576: }
577:
578: //*********************************************************************************
579: // acknowledgeSetPowerState
580: //
581: // After we instructed our controlling driver to change power states,
582: // it has called to say it has finished doing so.
583: // We continue to process the power state change.
584: //*********************************************************************************
585:
586: IOReturn IOService::acknowledgeSetPowerState ( void )
587: {
588: if (! acquire_lock() ) {
589: return IOPMNoErr;
590: }
591: if ( priv->driver_timer == -1 ) {
592: priv->driver_timer = 0; // driver is acking instead of using return code
593: }
594: else {
595: if ( priv->driver_timer > 0 ) { // are we expecting this?
596: stop_ack_timer(); // yes, stop the timer
597: priv->driver_timer = 0;
598: IOUnlock(priv->our_lock);
599: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogDriverAcknowledgeSet,0,0);
600: driver_acked();
601: return IOPMNoErr;
602: }
603: else {
604: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr4,0,0); // no
605: }
606: }
607: IOUnlock(priv->our_lock);
608: return IOPMNoErr;
609: }
610:
611:
612: //*********************************************************************************
613: // driver_acked
614: //
615: // Either the controlling driver has called acknowledgeSetPowerState
616: // or the acknowledgement timer has expired while waiting for that.
617: // We carry on processing the current change note.
618: //*********************************************************************************
619:
620: void IOService::driver_acked ( void )
621: {
622: switch (priv->machine_state) {
623: case IOPMour_prechange_2:
624: our_prechange_2();
625: break;
626: case IOPMparent_prechange_down_5:
627: parent_prechange_down_5();
628: break;
629: case IOPMparent_postchange_up_4:
630: parent_postchange_up_4();
631: break;
632: }
633: }
634:
635:
636: //*********************************************************************************
637: // powerDomainWillChangeTo
638: //
639: // Called by the power-hierarchy parent notifying of a new power state
640: // in the power domain.
641: // If power is going lower, we notify our interested parties that power
642: // will lower. When they have all acked, we lower the state of our device
643: // to the state appropriate for the coming domain level. Then we ack the parent.
644: // Later, when the domain has lowered, we notify everyone that power has dropped.
645: //
646: // If power is going higher and we will take advantage of this by raising our
647: // own power state, we notify our interested parties that power
648: // will raise. When they have all acked, we ack the parent. Later, when
649: // the domain has raised, we raise our power level. When power has
650: // settled, we inform our interested parties. When they have all acked,
651: // we ack the parent.
652: //*********************************************************************************
653:
654: IOReturn IOService::powerDomainWillChangeTo ( IOPMPowerFlags newPowerStateFlags )
655: {
656: unsigned long newStateNumber;
657:
658: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogWillChange,(unsigned long)newPowerStateFlags,0);
659:
660: if ( pm_vars->myParent == NULL ) {
661: return IOPMAckImplied; // somebody goofed
662: }
663:
664: if ( pm_vars->theControllingDriver == NULL ) {
665: pm_vars->parentCurrentPowerFlags = newPowerStateFlags; // we can't take any action except note the change
666: return IOPMAckImplied;
667: }
668: newStateNumber = pm_vars->theControllingDriver->maxCapabilityForDomainState(newPowerStateFlags);
669: return enqueuePowerChange(IOPMParentInitiated, newStateNumber,newPowerStateFlags); // tell interested parties about it
670: }
671:
672:
673: //*********************************************************************************
674: // powerDomainDidChangeTo
675: //
676: // Called by the power-hierarchy parent after the power state of the power domain
677: // has settled at a new level. We must notify our interested drivers and children.
678: // If they all acknowledge immediately, so do we. Otherwise, we'll acknowledge
679: // when the last of them does.
680: //*********************************************************************************
681:
682: IOReturn IOService::powerDomainDidChangeTo ( IOPMPowerFlags newPowerStateFlags )
683: {
684:
685: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogDidChange,(unsigned long)newPowerStateFlags,0);
686:
687: if ( (pm_vars->myParent == NULL) || (pm_vars->theControllingDriver == NULL) ) {
688: return IOPMAckImplied; // somebody goofed
689: }
690:
691: switch (priv->machine_state) {
692: case IOPMparent_postchange_down_1:
693: return parent_postchange_down_1(); // life-style 2 continues
694: case IOPMparent_postchange_up_1:
695: return parent_postchange_up_1(); // life-style 3 continues
696: case IOPMparent_postchange_null:
697: all_done();
698: return IOPMAckImplied; // life-style 4 done
699: }
700:
701: return IOPMAckImplied; // something wrong
702: }
703:
704:
705: //*********************************************************************************
706: // requestDomainState
707: //
708: //
709: //*********************************************************************************
710: IOReturn IOService::requestDomainState ( IOPMPowerFlags desiredState, IOService* whichChild, unsigned long specification )
711: {
712: unsigned long i;
713: IOPMinformee * nextChild;
714:
715: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRequestDomain,
716: (unsigned long)desiredState,(unsigned long)specification);
717:
718: if ( pm_vars->theControllingDriver == NULL) {
719: return IOPMNotYetInitialized;
720: }
721:
722: switch (specification) {
723: case IOPMLowestState:
724: i = 0;
725: while ( i < pm_vars->theNumberOfPowerStates ) {
726: if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & desiredState) == desiredState ) {
727: break;
728: }
729: i++;
730: }
731: if ( i >= pm_vars->theNumberOfPowerStates ) {
732: return IOPMNoSuchState;
733: }
734: break;
735:
736: case IOPMNextLowerState:
737: i = pm_vars->myCurrentState - 1;
738: while ( i >= 0 ) {
739: if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & desiredState) == desiredState ) {
740: break;
741: }
742: i--;
743: }
744: if ( i < 0 ) {
745: return IOPMNoSuchState;
746: }
747: break;
748:
749: case IOPMHighestState:
750: i = pm_vars->theNumberOfPowerStates;
751: while ( i >= 0 ) {
752: i--;
753: if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & desiredState) == desiredState ) {
754: break;
755: }
756: }
757: if ( i < 0 ) {
758: return IOPMNoSuchState;
759: }
760: break;
761:
762: case IOPMNextHigherState:
763: i = pm_vars->myCurrentState + 1;
764: while ( i < pm_vars->theNumberOfPowerStates ) {
765: if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & desiredState) == desiredState ) {
766: break;
767: }
768: i++;
769: }
770: if ( i == pm_vars->theNumberOfPowerStates ) {
771: return IOPMNoSuchState;
772: }
773: break;
774:
775: default:
776: return IOPMBadSpecification;
777: }
778:
779: // Now loop through the children. When we encounter the calling child, save
780: // the new state as this child's desire. Then, compute a new maximum
781: // of everybody's desires.
782:
783: nextChild = priv->children->firstInList();
784:
785: if ( nextChild == NULL ) { // we're not a power domain
786: return IOPMNoErr;
787: }
788:
789: while ( nextChild != NULL ) {
790: if ( whichChild == (IOService*)nextChild->whatObject ) {
791: ((IOPMpmChild *)nextChild)->desiredDomainState = i;
792: break;
793: }
794: nextChild = priv->children->nextInList(nextChild);
795: }
796:
797: if ( pm_vars->myParent != NULL ) {
798: changeState(); // change state if all children can now tolerate lower power
799: }
800:
801: return IOPMNoErr;
802: }
803:
804:
805: //*********************************************************************************
806: // makeUsable
807: //
808: // Some client of our device is asking that we become usable. Although
809: // this has not come from a subclassed device object, treat it exactly
810: // as if it had. In this way, subsequent requests for lower power from
811: // a subclassed device object will pre-empt this request.
812: //
813: // We treat this as a subclass object request to switch to the
814: // highest power state.
815: //*********************************************************************************
816:
817: IOReturn IOService::makeUsable ( void )
818: {
819: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogMakeUsable,0,0);
820:
821: if ( pm_vars->theControllingDriver == NULL ) {
822: priv->need_to_become_usable = true;
823: return IOPMNoErr;
824: }
825: priv->deviceDesire = pm_vars->theNumberOfPowerStates - 1;
826: if ( pm_vars->myParent == NULL ) {
827: return IOPMNoErr;
828: }
829: return changeState();
830: }
831:
832:
833: //*********************************************************************************
834: // currentCapability
835: //
836: //*********************************************************************************
837:
838: IOPMPowerFlags IOService::currentCapability ( void )
839: {
840: if ( pm_vars->theControllingDriver == NULL ) {
841: return 0;
842: }
843: else {
844: return pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags;
845: }
846: }
847:
848:
849: //*********************************************************************************
850: // changeStateTo
851: //
852: // For some reason, our power-controlling driver has decided it needs to change
853: // power state. We enqueue the power change so that appropriate parties
854: // will be notified, and then we will instruct the driver to make the change.
855: //*********************************************************************************
856:
857: IOReturn IOService::changeStateTo ( unsigned long ordinal )
858: {
859: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeStateTo,ordinal,0);
860:
861: if ( ordinal >= pm_vars->theNumberOfPowerStates ) {
862: return IOPMParameterError;
863: }
864: priv->driverDesire = ordinal;
865: if ( pm_vars->myParent == NULL ) {
866: return IOPMNoErr;
867: }
868: return changeState();
869: }
870:
871: //*********************************************************************************
872: // changeStateToPriv
873: //
874: // For some reason, a subclassed device object has decided it needs to change
875: // power state. We enqueue the power change so that appropriate parties
876: // will be notified, and then we will instruct the driver to make the change.
877: //*********************************************************************************
878:
879: IOReturn IOService::changeStateToPriv ( unsigned long ordinal )
880: {
881: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeStateToPriv,ordinal,0);
882:
883: if ( pm_vars->theControllingDriver == NULL) {
884: return IOPMNotYetInitialized;
885: }
886: if ( ordinal >= pm_vars->theNumberOfPowerStates ) {
887: return IOPMParameterError;
888: }
889: priv->deviceDesire = ordinal;
890: if ( pm_vars->myParent == NULL ) {
891: return IOPMNoErr;
892: }
893: return changeState();
894: }
895:
896:
897: //*********************************************************************************
898: // changeState
899: //
900: // A subclass object, our controlling driver, or a power domain child
901: // has asked for a different power state. Here we compute what new
902: // state we should enter and enqueue the change (or start it).
903: //*********************************************************************************
904:
905: IOReturn IOService::changeState ( void )
906: {
907: unsigned long newDesiredState = 0;
908: IOPMinformee * nextChild;
909:
910: // Compute the maximum of our children's desires, our controlling driver's desire, and the subclass device's desire.
911:
912: if ( ! priv->device_overrides ) {
913: nextChild = priv->children->firstInList();
914:
915: while ( nextChild != NULL ) {
916: if ( (( IOPMpmChild *)nextChild)->desiredDomainState > newDesiredState ) {
917: newDesiredState =(( IOPMpmChild *)nextChild)->desiredDomainState;
918: }
919: nextChild = priv->children->nextInList(nextChild);
920: }
921: if ( priv->driverDesire > newDesiredState ) {
922: newDesiredState = priv->driverDesire;
923: }
924: }
925:
926: if ( priv->deviceDesire > newDesiredState ) {
927: newDesiredState = priv->deviceDesire;
928: }
929:
930: priv->ourDesiredPowerState = newDesiredState;
931:
932: return enqueuePowerChange(IOPMWeInitiated,newDesiredState,0);
933: }
934:
935:
936: //*********************************************************************************
937: // currentPowerConsumption
938: //
939: //*********************************************************************************
940:
941: unsigned long IOService::currentPowerConsumption ( void )
942: {
943: if ( pm_vars->theControllingDriver == NULL ) {
944: return 0;
945: }
946: else {
947: return pm_vars->thePowerStates[pm_vars->myCurrentState].staticPower;
948: }
949: }
950:
951: //*********************************************************************************
952: // activityTickle
953: //
954: // The activity tickle with parameter kIOPMSubclassPolicyis not handled
955: // here and should have been intercepted by the subclass.
956: // The tickle with parameter kIOPMSuperclassPolicy1 causes the activity
957: // flag to be set, and the device state checked. If the device has been
958: // powered down, it is powered up again.
959: //*********************************************************************************
960:
961: bool IOService::activityTickle ( unsigned long type, unsigned long stateNumber=0 )
962: {
963: if ( type == kIOPMSuperclassPolicy1 ) {
964: if ( (priv->activityLock == NULL) ||
965: (pm_vars->theControllingDriver == NULL) ||
966: ( pm_vars->commandQueue == NULL) ) {
967: return true;
968: }
969: IOTakeLock(priv->activityLock);
970: priv->device_active = true;
971: if ( pm_vars->myCurrentState >= stateNumber) {
972: IOUnlock(priv->activityLock);
973: return true;
974: }
975: IOUnlock(priv->activityLock); // send a message on the command queue
976: pm_vars->commandQueue->enqueueCommand(true, (void *)kPMunIdleDevice, (void *)stateNumber);
977: return false;
978: }
979: return true;
980: }
981:
982: //*********************************************************************************
983: // getPMworkloop
984: //
985: // A child is calling to get a pointer to the Power Management workloop.
986: // We got it or get it from our parent.
987: //*********************************************************************************
988:
989: IOWorkLoop * IOService::getPMworkloop ( void )
990: {
991: if ( pm_vars->myParent == NULL ) {
992: return NULL;
993: }
994: if ( pm_vars->PMworkloop == NULL ) {
995: pm_vars->PMworkloop = pm_vars->myParent->getPMworkloop();
996: }
997: return pm_vars->PMworkloop;
998: }
999:
1000:
1001: //*********************************************************************************
1002: // setIdleTimerPeriod
1003: //
1004: // A subclass policy-maker is going to use our standard idleness
1005: // detection service. Make a command queue and an idle timer and
1006: // connect them to the power management workloop. Finally,
1007: // start the timer.
1008: //*********************************************************************************
1009:
1010: IOReturn IOService::setIdleTimerPeriod ( unsigned long period )
1011: {
1012: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMsetIdleTimerPeriod,period, 0);
1013:
1014: priv->idle_timer_period = period;
1015:
1016: if ( period > 0 ) {
1017: if ( getPMworkloop() == NULL ) {
1018: return kIOReturnError;
1019: }
1020:
1021: if (pm_vars->commandQueue == NULL ) { // make the command queue
1022: pm_vars->commandQueue = IOCommandQueue::commandQueue(this, PMreceiveCmd);
1023: if (! pm_vars->commandQueue ||
1024: ( pm_vars->PMworkloop->addEventSource( pm_vars->commandQueue) != kIOReturnSuccess) ) {
1025: return kIOReturnError;
1026: }
1027: }
1028: // make the timer event
1029: if ( priv->timerEventSrc == NULL ) {
1030: priv->timerEventSrc = IOTimerEventSource::timerEventSource(this,
1031: PM_idle_timer_expired);
1032: if ( ! priv->timerEventSrc ||
1033: ( pm_vars->PMworkloop->addEventSource( priv->timerEventSrc) != kIOReturnSuccess) ) {
1034: return kIOReturnError;
1035: }
1036: }
1037:
1038: if ( priv->activityLock == NULL ) {
1039: priv->activityLock = IOLockAlloc();
1040: }
1041:
1042: start_PM_idle_timer();
1043: }
1044: return IOPMNoErr;
1045: }
1046:
1047:
1048: //*********************************************************************************
1049: // start_PM_idle_timer
1050: //
1051: // The parameter is a pointer to us. Use it to call our timeout method.
1052: //*********************************************************************************
1053: void IOService::start_PM_idle_timer ( void )
1054: {
1055: priv->timerEventSrc->setTimeout(priv->idle_timer_period, NSEC_PER_SEC);
1056: }
1057:
1058:
1059: //*********************************************************************************
1060: // PM_idle_timer_expired
1061: //
1062: // The parameter is a pointer to us. Use it to call our timeout method.
1063: //*********************************************************************************
1064:
1065: void PM_idle_timer_expired(OSObject * ourSelves, IOTimerEventSource *)
1066: {
1067: ((IOService *)ourSelves)->PM_idle_timer_expiration();
1068: }
1069:
1070:
1071: //*********************************************************************************
1072: // PM_idle_timer_expiration
1073: //
1074: // The idle timer has expired. If there has been activity since the last
1075: // expiration, just restart the timer and return. If there has not been
1076: // activity, switch to the next lower power state and restart the timer.
1077: //*********************************************************************************
1078:
1079: void IOService::PM_idle_timer_expiration ( void )
1080: {
1081: if ( priv->idle_timer_period > 0 ) {
1082: IOTakeLock(priv->activityLock);
1083: if ( priv->device_active ) {
1084: priv->device_active = false;
1085: IOUnlock(priv->activityLock);
1086: start_PM_idle_timer();
1087: return;
1088: }
1089: if (pm_vars->myCurrentState > 0 ) {
1090: IOUnlock(priv->activityLock);
1091: priv->askingFor = pm_vars->myCurrentState - 1;
1092: changeStateToPriv(pm_vars->myCurrentState - 1);
1093: start_PM_idle_timer();
1094: return;
1095: }
1096: IOUnlock(priv->activityLock);
1097: start_PM_idle_timer();
1098: }
1099: }
1100:
1101:
1102:
1103: // **********************************************************************************
1104: // PMreceiveCmd
1105: //
1106: //
1107: //
1108: // **********************************************************************************
1109: void PMreceiveCmd ( OSObject * theDriver, void * command, void * param1, void * param2, void *param3 )
1110: {
1111: ((IOService *)theDriver)->command_received(command,param1,param2,param3);
1112: }
1113:
1114:
1115: // **********************************************************************************
1116: // command_received
1117: //
1118: // We have received a command from ourselves on the command queue.
1119: // This is to prevent races with timer-expiration code.
1120: // **********************************************************************************
1121: void IOService::command_received ( void * command, void *stateNumber , void * , void *)
1122: {
1123: if ( command == (void *)kPMunIdleDevice ) {
1124: if ((pm_vars->myCurrentState < (unsigned long)stateNumber) &&
1125: (priv->imminentState < (unsigned long)stateNumber ) &&
1126: ((unsigned long)stateNumber > priv->askingFor) ) {
1127: priv->askingFor = (unsigned long)stateNumber;
1128: changeStateToPriv((unsigned long)stateNumber);
1129: }
1130: }
1131: }
1132:
1133:
1134: //*********************************************************************************
1135: // setAggressiveness
1136: //
1137: // Pass on the input parameters to all power domain children. All those which are
1138: // power domains will pass it on to their children, etc.
1139: //*********************************************************************************
1140:
1141: IOReturn IOService::setAggressiveness ( unsigned long type, unsigned long newLevel )
1142: {
1143: IOPMinformee * nextChild;
1144:
1145: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogSetAggressiveness,type, newLevel);
1146:
1147: if ( type == kPMGeneralAggressiveness ) {
1148: pm_vars->aggressiveness = newLevel;
1149: }
1150:
1151: nextChild = priv->children->firstInList();
1152:
1153: while ( nextChild != NULL ) {
1154: nextChild->whatObject->setAggressiveness(type, newLevel);
1155: nextChild = priv->children->nextInList(nextChild);
1156: }
1157:
1158: return IOPMNoErr;
1159: }
1160:
1161:
1162: //*********************************************************************************
1163: // systemWake
1164: //
1165: // Pass this to all power domain children. All those which are
1166: // power domains will pass it on to their children, etc.
1167: //*********************************************************************************
1168:
1169: IOReturn IOService::systemWake ( void )
1170: {
1171: IOPMinformee * nextChild;
1172:
1173: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogSystemWake,0, 0);
1174:
1175: nextChild = priv->children->firstInList();
1176:
1177: while ( nextChild != NULL ) {
1178: nextChild->whatObject->systemWake();
1179: nextChild = priv->children->nextInList(nextChild);
1180: }
1181:
1182: return IOPMNoErr;
1183: }
1184:
1185:
1186: //*********************************************************************************
1187: // temperatureCriticalForZone
1188: //
1189: //*********************************************************************************
1190:
1191: IOReturn IOService::temperatureCriticalForZone ( IOService * whichZone )
1192: {
1193: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogCriticalTemp,0,0);
1194:
1195: if ( (pm_vars->myParent != NULL) &&
1196: ( ! priv->we_are_root) ) {
1197: pm_vars->myParent->temperatureCriticalForZone(whichZone);
1198: }
1199: return IOPMNoErr;
1200: }
1201:
1202:
1203: //*********************************************************************************
1204: // overrideOnPriv
1205: //
1206: //*********************************************************************************
1207:
1208:
1209: IOReturn IOService::overrideOnPriv ( void )
1210: {
1211: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogOverrideOn,0,0);
1212:
1213: priv->device_overrides = true; // turn on the override
1214: return changeState(); // change state if that changed something
1215: }
1216:
1217:
1218: //*********************************************************************************
1219: // overrideOffPriv
1220: //
1221: //*********************************************************************************
1222: IOReturn IOService::overrideOffPriv ( void )
1223: {
1224: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogOverrideOff,0,0);
1225:
1226: priv->device_overrides = false; // turn off the override
1227: return changeState(); // change state if that changed something
1228: }
1229:
1230:
1231: //*********************************************************************************
1232: // enqueuePowerChange
1233: //
1234: // Allocate a new state change notification, initialize it with fields from the
1235: // caller, and add it to the tail of the list of pending power changes.
1236: //
1237: // If it is early enough in the list, and almost all the time it is the only one in
1238: // the list, start the power change.
1239: //
1240: // In rare instances, this change will preempt the previous change in the list.
1241: // If the previous change is un-actioned in any way (because we are still
1242: // processing an even earlier power change), and if both the previous change
1243: // in the list and this change are initiated by us (not the parent), then we
1244: // needn't perform the previous change, so we collapse the list a little.
1245: //*********************************************************************************
1246:
1247: IOReturn IOService::enqueuePowerChange ( unsigned long flags, unsigned long whatStateOrdinal, unsigned long domainState )
1248: {
1249: long newNote;
1250: long previousNote;
1251:
1252: // Create and initialize the new change note
1253:
1254: newNote = priv->changeList->createChangeNote();
1255: if ( newNote == -1 ) {
1256: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogEnqueueErr,0,0);
1257: return IOPMAckImplied; // uh-oh, our list is full
1258: }
1259:
1260: priv->changeList->changeNote[newNote].newStateNumber = whatStateOrdinal;
1261: priv->changeList->changeNote[newNote].outputPowerCharacter = pm_vars->thePowerStates[whatStateOrdinal].outputPowerCharacter;
1262: priv->changeList->changeNote[newNote].inputPowerRequirement = pm_vars->thePowerStates[whatStateOrdinal].inputPowerRequirement;
1263: priv->changeList->changeNote[newNote].capabilityFlags = pm_vars->thePowerStates[whatStateOrdinal].capabilityFlags;
1264: priv->changeList->changeNote[newNote].flags = flags;
1265: if (flags & IOPMParentInitiated ) {
1266: priv->changeList->changeNote[newNote].domainState = domainState;
1267: }
1268:
1269: previousNote = priv->changeList->previousChangeNote(newNote);
1270:
1271: if ( previousNote == -1 ) {
1272:
1273: // Queue is empty, we can start this change.
1274:
1275: if (flags & IOPMWeInitiated ) {
1276: start_our_change(newNote);
1277: return 0;
1278: }
1279: else {
1280: return start_parent_change(newNote);
1281: }
1282: }
1283:
1284: // The queue is not empty. Try to collapse this new change and the previous one in queue into one change.
1285: // This is possible only if both changes are initiated by us, and neither has been started yet.
1286: // Do this more than once if possible.
1287:
1288: // (A change is started iff it is at the head of the queue)
1289:
1290: while ( (previousNote != priv->head_note) && (previousNote != -1) &&
1291: (priv->changeList->changeNote[newNote].flags & priv->changeList->changeNote[previousNote].flags & IOPMWeInitiated) ) {
1292: priv->changeList->changeNote[previousNote].outputPowerCharacter = priv->changeList->changeNote[newNote].outputPowerCharacter;
1293: priv->changeList->changeNote[previousNote].inputPowerRequirement = priv->changeList->changeNote[newNote].inputPowerRequirement;
1294: priv->changeList->changeNote[previousNote].capabilityFlags =priv-> changeList->changeNote[newNote].capabilityFlags;
1295: priv->changeList->changeNote[previousNote].newStateNumber = priv->changeList->changeNote[newNote].newStateNumber;
1296: priv->changeList->releaseTailChangeNote();
1297: newNote = previousNote;
1298: previousNote = priv->changeList->previousChangeNote(newNote);
1299: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogCollapseQueue,0,0);
1300: }
1301: return IOPMWillAckLater; // in any case, we can't start yet
1302: }
1303:
1304:
1305: //*********************************************************************************
1306: // notifyAll
1307: //
1308: // Notify all interested parties either that a change is impending or that the
1309: // previously-notified change is done and power has settled.
1310: // The parameter identifies whether this is the
1311: // pre-change notification or the post-change notification.
1312: //
1313: //*********************************************************************************
1314:
1315: IOReturn IOService::notifyAll ( bool is_prechange )
1316: {
1317: IOPMinformee * nextObject;
1318: bool start_timer = false;
1319:
1320: // To prevent acknowledgePowerChange from finishing the change note and removing it from the queue if
1321: // some driver calls it, we inflate the number of pending acks so it cannot become zero. We'll fix it later.
1322:
1323: priv->head_note_pendingAcks = priv->numberOfInformees + 1;
1324:
1325: // OK, we will go through the lists of interested drivers and power domain children
1326: // and notify each one of this change.
1327:
1328: nextObject = priv->interestedDrivers->firstInList(); // notify interested drivers
1329: while ( nextObject != NULL ) {
1330: if (! notifyObject( nextObject, is_prechange, false) ) {
1331: start_timer = true;
1332: }
1333: nextObject = priv->interestedDrivers->nextInList(nextObject);
1334: }
1335: if ( start_timer ) { // start ack timer if any drivers didn't ack
1336: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0);
1337: start_ack_timer();
1338: }
1339:
1340: nextObject = priv->children->firstInList(); // notify power domain children
1341: while ( nextObject != NULL ) {
1342: notifyObject(nextObject, is_prechange, true);
1343: nextObject = priv->children->nextInList(nextObject);
1344: }
1345:
1346: priv->head_note_pendingAcks -= 1; // fix this
1347: if (priv->head_note_pendingAcks == 0 ) { // is it all acked?
1348: return IOPMAckImplied; // return ack to parent
1349: }
1350: return IOPMWillAckLater;
1351: }
1352:
1353:
1354: //*********************************************************************************
1355: // notifyObject
1356: //
1357: // Notify an interested driver or a power domain child of an upcoming
1358: // power change.
1359: //
1360: // If the object acknowledges the current change, we return TRUE.
1361: //*********************************************************************************
1362:
1363: bool IOService::notifyObject ( IOPMinformee * nextObject, bool is_prechange, bool is_child )
1364: {
1365: IOReturn k = IOPMAckImplied;
1366:
1367: nextObject->timer = -1; // initialize this
1368:
1369: if ( is_prechange ) {
1370: if ( is_child ) {
1371: k =nextObject->whatObject->powerDomainWillChangeTo( priv->head_note_outputFlags);
1372: }
1373: else {
1374: pm_vars->thePlatform->PMLog (pm_vars->ourName,PMlogInformDriverPreChange,
1375: (unsigned long)priv->head_note_capabilityFlags,(unsigned long)priv->head_note_state);
1376: k = nextObject->whatObject->powerStateWillChangeTo( priv->head_note_capabilityFlags,priv->head_note_state,this);
1377: }
1378: }
1379: else {
1380: if ( is_child ) {
1381: k = nextObject->whatObject->powerDomainDidChangeTo(priv->head_note_outputFlags);
1382: }
1383: else {
1384: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInformDriverPostChange,
1385: (unsigned long)priv->head_note_capabilityFlags,(unsigned long)priv->head_note_state);
1386: k = nextObject->whatObject->powerStateDidChangeTo(priv->head_note_capabilityFlags,priv->head_note_state,this);
1387: }
1388: }
1389:
1390: if ( nextObject->timer == 0 ) { // did it ack behind our back?
1391: return true; // yes
1392: }
1393: if ( k ==IOPMAckImplied ) { // no, did the return code ack?
1394: nextObject->timer = 0; // yes
1395: priv->head_note_pendingAcks -= 1;
1396: return true;
1397: }
1398: if ( k < 0 ) {
1399: nextObject->timer = 0; // somebody goofed
1400: priv-> head_note_pendingAcks -= 1;
1401: return true;
1402: }
1403: nextObject->timer = (k * ns_per_us / ACK_TIMER_PERIOD) + 1; // no, it's a timer
1404: return false;
1405: }
1406:
1407:
1408: //*********************************************************************************
1409: // our_prechange_1
1410: //
1411: // All parties have acknowledged our pre-change notification of a power
1412: // change we initiated. Here we instruct our controlling driver to make
1413: // the change to the hardware. If it does so, we continue processing
1414: // (waiting for settle and notifying interested parties post-change.)
1415: // If it doesn't, we have to wait for it to acknowledge and then continue.
1416: //*********************************************************************************
1417:
1418: void IOService::our_prechange_1 ( void )
1419: {
1420: if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) {
1421: our_prechange_2(); // it's done, carry on
1422: }
1423: else {
1424: priv->machine_state = IOPMour_prechange_2; // it's not, wait for it
1425: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0);
1426: start_ack_timer();
1427: }
1428: }
1429:
1430:
1431: //*********************************************************************************
1432: // our_prechange_2
1433: //
1434: // Our controlling driver has changed power state on the hardware
1435: // during a power change we initiated. Here we see if we need to wait
1436: // for power to settle before continuing. If not, we continue processing
1437: // (notifying interested parties post-change). If so, we wait and
1438: // continue later.
1439: //*********************************************************************************
1440:
1441: void IOService::our_prechange_2 ( void )
1442: {
1443: priv->settle_time = compute_settle_time();
1444: if ( priv->settle_time == 0 ) {
1445: our_prechange_3();
1446: }
1447: else {
1448: priv->machine_state = IOPMour_prechange_3;
1449: startSettleTimer(priv->settle_time);
1450: }
1451: }
1452:
1453:
1454: //*********************************************************************************
1455: // our_prechange_3
1456: //
1457: // Power has settled on a power change we initiated. Here we notify
1458: // all our interested parties post-change. If they all acknowledge, we're
1459: // done with this change note, and we can start on the next one.
1460: // Otherwise we have to wait for acknowledgements and finish up later.
1461: //*********************************************************************************
1462:
1463: void IOService::our_prechange_3 ( void )
1464: {
1465: priv->machine_state = IOPMour_prechange_4; // in case they don't all ack
1466: if ( notifyAll(false) == IOPMAckImplied ) {
1467: our_prechange_4();
1468: }
1469: }
1470:
1471:
1472: //*********************************************************************************
1473: // our_prechange_4
1474: //
1475: // Power has settled on a power change we initiated, and
1476: // all our interested parties have acknowledged. We're
1477: // done with this change note, and we can start on the next one.
1478: //*********************************************************************************
1479:
1480: void IOService::our_prechange_4 ( void )
1481: {
1482: all_done();
1483: }
1484:
1485:
1486: //*********************************************************************************
1487: // parent_prechange_down_1
1488: //
1489: // All parties have acknowledged our pre-change notification of a power
1490: // lowering initiated by the parent. Here we instruct our controlling driver
1491: // to put the hardware in the state it needs to be in when the domain is
1492: // lowered. If it does so, we continue processing
1493: // (waiting for settle and acknowledging the parent.)
1494: // If it doesn't, we have to wait for it to acknowledge and then continue.
1495: //*********************************************************************************
1496:
1497: IOReturn IOService::parent_prechange_down_1 ( void )
1498: {
1499: if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) {
1500: return parent_prechange_down_2(); // it's done, carry on
1501: }
1502: priv->machine_state = IOPMparent_prechange_down_5; // it's not, wait for it
1503: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0);
1504: start_ack_timer();
1505: return IOPMWillAckLater;
1506: }
1507:
1508:
1509: //*********************************************************************************
1510: // parent_prechange_down_4
1511: //
1512: // We had to wait for it, but all parties have acknowledged our pre-change
1513: // notification of a power lowering initiated by the parent.
1514: // Here we instruct our controlling driver
1515: // to put the hardware in the state it needs to be in when the domain is
1516: // lowered. If it does so, we continue processing
1517: // (waiting for settle and acknowledging the parent.)
1518: // If it doesn't, we have to wait for it to acknowledge and then continue.
1519: //*********************************************************************************
1520:
1521: void IOService::parent_prechange_down_4 ( void )
1522: {
1523: if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) {
1524: parent_prechange_down_5(); // it's done, carry on
1525: }
1526: else {
1527: priv-> machine_state = IOPMparent_prechange_down_5; // it's not, wait for it
1528: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0);
1529: start_ack_timer();
1530: }
1531: }
1532:
1533:
1534: //*********************************************************************************
1535: // parent_prechange_down_2
1536: //
1537: // Our controlling driver has changed power state on the hardware
1538: // during a power change initiated by our parent. Here we see if we need
1539: // to wait for power to settle before continuing. If not, we continue
1540: // processing (acknowledging our preparedness to the parent).
1541: // If so, we wait and continue later.
1542: //*********************************************************************************
1543:
1544: IOReturn IOService::parent_prechange_down_2 ( void )
1545: {
1546: priv->settle_time = compute_settle_time();
1547: if ( priv->settle_time == 0 ) {
1548: priv->machine_state = IOPMparent_postchange_down_1;
1549: return IOPMAckImplied;
1550: }
1551: else {
1552: priv->machine_state = IOPMparent_prechange_down_3;
1553: startSettleTimer(priv->settle_time);
1554: return IOPMWillAckLater;
1555: }
1556: }
1557:
1558:
1559: //*********************************************************************************
1560: // parent_prechange_down_5
1561: //
1562: // Our controlling driver has changed power state on the hardware
1563: // during a power change initiated by our parent. We have had to wait
1564: // for acknowledgement from interested parties, or we have had to wait
1565: // for the controlling driver to change the state. Here we see if we need
1566: // to wait for power to settle before continuing. If not, we continue
1567: // processing (acknowledging our preparedness to the parent).
1568: // If so, we wait and continue later.
1569: //*********************************************************************************
1570:
1571: void IOService::parent_prechange_down_5 ( void )
1572: {
1573: priv->settle_time = compute_settle_time();
1574: if ( priv->settle_time == 0 ) {
1575: parent_prechange_down_3();
1576: }
1577: else {
1578: priv->machine_state = IOPMparent_prechange_down_3;
1579: startSettleTimer(priv->settle_time);
1580: }
1581: }
1582:
1583:
1584: //*********************************************************************************
1585: // parent_prechange_down_3
1586: //
1587: // Power has settled on a power change initiated by our parent. Here we
1588: // acknowledge the parent. There is nothing more to do until the
1589: // parent lowers power in the domain and calls us at powerStateDidChange.
1590: //*********************************************************************************
1591:
1592: void IOService::parent_prechange_down_3 ( void )
1593: {
1594: priv->machine_state = IOPMparent_postchange_down_1;
1595: pm_vars->myParent->acknowledgePowerChange(this);
1596: }
1597:
1598:
1599: //*********************************************************************************
1600: // parent_prechange_up_1
1601: //
1602: // All parties have acknowledged our pre-change notification of a power
1603: // raising initiated by the parent. Here we acknowledge the parent.
1604: // There is nothing more to do until the parent raises power in the domain
1605: // and calls us at powerStateDidChange.
1606: //*********************************************************************************
1607:
1608: void IOService::parent_prechange_up_1 ( void )
1609: {
1610: priv->machine_state = IOPMparent_postchange_up_1;
1611: pm_vars->myParent->acknowledgePowerChange(this);
1612: }
1613:
1614:
1615: //*********************************************************************************
1616: // parent_postchange_down_1
1617: //
1618: // Our parent is lowering power, and has called us at powerStateDidChange
1619: // to tell us the domain power has now settled in the new lower state.
1620: // We notify our interested parties. When they have all acked, we're done
1621: //*********************************************************************************
1622:
1623: IOReturn IOService::parent_postchange_down_1 ( void )
1624: {
1625: priv->machine_state = IOPMparent_postchange_down_2; // in case they don't all ack
1626: if ( notifyAll(false) == IOPMAckImplied ) {
1627: all_done();
1628: return IOPMAckImplied;
1629: }
1630: return IOPMWillAckLater; // they didn't
1631: }
1632:
1633:
1634: //*********************************************************************************
1635: // parent_postchange_down_2
1636: //
1637: // We had to wait for it, but all parties have acknowledged our post-change
1638: // notification of a power lowering initiated by the parent.
1639: // Here we acknowledge the parent.
1640: // We are done with this change note, and we can start on the next one.
1641: //*********************************************************************************
1642:
1643: void IOService::parent_postchange_down_2 ( void )
1644: {
1645: all_done();
1646: pm_vars->myParent->acknowledgePowerChange(this);
1647: }
1648:
1649:
1650: //*********************************************************************************
1651: // parent_postchange_up_1
1652: //
1653: // Our parent has informed us via powerStateDidChange that it has
1654: // raised the power in our power domain. Here we instruct our controlling
1655: // driver to program the hardware to take advantage of the higher domain
1656: // power. If it does so, we continue processing
1657: // (waiting for settle and notifying interested parties post-change.)
1658: // If it doesn't, we have to wait for it to acknowledge and then continue.
1659: //*********************************************************************************
1660:
1661: IOReturn IOService::parent_postchange_up_1 ( void )
1662: {
1663: if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) {
1664: return parent_postchange_up_2(); // it did it, carry on
1665: }
1666: else {
1667: priv->machine_state = IOPMparent_postchange_up_4; // it didn't, wait for it
1668: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0);
1669: start_ack_timer();
1670: return IOPMWillAckLater;
1671: }
1672: }
1673:
1674:
1675: //*********************************************************************************
1676: // parent_postchange_up_2
1677: //
1678: // Our controlling driver has changed power state on the hardware
1679: // during a power raise initiated by the parent. Here we see if we need to wait
1680: // for power to settle before continuing. If not, we continue processing
1681: // (notifying interested parties post-change). If so, we wait and
1682: // continue later.
1683: //*********************************************************************************
1684:
1685: IOReturn IOService::parent_postchange_up_2 ( void )
1686: {
1687: priv->settle_time = compute_settle_time();
1688: if ( priv->settle_time == 0 ) {
1689: return parent_postchange_up_3();
1690: }
1691: else {
1692: priv->machine_state = IOPMparent_postchange_up_5;
1693: startSettleTimer(priv->settle_time);
1694: return IOPMWillAckLater;
1695: }
1696: }
1697:
1698:
1699: //*********************************************************************************
1700: // parent_postchange_up_4
1701: //
1702: // Our controlling driver has changed power state on the hardware
1703: // during a power raise initiated by the parent, but we had to wait for it.
1704: // Here we see if we need to wait for power to settle before continuing.
1705: // If not, we continue processing (notifying interested parties post-change).
1706: // If so, we wait and continue later.
1707: //*********************************************************************************
1708:
1709: void IOService::parent_postchange_up_4 ( void )
1710: {
1711: priv->settle_time = compute_settle_time();
1712: if ( priv->settle_time == 0 ) {
1713: parent_postchange_up_5();
1714: }
1715: else {
1716: priv->machine_state = IOPMparent_postchange_up_5;
1717: startSettleTimer(priv->settle_time);
1718: }
1719: }
1720:
1721:
1722: //*********************************************************************************
1723: // parent_postchange_up_3
1724: //
1725: // No power settling was required on a power raise initiated by the parent.
1726: // Here we notify all our interested parties post-change. If they all acknowledge,
1727: // we're done with this change note, and we can start on the next one.
1728: // Otherwise we have to wait for acknowledgements and finish up later.
1729: //*********************************************************************************
1730:
1731: IOReturn IOService::parent_postchange_up_3 ( void )
1732: {
1733: priv->machine_state = IOPMparent_postchange_up_6; // in case they don't all ack
1734: if ( notifyAll(false) == IOPMAckImplied ) {
1735: all_done();
1736: return IOPMAckImplied;
1737: }
1738: return IOPMWillAckLater; // they didn't
1739: }
1740:
1741:
1742: //*********************************************************************************
1743: // parent_postchange_up_5
1744: //
1745: // Power has settled on a power raise initiated by the parent.
1746: // Here we notify all our interested parties post-change. If they all acknowledge,
1747: // we're done with this change note, and we can start on the next one.
1748: // Otherwise we have to wait for acknowledgements and finish up later.
1749: //*********************************************************************************
1750:
1751: void IOService::parent_postchange_up_5 ( void )
1752: {
1753: priv->machine_state = IOPMparent_postchange_up_6; // in case they don't all ack
1754: if ( notifyAll(false) == IOPMAckImplied ) {
1755: parent_postchange_up_6();
1756: }
1757: }
1758:
1759:
1760: //*********************************************************************************
1761: // parent_postchange_up_6
1762: //
1763: // All parties have acknowledged our post-change notification of a power
1764: // raising initiated by the parent. Here we acknowledge the parent.
1765: // We are done with this change note, and we can start on the next one.
1766: //*********************************************************************************
1767:
1768: void IOService::parent_postchange_up_6 ( void )
1769: {
1770: all_done();
1771: pm_vars->myParent->acknowledgePowerChange(this);
1772: }
1773:
1774:
1775: //*********************************************************************************
1776: // all_done
1777: //
1778: // A power change is complete, and the used post-change note is at
1779: // the head of the queue. Remove it and set myCurrentState to the result
1780: // of the change. Start up the next change in queue.
1781: //*********************************************************************************
1782:
1783: void IOService::all_done ( void )
1784: {
1785: priv->machine_state = IOPMfinished;
1786:
1787: if ( priv->head_note_flags & IOPMWeInitiated ) {
1788: if ( !( priv->head_note_flags & IOPMNotDone) ) { // could our driver switch to the new state?
1789: pm_vars->myCurrentState = priv-> head_note_state; // yes
1790: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeDone,(unsigned long)pm_vars->myCurrentState,0);
1791: }
1792: else { // no
1793: pm_vars->myCurrentState = pm_vars->theControllingDriver->powerStateForDomainState(pm_vars->parentCurrentPowerFlags);
1794: }
1795: }
1796: if ( priv->head_note_flags & IOPMParentInitiated ) {
1797: pm_vars->myCurrentState = priv->head_note_state;
1798: pm_vars->maxCapability = pm_vars->theControllingDriver->maxCapabilityForDomainState(priv->head_note_domainState);
1799: pm_vars->parentCurrentPowerFlags = priv->head_note_domainState;
1800: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeDone,(unsigned long)pm_vars->myCurrentState,0);
1801: }
1802:
1803: priv->changeList->releaseHeadChangeNote(); // either way, we're done with this
1804:
1805: priv->head_note = priv->changeList->currentChange(); // start next one in queue
1806: if ( priv->head_note != -1 ) {
1807:
1808: if (priv->changeList->changeNote[priv->head_note].flags & IOPMWeInitiated ) {
1809: start_our_change(priv->head_note);
1810: }
1811: else {
1812: if ( start_parent_change(priv->head_note) == IOPMAckImplied ) {
1813: pm_vars->myParent->acknowledgePowerChange(this);
1814: }
1815: }
1816: }
1817: }
1818:
1819:
1820:
1821: //*********************************************************************************
1822: // all_acked
1823: //
1824: // A driver or child has acknowledged our notification of an upcoming power
1825: // change, and this acknowledgement is the last one pending
1826: // before we change power or after changing power.
1827: //
1828: //*********************************************************************************
1829:
1830: void IOService::all_acked ( void )
1831: {
1832: switch (priv->machine_state) {
1833: case IOPMour_prechange_1:
1834: our_prechange_1();
1835: break;
1836: case IOPMour_prechange_4:
1837: our_prechange_4();
1838: break;
1839: case IOPMparent_prechange_down_4:
1840: parent_prechange_down_4();
1841: break;
1842: case IOPMparent_postchange_down_2:
1843: parent_postchange_down_2();
1844: break;
1845: case IOPMparent_prechange_up_1:
1846: parent_prechange_up_1();
1847: break;
1848: case IOPMparent_postchange_up_6:
1849: parent_postchange_up_6();
1850: break;
1851: }
1852: }
1853:
1854:
1855: //*********************************************************************************
1856: // settleTimerExpired
1857: //
1858: // Power has settled after our last change. Notify interested parties that
1859: // there is a new power state.
1860: //*********************************************************************************
1861:
1862: void IOService::settleTimerExpired ( void )
1863: {
1864: switch (priv->machine_state) {
1865: case IOPMour_prechange_3:
1866: our_prechange_3();
1867: break;
1868: case IOPMparent_prechange_down_3:
1869: parent_prechange_down_3();
1870: break;
1871: case IOPMparent_postchange_up_5:
1872: parent_postchange_up_5();
1873: break;
1874: }
1875: }
1876:
1877:
1878: //*********************************************************************************
1879: // compute_settle_time
1880: //
1881: // Compute the power-settling delay in microseconds for the
1882: // change from myCurrentState to head_note_state.
1883: //*********************************************************************************
1884:
1885: unsigned long IOService::compute_settle_time ( void )
1886: {
1887: unsigned long totalTime;
1888: unsigned long i;
1889:
1890: totalTime = 0; // compute total time to attain the new state
1891: i = pm_vars->myCurrentState;
1892: if ( priv->head_note_state < pm_vars->myCurrentState ) { // we're lowering power
1893: while ( i > priv->head_note_state ) {
1894: totalTime += pm_vars->thePowerStates[i].settleDownTime;
1895: i--;
1896: }
1897: }
1898:
1899: if ( priv->head_note_state > pm_vars->myCurrentState ) { // we're raising power
1900: while ( i < priv->head_note_state ) {
1901: totalTime += pm_vars->thePowerStates[i+1].settleUpTime;
1902: i++;
1903: }
1904: }
1905:
1906: return totalTime;
1907: }
1908:
1909:
1910: //*********************************************************************************
1911: // startSettleTimer
1912: //
1913: // Enter with a power-settling delay in microseconds and start a nano-second
1914: // timer for that delay.
1915: //*********************************************************************************
1916:
1917: IOReturn IOService::startSettleTimer ( unsigned long delay )
1918: {
1919: AbsoluteTime deadline;
1920:
1921: clock_interval_to_deadline(delay, kMicrosecondScale, &deadline);
1922: thread_call_func_delayed(settle_timer_expired, (void *)this, deadline);
1923: return IOPMNoErr;
1924: }
1925:
1926: //*********************************************************************************
1927: // ack_timer_ticked
1928: //
1929: // The acknowledgement timeout periodic timer has ticked.
1930: // If we are awaiting acks for a power change notification,
1931: // we decrement the timer word of each interested driver which hasn't acked.
1932: // If a timer word becomes zero, we pretend the driver aknowledged.
1933: // If we are waiting for the controlling driver to change the power
1934: // state of the hardware, we decrement its timer word, and if it becomes
1935: // zero, we pretend the driver acknowledged.
1936: //*********************************************************************************
1937:
1938: void IOService::ack_timer_ticked ( void )
1939: {
1940: IOPMinformee * nextObject;
1941:
1942: if (! acquire_lock() ) {
1943: return;
1944: }
1945:
1946: if ( priv->driver_timer != 0 ) { // are we waiting for our driver to make its change?
1947: priv->driver_timer -= 1; // yes, tick once
1948: if ( priv->driver_timer == 0 ) { // it's tardy, we'll go on without it
1949: IOUnlock(priv->our_lock);
1950: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogCtrlDriverTardy,0,0);
1951: driver_acked();
1952: }
1953: else { // still waiting, set timer again
1954: start_ack_timer();
1955: IOUnlock(priv->our_lock);
1956: }
1957: return;
1958: }
1959:
1960: if (priv->head_note_pendingAcks != 0 ) { // are we waiting for interested parties to acknowledge?
1961: nextObject = priv->interestedDrivers->firstInList(); // yes, go through the list of interested drivers
1962: while ( nextObject != NULL ) { // and check each one
1963: if ( nextObject->timer > 0 ) {
1964: nextObject->timer -= 1;
1965: if ( nextObject->timer == 0 ) { // this one should have acked by now
1966: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogIntDriverTardy,0,0);
1967: priv->head_note_pendingAcks -= 1;
1968: }
1969: }
1970: nextObject = priv->interestedDrivers->nextInList(nextObject);
1971: }
1972: if ( priv->head_note_pendingAcks == 0 ) { // is that the last?
1973: IOUnlock(priv->our_lock);
1974: all_acked(); // yes, we can continue
1975: }
1976: else { // no, set timer again
1977: start_ack_timer();
1978: IOUnlock(priv->our_lock);
1979: }
1980: return;
1981: }
1982: IOUnlock(priv->our_lock); // not waiting for acks
1983: }
1984:
1985:
1986: //*********************************************************************************
1987: // start_ack_timer
1988: //
1989: //*********************************************************************************
1990:
1991: void IOService::start_ack_timer ( void )
1992: {
1993: AbsoluteTime deadline;
1994:
1995: clock_interval_to_deadline(ACK_TIMER_PERIOD, kNanosecondScale, &deadline);
1996: thread_call_func_delayed(ack_timer_expired, (void *)this, deadline);
1997: }
1998:
1999:
2000: //*********************************************************************************
2001: // stop_ack_timer
2002: //
2003: //*********************************************************************************
2004:
2005: void IOService::stop_ack_timer ( void )
2006: {
2007: thread_call_func_cancel(ack_timer_expired, (void *)this, true);
2008: }
2009:
2010:
2011: //*********************************************************************************
2012: // c-language timer expiration functions
2013: //
2014: //*********************************************************************************
2015:
2016: static void ack_timer_expired ( thread_call_param_t us, thread_call_param_t )
2017: {
2018: ((IOService *)us)->ack_timer_ticked();
2019: }
2020:
2021:
2022: static void settle_timer_expired ( thread_call_param_t us, thread_call_param_t )
2023: {
2024: ((IOService *)us)->settleTimerExpired();
2025: }
2026:
2027:
2028: //*********************************************************************************
2029: // add_to_active_change
2030: //
2031: // A child or interested driver has just registered with us. If there is
2032: // currently a change in progress, get the new party involved: if we
2033: // have notified all parties and are waiting for acks, notify the new
2034: // party.
2035: //*********************************************************************************
2036:
2037: IOReturn IOService::add_to_active_change ( IOPMinformee * newObject, bool is_child )
2038: {
2039: if (! acquire_lock() ) {
2040: return IOPMNoErr;
2041: }
2042:
2043: switch (priv->machine_state) {
2044: case IOPMour_prechange_1:
2045: priv->head_note_pendingAcks += 1;
2046: IOUnlock(priv->our_lock);
2047: notifyObject(newObject, true, is_child);
2048: return IOPMNoErr;
2049: case IOPMour_prechange_4:
2050: priv->head_note_pendingAcks += 1;
2051: IOUnlock(priv->our_lock);
2052: notifyObject(newObject, false, is_child);
2053: return IOPMNoErr;
2054: case IOPMparent_prechange_down_4:
2055: priv->head_note_pendingAcks += 1;
2056: IOUnlock(priv->our_lock);
2057: notifyObject(newObject, true, is_child);
2058: return IOPMNoErr;
2059: case IOPMparent_postchange_down_2:
2060: priv->head_note_pendingAcks += 1;
2061: IOUnlock(priv->our_lock);
2062: notifyObject(newObject, false, is_child);
2063: return IOPMNoErr;
2064: case IOPMparent_prechange_up_1:
2065: priv->head_note_pendingAcks += 1;
2066: IOUnlock(priv->our_lock);
2067: notifyObject(newObject, true, is_child);
2068: return IOPMNoErr;
2069: case IOPMparent_postchange_up_6:
2070: priv-> head_note_pendingAcks += 1;
2071: IOUnlock(priv->our_lock);
2072: notifyObject(newObject, false, is_child);
2073: return IOPMNoErr;
2074: }
2075: IOUnlock(priv->our_lock);
2076: return IOPMNoErr;
2077: }
2078:
2079:
2080: //*********************************************************************************
2081: // start_parent_change
2082: //
2083: // Here we begin the processing of a change note initiated by our parent
2084: // which is at the head of the queue.
2085: //
2086: // It is possible for the change to be processed to completion and removed from the queue.
2087: // There are several possible interruptions to the processing, though, and they are:
2088: // we may have to wait for interested parties to acknowledge our pre-change notification,
2089: // changes initiated by the parent will wait in the middle for powerStateDidChange,
2090: // we may have to wait for our controlling driver to change the hardware power state,
2091: // there may be a settling time after changing the hardware power state,
2092: // we may have to wait for interested parties to acknowledge our post-change notification,
2093: // we may have to wait for the acknowledgement timer expiration to substitute for the
2094: // acknowledgement from a failing driver.
2095: // We identify which of the following three possible lives the note
2096: // will have and then start the life:
2097: // 2. The parent initiated the change, and it is lowering power,
2098: // 3. The parent initiated the change, and it is raising power,
2099: // 4. The parent initiated the change, and the power state is not changing.
2100: //
2101: // In life-style 2, if all interested parties acknowledge our pre-change notification,
2102: // our controlling driver changes power states immediately without having to call us back later,
2103: // and there is no settling time required, we return IOPMAckImplied.
2104: // In life-style 3, if all interested parties acknowledge our pre-change notification, we return IOPMAckImplied.
2105: // In life-style 4, we always return IOPMAckImplied.
2106: // In any other case, we return IOPMWillAckLater.
2107: // If our caller is ultimately our powerDomainWillChange method, it will return our return code to the parent.
2108: // Otherwise, this new notification was dequeued from the queue after we finished a previous one.
2109: // In this case, an IOPMAckImplied return from here will cause the caller to explicitly acknowledge
2110: // the parent by calling its acknowledgePowerChange method.
2111: //*********************************************************************************
2112:
2113: IOReturn IOService::start_parent_change ( unsigned long queue_head )
2114: {
2115: priv->head_note = queue_head;
2116: priv-> head_note_flags = priv-> changeList->changeNote[priv->head_note].flags;
2117: priv-> head_note_state = priv->changeList->changeNote[priv->head_note].newStateNumber;
2118: priv-> head_note_outputFlags = priv->changeList->changeNote[priv->head_note].outputPowerCharacter;
2119: priv->head_note_domainState = priv->changeList->changeNote[priv->head_note].domainState;
2120: priv->head_note_capabilityFlags = priv->changeList->changeNote[priv->head_note].capabilityFlags;
2121:
2122: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartParentChange,(unsigned long)priv->head_note_state,0);
2123:
2124: ask_parent( priv->ourDesiredPowerState); // if we need something and haven't told the parent, do so
2125:
2126: if ( priv->head_note_state < pm_vars->myCurrentState ) {
2127: priv->initial_change = false; // life-style 2
2128: priv->machine_state = IOPMparent_prechange_down_4; // in case they don't all ack
2129: if ( notifyAll(true) == IOPMAckImplied ) {
2130: return parent_prechange_down_1();
2131: }
2132: return IOPMWillAckLater; // they didn't
2133: }
2134:
2135: if ( priv->head_note_state > pm_vars->myCurrentState ) { // if the parent is raising power, we may or may not
2136: if ( priv->ourDesiredPowerState > pm_vars->myCurrentState ) {
2137: if ( priv->ourDesiredPowerState < priv->head_note_state ) {
2138: priv->head_note_state = priv->ourDesiredPowerState; // we do, but not all the way
2139: priv->head_note_outputFlags = pm_vars->thePowerStates[priv->head_note_state].outputPowerCharacter;
2140: priv->head_note_capabilityFlags = pm_vars->thePowerStates[priv->head_note_state].capabilityFlags;
2141: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAmendParentChange,(unsigned long)priv->head_note_state,0);
2142: }
2143: }
2144: else {
2145: priv-> head_note_state = pm_vars->myCurrentState; // we don't
2146: priv->head_note_outputFlags = pm_vars->thePowerStates[priv->head_note_state].outputPowerCharacter;
2147: priv->head_note_capabilityFlags = pm_vars->thePowerStates[priv->head_note_state].capabilityFlags;
2148: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAmendParentChange,(unsigned long)priv->head_note_state,0);
2149: }
2150: }
2151:
2152: if ( priv->head_note_state > pm_vars->myCurrentState ) {
2153: priv->initial_change = false; // life-style 3
2154: priv->machine_state = IOPMparent_prechange_up_1; // in case they don't all ack
2155: if ( notifyAll(true) == IOPMAckImplied ) {
2156: priv->machine_state = IOPMparent_postchange_up_1;
2157: return IOPMAckImplied;
2158: }
2159: return IOPMWillAckLater; // they didn't
2160: }
2161:
2162: if ( priv->head_note_state == pm_vars->myCurrentState ) {
2163: priv->machine_state = IOPMparent_postchange_null; // life-style 4
2164: return IOPMAckImplied;
2165: }
2166: return IOPMAckImplied; // something wrong
2167: }
2168:
2169:
2170: //*********************************************************************************
2171: // start_our_change
2172: //
2173: // Here we begin the processing of a change note initiated by us
2174: // which is at the head of the queue.
2175: //
2176: // It is possible for the change to be processed to completion and removed from the queue.
2177: // There are several possible interruptions to the processing, though, and they are:
2178: // we may have to wait for interested parties to acknowledge our pre-change notification,
2179: // changes initiated by the parent will wait in the middle for powerStateDidChange,
2180: // we may have to wait for our controlling driver to change the hardware power state,
2181: // there may be a settling time after changing the hardware power state,
2182: // we may have to wait for interested parties to acknowledge our post-change notification,
2183: // we may have to wait for the acknowledgement timer expiration to substitute for the
2184: // acknowledgement from a failing driver.
2185: //*********************************************************************************
2186:
2187: void IOService::start_our_change ( unsigned long queue_head )
2188: {
2189: priv->head_note = queue_head;
2190: priv->head_note_flags = priv->changeList->changeNote[priv->head_note].flags;
2191: priv->head_note_state = priv->changeList->changeNote[priv->head_note].newStateNumber;
2192: priv->head_note_outputFlags = priv->changeList->changeNote[priv->head_note].outputPowerCharacter;
2193: priv->head_note_capabilityFlags = priv->changeList->changeNote[priv->head_note].capabilityFlags;
2194:
2195: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartDeviceChange,(unsigned long)priv->head_note_state,0);
2196:
2197: if ( ! priv->we_are_root ) {
2198: ask_parent(priv->head_note_state); // if this changes our power requirement, tell the parent
2199: }
2200:
2201: if ( priv->head_note_capabilityFlags & IOPMNotAttainable ) { // can our driver switch to the new state?
2202: priv-> head_note_flags |= IOPMNotDone; // no, mark the change note un-actioned
2203: all_done(); // and we're done
2204: return; // let the parent make the change for us
2205: }
2206: if ( (pm_vars->maxCapability < priv->head_note_state) && (! priv->we_are_root) ) { // is there enough power in the domain?
2207: priv->head_note_flags |= IOPMNotDone; // no, mark the change note un-actioned
2208: all_done(); // and we're done
2209: return; // till the parent raises power
2210: }
2211:
2212: if ( ! priv->initial_change ) {
2213: if ( priv->head_note_state == pm_vars->myCurrentState ) {
2214: all_done(); // we initiated a null change; forget it
2215: return;
2216: }
2217: }
2218: priv->initial_change = false;
2219:
2220: priv->machine_state = IOPMour_prechange_1; // in case they don't all ack
2221: if ( notifyAll(true) == IOPMAckImplied ) { // in life-style 1
2222: our_prechange_1();
2223: }
2224: }
2225:
2226:
2227: //*********************************************************************************
2228: // ask_parent
2229: //
2230: // Call the power domain parent to ask for a higher power state in the domain
2231: // or to suggest a lower power state.
2232: //*********************************************************************************
2233:
2234: IOReturn IOService::ask_parent ( unsigned long requestedState )
2235: {
2236: unsigned long savedPreviousRequest;
2237: IOReturn return_code;
2238:
2239: if ( priv->previousRequest == pm_vars->thePowerStates[requestedState].inputPowerRequirement ) { // is this a new desire?
2240: return IOPMNoErr; // no, the parent knows already, just return
2241: }
2242:
2243: if ( priv->we_are_root ) {
2244: return IOPMNoErr;
2245: }
2246: savedPreviousRequest = priv->previousRequest; // yes, remember our previous request for a second
2247: priv->previousRequest = pm_vars->thePowerStates[requestedState].inputPowerRequirement;
2248: return_code = pm_vars->myParent->requestDomainState( priv->previousRequest,this,IOPMLowestState);
2249:
2250: if ( return_code != IOPMNoErr ) { // if that was not ok with the parent,
2251:
2252: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRequestDenied,(unsigned long)priv->previousRequest,0);
2253: priv->previousRequest = savedPreviousRequest; // remember our previous desire
2254: }
2255: return return_code;
2256: }
2257:
2258:
2259: //*********************************************************************************
2260: // instruct_driver
2261: //
2262: // Call the controlling driver and have it change the power state of the
2263: // hardware. If it returns IOPMAckImplied, the change is complete, and
2264: // we return IOPMAckImplied. Otherwise, it will ack when the change
2265: // is done; we return IOPMWillAckLater.
2266: //*********************************************************************************
2267:
2268: IOReturn IOService::instruct_driver ( unsigned long newState )
2269: {
2270: IOReturn return_code;
2271:
2272: if ( pm_vars->thePowerStates[newState].capabilityFlags & IOPMNotAttainable ) { // can our driver switch to the desired state?
2273: return IOPMAckImplied; // no, so don't try
2274: }
2275: priv->driver_timer = -1;
2276: pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogProgramHardware,newState,0);
2277: return_code = pm_vars->theControllingDriver->setPowerState( newState,this ); // yes, instruct it
2278: if ( return_code == IOPMAckImplied ) { // it finished
2279: priv->driver_timer = 0;
2280: return IOPMAckImplied;
2281: }
2282:
2283: if ( priv->driver_timer == 0 ) { // it acked behind our back
2284: return IOPMAckImplied;
2285: }
2286:
2287: if ( return_code < 0 ) { // somebody goofed
2288: return IOPMAckImplied;
2289: }
2290:
2291: priv->driver_timer = (return_code / 1000) + 1; // it didn't finish
2292: return IOPMWillAckLater;
2293: }
2294:
2295:
2296: //*********************************************************************************
2297: // acquire_lock
2298: //
2299: // We are acquiring the lock we use to protect our queue head from
2300: // simutaneous access by a thread which calls acknowledgePowerStateChange
2301: // or acknowledgeSetPowerState and the ack timer expiration thread.
2302: // Return TRUE if we acquire the lock, and the queue head didn't change
2303: // while we were acquiring the lock (and maybe blocked).
2304: // If there is no queue head, or it changes while we are blocked,
2305: // return FALSE with the lock unlocked.
2306: //*********************************************************************************
2307:
2308: bool IOService::acquire_lock ( void )
2309: {
2310: long current_change_note;
2311:
2312: current_change_note = priv->head_note;
2313: if ( current_change_note == -1 ) {
2314: return FALSE;
2315: }
2316:
2317: IOTakeLock(priv->our_lock);
2318: if ( current_change_note == priv->head_note ) {
2319: return TRUE;
2320: }
2321: else { // we blocked and something changed radically
2322: IOUnlock(priv->our_lock); // so there's nothing to do any more
2323: return FALSE;
2324: }
2325: }
2326:
2327:
2328: //*********************************************************************************
2329: // foundDevice
2330: //
2331: // Does nothing here. This should be implemented in a subclass driver.
2332: //*********************************************************************************
2333: #if BREAK
2334: IOReturn IOService::foundDevice ( IOService * yourDevice )
2335: {
2336: return IOPMNoErr;
2337: }
2338: #endif
2339:
2340: //*********************************************************************************
2341: // setPowerState
2342: //
2343: // Does nothing here. This should be implemented in a subclass driver.
2344: //*********************************************************************************
2345:
2346: IOReturn IOService::setPowerState ( unsigned long powerStateOrdinal, IOService* whatDevice )
2347: {
2348: return IOPMNoErr;
2349: }
2350:
2351:
2352: //*********************************************************************************
2353: // maxCapabilityForDomainState
2354: //
2355: // Finds the highest power state in the array whose input power
2356: // requirement is equal to the input parameter. Where a more intelligent
2357: // decision is possible, override this in the subclassed driver.
2358: //*********************************************************************************
2359:
2360: unsigned long IOService::maxCapabilityForDomainState ( IOPMPowerFlags domainState )
2361: {
2362: int i;
2363:
2364: if (pm_vars->theNumberOfPowerStates == 0 ) {
2365: return 0;
2366: }
2367: for ( i = (pm_vars->theNumberOfPowerStates)-1; i >= 0; i-- ) {
2368: if ( pm_vars->thePowerStates[i].inputPowerRequirement == domainState ) {
2369: return i;
2370: }
2371: }
2372: return 0;
2373: }
2374:
2375:
2376: //*********************************************************************************
2377: // initialPowerStateForDomainState
2378: //
2379: // Finds the highest power state in the array whose input power
2380: // requirement is equal to the input parameter. Where a more intelligent
2381: // decision is possible, override this in the subclassed driver.
2382: //*********************************************************************************
2383:
2384: unsigned long IOService::initialPowerStateForDomainState ( IOPMPowerFlags domainState )
2385: {
2386: int i;
2387:
2388: if (pm_vars->theNumberOfPowerStates == 0 ) {
2389: return 0;
2390: }
2391: for ( i = (pm_vars->theNumberOfPowerStates)-1; i >= 0; i-- ) {
2392: if ( pm_vars->thePowerStates[i].inputPowerRequirement == domainState ) {
2393: return i;
2394: }
2395: }
2396: return 0;
2397: }
2398:
2399:
2400: //*********************************************************************************
2401: // powerStateForDomainState
2402: //
2403: // Finds the highest power state in the array whose input power
2404: // requirement is equal to the input parameter. Where a more intelligent
2405: // decision is possible, override this in the subclassed driver.
2406: //*********************************************************************************
2407:
2408: unsigned long IOService::powerStateForDomainState ( IOPMPowerFlags domainState )
2409: {
2410: int i;
2411:
2412: if (pm_vars->theNumberOfPowerStates == 0 ) {
2413: return 0;
2414: }
2415: for ( i = (pm_vars->theNumberOfPowerStates)-1; i >= 0; i-- ) {
2416: if ( pm_vars->thePowerStates[i].inputPowerRequirement == domainState ) {
2417: return i;
2418: }
2419: }
2420: return 0;
2421: }
2422:
2423:
2424: //*********************************************************************************
2425: // powerStateWillChangeTo
2426: //
2427: // Does nothing here. This should be implemented in a subclass driver.
2428: //*********************************************************************************
2429:
2430: IOReturn IOService::powerStateWillChangeTo ( IOPMPowerFlags, unsigned long, IOService*)
2431: {
2432: return 0;
2433: }
2434:
2435:
2436: //*********************************************************************************
2437: // powerStateDidChangeTo
2438: //
2439: // Does nothing here. This should be implemented in a subclass driver.
2440: //*********************************************************************************
2441:
2442: IOReturn IOService::powerStateDidChangeTo ( IOPMPowerFlags, unsigned long, IOService*)
2443: {
2444: return 0;
2445: }
2446:
2447:
2448: //*********************************************************************************
2449: // newTemperature
2450: //
2451: // Does nothing here. This should be implemented in a subclass driver.
2452: //*********************************************************************************
2453:
2454: IOReturn IOService::newTemperature ( long currentTemp, IOService * whichZone )
2455:
2456: {
2457: return IOPMNoErr;
2458: }
2459:
2460:
2461: #undef super
2462: #define super OSObject
2463:
2464: OSDefineMetaClassAndStructors(IOPMprot, OSObject)
2465: //*********************************************************************************
2466: // serialize
2467: //
2468: // Serialize protected instance variables for debug output.
2469: //*********************************************************************************
2470: bool IOPMprot::serialize(OSSerialize *s) const
2471: {
2472: OSString * theOSString;
2473: char * buffer;
2474: char * ptr;
2475: int i;
2476: bool rtn_code;
2477:
2478: buffer = ptr = IONew(char, 2000);
2479: if(!buffer)
2480: return false;
2481:
2482: ptr += sprintf(ptr,"{ theNumberOfPowerStates = %d, ",(unsigned int)theNumberOfPowerStates);
2483:
2484: if ( theNumberOfPowerStates != 0 ) {
2485: ptr += sprintf(ptr,"version %d, ",(unsigned int)thePowerStates[0].version);
2486: }
2487:
2488: if ( theNumberOfPowerStates != 0 ) {
2489: for ( i = 0; i < (int)theNumberOfPowerStates; i++ ) {
2490: ptr += sprintf(ptr,"power state %d = { ",i);
2491: ptr += sprintf(ptr,"capabilityFlags %08x, ",(unsigned int)thePowerStates[i].capabilityFlags);
2492: ptr += sprintf(ptr,"outputPowerCharacter %08x, ",(unsigned int)thePowerStates[i].outputPowerCharacter);
2493: ptr += sprintf(ptr,"inputPowerRequirement %08x, ",(unsigned int)thePowerStates[i].inputPowerRequirement);
2494: ptr += sprintf(ptr,"staticPower %d, ",(unsigned int)thePowerStates[i].staticPower);
2495: ptr += sprintf(ptr,"unbudgetedPower %d, ",(unsigned int)thePowerStates[i].unbudgetedPower);
2496: ptr += sprintf(ptr,"powerToAttain %d, ",(unsigned int)thePowerStates[i].powerToAttain);
2497: ptr += sprintf(ptr,"timeToAttain %d, ",(unsigned int)thePowerStates[i].timeToAttain);
2498: ptr += sprintf(ptr,"settleUpTime %d, ",(unsigned int)thePowerStates[i].settleUpTime);
2499: ptr += sprintf(ptr,"timeToLower %d, ",(unsigned int)thePowerStates[i].timeToLower);
2500: ptr += sprintf(ptr,"settleDownTime %d, ",(unsigned int)thePowerStates[i].settleDownTime);
2501: ptr += sprintf(ptr,"powerDomainBudget %d }, ",(unsigned int)thePowerStates[i].powerDomainBudget);
2502: }
2503: }
2504:
2505: ptr += sprintf(ptr,"aggressiveness = %d, ",(unsigned int)aggressiveness);
2506: ptr += sprintf(ptr,"myCurrentState = %d, ",(unsigned int)myCurrentState);
2507: ptr += sprintf(ptr,"parentCurrentPowerFlags = %08x, ",(unsigned int)parentCurrentPowerFlags);
2508: ptr += sprintf(ptr,"maxCapability = %d }",(unsigned int)maxCapability);
2509:
2510: theOSString = OSString::withCString(buffer);
2511: rtn_code = theOSString->serialize(s);
2512: theOSString->release();
2513: IODelete(buffer, char, 2000);
2514:
2515: return rtn_code;
2516: }
2517:
2518:
2519: #undef super
2520: #define super OSObject
2521:
2522: OSDefineMetaClassAndStructors(IOPMpriv, OSObject)
2523: //*********************************************************************************
2524: // serialize
2525: //
2526: // Serialize private instance variables for debug output.
2527: //*********************************************************************************
2528: bool IOPMpriv::serialize(OSSerialize *s) const
2529: {
2530: OSString * theOSString;
2531: char * buffer;
2532: char * ptr;
2533: IOPMinformee * nextObject;
2534: bool rtn_code;
2535:
2536: buffer = ptr = IONew(char, 2000);
2537: if(!buffer)
2538: return false;
2539:
2540: ptr += sprintf(ptr,"{ this object = %08x",(unsigned int)owner);
2541: if ( we_are_root ) {
2542: ptr += sprintf(ptr," (root)");
2543: }
2544: ptr += sprintf(ptr,", ");
2545:
2546: nextObject = interestedDrivers->firstInList(); // display interested drivers
2547: while ( nextObject != NULL ) {
2548: ptr += sprintf(ptr,"interested driver = %08x, ",(unsigned int)nextObject->whatObject);
2549: nextObject = interestedDrivers->nextInList(nextObject);
2550: }
2551:
2552: nextObject =children->firstInList(); // display power domain children
2553: while ( nextObject != NULL ) {
2554: ptr += sprintf(ptr,"child = %08x, ",(unsigned int)nextObject->whatObject);
2555: nextObject = children->nextInList(nextObject);
2556: }
2557:
2558: ptr += sprintf(ptr,"numberOfInformees = %d, ",(unsigned int)numberOfInformees);
2559:
2560: if ( machine_state != IOPMfinished ) {
2561: ptr += sprintf(ptr,"machine_state = %d, ",(unsigned int)machine_state);
2562: ptr += sprintf(ptr,"driver_timer = %d, ",(unsigned int)driver_timer);
2563: ptr += sprintf(ptr,"settle_time = %d, ",(unsigned int)settle_time);
2564: ptr += sprintf(ptr,"head_note_flags = %08x, ",(unsigned int)head_note_flags);
2565: ptr += sprintf(ptr,"head_note_state = %d, ",(unsigned int)head_note_state);
2566: ptr += sprintf(ptr,"head_note_outputFlags = %08x, ",(unsigned int)head_note_outputFlags);
2567: ptr += sprintf(ptr,"head_note_domainState = %08x, ",(unsigned int)head_note_domainState);
2568: ptr += sprintf(ptr,"head_note_capabilityFlags = %08x, ",(unsigned int)head_note_capabilityFlags);
2569: ptr += sprintf(ptr,"head_note_pendingAcks = %d, ",(unsigned int)head_note_pendingAcks);
2570: }
2571:
2572: if ( device_overrides ) {
2573: ptr += sprintf(ptr,"device overrides, ");
2574: }
2575: ptr += sprintf(ptr,"driverDesire = %d, ",(unsigned int)driverDesire);
2576: ptr += sprintf(ptr,"deviceDesire = %d, ",(unsigned int)deviceDesire);
2577: ptr += sprintf(ptr,"ourDesiredPowerState = %d, ",(unsigned int)ourDesiredPowerState);
2578: ptr += sprintf(ptr,"previousRequest = %d }",(unsigned int)previousRequest);
2579:
2580: theOSString = OSString::withCString(buffer);
2581: rtn_code = theOSString->serialize(s);
2582: theOSString->release();
2583: IODelete(buffer, char, 2000);
2584:
2585: return rtn_code;
2586: }
2587:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.