static as_value
gtkext_ctor(const fn_call& /*fn*/)
{
// GNASH_REPORT_FUNCTION;
GtkExt *obj = new GtkExt();
attachInterface(obj);
return as_value(obj); // will keep alive
}
void
dbus_class_init(as_object &obj)
{
Global_as& gl = getGlobal(obj);
as_object* proto = createObject(gl);
attachInterface(*proto);
as_object* cl = gl.createClass(&dbus_ctor, proto);
obj.init_member("Dbus", cl);
}
static as_value
launcher_ctor(const fn_call& /* fn */)
{
GNASH_REPORT_FUNCTION;
launcher_as_object* obj = new launcher_as_object();
attachInterface(obj);
return as_value(obj); // will keep alive
// printf ("Hello World from %s !!!\n", __PRETTY_FUNCTION__);
}
bool HoRNDIS::createNetworkInterface() {
LOG(V_DEBUG, "attaching and registering interface");
/* MTU is initialized before we get here, so this is a safe time to do this. */
if (!attachInterface((IONetworkInterface **)&fNetworkInterface, true)) {
LOG(V_ERROR, "attachInterface failed?");
return false;
}
fNetworkInterface->registerService();
return true;
}
void
launcher_class_init(as_object &obj)
{
// GNASH_REPORT_FUNCTION;
// This is going to be the global "class"/"function"
static boost::intrusive_ptr<builtin_function> cl;
if (cl == NULL) {
Global_as* gl = getGlobal(global);
as_object* proto = getInterface();
cl = gl->createClass(&launcher_ctor, proto);
// // replicate all interface to class, to be able to access
// // all methods as static functions
attachInterface(cl.get());
}
obj.init_member("Launcher", cl.get());
}
bool NullEthernet::start(IOService *provider)
{
DebugLog("start() ===>\n");
if (!super::start(provider))
{
AlwaysLog("NullEthernet: IOEthernetController::start failed.\n");
return false;
}
// retain provider...
m_pProvider = OSDynamicCast(IOService, provider);
if (!m_pProvider)
{
AlwaysLog("NullEthernet: No provider.\n");
return false;
}
m_pProvider->retain();
// initialize MAC address: priority is from DSDT, then provider, last is default
if (!initMACfromACPI() && !initMACfromProvider())
{
AlwaysLog("Using default MAC address: %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]);
}
if (!attachInterface(reinterpret_cast<IONetworkInterface**>(&m_netif)))
{
AlwaysLog("NullEthernet: attachInterface() failed.\n");
goto error1;
}
AlwaysLog("NullEthernet: NullEthernet v1.0.0 starting.\n");
done:
DebugLog("start() <===\n");
return true;
error1:
OSSafeReleaseNULL(m_pProvider);
return false;
}
bool darwin_iwi3945::start(IOService *provider)
{
UInt16 reg;
//linking the kext control clone to the driver:
clone=this;
firstifup=0;
do {
if ( super::start(provider) == 0) {
IOLog("%s ERR: super::start failed\n", getName());
break;
}
if ( (fPCIDevice = OSDynamicCast(IOPCIDevice, provider)) == 0) {
IOLog("%s ERR: fPCIDevice == 0 :(\n", getName());
break;
}
fPCIDevice->retain();
if (fPCIDevice->open(this) == 0) {
IOLog("%s ERR: fPCIDevice->open(this) failed\n", getName());
break;
}
// Request domain power.
// Without this, the PCIDevice may be in state 0, and the
// PCI config space may be invalid if the machine has been
// sleeping.
if (fPCIDevice->requestPowerDomainState(kIOPMPowerOn,
(IOPowerConnection *) getParentEntry(gIOPowerPlane),
IOPMLowestState ) != IOPMNoErr) {
IOLog("%s Power thingi failed\n", getName());
break;
}
/*UInt16 reg16;
reg16 = fPCIDevice->configRead16(kIOPCIConfigCommand);
reg16 |= (kIOPCICommandBusMaster |
kIOPCICommandMemorySpace |
kIOPCICommandMemWrInvalidate);
reg16 &= ~kIOPCICommandIOSpace; // disable I/O space
fPCIDevice->configWrite16(kIOPCIConfigCommand,reg16);*/
fPCIDevice->setBusMasterEnable(true);
fPCIDevice->setMemoryEnable(true);
irqNumber = fPCIDevice->configRead8(kIOPCIConfigInterruptLine);
vendorID = fPCIDevice->configRead16(kIOPCIConfigVendorID);
deviceID = fPCIDevice->configRead16(kIOPCIConfigDeviceID);
pciReg = fPCIDevice->configRead16(kIOPCIConfigRevisionID);
map = fPCIDevice->mapDeviceMemoryWithRegister(kIOPCIConfigBaseAddress0, kIOMapInhibitCache);
if (map == 0) {
IOLog("%s map is zero\n", getName());
break;
}
ioBase = map->getPhysicalAddress();
memBase = (UInt16 *)map->getVirtualAddress();
//memDes = map->getMemoryDescriptor();
//mem = fPCIDevice->getDeviceMemoryWithRegister(kIOPCIConfigBaseAddress0);
//memDes->initWithPhysicalAddress(ioBase, map->getLength(), kIODirectionOutIn);
/* We disable the RETRY_TIMEOUT register (0x41) to keep
* PCI Tx retries from interfering with C3 CPU state */
reg = fPCIDevice->configRead16(0x40);
if((reg & 0x0000ff00) != 0)
fPCIDevice->configWrite16(0x40, reg & 0xffff00ff);
printf("%s iomemory length: 0x%x @ 0x%x\n", getName(), map->getLength(), ioBase);
printf("%s virt: 0x%x physical: 0x%x\n", getName(), memBase, ioBase);
printf("%s IRQ: %d, Vendor ID: %04x, Product ID: %04x\n", getName(), irqNumber, vendorID, deviceID);
fWorkLoop = (IOWorkLoop *) getWorkLoop();
if (!fWorkLoop) {
//IOLog("%s ERR: start - getWorkLoop failed\n", getName());
break;
}
fInterruptSrc = IOInterruptEventSource::interruptEventSource(
this, (IOInterruptEventAction) &darwin_iwi3945::interruptOccurred,
provider);
if(!fInterruptSrc || (fWorkLoop->addEventSource(fInterruptSrc) != kIOReturnSuccess)) {
//IOLog("%s fInterruptSrc error\n", getName());
break;;
}
// This is important. If the interrupt line is shared with other devices,
// then the interrupt vector will be enabled only if all corresponding
// interrupt event sources are enabled. To avoid masking interrupts for
// other devices that are sharing the interrupt line, the event source
// is enabled immediately.
fInterruptSrc->enable();
//mutex=IOLockAlloc();
fTransmitQueue = createOutputQueue();
if (fTransmitQueue == NULL)
{
IWI_ERR("ERR: getOutputQueue()\n");
break;
}
fTransmitQueue->setCapacity(1024);
iwl_pci_probe();
if (!priv) break;
iwl_hw_nic_init(priv);
iwl_hw_nic_reset(priv);
if (attachInterface((IONetworkInterface **) &fNetif, false) == false) {
//IOLog("%s attach failed\n", getName());
break;
}
setProperty(kIOMinPacketSize,12);
setProperty(kIOMaxPacketSize, IWL_RX_BUF_SIZE);
//setProperty(kIOFeatures, kIONetworkFeatureNoBSDWait|kIONetworkFeatureSoftwareVlan);
fNetif->registerOutputHandler(this,getOutputHandler());
fNetif->registerService();
registerService();
mediumDict = OSDictionary::withCapacity(MEDIUM_TYPE_INVALID + 1);
addMediumType(kIOMediumIEEE80211None, 0, MEDIUM_TYPE_NONE);
addMediumType(kIOMediumIEEE80211Auto, 0, MEDIUM_TYPE_AUTO);
publishMediumDictionary(mediumDict);
setCurrentMedium(mediumTable[MEDIUM_TYPE_AUTO]);
setSelectedMedium(mediumTable[MEDIUM_TYPE_AUTO]);
setLinkStatus(kIONetworkLinkValid, mediumTable[MEDIUM_TYPE_AUTO]);
//kext control registration:
//these functions registers the control which enables
//the user to interact with the driver
struct kern_ctl_reg ep_ctl; // Initialize control
kern_ctl_ref kctlref;
bzero(&ep_ctl, sizeof(ep_ctl));
ep_ctl.ctl_id = 0;
ep_ctl.ctl_unit = 0;
strcpy(ep_ctl.ctl_name,"insanelymac.iwidarwin.control");
ep_ctl.ctl_flags = 0;
ep_ctl.ctl_connect = ConnectClient;
ep_ctl.ctl_disconnect = disconnectClient;
ep_ctl.ctl_send = setSelectedNetwork;
ep_ctl.ctl_setopt = configureConnection;
ep_ctl.ctl_getopt = sendNetworkList;
errno_t error = ctl_register(&ep_ctl, &kctlref);
//queue_te(12,OSMemberFunctionCast(thread_call_func_t,this,&darwin_iwi3945::check_firstup),NULL,NULL,false);
//queue_te(12,OSMemberFunctionCast(thread_call_func_t,this,&darwin_iwi3945::check_firstup),priv,1000,true);
//check_firstup(priv);
return true; // end start successfully
} while (false);
//stop(provider);
//free();
return false; // end start insuccessfully
}
bool
MolEnet::start( IOService * provider )
{
IOPhysicalAddress tx_phys, rx_phys;
IOPhysicalAddress tx_of_phys, rx_of_phys;
int i, result;
if( !super::start(provider) )
return false;
if( OSI_Enet2Open() ) {
is_open = 1;
return false;
}
//transmitQueue = OSDynamicCast( IOGatedOutputQueue, getOutputQueue() );
transmitQueue = OSDynamicCast( IOBasicOutputQueue, getOutputQueue() );
if( !transmitQueue ) {
printm("MolEnet: output queue initialization failed\n");
return false;
}
transmitQueue->retain();
// Allocate a IOMbufBigMemoryCursor instance. Currently, the maximum
// number of segments is set to 2. The maximum length for each segment
// is set to the maximum ethernet frame size (plus padding).
txMBufCursor = IOMbufBigMemoryCursor::withSpecification( NETWORK_BUFSIZE, 2 );
rxMBufCursor = IOMbufBigMemoryCursor::withSpecification( NETWORK_BUFSIZE, 2 );
if( !txMBufCursor || !rxMBufCursor ) {
printm("MolEnet: IOMbufBigMemoryCursor allocation failure\n");
return false;
}
// Get a reference to the IOWorkLoop in our superclass.
IOWorkLoop * myWorkLoop = getWorkLoop();
assert(myWorkLoop);
// Allocate a IOInterruptEventSources.
_irq = IOInterruptEventSource::interruptEventSource( this,
(IOInterruptEventAction)&MolEnet::rxIRQ, provider, 0);
if( !_irq || (myWorkLoop->addEventSource(_irq) != kIOReturnSuccess )) {
printm("MolEnet: _irq init failure\n");
return false;
}
// Allocate the ring descriptors
rx_ring = (enet2_ring_t*)IOMallocContiguous( 2 * RX_NUM_EL * sizeof(enet2_ring_t),
sizeof(enet2_ring_t), &rx_phys );
tx_ring = (enet2_ring_t*)IOMallocContiguous( 2 * TX_NUM_EL * sizeof(enet2_ring_t),
sizeof(enet2_ring_t), &tx_phys );
if( !rx_ring || !tx_ring )
return false;
rx_of_ring = rx_ring + RX_NUM_EL;
tx_of_ring = tx_ring + TX_NUM_EL;
rx_of_phys = rx_phys + sizeof(enet2_ring_t) * RX_NUM_EL;
tx_of_phys = tx_phys + sizeof(enet2_ring_t) * TX_NUM_EL;
// Allocate receive buffers
for( i=0; i<RX_NUM_EL; i++ ) {
if( !(rxMBuf[i]=allocatePacket( NETWORK_BUFSIZE )) ) {
printm("MolEnet: packet allocation failed\n");
return false;
}
// reserve 2 bytes before the actual packet
rxMBuf[i]->m_data += 2;
rxMBuf[i]->m_len -= 2;
}
OSI_Enet2Cntrl( kEnet2Reset );
result = OSI_Enet2RingSetup( kEnet2SetupRXRing, rx_phys, RX_NUM_EL )
|| OSI_Enet2RingSetup( kEnet2SetupTXRing, tx_phys, TX_NUM_EL )
|| OSI_Enet2RingSetup( kEnet2SetupRXOverflowRing, rx_of_phys, RX_NUM_EL )
|| OSI_Enet2RingSetup( kEnet2SetupTXOverflowRing, tx_of_phys, TX_NUM_EL );
if( result )
return false;
if( !resetAndEnable(false) )
return false;
// Create a table of supported media types.
if( !createMediumTables() )
return false;
// Attach an IOEthernetInterface client.
if( !attachInterface( (IONetworkInterface**)&networkInterface, false ) )
return false;
// Ready to service interface requests.
networkInterface->registerService();
printm("Ethernet driver 1.1\n");
return true;
}
bool CLASS::start( IOService * provider )
{
bool success = false;
bool superStart = false;
do {
// Start our superclass first.
if (false == super::start(provider))
break;
superStart = true;
// Save a reference to our provider.
fPCINub = OSDynamicCast(IOPCIDevice, provider);
if (!fPCINub)
break;
// Retain provider, released in free().
fPCINub->retain();
// Open our provider.
if (false == fPCINub->open(this))
break;
// Allocate mbuf cursors and other support objects.
if (false == allocateSupportObjects(provider))
break;
// Initialize our harwdare's PCI config space.
initPCIConfigSpace(fPCINub);
// Get the virtual address mapping of registers located at
// Base Address Range 1 (offset 0x14 - memory range).
fRegMap = fPCINub->mapDeviceMemoryWithRegister(
kIOPCIConfigBaseAddress1);
if (0 == fRegMap)
break;
fRegBase = (volatile void *) fRegMap->getVirtualAddress();
// Detect the hardware type.
if (probeHardware() == false)
{
ERROR_LOG("%s: probeHardware() failed\n", getName());
break;
}
// Publish our media capabilities.
phyProbeCapability();
success = true;
}
while ( false );
// Stop super on failure.
if (!success && superStart)
{
super::stop(provider);
}
// Close our provider, it will be re-opened on demand when
// our enable() is called by a client.
if (fPCINub) fPCINub->close(this);
do {
if (false == success) break;
success = false;
// Allocate and attach an IOEthernetInterface instance.
if (false == attachInterface((IONetworkInterface **)&fNetif, false))
break;
// Optional: this driver supports kernel debugging.
// Reserved a copy buffer memory used during kernel debugging,
// and resolve its physical address. Use mbuf for convenience.
fKDPMbuf = allocatePacket(kIOEthernetMaxPacketSize);
if (fKDPMbuf &&
fRxMbufCursor->getPhysicalSegments(fKDPMbuf, &fKDPMbufSeg) == 1)
{
attachDebuggerClient(&fKDPNub);
}
// Start matching clients of netif.
fNetif->registerService();
success = true;
}
while ( false );
return success;
}
bool RTL8139::start( IOService *provider )
{
OSObject *builtinProperty;
bool success = false;
ELG( IOThreadSelf(), provider, 'Strt', "RTL8139::start - this, provider." );
DEBUG_LOG( "start() ===>\n" );
do
{
if ( false == super::start( provider ) ) // Start our superclass first
break;
// Save a reference to our provider.
pciNub = OSDynamicCast( IOPCIDevice, provider );
if ( 0 == pciNub )
break;
pciNub->retain(); // Retain provider, released in free().
if ( false == pciNub->open( this ) ) // Open our provider.
break;
fBuiltin = false;
builtinProperty = provider->getProperty( "built-in" );
if ( builtinProperty )
{
fBuiltin = true;
ELG( 0, 0, 'b-in', "RTL8139::start - found built-in property." );
}
if ( false == initEventSources( provider ) )
break;
// Allocate memory for descriptors. This function will leak memory
// if called more than once. So don't do it.
if ( false == allocateDescriptorMemory() )
break;
// Get the virtual address mapping of CSR registers located at
// Base Address Range 0 (0x10).
csrMap = pciNub->mapDeviceMemoryWithRegister( kIOPCIConfigBaseAddress1 );
if ( 0 == csrMap )
break;
csrBase = (volatile void*)csrMap->getVirtualAddress();
// Init PCI config space:
if ( false == initPCIConfigSpace( pciNub ) )
break;
// Reset chip to bring it to a known state.
if ( initAdapter( kResetChip ) == false )
{
IOLog( "%s: initAdapter() failed\n", getName() );
break;
}
registerEEPROM();
// Publish our media capabilities:
phyProbeMediaCapability();
if ( false == publishMediumDictionary( mediumDict ) )
break;
success = true;
} while ( false );
// Close our provider, it will be re-opened on demand when
// our enable() is called by a client.
if ( pciNub )
pciNub->close( this );
do
{
if ( false == success )
break;
success = false;
// Allocate and attach an IOEthernetInterface instance.
if ( false == attachInterface( (IONetworkInterface**)&netif, false) )
break;
// Optional: this driver supports kernel debugging.
attachDebuggerClient( &debugger );
// Trigger matching for clients of netif.
netif->registerService();
success = true;
}
while ( false );
DEBUG_LOG( "start() <===\n" );
return success;
}/* end start */
bool AgereET131x::start(IOService* provider)
{
//IOLog("%s::%s()\n",getName(),__FUNCTION__);
bool success = false;
if (super::start(provider) == false) {
IOLog("supper::start failed.\n");
return false;
}
pciDevice = OSDynamicCast(IOPCIDevice, provider);
if (pciDevice == NULL)
return false;
pciDevice->retain();
if (pciDevice->open(this) == false)
return false;
adapter.VendorID = pciDevice->configRead16(kIOPCIConfigVendorID);
adapter.DeviceID = pciDevice->configRead16(kIOPCIConfigDeviceID);
adapter.SubVendorID = pciDevice->configRead16(kIOPCIConfigSubSystemVendorID);
adapter.SubSystemID = pciDevice->configRead16(kIOPCIConfigSubSystemID);
adapter.RevisionID = pciDevice->configRead8(kIOPCIConfigRevisionID);
// adapter.hw.device_id will be used later
IOLog("vendor:device: 0x%x:0x%x.\n", adapter.VendorID, adapter.DeviceID);
do {
if(!initEventSources(provider)){
break;
}
csrPCIAddress = pciDevice->mapDeviceMemoryWithRegister(kIOPCIConfigBaseAddress0);
if (csrPCIAddress == NULL) {
IOLog("csrPCIAddress.\n");
break;
}
adapter.CSRAddress = (ADDRESS_MAP_t*)csrPCIAddress->getVirtualAddress();
adapter.netdev = this;
adapter.pdev = pciDevice;
set_mtu( ETH_DATA_LEN );
// Init PCI config space:
if ( false == initPCIConfigSpace() )
break;
// reset the hardware with the new settings
addNetworkMedium(kIOMediumEthernetAuto, 0, MEDIUM_INDEX_AUTO);
addNetworkMedium(kIOMediumEthernet10BaseT | kIOMediumOptionHalfDuplex,
10 * MBit, MEDIUM_INDEX_10HD);
addNetworkMedium(kIOMediumEthernet10BaseT | kIOMediumOptionFullDuplex,
10 * MBit, MEDIUM_INDEX_10FD);
addNetworkMedium(kIOMediumEthernet100BaseTX | kIOMediumOptionHalfDuplex,
100 * MBit, MEDIUM_INDEX_100HD);
addNetworkMedium(kIOMediumEthernet100BaseTX | kIOMediumOptionFullDuplex,
100 * MBit, MEDIUM_INDEX_100FD);
addNetworkMedium(kIOMediumEthernet1000BaseT | kIOMediumOptionFullDuplex,
1000 * MBit, MEDIUM_INDEX_1000FD);
if (!publishMediumDictionary(mediumDict)) {
IOLog("publishMediumDictionary.\n");
break;
}
success = true;
} while(false);
// Close our provider, it will be re-opened on demand when
// our enable() is called by a client.
pciDevice->close(this);
do {
if ( false == success )
break;
// Allocate and attach an IOEthernetInterface instance.
if (attachInterface((IONetworkInterface **)(&netif), true) == false) {
IOLog("Failed to attach data link layer.\n");
break;
}
success = true;
} while(false);
if(false == success){
adapter_memory_free();
}
return success;
}
