void iokit_post_constructor_init(void)
{
IORegistryEntry * root;
OSObject * obj;
root = IORegistryEntry::initialize();
assert( root );
IOService::initialize();
IOCatalogue::initialize();
IOStatistics::initialize();
OSKext::initialize();
IOUserClient::initialize();
IOMemoryDescriptor::initialize();
IORootParent::initialize();
// Initializes IOPMinformeeList class-wide shared lock
IOPMinformeeList::getSharedRecursiveLock();
obj = OSString::withCString( version );
assert( obj );
if( obj ) {
root->setProperty( kIOKitBuildVersionKey, obj );
obj->release();
}
obj = IOKitDiagnostics::diagnostics();
if( obj ) {
root->setProperty( kIOKitDiagnosticsKey, obj );
obj->release();
}
}
/******************************************************************************
* ACPIDebug::PrintTraces
******************************************************************************/
void ACPIDebug::PrintTraces()
{
for (;;)
{
// see if there are any trace items in the RING
UInt32 count = 0;
if (kIOReturnSuccess != m_pDevice->evaluateInteger("COUN", &count))
{
IOLog("ACPIDebug: evaluateObject of COUN method failed\n");
break;
}
if (!count)
break;
// gather the next item from RING and print it
OSObject* debug;
if (kIOReturnSuccess == m_pDevice->evaluateObject("FTCH", &debug) &&
NULL != debug)
{
static char buf[2048];
// got a valid object, format and print it...
FormatDebugString(debug, buf, sizeof(buf)/sizeof(buf[0]));
IOLog("ACPIDebug: %s\n", buf);
debug->release();
}
}
}
bool IOHIDEventSystemUserClient::
initWithTask(task_t owningTask, void * /* security_id */, UInt32 /* type */)
{
bool result = false;
OSObject* entitlement = copyClientEntitlement(owningTask, kIOHIDSystemUserAccessServiceEntitlement);
if (entitlement) {
result = (entitlement == kOSBooleanTrue);
entitlement->release();
}
if (!result) {
proc_t process;
process = (proc_t)get_bsdtask_info(owningTask);
char name[255];
bzero(name, sizeof(name));
proc_name(proc_pid(process), name, sizeof(name));
HIDLogError("%s is not entitled", name);
goto exit;
}
result = super::init();
require_action(result, exit, HIDLogError("failed"));
exit:
return result;
}
IOMapper * IOMapper::copyMapperForDevice(IOService * device)
{
OSObject * obj;
IOMapper * mapper;
OSDictionary * matching;
obj = device->copyProperty("iommu-parent");
if (!obj)
return (NULL);
if ((mapper = OSDynamicCast(IOMapper, obj)))
return (mapper);
matching = IOService::propertyMatching(gIOMapperIDKey, obj);
if (matching)
{
mapper = OSDynamicCast(IOMapper, IOService::waitForMatchingService(matching));
matching->release();
}
if (mapper)
device->setProperty("iommu-parent", mapper);
else
obj->release();
return (mapper);
}
bool
IOUSBNub::USBCompareProperty( OSDictionary * matching, const OSSymbol * key )
{
// We return success iff we match the key in the dictionary with the key in
// the property table.
//
OSObject *value;
bool matches = false;
OSObject *myProperty = NULL;
value = matching->getObject( key );
if ( value)
{
myProperty = copyProperty(key);
if (myProperty)
{
matches = value->isEqualTo( myProperty);
myProperty->release();
}
}
else
matches = false;
return matches;
}
//---------------------------------------------------------------------------
// Compare the properties in the supplied table to this object's properties.
bool CompareProperty( IOService * owner, OSDictionary * matching, const char * key, SInt32 * score, SInt32 increment)
{
// We return success if we match the key in the dictionary with the key in
// the property table, or if the prop isn't present
//
OSObject * value;
OSObject * property;
bool matches = true;
value = matching->getObject( key );
if( value)
{
property = owner->copyProperty( key );
if ( property )
{
matches = value->isEqualTo( property );
if (matches && score)
*score += increment;
property->release();
}
else
matches = false;
}
return matches;
}
IOReturn
IOI2CDevice::newUserClient(
task_t owningTask,
void *securityID,
UInt32 type,
OSDictionary *properties,
IOUserClient **handler)
{
IOUserClient *client;
OSObject *temp;
DLOG("%s::newUserClient\n", getName());
if (type != kIOI2CUserClientType)
return super::newUserClient(owningTask,securityID,type,properties,handler);
if (IOUserClient::clientHasPrivilege(securityID, "root") != kIOReturnSuccess)
{
ERRLOG("%s::newUserClient: Can't create user client, not privileged\n", getName());
return kIOReturnNotPrivileged;
}
temp = OSMetaClass::allocClassWithName("IOI2CUserClient");
if (!temp)
return kIOReturnNoMemory;
if (OSDynamicCast(IOUserClient, temp))
client = (IOUserClient *) temp;
else
{
temp->release();
return kIOReturnUnsupported;
}
if ( !client->initWithTask(owningTask, securityID, type, properties) )
{
client->release();
return kIOReturnBadArgument;
}
if ( !client->attach(this) )
{
client->release();
return kIOReturnUnsupported;
}
if ( !client->start(this) )
{
client->detach(this);
client->release();
return kIOReturnUnsupported;
}
*handler = client;
return kIOReturnSuccess;
}
IOMapper * IOMapper::copyMapperForDeviceWithIndex(IOService * device, unsigned int index)
{
OSData *data;
OSObject * obj;
IOMapper * mapper = NULL;
OSDictionary * matching;
obj = device->copyProperty("iommu-parent");
if (!obj) return (NULL);
if ((mapper = OSDynamicCast(IOMapper, obj))) goto found;
if ((data = OSDynamicCast(OSData, obj)))
{
if (index >= data->getLength() / sizeof(UInt32)) goto done;
data = OSData::withBytesNoCopy((UInt32 *)data->getBytesNoCopy() + index, sizeof(UInt32));
if (!data) goto done;
matching = IOService::propertyMatching(gIOMapperIDKey, data);
data->release();
}
else
matching = IOService::propertyMatching(gIOMapperIDKey, obj);
if (matching)
{
mapper = OSDynamicCast(IOMapper, IOService::waitForMatchingService(matching));
matching->release();
}
done:
if (obj) obj->release();
found:
if (mapper)
{
if (!mapper->fAllocName)
{
char name[MACH_ZONE_NAME_MAX_LEN];
char kmodname[KMOD_MAX_NAME];
vm_tag_t tag;
uint32_t kmodid;
tag = IOMemoryTag(kernel_map);
if (!(kmodid = vm_tag_get_kext(tag, &kmodname[0], KMOD_MAX_NAME)))
{
snprintf(kmodname, sizeof(kmodname), "%d", tag);
}
snprintf(name, sizeof(name), "%s.DMA.%s", kmodname, device->getName());
mapper->fAllocName = kern_allocation_name_allocate(name, 16);
}
}
return (mapper);
}
void USBInterfaceShim::setInterface(IOService* interface)
{
OSObject* prev = m_pInterface;
m_pInterface = OSDynamicCast(IOUSBInterface, interface);
if (m_pInterface)
m_pInterface->retain();
if (prev)
prev->release();
}
void USBDeviceShim::setDevice(IOService* provider)
{
OSObject* prev = m_pDevice;
m_pDevice = OSDynamicCast(IOUSBDevice, provider);
if (m_pDevice)
m_pDevice->retain();
if (prev)
prev->release();
}
OSDictionary*
IOFireWireUserClientIniter::dictionaryDeepCopy(
OSDictionary* srcDictionary)
{
//IOLog( "IOFireWireUserClientIniter<0x%08lx>::dictionaryDeepCopy - srcDictionary = 0x%08lx\n", this, srcDictionary );
OSDictionary* result = NULL;
OSObject* srcObject = NULL;
OSCollectionIterator* srcIterator = NULL;
OSSymbol* keyObject = NULL;
result = OSDictionary::withCapacity(srcDictionary->getCount());
if (result)
{
srcIterator = OSCollectionIterator::withCollection(srcDictionary);
if (srcIterator)
{
while ( (keyObject = OSDynamicCast(OSSymbol, srcIterator->getNextObject())) )
{
srcObject = srcDictionary->getObject(keyObject);
if (OSDynamicCast(OSDictionary, srcObject))
{
srcObject = dictionaryDeepCopy((OSDictionary*)srcObject);
result->setObject(keyObject, srcObject);
// copyDictionaryProperty creates a new dictionary, so we should release
// it after we add it to our dictionary
srcObject->release();
}
else
{
result->setObject(keyObject, srcObject);
}
}
srcIterator->release();
}
}
//IOLog( "IOFireWireUserClientIniter<0x%08lx>::dictionaryDeepCopy - return\n", this );
return result;
}
bool NullEthernet::initMACfromACPI()
{
bool result = false;
OSObject *ret = NULL;
IOACPIPlatformDevice* pACPI = OSDynamicCast(IOACPIPlatformDevice, m_pProvider);
if (NULL != pACPI && kIOReturnSuccess == pACPI->evaluateObject("MAC", &ret) && NULL != ret)
{
// get MAC address from DSDT if provided...
OSData* pData = OSDynamicCast(OSData, ret);
if (pData && pData->getLength() == kIOEthernetAddressSize)
{
bcopy(pData->getBytesNoCopy(), m_rgMacAddr, kIOEthernetAddressSize);
AlwaysLog("Using MAC address from DSDT: %02x:%02x:%02x:%02x:%02x:%02x\n", m_rgMacAddr[0], m_rgMacAddr[1], m_rgMacAddr[2], m_rgMacAddr[3], m_rgMacAddr[4], m_rgMacAddr[5]);
result = true;
}
ret->release();
}
return result;
}
// Received an update of a specific value
void WirelessHIDDevice::receivedUpdate(unsigned char type, unsigned char *data)
{
switch (type)
{
case 0x13: // Battery level
battery = data[0];
{
OSObject *prop = OSNumber::withNumber(battery, 8);
if (prop != NULL)
{
setProperty(kIOWirelessBatteryLevel, prop);
prop->release();
}
}
break;
default:
break;
}
}
static bool
getPCSPortMapping(
IORegistryEntry * root,
UInt32 portNum,
UInt8 * enableOffset,
UInt8 * enableMask,
UInt8 * presenceOffset,
UInt8 * presenceMask )
{
OSObject * prop;
OSData * data;
const PCSPortMap * portMap = gDefaultPortMap;
if (!root || (portNum > kSerialATAPort3) ||
root->getProperty( kSerialATAKey ) != kOSBooleanTrue)
return false;
prop = root->copyProperty( kPCSPortMapKey );
data = OSDynamicCast(OSData, prop);
if (data && (data->getLength() == sizeof(gDefaultPortMap)))
{
portMap = (const PCSPortMap *) data->getBytesNoCopy();
}
if (enableOffset)
*enableOffset = portMap[portNum].enableOffset;
if (enableMask)
*enableMask = portMap[portNum].enableMask;
if (presenceOffset)
*presenceOffset = portMap[portNum].presenceOffset;
if (presenceMask)
*presenceMask = portMap[portNum].presenceMask;
if (prop) prop->release();
return true;
}
static void createNubs(IOService *provider) {
const char nameID[2][8] = {"@0,name", "@1,name"};
const char name[11] = "Aty,Radeon";
const char typeID[2][15] = {"@0,device_type", "@1,device_type"};
const char type[] = "display";
OSObject *tempObj;
int i;
if (provider->getProperty(kIONDRVIgnoreKey)) return;
provider->setProperty(kIONDRVIgnoreKey, kOSBooleanTrue); //prevent IONDRVFramebuffer from match
LOG("createNubs\n");
if (!provider->getProperty("@0,name") && !provider->getProperty("@1,name")) {
for (i = 0;i < 2;i++) { // Debug
tempObj = OSData::withBytes(name, 11);
provider->setProperty(nameID[i], tempObj);
tempObj->release();
tempObj = OSData::withBytes(type, 8);
provider->setProperty(typeID[i], tempObj);
tempObj->release();
}
}
// have to move below part from IONDRVFramebuffer to make it work
IORegistryIterator * iter;
IORegistryEntry * next;
IOService * newNub;
OSArray * toDo = 0;
bool firstLevel;
OSData * data;
if (provider->getProperty("@0,name"))
{
OSDictionary * dict;
OSCollectionIterator * keys;
const OSSymbol * key;
char buffer[80];
const char * keyChrs;
size_t len;
char c;
dict = provider->dictionaryWithProperties();
keys = OSCollectionIterator::withCollection(dict);
if (dict)
dict->release();
if (keys)
{
while ((key = OSDynamicCast(OSSymbol, keys->getNextObject())))
{
keyChrs = key->getCStringNoCopy();
if ('@' != keyChrs[0])
continue;
len = 0;
do
{
c = keyChrs[len];
if (!c || (c == ','))
break;
buffer[len] = c;
len++;
}
while (len < (sizeof(buffer) - 1));
if (!c)
continue;
buffer[len] = 0;
keyChrs += len + 1;
next = provider->childFromPath(buffer, gIODTPlane);
if (!next)
{
next = new IOService;
if (next && !next->init())
{
next->release();
next = 0;
}
if (!next)
continue;
next->setLocation(&buffer[1]);
if (!next->attachToParent(provider, gIODTPlane))
continue;
}
OSObject * obj = dict->getObject(key);
next->setProperty(keyChrs, dict->getObject(key));
if (!strcmp(keyChrs, "name"))
{
OSData * data = OSDynamicCast(OSData, obj);
if (data)
next->setName((const char *) data->getBytesNoCopy());
}
next->release();
provider->removeProperty(key);
}
keys->release();
}
}
iter = IORegistryIterator::iterateOver( provider, gIODTPlane, 0 );
toDo = OSArray::withCapacity(2);
if (iter && toDo)
{
bool haveDoneLibInit = false;
UInt32 index = 0;
do
{
while ((next = (IORegistryEntry *) iter->getNextObject()))
{
firstLevel = (provider == next->getParentEntry(gIODTPlane));
if (firstLevel)
{
data = OSDynamicCast( OSData, next->getProperty("device_type"));
if (!data || (0 != strcmp("display", (char *) data->getBytesNoCopy())))
continue;
if (!haveDoneLibInit)
{
haveDoneLibInit = (kIOReturnSuccess == _IONDRVLibrariesInitialize(provider));
if (!haveDoneLibInit)
continue;
}
next->setProperty( kIOFBDependentIDKey, (uintptr_t) provider, 64 );
next->setProperty( kIOFBDependentIndexKey, index, 32 );
next->setProperty( kIONDRVIgnoreKey, kOSBooleanTrue );
index++;
}
toDo->setObject( next );
iter->enterEntry();
}
}
while (iter->exitEntry());
}
if (iter)
iter->release();
if (toDo)
{
OSObject * obj;
OSArray * deviceMemory;
obj = provider->copyProperty(gIODeviceMemoryKey);
deviceMemory = OSDynamicCast(OSArray, obj);
for (unsigned int i = 0;
(next = (IORegistryEntry *) toDo->getObject(i));
i++)
{
newNub = new IONDRVDevice;
if (!newNub)
continue;
if (!newNub->init(next, gIODTPlane))
{
newNub->free();
newNub = 0;
continue;
}
if (deviceMemory)
newNub->setDeviceMemory(deviceMemory);
newNub->attach(provider);
newNub->registerService(kIOServiceSynchronous);
}
if (obj)
obj->release();
toDo->release();
}
}
void testDictionary()
{
bool res = true;
void *spaceCheck, *spaceCheck2, *spaceCheck3;
OSObject *cache[numStrCache];
OSString *str;
const OSSymbol *symCache[numStrCache], *sym;
OSDictionary *dict1, *dict2;
int i, numSymbols, count1, count2;
// Do first test without memory leak tests to initialise the metaclass
dict1 = OSDictionary::withCapacity(1);
TEST_ASSERT('D', "0a", dict1);
if (dict1)
dict1->release();
// Grow the symbol pool to maximum
for (i = 0; i < numStrCache; i++)
symCache[i] = OSSymbol::withCStringNoCopy(strCache[i]);
for (i = 0; i < numStrCache; i++)
symCache[i]->release();
// Create and destroy a dictionary
spaceCheck = checkPointSpace();
dict1 = OSDictionary::withCapacity(1);
TEST_ASSERT('D', "1a", dict1);
if (dict1) {
TEST_ASSERT('D', "1b", !dict1->getCount());
TEST_ASSERT('D', "1c", 1 == dict1->getCapacity());
TEST_ASSERT('D', "1d", 1 == dict1->getCapacityIncrement());
TEST_ASSERT('D', "1e", 4 == dict1->setCapacityIncrement(4));
TEST_ASSERT('D', "1f", 4 == dict1->getCapacityIncrement());
TEST_ASSERT('D', "1g", 8 == dict1->ensureCapacity(5));
spaceCheck2 = checkPointSpace();
sym = OSSymbol::withCStringNoCopy(strCache[0]);
spaceCheck3 = checkPointSpace();
TEST_ASSERT('D', "1h", dict1->setObject((OSObject *) sym, sym));
TEST_ASSERT('D', "1i", (OSObject *) sym == dict1->getObject(sym));
sym->release();
TEST_ASSERT('D', "1i", 2 == sym->getRetainCount());
res = res && checkSpace("(D)1j", spaceCheck3, 0);
TEST_ASSERT('D', "1k", 1 == dict1->getCount());
dict1->flushCollection();
TEST_ASSERT('D', "1l", !dict1->getCount());
res = res && checkSpace("(D)1m", spaceCheck2, 0);
dict1->release();
}
res = res && checkSpace("(D)1", spaceCheck, 0);
// Check the creation of a sizable OSDictionary from an array of IOObjects
// Also check indexing into the array.
spaceCheck = checkPointSpace();
for (i = 0, numSymbols = 0; i < numStrCache; i++) {
sym = OSSymbol::withCStringNoCopy(strCache[i]);
if (1 == sym->getRetainCount())
symCache[numSymbols++] = sym;
else
sym->release();
}
dict1 = OSDictionary::withObjects(
(OSObject **) symCache, symCache, numSymbols, numSymbols);
TEST_ASSERT('D', "2a", dict1);
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++)
count1 += (symCache[i]->getRetainCount() == 3);
TEST_ASSERT('D', "2b", count1 == numSymbols);
if (dict1) {
TEST_ASSERT('D', "2c", numSymbols == (int) dict1->getCount());
TEST_ASSERT('D', "2d", numSymbols == (int) dict1->getCapacity());
TEST_ASSERT('D', "2e",
numSymbols == (int) dict1->getCapacityIncrement());
for (i = dict1->getCount(); --i >= 0; ) {
str = (OSString *) dict1->getObject(symCache[i]);
if (str != (OSString *) symCache[i]) {
verPrintf(("testDictionary(D) test 2f%d failed\n", i));
res = false;
}
}
dict1->release();
}
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
count1 += (symCache[i]->getRetainCount() == 1);
symCache[i]->release();
}
TEST_ASSERT('D', "2g", count1 == numSymbols);
res = res && checkSpace("(D)2", spaceCheck, 0);
// Check the creation of a sizable Dictionary from an array of IOStrings
// Also check searching dictionary use OSString for a key.
spaceCheck = checkPointSpace();
for (i = 0, numSymbols = 0; i < numStrCache; i++) {
sym = OSSymbol::withCStringNoCopy(strCache[i]);
if (1 == sym->getRetainCount()) {
cache[numSymbols] = OSString::withCStringNoCopy(strCache[i]);
symCache[numSymbols] = sym;
numSymbols++;
}
else
sym->release();
}
dict1 = OSDictionary::withObjects((OSObject **) symCache,
(OSString **) cache,
numSymbols, numSymbols);
TEST_ASSERT('D', "3a", dict1);
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
count1 += (symCache[i]->getRetainCount() == 3);
count2 += (cache[i]->getRetainCount() == 1);
}
TEST_ASSERT('D', "3b", count1 == numSymbols);
TEST_ASSERT('D', "3c", count2 == numSymbols);
if (dict1) {
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
str = (OSString *) cache[i];
count1 += (symCache[i] == (const OSSymbol *) dict1->getObject(str));
count2 += (symCache[i]->getRetainCount() == 3);
}
TEST_ASSERT('D', "3d", count1 == numSymbols);
TEST_ASSERT('D', "3e", count2 == numSymbols);
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
const char *cStr = ((OSString *) cache[i])->getCStringNoCopy();
count1 += (symCache[i] == (const OSSymbol *) dict1->getObject(cStr));
count2 += (symCache[i]->getRetainCount() == 3);
}
TEST_ASSERT('D', "3f", count1 == numSymbols);
TEST_ASSERT('D', "3g", count2 == numSymbols);
dict1->release();
}
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
count1 += (symCache[i]->getRetainCount() == 1);
count2 += (cache[i]->getRetainCount() == 1);
symCache[i]->release();
cache[i]->release();
}
TEST_ASSERT('D', "3h", count1 == numSymbols);
res = res && checkSpace("(D)3", spaceCheck, 0);
// Check the creation of a small dictionary then grow it one item at a time
// Create a new dictionary from the old dictionary.
// Finally remove each item permanently.
spaceCheck = checkPointSpace();
for (i = 0, numSymbols = 0; i < numStrCache; i++) {
sym = OSSymbol::withCStringNoCopy(strCache[i]);
if (1 == sym->getRetainCount()) {
cache[numSymbols] = OSString::withCStringNoCopy(strCache[i]);
symCache[numSymbols] = sym;
numSymbols++;
}
else
sym->release();
}
dict2 = 0;
dict1 = OSDictionary::withCapacity(1);
TEST_ASSERT('D', "4a", dict1);
if (dict1) {
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
sym = symCache[i];
count1 += ((OSObject *) sym == dict1->setObject((OSObject *) sym,
sym->getCStringNoCopy()));
count2 += (sym->getRetainCount() == 3);
}
TEST_ASSERT('D', "4b", numSymbols == (int) dict1->getCount());
TEST_ASSERT('D', "4c", numSymbols == count1);
TEST_ASSERT('D', "4d", numSymbols == count2);
dict2 = OSDictionary::withDictionary(dict1, numSymbols-1);
TEST_ASSERT('D', "4b", !dict2);
dict2 = OSDictionary::withDictionary(dict1, numSymbols);
}
TEST_ASSERT('D', "4e", dict2);
if (dict2) {
dict1->release();
dict1 = 0;
TEST_ASSERT('D', "4f", numSymbols == (int) dict2->getCount());
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
OSObject *replacedObject;
sym = symCache[i];
str = (OSString *) cache[i];
replacedObject = dict2->setObject(str, str);
count1 += ((OSString *) sym == replacedObject);
replacedObject->release();
count2 += (sym->getRetainCount() == 2);
str->release();
}
TEST_ASSERT('D', "4g", numSymbols == count1);
TEST_ASSERT('D', "4h", numSymbols == count2);
count1 = count2 = 0;
for (i = 0; i < numSymbols; i++) {
sym = symCache[i];
str = (OSString *) cache[i];
count1 += (str == dict2->__takeObject(sym));
str->release();
count2 += (sym->getRetainCount() == 1);
sym->release();
}
TEST_ASSERT('D', "4i", numSymbols == count1);
TEST_ASSERT('D', "4j", numSymbols == count2);
TEST_ASSERT('D', "4k", !dict2->getCount());
dict2->release();
dict2 = 0;
}
else if (dict1)
dict1->release();
res = res && checkSpace("(D)4", spaceCheck, 0);
if (res)
verPrintf(("testDictionary: All OSDictionary Tests passed\n"));
else
logPrintf(("testDictionary: Some OSDictionary Tests failed\n"));
}
IOReturn
com_evoluent_driver_VerticalMouse::StartFinalProcessing()
{
OSNumber *curResPtr, *resPrefPtr;
UInt32 curResInt, resPrefInt;
IOFixed curRes, resPref;
IOReturn err = kIOReturnSuccess;
OSBoolean * boolObj;
OSObject * propertyObj = NULL;
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing", this);
_switchBackOnRestart = FALSE;
propertyObj = copyProperty("SwitchTo800DPI");
boolObj = OSDynamicCast( OSBoolean, propertyObj );
if ( boolObj && boolObj->isTrue() )
{
// USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - found switchTo800DPI resolution property", this);
_switchTo800dpiFlag = true;
}
if (propertyObj)
propertyObj->release();
propertyObj = copyProperty("SwitchTo2000FPS");
boolObj = OSDynamicCast( OSBoolean, propertyObj );
if ( boolObj && boolObj->isTrue() )
{
// USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - found switchTo2000fps resolution property", this);
_switchTo2000fpsFlag = true;
}
if (propertyObj)
propertyObj->release();
if ( _switchTo2000fpsFlag )
{
IOUSBDevRequest devReq;
// Write the 2000 FPS value to the mouse
//
devReq.bmRequestType = 0x40;
devReq.bRequest = 0x01;
devReq.wValue = 0x05AC;
devReq.wIndex = 0xd810;
devReq.wLength = 0x0000;
devReq.pData = NULL;
err = _device->DeviceRequest(&devReq, 5000, 0);
if (err)
{
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - sending 1st part of FPS change received error 0x%x", this, err);
}
else
{
devReq.bmRequestType = 0x40;
devReq.bRequest = 0x01;
devReq.wValue = 0x05AC;
devReq.wIndex = 0xdc11;
devReq.wLength = 0x0000;
devReq.pData = NULL;
err = _device->DeviceRequest(&devReq, 5000, 0);
if (err)
{
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - sending 2nd part of FPS change received error 0x%x", this, err);
}
}
#if FORMOUSETESTING
UInt8 hi,lo;
UInt16 fps;
// Read back the value:
//
devReq.bmRequestType = 0xc0;
devReq.bRequest = 0x01;
devReq.wValue = 0x05AC;
devReq.wIndex = 0x0011;
devReq.wLength = 1;
devReq.pData = &hi;
err = _device->DeviceRequest(&devReq, 5000, 0);
if (err)
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - error reading hi byte: 0x%x", this, err);
devReq.bmRequestType = 0xc0;
devReq.bRequest = 0x01;
devReq.wValue = 0x05AC;
devReq.wIndex = 0x0010;
devReq.wLength = 1;
devReq.pData = &lo;
err = _device->DeviceRequest(&devReq, 5000, 0);
if (err)
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - read reading lo byte: 0x%x", this, err);
fps = hi;
fps = (fps << 8) | lo;
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - read : 0x%x", this, fps );
#endif
err = super::StartFinalProcessing();
if (err)
{
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - super returned error 0x%x", this, err);
}
}
if ( _switchTo800dpiFlag )
{
propertyObj = copyProperty(kIOHIDPointerResolutionKey);
curResPtr = OSDynamicCast( OSNumber, propertyObj );
if (curResPtr)
{
curResInt = curResPtr->unsigned32BitValue();
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - found current resolution property - value 0x%lx", this, curResInt);
}
else
{
curResInt = kDefaultFixedResolution;
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - no current property found - using default 0x%lx", this, curResInt);
}
if (propertyObj)
propertyObj->release();
propertyObj = copyProperty(("xResolutionPref"));
resPrefPtr = OSDynamicCast( OSNumber, propertyObj );
if (resPrefPtr)
resPrefInt = resPrefPtr->unsigned32BitValue();
else
{
resPrefInt = kDefaultFixedResolution * 2;
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - no preference property found - using default 0x%lx", this, resPrefInt);
}
if (propertyObj)
propertyObj->release();
resPref = (IOFixed) resPrefInt;
curRes = (IOFixed) curResInt;
if (resPref != curRes)
{
if (switchTo800dpi)
{
IOUSBDevRequest devReq;
devReq.bmRequestType = 0x40;
devReq.bRequest = 0x01;
devReq.wValue = 0x05AC;
devReq.wIndex = 0x0452;
devReq.wLength = 0x0000;
devReq.pData = NULL;
err = _device->DeviceRequest(&devReq, 5000, 0);
if (err)
{
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - error (%x) setting resolution", this, err);
}
else
{
// with this mouse, we do NOT want to start reading on the interrupt pipe, nor do
// we want to call super::start. We just want to wait for the device to get terminated
USBLog(3, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - waiting for click mouse termination", this);
}
}
}
else
{
// If we are already at the correct resolution for OSX, OK. But what if we are going
// back to OS 9? On restart, switch back to boot setup. Power Manager will tell us
// when we are going to restart.
//
_switchBackOnRestart = TRUE;
err = super::StartFinalProcessing();
if (err)
{
USBLog(1, "com_evoluent_driver_VerticalMouse[%p]::StartFinalProcessing - error (%p) from super::StartFinalProcessing", this, (void*)err);
}
}
}
return err;
}
void FileNVRAM::timeoutOccurred(OSObject *target, IOTimerEventSource* timer)
{
static int retryCount;
if (target)
{
FileNVRAM* self = OSDynamicCast(FileNVRAM, target);
if (self)
{
uint64_t timeout = 20000; // 20ms
// Check to see if BSD has been published, if so sync();
OSDictionary * dict = 0;
IOService * match = 0;
boolean_t found = false;
do
{
dict = IOService::resourceMatching("IOBSD");
if (dict)
{
if (IOService::waitForMatchingService(dict, timeout))
{
found = true;
}
}
} while (false);
OSSafeReleaseNULL(dict);
OSSafeReleaseNULL(match);
if (found)
{
UInt8 mLoggingLevel = self->mLoggingLevel;
LOG(NOTICE, "BSD found, syncing\n");
// TODO: Read /Extra/NVRAM/nvram.plist and populate the device tree.
char* buffer;
uint64_t len;
if (self->read_buffer(&buffer, &len, self->mCtx))
{
retryCount++;
LOG(ERROR, "Unable to read in nvram data at %s\n", self->mFilePath->getCStringNoCopy());
// TODO: Check if / is mounted, and if not, try again until it is.
if (retryCount < 100)
{
timer->setTimeoutMS(100);
}
else
{
self->mSafeToSync = true;
self->registerNVRAM();
}
}
else
{
self->mSafeToSync = false;
timer->cancelTimeout();
self->getWorkLoop()->removeEventSource(timer);
timer->release();
self->mTimer = NULL;
if (len > strlen(NVRAM_FILE_HEADER) + strlen(NVRAM_FILE_FOOTER) + 1)
{
char* xml = buffer + strlen(NVRAM_FILE_HEADER);
size_t xmllen = (size_t)len - strlen(NVRAM_FILE_HEADER) - strlen(NVRAM_FILE_FOOTER);
xml[xmllen-1] = 0;
OSString *errmsg = 0;
OSObject* nvram = OSUnserializeXML(xml, &errmsg);
if (nvram)
{
OSDictionary* data = OSDynamicCast(OSDictionary, nvram);
//if(data) self->setPropertyTable(data);
if (data)
{
self->copyUnserialzedData(NULL, data);
}
nvram->release();
}
}
IOFree(buffer, (size_t)len);
self->mSafeToSync = true;
self->registerNVRAM();
//self->sync();
}
}
else
{
timer->setTimeoutMS(50);
}
}
else
{
//printf("Self is not of type FileNVRAM.\n");
}
}
}
bool IOEthernetInterface::init(IONetworkController * controller)
{
OSObject * obj;
_reserved = IONew( ExpansionData, 1 );
if( _reserved == 0 )
return false;
memset(_reserved, 0, sizeof(ExpansionData));
if ( super::init(controller) == false )
return false;
// initialize enet specific fields.
setInterfaceType(IFT_ETHER);
setMaxTransferUnit( ETHERMTU );
setMediaAddressLength( ETHER_ADDR_LEN );
setMediaHeaderLength( ETHER_HDR_LEN );
setFlags( IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS,
IFF_RUNNING | IFF_MULTICAST );
// Add an IONetworkData with room to hold an IOEthernetStats structure.
// This class does not reference the data object created, and no harm
// is done if the data object is released or replaced.
IONetworkData * data = IONetworkData::withInternalBuffer(
kIOEthernetStatsKey,
sizeof(IOEthernetStats));
if (data)
{
addNetworkData(data);
data->release();
}
_inputEventThreadCall = thread_call_allocate(
handleEthernetInputEvent, this );
if (!_inputEventThreadCall)
return false;
// Create and initialize the filter dictionaries.
_requiredFilters = OSDictionary::withCapacity(2);
_activeFilters = OSDictionary::withCapacity(2);
if ( (_requiredFilters == 0) || (_activeFilters == 0) )
return false;
obj = controller->copyProperty(kIOPacketFilters);
if (obj && ((_supportedFilters = OSDynamicCast(OSDictionary, obj)) == 0))
obj->release();
if (!_supportedFilters)
return false;
// Cache the bit mask of wake filters supported by the driver.
// This value will not change.
_supportedWakeFilters = GET_SUPPORTED_FILTERS(
gIOEthernetWakeOnLANFilterGroup );
// Retain the Disabled WOL filters OSNumber.
// Its value will be updated live for link and WOL changed events.
obj = _supportedFilters->getObject(
gIOEthernetDisabledWakeOnLANFilterGroup );
_disabledWakeFilters = OSDynamicCast(OSNumber, obj);
if (_disabledWakeFilters)
_disabledWakeFilters->retain();
// Controller's Unicast (directed) and Broadcast filters should always
// be enabled. Those bits should never be cleared.
if ( !SET_REQUIRED_FILTERS( gIONetworkFilterGroup,
kIOPacketFilterUnicast |
kIOPacketFilterBroadcast )
|| !SET_REQUIRED_FILTERS( gIOEthernetWakeOnLANFilterGroup, 0 )
|| !SET_ACTIVE_FILTERS( gIONetworkFilterGroup, 0 )
|| !SET_ACTIVE_FILTERS( gIOEthernetWakeOnLANFilterGroup, 0 ) )
{
return false;
}
_publishedFeatureID = 0;
// Publish filter dictionaries to property table.
setProperty( kIORequiredPacketFilters, _requiredFilters );
setProperty( kIOActivePacketFilters, _activeFilters );
return true;
}
OSObject *
OSUnserializeBinary(const char *buffer, size_t bufferSize, OSString **errorString)
{
OSObject ** objsArray;
uint32_t objsCapacity;
enum { objsCapacityMax = 16*1024*1024 };
uint32_t objsIdx;
OSObject ** stackArray;
uint32_t stackCapacity;
enum { stackCapacityMax = 64 };
uint32_t stackIdx;
OSObject * result;
OSObject * parent;
OSDictionary * dict;
OSArray * array;
OSSet * set;
OSDictionary * newDict;
OSArray * newArray;
OSSet * newSet;
OSObject * o;
OSSymbol * sym;
OSString * str;
size_t bufferPos;
const uint32_t * next;
uint32_t key, len, wordLen;
bool end, newCollect, isRef;
unsigned long long value;
bool ok;
if (errorString) *errorString = 0;
if (bufferSize < sizeof(kOSSerializeBinarySignature)) return (NULL);
if (0 != strcmp(kOSSerializeBinarySignature, buffer)) return (NULL);
if (3 & ((uintptr_t) buffer)) return (NULL);
bufferPos = sizeof(kOSSerializeBinarySignature);
next = (typeof(next)) (((uintptr_t) buffer) + bufferPos);
DEBG("---------OSUnserializeBinary(%p)\n", buffer);
objsArray = stackArray = NULL;
objsIdx = objsCapacity = 0;
stackIdx = stackCapacity = 0;
result = 0;
parent = 0;
dict = 0;
array = 0;
set = 0;
sym = 0;
ok = true;
while (ok)
{
bufferPos += sizeof(*next);
if (!(ok = (bufferPos <= bufferSize))) break;
key = *next++;
len = (key & kOSSerializeDataMask);
wordLen = (len + 3) >> 2;
end = (0 != (kOSSerializeEndCollecton & key));
DEBG("key 0x%08x: 0x%04x, %d\n", key, len, end);
newCollect = isRef = false;
o = 0; newDict = 0; newArray = 0; newSet = 0;
switch (kOSSerializeTypeMask & key)
{
case kOSSerializeDictionary:
o = newDict = OSDictionary::withCapacity(len);
newCollect = (len != 0);
break;
case kOSSerializeArray:
o = newArray = OSArray::withCapacity(len);
newCollect = (len != 0);
break;
case kOSSerializeSet:
o = newSet = OSSet::withCapacity(len);
newCollect = (len != 0);
break;
case kOSSerializeObject:
if (len >= objsIdx) break;
o = objsArray[len];
isRef = true;
break;
case kOSSerializeNumber:
bufferPos += sizeof(long long);
if (bufferPos > bufferSize) break;
if ((len != 32) && (len != 64) && (len != 16) && (len != 8)) break;
value = next[1];
value <<= 32;
value |= next[0];
o = OSNumber::withNumber(value, len);
next += 2;
break;
case kOSSerializeSymbol:
bufferPos += (wordLen * sizeof(uint32_t));
if (bufferPos > bufferSize) break;
if (len < 2) break;
if (0 != ((const char *)next)[len-1]) break;
o = (OSObject *) OSSymbol::withCString((const char *) next);
next += wordLen;
break;
case kOSSerializeString:
bufferPos += (wordLen * sizeof(uint32_t));
if (bufferPos > bufferSize) break;
o = OSString::withStringOfLength((const char *) next, len);
next += wordLen;
break;
case kOSSerializeData:
bufferPos += (wordLen * sizeof(uint32_t));
if (bufferPos > bufferSize) break;
o = OSData::withBytes(next, len);
next += wordLen;
break;
case kOSSerializeBoolean:
o = (len ? kOSBooleanTrue : kOSBooleanFalse);
break;
default:
break;
}
if (!(ok = (o != 0))) break;
if (!isRef)
{
setAtIndex(objs, objsIdx, o);
if (!ok)
{
o->release();
break;
}
objsIdx++;
}
if (dict)
{
if (!sym) sym = (OSSymbol *) o;
else
{
str = sym;
sym = OSDynamicCast(OSSymbol, sym);
if (!sym && (str = OSDynamicCast(OSString, str)))
{
sym = const_cast<OSSymbol *>(OSSymbol::withString(str));
ok = (sym != 0);
if (!ok) break;
}
DEBG("%s = %s\n", sym->getCStringNoCopy(), o->getMetaClass()->getClassName());
if (o != dict) ok = dict->setObject(sym, o);
if (sym && (sym != str)) sym->release();
sym = 0;
}
}
else if (array) ok = array->setObject(o);
else if (set) ok = set->setObject(o);
else if (result) ok = false;
else
{
assert(!parent);
result = o;
}
if (!ok) break;
if (end) parent = 0;
if (newCollect)
{
stackIdx++;
setAtIndex(stack, stackIdx, parent);
if (!ok) break;
DEBG("++stack[%d] %p\n", stackIdx, parent);
parent = o;
dict = newDict;
array = newArray;
set = newSet;
end = false;
}
if (end)
{
while (stackIdx)
{
parent = stackArray[stackIdx];
DEBG("--stack[%d] %p\n", stackIdx, parent);
stackIdx--;
if (parent) break;
}
if (!parent) break;
set = 0;
dict = 0;
array = 0;
if (!(dict = OSDynamicCast(OSDictionary, parent)))
{
if (!(array = OSDynamicCast(OSArray, parent))) ok = (0 != (set = OSDynamicCast(OSSet, parent)));
}
}
}
DEBG("ret %p\n", result);
if (!ok) result = 0;
if (objsCapacity)
{
for (len = (result != 0); len < objsIdx; len++) objsArray[len]->release();
kfree(objsArray, objsCapacity * sizeof(*objsArray));
}
if (stackCapacity) kfree(stackArray, stackCapacity * sizeof(*stackArray));
return (result);
}
void StartIOKit( void * p1, void * p2, void * p3, void * p4 )
{
IOPlatformExpertDevice * rootNub;
int debugFlags;
IORegistryEntry * root;
OSObject * obj;
extern const char * gIOKernelKmods;
OSString * errorString = NULL; // must release
OSDictionary * fakeKmods; // must release
OSCollectionIterator * kmodIter; // must release
OSString * kmodName; // don't release
IOLog( iokit_version );
if( PE_parse_boot_arg( "io", &debugFlags ))
gIOKitDebug = debugFlags;
// Check for the log synchronous bit set in io
if (gIOKitDebug & kIOLogSynchronous)
debug_mode = true;
//
// Have to start IOKit environment before we attempt to start
// the C++ runtime environment. At some stage we have to clean up
// the initialisation path so that OS C++ can initialise independantly
// of iokit basic service initialisation, or better we have IOLib stuff
// initialise as basic OS services.
//
IOLibInit();
OSlibkernInit();
/*****
* Declare the fake kmod_info structs for built-in components
* that must be tracked as independent units for dependencies.
*/
fakeKmods = OSDynamicCast(OSDictionary,
OSUnserialize(gIOKernelKmods, &errorString));
if (!fakeKmods) {
if (errorString) {
panic("Kernel kmod list syntax error: %s\n",
errorString->getCStringNoCopy());
errorString->release();
} else {
panic("Error loading kernel kmod list.\n");
}
}
kmodIter = OSCollectionIterator::withCollection(fakeKmods);
if (!kmodIter) {
panic("Can't declare in-kernel kmods.\n");
}
while ((kmodName = OSDynamicCast(OSString, kmodIter->getNextObject()))) {
OSString * kmodVersion = OSDynamicCast(OSString,
fakeKmods->getObject(kmodName));
if (!kmodVersion) {
panic("Can't declare in-kernel kmod; \"%s\" has "
"an invalid version.\n",
kmodName->getCStringNoCopy());
}
if (KERN_SUCCESS != kmod_create_fake(kmodName->getCStringNoCopy(),
kmodVersion->getCStringNoCopy())) {
panic("Failure declaring in-kernel kmod \"%s\".\n",
kmodName->getCStringNoCopy());
}
}
kmodIter->release();
fakeKmods->release();
root = IORegistryEntry::initialize();
assert( root );
IOService::initialize();
IOCatalogue::initialize();
IOUserClient::initialize();
IOMemoryDescriptor::initialize();
obj = OSString::withCString( iokit_version );
assert( obj );
if( obj ) {
root->setProperty( kIOKitBuildVersionKey, obj );
obj->release();
}
obj = IOKitDiagnostics::diagnostics();
if( obj ) {
root->setProperty( kIOKitDiagnosticsKey, obj );
obj->release();
}
rootNub = new IOPlatformExpertDevice;
if( rootNub && rootNub->initWithArgs( p1, p2, p3, p4)) {
rootNub->attach( 0 );
/* Enter into the catalogue the drivers
* provided by BootX.
*/
gIOCatalogue->recordStartupExtensions();
rootNub->registerService();
}
}
