windows-nt-4.0/private/ntos/ndis/madge/driver/ftk_user.c

/****************************************************************************
*
* FTK_USER.C
*
* FastMAC Plus based NDIS3 miniport driver FTK interface. This module 
* contains all of the routines required to interface with the FastMAC 
* Plus FTK. This is includes the routines traditionally found in transmit.c 
* and receive.c.
*                                                                          
* Copyright (c) Madge Networks Ltd 1994                                    
*    
* COMPANY CONFIDENTIAL
*
* Created: PBA 21/06/1994
*                                                                           
****************************************************************************/

#include <ndis.h>

#include "ftk_defs.h"
#include "ftk_extr.h"
#include "ftk_intr.h"

#include "mdgmport.upd"
#include "ndismod.h"


/*---------------------------------------------------------------------------
|
|                      LOCAL VARIABLES                                  
|                                                                       
---------------------------------------------------------------------------*/

//
// To cut down on accesses to the slot structures on the card we keep
// a host cache of various detaisl we need.
//

typedef struct
{
    DWORD PhysicalAddress;
    PVOID VirtualAddress;
}
RX_SLOT_CACHE, *PRX_SLOT_CACHE;


typedef struct
{
    ULONG         BufferSize;
    ULONG         SharedMemoryAllocation;
    PVOID         SharedMemoryVirtAddr;
    DWORD         SharedMemoryPhysAddr;

    RX_SLOT_CACHE rx_slot_cache[FMPLUS_MAX_RX_SLOTS];

    UINT          active_rx_slot; /* Used to count through the slot array */
} 
RX_SLOT_MGMNT, *PRX_SLOT_MGMNT;


typedef struct 
{
    DWORD PhysicalAddress;
    PVOID VirtualAddress;
} 
TX_SLOT_CACHE, *PTX_SLOT_CACHE;


typedef struct 
{
    ULONG         BufferSize;
    ULONG         SharedMemoryAllocation;
    PVOID         SharedMemoryVirtAddr;
    DWORD         SharedMemoryPhysAddr;

    TX_SLOT_CACHE tx_slot_cache[FMPLUS_MAX_TX_SLOTS];

    UINT          active_tx_slot; 
    UINT          first_tx_in_use;   
    UINT          number_tx_in_use;
} 
TX_SLOT_MGMNT, *PTX_SLOT_MGMNT;


#define FRAME_TYPE_MASK    ((BYTE) 0xC0)   // What is ANDed with FC byte.
#define FRAME_TYPE_MAC     ((BYTE) 0x00)   // What's left for a MAC frame.


typedef struct
{
    ADAPTER_HANDLE   adapter_handle;
    ADAPTER        * adapter;
    TX_SLOT        * tx_slot_ptr;
    RX_SLOT        * rx_slot_ptr;
    UINT             frame_length;
    UINT             result1;
    UINT             result2;
}
MPSAFE_INFO;


#if 0

typedef struct
{
    ADAPTER_HANDLE handle;
    WORD           location;
    WORD           result;
}
RDIO;

WORD
_madge_rdio(
    void * ptr
    )
{
    RDIO * rdio;

    rdio = (RDIO *) ptr;

    sys_outsw(
        rdio->handle,
        adapter_record[rdio->handle]->sif_adr,
        rdio->location
        );

    rdio->result = sys_insw(
                       rdio->handle,
                       adapter_record[rdio->handle]->sif_dat
                       );

    return 0;
}


WORD
madge_rdio(
    ADAPTER_HANDLE adapter_handle,
    WORD           dio_location
    )
{
    RDIO rdio;

    rdio.handle   = adapter_handle;
    rdio.location = dio_location;

    sys_sync_with_interrupt(
        adapter_handle, 
        _madge_rdio,
        (void *) &rdio
        );

    return rdio.result;
}


void
madge_dump_fmplus_info(
    ADAPTER_HANDLE adapter_handle
    )
{
    ADAPTER          * adapter;
    PRX_SLOT_MGMNT     rx_slot_mgmnt;
    PTX_SLOT_MGMNT     tx_slot_mgmnt;
    PMADGE_ADAPTER     ndisAdap;
    RX_SLOT        * * rx_slot_array;
    TX_SLOT        * * tx_slot_array;
    UINT               active_rx_slot;
    UINT               active_tx_slot;
    UINT               first_tx_slot;
    UINT               rx_slots;
    UINT               tx_slots;
    UINT               i;

    adapter        = adapter_record[adapter_handle];

    rx_slot_array  = adapter->rx_slot_array;
    rx_slot_mgmnt  = (PRX_SLOT_MGMNT) adapter->rx_slot_mgmnt;
    active_rx_slot = rx_slot_mgmnt->active_rx_slot;
    rx_slots       = adapter->init_block->fastmac_parms.rx_slots;

    tx_slot_array  = adapter->tx_slot_array;
    tx_slot_mgmnt  = (PTX_SLOT_MGMNT) adapter->tx_slot_mgmnt;
    active_tx_slot = tx_slot_mgmnt->active_tx_slot;
    first_tx_slot  = tx_slot_mgmnt->first_tx_in_use;
    tx_slots       = adapter->init_block->fastmac_parms.tx_slots;

    DbgPrint("----------------------------------------------------------\n");

    DbgPrint(
        "SIFADR high word = %04x\n\n", 
        sys_insw(adapter_handle, adapter->sif_adx)
        );

    DbgPrint("RX SLOTS:\n\n");
    DbgPrint("Active slot = %d\n", active_rx_slot);

    DbgPrint("      Len  Res  Buffer    Stat Next\n");
    DbgPrint("      ---- ---- --------- ---- ----\n");

    for (i = 0; i < rx_slots; i++)
    {
        DbgPrint(
            "%04x: %04x %04x %04x %04x %04x %04x\n",
            (WORD) (card_t) rx_slot_array[i],
	    madge_rdio(adapter_handle, (WORD) (card_t) &rx_slot_array[i]->buffer_len),
	    madge_rdio(adapter_handle, (WORD) (card_t) &rx_slot_array[i]->reserved),
	    madge_rdio(adapter_handle, (WORD) (card_t) &rx_slot_array[i]->buffer_hiw),
	    madge_rdio(adapter_handle, (WORD) (card_t) &rx_slot_array[i]->buffer_low),
            madge_rdio(adapter_handle, (WORD) (card_t) &rx_slot_array[i]->rx_status),
	    madge_rdio(adapter_handle, (WORD) (card_t) &rx_slot_array[i]->next_slot)
            );
    }

    DbgPrint("\n");

    DbgPrint("TX SLOTS:\n\n");
    DbgPrint("Active slot     = %d\n", active_tx_slot);
    DbgPrint("First used slot = %d\n", first_tx_slot);

    DbgPrint("      Stat SLen LLen Res1 Res2 Sbuffer   Next LBuffer\n");
    DbgPrint("      ---- ---- ---- ---- ---- --------- ---- ---------\n");

    for (i = 0; i < tx_slots; i++)
    {
        DbgPrint(
            "%04x: %04x %04x %04x %04x %04x %04x %04x %04x %04x %04x\n",
            (WORD) (card_t) tx_slot_array[i],
   	    madge_rdio(adapter_handle, (WORD) (card_t) &tx_slot_array[i]->tx_status),
	    madge_rdio(adapter_handle, (WORD) (card_t) &tx_slot_array[i]->small_buffer_len),
	    madge_rdio(adapter_handle, (WORD) (card_t) &tx_slot_array[i]->large_buffer_len),
	    madge_rdio(adapter_handle, (WORD) (card_t) &tx_slot_array[i]->reserved[0]),
	    madge_rdio(adapter_handle, (WORD) (card_t) &tx_slot_array[i]->reserved[1]),
            madge_rdio(adapter_handle, (WORD) (card_t) &tx_slot_array[i]->small_buffer_hiw),
	    madge_rdio(adapter_handle, (WORD) (card_t) &tx_slot_array[i]->small_buffer_low),
	    madge_rdio(adapter_handle, (WORD) (card_t) &tx_slot_array[i]->next_slot),
	    madge_rdio(adapter_handle, (WORD) (card_t) &tx_slot_array[i]->large_buffer_hiw),
	    madge_rdio(adapter_handle, (WORD) (card_t) &tx_slot_array[i]->large_buffer_low)
            );
    }

    DbgPrint("\n");

    DbgPrint("DIO LOCATION 0x0CE0\n\n");

    for (i = 0; i < 32; i++)
    {
        DbgPrint(" %04x", madge_rdio(adapter_handle, (WORD) (0x0ce0 + i * 2)));
        if (i == 15)
        {
            DbgPrint("\n");
        }
    }

    DbgPrint("\n");
}

#endif

/***************************************************************************
*
* Function    - rxtx_allocate_rx_buffers
*
* Parameters  - adapter            -> Pointer to an FTK adapter structure.
*               max_frame_size     -> Maximum frame size.
*               number_of_slots    -> Number of receive slots.
*               
* Purpose     - Allocate buffer space for the receive slots.
*                                                                         
* Returns     - TRUE if it succeeds or FALSE otherwise.
*                                                                        
****************************************************************************/

WBOOLEAN
rxtx_allocate_rx_buffers(
    ADAPTER * adapter, 
    WORD      max_frame_size,
    WORD      number_of_slots
    );

#pragma FTK_INIT_FUNCTION(rxtx_allocate_rx_buffers)

WBOOLEAN
rxtx_allocate_rx_buffers(
    ADAPTER * adapter, 
    WORD      max_frame_size,
    WORD      number_of_slots
    )
{
    PRX_SLOT_MGMNT rx_slot_mgmnt;
    NDIS_STATUS    status;
    ADAPTER_HANDLE adapter_handle;
    PMADGE_ADAPTER ndisAdap;
    DWORD          SharedMemVirtAddr;
    DWORD          SharedMemPhysAddr;

    //
    // Pre-calculate some commonly used values.
    //
    
    rx_slot_mgmnt = (PRX_SLOT_MGMNT) adapter->rx_slot_mgmnt;

    //
    // Only want to allocate the receive buffers and slot management once 
    // per adapter.
    //

    if (rx_slot_mgmnt == NULL)
    {
        //
        // Pre-calculate some commonly used values.
        //

        adapter_handle = adapter->adapter_handle;
        ndisAdap       = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);

        //
        // Allocate the slot management structure.
        //

        MADGE_ALLOC_MEMORY(
            &status,
            &adapter->rx_slot_mgmnt,
            sizeof(RX_SLOT_MGMNT)
            );

        if (status != NDIS_STATUS_SUCCESS)
        {
            return FALSE;
        }

        MADGE_ZERO_MEMORY(adapter->rx_slot_mgmnt, sizeof(RX_SLOT_MGMNT));

        rx_slot_mgmnt = (PRX_SLOT_MGMNT) adapter->rx_slot_mgmnt;

        //
        // Work out how big the buffer should be. Remember to add 
        // four to the buffer allocation for the CRC. The addition
        // of 32 provides a little space between receive buffers
        // for those naughty transport protocols that read more
        // then the indicated lookahead.
        //

        rx_slot_mgmnt->BufferSize = (max_frame_size + 4 + 32 + 3) & ~3;

        rx_slot_mgmnt->SharedMemoryAllocation = 
            rx_slot_mgmnt->BufferSize * number_of_slots;

        //
        // Allocate the buffer.
        //

        if (!sys_alloc_dma_phys_buffer(
                 adapter_handle,
                 rx_slot_mgmnt->SharedMemoryAllocation,
                 &SharedMemPhysAddr,
                 &SharedMemVirtAddr
                 )) 
        {
            return FALSE;
        }

        rx_slot_mgmnt->SharedMemoryVirtAddr = (VOID *) SharedMemVirtAddr;
        rx_slot_mgmnt->SharedMemoryPhysAddr = SharedMemPhysAddr;
    }

    return TRUE;
}


/***************************************************************************
*
* Function    - rxtx_setup_rx_buffers
*
* Parameters  - adapter            -> Pointer to an FTK adapter structure.
*               physical_addresses -> Use physical addresses?
*               number_of_slots    -> Number of receive slots.
*
* Purpose     - Set up the adapter receive slots.
*                                                                         
* Returns     - TRUE if it succeeds or FALSE otherwise.
*                                                                        
****************************************************************************/

void
rxtx_setup_rx_buffers(
    ADAPTER  * adapter, 
    WBOOLEAN   physical_addresses,
    WORD       number_of_slots
    );

#pragma FTK_INIT_FUNCTION(rxtx_setup_rx_buffers)

void
rxtx_setup_rx_buffers(
    ADAPTER  * adapter, 
    WBOOLEAN   physical_addresses,
    WORD       number_of_slots
    )
{
    PRX_SLOT_MGMNT     rx_slot_mgmnt;
    NDIS_STATUS        status;
    ADAPTER_HANDLE     adapter_handle;
    PMADGE_ADAPTER     ndisAdap;
    PVOID              SharedMemVirtAddr;
    DWORD              SharedMemPhysAddr;
    PRX_SLOT_CACHE     rx_slot_cache;
    RX_SLOT        * * rx_slot_array;
    DWORD              phys_addr;
    WORD               slot_index;
    WORD               sifadr;
    WORD               sifdat;
    WORD               sifdatinc;
    UINT               buffer_size;

    //
    // Pre-calculate some commonly used values.
    //
    
    adapter_handle    = adapter->adapter_handle;
    ndisAdap          = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);

    rx_slot_array     = adapter->rx_slot_array;
    rx_slot_mgmnt     = (PRX_SLOT_MGMNT) adapter->rx_slot_mgmnt;
    rx_slot_cache     = rx_slot_mgmnt->rx_slot_cache;
    SharedMemVirtAddr = rx_slot_mgmnt->SharedMemoryVirtAddr;
    SharedMemPhysAddr = rx_slot_mgmnt->SharedMemoryPhysAddr;
    buffer_size       = rx_slot_mgmnt->BufferSize;

    sifadr            = adapter->sif_adr;
    sifdat            = adapter->sif_dat;
    sifdatinc         = adapter->sif_datinc;

    MadgePrint2("rxtx_setup_rx_buffers number_of_slots = %d\n", number_of_slots);
    MadgePrint2("rxtx_setup_rx_buffers buffer_size = %d\n", buffer_size);

    //
    // Work out the physical and virtual address of each buffer.
    //

    for (slot_index = 0; slot_index < number_of_slots; slot_index++)
    {
        rx_slot_cache[slot_index].VirtualAddress  = SharedMemVirtAddr;
        (PUCHAR) SharedMemVirtAddr               += buffer_size;

        rx_slot_cache[slot_index].PhysicalAddress = SharedMemPhysAddr;
        SharedMemPhysAddr                        += buffer_size; 

        phys_addr = (physical_addresses)
            ? (DWORD) rx_slot_cache[slot_index].PhysicalAddress
            : (DWORD) rx_slot_cache[slot_index].VirtualAddress;

        //
        // Write the buffer locations into the slots.
        //

        sys_outsw(
            adapter_handle,
            sifadr,
            (WORD) (card_t) &rx_slot_array[slot_index]->buffer_hiw
            );

        sys_outsw(
            adapter_handle,
            sifdatinc,
            (WORD) (phys_addr >> 16)
            );

        sys_outsw(
            adapter_handle,
            sifdat,
            (WORD) (phys_addr & 0x0FFFF)
            );
    }

    ndisAdap->RxTxBufferState    |= MADGE_RX_INITIALIZED;
    rx_slot_mgmnt->active_rx_slot = 0;
}


/***************************************************************************
*
* Function    - rxtx_free_rx_buffers
*
* Parameters  - adapter         -> Pointer to an FTK adapter structure.
*               max_frame_size  -> Maximum frame size.
*               number_of_slots -> Number of receive slots.
*
* Purpose     - Free the previously allocated receive buffers.
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/

void
rxtx_free_rx_buffers(
    ADAPTER * adapter,
    WORD      max_frame_size,
    WORD      number_of_slots
    )
{
    ADAPTER_HANDLE adapter_handle;
    PMADGE_ADAPTER ndisAdap;
    PRX_SLOT_MGMNT rx_slot_mgmnt;

    //
    // Pre-calculate some commonly used values.
    //

    adapter_handle  = adapter->adapter_handle;
    ndisAdap        = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);
    rx_slot_mgmnt   = (PRX_SLOT_MGMNT) adapter->rx_slot_mgmnt;

    //
    // If the slot management structure exists them free it 
    // and the buffers.
    //

    if (rx_slot_mgmnt != NULL)
    {
        if (rx_slot_mgmnt->SharedMemoryVirtAddr != NULL)
        {
            sys_free_dma_phys_buffer(
                adapter_handle,
                rx_slot_mgmnt->SharedMemoryAllocation,
                (DWORD) rx_slot_mgmnt->SharedMemoryPhysAddr,
                (DWORD) rx_slot_mgmnt->SharedMemoryVirtAddr
                );
        }

        MADGE_FREE_MEMORY(adapter->rx_slot_mgmnt, sizeof(RX_SLOT_MGMNT));

        adapter->rx_slot_mgmnt = NULL;

        ndisAdap->RxTxBufferState &= ~MADGE_RX_INITIALIZED;
    }
}


/***************************************************************************
*
* Function    - rxtx_allocate_tx_buffers
*
* Parameters  - adapter            -> Pointer to an FTK adapter structure.
*               max_frame_size     -> Maximum frame size.
*               number_of_slots    -> Number of transmit slots.
*               
* Purpose     - Allocate buffer space for the transmit slots.
*                                                                         
* Returns     - TRUE if it succeeds or FALSE otherwise.
*                                                                        
****************************************************************************/

WBOOLEAN
rxtx_allocate_tx_buffers(
    ADAPTER * adapter, 
    WORD      max_frame_size,
    WORD      number_of_slots
    );

#pragma FTK_INIT_FUNCTION(rxtx_allocate_tx_buffers)

WBOOLEAN
rxtx_allocate_tx_buffers(
    ADAPTER * adapter, 
    WORD      max_frame_size,
    WORD      number_of_slots
    )
{
    PTX_SLOT_MGMNT tx_slot_mgmnt;
    NDIS_STATUS    status;
    ADAPTER_HANDLE adapter_handle;
    PMADGE_ADAPTER ndisAdap;
    DWORD          SharedMemVirtAddr;
    DWORD          SharedMemPhysAddr;

    //
    // Pre-calculate some commonly used values.
    //
    
    tx_slot_mgmnt = (PTX_SLOT_MGMNT) adapter->tx_slot_mgmnt;

    //
    // Only want to allocate the receive buffers and slot management once 
    // per adapter.
    //

    if (tx_slot_mgmnt == NULL)
    {
        //
        // Pre-calculate some commonly used values.
        //

        adapter_handle = adapter->adapter_handle;
        ndisAdap       = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);

        //
        // Allocate the slot management structure.
        //

        MADGE_ALLOC_MEMORY(
            &status,
            &adapter->tx_slot_mgmnt,
            sizeof(TX_SLOT_MGMNT)
            );

        if (status != NDIS_STATUS_SUCCESS)
        {
            return FALSE;
        }

        MADGE_ZERO_MEMORY(adapter->tx_slot_mgmnt, sizeof(TX_SLOT_MGMNT));

        tx_slot_mgmnt = (PTX_SLOT_MGMNT) adapter->tx_slot_mgmnt;

        //
        // Work out how big the buffer should be.
        //

        tx_slot_mgmnt->BufferSize = (max_frame_size + 3) & ~3;

        tx_slot_mgmnt->SharedMemoryAllocation = 
            tx_slot_mgmnt->BufferSize * number_of_slots;

        //
        // Allocate the buffer.
        //

        if (!sys_alloc_dma_phys_buffer(
                 adapter_handle,
                 tx_slot_mgmnt->SharedMemoryAllocation,
                 &SharedMemPhysAddr,
                 &SharedMemVirtAddr
                 )) 
        {
            return FALSE;
        }

        tx_slot_mgmnt->SharedMemoryVirtAddr = (VOID *) SharedMemVirtAddr;
        tx_slot_mgmnt->SharedMemoryPhysAddr = SharedMemPhysAddr;
    }

    return TRUE;
}


/***************************************************************************
*
* Function    - rxtx_setup_tx_buffers
*
* Parameters  - adapter            -> Pointer to an FTK adapter structure.
*               physical_addresses -> Use physical addresses?
*               number_of_slots    -> Number of transmit slots.
*
* Purpose     - Set up the adapter transmit slots.
*                                                                         
* Returns     - TRUE if it succeeds or FALSE otherwise.
*                                                                        
****************************************************************************/

void
rxtx_setup_tx_buffers(
    ADAPTER  * adapter, 
    WBOOLEAN   physical_addresses,
    WORD       number_of_slots
    );

#pragma FTK_INIT_FUNCTION(rxtx_setup_tx_buffers)

void
rxtx_setup_tx_buffers(
    ADAPTER  * adapter, 
    WBOOLEAN   physical_addresses,
    WORD       number_of_slots
    )
{
    PTX_SLOT_MGMNT     tx_slot_mgmnt;
    NDIS_STATUS        status;
    ADAPTER_HANDLE     adapter_handle;
    PMADGE_ADAPTER     ndisAdap;
    PVOID              SharedMemVirtAddr;
    DWORD              SharedMemPhysAddr;
    PTX_SLOT_CACHE     tx_slot_cache;
    TX_SLOT        * * tx_slot_array;
    DWORD              phys_addr;
    WORD               slot_index;
    WORD               sifadr;
    WORD               sifdat;
    WORD               sifdatinc;
    UINT               buffer_size;

    //
    // Pre-calculate some commonly used values.
    //
    
    adapter_handle    = adapter->adapter_handle;
    ndisAdap          = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);

    tx_slot_array     = adapter->tx_slot_array;
    tx_slot_mgmnt     = (PTX_SLOT_MGMNT) adapter->tx_slot_mgmnt;
    tx_slot_cache     = tx_slot_mgmnt->tx_slot_cache;
    SharedMemVirtAddr = tx_slot_mgmnt->SharedMemoryVirtAddr;
    SharedMemPhysAddr = tx_slot_mgmnt->SharedMemoryPhysAddr;
    buffer_size       = tx_slot_mgmnt->BufferSize;

    sifadr            = adapter->sif_adr;
    sifdat            = adapter->sif_dat;
    sifdatinc         = adapter->sif_datinc;

    MadgePrint2("rxtx_setup_tx_buffers number_of_slots = %d\n", number_of_slots);
    MadgePrint2("rxtx_setup_tx_buffers buffer_size = %d\n", buffer_size);

    //
    // Work out the physical and virtual address of each buffer.
    //

    for (slot_index = 0; slot_index < number_of_slots; slot_index++)
    {
        tx_slot_cache[slot_index].VirtualAddress  = SharedMemVirtAddr;
        (PUCHAR) SharedMemVirtAddr               += buffer_size;

        tx_slot_cache[slot_index].PhysicalAddress = SharedMemPhysAddr;
        SharedMemPhysAddr                        += buffer_size;

        phys_addr = (physical_addresses)
            ? (DWORD) tx_slot_cache[slot_index].PhysicalAddress
            : (DWORD) tx_slot_cache[slot_index].VirtualAddress;

        //
        // Write the buffer locations into the slots.
        //

        sys_outsw(
            adapter_handle,
            sifadr,
            (WORD) (card_t) &tx_slot_array[slot_index]->large_buffer_hiw
            );

        sys_outsw(
            adapter_handle,
            sifdatinc,
            (WORD) (phys_addr >> 16)
            );

        sys_outsw(
            adapter_handle,
            sifdat,
            (WORD) (phys_addr & 0x0FFFF)
            );
    }

    ndisAdap->RxTxBufferState      |= MADGE_TX_INITIALIZED;
    tx_slot_mgmnt->active_tx_slot   = 0;
    tx_slot_mgmnt->first_tx_in_use  = 0;
    tx_slot_mgmnt->number_tx_in_use = 0;
}


/***************************************************************************
*
* Function    - rxtx_free_tx_buffers
*
* Parameters  - adapter         -> Pointer to an FTK adapter structure.
*               max_frame_size  -> Maximum frame size.
*               number_of_slots -> Number of transmit slots.
*
* Purpose     - Free the previously allocated transmit buffers.
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/

void
rxtx_free_tx_buffers(
    ADAPTER * adapter,
    WORD      max_frame_size,
    WORD      number_of_slots
    )
{
    ADAPTER_HANDLE adapter_handle;
    PMADGE_ADAPTER ndisAdap;
    PTX_SLOT_MGMNT tx_slot_mgmnt;

    //
    // Pre-calculate some commonly used values.
    //

    adapter_handle  = adapter->adapter_handle;
    ndisAdap        = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);
    tx_slot_mgmnt   = (PTX_SLOT_MGMNT) adapter->tx_slot_mgmnt;

    //
    // If the slot management structure exists them free it 
    // and the buffers.
    //

    if (tx_slot_mgmnt != NULL)
    {
        if (tx_slot_mgmnt->SharedMemoryVirtAddr != NULL)
        {
            sys_free_dma_phys_buffer(
                adapter_handle,
                tx_slot_mgmnt->SharedMemoryAllocation,
                (DWORD) tx_slot_mgmnt->SharedMemoryPhysAddr,
                (DWORD) tx_slot_mgmnt->SharedMemoryVirtAddr
                );
        }

        MADGE_FREE_MEMORY(adapter->tx_slot_mgmnt, sizeof(TX_SLOT_MGMNT));

        adapter->tx_slot_mgmnt = NULL;

        ndisAdap->RxTxBufferState &= ~MADGE_TX_INITIALIZED;
    }
}


/*--------------------------------------------------------------------------
|
| Function    - MPSafeReadTxStatus
|
| Paramters   - ptr -> Pointer to an MPSAFE_INFO structure.
|
| Purpose     - Reads the transmit status from the next slot to use. This
|               function is called via NdisSynchronizeWithInterrupt when
|               in PIO mode so that we don't get SIF register contention
|               on a multiprocessor.
|
| Returns     - Nothing.
|
--------------------------------------------------------------------------*/

STATIC BOOLEAN
MPSafeReadTxStatus(PVOID ptr)
{
    MPSAFE_INFO * info = (MPSAFE_INFO *) ptr;

    //
    // Read the transmit status from the slot.
    //

    sys_outsw(
        info->adapter_handle, 
        info->adapter->sif_adr,
        (WORD) (card_t) &(info->tx_slot_ptr)->tx_status
        );

    info->result1 = sys_insw(
                        info->adapter_handle, 
                        info->adapter->sif_dat
                        );

    return FALSE;
}


/***************************************************************************
*
* Function    - rxtx_irq_tx_completion_check
*
* Parameters  - adapter_handle -> FTK adapter handle.
*               adapter        -> Pointer to FTK adapter structure.
*
* Purpose     - Complete any outstanding transmits.
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/

void
rxtx_irq_tx_completion_check(
    ADAPTER_HANDLE   adapter_handle,
    ADAPTER        * adapter
    )
{
    UINT                tx_slots;
    PTX_SLOT_MGMNT      tx_slot_mgmnt;
    PTX_SLOT_CACHE      tx_slot_cache;
    TX_SLOT         * * tx_slot_array;
    PMADGE_ADAPTER      ndisAdap;
    UINT                tx_status;
    MPSAFE_INFO         info;
    WORD                sifadr;
    WORD                sifdat;

    //
    // Pre-calculate some commonly used values.
    //
            
    tx_slot_mgmnt  = (PTX_SLOT_MGMNT) adapter->tx_slot_mgmnt;
    tx_slot_cache  = tx_slot_mgmnt->tx_slot_cache;
    tx_slot_array  = adapter->tx_slot_array;
    ndisAdap       = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);
    tx_slots       = adapter->init_block->fastmac_parms.tx_slots;
    sifadr         = adapter->sif_adr;
    sifdat         = adapter->sif_dat;

    //
    // If we're doing multiprocessor safe PIO then we need to set up
    // the info structure.
    //

    if (ndisAdap->UseMPSafePIO)
    {
        info.adapter_handle = adapter_handle;
        info.adapter        = adapter;
    }

    //
    // Iterate around the transmit slots that are are marked as in use
    // checking if they are now free. Note: we must work with the 
    // global coopies of the first_tx_in_use and number_tx_in_use
    // in case rxtx_transmit_frame is called during our up-call
    // to the wrapper.
    //

    while (tx_slot_mgmnt->number_tx_in_use > 0)
    {
        //
        // Read the transmit status from the slot. If we're doing 
        // multiprocessor safe PIO we must do the DIO via an ISR 
        // synchronized function.
        //

        if (ndisAdap->UseMPSafePIO)
        {
            info.tx_slot_ptr = tx_slot_array[tx_slot_mgmnt->first_tx_in_use];

            NdisMSynchronizeWithInterrupt(
                &ndisAdap->Interrupt,
                MPSafeReadTxStatus,
                &info
                );

            tx_status = info.result1;
        }
        else
        {
            sys_outsw(
                adapter_handle, 
                sifadr,
                (WORD) (card_t) &tx_slot_array[
                                    tx_slot_mgmnt->first_tx_in_use
                                    ]->tx_status
                );

            tx_status = sys_insw(
                            adapter_handle, 
                            sifdat
                            );
        }

        //
        // If the slot is still in use then we must give up. This will
        // also work if a PCMCIA adapter has been removed because
        // tx_status will have been read as 0xffff.
        //

        if (tx_status >= 0x8000 || tx_status == 0)
        {
            break;
        }

        //
        // Update the appropriate counters from the frame transmit
        // status.
        //

        if ((tx_status & TX_RECEIVE_STATUS_MASK) == TX_RECEIVE_LOST_FRAME)
        {
            ndisAdap->LostFrames++;
        }
        else if ((tx_status & GOOD_TX_FRAME_MASK) != GOOD_TX_FRAME_VALUE)
        {
            ndisAdap->FrameTransmitErrors++;
        }

        //
        // Update the slot usage.
        //

        tx_slot_mgmnt->number_tx_in_use--;

        if (++tx_slot_mgmnt->first_tx_in_use == tx_slots)
        {
            tx_slot_mgmnt->first_tx_in_use = 0;
        }

        //
        // Tell the wrapper that there is a free slot.
        //

        NdisMSendResourcesAvailable(ndisAdap->UsedInISR.MiniportHandle);
    }

    //
    // If there are any frames we have queued for transmit that
    // have not been completed then arm the timer so we are guaranteed
    // to be called again. Under normal operation our DPR gets called
    // often enough that this function is called frequently enough to
    // complete all of the frames. However if we have an adapter in a 
    // fast bus (PCI/EISA) with a lot of RAM and we are not
    // getting any recieve interrupts we can occasionally miss
    // completing a frame. Hence the timer.
    //
    
    if (tx_slot_mgmnt->number_tx_in_use > 0)
    {
        NdisMSetTimer(&ndisAdap->CompletionTimer, 20);
    }
}


/*--------------------------------------------------------------------------
|
| Function    - MPSafeStartTx
|
| Paramters   - ptr -> Pointer to an MPSAFE_INFO structure.
|
| Purpose     - Set up a tx slot and start the transmit going. This
|               function is called via NdisSynchronizeWithInterrupt when
|               in PIO mode so that we don't get SIF register contention
|               on a multiprocessor.
|
| Returns     - Nothing.
|
--------------------------------------------------------------------------*/

STATIC BOOLEAN
MPSafeStartTx(PVOID ptr)
{
    MPSAFE_INFO * info = (MPSAFE_INFO *) ptr;

    //
    // Reset the transmit status in the transmit slot.
    //

    sys_outsw(
        info->adapter_handle, 
        info->adapter->sif_adr,
        (WORD) (card_t) &(info->tx_slot_ptr)->tx_status
        );

    sys_outsw(
        info->adapter_handle, 
        info->adapter->sif_dat, 
        0x8000
        );

    //
    // Write in the length of the buffer into the transmit slot
    // (large buffer).
    //

    sys_outsw(
        info->adapter_handle, 
        info->adapter->sif_adr,
        (WORD) (card_t) &(info->tx_slot_ptr)->large_buffer_len
        );

    sys_outsw(
        info->adapter_handle, 
        info->adapter->sif_dat, 
        (WORD) info->frame_length
        );

    //
    // Write the length of the small buffer in the transmit slot to 
    // start the transmit going.
    //

    sys_outsw(
        info->adapter_handle, 
        info->adapter->sif_adr,
        (WORD) (card_t) &(info->tx_slot_ptr)->small_buffer_len
        );

    sys_outsw(
        info->adapter_handle, 
        info->adapter->sif_dat, 
        FMPLUS_SBUFF_ZERO_LENGTH
        );

    return FALSE;
}


/***************************************************************************
*
* Function    - rxtx_transmit_frame
*
* Parameters  - adapter_handle      -> FTK adapter handle.
*               tx_frame_identifier -> NDIS packet handle or a pointer
*                                      to some data to send.
*               tx_frame_length     -> Length of the frame.
*               tx_is_packet        -> TRUE if tx_frame_identifier is
*                                      an NDIS packet handle.
*
* Purpose     - Attempts to transmit a frame by copying it into a transmit
*               buffer and activating a FastMAC Plus tx slot.
*                                                                         
* Returns     - DRIVER_TRANSMIT_SUCCESS if it succeeds or 
*               DRIVER_TRANSMIT_FAILURE if it does not.
*                                                                        
****************************************************************************/

WORD 
rxtx_transmit_frame(
    ADAPTER_HANDLE adapter_handle,
    DWORD          tx_frame_identifier,
    WORD           tx_frame_length,
    WORD           tx_is_packet
    )
{
    ADAPTER            * adapter;
    PTX_SLOT_MGMNT       tx_slot_mgmnt;
    PTX_SLOT_CACHE       tx_slot_cache;
    TX_SLOT            * tx_slot_ptr;
    UINT                 active_tx_slot;
    UINT                 tx_slots;
    PMADGE_ADAPTER       ndisAdap;
    UINT                 bytes_copied;
    UINT                 tx_status;
    MPSAFE_INFO          info;
    WORD                 sifadr;
    WORD                 sifdat;

    //
    // Pre-calculate some commonly used values.
    //
            
    adapter        = adapter_record[adapter_handle];
    tx_slot_mgmnt  = (PTX_SLOT_MGMNT) adapter->tx_slot_mgmnt;
    tx_slot_cache  = tx_slot_mgmnt->tx_slot_cache;
    active_tx_slot = tx_slot_mgmnt->active_tx_slot;
    tx_slot_ptr    = adapter->tx_slot_array[active_tx_slot];
    tx_slots       = adapter->init_block->fastmac_parms.tx_slots;
    ndisAdap       = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);
    sifadr         = adapter->sif_adr;
    sifdat         = adapter->sif_dat;

    //
    // If we are a PCMCIA adapter it is possible that the adapter
    // may have been removed. To detect this we check if SIFADR
    // is 0xffff since this should not normally be true.
    //

    if (adapter->adapter_card_bus_type == ADAPTER_CARD_PCMCIA_BUS_TYPE)
    {
        if (sys_insw(adapter_handle, sifadr) == 0xffff)
        {
            rxtx_adapter_removed(adapter_handle);

            return DRIVER_TRANSMIT_SUCCEED;
        }
    }

    //
    // If the next slot to be used is still in use then we must 
    // give up.
    //

    if (tx_slot_mgmnt->number_tx_in_use == tx_slots)
    {

#ifdef OID_MADGE_MONITOR
        (ndisAdap->MonitorInfo).FailedToTransmit++;
#endif

        return DRIVER_TRANSMIT_FAIL;
    }

    //
    // Copy the frame into the transmit buffer.
    //

    if (tx_is_packet)
    {
        MadgeCopyFromPacketToBuffer(
            (PNDIS_PACKET) tx_frame_identifier,
            0,
            tx_frame_length,
            (PUCHAR) tx_slot_cache[active_tx_slot].VirtualAddress,
            &bytes_copied
            );
    }
    else
    {
        MADGE_MOVE_MEMORY(
            tx_slot_cache[active_tx_slot].VirtualAddress,
            (PUCHAR) tx_frame_identifier,
            tx_frame_length
            );
    }

    //
    // Set up the tx slot and start the transmit. If we're using 
    // multiprocessor safe PIO then we must do the DIO via an ISR
    // synchronised function.
    //

    if (ndisAdap->UseMPSafePIO)
    {
        info.adapter_handle = adapter_handle;
        info.adapter        = adapter;
        info.tx_slot_ptr    = tx_slot_ptr;
        info.frame_length   = tx_frame_length;

        NdisMSynchronizeWithInterrupt(
            &ndisAdap->Interrupt,
            MPSafeStartTx,
            &info
            );
    }
    else
    {
        //
        // Reset the transmit status in the transmit slot.
        //

        sys_outsw(
            adapter_handle, 
            sifadr,
            (WORD) (card_t) &tx_slot_ptr->tx_status
            );

        sys_outsw(
            adapter_handle, 
            sifdat, 
            (WORD) 0x8000
            );

        //
        // Write in the length of the buffer into the transmit slot
        // (large buffer).
        //

        sys_outsw(
            adapter_handle, 
            sifadr,
            (WORD) (card_t) &tx_slot_ptr->large_buffer_len
            );

        sys_outsw(
            adapter_handle, 
            sifdat, 
            (WORD) tx_frame_length
            );

        //
        // Write the length of the small buffer in the transmit slot to 
        // start the transmit going.
        //

        sys_outsw(
            adapter_handle, 
            sifadr,
            (WORD) (card_t) &tx_slot_ptr->small_buffer_len
            );

        sys_outsw(
            adapter_handle, 
            sifdat, 
            FMPLUS_SBUFF_ZERO_LENGTH
            );
    }

    //
    // Note that the slot is in use.
    //

    tx_slot_mgmnt->number_tx_in_use++;

    //
    // Update the slot counter ready for the next transmit.
    //

    if (++tx_slot_mgmnt->active_tx_slot == tx_slots)
    {
        tx_slot_mgmnt->active_tx_slot = 0;
    }

    return DRIVER_TRANSMIT_SUCCEED;
}


/*--------------------------------------------------------------------------
|
| Function    - ProcessTestAndXIDFrames
|
| Paramters   - adapHnd   -> An FTK adapter handle.
|               framePtr  -> Pointer to the start of the frame.
|               frameLen  -> The length of the frame.
|               headerLen -> The length of the frame header.
|
| Purpose     - Process LLC Test and XID frames in the same way as IBM
|               adapter hardware.
|
| Returns     - TRUE if the frame was processed or FALSE if not.
|
|-------------------------------------------------------------------------*/

STATIC BOOLEAN
ProcessTestAndXIDFrames(
    ADAPTER_HANDLE  adapHnd, 
    UCHAR          *framePtr,
    UINT            frameLen,
    UINT            headerLen
    )
{
    UINT         llcCmd;     
    UINT         sSAP; 
    NODE_ADDRESS tempNodeAddr;
    BOOLEAN      doneFrame;

    doneFrame = FALSE;

    //
    // We are only interested in frames that are LLC (i.e. frame
    // control byte is 0x40), have a null destination SAP and are
    // commands (i.e. 0x01 bit of the source SAP is clear).
    //

    sSAP = framePtr[headerLen + 1];
    
    if (framePtr[1]         == 0x40 && 
        framePtr[headerLen] == 0x00 &&
        (sSAP & 0x01)       == 0x00)
    {
        llcCmd = framePtr[headerLen + 2] & 0xef;

        //
        // Test frames have an LLC command byte of 0b111x0011.
        //

        if (llcCmd == 0xe3)
        {
            MadgePrint1("Got TEST frame\n");
            
            //
            // We don't need to do anything to a test frame
            // other than send it back.
            //

            doneFrame = TRUE;
        }

        //
        // XID frames have an LLC command byte of 0b101x1111 and
        // a standard IEEE defined XID frame will have 3 data
        // bytes and its first data byte set to 0x81. 
        //

        else if (llcCmd                  == 0xaf          && 
                 frameLen                == headerLen + 6 &&
                 framePtr[headerLen + 3] == 0x81)
        {
            MadgePrint1("Got XID frame\n");

            //
            // Fill in the XID frame data with 0x81 0x01 0x00
            // (Standard XID frame, type 1 only and 0 sized
            // receive window).
            //

            framePtr[headerLen + 4] = 0x01;
            framePtr[headerLen + 5] = 0x00;

            doneFrame = TRUE;
        }

        //
        // If we've had a TEST or a XID frame then doneFrame will
        // be TRUE and we should send a frame back.
        //

        if (doneFrame)
        {
            //
            // Flip the direction bit in the source routing 
            // control word and switch the source routing flag 
            // from the source to destination address.
            //

            if ((framePtr[8] & 0x80) != 0)
            {                                    
                framePtr[14] &= 0x1f;  // Clear broadcast bits.
                framePtr[15] ^= 0x80;  // Flip direction bit.
                framePtr[8]  &= 0x7f;  // Clear source routing bit.
                framePtr[2]  |= 0x80;  // Set source routing bit.
            }

            //
            // Swap the node addresses around.
            //

            tempNodeAddr                     = *((NODE_ADDRESS *) &framePtr[2]);
            *((NODE_ADDRESS *) &framePtr[2]) = *((NODE_ADDRESS *) &framePtr[8]);
            *((NODE_ADDRESS *) &framePtr[8]) = tempNodeAddr;

            //
            // Swap the SAPs around and set the response bit in the 
            // new source SAP.
            //

            framePtr[headerLen + 1] = 0x01;
            framePtr[headerLen]     = sSAP;
            framePtr[0]             = 0x10;

            //
            // And now send the frame.
            //

            rxtx_transmit_frame(
                adapHnd, 
                (DWORD) framePtr,
                (WORD) frameLen,
                FALSE
                );
        }
    }

    return doneFrame;
}


/*--------------------------------------------------------------------------
|
| Function    - MPSafeReadRxStatus
|
| Paramters   - ptr -> Pointer to an MPSAFE_INFO structure.
|
| Purpose     - Read the status and length of the current rx slot. This
|               function is called via NdisSynchronizeWithInterrupt when
|               in PIO mode so that we don't get SIF register contention
|               on a multiprocessor.
|
| Returns     - Nothing.
|
--------------------------------------------------------------------------*/

STATIC BOOLEAN
MPSafeReadRxStatus(PVOID ptr)
{
    MPSAFE_INFO * info = (MPSAFE_INFO *) ptr;

    sys_outsw( 
        info->adapter_handle,
        info->adapter->sif_adr,
        (WORD) (card_t) &(info->rx_slot_ptr)->buffer_len
        );

    info->result1 = sys_insw( 
                        info->adapter_handle,
                        info->adapter->sif_dat
                        );

    sys_outsw(
        info->adapter_handle,
        info->adapter->sif_adr,
        (WORD) (card_t) &(info->rx_slot_ptr)->rx_status
        );

    info->result2 = sys_insw(
                        info->adapter_handle, 
                        info->adapter->sif_dat
                        );

    return FALSE;
}

/*--------------------------------------------------------------------------
|
| Function    - MPSafeFreeRxSlot
|
| Paramters   - ptr -> Pointer to an MPSAFE_INFO structure.
|
| Purpose     - Free an rx slot. This
|               function is called via NdisSynchronizeWithInterrupt when
|               in PIO mode so that we don't get SIF register contention
|               on a multiprocessor.
|
| Returns     - Nothing.
|
--------------------------------------------------------------------------*/

STATIC BOOLEAN
MPSafeFreeRxSlot(PVOID ptr)
{
    MPSAFE_INFO * info = (MPSAFE_INFO *) ptr;

    sys_outsw(
        info->adapter_handle,
        info->adapter->sif_adr,
        (WORD) (card_t) &(info->rx_slot_ptr)->buffer_len
        );

    sys_outsw( 
        info->adapter_handle,
        info->adapter->sif_dat, 
        (WORD) 0x0000
        );

    return FALSE;
}


/***************************************************************************
*
* Function    - rxtx_irq_rx_frame_handler
*
* Parameters  - adapter_handle -> FTK adapter handle.
*               adapter        -> Pointer to an FTK adapter structure.
*
* Purpose     - Called out of the back or our DPR route via 
*               driver_get_outstanding_receive() to process received
*               frames. 
*
*               Note we preserve the value of SIFADR so that the transmit
*               code does not have to worry about it changing under its
*               feet. No we don't because we are called out of a DPR
*               and the wrapper will have grabbed a spin lock so 
*               we can't be executing at the same time as the transmit
*               code.
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/

#define PROM_OR_MAC \
    (NDIS_PACKET_TYPE_PROMISCUOUS | NDIS_PACKET_TYPE_MAC_FRAME)

void     
rxtx_irq_rx_frame_handler(
    ADAPTER_HANDLE adapter_handle,
    ADAPTER *      adapter
    )
{
    BYTE *               rx_frame_addr;
    UINT                 rx_frame_stat;
    UINT                 rx_frame_length;
    UINT                 slot_count;
    UINT                 active_rx_slot;
    PRX_SLOT_MGMNT       rx_slot_mgmnt;
    PRX_SLOT_CACHE       rx_slot_cache;
    RX_SLOT          * * rx_slot_array;
    RX_SLOT            * rx_slot_ptr;
    UINT                 rx_slots;
    PMADGE_ADAPTER       ndisAdap;
    UINT                 packet_filter;
    UINT                 header_len;
    BOOLEAN              done_frame;
    BOOLEAN              ignore_frame;
    BOOLEAN              test_and_xid;
    MPSAFE_INFO          info;
    WORD                 sifadr;
    WORD                 sifdat;

    //
    // Pre-calculate some commonly used values.
    //

    rx_slot_array  = adapter->rx_slot_array;
    rx_slot_mgmnt  = (PRX_SLOT_MGMNT) adapter->rx_slot_mgmnt;
    active_rx_slot = rx_slot_mgmnt->active_rx_slot;
    rx_slot_cache  = rx_slot_mgmnt->rx_slot_cache;
    rx_slots       = adapter->init_block->fastmac_parms.rx_slots;
    ndisAdap       = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);
    packet_filter  = ndisAdap->CurrentPacketFilter;
    test_and_xid   = ndisAdap->TestAndXIDEnabled;
    done_frame     = FALSE;
    sifadr         = adapter->sif_adr;
    sifdat         = adapter->sif_dat;

    //
    // If we're doing multiprocessor safe PIO then we need to set up
    // the info structure.
    //

    if (ndisAdap->UseMPSafePIO)
    {
        info.adapter_handle = adapter_handle;
        info.adapter        = adapter;
    }

    //
    // Now read the length and status fields of the current receive slot. 
    // If we are doing multiprocessor safe PIO then we must do the DIO via 
    // an ISR synchronised function.
    //

    rx_slot_ptr = rx_slot_array[active_rx_slot];

    if (ndisAdap->UseMPSafePIO)
    {
        info.rx_slot_ptr = rx_slot_ptr;

        NdisMSynchronizeWithInterrupt(
            &ndisAdap->Interrupt,
            MPSafeReadRxStatus,
            &info
            );

        rx_frame_length = info.result1;
        rx_frame_stat   = info.result2;
    }
    else
    {
        sys_outsw( 
            adapter_handle,
            sifadr,
            (WORD) (card_t) &rx_slot_ptr->buffer_len
            );
          
        rx_frame_length = sys_insw( 
                              adapter_handle,
                              sifdat
                              );
        sys_outsw(
            adapter_handle,
            sifadr,
            (WORD) (card_t) &rx_slot_ptr->rx_status
            );

        rx_frame_stat = sys_insw(
                            adapter_handle, 
                            sifdat
                            );

    }

    //
    // Try to receive as many frames as possible, but only examine as many 
    // slots as we have, otherwise we might end up going round this loop   
    // forever! If we do stop and there is still a frame to be received, we
    // will be re-interrupted anyway.                                      
    //

    slot_count = 0;

    while (rx_frame_length != 0 && slot_count++ < rx_slots)
    {
        //
        // It is possible that a PCMCIA adapter may have been removed
        // in which case we must not wait forever. If an adapter has
        // been removed we would expect to read 0xffff from any IO
        // location occupied by the adapter. 0xffff is not a valid
        // value for an FMP RX status.
        //

        if (rx_frame_stat == 0xffff)
        {
            MadgePrint1("Rx frame: RX status == 0xffff\n");
            ndisAdap->AdapterRemoved = TRUE;
            return;
        }

        //
        // FastMAC Plus includes the CRC in the frame length.
        //

        rx_frame_length -= 4;

        if ((rx_frame_stat & GOOD_RX_FRAME_MASK) == 0)
        {
            //
            // We have got a good frame here. 
            //

            rx_frame_addr = rx_slot_cache[active_rx_slot].VirtualAddress;

            header_len = (FRAME_IS_SOURCE_ROUTED(rx_frame_addr))
                ? FRAME_HEADER_SIZE + FRAME_SOURCE_ROUTING_BYTES(rx_frame_addr)
                : FRAME_HEADER_SIZE;

            //
            // Check for a frame copied error.
            //

            if ((rx_frame_addr[2] & 0x80) && (rx_frame_stat & 0x80))
            {
                ndisAdap->FrameCopiedErrors++;
            }

            //
            // We may have to behave like the hardware of an IBM adapter
            // and process LLC TEST and XID frames ourselves.
            //

            if (test_and_xid)
            {
                ignore_frame = ProcessTestAndXIDFrames(
                                   adapter_handle,
                                   rx_frame_addr,
                                   rx_frame_length,
                                   header_len
                                   );
            }
            else
            {
                ignore_frame = FALSE;
            }
                
            //
            // If we've got a valid frame then pass it up to the user.
            //

            if (!ignore_frame && 
                ((rx_frame_addr[1] & FRAME_TYPE_MASK) != FRAME_TYPE_MAC ||
                 (packet_filter & PROM_OR_MAC)        != 0))
            {
                //
                // When indicating the frame, we can pass all of it 
                // as lookahead if we want, but we ought to take 
                // account of the current lookahead setting in case it 
                // is less than the frame size. This becomes important in 
                // WFWG, where it is unable to cope with large lookaheads. The 
                // lookahead length used to be : 
                // (UINT) rx_frame_length - header_len    
                //

                NdisMTrIndicateReceive(
                        ndisAdap->UsedInISR.MiniportHandle,
                        (NDIS_HANDLE) (rx_frame_addr + header_len),
                        (PVOID) rx_frame_addr,
                        (UINT) header_len,
                        (PVOID) (rx_frame_addr + header_len),
                        (UINT) MIN(
                            ndisAdap->CurrentLookahead, 
                            (rx_frame_length - header_len)
                            ),
                        (UINT) (rx_frame_length - header_len)
                        );
    
	        //
                // Note that we've given the upper protocol at
                // least one frame.
                //

                done_frame = TRUE;

                ndisAdap->FramesReceived++;

#ifdef OID_MADGE_MONITOR
                //
                // Update the appropriate parts of the monitor structure
                //
                (ndisAdap->MonitorInfo).ReceiveFrames++;
                (ndisAdap->MonitorInfo).ReceiveFrameSize[rx_frame_length/128]++;
                (ndisAdap->MonitorInfo).CurrentFrameSize = rx_frame_length;
                (ndisAdap->MonitorInfo).ReceiveFlag = 1;
#endif
            }
        }

        //
        // Otherwise we have some sort of receive error.
        //

        else
        {
            ndisAdap->FrameReceiveErrors++;
        }

        //
        // Zero the frame length so that FastMAC Plus can reuse the buffer.
        // If we're doing multiprocessor safe PIO then we must do the DIO
        // via an ISR synchronised function.
        //

        if (ndisAdap->UseMPSafePIO)
        {
            info.rx_slot_ptr = rx_slot_ptr;

            NdisMSynchronizeWithInterrupt(
                &ndisAdap->Interrupt,
                MPSafeFreeRxSlot,
                &info
                );
        }
        else
        {
            sys_outsw(
                adapter_handle,
                sifadr,
                (WORD) (card_t) &rx_slot_ptr->buffer_len
                );

            sys_outsw( 
                adapter_handle,
                sifdat,
                0x0000
                );
        }

        //
        // Update the active receive slot pointer.                         
        //

        if (++active_rx_slot == rx_slots)
        {
            active_rx_slot = 0;
        }

        rx_slot_mgmnt->active_rx_slot = active_rx_slot;

        //
        // Now we had better look at the next slot in case another frame
        // has been received.
        //

        rx_slot_ptr = rx_slot_array[active_rx_slot];

        if (ndisAdap->UseMPSafePIO)
        {
            info.rx_slot_ptr = rx_slot_ptr;

            NdisMSynchronizeWithInterrupt(
                &ndisAdap->Interrupt,
                MPSafeReadRxStatus,
                &info
                );

            rx_frame_length = info.result1;
            rx_frame_stat   = info.result2;
        }
        else
        {
            sys_outsw( 
                adapter_handle,
                sifadr,
                (WORD) (card_t) &rx_slot_ptr->buffer_len
                );
          
            rx_frame_length = sys_insw( 
                                  adapter_handle,
                                  sifdat
                                  );
            sys_outsw(
                adapter_handle,
                sifadr,
                (WORD) (card_t) &rx_slot_ptr->rx_status
                );

            rx_frame_stat = sys_insw(
                                adapter_handle, 
                                sifdat
                                );

        }
    }

    //
    // If we've given the upper protocol a frame then call the
    // receive completion routine.
    //

    if (done_frame)
    {
        NdisMTrIndicateReceiveComplete(ndisAdap->UsedInISR.MiniportHandle);
    }
}



/***************************************************************************
*
* Function    - rxtx_abort_txing_frames
*
* Parameters  - adapter_handle -> FTK adapter handle.
*
* Purpose     - Stop sending frames.
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/

void
rxtx_abort_txing_frames(ADAPTER_HANDLE adapter_handle)
{
    //
    // Nothing to do here.
    //
}


/***************************************************************************
*
* Function    - rxtx_await_empty_tx_slots
*
* Parameters  - adapter_handle -> FTK adapter handle.
*
* Purpose     - Wait until all of the tx slots are empty.
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/

void
rxtx_await_empty_tx_slots(ADAPTER_HANDLE adapter_handle)
{
    ADAPTER            * adapter;
    FASTMAC_INIT_PARMS * fastmac_parms;
    TX_SLOT          * * tx_slot_array;
    UINT                 i;
    UINT                 status;
    PMADGE_ADAPTER       ndisAdap;
    MPSAFE_INFO          info;
    WORD                 sifadr;
    WORD                 sifdat;

    if (!driver_check_adapter(adapter_handle, ADAPTER_RUNNING, SRB_ANY_STATE))
    {
        MadgePrint1("rxtx_await_empty_tx_slots: adapter not running\n");
        return;
    }

    //
    // Pre-calculate some commonly used values.
    //

    adapter             = adapter_record[adapter_handle];
    fastmac_parms       = &adapter->init_block->fastmac_parms;
    tx_slot_array       = adapter->tx_slot_array;
    info.adapter_handle = adapter_handle;
    info.adapter        = adapter;
    ndisAdap            = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);
    sifadr              = adapter->sif_adr;
    sifdat              = adapter->sif_dat;

    for (i = 0; i < fastmac_parms->tx_slots; i++)
    {
        do
        {
            //
            // Get the slot status. If we are doing multiprocessor safe
            // PIO then we must do this with an ISR synchronised function.
            //

            if (ndisAdap->UseMPSafePIO)
            {
                info.tx_slot_ptr = tx_slot_array[i];

                NdisMSynchronizeWithInterrupt(
                    &ndisAdap->Interrupt,
                    MPSafeReadTxStatus,
                    &info
                    );

                status = info.result1;
            }
            else
            {
                sys_outsw(
                    adapter_handle,
                    sifadr,
                    (WORD) (card_t) &tx_slot_array[i]->tx_status
                    );

                status = sys_insw(adapter_handle, sifdat);
            }

            //
            // It is possible that a PCMCIA adapter may have been removed
            // in which case we must not wait forever. If an adapter has
            // been removed we would expect to read 0xffff from any IO
            // location occupied by the adapter. 0xffff is not a valid
            // value for an FMP TX status.
            //

            if (status == 0xffff)
            {
                MadgePrint1("Await empty tx: TX status == 0xffff\n");
                return;
            }
        }
        while (status >= 0x8000 || status == 0);
    }
}


/***************************************************************************
*
* Function    - user_completed_srb
*
* Parameters  - adapter_handle             -> FTK adapter handle.
*               srb_completed_successfully -> SRB successful?
*
* Purpose     - Record that an SRB has completed and arrange for our
*               DPR to be scheduled.
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/

void
user_completed_srb(
    ADAPTER_HANDLE adapter_handle,
    WBOOLEAN       srb_completed_successfully
    )
{
    PMADGE_ADAPTER ndisAdap;

    ndisAdap = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);

    //
    // If we have issued a private SRB then we just clear the 
    // private SRB flag. Otherwise we need to arrange for our
    // DPR to be told about the SRB.
    //

    if (ndisAdap->PrivateSrbInProgress)
    {
        ndisAdap->PrivateSrbInProgress = FALSE;
    }
    else
    {
        ndisAdap->UsedInISR.SrbRequestStatus    = (BOOLEAN) srb_completed_successfully;
        ndisAdap->UsedInISR.SrbRequestCompleted = TRUE;
        ndisAdap->DprRequired                   = TRUE;
    }
}


/***************************************************************************
*
* Function    - user_shedule_receive_process
*
* Parameters  - adapter_handle -> FTK adapter handle.
*
* Purpose     - Arrange for our DPR to be scheduled so that we can deal
*               with received frames.
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/


void
user_schedule_receive_process(ADAPTER_HANDLE adapter_handle)
{
    PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle)->DprRequired = TRUE;
}


/***************************************************************************
*
* Function    - user_adapter_removed
*
* Parameters  - adapter_handle -> FTK adapter handle.
*
* Purpose     - Arrange for our DPR to be scheduled so that we can deal
*               with a removed adapter.
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/


void
user_adapter_removed(ADAPTER_HANDLE adapter_handle)
{
    PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle)->DprRequired    = TRUE;
    PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle)->AdapterRemoved = TRUE;
}


/***************************************************************************
*
* Function    - user_handle_adapter_check
*
* Parameters  - adapter_handle -> FTK adapter handle.
*
* Purpose     - Called on an adapter check. Not a lot we can do really!
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/


void
user_handle_adapter_check(ADAPTER_HANDLE adapter_handle)
{
    MadgePrint1("Adapter Check!!!!\n");
}


//
// Currently we are not supporting transmit modes that require 
// user completion routine.
//

#if 0

/***************************************************************************
*
* Function    - user_transmit_completion
*
* Parameters  - adapter_handle -> FTK adapter handle.
*               identifier     -> NDIS packet handle.
*
* Purpose     - To notify an upper protocol that a transmit has completed.
*
* Returns     - Nothing.
*                                                                        
****************************************************************************/


void
user_transmit_completion(
    ADAPTER_HANDLE adapter_handle,
    DWORD          identifier
    )
{
}

#endif


/***************************************************************************
*
* Function    - rxtx_adapter_removed
*
* Parameters  - adapter_handle -> FTK adapter handle.
*
* Purpose     - Called to tidy up when we find out that the adapter has
*               been removed. All we do is tell the wrapper that we
*               have finished any submitted transmits.
*                                                                         
* Returns     - Nothing.
*                                                                        
****************************************************************************/

void
rxtx_adapter_removed(
    ADAPTER_HANDLE adapter_handle
    )
{
    ADAPTER        * adapter;
    PTX_SLOT_MGMNT   tx_slot_mgmnt;
    UINT             tx_slots;
    PMADGE_ADAPTER   ndisAdap;

    //
    // Pre-calculate some commonly used values.
    //
            
    adapter       = adapter_record[adapter_handle];
    tx_slot_mgmnt = (PTX_SLOT_MGMNT) adapter->tx_slot_mgmnt;
    tx_slots      = adapter->init_block->fastmac_parms.tx_slots;
    ndisAdap      = PMADGE_ADAPTER_FROM_ADAPTER_HANDLE(adapter_handle);

    //
    // Note that the adapter has been removed.
    //

    ndisAdap->AdapterRemoved = TRUE;

    //
    // Iterate around the transmit slots that are in use and 
    // up call to indicate that the transmits are over.
    //

    while (tx_slot_mgmnt->number_tx_in_use > 0)
    {
        //
        // Update the slot usage.
        //

        tx_slot_mgmnt->number_tx_in_use--;

        if (++tx_slot_mgmnt->first_tx_in_use == tx_slots)
        {
            tx_slot_mgmnt->first_tx_in_use = 0;
        }

        //
        // Tell the wrapper that there is a free slot.
        //

        NdisMSendResourcesAvailable(ndisAdap->UsedInISR.MiniportHandle);
    }
}


/******** End of FTK_USER.C ***********************************************/