/*
- * Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2014 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
-/*
- * HISTORY
- */
#include <IOKit/IOCPU.h>
#include <IOKit/IODeviceTreeSupport.h>
#include <IOKit/IOKitKeys.h>
#include <IOKit/IOTimeStamp.h>
#include <IOKit/IOUserClient.h>
+#include <IOKit/IOKitDiagnosticsUserClient.h>
#include <IOKit/system.h>
#include <libkern/c++/OSContainers.h>
#include <libkern/crypto/sha1.h>
+#include <libkern/OSAtomic.h>
extern "C" {
#include <machine/machine_routines.h>
#include <uuid/uuid.h>
}
-/* Delay period for UPS halt */
-#define kUPSDelayHaltCPU_msec (1000*60*5)
-
void printDictionaryKeys (OSDictionary * inDictionary, char * inMsg);
static void getCStringForObject(OSObject *inObj, char *outStr, size_t outStrLen);
OSDefineMetaClassAndStructors(IOPlatformExpert, IOService)
OSMetaClassDefineReservedUsed(IOPlatformExpert, 0);
-
OSMetaClassDefineReservedUsed(IOPlatformExpert, 1);
-OSMetaClassDefineReservedUnused(IOPlatformExpert, 2);
-OSMetaClassDefineReservedUnused(IOPlatformExpert, 3);
-OSMetaClassDefineReservedUnused(IOPlatformExpert, 4);
+OSMetaClassDefineReservedUsed(IOPlatformExpert, 2);
+OSMetaClassDefineReservedUsed(IOPlatformExpert, 3);
+OSMetaClassDefineReservedUsed(IOPlatformExpert, 4);
+
OSMetaClassDefineReservedUnused(IOPlatformExpert, 5);
OSMetaClassDefineReservedUnused(IOPlatformExpert, 6);
OSMetaClassDefineReservedUnused(IOPlatformExpert, 7);
static IOPlatformExpert * gIOPlatform;
static OSDictionary * gIOInterruptControllers;
static IOLock * gIOInterruptControllersLock;
+static IODTNVRAM *gIOOptionsEntry;
OSSymbol * gPlatformInterruptControllerName;
// Override the mapper present flag is requested by boot arguments.
if (PE_parse_boot_argn("dart", &debugFlags, sizeof (debugFlags)) && (debugFlags == 0))
removeProperty(kIOPlatformMapperPresentKey);
-
+ if (PE_parse_boot_argn("-x", &debugFlags, sizeof (debugFlags)))
+ removeProperty(kIOPlatformMapperPresentKey);
+
// Register the presence or lack thereof a system
// PCI address mapper with the IOMapper class
IOMapper::setMapperRequired(0 != getProperty(kIOPlatformMapperPresentKey));
{
if (type == kPEPanicSync) return 0;
- if (type == kPEHangCPU) while (1);
+ if (type == kPEHangCPU) while (true) {}
if (type == kPEUPSDelayHaltCPU) {
- // Stall shutdown for 5 minutes, and if no outside force has
- // removed our power at that point, proceed with a reboot.
- IOSleep( kUPSDelayHaltCPU_msec );
-
- // Ideally we never reach this point.
-
- type = kPERestartCPU;
+ // RestartOnPowerLoss feature was turned on, proceed with shutdown.
+ type = kPEHaltCPU;
}
// On ARM kPEPanicRestartCPU is supported in the drivers
if (type == kPEPanicRestartCPU)
type = kPERestartCPU;
-
+
if (PE_halt_restart) return (*PE_halt_restart)(type);
else return -1;
}
return kIOReturnSuccess;
}
+IOReturn IOPlatformExpert::deregisterInterruptController(OSSymbol *name)
+{
+ IOLockLock(gIOInterruptControllersLock);
+
+ gIOInterruptControllers->removeObject(name);
+
+ IOLockUnlock(gIOInterruptControllersLock);
+
+ return kIOReturnSuccess;
+}
+
IOInterruptController *IOPlatformExpert::lookUpInterruptController(OSSymbol *name)
{
OSObject *object;
return true;
}
+void IOPlatformExpert::getUTCTimeOfDay(clock_sec_t * secs, clock_nsec_t * nsecs)
+{
+ *secs = getGMTTimeOfDay();
+ *nsecs = 0;
+}
+
+void IOPlatformExpert::setUTCTimeOfDay(clock_sec_t secs, __unused clock_nsec_t nsecs)
+{
+ setGMTTimeOfDay(secs);
+}
+
//*********************************************************************************
// PMLog
PMLog(const char *who, unsigned long event,
unsigned long param1, unsigned long param2)
{
- UInt32 debugFlags = gIOKitDebug;
-
- if (debugFlags & kIOLogPower) {
-
- uint32_t nows, nowus;
+ clock_sec_t nows;
+ clock_usec_t nowus;
clock_get_system_microtime(&nows, &nowus);
nowus += (nows % 1000) * 1000000;
- kprintf("pm%u %x %.30s %d %x %x\n",
- nowus, (unsigned) current_thread(), who, // Identity
- (int) event, param1, param2); // Args
-
- if (debugFlags & kIOLogTracePower) {
- static const UInt32 sStartStopBitField[] =
- { 0x00000000, 0x00000040 }; // Only Program Hardware so far
-
- // Arcane formula from Hacker's Delight by Warren
- // abs(x) = ((int) x >> 31) ^ (x + ((int) x >> 31))
- UInt32 sgnevent = ((long) event >> 31);
- UInt32 absevent = sgnevent ^ (event + sgnevent);
- UInt32 code = IODBG_POWER(absevent);
-
- UInt32 bit = 1 << (absevent & 0x1f);
- if (absevent < sizeof(sStartStopBitField) * 8
- && (sStartStopBitField[absevent >> 5] & bit) ) {
- // Or in the START or END bits, Start = 1 & END = 2
- // If sgnevent == 0 then START - 0 => START
- // else if sgnevent == -1 then START - -1 => END
- code |= DBG_FUNC_START - sgnevent;
- }
-
- // Record the timestamp, wish I had a this pointer
- IOTimeStampConstant(code, (UInt32) who, event, param1, param2);
- }
- }
+ kprintf("pm%u %p %.30s %d %lx %lx\n",
+ nowus, OBFUSCATE(current_thread()), who, // Identity
+ (int) event, (long)OBFUSCATE(param1), (long)OBFUSCATE(param2)); // Args
}
root->init();
root->attach(this);
root->start(this);
- root->youAreRoot();
}
thread_call_param_t p0,
thread_call_param_t p1)
{
- int type = (int)p0;
+ int type = (int)(long)p0;
/* 30 seconds has elapsed - resume shutdown */
if(gIOPlatform) gIOPlatform->haltRestart(type);
int PEHaltRestart(unsigned int type)
{
- IOPMrootDomain *pmRootDomain = IOService::getPMRootDomain();
+ IOPMrootDomain *pmRootDomain;
AbsoluteTime deadline;
thread_call_t shutdown_hang;
- unsigned int tell_type;
+ IORegistryEntry *node;
+ OSData *data;
+ uint32_t timeout = 30;
if(type == kPEHaltCPU || type == kPERestartCPU || type == kPEUPSDelayHaltCPU)
{
+ pmRootDomain = IOService::getPMRootDomain();
/* Notify IOKit PM clients of shutdown/restart
Clients subscribe to this message with a call to
IOService::registerInterest()
/* Spawn a thread that will panic in 30 seconds.
If all goes well the machine will be off by the time
- the timer expires.
+ the timer expires. If the device wants a different
+ timeout, use that value instead of 30 seconds.
*/
+#define RESTART_NODE_PATH "/chosen"
+ node = IORegistryEntry::fromPath( RESTART_NODE_PATH, gIODTPlane );
+ if ( node ) {
+ data = OSDynamicCast( OSData, node->getProperty( "halt-restart-timeout" ) );
+ if ( data && data->getLength() == 4 )
+ timeout = *((uint32_t *) data->getBytesNoCopy());
+ }
+
shutdown_hang = thread_call_allocate( &IOShutdownNotificationsTimedOut,
- (thread_call_param_t) type);
- clock_interval_to_deadline( 30, kSecondScale, &deadline );
+ (thread_call_param_t)(uintptr_t) type);
+ clock_interval_to_deadline( timeout, kSecondScale, &deadline );
thread_call_enter1_delayed( shutdown_hang, 0, deadline );
-
-
- if( kPEUPSDelayHaltCPU == type ) {
- tell_type = kPEHaltCPU;
- } else {
- tell_type = type;
- }
- pmRootDomain->handlePlatformHaltRestart(tell_type);
+ pmRootDomain->handlePlatformHaltRestart(type);
/* This notification should have few clients who all do
their work synchronously.
replies.
*/
}
+ else if(type == kPEPanicRestartCPU || type == kPEPanicSync)
+ {
+ IOCPURunPlatformPanicActions(type);
+ }
if (gIOPlatform) return gIOPlatform->haltRestart(type);
else return -1;
else return 0;
}
-long PEGetGMTTimeOfDay(void)
+
+
+inline static int init_gIOOptionsEntry(void)
{
- long result = 0;
+ IORegistryEntry *entry;
+ void *nvram_entry;
+ volatile void **options;
+ int ret = -1;
- if( gIOPlatform)
- result = gIOPlatform->getGMTTimeOfDay();
+ if (gIOOptionsEntry)
+ return 0;
+
+ entry = IORegistryEntry::fromPath( "/options", gIODTPlane );
+ if (!entry)
+ return -1;
+
+ nvram_entry = (void *) OSDynamicCast(IODTNVRAM, entry);
+ if (!nvram_entry)
+ goto release;
+
+ options = (volatile void **) &gIOOptionsEntry;
+ if (!OSCompareAndSwapPtr(NULL, nvram_entry, options)) {
+ ret = 0;
+ goto release;
+ }
+
+ return 0;
+
+release:
+ entry->release();
+ return ret;
+
+}
+
+/* pass in a NULL value if you just want to figure out the len */
+boolean_t PEReadNVRAMProperty(const char *symbol, void *value,
+ unsigned int *len)
+{
+ OSObject *obj;
+ OSData *data;
+ unsigned int vlen;
+
+ if (!symbol || !len)
+ goto err;
+
+ if (init_gIOOptionsEntry() < 0)
+ goto err;
+
+ vlen = *len;
+ *len = 0;
+
+ obj = gIOOptionsEntry->getProperty(symbol);
+ if (!obj)
+ goto err;
+
+ /* convert to data */
+ data = OSDynamicCast(OSData, obj);
+ if (!data)
+ goto err;
- return (result);
+ *len = data->getLength();
+ vlen = min(vlen, *len);
+ if (value && vlen)
+ memcpy((void *) value, data->getBytesNoCopy(), vlen);
+
+ return TRUE;
+
+err:
+ return FALSE;
+}
+
+boolean_t
+PEWriteNVRAMBooleanProperty(const char *symbol, boolean_t value)
+{
+ const OSSymbol *sym = NULL;
+ OSBoolean *data = NULL;
+ bool ret = false;
+
+ if (symbol == NULL) {
+ goto exit;
+ }
+
+ if (init_gIOOptionsEntry() < 0) {
+ goto exit;
+ }
+
+ if ((sym = OSSymbol::withCStringNoCopy(symbol)) == NULL) {
+ goto exit;
+ }
+
+ data = value ? kOSBooleanTrue : kOSBooleanFalse;
+ ret = gIOOptionsEntry->setProperty(sym, data);
+
+ sym->release();
+
+ /* success, force the NVRAM to flush writes */
+ if (ret == true) {
+ gIOOptionsEntry->sync();
+ }
+
+exit:
+ return ret;
+}
+
+boolean_t PEWriteNVRAMProperty(const char *symbol, const void *value,
+ const unsigned int len)
+{
+ const OSSymbol *sym;
+ OSData *data;
+ bool ret = false;
+
+ if (!symbol || !value || !len)
+ goto err;
+
+ if (init_gIOOptionsEntry() < 0)
+ goto err;
+
+ sym = OSSymbol::withCStringNoCopy(symbol);
+ if (!sym)
+ goto err;
+
+ data = OSData::withBytes((void *) value, len);
+ if (!data)
+ goto sym_done;
+
+ ret = gIOOptionsEntry->setProperty(sym, data);
+ data->release();
+
+sym_done:
+ sym->release();
+
+ if (ret == true) {
+ gIOOptionsEntry->sync();
+ return TRUE;
+ }
+
+err:
+ return FALSE;
+}
+
+
+boolean_t PERemoveNVRAMProperty(const char *symbol)
+{
+ const OSSymbol *sym;
+
+ if (!symbol)
+ goto err;
+
+ if (init_gIOOptionsEntry() < 0)
+ goto err;
+
+ sym = OSSymbol::withCStringNoCopy(symbol);
+ if (!sym)
+ goto err;
+
+ gIOOptionsEntry->removeProperty(sym);
+
+ sym->release();
+
+ gIOOptionsEntry->sync();
+ return TRUE;
+
+err:
+ return FALSE;
+
+}
+
+long PEGetGMTTimeOfDay(void)
+{
+ clock_sec_t secs;
+ clock_usec_t usecs;
+
+ PEGetUTCTimeOfDay(&secs, &usecs);
+ return secs;
}
void PESetGMTTimeOfDay(long secs)
{
- if( gIOPlatform)
- gIOPlatform->setGMTTimeOfDay(secs);
+ PESetUTCTimeOfDay(secs, 0);
+}
+
+void PEGetUTCTimeOfDay(clock_sec_t * secs, clock_usec_t * usecs)
+{
+ clock_nsec_t nsecs = 0;
+
+ *secs = 0;
+ if (gIOPlatform)
+ gIOPlatform->getUTCTimeOfDay(secs, &nsecs);
+
+ assert(nsecs < NSEC_PER_SEC);
+ *usecs = nsecs / NSEC_PER_USEC;
+}
+
+void PESetUTCTimeOfDay(clock_sec_t secs, clock_usec_t usecs)
+{
+ assert(usecs < USEC_PER_SEC);
+ if (gIOPlatform)
+ gIOPlatform->setUTCTimeOfDay(secs, usecs * NSEC_PER_USEC);
}
} /* extern "C" */
OSData * data;
IORegistryEntry * entry;
OSString * string = 0;
- char uuid[ 36 + 1 ];
+ uuid_string_t uuid;
entry = IORegistryEntry::fromPath( "/efi/platform", gIODTPlane );
if ( entry )
if (waitForFunction) {
_resources = waitForService(resourceMatching(functionName));
} else {
- _resources = resources();
+ _resources = getResourceService();
}
if (_resources == 0) return kIOReturnUnsupported;
} else {
dtNVRAM->attach(this);
dtNVRAM->registerService();
+ options->release();
}
}
}
// Publish the cpus.
cpus = rootEntry->childFromPath( "cpus", gIODTPlane);
if ( cpus)
+ {
createNubs( this, IODTFindMatchingEntries( cpus, kIODTExclusive, 0));
+ cpus->release();
+ }
// publish top level, minus excludeList
createNubs( this, IODTFindMatchingEntries( rootEntry, kIODTExclusive, excludeList()));
void * dtTop, void * p2, void * p3, void * p4 )
{
IORegistryEntry * dt = 0;
- void * argsData[ 4 ];
bool ok;
// dtTop may be zero on non- device tree systems
if( !ok)
return( false);
+ reserved = NULL;
workLoop = IOWorkLoop::workLoop();
if (!workLoop)
return false;
- argsData[ 0 ] = dtTop;
- argsData[ 1 ] = p2;
- argsData[ 2 ] = p3;
- argsData[ 3 ] = p4;
-
- setProperty("IOPlatformArgs", (void *)argsData, sizeof(argsData));
-
return( true);
}
return kIOReturnUnsupported;
}
+IOReturn IOPlatformExpertDevice::newUserClient( task_t owningTask, void * securityID,
+ UInt32 type, OSDictionary * properties,
+ IOUserClient ** handler )
+{
+ IOReturn err = kIOReturnSuccess;
+ IOUserClient * newConnect = 0;
+ IOUserClient * theConnect = 0;
+
+ switch (type)
+ {
+ case kIOKitDiagnosticsClientType:
+ newConnect = IOKitDiagnosticsClient::withTask(owningTask);
+ if (!newConnect) err = kIOReturnNotPermitted;
+ break;
+ default:
+ err = kIOReturnBadArgument;
+ }
+
+ if (newConnect)
+ {
+ if ((false == newConnect->attach(this))
+ || (false == newConnect->start(this)))
+ {
+ newConnect->detach( this );
+ newConnect->release();
+ }
+ else
+ theConnect = newConnect;
+ }
+
+ *handler = theConnect;
+ return (err);
+}
+
void IOPlatformExpertDevice::free()
{
if (workLoop)
OSDeclareDefaultStructors(IOPanicPlatform);
public:
- bool start(IOService * provider);
+ bool start(IOService * provider) APPLE_KEXT_OVERRIDE;
};
return false;
}
+
projects / apple / xnu.git / blobdiff