bool
MolEnet::createMediumTables()
{
IONetworkMedium *medium;
UInt32 i;
mediumDict = OSDictionary::withCapacity( sizeof(mediumTable)/sizeof(mediumTable[0]) );
if( !mediumDict )
return false;
for( i=0; i<sizeof(mediumTable)/sizeof(mediumTable[0]); i++ ) {
medium = IONetworkMedium::medium( mediumTable[i].type, mediumTable[i].speed );
if( medium ) {
IONetworkMedium::addMedium( mediumDict, medium );
medium->release();
}
}
if( !publishMediumDictionary( mediumDict ) )
return false;
medium = IONetworkMedium::getMediumWithType( mediumDict, kIOMediumEthernetAuto );
setCurrentMedium( medium );
return true;
}
IOReturn AttansicL2Ethernet::selectMedium(const IONetworkMedium *medium)
{
DbgPrint("selectMedium()\n");
if (medium)
{
switch(medium->getIndex())
{
case MEDIUM_INDEX_AUTO:
DbgPrint("Selected medium is autoselect\n");
adapter_.link_speed = SPEED_100;
adapter_.link_duplex = FULL_DUPLEX;
adapter_.hw.MediaType = MEDIA_TYPE_AUTO_SENSOR;
break;
case MEDIUM_INDEX_10HD:
DbgPrint("Selected medium is 10HD\n");
adapter_.link_speed = SPEED_10;
adapter_.link_duplex = HALF_DUPLEX;
adapter_.hw.MediaType = MEDIA_TYPE_10M_HALF;
break;
case MEDIUM_INDEX_10FD:
DbgPrint("Selected medium is 10FD\n");
adapter_.link_speed = SPEED_10;
adapter_.link_duplex = FULL_DUPLEX;
adapter_.hw.MediaType = MEDIA_TYPE_10M_FULL;
break;
case MEDIUM_INDEX_100HD:
DbgPrint("Selected medium is 100HD\n");
adapter_.link_speed = SPEED_100;
adapter_.link_duplex = HALF_DUPLEX;
adapter_.hw.MediaType = MEDIA_TYPE_100M_HALF;
break;
case MEDIUM_INDEX_100FD:
DbgPrint("Selected medium is 100FD\n");
adapter_.link_speed = SPEED_100;
adapter_.link_duplex = FULL_DUPLEX;
adapter_.hw.MediaType = MEDIA_TYPE_100M_FULL;
break;
}
atSetupLink();
setCurrentMedium(medium);
}
else
{
DbgPrint("Selected medium is NULL\n");
return kIOReturnError;
}
//Refresh link status
IOSleep(100*((medium->getIndex() == MEDIUM_INDEX_AUTO)? PHY_AUTO_NEG_TIME:PHY_FORCE_TIME));
atGetAndUpdateLinkStatus();
return kIOReturnSuccess;
}
IOReturn NullEthernet::selectMedium(const IONetworkMedium *medium)
{
IOReturn result = kIOReturnSuccess;
DebugLog("selectMedium() ===>\n");
if (medium) {
#if 0
switch (medium->getIndex()) {
case MEDIUM_INDEX_AUTO:
autoneg = AUTONEG_ENABLE;
speed = SPEED_1000;
duplex = DUPLEX_FULL;
break;
case MEDIUM_INDEX_10HD:
autoneg = AUTONEG_DISABLE;
speed = SPEED_10;
duplex = DUPLEX_HALF;
break;
case MEDIUM_INDEX_10FD:
autoneg = AUTONEG_DISABLE;
speed = SPEED_10;
duplex = DUPLEX_FULL;
break;
case MEDIUM_INDEX_100HD:
autoneg = AUTONEG_DISABLE;
speed = SPEED_100;
duplex = DUPLEX_HALF;
break;
case MEDIUM_INDEX_100FD:
autoneg = AUTONEG_DISABLE;
speed = SPEED_100;
duplex = DUPLEX_FULL;
break;
case MEDIUM_INDEX_1000FD:
autoneg = AUTONEG_DISABLE;
speed = SPEED_1000;
duplex = DUPLEX_FULL;
break;
}
#endif
setCurrentMedium(medium);
}
DebugLog("selectMedium() <===\n");
done:
return result;
}
IOReturn HoRNDIS::enable(IONetworkInterface *netif) {
IONetworkMedium *medium;
IOReturn rtn = kIOReturnSuccess;
if (fNetifEnabled) {
LOG(V_ERROR, "already enabled?");
return kIOReturnSuccess;
}
if (!allocateResources())
return kIOReturnNoMemory;
if (!fMediumDict)
if (!createMediumTables()) {
rtn = kIOReturnNoMemory;
goto bailout;
}
setCurrentMedium(IONetworkMedium::medium(kIOMediumEthernetAuto, 480 * 1000000));
/* Kick off the first read. */
inbuf.comp.target = this;
inbuf.comp.action = dataReadComplete;
inbuf.comp.parameter = NULL;
rtn = fInPipe->Read(inbuf.mdp, &inbuf.comp, NULL);
if (rtn != kIOReturnSuccess)
goto bailout;
/* Tell the world that the link is up... */
medium = IONetworkMedium::getMediumWithType(fMediumDict, kIOMediumEthernetAuto);
setLinkStatus(kIONetworkLinkActive | kIONetworkLinkValid, medium, 480 * 1000000);
/* ... and then listen for packets! */
getOutputQueue()->setCapacity(TRANSMIT_QUEUE_SIZE);
getOutputQueue()->start();
LOG(V_DEBUG, "txqueue started");
/* Tell the other end to start transmitting. */
if (!rndisSetPacketFilter(RNDIS_DEFAULT_FILTER))
goto bailout;
/* Now we can say we're alive. */
fNetifEnabled = true;
return kIOReturnSuccess;
bailout:
LOG(V_ERROR, "setting up the pipes failed");
releaseResources();
return rtn;
}
IOReturn AgereET131x::selectMedium(const IONetworkMedium * medium)
{
if (OSDynamicCast(IONetworkMedium, medium) == 0) {
// Defaults to Auto.
medium = mediumTable[MEDIUM_INDEX_AUTO];
}
if (medium){
setCurrentMedium(medium);
return kIOReturnSuccess;
}
return kIOReturnIOError;
}
IOReturn RTL8139::selectMedium( const IONetworkMedium *medium )
{
bool success;
ELG( 0, medium, 'sMed', "RTL8139::selectMedium" );
if ( medium == 0 )
medium = phyGetMediumWithIndex( MEDIUM_INDEX_AUTO );
if ( medium == 0 )
return kIOReturnUnsupported;
success = phySetMedium( medium );
if ( success )
{
setCurrentMedium( medium );
forceLinkChange = true; // force link change
phyReportLinkStatus();
}
return success ? kIOReturnSuccess : kIOReturnIOError;
}/* end selectMedium */
IOReturn darwin_iwi3945::selectMedium(const IONetworkMedium * medium)
{
bool r;
if ( OSDynamicCast(IONetworkMedium, medium) == 0 )
{
// Defaults to Auto.
medium = mediumTable[MEDIUM_TYPE_AUTO];
if ( medium == 0 ) {
//IOLog("selectMedium failed\n");
return kIOReturnError;
}
}
// Program PHY to select the desired medium.
//r = _phySetMedium( (mediumType_t) medium->getIndex() );
if ( r && !setCurrentMedium(medium) )
//IOLog("%s: setCurrentMedium error\n", getName());
//IOLog("Medium is set to: %s\n", medium->getName()->getCStringNoCopy());
return ( r ? kIOReturnSuccess : kIOReturnIOError );
}
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
}
