bool IOEthernetInterface::initIfnetParams(struct ifnet_init_params *params)
{
OSData *uniqueID;
//get the default values
super::initIfnetParams( params );
uniqueID = OSDynamicCast(OSData, getProvider()->getProperty(kIOMACAddress));
if ( (uniqueID == 0) || (uniqueID->getLength() != ETHER_ADDR_LEN) )
{
DLOG("%s: kIOMACAddress property access error (len %d)\n",
getName(), uniqueID ? uniqueID->getLength() : 0);
return false;
}
// fill in ethernet specific values
params->uniqueid = uniqueID->getBytesNoCopy();
params->uniqueid_len = uniqueID->getLength();
params->family = APPLE_IF_FAM_ETHERNET;
params->demux = ether_demux;
params->add_proto = ether_add_proto;
params->del_proto = ether_del_proto;
params->framer = ether_frameout;
params->check_multi = ether_check_multi;
params->broadcast_addr = ether_broadcast_addr;
params->broadcast_len = sizeof(ether_broadcast_addr);
return true;
}
bool IOEthernetInterface::controllerDidOpen(IONetworkController * ctr)
{
bool ret = false;
OSData * addrData;
IOEthernetAddress * addr;
do {
// Call the controllerDidOpen() in superclass first.
if ( (ctr == 0) || (super::controllerDidOpen(ctr) == false) )
break;
// If the controller supports some form of multicast filtering,
// then set the ifnet IFF_MULTICAST flag.
if ( GET_SUPPORTED_FILTERS(gIONetworkFilterGroup) &
(kIOPacketFilterMulticast | kIOPacketFilterMulticastAll) )
{
setFlags(IFF_MULTICAST);
}
// Advertise Wake on Magic Packet feature if supported.
if ( _supportedWakeFilters & kIOEthernetWakeOnMagicPacket )
{
IOPMrootDomain * root = getPMRootDomain();
if ( root ) root->publishFeature( kWOMPFeatureKey,
kIOPMSupportedOnAC | kIOPMSupportedOnUPS,
(uint32_t *)&_publishedFeatureID);
}
// Get the controller's MAC/Ethernet address.
addrData = OSDynamicCast(OSData, ctr->getProperty(kIOMACAddress));
if ( (addrData == 0) || (addrData->getLength() != ETHER_ADDR_LEN) )
{
DLOG("%s: kIOMACAddress property access error (len %d)\n",
getName(), addrData ? addrData->getLength() : 0);
break;
}
addr = (IOEthernetAddress *) addrData->getBytesNoCopy();
DLOG("%s: Ethernet address %02x:%02x:%02x:%02x:%02x:%02x\n",
ctr->getName(),
addr->bytes[0],
addr->bytes[1],
addr->bytes[2],
addr->bytes[3],
addr->bytes[4],
addr->bytes[5]);
ret = true;
}
while (0);
return ret;
}
void IOPlatformExpert::registerNVRAMController(IONVRAMController * caller)
{
OSData * data;
IORegistryEntry * entry;
OSString * string = 0;
uuid_string_t uuid;
entry = IORegistryEntry::fromPath( "/efi/platform", gIODTPlane );
if ( entry )
{
data = OSDynamicCast( OSData, entry->getProperty( "system-id" ) );
if ( data && data->getLength( ) == 16 )
{
SHA1_CTX context;
uint8_t digest[ SHA_DIGEST_LENGTH ];
const uuid_t space = { 0x2A, 0x06, 0x19, 0x90, 0xD3, 0x8D, 0x44, 0x40, 0xA1, 0x39, 0xC4, 0x97, 0x70, 0x37, 0x65, 0xAC };
SHA1Init( &context );
SHA1Update( &context, space, sizeof( space ) );
SHA1Update( &context, data->getBytesNoCopy( ), data->getLength( ) );
SHA1Final( digest, &context );
digest[ 6 ] = ( digest[ 6 ] & 0x0F ) | 0x50;
digest[ 8 ] = ( digest[ 8 ] & 0x3F ) | 0x80;
uuid_unparse( digest, uuid );
string = OSString::withCString( uuid );
}
entry->release( );
}
if ( string == 0 )
{
entry = IORegistryEntry::fromPath( "/options", gIODTPlane );
if ( entry )
{
data = OSDynamicCast( OSData, entry->getProperty( "platform-uuid" ) );
if ( data && data->getLength( ) == sizeof( uuid_t ) )
{
uuid_unparse( ( uint8_t * ) data->getBytesNoCopy( ), uuid );
string = OSString::withCString( uuid );
}
entry->release( );
}
}
if ( string )
{
getProvider( )->setProperty( kIOPlatformUUIDKey, string );
publishResource( kIOPlatformUUIDKey, string );
string->release( );
}
publishResource("IONVRAM");
}
/* 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;
*len = data->getLength();
vlen = min(vlen, *len);
if (value && vlen)
memcpy((void *) value, data->getBytesNoCopy(), vlen);
return TRUE;
err:
return FALSE;
}
bool NullEthernet::init(OSDictionary *properties)
{
DebugLog("init() ===>\n");
if (!super::init(properties))
{
DebugLog("super::init failed\n");
return false;
}
m_pProvider = NULL;
m_netif = NULL;
m_isEnabled = false;
unitNumber = 0;
// load default MAC address (can be overridden in DSDT)
static unsigned char rgDefault[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
bcopy(rgDefault, m_rgMacAddr, kIOEthernetAddressSize);
if (properties)
{
OSData* pData = OSDynamicCast(OSData, properties->getObject("MAC-address"));
if (pData && pData->getLength() == kIOEthernetAddressSize)
bcopy(pData->getBytesNoCopy(), m_rgMacAddr, kIOEthernetAddressSize);
}
DebugLog("init() <===>\n");
return true;
}
UInt32 PCIDeviceStub_XHCIMux::getUInt32Property(const char* name)
{
UInt32 result = 0;
OSData* data = OSDynamicCast(OSData, getProperty(name));
if (data && data->getLength() == 4)
result = *static_cast<const UInt32*>(data->getBytesNoCopy());
return result;
}
bool PCIDeviceStub_XHCIMux::getBoolProperty(const char* name, bool defValue)
{
bool result = defValue;
OSData* data = OSDynamicCast(OSData, getProperty(name));
if (data && data->getLength() == 1)
result = *static_cast<const UInt8*>(data->getBytesNoCopy());
return result;
}
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);
}
//----------------------------------------------------------------------------------------------------
// IOHIDUserDevice::newReportDescriptor
//----------------------------------------------------------------------------------------------------
IOReturn IOHIDUserDevice::newReportDescriptor(IOMemoryDescriptor ** descriptor ) const
{
OSData * data;
data = OSDynamicCast(OSData, _properties->getObject(kIOHIDReportDescriptorKey));
if ( !data )
return kIOReturnError;
*descriptor = IOBufferMemoryDescriptor::withBytes(data->getBytesNoCopy(), data->getLength(), kIODirectionNone);
return kIOReturnSuccess;
}
bool NullEthernet::initMACfromProvider()
{
bool result = false;
OSData* pData = OSDynamicCast(OSData, m_pProvider->getProperty("RM,MAC-address"));
if (pData && pData->getLength() == kIOEthernetAddressSize)
{
bcopy(pData->getBytesNoCopy(), m_rgMacAddr, kIOEthernetAddressSize);
AlwaysLog("Using MAC address from provider: %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;
}
return result;
}
static bool GetUInt32( IORegistryEntry * regEntry, const OSSymbol * name,
UInt32 * value )
{
OSData *data;
if( (data = OSDynamicCast( OSData, regEntry->getProperty( name )))
&& (4 == data->getLength())) {
*value = *((UInt32 *) data->getBytesNoCopy());
return( true );
} else
return( false );
}
OSReturn NoSleepExtension::readNVRAM(UInt8 *value)
{
#ifdef DEBUG
IOLog("%s[%p]::%s(%p)\n", getName(), this, __FUNCTION__, value);
#endif
OSReturn ret = kOSReturnError;
IORegistryEntry *entry = IORegistryEntry::fromPath( "/options", gIODTPlane );
if ( entry )
{
OSObject *rawValue = entry->getProperty(IORegistrySleepSuppressionMode);
if(rawValue != NULL) {
#ifdef DEBUG
IOLog("%s: rawValueClassName: %s\n", getName(), rawValue->getMetaClass()->getClassName());
#endif
OSData *data = OSDynamicCast(OSData, rawValue);
if(data->getLength() == 1) {
*value = ((UInt8 *)data->getBytesNoCopy())[0];
ret = kOSReturnSuccess;
#ifdef DEBUG
IOLog("%s: reading nvram, value: 0x%02x\n", getName(), (*value));
#endif
}
#ifdef DEBUG
else {
IOLog("%s: read error: data->Len %s 1\n", getName(),
(data->getLength() == 1)?"==":"!=");
}
#endif
}
entry->release();
}
return ret;
}
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;
}
int IODTGetDefault(const char *key, void *infoAddr, unsigned int infoSize )
{
IORegistryEntry *defaults;
OSData *defaultObj;
unsigned int defaultSize;
defaults = IORegistryEntry::fromPath( "/defaults", gIODTPlane );
if ( defaults == 0 ) return -1;
defaultObj = OSDynamicCast( OSData, defaults->getProperty(key) );
if ( defaultObj == 0 ) return -1;
defaultSize = defaultObj->getLength();
if ( defaultSize > infoSize) return -1;
memcpy( infoAddr, defaultObj->getBytesNoCopy(), defaultSize );
return 0;
}
IOReturn org_litio_OzoneStrikeBattle::newReportDescriptor(IOMemoryDescriptor** descriptor) const {
// TODO: Define new device descriptor struct for the keyboard.
// Assigning current descriptor.
IOLog("OzoneStrike::%s[%p] - Setting HID report descriptor.\n", getName(), this);
OSData *reportDescriptor = OSData::withBytes(Ozone::HIDReportDescriptor, sizeof(Ozone::HIDReportDescriptor));
OSData *reportDescriptorNew = OSDynamicCast(OSData, getProperty("ReportDescriptorOverride"));
if (reportDescriptor == NULL) {
IOLog("OzoneStrike::%s[%p] - reportDescriptor OSData not set.\n", getName(), this);
return kIOReturnNoResources;
}
printBytes(reportDescriptorNew);
printBytes(reportDescriptor);
IOLog("OzoneStrike::%s[%p] - reportDescriptor OSData set (size: %d, data: %s).\n", getName(), this, reportDescriptor->getLength(), reportDescriptor->getBytesNoCopy());
//OSData *reportDescriptor = OSDynamicCast(OSData, Ozone::HIDReportDescriptor);
IOBufferMemoryDescriptor *bufferDescriptor = IOBufferMemoryDescriptor::withBytes(reportDescriptor->getBytesNoCopy(),
reportDescriptor->getLength(),
kIODirectionOutIn);
//IOBufferMemoryDescriptor *bufferDescriptor = IOBufferMemoryDescriptor::inTaskWithOptions(kernel_task,
// 0,
// sizeof(Ozone::HIDReportDescriptor));
/*
if (bufferDescriptor == NULL) {
return kIOReturnNoResources;
}
bufferDescriptor->writeBytes(0, Ozone::HIDReportDescriptor,sizeof(Ozone::HIDReportDescriptor));
*/
if (bufferDescriptor) {
*descriptor = bufferDescriptor;
return kIOReturnSuccess;
} else {
bufferDescriptor->release();
*descriptor = NULL;
return kIOReturnNoMemory;
}
//return IOUSBHostHIDDevice::newReportDescriptor(descriptor);
}
static IORegistryEntry * IODTFindInterruptParent( IORegistryEntry * regEntry, IOItemCount index )
{
IORegistryEntry * parent;
UInt32 phandle;
OSData * data;
unsigned int len;
if( (data = OSDynamicCast( OSData, regEntry->getProperty( gIODTInterruptParentKey )))
&& (sizeof(UInt32) <= (len = data->getLength()))) {
if (((index + 1) * sizeof(UInt32)) > len)
index = 0;
phandle = ((UInt32 *) data->getBytesNoCopy())[index];
parent = FindPHandle( phandle );
} else if( 0 == regEntry->getProperty( "interrupt-controller"))
parent = regEntry->getParentEntry( gIODTPlane);
else
parent = 0;
return( parent );
}
IOService *Apple16X50PCI::
probe(IOService *provider, SInt32 *score)
{
Provider = OSDynamicCast(IOPCIDevice, provider);
if (!Provider) {
IOLog ("Apple16X50PCI: Attached to non-IOPCIDevice provider! Failing probe()\n");
return NULL;
}
if (!super::probe(provider, score)) return NULL;
char buf[80];
UInt8 dev = Provider->getDeviceNumber();
UInt8 func = Provider->getFunctionNumber();
UInt8 bus = Provider->getBusNumber();
OSData *propData = OSDynamicCast(OSData, Provider->getProperty("AAPL,slot-name"));
if (propData && (propData->getLength()) < 16)
snprintf(buf, sizeof (buf), "PCI %s Bus=%d Dev=%d Func=%d", (char *)(propData->getBytesNoCopy()), bus, dev, func);
else
snprintf(buf, sizeof (buf), "PCI Bus=%d Dev=%d Func=%d", bus, dev, func);
setProperty(kLocationKey, buf);
Location = (OSDynamicCast(OSString, getProperty(kLocationKey))->getCStringNoCopy());
setProperty(kIOTTYBaseNameKey, "pci-serial"); // this will be the TTY base name for all UARTS
InterfaceBaseName="PCI Serial Adapter"; // this will (eventually) be displayed in NetworkPrefs
InterfaceInstance=dev;
snprintf(buf, sizeof (buf), "Apple16X50PCI%d", (int)InterfaceInstance);
setName(buf);
// turn off all access except Config space (for now)
Provider->setMemoryEnable(false);
Provider->setIOEnable(false);
Provider->setBusMasterEnable(false);
return this;
}
int IOEthernetInterface::syncSIOCSIFLLADDR( IONetworkController * ctr,
const char * lladdr, int len )
{
unsigned char tempaddr[kIOEthernetAddressSize];
OSData *hardAddr;
if(len != kIOEthernetAddressSize)
return EINVAL;
if (_ctrEnabled != true) /* reject if interface is down */
return (ENETDOWN);
// keep a backup in case stack refuses our change
hardAddr = OSDynamicCast(OSData, getProperty(kIOMACAddress));
if(hardAddr && hardAddr->getLength() == kIOEthernetAddressSize)
bcopy(hardAddr->getBytesNoCopy(), tempaddr, kIOEthernetAddressSize);
// change the hardware- we do it before the stack, in case the stack
// needs to generate traffic as a result.
if ( ctr->setHardwareAddress( lladdr, len ) == kIOReturnSuccess )
{
if( ifnet_set_lladdr(getIfnet(), lladdr, len) ) //uh-oh, stack didn't like this
{
// restore previous address
if(hardAddr)
ctr->setHardwareAddress(tempaddr, sizeof(tempaddr));
return EINVAL;
}
setProperty(kIOMACAddress, (void *)lladdr, len);
DLOG("%s: SIOCSIFLLADDR %02x:%02x:%02x:%02x:%02x:%02x\n",
ctr->getName(),
lladdr[0], lladdr[1], lladdr[2],
lladdr[3], lladdr[4], lladdr[5]);
}
return 0;
}
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;
}
IOReturn IOUSBHIDDriverDescriptorOverride::newReportDescriptor(IOMemoryDescriptor **desc) const {
OSData *reportDescriptor = OSDynamicCast(OSData, getProperty(REPORT_DESCRIPTOR_OVERRIDE_KEY));
if(reportDescriptor) {
IOBufferMemoryDescriptor *bufferDesc = IOBufferMemoryDescriptor::withBytes(reportDescriptor->getBytesNoCopy(),
reportDescriptor->getLength(),
kIODirectionOutIn);
if(bufferDesc) {
*desc = bufferDesc;
return kIOReturnSuccess;
} else {
bufferDesc->release();
*desc = NULL;
return kIOReturnNoMemory;
}
} else {
//IOLog("IOUSBHIDDriverDescriptorOverride(%s)[%p]::newReportDescriptor - "
// "No %s data in personality, calling IOUSBHIDDriver::newReportDescriptor\n",
// getName(), this, REPORT_DESCRIPTOR_OVERRIDE_KEY);
return IOUSBHIDDriver::newReportDescriptor(desc);
}
}
int IODTGetLoaderInfo( const char *key, void **infoAddr, int *infoSize )
{
IORegistryEntry *chosen;
OSData *propObj;
unsigned int *propPtr;
unsigned int propSize;
chosen = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane );
if ( chosen == 0 ) return -1;
propObj = OSDynamicCast( OSData, chosen->getProperty(key) );
if ( propObj == 0 ) return -1;
propSize = propObj->getLength();
if ( propSize != (2 * sizeof(UInt32)) ) return -1;
propPtr = (unsigned int *)propObj->getBytesNoCopy();
if ( propPtr == 0 ) return -1;
*infoAddr = (void *)(uintptr_t) (propPtr[0]);
*infoSize = (int) (propPtr[1]);
return 0;
}
bool IT87x::start(IOService * provider)
{
DebugLog("starting ...");
if (!super::start(provider))
return false;
InfoLog("found ITE %s", getModelName());
OSDictionary* list = OSDynamicCast(OSDictionary, getProperty("Sensors Configuration"));
OSDictionary *configuration=NULL;
OSData *data;
IORegistryEntry * rootNode = fromPath("/efi/platform", gIODTPlane);
if(rootNode) {
data = OSDynamicCast(OSData, rootNode->getProperty("OEMVendor"));
if (data) {
bcopy(data->getBytesNoCopy(), vendor, data->getLength());
OSString * VendorNick = vendorID(OSString::withCString(vendor));
if (VendorNick) {
data = OSDynamicCast(OSData, rootNode->getProperty("OEMBoard"));
if (!data) {
WarningLog("no OEMBoard");
data = OSDynamicCast(OSData, rootNode->getProperty("OEMProduct"));
}
if (data) {
bcopy(data->getBytesNoCopy(), product, data->getLength());
OSDictionary *link = OSDynamicCast(OSDictionary, list->getObject(VendorNick));
if (link){
configuration = OSDynamicCast(OSDictionary, link->getObject(OSString::withCString(product)));
InfoLog(" mother vendor=%s product=%s", vendor, product);
}
}
} else {
WarningLog("unknown OEMVendor %s", vendor);
}
} else {
WarningLog("no OEMVendor");
}
}
if (list && !configuration) {
configuration = OSDynamicCast(OSDictionary, list->getObject("Default"));
WarningLog("set default configuration");
}
if(configuration) {
this->setProperty("Current Configuration", configuration);
}
// Temperature Sensors
if (configuration) {
for (int i = 0; i < 3; i++) {
char key[8];
snprintf(key, 8, "TEMPIN%X", i);
if(readTemperature(i)<MAX_TEMP_THRESHOLD) { // Need to check if temperature sensor valid
if (OSString* name = OSDynamicCast(OSString, configuration->getObject(key))) {
if (name->isEqualTo("CPU")) {
if (!addSensor(KEY_CPU_HEATSINK_TEMPERATURE, TYPE_SP78, 2, kSuperIOTemperatureSensor, i)) {
WarningLog("error adding heatsink temperature sensor");
}
}
else if (name->isEqualTo("System")) {
if (!addSensor(KEY_NORTHBRIDGE_TEMPERATURE, TYPE_SP78, 2, kSuperIOTemperatureSensor,i)) {
WarningLog("error adding system temperature sensor");
}
}
else if (name->isEqualTo("Ambient")) {
if (!addSensor(KEY_AMBIENT_TEMPERATURE, TYPE_SP78, 2, kSuperIOTemperatureSensor,i)) {
WarningLog("error adding Ambient temperature sensor");
}
}
}
}
}
}
else {
if(readTemperature(0)<MAX_TEMP_THRESHOLD) // Need to check if temperature sensor valid
if (!addSensor(KEY_CPU_HEATSINK_TEMPERATURE, TYPE_SP78, 2, kSuperIOTemperatureSensor, 0)) {
WarningLog("error adding heatsink temperature sensor");
}
if(readTemperature(1)<MAX_TEMP_THRESHOLD) // Need to check if temperature sensor valid
if (!addSensor(KEY_AMBIENT_TEMPERATURE, TYPE_SP78, 2, kSuperIOTemperatureSensor, 1)) {
WarningLog("error adding Ambient temperature sensor");
}
if(readTemperature(2)<MAX_TEMP_THRESHOLD) // Need to check if temperature sensor valid
if (!addSensor(KEY_NORTHBRIDGE_TEMPERATURE, TYPE_SP78, 2, kSuperIOTemperatureSensor, 2)) {
WarningLog("error adding system temperature sensor");
}
}
// Voltage
UInt8 tmp = readByte(address, ITE_ADC_CHANNEL_ENABLE);
DebugLog("ADC Enable register = %X",tmp);
vbat_updates = false;
if(configuration)
{
OSBoolean* smartGuard = OSDynamicCast(OSBoolean, configuration->getObject("VBATNeedUpdates"));
if(smartGuard && smartGuard->isTrue())
vbat_updates=true;
}
// Refresh VBAT reading on each access to the key
if(vbat_updates)
writeByte(address, ITE_CONFIGURATION_REGISTER, readByte(address, ITE_CONFIGURATION_REGISTER) | 0x40);
if (configuration) {
for (int i = 0; i < 9; i++) {
char key[5];
OSString * name;
long Ri=0;
long Rf=1;
long Vf=0;
snprintf(key, 5, "VIN%X", i);
if (process_sensor_entry(configuration->getObject(key), &name, &Ri, &Rf, &Vf)) {
if (name->isEqualTo("CPU")) {
if (!addSensor(KEY_CPU_VRM_SUPPLY0, TYPE_FP2E, 2, kSuperIOVoltageSensor, i,Ri,Rf,Vf))
WarningLog("error adding CPU voltage sensor");
}
else if (name->isEqualTo("Memory")) {
if (!addSensor(KEY_MEMORY_VOLTAGE, TYPE_FP2E, 2, kSuperIOVoltageSensor, i,Ri,Rf,Vf))
WarningLog("error adding memory voltage sensor");
}
else if (name->isEqualTo("+5VC")) {
if (!addSensor(KEY_5VC_VOLTAGE, TYPE_SP4B, 2, kSuperIOVoltageSensor, i,Ri,Rf,Vf)) {
WarningLog("ERROR Adding AVCC Voltage Sensor!");
}
}
else if (name->isEqualTo("+5VSB")) {
if (!addSensor(KEY_5VSB_VOLTAGE, TYPE_SP4B, 2, kSuperIOVoltageSensor, i,Ri,Rf,Vf)) {
WarningLog("ERROR Adding AVCC Voltage Sensor!");
}
}
else if (name->isEqualTo("+12VC")) {
if (!addSensor(KEY_12V_VOLTAGE, TYPE_SP4B, 2, kSuperIOVoltageSensor, i,Ri,Rf,Vf)) {
WarningLog("ERROR Adding 12V Voltage Sensor!");
}
}
else if (name->isEqualTo("-12VC")) {
if (!addSensor(KEY_N12VC_VOLTAGE, TYPE_SP4B, 2, kSuperIOVoltageSensor, i,Ri,Rf,Vf)) {
WarningLog("ERROR Adding 12V Voltage Sensor!");
}
}
else if (name->isEqualTo("3VCC")) {
if (!addSensor(KEY_3VCC_VOLTAGE, TYPE_FP2E, 2, kSuperIOVoltageSensor, i,Ri,Rf,Vf)) {
WarningLog("ERROR Adding 3VCC Voltage Sensor!");
}
}
else if (name->isEqualTo("3VSB")) {
if (!addSensor(KEY_3VSB_VOLTAGE, TYPE_FP2E, 2, kSuperIOVoltageSensor, i,Ri,Rf,Vf)) {
WarningLog("ERROR Adding 3VSB Voltage Sensor!");
}
}
else if (name->isEqualTo("VBAT")) {
if (!addSensor(KEY_VBAT_VOLTAGE, TYPE_FP2E, 2, kSuperIOVoltageSensor, i,Ri,Rf,Vf)) {
WarningLog("ERROR Adding VBAT Voltage Sensor!");
}
}
}
}
}
// Tachometers
for (int i = 0; i < 5; i++) {
OSString* name = NULL;
char key[5];
if (configuration) {
char key_temp[7];
snprintf(key_temp, 7, "FANIN%X", i);
name = OSDynamicCast(OSString, configuration->getObject(key_temp));
}
UInt32 nameLength = name ? (UInt32)strlen(name->getCStringNoCopy()) : 0;
if (readTachometer(i) > 10 || nameLength > 0) {
// Pff WTF ??? Add tachometer if it doesn't exist in a system but only the name defined in the config???
if (!addTachometer(i, (nameLength > 0 ? name->getCStringNoCopy() : 0)))
// Need to look at this a bit later
WarningLog("error adding tachometer sensor %d", i);
}
// Check if this chip support SmartGuardian feature
hasSmartGuardian=false;
if(configuration) {
if(OSBoolean* smartGuard=OSDynamicCast(OSBoolean, configuration->getObject("SmartGuardian")))
if(smartGuard->isTrue())
hasSmartGuardian=true;
}
if(hasSmartGuardian) {
// Ugly development hack started for (SuperIOSensorGroup)
snprintf(key,5,KEY_FORMAT_FAN_TARGET_SPEED,i);
if (!addSensor(key, TYPE_UI8, 1, (SuperIOSensorGroup)kSuperIOSmartGuardPWMControl, i))
WarningLog("error adding PWM fan control");
snprintf(key,5,KEY_FORMAT_FAN_START_TEMP,i);
if (!addSensor(key, TYPE_UI8, 1, (SuperIOSensorGroup)kSuperIOSmartGuardTempFanStart, i))
WarningLog("error adding start temp fan control");
snprintf(key,5,KEY_FORMAT_FAN_OFF_TEMP,i);
if (!addSensor(key, TYPE_UI8, 1, (SuperIOSensorGroup)kSuperIOSmartGuardTempFanStop, i))
WarningLog("error adding stop temp fan control");
snprintf(key,5,KEY_FORMAT_FAN_FULL_TEMP,i);
if (!addSensor(key, TYPE_UI8, 1, (SuperIOSensorGroup)kSuperIOSmartGuardTempFanFullOn, i))
WarningLog("error adding full speed temp fan control");
snprintf(key,5,KEY_FORMAT_FAN_START_PWM,i);
if (!addSensor(key, TYPE_UI8, 1, (SuperIOSensorGroup)kSuperIOSmartGuardPWMStart, i))
WarningLog("error adding start PWM fan control");
snprintf(key,5,KEY_FORMAT_FAN_TEMP_DELTA,i);
if (!addSensor(key, TYPE_UI8, 1, (SuperIOSensorGroup)kSuperIOSmartGuardTempFanFullOff, i))
WarningLog("error adding temp full off fan control");
snprintf(key,5,KEY_FORMAT_FAN_CONTROL,i);
if (!addSensor(key, TYPE_UI8, 1, (SuperIOSensorGroup)kSuperIOSmartGuardTempFanControl, i))
WarningLog("error adding register fan control");
}
}
if(hasSmartGuardian) {
if (!addSensor(KEY_FORMAT_FAN_MAIN_CONTROL, TYPE_UI8, 1, (SuperIOSensorGroup)kSuperIOSmartGuardMainControl, 0))
WarningLog("error adding Main fan control");
if (!addSensor(KEY_FORMAT_FAN_REG_CONTROL, TYPE_UI8, 1, (SuperIOSensorGroup)kSuperIOSmartGuardRegControl, 0))
WarningLog("error adding Main fan control");
}
return true;
}
bool SMBIOSResolver::start(IOService * provider)
{
if( super::start(provider) != true ) return false; // Oh no
if( IOService::getResourceService()->getProperty("SMBIOS-Resolver") ) return false; // We should exist only once
if( !IOService::getResourceService()->getProperty("SMBIOS") ) return false; // AppleSMBIOS.kext didn´t start we bail out
IOService * iosRoot = getServiceRoot();
if( !iosRoot ) return false; // Unable to get IOServiceRoot
int doVerbose = 0;
// PE_parse_boot_arg("smbios", &doVerbose); // bootarg SMBIOS=1 will give a verbose output to log (when I find something verbose worth outputting)
// Dictionary from plist
OSDictionary * hwDict = OSDynamicCast( OSDictionary, getProperty("Override"));
// /rom/version
IORegistryEntry * dtROMNode = fromPath("/rom", gIODTPlane);
if( dtROMNode )
{
OSString * romVersion = OSDynamicCast( OSString, hwDict->getObject("rom-version"));
if(romVersion->getLength() > 0) dtROMNode->setProperty("version", OSData::withBytes(romVersion->getCStringNoCopy(), romVersion->getLength() + 1) );
dtROMNode->release();
}
else
{
return false; // No /rom node in IODeviceTree plane
}
// root entries
OSObject * dictString = 0;
dictString = hwDict->getObject("manufacturer");
if(dictString)
{
OSString * rootManufacturer = OSDynamicCast( OSString, dictString);
if(rootManufacturer->getLength() > 1) iosRoot->setProperty("manufacturer", OSData::withBytes(rootManufacturer->getCStringNoCopy(), rootManufacturer->getLength() + 1) );
}
dictString = hwDict->getObject("system-type");
if(dictString)
{
OSData * systemType = OSDynamicCast( OSData, dictString);
if(systemType) iosRoot->setProperty("system-type", systemType );
}
dictString = hwDict->getObject("compatible");
if(dictString)
{
OSString * rootCompatible = OSDynamicCast( OSString, dictString);
if(rootCompatible->getLength() > 1) iosRoot->setProperty("compatible", OSData::withBytes(rootCompatible->getCStringNoCopy(), rootCompatible->getLength() + 1) );
}
dictString = hwDict->getObject("product-name");
if(dictString)
{
OSString * rootProductName = OSDynamicCast( OSString, dictString);
if(rootProductName->getLength() > 1) iosRoot->setProperty("product-name", OSData::withBytes(rootProductName->getCStringNoCopy(), rootProductName->getLength() + 1) );
}
dictString = hwDict->getObject("model");
if(dictString)
{
OSString * rootModel = OSDynamicCast( OSString, dictString);
if(rootModel->getLength() > 1)
{
iosRoot->setProperty("model", OSData::withBytes(rootModel->getCStringNoCopy(), rootModel->getLength() + 1) );
iosRoot->setName(rootModel->getCStringNoCopy());
}
}
dictString = hwDict->getObject("version");
if(dictString)
{
OSString * rootVersion = OSDynamicCast( OSString, dictString);
if(rootVersion->getLength() > 1) iosRoot->setProperty("version", OSData::withBytes(rootVersion->getCStringNoCopy(), rootVersion->getLength() + 1) );
}
dictString = hwDict->getObject("board-id");
if(dictString)
{
OSString * rootBoardId = OSDynamicCast( OSString, dictString);
if(rootBoardId->getLength() > 1) iosRoot->setProperty("board-id", OSData::withBytes(rootBoardId->getCStringNoCopy(), rootBoardId->getLength() + 1) );
}
dictString = hwDict->getObject("serial-number");
if(dictString)
{
OSString * rootSerial = OSDynamicCast( OSString, dictString);
if(rootSerial->getLength() > 1)
{
UInt8 length = rootSerial->getLength();
const char *serialNumberString = rootSerial->getCStringNoCopy();
// The serial-number property in the IORegistry is a 43-byte data object.
// Bytes 0 through 2 are the last three bytes of the serial number string.
// Bytes 11 through 20, inclusive, are the serial number string itself.
// All other bytes are '\0'.
OSData * data = OSData::withCapacity(43);
if (data)
{
data->appendBytes(serialNumberString + (length - 3), 3);
data->appendBytes(NULL, 10);
data->appendBytes(serialNumberString, length);
data->appendBytes(NULL, 43 - length - 10 - 3);
iosRoot->setProperty("serial-number", data);
data->release();
}
iosRoot->setProperty(kIOPlatformSerialNumberKey, rootSerial);
}
}
dictString = hwDict->getObject("UUID-key");
if(dictString)
{
OSString * rootUUIDKey = OSDynamicCast( OSString, hwDict->getObject("UUID-key"));
iosRoot->setProperty(kIOPlatformUUIDKey, rootUUIDKey);
publishResource(kIOPlatformUUIDKey, rootUUIDKey);
}
bool useEfiBus = false;
UInt64 fsbFrequency = 0;
UInt64 msr;
dictString = hwDict->getObject("use-efi-bus");
if (dictString) useEfiBus = (OSDynamicCast(OSBoolean, dictString))->getValue();
IORegistryEntry * efiPlatform = fromPath("/efi/platform", gIODTPlane);
if (efiPlatform && useEfiBus)
{
OSData * efiFSBFreq = OSDynamicCast(OSData, efiPlatform->getProperty("FSBFrequency"));
bcopy(efiFSBFreq->getBytesNoCopy(), &fsbFrequency, efiFSBFreq->getLength());
efiPlatform->release();
}
else
{ // No /efi/platform found
fsbFrequency = gPEClockFrequencyInfo.bus_frequency_hz; // Value previously set by AppleSMBIOS
if (!strncmp(cpuid_info()->cpuid_vendor, CPUID_VID_INTEL, sizeof(CPUID_VID_INTEL)) && (cpuid_info()->cpuid_features & CPUID_FEATURE_SSE2)) fsbFrequency /= 4;
}
dictString = hwDict->getObject("hardcode-bus");
if(dictString)
{
fsbFrequency = (OSDynamicCast(OSNumber, dictString))->unsigned64BitValue();
if (fsbFrequency)
{
if (fsbFrequency <= 10000) fsbFrequency *= 1000000;
}
else
{
if (!strncmp(cpuid_info()->cpuid_vendor, CPUID_VID_INTEL, sizeof(CPUID_VID_INTEL)))
{
if ((cpuid_info()->cpuid_family == 0x0f) && (cpuid_info()->cpuid_model >= 2))
{
msr = rdmsr64(0x0000002C);
switch ((msr >> 16) & 0x7) {
case 0:
if (cpuid_info()->cpuid_model == 2) fsbFrequency = 100 * 1000000;
else
{
fsbFrequency = (800 * 1000000) / 3; // 266
fsbFrequency++;
}
break;
case 1:
fsbFrequency = (400 * 1000000) / 3; // 133
break;
case 2:
fsbFrequency = (600 * 1000000) / 3; // 200
break;
case 3:
fsbFrequency = (500 * 1000000) / 3; // 166
fsbFrequency++;
break;
case 4:
fsbFrequency = (1000 * 1000000) / 3; // 333
break;
default:
break;
}
}
else
{
fsbFrequency = 100 * 1000000;
}
if (cpuid_info()->cpuid_family == 0x06)
{
msr = rdmsr64(0x000000CD);
switch (msr & 0x7) {
case 0:
fsbFrequency = (800 * 1000000) / 3; // 266
fsbFrequency++;
break;
case 1:
fsbFrequency = (400 * 1000000) / 3; // 133
break;
case 2:
fsbFrequency = (600 * 1000000) / 3; // 200
break;
case 3:
fsbFrequency = (500 * 1000000) / 3; // 166
fsbFrequency++;
break;
case 4:
fsbFrequency = (1000 * 1000000) / 3;// 333
break;
case 5:
fsbFrequency = (300 * 1000000) / 3; // 100
break;
case 6:
fsbFrequency = (1200 * 1000000) / 3;// 400
break;
case 7: // should check
fsbFrequency = (1400 * 1000000) / 3;// 466
fsbFrequency++;
break;
default:
break;
}
}
}
}
UInt32 FakeSMCKeyStore::addKeysFromDictionary(OSDictionary* dictionary)
{
UInt32 keysAdded = 0;
if (dictionary) {
if (OSIterator *iterator = OSCollectionIterator::withCollection(dictionary)) {
while (const OSSymbol *key = (const OSSymbol *)iterator->getNextObject()) {
if (OSArray *array = OSDynamicCast(OSArray, dictionary->getObject(key))) {
if (OSIterator *aiterator = OSCollectionIterator::withCollection(array)) {
OSString *type = OSDynamicCast(OSString, aiterator->getNextObject());
OSData *value = OSDynamicCast(OSData, aiterator->getNextObject());
if (type && value) {
addKeyWithValue(key->getCStringNoCopy(), type->getCStringNoCopy(), value->getLength(), value->getBytesNoCopy());
keysAdded++;
}
OSSafeRelease(aiterator);
}
}
key = 0;
}
OSSafeRelease(iterator);
}
}
return keysAdded;
}
bool FakeSMCDevice::initAndStart(IOService *platform, IOService *provider)
{
if (!provider || !super::init(platform, 0, 0))
return false;
OSDictionary *properties = OSDynamicCast(OSDictionary, provider->getProperty("Configuration"));
if (!properties)
return false;
status = (ApleSMCStatus *) IOMalloc(sizeof(struct AppleSMCStatus));
bzero((void*)status, sizeof(struct AppleSMCStatus));
interrupt_handler = 0;
keys = OSArray::withCapacity(1);
types = OSDictionary::withCapacity(0);
exposedValues = OSDictionary::withCapacity(0);
// Add fist key - counter key
keyCounterKey = FakeSMCKey::withValue(KEY_COUNTER, TYPE_UI32, TYPE_UI32_SIZE, "\0\0\0\1");
keys->setObject(keyCounterKey);
fanCounterKey = FakeSMCKey::withValue(KEY_FAN_NUMBER, TYPE_UI8, TYPE_UI8_SIZE, "\0");
keys->setObject(fanCounterKey);
if (!gKeysLock)
gKeysLock = IORecursiveLockAlloc();
// Load preconfigured keys
FakeSMCDebugLog("loading keys...");
if (OSDictionary *dictionary = OSDynamicCast(OSDictionary, properties->getObject("Keys"))) {
if (OSIterator *iterator = OSCollectionIterator::withCollection(dictionary)) {
while (const OSSymbol *key = (const OSSymbol *)iterator->getNextObject()) {
if (OSArray *array = OSDynamicCast(OSArray, dictionary->getObject(key))) {
if (OSIterator *aiterator = OSCollectionIterator::withCollection(array)) {
OSString *type = OSDynamicCast(OSString, aiterator->getNextObject());
OSData *value = OSDynamicCast(OSData, aiterator->getNextObject());
if (type && value)
addKeyWithValue(key->getCStringNoCopy(), type->getCStringNoCopy(), value->getLength(), value->getBytesNoCopy());
OSSafeRelease(aiterator);
}
}
key = 0;
}
OSSafeRelease(iterator);
}
HWSensorsInfoLog("%d preconfigured key%s added", keys->getCount(), keys->getCount() == 1 ? "" : "s");
}
else {
HWSensorsWarningLog("no preconfigured keys found");
}
// Load wellknown type names
FakeSMCDebugLog("loading types...");
if (OSDictionary *dictionary = OSDynamicCast(OSDictionary, properties->getObject("Types"))) {
if (OSIterator *iterator = OSCollectionIterator::withCollection(dictionary)) {
while (OSString *key = OSDynamicCast(OSString, iterator->getNextObject())) {
if (OSString *value = OSDynamicCast(OSString, dictionary->getObject(key))) {
types->setObject(key, value);
}
}
OSSafeRelease(iterator);
}
}
// Set Clover platform keys
if (OSDictionary *dictionary = OSDynamicCast(OSDictionary, properties->getObject("Clover"))) {
UInt32 count = 0;
if (IORegistryEntry* cloverPlatformNode = fromPath("/efi/platform", gIODTPlane)) {
if (OSIterator *iterator = OSCollectionIterator::withCollection(dictionary)) {
while (OSString *name = OSDynamicCast(OSString, iterator->getNextObject())) {
if (OSData *data = OSDynamicCast(OSData, cloverPlatformNode->getProperty(name))) {
if (OSArray *items = OSDynamicCast(OSArray, dictionary->getObject(name))) {
OSString *key = OSDynamicCast(OSString, items->getObject(0));
OSString *type = OSDynamicCast(OSString, items->getObject(1));
if (addKeyWithValue(key->getCStringNoCopy(), type->getCStringNoCopy(), data->getLength(), data->getBytesNoCopy()))
count++;
}
}
}
OSSafeRelease(iterator);
}
}
if (count)
HWSensorsInfoLog("%d key%s exported by Clover EFI", count, count == 1 ? "" : "s");
}
// Start SMC device
if (!super::start(platform))
return false;
this->setName("SMC");
FakeSMCSetProperty("name", "APP0001");
if (OSString *compatibleKey = OSDynamicCast(OSString, properties->getObject("smc-compatible")))
FakeSMCSetProperty("compatible", (const char *)compatibleKey->getCStringNoCopy());
else
FakeSMCSetProperty("compatible", "smc-napa");
if (!this->setProperty("_STA", (unsigned long long)0x0000000b, 32)) {
HWSensorsErrorLog("failed to set '_STA' property");
return false;
}
if (OSBoolean *debugKey = OSDynamicCast(OSBoolean, properties->getObject("debug")))
debug = debugKey->getValue();
else
debug = false;
if (OSBoolean *traceKey = OSDynamicCast(OSBoolean, properties->getObject("trace")))
trace = traceKey->getValue();
else
trace = false;
IODeviceMemory::InitElement rangeList[1];
rangeList[0].start = 0x300;
rangeList[0].length = 0x20;
// rangeList[1].start = 0xfef00000;
// rangeList[1].length = 0x10000;
if(OSArray *array = IODeviceMemory::arrayFromList(rangeList, 1)) {
this->setDeviceMemory(array);
OSSafeRelease(array);
}
else
{
HWSensorsFatalLog("failed to create Device memory array");
return false;
}
OSArray *controllers = OSArray::withCapacity(1);
if(!controllers) {
HWSensorsFatalLog("failed to create controllers array");
return false;
}
controllers->setObject((OSSymbol *)OSSymbol::withCStringNoCopy("io-apic-0"));
OSArray *specifiers = OSArray::withCapacity(1);
if(!specifiers) {
HWSensorsFatalLog("failed to create specifiers array");
return false;
}
UInt64 line = 0x06;
OSData *tmpData = OSData::withBytes(&line, sizeof(line));
if (!tmpData) {
HWSensorsFatalLog("failed to create specifiers data");
return false;
}
specifiers->setObject(tmpData);
this->setProperty(gIOInterruptControllersKey, controllers) && this->setProperty(gIOInterruptSpecifiersKey, specifiers);
this->attachToParent(platform, gIOServicePlane);
registerService();
HWSensorsInfoLog("successfully initialized");
return true;
}
static UInt32 IODTMapOneInterrupt( IORegistryEntry * regEntry, UInt32 * intSpec, UInt32 index,
OSData ** spec, const OSSymbol ** controller )
{
IORegistryEntry *parent = 0;
OSData *data;
UInt32 *addrCmp;
UInt32 *maskCmp;
UInt32 *map;
UInt32 *endMap;
UInt32 acells, icells, pacells, picells, cell;
UInt32 i, original_icells;
bool cmp, ok = false;
parent = IODTFindInterruptParent( regEntry, index );
IODTGetICellCounts( parent, &icells, &acells );
addrCmp = 0;
if( acells) {
data = OSDynamicCast( OSData, regEntry->getProperty( "reg" ));
if( data && (data->getLength() >= (acells * sizeof(UInt32))))
addrCmp = (UInt32 *) data->getBytesNoCopy();
}
original_icells = icells;
regEntry = parent;
do {
#if IODTSUPPORTDEBUG
kprintf ("IODTMapOneInterrupt: current regEntry name %s\n", regEntry->getName());
kprintf ("acells - icells: ");
for (i = 0; i < acells; i++) kprintf ("0x%08X ", addrCmp[i]);
kprintf ("- ");
for (i = 0; i < icells; i++) kprintf ("0x%08X ", intSpec[i]);
kprintf ("\n");
#endif
if( parent && (data = OSDynamicCast( OSData,
regEntry->getProperty( "interrupt-controller")))) {
// found a controller - don't want to follow cascaded controllers
parent = 0;
*spec = OSData::withBytesNoCopy( (void *) intSpec,
icells * sizeof(UInt32));
*controller = IODTInterruptControllerName( regEntry );
ok = (*spec && *controller);
} else if( parent && (data = OSDynamicCast( OSData,
regEntry->getProperty( "interrupt-map")))) {
// interrupt-map
map = (UInt32 *) data->getBytesNoCopy();
endMap = map + (data->getLength() / sizeof(UInt32));
data = OSDynamicCast( OSData, regEntry->getProperty( "interrupt-map-mask" ));
if( data && (data->getLength() >= ((acells + icells) * sizeof(UInt32))))
maskCmp = (UInt32 *) data->getBytesNoCopy();
else
maskCmp = 0;
#if IODTSUPPORTDEBUG
if (maskCmp) {
kprintf (" maskCmp: ");
for (i = 0; i < acells + icells; i++) {
if (i == acells)
kprintf ("- ");
kprintf ("0x%08X ", maskCmp[i]);
}
kprintf ("\n");
kprintf (" masked: ");
for (i = 0; i < acells + icells; i++) {
if (i == acells)
kprintf ("- ");
kprintf ("0x%08X ", ((i < acells) ? addrCmp[i] : intSpec[i-acells]) & maskCmp[i]);
}
kprintf ("\n");
} else
kprintf ("no maskCmp\n");
#endif
do {
#if IODTSUPPORTDEBUG
kprintf (" map: ");
for (i = 0; i < acells + icells; i++) {
if (i == acells)
kprintf ("- ");
kprintf ("0x%08X ", map[i]);
}
kprintf ("\n");
#endif
for( i = 0, cmp = true; cmp && (i < (acells + icells)); i++) {
cell = (i < acells) ? addrCmp[i] : intSpec[ i - acells ];
if( maskCmp)
cell &= maskCmp[i];
cmp = (cell == map[i]);
}
map += acells + icells;
if( 0 == (parent = FindPHandle( *(map++) )))
unexpected(break);
IODTGetICellCounts( parent, &picells, &pacells );
if( cmp) {
addrCmp = map;
intSpec = map + pacells;
regEntry = parent;
} else {
map += pacells + picells;
}
} while( !cmp && (map < endMap) );
if (!cmp)
parent = 0;
}
if( parent) {
IODTGetICellCounts( parent, &icells, &acells );
regEntry = parent;
}
} while( parent);
bool RadeonController::start( IOService * provider )
{
if (!super::start(provider)) return false;
device = OSDynamicCast(IOPCIDevice, provider);
if (device == NULL) return false;
//get user options
OSBoolean *prop;
OSDictionary *dict = OSDynamicCast(OSDictionary, getProperty("UserOptions"));
bzero(&options, sizeof(UserOptions));
options.HWCursorSupport = FALSE;
options.enableGammaTable = FALSE;
options.enableOSXI2C = FALSE;
options.lowPowerMode = FALSE;
if (dict) {
prop = OSDynamicCast(OSBoolean, dict->getObject("enableHWCursor"));
if (prop) options.HWCursorSupport = prop->getValue();
prop = OSDynamicCast(OSBoolean, dict->getObject("debugMode"));
if (prop) options.debugMode = prop->getValue();
if (options.debugMode) options.HWCursorSupport = FALSE;
prop = OSDynamicCast(OSBoolean, dict->getObject("enableGammaTable"));
if (prop) options.enableGammaTable = prop->getValue();
prop = OSDynamicCast(OSBoolean, dict->getObject("lowPowerMode"));
if (prop) options.lowPowerMode = prop->getValue();
}
options.verbosity = 1;
#ifdef DEBUG
if (0 == getRegistryRoot()->getProperty("RadeonDumpReady")) {
getRegistryRoot()->setProperty("RadeonDumpReady", kOSBooleanTrue);
DumpMsg.mVerbose = 1;
DumpMsg.client = 1;
DumpMsg.mMsgBufferSize = 65535;
if (dict) {
OSNumber *optionNum;
optionNum = OSDynamicCast(OSNumber, dict->getObject("verboseLevel"));
if (optionNum) DumpMsg.mVerbose = optionNum->unsigned32BitValue();
optionNum = OSDynamicCast(OSNumber, dict->getObject("MsgBufferSize"));
if (optionNum) DumpMsg.mMsgBufferSize = max(65535, optionNum->unsigned32BitValue());
}
DumpMsg.mMsgBufferEnabled = false;
DumpMsg.mMsgBufferPos = 0;
DumpMsg.mMessageLock = IOLockAlloc();
DumpMsg.mMsgBuffer = (char *) IOMalloc(DumpMsg.mMsgBufferSize);
if (!DumpMsg.mMsgBuffer) {
IOLog("error: couldn't allocate message buffer (%ld bytes)\n", DumpMsg.mMsgBufferSize);
return false;
}
enableMsgBuffer(true);
} else DumpMsg.client += 1;
options.verbosity = DumpMsg.mVerbose;
#endif
device->setMemoryEnable(true);
IOMap = device->mapDeviceMemoryWithRegister( kIOPCIConfigBaseAddress2 );
if (IOMap == NULL) return false;
FBMap = device->mapDeviceMemoryWithRegister( kIOPCIConfigBaseAddress0 );
if (FBMap == NULL) return false;
memoryMap.MMIOBase = (pointer) IOMap->getVirtualAddress();
memoryMap.MMIOMapSize = IOMap->getLength();
memoryMap.FbBase = (pointer) FBMap->getVirtualAddress();
memoryMap.FbMapSize = FBMap->getLength();
memoryMap.FbPhysBase = (unsigned long)FBMap->getPhysicalAddress();
memoryMap.bitsPerPixel = 32;
memoryMap.bitsPerComponent = 8;
memoryMap.colorFormat = 0; //0 for non-64 bit
memoryMap.BIOSCopy = NULL;
memoryMap.BIOSLength = 0;
IOMemoryDescriptor * mem;
mem = IOMemoryDescriptor::withPhysicalAddress((IOPhysicalAddress) RHD_VBIOS_BASE, RHD_VBIOS_SIZE, kIODirectionOut);
if (mem) {
memoryMap.BIOSCopy = (unsigned char *)IOMalloc(RHD_VBIOS_SIZE);
if (memoryMap.BIOSCopy) {
mem->prepare(kIODirectionOut);
if (!(memoryMap.BIOSLength = mem->readBytes(0, memoryMap.BIOSCopy, RHD_VBIOS_SIZE))) {
LOG("Cannot read BIOS image\n");
memoryMap.BIOSLength = 0;
}
if ((unsigned int)memoryMap.BIOSLength != RHD_VBIOS_SIZE)
LOG("Read only %d of %d bytes of BIOS image\n", memoryMap.BIOSLength, RHD_VBIOS_SIZE);
mem->complete(kIODirectionOut);
}
}
if (dict) {
const char typeKey[2][8] = {"@0,TYPE", "@1,TYPE"};
const char EDIDKey[2][8] = {"@0,EDID", "@1,EDID"};
const char fixedModesKey[2][17] = {"@0,UseFixedModes", "@1,UseFixedModes"};
OSString *type;
OSData *edidData;
OSBoolean *boolData;
int i;
for (i = 0;i < 2;i++) {
type = OSDynamicCast(OSString, dict->getObject(typeKey[i]));
if (!type) continue;
edidData = OSDynamicCast(OSData, dict->getObject(EDIDKey[i]));
if (edidData == NULL) continue;
options.EDID_Block[i] = (unsigned char *)IOMalloc(edidData->getLength());
if (options.EDID_Block[i] == NULL) continue;
strncpy(options.outputTypes[i], type->getCStringNoCopy(), outputTypeLength);
bcopy(edidData->getBytesNoCopy(), options.EDID_Block[i], edidData->getLength());
options.EDID_Length[i] = edidData->getLength();
boolData = OSDynamicCast(OSBoolean, dict->getObject(fixedModesKey[i]));
if (boolData) options.UseFixedModes[i] = boolData->getValue();
}
}
xf86Screens[0] = IONew(ScrnInfoRec, 1); //using global variable, will change it later
ScrnInfoPtr pScrn = xf86Screens[0];
if (pScrn == NULL) return false;
bzero(pScrn, sizeof(ScrnInfoRec));
MAKE_REG_ENTRY(&nub, device);
pciRec.chipType = device->configRead16(kIOPCIConfigDeviceID);
pciRec.subsysVendor = device->configRead16(kIOPCIConfigSubSystemVendorID);
pciRec.subsysCard = device->configRead16(kIOPCIConfigSubSystemID);
pciRec.biosSize = 16; //RHD_VBIOS_SIZE = 1 << 16
pScrn->PciTag = &nub;
pScrn->PciInfo = &pciRec;
pScrn->options = &options;
pScrn->memPhysBase = (unsigned long)FBMap->getPhysicalAddress();
pScrn->fbOffset = 0; //scanout offset
pScrn->bitsPerPixel = 32;
pScrn->bitsPerComponent = 8;
pScrn->colorFormat = 0;
pScrn->depth = pScrn->bitsPerPixel;
pScrn->memoryMap = &memoryMap;
createNubs(provider);
setModel(device);
return true;
}
bool BrcmPatchRAM::performUpgrade()
{
BrcmFirmwareStore* firmwareStore;
OSArray* instructions = NULL;
OSCollectionIterator* iterator = NULL;
OSData* data;
#ifdef DEBUG
DeviceState previousState = kUnknown;
#endif
IOLockLock(mCompletionLock);
mDeviceState = kInitialize;
while (true)
{
#ifdef DEBUG
if (mDeviceState != kInstructionWrite && mDeviceState != kInstructionWritten)
DebugLog("[%04x:%04x]: State \"%s\" --> \"%s\".\n", mVendorId, mProductId, getState(previousState), getState(mDeviceState));
previousState = mDeviceState;
#endif
// Break out when done
if (mDeviceState == kUpdateAborted || mDeviceState == kUpdateComplete)
break;
// Note on following switch/case:
// use 'break' when a response from io completion callback is expected
// use 'continue' when a change of state with no expected response (loop again)
switch (mDeviceState)
{
case kInitialize:
hciCommand(&HCI_VSC_READ_VERBOSE_CONFIG, sizeof(HCI_VSC_READ_VERBOSE_CONFIG));
break;
case kFirmwareVersion:
// Unable to retrieve firmware store
if (!(firmwareStore = getFirmwareStore()))
{
mDeviceState = kUpdateAborted;
continue;
}
instructions = firmwareStore->getFirmware(OSDynamicCast(OSString, getProperty(kFirmwareKey)));
// Unable to retrieve firmware instructions
if (!instructions)
{
mDeviceState = kUpdateAborted;
continue;
}
// Initiate firmware upgrade
hciCommand(&HCI_VSC_DOWNLOAD_MINIDRIVER, sizeof(HCI_VSC_DOWNLOAD_MINIDRIVER));
break;
case kMiniDriverComplete:
// Write firmware data to bulk pipe
iterator = OSCollectionIterator::withCollection(instructions);
if (!iterator)
{
mDeviceState = kUpdateAborted;
continue;
}
// If this IOSleep is not issued, the device is not ready to receive
// the firmware instructions and we will deadlock due to lack of
// responses.
IOSleep(10);
// Write first 2 instructions to trigger response
if ((data = OSDynamicCast(OSData, iterator->getNextObject())))
bulkWrite(data->getBytesNoCopy(), data->getLength());
if ((data = OSDynamicCast(OSData, iterator->getNextObject())))
bulkWrite(data->getBytesNoCopy(), data->getLength());
break;
case kInstructionWrite:
// should never happen, but would cause a crash
if (!iterator)
{
mDeviceState = kUpdateAborted;
continue;
}
if ((data = OSDynamicCast(OSData, iterator->getNextObject())))
bulkWrite(data->getBytesNoCopy(), data->getLength());
else
// Firmware data fully written
hciCommand(&HCI_VSC_END_OF_RECORD, sizeof(HCI_VSC_END_OF_RECORD));
break;
case kInstructionWritten:
mDeviceState = kInstructionWrite;
continue;
case kFirmwareWritten:
hciCommand(&HCI_RESET, sizeof(HCI_RESET));
break;
case kResetComplete:
resetDevice();
getDeviceStatus();
mDeviceState = kUpdateComplete;
continue;
case kUnknown:
case kUpdateComplete:
case kUpdateAborted:
DebugLog("Error: kUnkown/kUpdateComplete/kUpdateAborted cases should be unreachable.\n");
break;
}
// queue async read
if (!continuousRead())
{
mDeviceState = kUpdateAborted;
continue;
}
// wait for completion of the async read
IOLockSleep(mCompletionLock, NULL, 0);
}
IOLockUnlock(mCompletionLock);
OSSafeRelease(iterator);
return mDeviceState == kUpdateComplete;
}
bool OSSerialize::binarySerialize(const OSMetaClassBase *o)
{
OSDictionary * dict;
OSArray * array;
OSSet * set;
OSNumber * num;
OSSymbol * sym;
OSString * str;
OSData * ldata;
OSBoolean * boo;
unsigned int tagIdx;
uint32_t i, key;
size_t len;
bool ok;
tagIdx = tags->getNextIndexOfObject(o, 0);
// does it exist?
if (-1U != tagIdx)
{
key = (kOSSerializeObject | tagIdx);
if (endCollection)
{
endCollection = false;
key |= kOSSerializeEndCollecton;
}
ok = addBinary(&key, sizeof(key));
return (ok);
}
if ((dict = OSDynamicCast(OSDictionary, o)))
{
key = (kOSSerializeDictionary | dict->count);
ok = addBinaryObject(o, key, NULL, 0);
for (i = 0; ok && (i < dict->count);)
{
const OSSymbol * dictKey;
const OSMetaClassBase * dictValue;
const OSMetaClassBase * nvalue = 0;
dictKey = dict->dictionary[i].key;
dictValue = dict->dictionary[i].value;
i++;
if (editor)
{
dictValue = nvalue = (*editor)(editRef, this, dict, dictKey, dictValue);
if (!dictValue) dictValue = dict;
}
ok = binarySerialize(dictKey);
if (!ok) break;
endCollection = (i == dict->count);
ok = binarySerialize(dictValue);
if (!ok) ok = dictValue->serialize(this);
if (nvalue) nvalue->release();
// if (!ok) ok = binarySerialize(kOSBooleanFalse);
}
}
else if ((array = OSDynamicCast(OSArray, o)))
{
key = (kOSSerializeArray | array->count);
ok = addBinaryObject(o, key, NULL, 0);
for (i = 0; ok && (i < array->count);)
{
i++;
endCollection = (i == array->count);
ok = binarySerialize(array->array[i-1]);
if (!ok) ok = array->array[i-1]->serialize(this);
// if (!ok) ok = binarySerialize(kOSBooleanFalse);
}
}
else if ((set = OSDynamicCast(OSSet, o)))
{
key = (kOSSerializeSet | set->members->count);
ok = addBinaryObject(o, key, NULL, 0);
for (i = 0; ok && (i < set->members->count);)
{
i++;
endCollection = (i == set->members->count);
ok = binarySerialize(set->members->array[i-1]);
if (!ok) ok = set->members->array[i-1]->serialize(this);
// if (!ok) ok = binarySerialize(kOSBooleanFalse);
}
}
else if ((num = OSDynamicCast(OSNumber, o)))
{
key = (kOSSerializeNumber | num->size);
ok = addBinaryObject(o, key, &num->value, sizeof(num->value));
}
else if ((boo = OSDynamicCast(OSBoolean, o)))
{
key = (kOSSerializeBoolean | (kOSBooleanTrue == boo));
ok = addBinaryObject(o, key, NULL, 0);
}
else if ((sym = OSDynamicCast(OSSymbol, o)))
{
len = (sym->getLength() + 1);
key = (kOSSerializeSymbol | len);
ok = addBinaryObject(o, key, sym->getCStringNoCopy(), len);
}
else if ((str = OSDynamicCast(OSString, o)))
{
len = (str->getLength() + 0);
key = (kOSSerializeString | len);
ok = addBinaryObject(o, key, str->getCStringNoCopy(), len);
}
else if ((ldata = OSDynamicCast(OSData, o)))
{
len = ldata->getLength();
if (ldata->reserved && ldata->reserved->disableSerialization) len = 0;
key = (kOSSerializeData | len);
ok = addBinaryObject(o, key, ldata->getBytesNoCopy(), len);
}
else return (false);
return (ok);
}
/*********************************************************************
* This function reads the startup extensions dictionary to get the
* address and length of the executable data for the requested kmod.
*********************************************************************/
static
int map_and_patch(const char * kmod_name) {
char *address;
// Does the kld system already know about this kmod?
address = (char *) kld_file_getaddr(kmod_name, NULL);
if (address)
return 1;
// None of these needs to be released.
OSDictionary * extensionsDict;
OSDictionary * kmodDict;
OSData * compressedCode = 0;
// Driver Code may need to be released
OSData * driverCode;
/* Get the requested kmod's info dictionary from the global
* startup extensions dictionary.
*/
extensionsDict = getStartupExtensions();
if (!extensionsDict) {
IOLog("map_and_patch(): No extensions dictionary.\n");
LOG_DELAY();
return 0;
}
kmodDict = OSDynamicCast(OSDictionary,
extensionsDict->getObject(kmod_name));
if (!kmodDict) {
IOLog("map_and_patch(): "
"Extension \"%s\" cannot be found.\n", kmod_name);
LOG_DELAY();
return 0;
}
Boolean ret = false;
driverCode = OSDynamicCast(OSData, kmodDict->getObject("code"));
if (driverCode) {
ret = kld_file_map(kmod_name,
(unsigned char *) driverCode->getBytesNoCopy(),
(size_t) driverCode->getLength(),
/* isKmem */ false);
}
else { // May be an compressed extension
// If we have a compressed segment the uncompressModule
// will return a new OSData object that points to the kmem_alloced
// memory. Note we don't take a reference to driverCode so later
// when we release it we will actually free this driver. Ownership
// of the kmem has been handed of to kld_file.
compressedCode = OSDynamicCast(OSData,
kmodDict->getObject("compressedCode"));
if (!compressedCode) {
IOLog("map_and_patch(): "
"Extension \"%s\" has no \"code\" property.\n", kmod_name);
LOG_DELAY();
return 0;
}
if (!uncompressModule(compressedCode, &driverCode)) {
IOLog("map_and_patch(): "
"Extension \"%s\" Couldn't uncompress code.\n", kmod_name);
LOG_DELAY();
return 0;
}
unsigned char *driver = (unsigned char *) driverCode->getBytesNoCopy();
size_t driverSize = driverCode->getLength();
ret = kld_file_map(kmod_name, driver, driverSize, /* isKmem */ true);
driverCode->release();
if (!ret)
kmem_free(kernel_map, (vm_address_t) driver, driverSize);
}
if (!ret) {
IOLog("map_and_patch(): "
"Extension \"%s\" Didn't successfully load.\n", kmod_name);
LOG_DELAY();
return 0;
}
ret = TRUE;
if (!kld_file_patch_OSObjects(kmod_name)) {
IOLog("map_and_patch(): "
"Extension \"%s\" Error binding OSObjects.\n", kmod_name);
LOG_DELAY();
// RY: Instead of returning here, set the return value.
// We still need to call kld_file_prepare_for_link because
// we might have patched files outside of the driver. Don't
// worry, it will know to ignore the damaged file
ret = FALSE;
}
// Now repair any damage that the kld patcher may have done to the image
kld_file_prepare_for_link();
return ret;
}
