// Check the cable connection state
void NeoCheckConnectState()
{
NDIS_STATUS_INDICATION t;
NDIS_LINK_STATE state;
if (ctx == NULL || ctx->NdisMiniport == NULL)
{
return;
}
NeoZero(&t, sizeof(t));
t.Header.Type = NDIS_OBJECT_TYPE_STATUS_INDICATION;
t.Header.Revision = NDIS_STATUS_INDICATION_REVISION_1;
t.Header.Size = NDIS_SIZEOF_STATUS_INDICATION_REVISION_1;
t.SourceHandle = ctx->NdisMiniport;
NeoZero(&state, sizeof(state));
state.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
state.Header.Revision = NDIS_LINK_STATE_REVISION_1;
state.Header.Size = NDIS_SIZEOF_LINK_STATE_REVISION_1;
state.MediaDuplexState = NdisPauseFunctionsSendAndReceive;
state.XmitLinkSpeed = state.RcvLinkSpeed = max_speed;
state.PauseFunctions = NdisPauseFunctionsUnsupported;
t.StatusCode = NDIS_STATUS_LINK_STATE;
t.StatusBuffer = &state;
t.StatusBufferSize = sizeof(NDIS_LINK_STATE);
if (keep_link == false)
{
if (ctx->ConnectedOld != ctx->Connected || ctx->ConnectedForce)
{
ctx->ConnectedForce = FALSE;
ctx->ConnectedOld = ctx->Connected;
if (ctx->Halting == FALSE)
{
state.MediaConnectState = ctx->Connected ? MediaConnectStateConnected : MediaConnectStateDisconnected;
NdisMIndicateStatusEx(ctx->NdisMiniport, &t);
}
}
}
else
{
if (ctx->ConnectedForce)
{
ctx->ConnectedForce = false;
if (ctx->Halting == FALSE)
{
state.MediaConnectState = MediaConnectStateConnected;
NdisMIndicateStatusEx(ctx->NdisMiniport, &t);
}
}
}
}
static VOID PostLinkState(PARANDIS_ADAPTER *pContext, NDIS_MEDIA_CONNECT_STATE connectState)
{
NDIS_STATUS_INDICATION indication;
NDIS_LINK_STATE state;
NdisZeroMemory(&state, sizeof(state));
state.Header.Revision = NDIS_LINK_STATE_REVISION_1;
state.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
state.Header.Size = NDIS_SIZEOF_LINK_STATE_REVISION_1;
state.MediaConnectState = connectState;
state.MediaDuplexState = MediaDuplexStateFull;
state.RcvLinkSpeed = state.XmitLinkSpeed =
connectState == MediaConnectStateConnected ?
PARANDIS_MAXIMUM_RECEIVE_SPEED :
NDIS_LINK_SPEED_UNKNOWN;
state.PauseFunctions = NdisPauseFunctionsUnsupported;
NdisZeroMemory(&indication, sizeof(indication));
indication.Header.Type = NDIS_OBJECT_TYPE_STATUS_INDICATION;
indication.Header.Revision = NDIS_STATUS_INDICATION_REVISION_1;
indication.Header.Size = NDIS_SIZEOF_STATUS_INDICATION_REVISION_1;
indication.SourceHandle = pContext->MiniportHandle;
indication.StatusCode = NDIS_STATUS_LINK_STATE;
indication.StatusBuffer = &state;
indication.StatusBufferSize = sizeof(state);
DPrintf(0, ("Indicating %s\n", ConnectStateName(connectState)));
ParaNdis_DebugHistory(pContext, hopConnectIndication, NULL, connectState, 0, 0);
NdisMIndicateStatusEx(pContext->MiniportHandle , &indication);
}
//===================================================
// Tell Windows whether the TAP device should be
// considered "connected" or "disconnected".
//
// Allows application control of media connect state.
//===================================================
VOID tapSetMediaConnectStatus(__in PTAP_ADAPTER_CONTEXT Adapter, __in BOOLEAN LogicalMediaState) {
NDIS_STATUS_INDICATION statusIndication;
NDIS_LINK_STATE linkState;
NdisZeroMemory(&statusIndication, sizeof(NDIS_STATUS_INDICATION));
NdisZeroMemory(&linkState, sizeof(NDIS_LINK_STATE));
//
// Fill in object headers
//
statusIndication.Header.Type = NDIS_OBJECT_TYPE_STATUS_INDICATION;
statusIndication.Header.Revision = NDIS_STATUS_INDICATION_REVISION_1;
statusIndication.Header.Size = sizeof(NDIS_STATUS_INDICATION);
linkState.Header.Revision = NDIS_LINK_STATE_REVISION_1;
linkState.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
linkState.Header.Size = sizeof(NDIS_LINK_STATE);
//
// Link state buffer
//
if (Adapter->LogicalMediaState == TRUE) {
linkState.MediaConnectState = MediaConnectStateConnected;
}
linkState.MediaDuplexState = MediaDuplexStateFull;
linkState.RcvLinkSpeed = TAP_RECV_SPEED;
linkState.XmitLinkSpeed = TAP_XMIT_SPEED;
//
// Fill in the status buffer
//
statusIndication.StatusCode = NDIS_STATUS_LINK_STATE;
statusIndication.SourceHandle = Adapter->MiniportAdapterHandle;
statusIndication.DestinationHandle = NULL;
statusIndication.RequestId = 0;
statusIndication.StatusBuffer = &linkState;
statusIndication.StatusBufferSize = sizeof(NDIS_LINK_STATE);
// Fill in new media connect state.
if ((Adapter->LogicalMediaState != LogicalMediaState) && !Adapter->MediaStateAlwaysConnected) {
Adapter->LogicalMediaState = LogicalMediaState;
if (LogicalMediaState == TRUE) {
linkState.MediaConnectState = MediaConnectStateConnected;
DEBUGP(("[TAP] Set MediaConnectState: Connected.\n"));
} else {
linkState.MediaConnectState = MediaConnectStateDisconnected;
DEBUGP(("[TAP] Set MediaConnectState: Disconnected.\n"));
}
}
// Make the status indication.
if (Adapter->Locked.AdapterState != MiniportHaltedState) {
NdisMIndicateStatusEx(Adapter->MiniportAdapterHandle, &statusIndication);
}
}
void
shared_indicate_status(NDIS_HANDLE adapterhandle, NDIS_STATUS StatusCode,
void *StatusBuffer, ULONG StatusBufferSize)
{
#ifndef NDIS60
/* NdisMIndicateStatus(wl->sh.adapterhandle,
NDIS_STATUS_MEDIA_SPECIFIC_INDICATION,
StatusBuffer, StatusBufferSize);
NdisMIndicateStatusComplete(wl->sh.adapterhandle);
*/
NdisMIndicateStatus(adapterhandle,
NDIS_STATUS_MEDIA_SPECIFIC_INDICATION,
StatusBuffer, StatusBufferSize);
NdisMIndicateStatusComplete(adapterhandle);
#else
NDIS_STATUS_INDICATION ind;
bzero(&ind, sizeof(NDIS_STATUS_INDICATION));
ind.Header.Type = NDIS_OBJECT_TYPE_STATUS_INDICATION;
ind.Header.Revision = NDIS_STATUS_INDICATION_REVISION_1;
ind.Header.Size = sizeof(NDIS_STATUS_INDICATION);
ind.SourceHandle = adapterhandle;
ind.DestinationHandle = NULL;
/* [N.B.: Jiandong says the RequestID field is not needed...] */
ind.StatusCode = StatusCode;
ind.StatusBuffer = StatusBuffer;
ind.StatusBufferSize = StatusBufferSize;
NdisMIndicateStatusEx(adapterhandle, &ind);
#endif /* NDIS60 */
}
VOID
VenetSetLinkState(PADAPTER a, BOOLEAN state)
{
NDIS_LINK_STATE link;
NDIS_STATUS_INDICATION status;
NdisZeroMemory(&link, sizeof(NDIS_LINK_STATE));
NdisZeroMemory(&status, sizeof(NDIS_STATUS_INDICATION));
link.Header.Revision = NDIS_LINK_STATE_REVISION_1;
link.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
link.Header.Size = sizeof(NDIS_LINK_STATE);
status.Header.Type = NDIS_OBJECT_TYPE_STATUS_INDICATION;
status.Header.Revision = NDIS_STATUS_INDICATION_REVISION_1;
status.Header.Size = sizeof(NDIS_STATUS_INDICATION);
status.SourceHandle = a->adapterHandle;
status.StatusCode = NDIS_STATUS_LINK_STATE;
status.StatusBuffer = &link;
status.StatusBufferSize = sizeof(link);
if (state) {
link.MediaConnectState = MediaConnectStateConnected;
link.MediaDuplexState = MediaDuplexStateFull;
link.XmitLinkSpeed = 1000000000;
}
else {
link.MediaConnectState = MediaConnectStateDisconnected;
link.MediaDuplexState = MediaDuplexStateUnknown;
link.XmitLinkSpeed = NDIS_LINK_SPEED_UNKNOWN;
}
NdisMIndicateStatusEx(a->adapterHandle, &status);
}
NDIS_STATUS
xmpSetInformation(
IN xmpNicCtx_t *pNicCtx,
IN PNDIS_OID_REQUEST NdisRequest
)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
NDIS_OID Oid;
PVOID InformationBuffer;
ULONG InformationBufferLength;
ULONG BytesRead;
ULONG BytesNeeded;
ULONG PacketFilter;
ULONG MCastCnt;
ULONG HashType;
ULONG validBits;
USHORT i;
xge_hal_device_t *pHalDev;
NDIS_RECEIVE_SCALE_PARAMETERS *pRssParam;
xmpSetRssContext SetRssCtx = {0};
static ULONG setRssCount = 10;
pHalDev = XMP_NIC_GET_DEV(pNicCtx);
Oid = NdisRequest->DATA.SET_INFORMATION.Oid;
InformationBuffer = NdisRequest->DATA.SET_INFORMATION.InformationBuffer;
InformationBufferLength =
NdisRequest->DATA.SET_INFORMATION.InformationBufferLength;
XMPTRACE(XMP_DBG_REQ, ("==> xmpSetInformation %x\n", Oid));
BytesRead = 0;
BytesNeeded = 0;
switch(Oid)
{
case OID_802_3_MULTICAST_LIST:
XMPTRACE(XMP_DBG_REQ, ("xmpSetInformation Multicast list\n"));
if ( InformationBufferLength % ETH_LENGTH_OF_ADDRESS != 0 )
return(NDIS_STATUS_INVALID_LENGTH);
MCastCnt = InformationBufferLength / ETH_LENGTH_OF_ADDRESS;
xmpHalMcastFilterClr(pNicCtx);
Status = xmpHalSetMcastList(pNicCtx,
(UCHAR *) InformationBuffer,
&MCastCnt);
BytesRead = MCastCnt * ETH_LENGTH_OF_ADDRESS;
break;
case OID_GEN_CURRENT_PACKET_FILTER:
XMPTRACE(XMP_DBG_REQ, ("xmpSetInformation: packet filter\n"));
if ( InformationBufferLength != sizeof (ULONG) )
return ( NDIS_STATUS_INVALID_LENGTH );
BytesRead = InformationBufferLength;
PacketFilter = *((PULONG) InformationBuffer);
Status = xmpSetFilter(pNicCtx, PacketFilter);
break;
case OID_GEN_CURRENT_LOOKAHEAD:
XMPTRACE(XMP_DBG_REQ, ("xmpSetInformation: current lookahead\n"));
if( InformationBufferLength < sizeof(ULONG) )
{
BytesNeeded = sizeof(ULONG);
Status = NDIS_STATUS_INVALID_LENGTH;
break;
}
pNicCtx->LookAheadSz = *((PULONG) InformationBuffer);
BytesRead = sizeof(ULONG);
Status = NDIS_STATUS_SUCCESS;
break;
case OID_GEN_RECEIVE_SCALE_PARAMETERS:
XMPTRACE(XMP_DBG_INFO, ("xmpSetInformation: OID_GEN_RECEIVE_SCALE_PARAMETERS\n"));
if ( !(XMP_NIC_RSS_IN_CONFIG(pNicCtx)) )
{
Status = NDIS_STATUS_NOT_SUPPORTED;
break;
}
if ( InformationBufferLength < sizeof(NDIS_RECEIVE_SCALE_PARAMETERS) )
{
BytesNeeded = sizeof(NDIS_RECEIVE_SCALE_PARAMETERS);
Status = NDIS_STATUS_INVALID_LENGTH;
break;
}
pRssParam = (PNDIS_RECEIVE_SCALE_PARAMETERS)InformationBuffer;
#ifdef NDISTEST_BUG
if ( !XENAMP_NDIS_OBJECT_VALID(&pRssParam->Header,
NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_1,
NDIS_OBJECT_TYPE_RSS_PARAMETERS,
sizeof(NDIS_RECEIVE_SCALE_PARAMETERS)) )
{
XMPTRACE(XMP_DBG_WRN, ("xmpSetInformation:RSS_PARAMETERS invalid!!"
" Revision=%d Type=%d Size=%d\n",
pRssParam->Header.Revision,
pRssParam->Header.Type,
pRssParam->Header.Size));
BytesRead = sizeof(NDIS_OBJECT_HEADER);
Status = NDIS_STATUS_INVALID_PARAMETER;
break;
}
#endif
BytesRead = sizeof(NDIS_RECEIVE_SCALE_PARAMETERS);
if ( (InformationBufferLength < (pRssParam->IndirectionTableSize
+ pRssParam->IndirectionTableOffset)) ||
(InformationBufferLength < (pRssParam->HashSecretKeySize
+ pRssParam->HashSecretKeyOffset)) )
{
BytesNeeded = sizeof(NDIS_RECEIVE_SCALE_PARAMETERS);
Status = NDIS_STATUS_INVALID_LENGTH;
break;
}
HashType = NDIS_RSS_HASH_TYPE_FROM_HASH_INFO(pRssParam->HashInformation);
/*if ( HashType != 0 || NDIS_RSS_HASH_FUNC_FROM_HASH_INFO(pRssParam->HashInformation) != 0) */
validBits = (NDIS_HASH_IPV4 | NDIS_HASH_TCP_IPV4
#ifndef XMP_RSS_IPV4_ONLY
| NDIS_HASH_IPV6 | NDIS_HASH_TCP_IPV6
| NDIS_HASH_IPV6_EX | NDIS_HASH_TCP_IPV6_EX
#endif
);
if ( ((NDIS_RSS_HASH_FUNC_FROM_HASH_INFO(pRssParam->HashInformation) !=
NdisHashFunctionToeplitz) || /* the only hash function supported */
!bit(HashType, validBits) || /* at least one type should be set */
(HashType & ~validBits)) && /* no other type should be set */
(!(bit(pRssParam->Flags, NDIS_RSS_PARAM_FLAG_DISABLE_RSS)) &&
NDIS_RSS_HASH_FUNC_FROM_HASH_INFO(pRssParam->HashInformation) != 0) )
{
Status = NDIS_STATUS_INVALID_PARAMETER;
break;
}
if ( /*(pRssParam->IndirectionTableSize < (1 << pRssParam->NumberOfLsbs)) || */
(pRssParam->HashSecretKeySize & 0x7) || /* must be 8-bytes align */
(pRssParam->HashSecretKeySize > 40) || /* max secret key size */
(pRssParam->BaseCpuNumber & (pRssParam->BaseCpuNumber - 1)) )/*pow2 */
{
XMPTRACE(XMP_DBG_WRN, ("xmpReqSetRss:Invalid settings: Key Size=%d"
" IDT size=%d BaseCpu=%d\n",
pRssParam->HashSecretKeySize,
pRssParam->IndirectionTableSize,
pRssParam->BaseCpuNumber));
Status = NDIS_STATUS_INVALID_PARAMETER;
break;
}
if ((pRssParam->IndirectionTableSize + pRssParam->IndirectionTableOffset) >
(pRssParam->HashSecretKeySize + pRssParam->HashSecretKeyOffset))
BytesRead = (pRssParam->IndirectionTableSize +
pRssParam->IndirectionTableOffset);
else
BytesRead = (pRssParam->HashSecretKeySize +
pRssParam->HashSecretKeyOffset);
SetRssCtx.pNicCtx = pNicCtx;
SetRssCtx.pParams = pRssParam;
#if 0
if(NdisMSynchronizeWithInterruptEx(pNicCtx->hInterrupt, 0, xmpReqSetRss, &SetRssCtx))
#endif
if ( NDIS_RSS_HASH_FUNC_FROM_HASH_INFO(pRssParam->HashInformation) == 0 )
bis(pRssParam->Flags, NDIS_RSS_PARAM_FLAG_DISABLE_RSS);
if ( bit(pRssParam->Flags, NDIS_RSS_PARAM_FLAG_DISABLE_RSS) )
{
pNicCtx->ndisRssSet.size = sizeof(NDIS_RECEIVE_SCALE_PARAMETERS);
pNicCtx->ndisRssSet.params.BaseCpuNumber = 0;
pNicCtx->ndisRssSet.params.Flags = 0;
pNicCtx->ndisRssSet.params.HashInformation = 0;
pNicCtx->ndisRssSet.params.IndirectionTableSize = 0;
pNicCtx->ndisRssSet.params.IndirectionTableOffset = 0;
pNicCtx->ndisRssSet.params.HashSecretKeySize = 0;
pNicCtx->ndisRssSet.params.HashSecretKeyOffset = 0;
}
else
{
NdisMoveMemory(&pNicCtx->ndisRssSet.params, pRssParam, BytesRead);
pNicCtx->ndisRssSet.size = BytesRead;
}
xmpReqSetRss(pNicCtx);
#if 0
if ( !(setRssCount % 10) )
{
xmpReqSetRss(pNicCtx);
}
setRssCount++;
#endif
Status = NDIS_STATUS_SUCCESS;
break;
case OID_OFFLOAD_ENCAPSULATION:
XMPTRACE(XMP_DBG_OFLD, ("xmpSetInformation: offload encapsulation\n"));
if ( InformationBufferLength < sizeof(NDIS_OFFLOAD_ENCAPSULATION) )
{
BytesNeeded = sizeof(NDIS_OFFLOAD_ENCAPSULATION);
Status = NDIS_STATUS_INVALID_LENGTH;
break;
}
NdisMoveMemory(&pNicCtx->OffloadEncapsulation,
InformationBuffer,
sizeof(NDIS_OFFLOAD_ENCAPSULATION));
BytesRead = sizeof(NDIS_OFFLOAD_ENCAPSULATION);
Status = NDIS_STATUS_SUCCESS;
break;
case OID_GEN_INTERRUPT_MODERATION:
{
NDIS_INTERRUPT_MODERATION_PARAMETERS *pIntrModr;
if ( InformationBufferLength < sizeof(NDIS_INTERRUPT_MODERATION_PARAMETERS) )
{
BytesNeeded = sizeof(NDIS_INTERRUPT_MODERATION_PARAMETERS);
Status = NDIS_STATUS_INVALID_LENGTH;
break;
}
pIntrModr = (NDIS_INTERRUPT_MODERATION_PARAMETERS *) InformationBuffer;
if ( !XENAMP_NDIS_OBJECT_VALID(&pIntrModr->Header,
NDIS_INTERRUPT_MODERATION_PARAMETERS_REVISION_1,
NDIS_OBJECT_TYPE_DEFAULT,
sizeof(NDIS_INTERRUPT_MODERATION_PARAMETERS)) )
{
BytesRead = sizeof(NDIS_OBJECT_HEADER);
Status = NDIS_STATUS_INVALID_DATA;
break;
}
break;
}
case OID_TCP_OFFLOAD_PARAMETERS:
{
NDIS_OFFLOAD_PARAMETERS *pAdmin;
NDIS_STATUS_INDICATION StatusIndication;
ULONG size;
pAdmin = (NDIS_OFFLOAD_PARAMETERS *) InformationBuffer;
if ( InformationBufferLength < NDIS_SIZEOF_OFFLOAD_PARAMETERS_REVISION_1 )
{
BytesNeeded = NDIS_SIZEOF_OFFLOAD_PARAMETERS_REVISION_1;
Status = NDIS_STATUS_INVALID_LENGTH;
break;
}
if ( !XENAMP_NDIS_OBJECT_VALID(&pAdmin->Header,
NDIS_OFFLOAD_PARAMETERS_REVISION_1,
NDIS_OBJECT_TYPE_DEFAULT,
NDIS_SIZEOF_OFFLOAD_PARAMETERS_REVISION_1 ))
{
BytesRead = sizeof(NDIS_OBJECT_HEADER);
Status = NDIS_STATUS_INVALID_DATA;
break;
}
XMP_NIC_SET_ADMIN_OFFLOADS(pNicCtx, pAdmin);
xmpNicSetCkoFlags(pNicCtx);
xmpNicInitOffloadCapabilities(pNicCtx, &pNicCtx->OffloadCapabilities);
/* TODO: Generate event */
BytesRead = NDIS_SIZEOF_OFFLOAD_PARAMETERS_REVISION_1;
Status = NDIS_STATUS_SUCCESS;
XENAMP_NDIS_OBJECT_INIT(&StatusIndication.Header,
NDIS_OBJECT_TYPE_STATUS_INDICATION,
NDIS_STATUS_INDICATION_REVISION_1,
sizeof(NDIS_STATUS_INDICATION));
StatusIndication.SourceHandle = pNicCtx->hMPAdapter;
StatusIndication.PortNumber = 0;
StatusIndication.StatusCode = NDIS_STATUS_TASK_OFFLOAD_CURRENT_CONFIG;
StatusIndication.Flags = 0;
StatusIndication.DestinationHandle = NULL;
StatusIndication.RequestId = NdisRequest->RequestId;
StatusIndication.StatusBuffer = &pNicCtx->OffloadCapabilities;
StatusIndication.StatusBufferSize = sizeof(NDIS_OFFLOAD);
NdisMIndicateStatusEx(pNicCtx->hMPAdapter, &StatusIndication);
}
break;
case OID_GEN_HD_SPLIT_PARAMETERS:
{
NDIS_HD_SPLIT_PARAMETERS *pHdSplit;
pHdSplit = (NDIS_HD_SPLIT_PARAMETERS *) InformationBuffer;
if ( InformationBufferLength < NDIS_SIZEOF_HD_SPLIT_PARAMETERS_REVISION_1 )
{
BytesNeeded = NDIS_SIZEOF_HD_SPLIT_PARAMETERS_REVISION_1;
Status = NDIS_STATUS_INVALID_LENGTH;
break;
}
if ( !XENAMP_NDIS_OBJECT_VALID(&pHdSplit->Header,
NDIS_HD_SPLIT_PARAMETERS_REVISION_1,
NDIS_OBJECT_TYPE_DEFAULT,
NDIS_SIZEOF_HD_SPLIT_PARAMETERS_REVISION_1 ))
{
BytesRead = sizeof(NDIS_OBJECT_HEADER);
Status = NDIS_STATUS_INVALID_DATA;
break;
}
if( bit(pHdSplit->HDSplitCombineFlags, NDIS_HD_SPLIT_COMBINE_ALL_HEADERS) )
bis( pNicCtx->Flags, XMP_NIC_FLAGS_RX_SPLIT_COMBINE );
else
bic( pNicCtx->Flags, XMP_NIC_FLAGS_RX_SPLIT_COMBINE );
}
break;
default:
XMPTRACE(XMP_DBG_INFO, ("xmpSetInformation: unsupported OID=%lx\n", Oid));
Status = xmpDiagSetInformation(
pNicCtx,
Oid,
InformationBuffer,
InformationBufferLength,
&BytesRead,
&BytesNeeded);
break;
}
NdisRequest->DATA.SET_INFORMATION.BytesRead = BytesRead;
NdisRequest->DATA.SET_INFORMATION.BytesNeeded = BytesNeeded;
XMPTRACE(XMP_DBG_REQ, ("<== xmpSetInformation: Status=%x\n", Status));
return Status;
}
