SInt8 FakeSMCKeyStore::takeVacantFanIndex(void)
{
for (UInt8 i = 0; i <= 0xf; i++) {
if (!bit_get(vacantFanIndex, BIT(i))) {
bit_set(vacantFanIndex, BIT(i));
updateFanCounterKey();
return i;
}
}
return -1;
}
SInt8 FakeSMCKeyStore::takeVacantFanIndex(void)
{
//REVIEW_REHABMAN: lock required?
KEYSLOCK;
for (UInt8 i = 0; i <= 0xf; i++) {
if (!bit_get(vacantFanIndex, BIT(i))) {
bit_set(vacantFanIndex, BIT(i));
updateFanCounterKey();
KEYSUNLOCK;
return i;
}
}
KEYSUNLOCK;
return -1;
}
IOReturn FakeSMCDevice::callPlatformFunction(const OSSymbol *functionName, bool waitForFunction, void *param1, void *param2, void *param3, void *param4 )
{
IOReturn result = kIOReturnUnsupported;
if (functionName->isEqualTo(kFakeSMCAddKeyHandler)) {
result = kIOReturnBadArgument;
if (param1 && param2 && param3 && param4) {
const char *name = (const char *)param1;
const char *type = (const char *)param2;
UInt8 size = (UInt64)param3;
IOService *handler = (IOService*)param4;
if (name && type && size > 0 && handler) {
if (addKeyWithHandler(name, type, size, handler))
result = kIOReturnSuccess;
else
result = kIOReturnError;
}
}
}
else if (functionName->isEqualTo(kFakeSMCGetKeyHandler)) {
result = kIOReturnBadArgument;
if (const char *name = (const char *)param1) {
result = kIOReturnError;
if (FakeSMCKey *key = OSDynamicCast(FakeSMCKey, getKey(name))) {
result = kIOReturnSuccess;
if (key->getHandler()) {
result = kIOReturnBadArgument;
if (param2) {
IOService **handler = (IOService**)param2;
*handler = key->getHandler();
result = kIOReturnSuccess;
}
}
}
}
}
else if (functionName->isEqualTo(kFakeSMCRemoveKeyHandler)) {
result = kIOReturnBadArgument;
if (param1) {
result = kIOReturnError;
if (OSCollectionIterator *iterator = OSCollectionIterator::withCollection(keys)) {
IOService *handler = (IOService *)param1;
while (FakeSMCKey *key = OSDynamicCast(FakeSMCKey, iterator->getNextObject())) {
if (key->getHandler() == handler)
key->setHandler(NULL);
}
result = kIOReturnSuccess;
OSSafeRelease(iterator);
}
}
}
else if (functionName->isEqualTo(kFakeSMCAddKeyValue)) {
result = kIOReturnBadArgument;
if (param1 && param2 && param3) {
const char *name = (const char *)param1;
const char *type = (const char *)param2;
UInt8 size = (UInt64)param3;
const void *value = (const void *)param4;
if (name && type && size > 0) {
if (addKeyWithValue(name, type, size, value))
result = kIOReturnSuccess;
else
result = kIOReturnError;
}
}
}
else if (functionName->isEqualTo(kFakeSMCSetKeyValue)) {
result = kIOReturnBadArgument;
if (param1 && param2 && param3) {
const char *name = (const char *)param1;
UInt8 size = (UInt64)param2;
const void *data = (const void *)param3;
result = kIOReturnError;
if (name && data && size > 0) {
if (FakeSMCKey *key = OSDynamicCast(FakeSMCKey, getKey(name))) {
if (key->setValueFromBuffer(data, size)) {
result = kIOReturnSuccess;
}
}
}
}
}
else if (functionName->isEqualTo(kFakeSMCGetKeyValue)) {
result = kIOReturnBadArgument;
if (const char *name = (const char *)param1) {
result = kIOReturnError;
if (FakeSMCKey *key = getKey(name)) {
result = kIOReturnBadArgument;
if (param2 && param3) {
UInt8 *size = (UInt8*)param2;
const void **value = (const void **)param3;
*size = key->getSize();
*value = key->getValue();
result = kIOReturnSuccess;
}
}
}
}
else if (functionName->isEqualTo(kFakeSMCTakeVacantGPUIndex)) {
result = kIOReturnBadArgument;
KEYSLOCK;
if (SInt8 *index = (SInt8*)param1) {
for (UInt8 i = 0; i <= 0xf; i++) {
if (!bit_get(vacantGPUIndex, BIT(i))) {
bit_set(vacantGPUIndex, BIT(i));
*index = i;
result = kIOReturnSuccess;
break;
}
}
if (result != kIOReturnSuccess)
result = kIOReturnError;
}
KEYSUNLOCK;
}
else if (functionName->isEqualTo(kFakeSMCTakeGPUIndex)) {
result = kIOReturnBadArgument;
KEYSLOCK;
if (UInt8 *index = (UInt8*)param1) {
if (*index < 0xf && !bit_get(vacantGPUIndex, BIT(*index))) {
bit_set(vacantGPUIndex, BIT(*index));
result = kIOReturnSuccess;
}
if (result != kIOReturnSuccess)
result = kIOReturnError;
}
KEYSUNLOCK;
}
else if (functionName->isEqualTo(kFakeSMCReleaseGPUIndex)) {
result = kIOReturnBadArgument;
KEYSLOCK;
if (UInt8 *index = (UInt8*)param1) {
if (*index <= 0xf) {
bit_clear(vacantGPUIndex, BIT(*index));
result = kIOReturnSuccess;
}
}
KEYSUNLOCK;
}
else if (functionName->isEqualTo(kFakeSMCTakeVacantFanIndex)) {
result = kIOReturnBadArgument;
KEYSLOCK;
if (SInt8 *index = (SInt8*)param1) {
for (UInt8 i = 0; i <= 0xf; i++) {
if (!bit_get(vacantFanIndex, BIT(i))) {
bit_set(vacantFanIndex, BIT(i));
*index = i;
updateFanCounterKey();
result = kIOReturnSuccess;
break;
}
}
if (result != kIOReturnSuccess)
result = kIOReturnError;
}
KEYSUNLOCK;
}
else if (functionName->isEqualTo(kFakeSMCReleaseFanIndex)) {
result = kIOReturnBadArgument;
KEYSLOCK;
if (UInt8 *index = (UInt8*)param1) {
if (*index <= 0xf) {
bit_clear(vacantFanIndex, BIT(*index));
updateFanCounterKey();
result = kIOReturnSuccess;
}
}
KEYSUNLOCK;
}
else {
result = super::callPlatformFunction(functionName, waitForFunction, param1, param2, param3, param4);
}
return result;
}
