[apple/xnu.git] / iokit / Drivers / network / drvIntel82557 / i82557.cpp

/*
 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1996 NeXT Software, Inc.  All rights reserved. 
 *
 * i82557.cpp
 *
 * HISTORY
 *
 * 22-Jan-96    Dieter Siegmund (dieter) at NeXT
 *      Created.
 *
 * 03-May-96    Dieter Siegmund (dieter) at NeXT
 *      Added a real ISR to improve performance.
 *
 * 10-June-96   Dieter Siegmund (dieter) at NeXT
 *      Added support for Splash 3 (10 Base-T only card).
 *
 * 18-June-96   Dieter Siegmund (dieter) at NeXT
 *      Keep the transmit queue draining by interrupting every
 *      N / 2 transmits (where N is the size of the hardware queue).
 *
 * 15-Dec-97    Joe Liu (jliu) at Apple
 *      Updated PHY programming to be 82558 aware.
 *      Misc changes to conform to new 82558 register flags.
 *      Changed RNR interrupt handler to restart RU instead of a reset.
 *      Interrupt handler now does a thread_call_func() to do most of its work.
 *      Interrupts are disabled until the thread callout finishes its work.
 *      Increased the size of TX/RX rings.
 *      buffer object removed, we use cluster mbufs to back up the receive ring.
 *
 * 29-May-98    Joe Liu (jliu) at Apple
 *      Updated _setupPhy method to take advantage of parallel detection whenever
 *      possible in order to detect the proper link speed.
 *
 * 17-Aug-98    Joe Liu (jliu) at Apple
 *      Re-enabled the setting of txready_sel PHY (PCS) bit for DP83840.
 *      Simplified interrupt handling, resulting in RCV performance improvements.
 *      Receive packets are sent upstream via a cached function pointer.
 */

#include "i82557.h"

#define ONE_SECOND_TICKS                        1000
#define LOAD_STATISTICS_INTERVAL        (4 * ONE_SECOND_TICKS)

#define super IOEthernetController
OSDefineMetaClassAndStructors( Intel82557, IOEthernetController )

//---------------------------------------------------------------------------
// Function: pciConfigInit
//
// Update PCI command register to enable the memory-mapped range,
// and bus-master interface.

bool Intel82557::pciConfigInit(IOPCIDevice * provider)
{
        UInt32  reg;
        
        reg = provider->configRead32( kIOPCIConfigCommand );

    reg |= ( kIOPCICommandBusMaster       |
             kIOPCICommandMemorySpace     |
             kIOPCICommandMemWrInvalidate );

    reg &= ~kIOPCICommandIOSpace;  // disable I/O space

        provider->configWrite32( kIOPCIConfigCommand, reg );

        return true;
}

//---------------------------------------------------------------------------
// Function: initDriver
//
// Create and initialize driver objects before the hardware is 
// enabled.
//
// Returns true on sucess, and false if initialization failed.

bool Intel82557::initDriver(IOService * provider)
{
        currentMediumType = MEDIUM_TYPE_INVALID;

        // This driver will allocate and use an IOGatedOutputQueue.
        //
        transmitQueue = getOutputQueue();
        if ( transmitQueue == 0 ) return false;

        // Allocate two IOMbufLittleMemoryCursor instances. One for transmit and
        // the other for receive.
        //
        rxMbufCursor = IOMbufLittleMemoryCursor::withSpecification(MAX_BUF_SIZE,1);
        txMbufCursor = IOMbufLittleMemoryCursor::withSpecification(MAX_BUF_SIZE, 
                                                                   TBDS_PER_TCB);
        if (!rxMbufCursor || !txMbufCursor)
                return false;

        // Get a handle to our superclass' workloop.
        //
        IOWorkLoop * myWorkLoop = (IOWorkLoop *) getWorkLoop();
        if (!myWorkLoop)
                return false;

        // Create and register an interrupt event source. The provider will
        // take care of the low-level interrupt registration stuff.
        //
        interruptSrc = 
                IOInterruptEventSource::interruptEventSource(this,
                    (IOInterruptEventAction) &Intel82557::interruptOccurred,
                    provider);

        if (!interruptSrc ||
                (myWorkLoop->addEventSource(interruptSrc) != kIOReturnSuccess))
                return false;

        // Register a timer event source. This is used as a watchdog timer.
        //
        timerSrc = IOTimerEventSource::timerEventSource( this,
               (IOTimerEventSource::Action) &Intel82557::timeoutOccurred );
        if (!timerSrc ||
                (myWorkLoop->addEventSource(timerSrc) != kIOReturnSuccess))
                return false;

        // Create a dictionary to hold IONetworkMedium objects.
        //
        mediumDict = OSDictionary::withCapacity(5);
        if (!mediumDict)
                return false;

        return true;
}

//---------------------------------------------------------------------------
// Function: getDefaultSettings
//
// Get the default driver settings chosen by the user. The properties
// are all stored in our property table (an OSDictionary).

bool Intel82557::getDefaultSettings()
{
        OSNumber *  numObj;
    OSBoolean * boolObj;

    // Check for PHY address override.
        //
    phyAddr = PHY_ADDRESS_DEFAULT;
        numObj  = OSDynamicCast( OSNumber, getProperty("PHY Address") );
        if ( numObj )
    {
                phyAddr = numObj->unsigned32BitValue();
    }

    // Check for Verbose flag.
        //
    verbose = false;
        boolObj = OSDynamicCast( OSBoolean, getProperty("Verbose") );
        if ( boolObj && boolObj->isTrue() )
    {
                IOLog("%s: verbose mode enabled\n", getName());
                verbose = true;
        }

    // Check for Flow-Control enable flag.
        //
    flowControl = false;
    boolObj = OSDynamicCast( OSBoolean, getProperty("Flow Control") );
        if ( boolObj && boolObj->isTrue() )
    {
                IOLog("%s: 802.3x flow control enabled\n", getName());
                flowControl = true;
        }

        return true;
}

//---------------------------------------------------------------------------
// Function: start <IOService>
//
// Hardware was detected and initialized, start the driver.

bool Intel82557::start( IOService * provider )
{
    bool ret = false;

    do {
        // Start our superclass first.

        if ( super::start(provider) == false )
            break;

        // Cache our provider to an instance variable.

        pciNub = OSDynamicCast(IOPCIDevice, provider);
        if ( pciNub == 0 ) break;

        // Retain provider, released in free().

        pciNub->retain();

        // Open our provider.

        if ( pciNub->open(this) == false ) break;

        // Initialize the driver's event sources and other support objects.

        if ( initDriver(provider) == false ) break;

        // Get the virtual address mapping of CSR registers located at
        // Base Address Range 0 (0x10). The size of this range is 4K.

        csrMap = pciNub->mapDeviceMemoryWithRegister( kIOPCIConfigBaseAddress0 );
        if ( csrMap == 0 ) break;
        
        CSR_p  = (CSR_t *) csrMap->getVirtualAddress();

        // Setup our PCI config space.

        if ( pciConfigInit(pciNub) == false ) break;

        // Create the EEPROM object.

        eeprom = i82557eeprom::withAddress(&CSR_p->eepromControl);
        if ( eeprom == 0 )
        {
            IOLog("%s: couldn't allocate eeprom object", getName());
                        break;
        }

        // Get default driver settings (stored in property table).

        if ( getDefaultSettings() == false ) break;

        if ( verbose ) eeprom->dumpContents();

        // Execute one-time initialization code.

        if ( coldInit() == false )
        {
            IOLog("%s: coldInit failed\n", getName());
            break;
        }

        if ( hwInit() == false )
        {
            IOLog("%s: hwInit failed\n", getName());
            break;
        }

        // Publish our media capabilities.

        _phyPublishMedia();
        if ( publishMediumDictionary(mediumDict) == false )
        {
            IOLog("%s: publishMediumDictionary failed\n", getName());
                        break;
        }

#if 0
        // Announce the basic hardware configuration info.
        IOLog("%s: Memory 0x%lx irq %d\n", getName(),
              csrMap->getPhysicalAddress(), 0);
#endif

        ret = true;
    }
    while ( false );

    // Close our provider, it will be re-opened on demand when
    // our enable() is called.

    if ( pciNub ) pciNub->close(this);

    do {
        if ( ret == false ) break;

        ret = false;

        // Allocate and attach an IOEthernetInterface instance to this driver
        // object.

        if ( attachInterface((IONetworkInterface **) &netif, false) == false )
            break;
        
        // Attach a kernel debugger client. This is not an essential service,
        // and the return is not checked.

        attachDebuggerClient(&debugger);

        // Start matching for clients of IONetworkInterface.

        netif->registerService();
        
        ret = true;
    }
    while ( false );
    
    return ret;
}

//---------------------------------------------------------------------------
// Function: stop <IOService>
//
// Stop all activities and prepare for termination.

void Intel82557::stop(IOService * provider)
{
    super::stop(provider);
}

//---------------------------------------------------------------------------
// Function: createWorkLoop <IONetworkController>
//
// Override IONetworkController::createWorkLoop() method to create a workloop.

bool Intel82557::createWorkLoop()
{
    workLoop = IOWorkLoop::workLoop();

    return ( workLoop != 0 );
}

//---------------------------------------------------------------------------
// Function: getWorkLoop <IOService>
//
// Override IOService::getWorkLoop() method to return our workloop.

IOWorkLoop * Intel82557::getWorkLoop() const
{
    return workLoop;
}

//---------------------------------------------------------------------------
// Function: configureInterface <IONetworkController>
//
// Configure a newly instantiated IONetworkInterface object.

bool Intel82557::configureInterface(IONetworkInterface * netif)
{
        IONetworkData * data;
        
        if ( super::configureInterface(netif) == false )
                return false;
        
        // Get the generic network statistics structure.

        data = netif->getParameter(kIONetworkStatsKey);
        if (!data || !(netStats = (IONetworkStats *) data->getBuffer())) {
                return false;
        }

        // Get the Ethernet statistics structure.

        data = netif->getParameter(kIOEthernetStatsKey);
        if (!data || !(etherStats = (IOEthernetStats *) data->getBuffer())) {
                return false;
        }
        
        return true;
}

//---------------------------------------------------------------------------
// Function: free <IOService>
//
// Deallocate all resources and destroy the instance.

void Intel82557::free()
{
        if (debugger)      { debugger->release();     debugger = 0;     }
    if (netif)         { netif->release();        netif = 0;        }
        if (interruptSrc)  { interruptSrc->release(); interruptSrc = 0; }
        if (timerSrc)      { timerSrc->release();     timerSrc = 0;     }
        if (rxMbufCursor)  { rxMbufCursor->release(); rxMbufCursor = 0; }
        if (txMbufCursor)  { txMbufCursor->release(); txMbufCursor = 0; }
        if (csrMap)        { csrMap->release();       csrMap = 0;       }
        if (eeprom)        { eeprom->release();       eeprom = 0;       }
        if (mediumDict)    { mediumDict->release();   mediumDict = 0;   }
    if ( pciNub )      { pciNub->release();       pciNub = 0;       }
    if ( workLoop )    { workLoop->release();     workLoop = 0;     }

        _freeMemPage( &shared );
        _freeMemPage( &txRing );
        _freeMemPage( &rxRing );

        super::free();  // pass it to our superclass
}

//---------------------------------------------------------------------------
// Function: enableAdapter
//
// Enables the adapter & driver to the given level of support.

bool Intel82557::enableAdapter(UInt32 level)
{
        bool ret = false;

//      IOLog("%s::%s enabling level %ld\n", getName(), __FUNCTION__, level);

        switch (level) {
                case kActivationLevel1:

            // Open provider.
            //
            if ( ( pciNub == 0 ) || ( pciNub->open(this) == false ) )
            {
                break;
            }

                        if (!_initRingBuffers())
                                break;
                
                        if (!_startReceive()) {
                                _clearRingBuffers();
                                break;
                        }
                
                        // Set current medium.
                        //
                        if (setMedium(getCurrentMedium()) != kIOReturnSuccess)
                                IOLog("%s: setMedium error\n", getName());

                        // Start the watchdog timer.
                        //
                        timerSrc->setTimeoutMS(LOAD_STATISTICS_INTERVAL);

                        // Enable interrupt event sources and hardware interrupts.
                        //
                        if (getWorkLoop())
                                getWorkLoop()->enableAllInterrupts();
                        enableAdapterInterrupts();

            // Force PHY to report link status.
            //
            _phyReportLinkStatus(true);

                        ret = true;
                        break;
                
                case kActivationLevel2:
                        // Issue a dump statistics command.
                        //
                        _dumpStatistics();
                
                        // Start our IOOutputQueue object.
                        //
                        transmitQueue->setCapacity(TRANSMIT_QUEUE_SIZE);
                        transmitQueue->start();

                        ret = true;
                        break;
        }

        if (!ret)
                IOLog("%s::%s error in level %ld\n", getName(), __FUNCTION__, level);

        return ret;
}

//---------------------------------------------------------------------------
// Function: disableAdapter
//
// Disables the adapter & driver to the given level of support.

bool Intel82557::disableAdapter(UInt32 level)
{
        bool ret = false;

//      IOLog("%s::%s disabling level %ld\n", getName(), __FUNCTION__, level);
                
        switch (level) {
                case kActivationLevel1:
                        // Disable interrupt handling and hardware interrupt sources.
                        //
                        disableAdapterInterrupts();
                        if (getWorkLoop())
                                getWorkLoop()->disableAllInterrupts();

                        // Stop the timer event source, and initialize the watchdog state.
                        //
                        timerSrc->cancelTimeout();
                        packetsReceived    = true;      // assume we're getting packets
                        packetsTransmitted = false;
                        txCount = 0;
                
                        // Reset the hardware engine.
                        //
                        ret = hwInit();
                
                        // Clear the descriptor rings after the hardware is idle.
                        //
                        _clearRingBuffers();
                
                        // Report link status: unknown.
                        //
                        setLinkStatus(0, 0);
                
                        // Flush all packets held in the queue and prevent it
                        // from accumulating any additional packets.
                        //
                        transmitQueue->setCapacity(0);
                        transmitQueue->flush();

            // Close provider.
            //
            if ( pciNub )
            {
                pciNub->close(this);
            }

                        break;
                
                case kActivationLevel2:
                        // Stop the transmit queue. outputPacket() will not get called
                        // after this.
                        //
                        transmitQueue->stop();

                        ret = true;
                        break;
        }

        if (!ret)
                IOLog("%s::%s error in level %ld\n", getName(), __FUNCTION__, level);

        return ret;
}

//---------------------------------------------------------------------------
// Function: setActivationLevel
//
// Sets the adapter's activation level.
//
// kActivationLevel0 - Adapter is disabled.
// kActivationLevel1 - Adapter is brought up just enough to support debugging.
// kActivationLevel2 - Adapter is completely up.

bool Intel82557::setActivationLevel(UInt32 level)
{
        bool    ret = false;
        UInt32  nextLevel;

    // IOLog("---> DESIRED LEVEL : %d\n", level);

        if (currentLevel == level) return true;

        for ( ; currentLevel > level; currentLevel--) 
        {
                if ( (ret = disableAdapter(currentLevel)) == false )
                        break;
        }

        for ( nextLevel = currentLevel + 1;
          currentLevel < level; 
              currentLevel++, nextLevel++ ) 
        {
                if ( (ret = enableAdapter(nextLevel)) == false )
                        break;
        }

    // IOLog("---> PRESENT LEVEL : %d\n\n", currentLevel);

        return ret;
}

//---------------------------------------------------------------------------
// Function: enable <IONetworkController>
//
// A request from our interface client to enable the adapter.

IOReturn Intel82557::enable(IONetworkInterface * /*netif*/)
{
        if ( enabledForNetif ) return kIOReturnSuccess;

        enabledForNetif = setActivationLevel( kActivationLevel2 );

        return ( enabledForNetif ? kIOReturnSuccess : kIOReturnIOError );
}

//---------------------------------------------------------------------------
// Function: disable <IONetworkController>
//
// A request from our interface client to disable the adapter.

IOReturn Intel82557::disable(IONetworkInterface * /*netif*/)
{
        enabledForNetif = false;

    setActivationLevel( enabledForDebugger ?
                        kActivationLevel1 : kActivationLevel0 );

        return kIOReturnSuccess;
}

//---------------------------------------------------------------------------
// Function: enable <IONetworkController>
//
// A request from our debugger client to enable the adapter.

IOReturn Intel82557::enable(IOKernelDebugger * /*debugger*/)
{
        if ( enabledForDebugger || enabledForNetif )
    {
                enabledForDebugger = true;
                return kIOReturnSuccess;
        }

        enabledForDebugger = setActivationLevel( kActivationLevel1 );

        return ( enabledForDebugger ? kIOReturnSuccess : kIOReturnIOError );
}

//---------------------------------------------------------------------------
// Function: disable <IONetworkController>
//
// A request from our debugger client to disable the adapter.

IOReturn Intel82557::disable(IOKernelDebugger * /*debugger*/)
{
        enabledForDebugger = false;

        if ( enabledForNetif == false )
                setActivationLevel( kActivationLevel0 );

        return kIOReturnSuccess;
}

//---------------------------------------------------------------------------
// Function: timeoutOccurred
//
// Periodic timer that monitors the receiver status, updates error
// and collision statistics, and update the current link status.

void Intel82557::timeoutOccurred(IOTimerEventSource * /*timer*/)
{
        if ( (packetsReceived == false) && (packetsTransmitted == true) )
    {
                /*
                 * The B-step of the i82557 requires that an mcsetup command be
                 * issued if the receiver stops receiving.  This is a documented
                 * errata.
                 */
                mcSetup(0, 0, true);
        }
        packetsReceived = packetsTransmitted = false;

        _updateStatistics();

    _phyReportLinkStatus();

        timerSrc->setTimeoutMS(LOAD_STATISTICS_INTERVAL);
}

//---------------------------------------------------------------------------
// Function: setPromiscuousMode <IOEthernetController>

IOReturn Intel82557::setPromiscuousMode(IOEnetPromiscuousMode mode)
{
    bool rv;
        promiscuousEnabled = (mode == kIOEnetPromiscuousModeOff) ? false : true;
        reserveDebuggerLock();
        rv = config();
        releaseDebuggerLock();
    return (rv ? kIOReturnSuccess : kIOReturnIOError);
}

//---------------------------------------------------------------------------
// Function: setMulticastMode <IOEthernetController>

IOReturn Intel82557::setMulticastMode(IOEnetMulticastMode mode)
{
        multicastEnabled = (mode == kIOEnetMulticastModeOff) ? false : true;
        return kIOReturnSuccess;
}

//---------------------------------------------------------------------------
// Function: setMulticastList <IOEthernetController>

IOReturn Intel82557::setMulticastList(IOEthernetAddress * addrs, UInt32 count)
{
        IOReturn ret = kIOReturnSuccess;

    if ( mcSetup(addrs, count) == false )
    {
        IOLog("%s: set multicast list failed\n", getName());
                ret = kIOReturnIOError;
        }
        return ret;
}

//---------------------------------------------------------------------------
// Function: getPacketBufferConstraints <IONetworkController>
//
// Return our driver's packet alignment requirements.

void
Intel82557::getPacketBufferConstraints(IOPacketBufferConstraints * constraints) const
{
        constraints->alignStart  = kIOPacketBufferAlign2;       // even word aligned.
        constraints->alignLength = kIOPacketBufferAlign1;       // no restriction.
}

//---------------------------------------------------------------------------
// Function: getHardwareAddress <IOEthernetController>
//
// Return the adapter's hardware/Ethernet address.

IOReturn Intel82557::getHardwareAddress(IOEthernetAddress * addrs)
{
        bcopy(&myAddress, addrs, sizeof(*addrs));
        return kIOReturnSuccess;
}

//---------------------------------------------------------------------------
// Function: createOutputQueue <IONetworkController>
//
// Allocate an IOGatedOutputQueue instance.

IOOutputQueue * Intel82557::createOutputQueue()
{       
        return IOGatedOutputQueue::withTarget(this, getWorkLoop());
}

//---------------------------------------------------------------------------
// Function: setMedium <IONetworkController>
//
// Transition the controller/PHY to use a new medium. Note that
// this function can be called my the driver, or by our client.

IOReturn Intel82557::setMedium(const IONetworkMedium * medium)
{
        bool  r;

        if ( OSDynamicCast(IONetworkMedium, medium) == 0 )
    {
        // Defaults to Auto.
        medium = _phyGetMediumWithType( MEDIUM_TYPE_AUTO );
        if ( medium == 0 ) return kIOReturnError;
    }

#if 0
        IOLog("%s: setMedium -> %s\n", getName(),
          medium->getName()->getCStringNoCopy());
#endif

        // Program PHY to select the desired medium.
        //
        r = _phySetMedium( (mediumType_t) medium->getIndex() );

        // Update the current medium property.
        //
        if ( r && !setCurrentMedium(medium) )
                IOLog("%s: setCurrentMedium error\n", getName());

        return ( r ? kIOReturnSuccess : kIOReturnIOError );
}

//---------------------------------------------------------------------------
// Function: newVendorString(), newModelString()
//           <IONetworkController>
//
// Report human readable hardware information strings.

const OSString * Intel82557::newVendorString() const
{
        return OSString::withCString("Intel");
}

const OSString * Intel82557::newModelString() const
{
        const char * model = 0;

        assert( eeprom && eeprom->getContents() );

        switch ( eeprom->getContents()->controllerType )
    {
                case I82558_CONTROLLER_TYPE:
                        model = "82558";
                        break;
                case I82557_CONTROLLER_TYPE:
                default:
                        model = "82557";
                        break;
        }
        return OSString::withCString(model);
}

//---------------------------------------------------------------------------
// Kernel debugger entry points.
//
// KDP driven polling routines to send and transmit a frame.
// Remember, no memory allocation! Not even mbufs are safe.

void Intel82557::sendPacket(void * pkt, UInt32 pkt_len)
{
        _sendPacket(pkt, pkt_len);
}

void Intel82557::receivePacket(void * pkt, UInt32 * pkt_len, UInt32 timeout)
{
        _receivePacket(pkt, (UInt *) pkt_len, timeout);
}