rndismin.c

6410BSP3

    IN  UINT8 *pData,   /* data to send */
    IN  UINT32 size     /* number of bytes to send from pData */
    )
{
    UINT32 cbLeftToSend;
    UINT32 retVal;

    USBDBGMSG(USBDBG_ZONE_FUNC, (L"+Rndis_SendFrame: size=%d\r\n", size));
    
    if (!IsRndisInit())
    {
        retVal = 0;
        goto cleanUp;
    }
    
    if (!PrepareRndisPacket(pData, size))
    {
        retVal = ERROR_BUFFER_OVERFLOW;
        goto cleanUp;
    }
    
    cbLeftToSend = m_outgoingPkt.rndisMsg.MessageLength +
                    ((UINT32)(&m_outgoingPkt.rndisMsg.Message) -
                     (UINT32)(&m_outgoingPkt.rndisMsg));
    pData = (UINT8*) &m_outgoingPkt;

    UsbRndis_SendData(pData, cbLeftToSend);
    retVal = ERROR_SUCCESS;

cleanUp:
    USBDBGMSG(USBDBG_ZONE_FUNC, (L"-Rndis_SendFrame: retVal=%d\r\n", retVal));
    return retVal;

}

//------------------------------------------------------------------------------
// Description: Signature matches OAL_KITLETH_GET_FRAME defined in oal_kitl.h
//              Called by KITL or DLE to receive a packet over USB DBG RNDIS.
//
// Returns: Size of data received.
// 
UINT16
Rndis_RecvFrame(
    LPBYTE pbOutBuffer,
    PUSHORT pcbOutBufSize
    )
{
    DWORD cbRecvdData = 0;
    
    USBDBGMSG(USBDBG_ZONE_FUNC, (L"+Rndis_RecvFrame: bufSize=%d\r\n",*pcbOutBufSize));
    
    if (!IsRndisInit())
        goto clean;

    // get frame from PDD
    cbRecvdData = UsbRndis_RecvData(pbOutBuffer, *pcbOutBufSize);

clean:
    //sanity check retVal
    if (cbRecvdData > USBDBG_KITL_MTU)
    {
        USBDBGMSG(USBDBG_ZONE_ERROR, (L"ERROR: RNdis:: RecvFrame: cbRecvdData=%d > KITL_MTU.\r\n", cbRecvdData));
    }
    *pcbOutBufSize = (USHORT)cbRecvdData;
    
#ifdef DEBUG
    if (cbRecvdData > 0)
    {
        USBDBGMSG(USBDBG_ZONE_RECV, (L"<<RECV_UsbDbg: %d bytes\r\n", cbRecvdData));
        DumpPacket(USBDBG_ZONE_RECV, pbOutBuffer, cbRecvdData);
    }
#endif

    USBDBGMSG(USBDBG_ZONE_FUNC, (L"-Rndis_RecvFrame: cbRecvdData=%d\r\n",cbRecvdData));

    return (UINT16)cbRecvdData;
}

void
Rndis_PowerOff(
    )
{
    UsbRndis_SetPower(TRUE);
}

void
Rndis_PowerOn(
    )
{
    UsbRndis_SetPower(FALSE);
}

void
Rndis_DeInit(
    )
{
    UsbRndis_Deinit();
}

//---------------------------------------------------------------------------//

//---------------------------------------------------------------------------//
/// callback interface (from USBRNDIS layer)


//------------------------------------------------------------------------------
// Description: Received a RNDIS_ message. Process the message and send the
//              reply.
//
// Returns: Size of data received.
// 
void
RndisPdd_RecvdMsg(
    PBYTE pbData,
    UINT32 cbData
    )
{
    PRNDIS_MESSAGE  pRndisMessage;

    pRndisMessage = (PRNDIS_MESSAGE) pbData;

    USBDBGMSG(USBDBG_ZONE_VERBOSE,  
        (L"RNdis:: Processing RndisMessage [%s] - Length [%d]\r\n",
        pRndisMessage->NdisMessageType == REMOTE_NDIS_INITIALIZE_MSG      ? 
                L"RNDIS_INITIALIZE" : 
        pRndisMessage->NdisMessageType == REMOTE_NDIS_HALT_MSG            ? 
                L"RNDIS_HALT"       :
        pRndisMessage->NdisMessageType == REMOTE_NDIS_QUERY_MSG           ? 
                L"RNDIS_QUERY"      :
        pRndisMessage->NdisMessageType == REMOTE_NDIS_SET_MSG             ?
                L"RNDIS_SET"        :
        pRndisMessage->NdisMessageType == REMOTE_NDIS_RESET_MSG           ? 
                L"RNDIS_RESET"      :
        pRndisMessage->NdisMessageType == REMOTE_NDIS_PACKET_MSG          ? 
                L"RNDIS_PACKET"   :
        pRndisMessage->NdisMessageType == REMOTE_NDIS_INDICATE_STATUS_MSG ? 
                L"RNDIS_INDICATE"   :
        pRndisMessage->NdisMessageType == REMOTE_NDIS_KEEPALIVE_MSG       ? 
                L"RNDIS_KEEPALIVE"  :      
        pRndisMessage->NdisMessageType == REMOTE_NDIS_PACKET_MSG          ? 
                L"RNDIS_DATA_PACKET"   :
                L"UNKNOWN!",
        pRndisMessage->MessageLength));

    // we only queue one rndis message and response
    // Hence drop this message if last response has not been sent yet
    // do not drop REMOTE_NDIS_INITIALIZE_MSG & REMOTE_NDIS_RESET_MSG
    //
    if (pRndisMessage->NdisMessageType!= REMOTE_NDIS_INITIALIZE_MSG &&
        pRndisMessage->NdisMessageType!= REMOTE_NDIS_RESET_MSG &&
        !UsbRndis_RndisMsgSent())
    {
        USBDBGMSG(USBDBG_ZONE_WARN, (L"RNdis:: Dropping RndisMessageType=%d\r\n", pRndisMessage->NdisMessageType));
        return;
    }
    
    switch (pRndisMessage->NdisMessageType)
    {
        case REMOTE_NDIS_PACKET_MSG:
            USBDBGMSG(USBDBG_ZONE_ERROR, (L"ERROR: RNdis:: Current codepath not expecting REMOTE_NDIS_PACKET_MSG\r\n"));
            break;
            
        case REMOTE_NDIS_INITIALIZE_MSG:
        {
            PRNDIS_INITIALIZE_REQUEST   pInitializeRequest;
            NDIS_STATUS                 NdisStatus;

            pInitializeRequest = &pRndisMessage->Message.InitializeRequest;

            USBDBGMSG (USBDBG_ZONE_VERBOSE,
                (L"RNdis:: ReqID[0x%x] - Ver[%d-%d] - MaxXfer[%d]\r\n",
                pInitializeRequest->RequestId,
                pInitializeRequest->MajorVersion,
                pInitializeRequest->MinorVersion,
                pInitializeRequest->MaxTransferSize));

            //  We support SUPPORTED_RNDIS_MAJOR_VERSION, so bail out if 
            //  it's not.           
            if (pInitializeRequest->MajorVersion > SUPPORTED_RNDIS_MAJOR_VER  ||
                (pInitializeRequest->MajorVersion == SUPPORTED_RNDIS_MAJOR_VER &&
                 pInitializeRequest->MinorVersion > SUPPORTED_RNDIS_MINOR_VER))
            {
                USBDBGMSG (USBDBG_ZONE_ERROR,
                    (L"RNdisMini Err!! unsupported RNDIS host ver.\r\n"));
                NdisStatus = NDIS_STATUS_FAILURE;
            }
            else
            {
                NdisStatus = NDIS_STATUS_SUCCESS;               
            }

            //  Send the reply out..
            //
            USBDBGMSG (USBDBG_ZONE_VERBOSE, 
                (TEXT("RNdis:: Send InitializeComplete Status[0x%x] ID[0x%x]\r\n"),
                NdisStatus,
                pInitializeRequest->RequestId));
            
            SendRndisMessage(
                REMOTE_NDIS_INITIALIZE_CMPLT,
                pInitializeRequest->RequestId,                  
                NdisStatus,
                NULL,
                0x00,
                0x00);
            
            m_rndisDev.state = RNDIS_INITIALIZED;

            break;
        }

        case REMOTE_NDIS_QUERY_MSG:
        {
            PRNDIS_QUERY_REQUEST    pRndisRequest;
            NDIS_STATUS             NdisStatus;         
            ULONG                   ulBytesWritten;
            ULONG                   ulBytesNeeded;
            UCHAR                   *pucBuffer;


            if(m_rndisDev.state == RNDIS_UNINITIALIZED)
                break;

            pRndisRequest = &pRndisMessage->Message.QueryRequest;

            USBDBGMSG(USBDBG_ZONE_VERBOSE,
                (TEXT("RNdis:: Query: ID[0x%x]:OID[0x%x]:Buff[%d-%d]\r\n"),
                pRndisRequest->RequestId,
                pRndisRequest->Oid,
                pRndisRequest->InformationBufferLength,
                pRndisRequest->InformationBufferOffset));           

            //  Special treatment for this OID.
            //
            if (pRndisRequest->Oid == OID_GEN_SUPPORTED_LIST)
            {
                pucBuffer = (PUCHAR)RNdisMddSupportedOids;
                
                HostMiniQueryInformation(pRndisRequest->Oid, NULL, 0x00,
                        &ulBytesWritten, &ulBytesNeeded);

                ulBytesWritten  = ulBytesNeeded;
                ulBytesNeeded   = 0x00;
                NdisStatus      = NDIS_STATUS_SUCCESS;
            }
            else
            {
                //  Pass this to our miniport handler..
                //
                pucBuffer  = (PUCHAR)((PUCHAR)pRndisRequest + 
                            pRndisRequest->InformationBufferOffset);

                NdisStatus = HostMiniQueryInformation(pRndisRequest->Oid,
                        pucBuffer,  pRndisRequest->InformationBufferLength,
                        &ulBytesWritten, &ulBytesNeeded);
                
            }


            //  Reply back to host..
            SendRndisMessage(REMOTE_NDIS_QUERY_CMPLT, pRndisRequest->RequestId,
                NdisStatus, pucBuffer, ulBytesWritten,
                ulBytesWritten ? ulBytesWritten : ulBytesNeeded);


            break;
        }   

        case REMOTE_NDIS_SET_MSG:
        {
            PRNDIS_SET_REQUEST      pRndisSet;
            NDIS_STATUS             NdisStatus;         
            ULONG                   ulBytesRead;
            ULONG                   ulBytesNeeded;
            UCHAR                   *pucBuffer;

            if (m_rndisDev.state == RNDIS_UNINITIALIZED)
                break;

            pRndisSet = &pRndisMessage->Message.SetRequest;
            pucBuffer  = (PUCHAR)((PUCHAR)pRndisSet + pRndisSet->InformationBufferOffset);
            NdisStatus = HostMiniSetInformation(
                            pRndisSet->Oid,
                            pucBuffer,
                            pRndisSet->InformationBufferLength,
                            &ulBytesRead,
                            &ulBytesNeeded);

            //  Reply back to host on the status..
            SendRndisMessage(
                REMOTE_NDIS_SET_CMPLT,
                pRndisSet->RequestId,
                NdisStatus,
                NULL,
                0,
                0);

            break;
        }       

        case REMOTE_NDIS_KEEPALIVE_MSG:
        {
            PRNDIS_KEEPALIVE_REQUEST    pKeepAliveRequest;

            if(m_rndisDev.state == RNDIS_UNINITIALIZED)
                break;

            USBDBGMSG (USBDBG_ZONE_VERBOSE, (TEXT("RNdis:: REMOTE_NDIS_KEEPALIVE_MSG.\r\n")));

            pKeepAliveRequest = &pRndisMessage->Message.KeepaliveRequest;

            //  [todo] DISCONNECTION HANDLING
            //  We probably need to keep track of this to detect 
            //  device being disconnected..

            //  We are here host!!!
            SendRndisMessage(
                REMOTE_NDIS_KEEPALIVE_CMPLT,
                pKeepAliveRequest->RequestId,
                RNDIS_STATUS_SUCCESS,
                NULL,
                0,
                0);
        
            break;
        }       

        case REMOTE_NDIS_HALT_MSG:
        {
            if(m_rndisDev.state == RNDIS_UNINITIALIZED)
                break;

            USBDBGMSG(USBDBG_ZONE_WARN, (L"RNdis:: recv REMOTE_NDIS_HALT_MSG from host!\r\n"));

            break;
        }
        
        case REMOTE_NDIS_RESET_MSG:
        {
            if(m_rndisDev.state == RNDIS_UNINITIALIZED)
                break;          

            USBDBGMSG(USBDBG_ZONE_WARN, (L"RNdis:: rcv REMOTE_NDIS_RESET_MSG from host!\r\n"));

#if 0
            LogCallStack();
#endif
            //  Per RNDIS spec discard all outstanding messages.
            //  Since we don't queue RNDIS messages just reply with reset complete.

            //  Reply this message.
            SendRndisMessage(
                REMOTE_NDIS_RESET_CMPLT,
                0x00,
                0x00,
                NULL,
                0,
                0);

            break;
        }
        
        case REMOTE_NDIS_INDICATE_STATUS_MSG:
        {
            if(m_rndisDev.state == RNDIS_UNINITIALIZED)
                break;      
            break;      
        }
        
        default:
            USBDBGMSG(USBDBG_ZONE_ERROR, (
                L"USBDBGRNDIS:: Unknown RNDIS msg, buff[0x%x] l=[%d]!\r\n",
                pbData, cbData
                ));
            break;
    }   

}

DWORD
RndisPdd_ProcessRecvdData(
    PBYTE pbSourceBuf,
    DWORD cbSourceBufLen,
    PBYTE pbTargetBuf,
    DWORD cbTargetBufLen
    )
{
    DWORD cbRecvdData = 0;
    PRNDIS_MESSAGE pRndisMessage = (PRNDIS_MESSAGE) pbSourceBuf;
    PRNDIS_PACKET pRndisPacket =RNDIS_MESSAGE_PTR_TO_MESSAGE_PTR(pRndisMessage);
    UINT32 rndisDataOffset = 
        (UINT32)GET_PTR_TO_RNDIS_DATA_BUFF(pRndisPacket) -
        (UINT32)pRndisMessage;

    if (pRndisMessage->NdisMessageType != REMOTE_NDIS_PACKET_MSG)
    {
        USBDBGMSG(USBDBG_ZONE_ERROR, (
            L"ERROR:usbdbg:REMOTE_NDIS_PACKET_MSG not recvd t=%d, len=%d",
            pRndisMessage->NdisMessageType, cbSourceBufLen));
        goto clean;
    }

    cbRecvdData = pRndisPacket->DataLength;
    
    // copy data payload to target buffer
    memcpy(pbTargetBuf,
           pbSourceBuf + rndisDataOffset,
           pRndisPacket->DataLength);


    
clean:           
    return cbRecvdData;                
}

void
RndisPdd_SetRndisState(
    BOOL notInit
    )
{
    if (notInit)
    {
        // set current packet filter to 0.
        m_rndisDev.dwCurrentPacketFilter = 0;
        // state to uninit
        m_rndisDev.state = RNDIS_UNINITIALIZED;
    }
}