/*++

Copyright (c) 1992  Microsoft Corporation

Module Name:

    send.c

Abstract:

    This file handles sending packets the Ungermann Bass Ethernet Controller.
    This driver conforms to the NDIS 3.0 interface.


Author:

    Brian Lieuallen     (BrianLie)      07/02/92


Environment:

    Kernel Mode     Operating Systems        : NT and other lesser OS's

Revision History:

    Brian Lieuallen     BrianLie        12/15/93
        Made it a mini-port


--*/



#include <ndis.h>
#include <efilter.h>

#include "niudata.h"
#include "debug.h"

#include "ubhard.h"
#include "ubsoft.h"
#include "ubnei.h"

#include "map.h"


BOOLEAN
CardSend(
    IN PUBNEI_ADAPTER  pAdapter,
    IN PNDIS_PACKET    pPacket,
    IN UINT            PacketLength
    );



BOOLEAN
UbneiMapSendBufferSync(
    PSEND_SYNC_CONTEXT  pSync
    );

BOOLEAN
UbneiGiveSendBufferToCardSync(
    PSEND_SYNC_CONTEXT  pSync
    );




NDIS_STATUS
UbneiMacSend(
    IN  NDIS_HANDLE    MacBindingHandle,
    IN  PNDIS_PACKET   pPacket,
    IN  UINT           Flags
    )
/*++

Routine Description:
    MacSend


Arguments:
    See NDIS 3.0 spec

Return Value:


--*/


  {
    PUBNEI_ADAPTER      pAdapter  = MacBindingHandle;
    UINT                PacketLength;
    BOOLEAN             SendResult;

    IF_LOG('s');

    ASSERT_RECEIVE_WINDOW( pAdapter);

    IF_SEND_LOUD(DbgPrint("MacSend called Packets\n");)

    NdisQueryPacket(pPacket, NULL, NULL, NULL, &PacketLength);

    //
    //  Here we check to make sure the packet meets some size constraints
    //

    if (PacketLength < 14  ||  PacketLength > 1514) {

        IF_LOUD(DbgPrint("MovePacketToCard: Packet too long or too short\n");)

        return NDIS_STATUS_FAILURE;

    }


    //  No packets queued, so we have a good chance
    //  being able to complete this send right now.
    //  After all the card has enough buffers for
    //  ~32 full size frames.
    //

    SendResult=CardSend(pAdapter, pPacket, PacketLength);

    if (SendResult) {
        //
        //  It's gone, were out of here!
        //
        //  Since we sent it down to the card we don't need the card
        //  to generate an interrupt
        //
        ASSERT_RECEIVE_WINDOW( pAdapter);

        UBNEI_MOVE_UCHAR_TO_SHARED_RAM(&(((PLOWNIUDATA)(pAdapter->pCardRam))->HostQueuedTransmits),0);

        NdisMSendResourcesAvailable(pAdapter->NdisAdapterHandle);

        return NDIS_STATUS_SUCCESS;

    } else {
        //
        //  No card buffers left, queue it and tell the card
        //  to interrupt us when there is room.
        //
        IF_LOUD(DbgPrint("UBNEI: No card send resources\n");)

        IF_LOG('o');

        pAdapter->WaitingForXmitInterrupt=TRUE;

        ASSERT_RECEIVE_WINDOW( pAdapter);

        UBNEI_MOVE_UCHAR_TO_SHARED_RAM(&(((PLOWNIUDATA)(pAdapter->pCardRam))->HostQueuedTransmits),1);

        return NDIS_STATUS_RESOURCES;
    }



}







BOOLEAN
CardSend(
    IN PUBNEI_ADAPTER  pAdapter,
    IN PNDIS_PACKET    pPacket,
    IN UINT            PacketLength
        )

/*++

Routine Description:
    This routine checks the cards transmit ring buffer to see if
    a send can take place. If it can then it removes the buffer
    from the free transmit buffer ring buffer and places it on
    the to be transimitted ring buffer.


Arguments:

    pAdapt - pointer to the adapter block

Return Value:
    returns TRUE if it was able to copy the send data to the card

    FALSE indicates that there are no free transmit buffers currently


--*/

{

    SEND_SYNC_CONTEXT   SyncContext;

    BOOLEAN        OkToSend;

    SyncContext.pAdapter=pAdapter;


    if (PacketLength<60) {

       PacketLength=60;

    }

    SyncContext.PacketLength=PacketLength;

    OkToSend=NdisMSynchronizeWithInterrupt(
        &pAdapter->NdisInterrupt,
        UbneiMapSendBufferSync,
        &SyncContext
        );

    if (OkToSend) {
        //
        //  If we can send now the sync routine left the correct
        //  window mapped in for us to copy to the send buffer
        //
        {
            PUCHAR          CurAddress, BufAddress;
            UINT            Len;
            PNDIS_BUFFER    CurBuffer;

            //
            // Memory mapped, just copy each buffer over.
            //

            NdisQueryPacket(pPacket, NULL, NULL, &CurBuffer, NULL);

            CurAddress = SyncContext.SendBuffer;

            while (CurBuffer) {

                NdisQueryBuffer(CurBuffer, (PVOID *)&BufAddress, &Len);

                UBNEI_MOVE_MEM_TO_SHARED_RAM(CurAddress, BufAddress, Len);

                CurAddress += Len;

                NdisGetNextBuffer(CurBuffer, &CurBuffer);

            }

        }


        NdisMSynchronizeWithInterrupt(
            &pAdapter->NdisInterrupt,
            UbneiGiveSendBufferToCardSync,
            &SyncContext
            );


    }


    return OkToSend;


}


BOOLEAN
UbneiMapSendBufferSync(
    PSEND_SYNC_CONTEXT  pSync
    )

{
    PUBNEI_ADAPTER      pAdapter=pSync->pAdapter;
    PHIGHNIUDATA        pDataWindow  = (PHIGHNIUDATA) pAdapter->pDataWindow;

    PTBD                pTBD;

    UCHAR               TmpUchar2;
    UCHAR               MapWindow;

    USHORT              TbdOffset;
    USHORT              BufferOffset;


    SET_DATAWINDOW(pAdapter,INTERRUPT_ENABLED);

    //
    //  Check to see if there are any free TBD descriptors. If not then
    //  we can't do any sends now
    //

    UBNEI_MOVE_SHARED_RAM_TO_UCHAR(&pSync->TbdIndex, &(pDataWindow->FreeTDBs.SRB_ReadPtr[0]));
    UBNEI_MOVE_SHARED_RAM_TO_UCHAR(&TmpUchar2, &(pDataWindow->FreeTDBs.SRB_WritePtr[0]));

    if (pSync->TbdIndex == TmpUchar2 ) {
        SET_RECDWINDOW(pAdapter,INTERRUPT_ENABLED);
        return FALSE;
    }

    //
    //  Get the address of the TBD in the NIU data segment
    //

    UBNEI_MOVE_SHARED_RAM_TO_USHORT(&TbdOffset,
                                    &(pDataWindow->FreeTDBs.SRB_Offsets[pSync->TbdIndex])
                                   );

    pTBD=(PTBD)((PUCHAR)pAdapter->pCardRam+TbdOffset);

    //
    //  Set the length of the frame to be sent in the TBD
    //

    UBNEI_MOVE_USHORT_TO_SHARED_RAM(&(pTBD->TBD_Frame_Length), (USHORT)pSync->PacketLength);
    UBNEI_MOVE_USHORT_TO_SHARED_RAM(&(pTBD->TBD_EOF_and_Length), (USHORT)pSync->PacketLength | 0x8000);

    //
    //  Get a pointer to the TBD buffer located in the NIU code segment
    //  Under the current version of download code the transmit buffer is
    //  is 1514 bytes long, so this makes things easy
    //

    UBNEI_MOVE_SHARED_RAM_TO_USHORT(&BufferOffset, &(pTBD->TBD_Buffer_offset));

    pSync->SendBuffer=(PUCHAR)pAdapter->pCardRam + BufferOffset;

    //
    //  Set the map register to point to the correct window to access
    //  the send buffer
    //

    UBNEI_MOVE_SHARED_RAM_TO_UCHAR(&MapWindow, &(pTBD->TBD_Buffer_Map));

    pAdapter->MapRegSync.NewMapRegister=MapWindow | INTERRUPT_ENABLED;

    UbneiMapRegisterChangeSync(&pAdapter->MapRegSync);

    return TRUE;

}

BOOLEAN
UbneiGiveSendBufferToCardSync(
    PSEND_SYNC_CONTEXT  pSync
    )

{
    PUBNEI_ADAPTER      pAdapter=pSync->pAdapter;
    PHIGHNIUDATA        pDataWindow  = (PHIGHNIUDATA) pAdapter->pDataWindow;

    UCHAR               TmpUchar1;


    SET_DATAWINDOW(pAdapter,INTERRUPT_ENABLED);

    //
    //  To actually give the data to the NIU to send, we remove the this
    //  TBD from the FreeTDB buffer and add it to XmtFrames buffer
    //

    UBNEI_MOVE_UCHAR_TO_SHARED_RAM(&(pDataWindow->FreeTDBs.SRB_ReadPtr[0]), pSync->TbdIndex + 1);

    UBNEI_MOVE_SHARED_RAM_TO_UCHAR(&TmpUchar1, &(pDataWindow->XmtFrames.SRB_WritePtr[0]));
    UBNEI_MOVE_UCHAR_TO_SHARED_RAM(&(pDataWindow->XmtFrames.SRB_WritePtr[0]), TmpUchar1 + 1);

    SET_RECDWINDOW(pAdapter,INTERRUPT_ENABLED);

    return TRUE;
}