IOReturn IOHIDevice::setParamProperties( OSDictionary * dict )
{
IOHIDEventService * eventService = NULL;
if ( dict->getObject(kIOHIDEventServicePropertiesKey) == NULL ) {
IOService * service = getProvider();
if ( service )
eventService = OSDynamicCast(IOHIDEventService, service);
}
if ( dict->getObject(kIOHIDDeviceParametersKey) == kOSBooleanTrue ) {
OSDictionary * deviceParameters = OSDynamicCast(OSDictionary, copyProperty(kIOHIDParametersKey));
if ( !deviceParameters ) {
deviceParameters = OSDictionary::withCapacity(4);
}
else {
if (deviceParameters->setOptions(0, 0) & OSDictionary::kImmutable) {
OSDictionary * temp = deviceParameters;
deviceParameters = OSDynamicCast(OSDictionary, temp->copyCollection());
temp->release();
}
else {
// do nothing
}
}
if ( deviceParameters ) {
// RY: Because K&M Prefs and Admin still expect device props to be
// top level, let's continue to set them via setProperty. When we get
// Max to migrate over, we can remove the interator code and use:
// deviceParameters->merge(dict);
// deviceParameters->removeObject(kIOHIDResetKeyboardKey);
// deviceParameters->removeObject(kIOHIDResetPointerKey);
// setProperty(kIOHIDParametersKey, deviceParameters);
// deviceParameters->release();
OSCollectionIterator * iterator = OSCollectionIterator::withCollection(dict);
if ( iterator ) {
OSSymbol * key;
while ( ( key = (OSSymbol *)iterator->getNextObject() ) )
if ( !key->isEqualTo(kIOHIDResetKeyboardKey) &&
!key->isEqualTo(kIOHIDResetPointerKey) &&
!key->isEqualTo(kIOHIDScrollResetKey) &&
!key->isEqualTo(kIOHIDDeviceParametersKey) &&
!key->isEqualTo(kIOHIDResetLEDsKey) &&
!key->isEqualTo(kIOUserClientClassKey) &&
!key->isEqualTo(kIOClassKey) &&
!key->isEqualTo(kIOProviderClassKey) &&
!key->isEqualTo(kIOKitDebugKey)) {
OSObject * value = dict->getObject(key);
deviceParameters->setObject(key, value);
setProperty(key, value);
}
iterator->release();
}
setProperty(kIOHIDParametersKey, deviceParameters);
deviceParameters->release();
// RY: Propogate up to IOHIDEventService level
if ( eventService )
eventService->setSystemProperties(dict);
}
else {
return kIOReturnNoMemory;
}
}
return( kIOReturnSuccess );
}
OSSet * IOPartitionScheme::juxtaposeMediaObjects(OSSet * partitionsOld,
OSSet * partitionsNew)
{
//
// Updates a set of existing partitions, represented by partitionsOld,
// with possible updates from a rescan of the disk, represented by
// partitionsNew. It returns a new set of partitions with the results,
// removing partitions from partitionsOld where applicable, adding
// partitions from partitionsNew where applicable, and folding in property
// changes to partitions from partitionsNew into partitionsOld where
// applicable.
//
OSIterator * iterator = 0;
OSIterator * iterator1 = 0;
OSIterator * iterator2 = 0;
OSSymbol * key;
OSSet * keys = 0;
IOMedia * partition;
IOMedia * partition1;
IOMedia * partition2;
OSSet * partitions = 0;
OSOrderedSet * partitions1 = 0;
OSOrderedSet * partitions2 = 0;
UInt32 partitionID = 0;
OSDictionary * properties;
// Allocate a set to hold the set of media objects representing partitions.
partitions = OSSet::withCapacity( partitionsNew->getCapacity( ) );
if ( partitions == 0 ) goto juxtaposeErr;
// Prepare the reference set of partitions.
partitions1 = OSOrderedSet::withCapacity( partitionsOld->getCapacity( ), partitionComparison, 0 );
if ( partitions1 == 0 ) goto juxtaposeErr;
iterator1 = OSCollectionIterator::withCollection( partitionsOld );
if ( iterator1 == 0 ) goto juxtaposeErr;
while ( ( partition1 = ( IOMedia * ) iterator1->getNextObject( ) ) )
{
partitionID = max( partitionID, strtoul( partition1->getLocation( ), NULL, 10 ) );
partitions1->setObject( partition1 );
}
iterator1->release( );
iterator1 = 0;
// Prepare the comparison set of partitions.
partitions2 = OSOrderedSet::withCapacity( partitionsNew->getCapacity( ), partitionComparison, 0 );
if ( partitions2 == 0 ) goto juxtaposeErr;
iterator2 = OSCollectionIterator::withCollection( partitionsNew );
if ( iterator2 == 0 ) goto juxtaposeErr;
while ( ( partition2 = ( IOMedia * ) iterator2->getNextObject( ) ) )
{
partitionID = max( partitionID, strtoul( partition2->getLocation( ), NULL, 10 ) );
partitions2->setObject( partition2 );
}
iterator2->release( );
iterator2 = 0;
// Juxtapose the partitions.
iterator1 = OSCollectionIterator::withCollection( partitions1 );
if ( iterator1 == 0 ) goto juxtaposeErr;
iterator2 = OSCollectionIterator::withCollection( partitions2 );
if ( iterator2 == 0 ) goto juxtaposeErr;
partition1 = ( IOMedia * ) iterator1->getNextObject( );
partition2 = ( IOMedia * ) iterator2->getNextObject( );
while ( partition1 || partition2 )
{
UInt64 base1;
UInt64 base2;
base1 = partition1 ? partition1->getBase( ) : UINT64_MAX;
base2 = partition2 ? partition2->getBase( ) : UINT64_MAX;
#if TARGET_OS_EMBEDDED
if ( partition1 && partition2 )
{
OSString * uuid1;
OSString * uuid2;
uuid1 = OSDynamicCast( OSString, partition1->getProperty( kIOMediaUUIDKey ) );
uuid2 = OSDynamicCast( OSString, partition2->getProperty( kIOMediaUUIDKey ) );
if ( uuid1 || uuid2 )
{
if ( uuid1 == 0 )
{
base1 = UINT64_MAX;
}
else if ( uuid2 == 0 )
{
base2 = UINT64_MAX;
}
else
{
int compare;
compare = strcmp( uuid1->getCStringNoCopy( ), uuid2->getCStringNoCopy( ) );
if ( compare > 0 )
{
base1 = UINT64_MAX;
}
else if ( compare < 0 )
{
base2 = UINT64_MAX;
}
else
{
base1 = base2;
}
}
}
}
#endif /* TARGET_OS_EMBEDDED */
if ( base1 > base2 )
{
// A partition was added.
partition2->setProperty( kIOMediaLiveKey, true );
iterator = OSCollectionIterator::withCollection( partitions1 );
if ( iterator == 0 ) goto juxtaposeErr;
while ( ( partition = ( IOMedia * ) iterator->getNextObject( ) ) )
{
if ( strcmp( partition->getLocation( ), partition2->getLocation( ) ) == 0 )
{
// Set a location value for this partition.
char location[ 12 ];
partitionID++;
snprintf( location, sizeof( location ), "%d", ( int ) partitionID );
partition2->setLocation( location );
partition2->setProperty( kIOMediaLiveKey, false );
break;
}
}
iterator->release( );
iterator = 0;
if ( partition2->attach( this ) )
{
attachMediaObjectToDeviceTree( partition2 );
partition2->registerService( kIOServiceAsynchronous );
}
partitions->setObject( partition2 );
partition2 = ( IOMedia * ) iterator2->getNextObject( );
}
else if ( base1 < base2 )
{
// A partition was removed.
partition1->setProperty( kIOMediaLiveKey, false );
if ( handleIsOpen( partition1 ) == false )
{
partition1->terminate( kIOServiceSynchronous );
detachMediaObjectFromDeviceTree( partition1 );
}
else
{
partition1->removeProperty( kIOMediaPartitionIDKey );
partitions->setObject( partition1 );
}
partition1 = ( IOMedia * ) iterator1->getNextObject( );
}
else
{
// A partition was matched.
bool edit;
bool move;
edit = false;
move = false;
keys = OSSet::withCapacity( 1 );
if ( keys == 0 ) goto juxtaposeErr;
properties = partition2->getPropertyTable( );
// Determine which properties were updated.
if ( partition1->getBase( ) != partition2->getBase( ) ||
partition1->getSize( ) != partition2->getSize( ) ||
partition1->getPreferredBlockSize( ) != partition2->getPreferredBlockSize( ) ||
partition1->getAttributes( ) != partition2->getAttributes( ) ||
partition1->isWhole( ) != partition2->isWhole( ) ||
partition1->isWritable( ) != partition2->isWritable( ) ||
strcmp( partition1->getContentHint( ), partition2->getContentHint( ) ) )
{
edit = true;
}
if ( strcmp( partition1->getName( ), partition2->getName( ) ) ||
strcmp( partition1->getLocation( ), partition2->getLocation( ) ) )
{
move = true;
}
iterator = OSCollectionIterator::withCollection( properties );
if ( iterator == 0 ) goto juxtaposeErr;
while ( ( key = ( OSSymbol * ) iterator->getNextObject( ) ) )
{
OSObject * value1;
OSObject * value2;
if ( key->isEqualTo( kIOMediaContentHintKey ) ||
key->isEqualTo( kIOMediaEjectableKey ) ||
key->isEqualTo( kIOMediaPreferredBlockSizeKey ) ||
key->isEqualTo( kIOMediaRemovableKey ) ||
key->isEqualTo( kIOMediaSizeKey ) ||
key->isEqualTo( kIOMediaWholeKey ) ||
key->isEqualTo( kIOMediaWritableKey ) )
{
continue;
}
if ( key->isEqualTo( kIOMediaContentKey ) ||
key->isEqualTo( kIOMediaLeafKey ) ||
key->isEqualTo( kIOMediaLiveKey ) ||
key->isEqualTo( kIOMediaOpenKey ) )
{
continue;
}
value1 = partition1->getProperty( key );
value2 = partition2->getProperty( key );
if ( value1 == 0 || value1->isEqualTo( value2 ) == false )
{
keys->setObject( key );
}
}
iterator->release( );
iterator = 0;
// A partition was updated.
partition1->setProperty( kIOMediaLiveKey, ( move == false ) );
if ( edit )
{
partition1->init( partition2->getBase( ),
partition2->getSize( ),
partition2->getPreferredBlockSize( ),
partition2->getAttributes( ),
partition2->isWhole( ),
partition2->isWritable( ),
partition2->getContentHint( ) );
}
if ( keys->getCount( ) )
{
iterator = OSCollectionIterator::withCollection( keys );
if ( iterator == 0 ) goto juxtaposeErr;
while ( ( key = ( OSSymbol * ) iterator->getNextObject( ) ) )
{
partition1->setProperty( key, partition2->getProperty( key ) );
}
iterator->release( );
iterator = 0;
}
if ( edit || keys->getCount( ) )
{
partition1->messageClients( kIOMessageServicePropertyChange );
partition1->registerService( kIOServiceAsynchronous );
}
keys->release( );
keys = 0;
partitions->setObject( partition1 );
partition1 = ( IOMedia * ) iterator1->getNextObject( );
partition2 = ( IOMedia * ) iterator2->getNextObject( );
}
}
// Release our resources.
iterator1->release( );
iterator2->release( );
partitions1->release( );
partitions2->release( );
return partitions;
juxtaposeErr:
// Release our resources.
if ( iterator ) iterator->release( );
if ( iterator1 ) iterator1->release( );
if ( iterator2 ) iterator2->release( );
if ( keys ) keys->release( );
if ( partitions ) partitions->release( );
if ( partitions1 ) partitions1->release( );
if ( partitions2 ) partitions2->release( );
return 0;
}
//*********************************************************************************
// printDictionaryKeys
//
// Print the keys for the given dictionary and selected contents.
//*********************************************************************************
void printDictionaryKeys (OSDictionary * inDictionary, char * inMsg)
{
OSCollectionIterator * mcoll = OSCollectionIterator::withCollection (inDictionary);
OSSymbol * mkey;
OSString * ioClass;
unsigned int i = 0;
mcoll->reset ();
mkey = OSDynamicCast (OSSymbol, mcoll->getNextObject ());
while (mkey) {
// kprintf ("dictionary key #%d: %s\n", i, mkey->getCStringNoCopy () );
// if this is the IOClass key, print it's contents
if ( mkey->isEqualTo ("IOClass") ) {
ioClass = (OSString *) inDictionary->getObject ("IOClass");
if ( ioClass ) IOLog ("%s IOClass is %s\n", inMsg, ioClass->getCStringNoCopy () );
}
// if this is an IOProviderClass key print it
if ( mkey->isEqualTo ("IOProviderClass") ) {
ioClass = (OSString *) inDictionary->getObject ("IOProviderClass");
if ( ioClass ) IOLog ("%s IOProviderClass is %s\n", inMsg, ioClass->getCStringNoCopy () );
}
// also print IONameMatch keys
if ( mkey->isEqualTo ("IONameMatch") ) {
ioClass = (OSString *) inDictionary->getObject ("IONameMatch");
if ( ioClass ) IOLog ("%s IONameMatch is %s\n", inMsg, ioClass->getCStringNoCopy () );
}
// also print IONameMatched keys
if ( mkey->isEqualTo ("IONameMatched") ) {
ioClass = (OSString *) inDictionary->getObject ("IONameMatched");
if ( ioClass ) IOLog ("%s IONameMatched is %s\n", inMsg, ioClass->getCStringNoCopy () );
}
#if 0
// print clock-id
if ( mkey->isEqualTo ("AAPL,clock-id") ) {
char * cstr;
cstr = getCStringForObject (inDictionary->getObject ("AAPL,clock-id"));
if (cstr)
kprintf (" ===> AAPL,clock-id is %s\n", cstr );
}
#endif
// print name
if ( mkey->isEqualTo ("name") ) {
char nameStr[64];
nameStr[0] = 0;
getCStringForObject (inDictionary->getObject ("name"), nameStr );
if (strlen(nameStr) > 0)
IOLog ("%s name is %s\n", inMsg, nameStr);
}
mkey = (OSSymbol *) mcoll->getNextObject ();
i++;
}
mcoll->release ();
}
IOReturn AppleUSBCDC::setPropertiesWL( OSObject * properties )
{
IOReturn result = kIOReturnBadArgument;
OSDictionary *propertyDict;
WWAN_DICTIONARY whichDictionary = WWAN_DICTIONARY_UNKNOWN;
OSObject * dynamicKey = NULL;
bool rc = false;
propertyDict = OSDynamicCast( OSDictionary, properties );
if ( propertyDict != NULL )
{
OSCollectionIterator *propertyIterator;
#if TARGET_OS_EMBEDDED
// Suspend support
OSBoolean *suspendDevice = OSDynamicCast(OSBoolean, propertyDict->getObject("SuspendDevice"));
if ( suspendDevice == kOSBooleanTrue )
{
Log("AppleUSBCDC::setProperties - SuspendDevice: true\n");
if ( fpDevice->isOpen(this) )
{
if ( ( result = fpDevice->SuspendDevice(true) ) != kIOReturnSuccess )
{
Log("AppleUSBCDC::setProperties - failed to suspend the device, error: %08x \n", result);
}
}
else
{
Log("AppleUSBCDC::setProperties - device was not open \n");
return kIOReturnError;
}
return result;
}
else if ( suspendDevice == kOSBooleanFalse )
{
Log("AppleUSBCDC::setProperties - SuspendDevice: false\n");
if ( fpDevice->isOpen(this) )
{
if ( ( result = fpDevice->SuspendDevice(false) ) != kIOReturnSuccess )
{
Log("AppleUSBCDC::setProperties - failed to !suspend the device, error: %08x \n", result);
}
}
else
{
IOLog("AppleUSBCDC::setProperties - device was not open \n");
result = kIOReturnError;
}
return result;
}
// Remote Wake-up support
OSBoolean *remoteWakeup = OSDynamicCast(OSBoolean, propertyDict->getObject("RemoteWakeUp"));
IOUSBDevRequest devreq;
if ( remoteWakeup )
{
devreq.bmRequestType = USBmakebmRequestType(kUSBOut, kUSBStandard, kUSBDevice);
if ( remoteWakeup == kOSBooleanTrue )
{
devreq.bRequest = kUSBRqSetFeature;
} else {
devreq.bRequest = kUSBRqClearFeature;
}
devreq.wValue = kUSBFeatureDeviceRemoteWakeup;
devreq.wIndex = 0;
devreq.wLength = 0;
devreq.pData = 0;
result = fpDevice->DeviceRequest(&devreq);
if ( result == kIOReturnSuccess )
{
IOLog("AppleUSBCDC::setProperties - Set/Clear remote wake up feature successful\n");
} else {
IOLog("AppleUSBCDC::setProperties - Set/Clear remote wake up feature failed, %08x\n", result);
}
return result;
}
#endif // TARGET_OS_EMBEDDED
if (dynamicKey = propertyDict->getObject(kWWAN_TYPE))
whichDictionary = WWAN_SET_DYNAMIC_DICTIONARY;
else
if (dynamicKey = propertyDict->getObject(kWWAN_HW_VERSION))
whichDictionary = WWAN_SET_HARDWARE_DICTIONARY;
else
if (dynamicKey = propertyDict->getObject("AccessPointName"))
whichDictionary = WWAN_SET_MODEM_DICTIONARY;
else
if (dynamicKey = propertyDict->getObject("LCPMTU"))
whichDictionary = WWAN_SET_PPP_DICTIONARY;
else
if (dynamicKey = propertyDict->getObject(kWWAN_UNIQUIFIER))
whichDictionary = WWAN_SET_MODEM_DICTIONARY;
// if we still can't determine which dictionary it is
// Iterate to see if it is a property we know about..
if (whichDictionary == WWAN_DICTIONARY_UNKNOWN)
{
propertyIterator = OSCollectionIterator::withCollection( propertyDict );
if ( propertyIterator != NULL )
{
OSSymbol *key;
while( ( key = (OSSymbol *)propertyIterator->getNextObject() ) )
{
// Log("[setPropertiesWL] key: %s \n", key->getCStringNoCopy());
// if (dynamicKey)
// setProperty(key->getCStringNoCopy(),key);
// setProperty(key->getCStringNoCopy(),propertyDict->getObject(key));
if (key->isEqualTo(kWWAN_SC_SETUP))
{
if (fTerminate == true)
return kIOReturnNoDevice;//We were terminated in the middle of handling a wwand request.
rc = fpDevice->setProperty(kWWAN_SC_SETUP,propertyDict->getObject(key));
goto exit;
}
/*
if (key->isEqualTo(kWWAN_UNIQUIFIER))
{
rc = fpDevice->setProperty(kWWAN_UNIQUIFIER,propertyDict->getObject(key));
goto exit;
}
*/
}
propertyIterator->release();
}
else
{
// Log("[setPropertiesWL] could not obtain an OSCollectionIterator... \n");
ALERT(0, 0, "setPropertiesWL - Could not obtain an OSCollectionIterator...");
result = kIOReturnError;
}
}
else
{
switch (whichDictionary)
{
case WWAN_SET_DYNAMIC_DICTIONARY:
rc = fpDevice->setProperty(kWWAN_DynamicDictonary,propertyDict);
// Log("[setPropertiesWL] setting kWWAN_DynamicDictonary\n");
break;
case WWAN_SET_HARDWARE_DICTIONARY:
rc = fpDevice->setProperty(kWWAN_HardwareDictionary,propertyDict);
// Log("[setPropertiesWL] setting kWWAN_HardwareDictionary\n");
break;
case WWAN_SET_MODEM_DICTIONARY:
rc = fpDevice->setProperty("DeviceModemOverrides",propertyDict);
// Log("[setPropertiesWL] setting DeviceModemOverrides\n");
break;
case WWAN_SET_PPP_DICTIONARY:
rc = fpDevice->setProperty("DevicePPPOverrides",propertyDict);
// Log("[setPropertiesWL] setting DevicePPPOverrides\n");
break;
case WWAN_DICTIONARY_UNKNOWN:
// Log("AppleWWANSUpport::setPropertiesWL - Unknown Dictionary");
break;
default:
// Log("AppleWWANSUpport::setPropertiesWL - default Unknown Dictionary");
break;
}
}
fpDevice->messageClients ( kIOMessageServicePropertyChange );
// Log("[setPropertiesWL] set kWWAN_HardwareDictionary [%x] pNub mesaging Clients with kIOMessageServicePropertyChange \n",rc);
}
exit:
this->messageClients ( kIOMessageServicePropertyChange );
fpDevice->messageClients ( kIOMessageServicePropertyChange );
return kIOReturnSuccess;
}