iokit/Kernel/IOServicePM.cpp

294       parent.
310         time, the parent decides to lower or raise the power state of the entire
327  state, we suggest to the parent that it lower the power domain state.
330 How a change to a lower power domain state initiated by the parent is handled:
337     -> Then we acknowledge our preparedness to our parent.  When all its
344 How a change to a higher power domain state initiated by the parent is handled:
347     -> If it is different from our current state we acknowledge the parent.
348     -> When all the parent's interested parties have acknowledged, it raises
363         do but acknowledge the parent.  So when the parent calls our
365         state, we merely acknowledge the parent, via return code, and wait.
366  When the parent subsequently calls powerStateDidChange, we acknowledge again
375  The fourth is nearly trivial.  In this path, the parent is changing the domain
377  parent calls powerDomainWillChange.  All we do is acknowledge the parent. When
378  the parent calls powerStateDidChange, we acknowledge the parent again, and
388  These are all power changes initiated by us, not forced upon us by the parent.
426 Note all parent requested changes need to acknowledge the power has changed to the parent when done.
974 // Step 1/3 of adding a power child. Called on the power parent.
1007 	IOService *         parent;
1014 	parent = (IOService *) connection->getParentEntry(gIOPowerPlane);
1016 	if (!parent || !inPlane(gIOPowerPlane))
1023 	// It is safe to directly access parent's vars.
1025 	knowsState = (parent->fPowerStates) && (parent->fParentsKnowState);
1026 	powerState = parent->fCurrentPowerState;
1029 		powerFlags = parent->fPowerStates[powerState].outputPowerFlags;
1033 	// Set our power parent.
1056 // Step 3/3 of adding a power child. Called on the parent.
1092 // Power Management is informing us who our parent is.
1108 // Called on a parent whose child is being removed by PMstop().
1155     // The fPendingAdjustPowerRequest helps to reduce redundant parent work.
1495 // That may include acknowledging to our parent.  In this case, we do it
1496 // last of all to insure that this doesn't cause the parent to call us some-
1687 			 /* parent flags */	0);
1759 			 /* parent flags */	0);
1767 // Called by the power-hierarchy parent notifying of a new power state
1769 // We enqueue a parent power-change to our queue of power changes.
1840         // Absorb parent's kIOPMSynchronize flag.
1849 				 /* parent flags */	parentPowerFlags);
1852 	// If parent is dropping power, immediately update the parent's
1853 	// capability flags. Any future merging of parent(s) combined
1863 	// still required to issue an ACK to our parent.
1867 		IOService * parent;
1868 		parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane);
1869 		assert(parent);
1870 		if ( parent )
1872 			parent->acknowledgePowerChange( whichParent );
1873 			parent->release();
1886 // Called by the power-hierarchy parent after the power state of the power domain
1888 // We enqueue a parent power-change to our queue of power changes.
1948         // Absorb parent's kIOPMSynchronize flag.
1957 				 /* parent flags */	0);
1962 	// still required to issue an ACK to our parent.
1966 		IOService * parent;
1967 		parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane);
1968 		assert(parent);
1969 		if ( parent )
1971 			parent->acknowledgePowerChange( whichParent );
1972 			parent->release();
1976 	// If the parent registers its power driver late, then this is the
1977 	// first opportunity to tell our parent about our desire.
1994 // Set our connection data for one specific parent, and then combine all the parent
2013     // recompute our parent info
2083 // Called on a power parent when a child's power requirement changes.
2117     // Merge in the power flags contributed by this power parent
2131 			// The child must not wait for this parent to raise power
2134 			// re-evaluate the parent's power state.
2158 			// parent is transitioning upwards. If a request arrives after
2182     // Conditions that warrants a power adjustment on this parent.
2751     IOService *             parent;
2762                 parent = (IOService *) connection->copyParentEntry(gIOPowerPlane);
2763                 if (parent)
2765                     (*applier)(parent, context);
2766                     parent->release();
4128 			// we changed, tell our parent
4168     // parent's power change
4283         // new power state. However a parent may have already committed to
4291         // then the child will signal the parent to adjust power, and the child
4296         // Reserve parent power necessary to achieve fHeadNotePowerState.
4323     IOService *                     parent;
4328     parent = (IOService *) connection->copyParentEntry(gIOPowerPlane);
4329     if (!parent)
4337         parent->requestPowerDomainState(
4343     parent->release();
4595 // Here we begin the processing of a power change initiated by our parent.
4606         // Piggy-back idle timer cancellation on a parent down
4730 // parent. Wait for the driver specified settle time to expire.
4742 // Power has settled on a power change initiated by our parent. Here we notify
4768 // Acknowledge our power parent that our power change is done.
4774     IOService *			parent;
4779     parent = (IOService *)nub->copyParentEntry(gIOPowerPlane);
4780     if ( parent )
4782         parent->acknowledgePowerChange((IOService *)nub);
4783         parent->release();