bool FakePCIID::hookProvider(IOService *provider)
{
if (mDeviceVtable)
return true; // already hooked
IOPCIDevice *device = OSDynamicCast(IOPCIDevice, provider);
if (!device)
{
AlwaysLog("provider is not a IOPCIDevice: %s\n", provider->getMetaClass()->getClassName());
return false;
}
// merge FakeProperties into the provider (only properties that do not exist)
mergeFakeProperties(provider, "FakeProperties", false);
mergeFakeProperties(provider, "FakeProperties-Forced", true);
// hook provider IOPCIDevice vtable on attach/start
mProvider = device;
device->retain();
mDeviceVtable = getVTable(device);
setVTable(device, mStubVtable);
return true;
}
IOService* X3100monitor::probe(IOService *provider, SInt32 *score)
{
if (super::probe(provider, score) != this) return 0;
UInt32 vendor_id, device_id;
if (OSDictionary * dictionary = serviceMatching(kGenericPCIDevice)) {
if (OSIterator * iterator = getMatchingServices(dictionary)) {
IOPCIDevice* device = 0;
while (device = OSDynamicCast(IOPCIDevice, iterator->getNextObject())) {
OSData *data = OSDynamicCast(OSData, device->getProperty("vendor-id"));
if (data)
vendor_id = *(UInt32*)data->getBytesNoCopy();
data = OSDynamicCast(OSData, device->getProperty("device-id"));
if (data)
device_id = *(UInt32*)data->getBytesNoCopy();
if ((vendor_id==0x8086) && (device_id==0x2a00)){
InfoLog("found %lx chip", (long unsigned int)device_id);
VCard = device;
}
}
}
}
return this;
}
IOService * AppleIntelPIIXATARoot::probe( IOService * provider,
SInt32 * score )
{
IOPCIDevice * pciDevice;
// Let our superclass probe first.
if ( super::probe( provider, score ) == 0 )
{
return 0;
}
// Verify the provider type.
pciDevice = OSDynamicCast( IOPCIDevice, provider );
if ( pciDevice == 0 )
{
return 0;
}
// BIOS did not enable I/O space decoding.
// For now assume the ATA controller is disabled.
if ( (pciDevice->configRead16( kIOPCIConfigCommand ) &
kIOPCICommandIOSpace) == 0 )
{
return 0;
}
return this;
}
IOService * AppleNForceATARoot::probe( IOService * provider, SInt32 * score )
{
IOPCIDevice * pciDevice;
// Let superclass probe first.
if (super::probe( provider, score ) == 0)
{
return 0;
}
// Verify the provider is an IOPCIDevice.
pciDevice = OSDynamicCast( IOPCIDevice, provider );
if (pciDevice == 0)
{
return 0;
}
// Fail if I/O space decoding is disabled.
if ((pciDevice->configRead16( kIOPCIConfigCommand ) &
kIOPCICommandIOSpace) == 0)
{
return 0;
}
return this;
}
kern_return_t pmem_iokit_enumerate_pci(pmem_pci_callback_t callback,
void *ctx) {
kern_return_t error = KERN_FAILURE;
OSObject *obj = nullptr;
OSDictionary *search = nullptr;
OSIterator *iter = nullptr;
IOPCIDevice *dev = nullptr;
IODeviceMemory *mem = nullptr;
IOItemCount mem_count = 0;
int cmp;
search = IOService::serviceMatching("IOPCIDevice");
iter = IOService::getMatchingServices(search);
if (!iter) {
pmem_error("Couldn't find any PCI devices.");
goto bail;
}
while ((obj = iter->getNextObject())) {
cmp = strncmp("IOPCIDevice",
obj->getMetaClass()->getClassName(),
strlen("IOPCIDevice"));
if (cmp != 0) {
// I haven't seen the above return anything other than
// PCI devices, but Apple's documentation is sparse (which
// is a nice word for what it is) and doesn't actually
// say anything about what's guaranteed to be returned.
// I'd just as well rather not chance it.
pmem_warn("Expected IOPCIDevice but got %s - skipping.",
obj->getMetaClass()->getClassName());
continue;
}
dev = (IOPCIDevice *)obj;
mem_count = dev->getDeviceMemoryCount();
pmem_debug("Found PCI device %s", dev->getName());
for (unsigned idx = 0; idx < mem_count; ++idx) {
pmem_debug("Memory segment %d found.", idx);
mem = dev->getDeviceMemoryWithIndex(idx);
pmem_signal_t signal = callback(dev, mem, idx, ctx);
if (signal == pmem_Stop) {
error = KERN_FAILURE;
goto bail;
}
}
}
error = KERN_SUCCESS;
bail:
if (iter) {
iter->release();
}
if (search) {
search->release();
}
return error;
}
IOService* GeforceSensors::probe(IOService *provider, SInt32 *score)
{
UInt32 vendor_id, device_id, class_id;
DebugLog("Probing...");
if (super::probe(provider, score) != this) return 0;
InfoLog("GeforceSensors by kozlek (C) 2012");
s8 ret = 0;
if (OSDictionary * dictionary = serviceMatching(kGenericPCIDevice)) {
if (OSIterator * iterator = getMatchingServices(dictionary)) {
ret = 1;
IOPCIDevice* device = 0;
do {
device = OSDynamicCast(IOPCIDevice, iterator->getNextObject());
if (!device) {
break;
}
OSData *data = OSDynamicCast(OSData, device->getProperty(fVendor));
vendor_id = 0;
if (data)
vendor_id = *(UInt32*)data->getBytesNoCopy();
device_id = 0;
data = OSDynamicCast(OSData, device->getProperty(fDevice));
if (data)
device_id = *(UInt32*)data->getBytesNoCopy();
class_id = 0;
data = OSDynamicCast(OSData, device->getProperty(fClass));
if (data)
class_id = *(UInt32*)data->getBytesNoCopy();
if ((vendor_id==0x10de) && (class_id == 0x030000)) {
InfoLog("found %x Nvidia chip", (unsigned int)device_id);
card.pcidev = device;
card.device_id = device_id;
ret = 1; //TODO - count a number of cards
card.card_index = ret;
break;
}
} while (device);
}
}
if(ret)
return this;
else return 0;
return this;
}
bool AppleNForceATARoot::isaBridgePublished( void * target,
void * param,
IOService * service )
{
IOPCIDevice * bridge;
AppleNForceATARoot * root = (AppleNForceATARoot *) target;
const ISABridgeInfo * info;
UInt16 bridgeDID;
UInt16 bridgeSubDID;
//UInt8 bridgeRev;
if (root == 0)
return false;
bridge = OSDynamicCast( IOPCIDevice, service );
if (bridge == 0)
return false;
bridgeDID = bridge->configRead16(kIOPCIConfigDeviceID);
bridgeSubDID = bridge->configRead16(kIOPCIConfigSubSystemVendorID);
//bridgeRev = bridge->configRead8(kIOPCIConfigRevisionID);
DEBUG_LOG( "AppleNForceATARoot::%s( %p, %p, %p ) device/subdevice id: 0x%04x - 0x%04x.\n",
__FUNCTION__, target, param, service, bridgeDID, bridgeSubDID );
info = &gISABridges[0];
while (info->deviceID)
{
if ( bridgeDID == info->deviceID || bridgeSubDID == info->deviceID )
break;
info++;
}
root->setProperty(kHardwareNameKey, info->name);
root->fHardwareType = info->hwType;
root->fHardwareFlags = info->hwFlags;
root->applyToClients( registerClientApplier, 0 );
if (root->fISABridgeNotifier)
root->fISABridgeNotifier->disable();
return false;
}
bool AppleMacIO::start( IOService * provider )
{
IOPCIDevice *pciNub = (IOPCIDevice *)provider;
if( !super::start( provider))
return( false);
// Make sure memory space is on.
pciNub->setMemoryEnable(true);
fNub = provider;
fMemory = provider->mapDeviceMemoryWithIndex( 0 );
if( 0 == fMemory)
IOLog("%s: unexpected ranges\n", getName());
else if( !selfTest())
IOLog("Warning: AppleMacIO self test fails\n");
PMinit(); // initialize for power management
temporaryPowerClampOn(); // hold power on till we get children
return( true);
}
IOReturn IntelMausi::setPowerStateWakeAction(OSObject *owner, void *arg1, void *arg2, void *arg3, void *arg4)
{
IntelMausi *ethCtlr = OSDynamicCast(IntelMausi, owner);
IOPCIDevice *dev;
UInt16 val16;
UInt8 offset;
if (ethCtlr) {
dev = ethCtlr->pciDevice;
offset = ethCtlr->pciPMCtrlOffset;
val16 = dev->configRead16(offset);
val16 &= ~(kPCIPMCSPowerStateMask | kPCIPMCSPMEStatus | kPCIPMCSPMEEnable);
val16 |= kPCIPMCSPowerStateD0;
dev->configWrite16(offset, val16);
/* Restore the PCI Command register. */
ethCtlr->intelEnablePCIDevice(dev);
}
return kIOReturnSuccess;
}
IOReturn IntelMausi::setPowerStateSleepAction(OSObject *owner, void *arg1, void *arg2, void *arg3, void *arg4)
{
IntelMausi *ethCtlr = OSDynamicCast(IntelMausi, owner);
IOPCIDevice *dev;
UInt16 val16;
UInt8 offset;
if (ethCtlr) {
dev = ethCtlr->pciDevice;
offset = ethCtlr->pciPMCtrlOffset;
val16 = dev->configRead16(offset);
val16 &= ~(kPCIPMCSPowerStateMask | kPCIPMCSPMEStatus | kPCIPMCSPMEEnable);
if (ethCtlr->wolActive)
val16 |= (kPCIPMCSPMEStatus | kPCIPMCSPMEEnable | kPCIPMCSPowerStateD3);
else
val16 |= kPCIPMCSPowerStateD3;
dev->configWrite16(offset, val16);
}
return kIOReturnSuccess;
}
bool org_virtualbox_VBoxGuest::isVmmDev(IOPCIDevice *pIOPCIDevice)
{
UInt16 uVendorId, uDeviceId;
if (!pIOPCIDevice)
return false;
uVendorId = m_pIOPCIDevice->configRead16(kIOPCIConfigVendorID);
uDeviceId = m_pIOPCIDevice->configRead16(kIOPCIConfigDeviceID);
if (uVendorId == VMMDEV_VENDORID && uDeviceId == VMMDEV_DEVICEID)
return true;
return true;
}
int
at_sw_init(at_adapter *adapter)
{
at_hw *hw = &adapter->hw;
IOPCIDevice *pdev = adapter->pdev;
/* PCI config space info */
hw->vendor_id = pdev->configRead16(kIOPCIConfigVendorID);
hw->device_id = pdev->configRead16(kIOPCIConfigDeviceID);
hw->subsystem_vendor_id = pdev->configRead16(kIOPCIConfigSubSystemVendorID);
hw->subsystem_id = pdev->configRead16(kIOPCIConfigSubSystemID);
hw->revision_id = pdev->configRead8(kIOPCIConfigRevisionID);
hw->pci_cmd_word = pdev->configRead16(kIOPCIConfigCommand);
adapter->wol = 0;
adapter->ict = 50000; // 100ms
adapter->link_speed = SPEED_0; // hardware init
adapter->link_duplex = FULL_DUPLEX; //
hw->phy_configured = false;
hw->preamble_len = 7;
hw->ipgt = 0x60;
hw->min_ifg = 0x50;
hw->ipgr1 = 0x40;
hw->ipgr2 = 0x60;
hw->retry_buf = 2;
hw->max_retry = 0xf;
hw->lcol = 0x37;
hw->jam_ipg = 7;
hw->fc_rxd_hi = 0;
hw->fc_rxd_lo = 0;
hw->max_frame_size = 1500;
atomic_set(&adapter->irq_sem, 1);
adapter->stats_lock = IOSimpleLockAlloc();
adapter->tx_lock = IOSimpleLockAlloc();
return 0;
}
bool IntelBacklightHandler::start(IOService *provider)
{
if (!super::start(provider))
return false;
IOPCIDevice* pci = OSDynamicCast(IOPCIDevice, provider);
if (!pci)
{
IOLog("IntelBacklightHandler is not an IOPCIDevice... aborting\n");
return false;
}
// setup for direct access
IOService* service = waitForMatchingService(serviceMatching("ACPIBacklightPanel"), 2000UL*1000UL*1000UL);
if (!service)
{
IOLog("ACPIBacklightPanel not found... aborting\n");
return false;
}
ACPIBacklightPanel* panel = OSDynamicCast(ACPIBacklightPanel, service);
if (!panel)
{
IOLog("Backlight service was not ACPIBacklightPanel\n");
return false;
}
// setup BAR1 address...
_baseMap = pci->mapDeviceMemoryWithRegister(kIOPCIConfigBaseAddress0);
if (!_baseMap)
{
IOLog("unable to map BAR1... aborting\n");
return false;
}
_baseAddr = reinterpret_cast<volatile void *>(_baseMap->getVirtualAddress());
if (!_baseAddr)
{
IOLog("unable to get virtual address for BAR1... aborting\n");
return false;
}
OSNumber* num = OSDynamicCast(OSNumber, getProperty("kFrameBufferType"));
if (num == NULL)
{
IOLog("unable to get framebuffer type\n");
return false;
}
_fbtype = num->unsigned32BitValue();
// now register with ACPIBacklight
if (!panel->setBacklightHandler(this, &_params))
{
// setBacklightHandler will return false for old PNLF patches
_baseMap->release();
return false;
}
_panel = panel;
panel->retain();
// register service so ACPIBacklightPanel can proceed...
registerService();
return true;
}
/**
* at_probe - Device Initialization Routine
* @pdev: PCI device information struct
* @ent: entry in at_pci_tbl
*
* Returns 0 on success, negative on failure
*
* at_probe initializes an adapter identified by a pci_dev structure.
* The OS initialization, configuring of the adapter private structure,
* and a hardware reset occur.
**/
bool AtherosL1Ethernet::atProbe()
{
u16 vendorId, deviceId;
at_adapter *adapter=&adapter_;
IOPCIDevice *pdev = adapter_.pdev;
pdev->setBusMasterEnable(true);
pdev->setMemoryEnable(true);
pdev->setIOEnable(true);
vendorId = pdev->configRead16(kIOPCIConfigVendorID);
deviceId = pdev->configRead16(kIOPCIConfigDeviceID);
DbgPrint("Vendor ID %x, device ID %x\n", vendorId, deviceId);
DbgPrint("MMR0 address %x\n", (u32)pdev->configRead32(kIOPCIConfigBaseAddress0));
pdev->enablePCIPowerManagement();
hw_addr_ = pdev->mapDeviceMemoryWithRegister(kIOPCIConfigBaseAddress0);
if (hw_addr_ == NULL)
{
ErrPrint("Couldn't map io regs\n");
return false;
}
DbgPrint("Memory mapped at bus address %x, virtual address %x, length %d\n", (u32)hw_addr_->getPhysicalAddress(),
(u32)hw_addr_->getVirtualAddress(), (u32)hw_addr_->getLength());
hw_addr_->retain();
adapter->hw.mmr_base = reinterpret_cast<char *>(hw_addr_->getVirtualAddress());
DbgPrint("REG_VPD_CAP = %x\n", OSReadLittleInt32(adapter->hw.mmr_base, REG_VPD_CAP));
DbgPrint("REG_PCIE_CAP_LIST = %x\n", OSReadLittleInt32(adapter->hw.mmr_base, REG_PCIE_CAP_LIST));
DbgPrint("REG_MASTER_CTRL = %x\n", OSReadLittleInt32(adapter->hw.mmr_base, REG_MASTER_CTRL));
at_setup_pcicmd(pdev);
/* get user settings */
at_check_options(adapter);
/* setup the private structure */
if(at_sw_init(adapter))
{
ErrPrint("Couldn't init software\n");
return false;
}
/* Init GPHY as early as possible due to power saving issue */
at_phy_init(&adapter->hw);
/* reset the controller to
* put the device in a known good starting state */
if (at_reset_hw(&adapter->hw))
{
ErrPrint("Couldn't reset hardware\n");
return false; //TO-DO: Uncomment
}
/* copy the MAC address out of the EEPROM */
at_read_mac_addr(&adapter->hw);
return true;
}
/**
* Start this service.
*/
bool org_virtualbox_VBoxGuest::start(IOService *pProvider)
{
if (!IOService::start(pProvider))
return false;
/* Low level initialization should be performed only once */
if (!ASMAtomicCmpXchgBool(&g_fInstantiated, true, false))
{
IOService::stop(pProvider);
return false;
}
m_pIOPCIDevice = OSDynamicCast(IOPCIDevice, pProvider);
if (m_pIOPCIDevice)
{
if (isVmmDev(m_pIOPCIDevice))
{
/* Enable memory response from VMM device */
m_pIOPCIDevice->setMemoryEnable(true);
m_pIOPCIDevice->setIOEnable(true);
IOMemoryDescriptor *pMem = m_pIOPCIDevice->getDeviceMemoryWithIndex(0);
if (pMem)
{
IOPhysicalAddress IOPortBasePhys = pMem->getPhysicalAddress();
/* Check that returned value is from I/O port range (at least it is 16-bit lenght) */
if((IOPortBasePhys >> 16) == 0)
{
RTIOPORT IOPortBase = (RTIOPORT)IOPortBasePhys;
void *pvMMIOBase = NULL;
uint32_t cbMMIO = 0;
m_pMap = m_pIOPCIDevice->mapDeviceMemoryWithIndex(1);
if (m_pMap)
{
pvMMIOBase = (void *)m_pMap->getVirtualAddress();
cbMMIO = m_pMap->getLength();
}
int rc = VBoxGuestInitDevExt(&g_DevExt,
IOPortBase,
pvMMIOBase,
cbMMIO,
#if ARCH_BITS == 64
VBOXOSTYPE_MacOS_x64,
#else
VBOXOSTYPE_MacOS,
#endif
0);
if (RT_SUCCESS(rc))
{
rc = VbgdDarwinCharDevInit();
if (rc == KMOD_RETURN_SUCCESS)
{
if (setupVmmDevInterrupts(pProvider))
{
/* register the service. */
registerService();
LogRel(("VBoxGuest: IOService started\n"));
return true;
}
LogRel(("VBoxGuest: Failed to set up interrupts\n"));
VbgdDarwinCharDevRemove();
}
else
LogRel(("VBoxGuest: Failed to initialize character device (rc=%d).\n", rc));
VBoxGuestDeleteDevExt(&g_DevExt);
}
else
LogRel(("VBoxGuest: Failed to initialize common code (rc=%d).\n", rc));
if (m_pMap)
{
m_pMap->release();
m_pMap = NULL;
}
}
}
else
LogRel(("VBoxGuest: The device missing is the I/O port range (#0).\n"));
}
else
