static NDIS_STATUS
VenetSetupAdapter(PADAPTER a)
{
NDIS_STATUS rc;
NDIS_TIMER_CHARACTERISTICS timer;
a->lookAhead = NIC_MAX_LOOKAHEAD;
a->numTcbs = NIC_MAX_BUSY_SENDS;
a->refCount = 1;
VENET_SET_FLAG(a, VNET_DISCONNECTED);
QueueInit(&a->sendQueue);
NdisInitializeListHead(&a->recvFreeList);
NdisInitializeListHead(&a->recvToProcess);
NdisInitializeListHead(&a->tcbFree);
NdisInitializeListHead(&a->tcbBusy);
NdisAllocateSpinLock(&a->lock);
NdisAllocateSpinLock(&a->recvLock);
NdisAllocateSpinLock(&a->sendLock);
NdisInitializeEvent(&a->removeEvent);
NdisInitializeEvent(&a->sendEvent);
/* We use the opposite sense of the sendEvent,
* SET == No Tx in use
* UNSET == Tx in use
*/
NdisInitializeEvent(&a->sendEvent);
NdisSetEvent(&a->sendEvent);
/* Create Rest and receive timers. */
NdisZeroMemory(&timer, sizeof(NDIS_TIMER_CHARACTERISTICS));
timer.Header.Type = NDIS_OBJECT_TYPE_TIMER_CHARACTERISTICS;
timer.Header.Revision = NDIS_TIMER_CHARACTERISTICS_REVISION_1;
timer.Header.Size = sizeof(NDIS_TIMER_CHARACTERISTICS);
timer.AllocationTag = VNET;
timer.TimerFunction = VenetResetTimerDpc;
timer.FunctionContext = a;
rc = NdisAllocateTimerObject(a->adapterHandle, &timer, &a->resetTimer);
if (rc != NDIS_STATUS_SUCCESS)
goto done;
timer.TimerFunction = VenetReceiveTimerDpc;
rc = NdisAllocateTimerObject(a->adapterHandle, &timer, &a->recvTimer);
if (rc != NDIS_STATUS_SUCCESS)
goto done;
done:
return rc;
}
void mp8711init(_adapter *padapter)
{
struct mp_priv *pmppriv=&padapter->mppriv;
// MP8711 WorkItem
struct mp_wi_cntx *pmp_wi_cntx = &(pmppriv->wi_cntx);
pmp_wi_cntx->bmpdrv_unload =_FALSE;
pmp_wi_cntx->bmp_wi_progress=_FALSE;
pmp_wi_cntx->curractfunc=NULL;
NdisInitializeEvent(&(pmp_wi_cntx->mp_wi_evt));
NdisAllocateSpinLock(&(pmp_wi_cntx->mp_wi_lock));
NdisInitializeWorkItem(&(pmp_wi_cntx->mp_wi),
mp_wi_callback,// MP8711WorkItemCallback,
padapter);
// H2C/C2H
// padapter->nH2cCmdCnt = 0 ;
// NdisAllocateSpinLock(&(pAdapter->MpH2cSpinLock));
// NdisInitializeEvent(&(pAdapter->CMDCommEvent));
//New Arch.
init_mp_priv(&padapter->mppriv);
}
VOID
NPF_CloseOpenInstance(
IN POPEN_INSTANCE pOpen
)
{
ULONG i = 0;
NDIS_EVENT Event;
ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
NdisInitializeEvent(&Event);
NdisResetEvent(&Event);
NdisAcquireSpinLock(&pOpen->OpenInUseLock);
pOpen->ClosePending = TRUE;
while(pOpen->NumPendingIrps > 0)
{
NdisReleaseSpinLock(&pOpen->OpenInUseLock);
NdisWaitEvent(&Event,1);
NdisAcquireSpinLock(&pOpen->OpenInUseLock);
}
NdisReleaseSpinLock(&pOpen->OpenInUseLock);
}
NDIS_STATUS
shared_interrupt_register(OUT PNDIS_MINIPORT_INTERRUPT Interrupt,
NDIS_HANDLE MiniportAdapterHandle,
UINT InterruptVector,
UINT InterruptLevel,
BOOLEAN RequestIsr,
BOOLEAN SharedInterrupt,
NDIS_INTERRUPT_MODE InterruptMode,
shared_info_t *sh,
void (*isr_cb)(PBOOLEAN, PBOOLEAN, NDIS_HANDLE),
void *isr_arg,
void (*dpc_cb)(NDIS_HANDLE),
void *dpc_arg)
{
if (sh->BusType == NdisInterfacePci || sh->BusType == NdisInterfacePcMcia) {
return NdisMRegisterInterrupt(Interrupt, MiniportAdapterHandle,
InterruptVector, InterruptLevel,
RequestIsr,
SharedInterrupt,
InterruptMode);
}
else if (sh->BusType == NdisInterfaceSDIO) {
sh->isr_cb = isr_cb;
sh->isr_arg = isr_arg;
NdisInitializeEvent(&sh->dpc_event);
NdisResetEvent(&sh->dpc_event);
sh->dpc_handle = CreateThread(NULL, /* security atributes */
0, /* initial stack size */
(LPTHREAD_START_ROUTINE)shared_dpc_thread, /* Main() function */
sh, /* arg to reader thread */
0, /* creation flags */
&sh->dpc_thread_id); /* returned thread id */
if (!sh->dpc_handle)
return NDIS_STATUS_FAILURE;
if (bcmsdh_intr_reg(sh->sdh, shared_isr, sh))
return NDIS_STATUS_FAILURE;
}
sh->dpc_cb = dpc_cb;
sh->dpc_arg = dpc_arg;
/* Initilize the timer required to reschdule the DPC, if necessary */
NdisInitializeTimer(&sh->dpc_reshed_timer, shared_dpc_reschedule, (PVOID)sh);
return NDIS_STATUS_SUCCESS;
}
/* Initilize the timer required to reschdule the DPC, if necessary */
NdisInitializeTimer(&sh->dpc_reshed_timer, shared_dpc_reschedule, (PVOID)sh);
return NDIS_STATUS_SUCCESS;
}
#else /* !NDIS60 */
NDIS_STATUS
shared_interrupt_register(NDIS_HANDLE MiniportAdapterHandle,
shared_info_t *sh,
void (*isr_cb)(PBOOLEAN, PBOOLEAN, NDIS_HANDLE),
void *isr_arg,
void (*dpc_cb)(NDIS_HANDLE),
void *dpc_arg)
{
if (sh->BusType == NdisInterfaceSDIO) {
sh->isr_cb = isr_cb;
sh->isr_arg = isr_arg;
sh->dpc_handle = CreateThread(NULL, /* security atributes */
0, /* initial stack size */
(LPTHREAD_START_ROUTINE)shared_dpc_thread, /* Main() function */
sh, /* arg to reader thread */
0, /* creation flags */
&sh->dpc_thread_id); /* returned thread id */
if (!sh->dpc_handle)
{
printf("---> shared_interrupt_register error 1\n");
return NDIS_STATUS_FAILURE;
}
NdisInitializeEvent(&sh->dpc_event);
NdisResetEvent(&sh->dpc_event);
if (bcmsdh_intr_reg(sh->sdh, shared_isr, sh))
{
printf("---> shared_interrupt_register Error 2\n");
return NDIS_STATUS_FAILURE;
}
}
sh->dpc_cb = dpc_cb;
sh->dpc_arg = dpc_arg;
/* WM7 TODO: do we need this? */
/* Initilize the timer required to reschdule the DPC, if necessary */
NdisInitializeTimer(&sh->dpc_reshed_timer, shared_dpc_reschedule, (PVOID)sh);
return NDIS_STATUS_SUCCESS;
}
VOID
NPF_CloseBinding(
IN POPEN_INSTANCE pOpen)
{
NDIS_EVENT Event;
NDIS_STATUS Status;
ASSERT(pOpen != NULL);
ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
NdisInitializeEvent(&Event);
NdisResetEvent(&Event);
NdisAcquireSpinLock(&pOpen->AdapterHandleLock);
while(pOpen->AdapterHandleUsageCounter > 0)
{
NdisReleaseSpinLock(&pOpen->AdapterHandleLock);
NdisWaitEvent(&Event,1);
NdisAcquireSpinLock(&pOpen->AdapterHandleLock);
}
//
// now the UsageCounter is 0
//
while(pOpen->AdapterBindingStatus == ADAPTER_UNBINDING)
{
NdisReleaseSpinLock(&pOpen->AdapterHandleLock);
NdisWaitEvent(&Event,1);
NdisAcquireSpinLock(&pOpen->AdapterHandleLock);
}
//
// now the binding status is either bound or unbound
//
if (pOpen->AdapterBindingStatus == ADAPTER_UNBOUND)
{
NdisReleaseSpinLock(&pOpen->AdapterHandleLock);
return;
}
ASSERT(pOpen->AdapterBindingStatus == ADAPTER_BOUND);
pOpen->AdapterBindingStatus = ADAPTER_UNBINDING;
NdisReleaseSpinLock(&pOpen->AdapterHandleLock);
//
// do the release procedure
//
NdisResetEvent(&pOpen->NdisOpenCloseCompleteEvent);
// Close the adapter
NdisCloseAdapter(
&Status,
pOpen->AdapterHandle
);
if (Status == NDIS_STATUS_PENDING)
{
TRACE_MESSAGE(PACKET_DEBUG_LOUD, "Pending NdisCloseAdapter");
NdisWaitEvent(&pOpen->NdisOpenCloseCompleteEvent, 0);
}
else
{
TRACE_MESSAGE(PACKET_DEBUG_LOUD, "Not Pending NdisCloseAdapter");
}
NdisAcquireSpinLock(&pOpen->AdapterHandleLock);
pOpen->AdapterBindingStatus = ADAPTER_UNBOUND;
NdisReleaseSpinLock(&pOpen->AdapterHandleLock);
}
//------------------------------------------------------------------------------
tOplkError eventkcal_init(void)
{
ULONG desiredAccess = DELETE | SYNCHRONIZE;
OBJECT_ATTRIBUTES objectAttributes;
NTSTATUS ntStatus;
OPLK_MEMSET(&instance_l, 0, sizeof(tEventkCalInstance));
NdisInitializeEvent(&instance_l.kernelWaitEvent);
NdisInitializeEvent(&instance_l.userWaitEvent);
instance_l.userEventCount = 0;
instance_l.kernelEventCount = 0;
if (eventkcal_initQueueCircbuf(kEventQueueK2U) != kErrorOk)
goto Exit;
if (eventkcal_initQueueCircbuf(kEventQueueU2K) != kErrorOk)
goto Exit;
if (eventkcal_initQueueCircbuf(kEventQueueKInt) != kErrorOk)
goto Exit;
if (eventkcal_initQueueCircbuf(kEventQueueUInt) != kErrorOk)
goto Exit;
eventkcal_setSignalingCircbuf(kEventQueueK2U, signalUserEvent);
eventkcal_setSignalingCircbuf(kEventQueueU2K, signalKernelEvent);
eventkcal_setSignalingCircbuf(kEventQueueUInt, signalUserEvent);
eventkcal_setSignalingCircbuf(kEventQueueKInt, signalKernelEvent);
InitializeObjectAttributes(&objectAttributes,
NULL,
OBJ_KERNEL_HANDLE,
NULL,
NULL);
instance_l.fStopThread = FALSE;
ntStatus = PsCreateSystemThread(&instance_l.hThreadHandle,
desiredAccess,
&objectAttributes,
NULL,
NULL,
eventThread,
&instance_l);
if (ntStatus != STATUS_SUCCESS)
{
DEBUG_LVL_ERROR_TRACE("%s() Unable to create event thread 0x%X\n",
__func__,
ntStatus);
goto Exit;
}
instance_l.fInitialized = TRUE;
return kErrorOk;
Exit:
DEBUG_LVL_ERROR_TRACE("%s() Initialization error!\n", __func__);
eventkcal_exitQueueCircbuf(kEventQueueK2U);
eventkcal_exitQueueCircbuf(kEventQueueU2K);
eventkcal_exitQueueCircbuf(kEventQueueKInt);
eventkcal_exitQueueCircbuf(kEventQueueUInt);
return kErrorNoResource;
}
s32
MPT_InitializeAdapter(
IN PADAPTER pAdapter,
IN u8 Channel
)
{
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(pAdapter);
s32 rtStatus = _SUCCESS;
PMPT_CONTEXT pMptCtx = &pAdapter->mppriv.MptCtx;
u32 ledsetting;
struct mlme_priv *pmlmepriv = &pAdapter->mlmepriv;
//-------------------------------------------------------------------------
// HW Initialization for 8190 MPT.
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// SW Initialization for 8190 MP.
//-------------------------------------------------------------------------
pMptCtx->bMptDrvUnload = _FALSE;
pMptCtx->bMassProdTest = _FALSE;
pMptCtx->bMptIndexEven = _TRUE; //default gain index is -6.0db
pMptCtx->h2cReqNum = 0x0;
/* Init mpt event. */
#if 0 // for Windows
NdisInitializeEvent( &(pMptCtx->MptWorkItemEvent) );
NdisAllocateSpinLock( &(pMptCtx->MptWorkItemSpinLock) );
PlatformInitializeWorkItem(
Adapter,
&(pMptCtx->MptWorkItem),
(RT_WORKITEM_CALL_BACK)MPT_WorkItemCallback,
(PVOID)Adapter,
"MptWorkItem");
#endif
//init for BT MP
#ifdef CONFIG_RTL8723A
pMptCtx->bMPh2c_timeout = _FALSE;
pMptCtx->MptH2cRspEvent = _FALSE;
pMptCtx->MptBtC2hEvent = _FALSE;
_rtw_init_sema(&pMptCtx->MPh2c_Sema, 0);
_init_timer( &pMptCtx->MPh2c_timeout_timer, pAdapter->pnetdev, MPh2c_timeout_handle, pAdapter );
//before the reset bt patch command,set the wifi page 0's IO to BT mac reboot.
#endif
pMptCtx->bMptWorkItemInProgress = _FALSE;
pMptCtx->CurrMptAct = NULL;
//-------------------------------------------------------------------------
#if 1
// Don't accept any packets
rtw_write32(pAdapter, REG_RCR, 0);
#else
// Accept CRC error and destination address
//pHalData->ReceiveConfig |= (RCR_ACRC32|RCR_AAP);
//rtw_write32(pAdapter, REG_RCR, pHalData->ReceiveConfig);
rtw_write32(pAdapter, REG_RCR, 0x70000101);
#endif
#if 0
// If EEPROM or EFUSE is empty,we assign as RF 2T2R for MP.
if (pHalData->AutoloadFailFlag == TRUE)
{
pHalData->RF_Type = RF_2T2R;
}
#endif
//ledsetting = rtw_read32(pAdapter, REG_LEDCFG0);
//rtw_write32(pAdapter, REG_LEDCFG0, ledsetting & ~LED0DIS);
if(IS_HARDWARE_TYPE_8192DU(pAdapter))
{
rtw_write32(pAdapter, REG_LEDCFG0, 0x8888);
}
else
{
//rtw_write32(pAdapter, REG_LEDCFG0, 0x08080);
ledsetting = rtw_read32(pAdapter, REG_LEDCFG0);
#if defined (CONFIG_RTL8192C) || defined( CONFIG_RTL8192D )
rtw_write32(pAdapter, REG_LEDCFG0, ledsetting & ~LED0DIS);
#endif
}
PHY_IQCalibrate(pAdapter, _FALSE);
dm_CheckTXPowerTracking(&pHalData->odmpriv); //trigger thermal meter
PHY_LCCalibrate(pAdapter);
#ifdef CONFIG_PCI_HCI
PHY_SetRFPathSwitch(pAdapter, 1/*pHalData->bDefaultAntenna*/); //Wifi default use Main
#else
#ifdef CONFIG_RTL8192C
if (pHalData->BoardType == BOARD_MINICARD)
PHY_SetRFPathSwitch(pAdapter, 1/*pHalData->bDefaultAntenna*/); //default use Main
#endif
#endif
pMptCtx->backup0xc50 = (u1Byte)PHY_QueryBBReg(pAdapter, rOFDM0_XAAGCCore1, bMaskByte0);
pMptCtx->backup0xc58 = (u1Byte)PHY_QueryBBReg(pAdapter, rOFDM0_XBAGCCore1, bMaskByte0);
pMptCtx->backup0xc30 = (u1Byte)PHY_QueryBBReg(pAdapter, rOFDM0_RxDetector1, bMaskByte0);
#ifdef CONFIG_RTL8188E
pMptCtx->backup0x52_RF_A = (u1Byte)PHY_QueryRFReg(pAdapter, RF_PATH_A, RF_0x52, 0x000F0);
pMptCtx->backup0x52_RF_B = (u1Byte)PHY_QueryRFReg(pAdapter, RF_PATH_A, RF_0x52, 0x000F0);
#endif
//set ant to wifi side in mp mode
#ifdef CONFIG_RTL8723A
rtl8723a_InitAntenna_Selection(pAdapter);
#endif //CONFIG_RTL8723A
//set ant to wifi side in mp mode
rtw_write16(pAdapter, 0x870, 0x300);
rtw_write16(pAdapter, 0x860, 0x110);
if (pAdapter->registrypriv.mp_mode == 1)
pmlmepriv->fw_state = WIFI_MP_STATE;
return rtStatus;
}
/*
* --------------------------------------------------------------------------
* Utility function to issue the specified OID to the NDIS stack. The OID is
* directed towards the miniport edge of the extensible switch.
* An OID that gets issued may not complete immediately, and in such cases, the
* function waits for the OID to complete. Thus, this function must not be
* called at the PASSIVE_LEVEL.
* --------------------------------------------------------------------------
*/
static NDIS_STATUS
OvsIssueOidRequest(POVS_SWITCH_CONTEXT switchContext,
NDIS_REQUEST_TYPE oidType,
UINT32 oidRequestEnum,
PVOID oidInputBuffer,
UINT32 inputSize,
PVOID oidOutputBuffer,
UINT32 outputSize,
UINT32 *outputSizeNeeded)
{
NDIS_STATUS status;
PNDIS_OID_REQUEST oidRequest;
POVS_OID_CONTEXT oidContext;
ULONG OvsExtOidRequestId = 'ISVO';
DBG_UNREFERENCED_PARAMETER(inputSize);
DBG_UNREFERENCED_PARAMETER(oidInputBuffer);
OVS_LOG_TRACE("Enter: switchContext: %p, oidType: %d",
switchContext, oidType);
ASSERT(oidInputBuffer == NULL || inputSize != 0);
ASSERT(oidOutputBuffer == NULL || outputSize != 0);
ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
oidRequest = OvsAllocateMemoryWithTag(sizeof *oidRequest,
OVS_OID_POOL_TAG);
if (!oidRequest) {
status = NDIS_STATUS_RESOURCES;
goto done;
}
oidContext = OvsAllocateMemoryWithTag(sizeof *oidContext,
OVS_OID_POOL_TAG);
if (!oidContext) {
OvsFreeMemoryWithTag(oidRequest, OVS_OID_POOL_TAG);
status = NDIS_STATUS_RESOURCES;
goto done;
}
RtlZeroMemory(oidRequest, sizeof *oidRequest);
RtlZeroMemory(oidContext, sizeof *oidContext);
oidRequest->Header.Type = NDIS_OBJECT_TYPE_OID_REQUEST;
oidRequest->Header.Revision = NDIS_OID_REQUEST_REVISION_1;
oidRequest->Header.Size = NDIS_SIZEOF_OID_REQUEST_REVISION_1;
oidRequest->RequestType = oidType;
oidRequest->PortNumber = 0;
oidRequest->Timeout = 0;
oidRequest->RequestId = (PVOID)OvsExtOidRequestId;
switch(oidType) {
case NdisRequestQueryInformation:
oidRequest->DATA.QUERY_INFORMATION.Oid = oidRequestEnum;
oidRequest->DATA.QUERY_INFORMATION.InformationBuffer = oidOutputBuffer;
oidRequest->DATA.QUERY_INFORMATION.InformationBufferLength = outputSize;
break;
default:
ASSERT(FALSE);
status = NDIS_STATUS_INVALID_PARAMETER;
break;
}
/*
* We make use of the SourceReserved field in the OID request to store
* pointers to the original OID (if any), and also context for completion
* (if any).
*/
oidContext->status = NDIS_STATUS_SUCCESS;
NdisInitializeEvent(&oidContext->oidComplete);
OvsOidSetOrigRequest(oidRequest, NULL);
OvsOidSetContext(oidRequest, oidContext);
NdisInterlockedIncrement(&(switchContext->pendingOidCount));
status = NdisFOidRequest(switchContext->NdisFilterHandle, oidRequest);
if (status == NDIS_STATUS_PENDING) {
NdisWaitEvent(&oidContext->oidComplete, 0);
} else {
NdisInterlockedDecrement(&(switchContext->pendingOidCount));
}
if (status == NDIS_STATUS_INVALID_LENGTH ||
oidContext->status == NDIS_STATUS_INVALID_LENGTH) {
switch(oidType) {
case NdisRequestQueryInformation:
*outputSizeNeeded = oidRequest->DATA.QUERY_INFORMATION.BytesNeeded;
}
}
status = oidContext->status;
ASSERT(status != NDIS_STATUS_PENDING);
OvsFreeMemoryWithTag(oidRequest, OVS_OID_POOL_TAG);
OvsFreeMemoryWithTag(oidContext, OVS_OID_POOL_TAG);
done:
OVS_LOG_TRACE("Exit: status %8x.", status);
return status;
}
VOID
natpBindAdapter(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE BindContext,
IN PNDIS_STRING DeviceName,
IN PVOID SystemSpecific1,
IN PVOID SystemSpecific2
)
{
NDIS_HANDLE ConfigHandle = NULL;
PNDIS_CONFIGURATION_PARAMETER Param;
NDIS_STRING DeviceStr = UPPER_BINDINGS;
PFILTER_ADAPTER pAdapt = NULL;
NDIS_STATUS Sts;
UINT MediumIndex, i;
ULONG TotalSize;
WCHAR DevicePrefix[] = L"\\Device\\";
UNREFERENCED_PARAMETER(BindContext);
UNREFERENCED_PARAMETER(SystemSpecific2);
__try{
NdisOpenProtocolConfiguration(
Status,
&ConfigHandle,
SystemSpecific1
);
if (*Status != NDIS_STATUS_SUCCESS)
__leave;
NdisReadConfiguration(
Status,
&Param,
ConfigHandle,
&DeviceStr,
NdisParameterString
);
if (*Status != NDIS_STATUS_SUCCESS)
__leave;
TotalSize = sizeof(FILTER_ADAPTER) + Param->ParameterData.StringData.MaximumLength + DeviceName->MaximumLength;
NdisAllocateMemoryWithTag(&pAdapt, TotalSize, NAT_TAG);
if (NULL == pAdapt){
*Status = NDIS_STATUS_RESOURCES;
__leave;
}
NdisZeroMemory(pAdapt, TotalSize);
pAdapt->DeviceName.MaximumLength = Param->ParameterData.StringData.MaximumLength;
pAdapt->DeviceName.Length = Param->ParameterData.StringData.Length;
pAdapt->DeviceName.Buffer = (PWCHAR)((ULONG_PTR)pAdapt + sizeof(FILTER_ADAPTER));
NdisMoveMemory(
pAdapt->DeviceName.Buffer,
Param->ParameterData.StringData.Buffer,
Param->ParameterData.StringData.MaximumLength
);
if(sizeof(DevicePrefix) >= DeviceName->Length){
}else{
pAdapt->RootDeviceName.MaximumLength = DeviceName->MaximumLength;
pAdapt->RootDeviceName.Length = DeviceName->Length - sizeof(DevicePrefix) + sizeof(WCHAR);
pAdapt->RootDeviceName.Buffer = (PWCHAR)((ULONG_PTR)pAdapt + sizeof(FILTER_ADAPTER) + Param->ParameterData.StringData.MaximumLength);
NdisMoveMemory(
pAdapt->RootDeviceName.Buffer,
DeviceName->Buffer + sizeof(DevicePrefix)/sizeof(WCHAR) - 1,
DeviceName->MaximumLength - sizeof(DevicePrefix)/sizeof(WCHAR) + 1
);
}
NdisInitializeEvent(&pAdapt->Event);
NdisAllocateSpinLock(&pAdapt->Lock);
natInitControlBlock(&pAdapt->ctrl);
NdisAllocatePacketPoolEx(
Status,
&pAdapt->SndPP1,
MIN_PACKET_POOL_SIZE,
MAX_PACKET_POOL_SIZE,
PROTOCOL_RESERVED_SIZE_IN_PACKET
);
if (*Status != NDIS_STATUS_SUCCESS)
__leave;
NdisAllocatePacketPoolEx(
Status,
&pAdapt->SndPP2,
MIN_PACKET_POOL_SIZE,
MAX_PACKET_POOL_SIZE,
PROTOCOL_RESERVED_SIZE_IN_PACKET
);
if (*Status != NDIS_STATUS_SUCCESS)
__leave;
NdisAllocateBufferPool(
Status,
&pAdapt->SndBP,
MIN_PACKET_POOL_SIZE
);
if ( *Status != NDIS_STATUS_SUCCESS )
__leave;
NdisAllocatePacketPoolEx(
Status,
&pAdapt->RcvPP1,
MIN_PACKET_POOL_SIZE,
MAX_PACKET_POOL_SIZE - MIN_PACKET_POOL_SIZE,
PROTOCOL_RESERVED_SIZE_IN_PACKET
);
if (*Status != NDIS_STATUS_SUCCESS)
__leave;
NdisAllocatePacketPoolEx(
Status,
&pAdapt->RcvPP2,
MIN_PACKET_POOL_SIZE,
MAX_PACKET_POOL_SIZE - MIN_PACKET_POOL_SIZE,
PROTOCOL_RESERVED_SIZE_IN_PACKET
);
if (*Status != NDIS_STATUS_SUCCESS)
__leave;
NdisAllocateBufferPool(
Status,
&pAdapt->RcvBP,
MIN_PACKET_POOL_SIZE
);
if ( *Status != NDIS_STATUS_SUCCESS )
__leave;
NdisOpenAdapter(
Status,
&Sts,
&pAdapt->BindingHandle,
&MediumIndex,
MediumArray,
sizeof(MediumArray)/sizeof(NDIS_MEDIUM),
ProtHandle,
pAdapt,
DeviceName,
0,NULL
);
if (*Status == NDIS_STATUS_PENDING){
NdisWaitEvent(&pAdapt->Event, 0);
*Status = pAdapt->Status;
}
if (*Status != NDIS_STATUS_SUCCESS)
__leave;
pAdapt->Medium = MediumArray[MediumIndex];
pAdapt->MiniportInitPending = TRUE;
NdisInitializeEvent(&pAdapt->MiniportInitEvent);
*Status =
NdisIMInitializeDeviceInstanceEx(
DriverHandle,
&pAdapt->DeviceName,
pAdapt
);
if (*Status != NDIS_STATUS_SUCCESS)
__leave;
StartQueryInfo( pAdapt );
} __finally{
}
if (ConfigHandle != NULL)
NdisCloseConfiguration(ConfigHandle);
if(NDIS_STATUS_SUCCESS != *Status){
if (pAdapt != NULL){
if (pAdapt->BindingHandle != NULL){
NDIS_STATUS LocalStatus;
NdisResetEvent(&pAdapt->Event);
NdisCloseAdapter(&LocalStatus, pAdapt->BindingHandle);
pAdapt->BindingHandle = NULL;
if (LocalStatus == NDIS_STATUS_PENDING){
NdisWaitEvent(&pAdapt->Event, 0);
LocalStatus = pAdapt->Status;
}
}
natFreeAllItems(&pAdapt->ctrl);
natFreeAllFwSessionsAndRules(&pAdapt->ctrl);
for(i = 0;i<FLT_FW_SESSION_HASH_TBL_SZ;i++)
NdisFreeSpinLock(pAdapt->ctrl.FwSessionLocks + i);
NdisFreeSpinLock(&pAdapt->ctrl.IcmpRuleLock);
NdisFreeSpinLock(&pAdapt->ctrl.UdpRuleLock);
NdisFreeSpinLock(&pAdapt->ctrl.TcpRuleLock);
natmFreeAllPacketPools(pAdapt);
NdisFreeSpinLock(&pAdapt->Lock);
NdisFreeMemory(pAdapt, 0, 0);
pAdapt = NULL;
}
}
}
BOOL
hifDeviceInserted(SD_DEVICE_HANDLE *handle)
{
HIF_DEVICE *device;
SD_API_STATUS sdStatus;
SDIO_CARD_INFO sdioInfo;
SD_HOST_BLOCK_CAPABILITY blockCap;
SD_CARD_RCA cardRCA;
A_UCHAR rgucTuple[SD_CISTPLE_MAX_BODY_SIZE];
PSD_CISTPL_FUNCE_FUNCTION pFunce = (PSD_CISTPL_FUNCE_FUNCTION) rgucTuple;
A_UINT32 ulLength = 0;
A_UCHAR ucRegVal;
A_BOOL blockMode;
SD_CARD_INTERFACE ci;
SD_IO_FUNCTION_ENABLE_INFO fData;
DWORD bData;
//SDCONFIG_FUNC_SLOT_CURRENT_DATA slotCurrent;
#ifdef CEPC
HANDLE hThread;
#endif //CEPC
device = addHifDevice(handle);
HIF_DEBUG_PRINTF(ATH_LOG_TRC, "hifDeviceInserted: Enter\n");
/* Enable SDIO [dragon] function */
fData.Interval = DEFAULT_SDIO_FUNCTION_RETRY_TIMEOUT;
fData.ReadyRetryCount = DEFAULT_SDIO_FUNCTION_RETRIES;
sdStatus = SDSetCardFeature (handle, SD_IO_FUNCTION_ENABLE,
&fData, sizeof(fData));
if (!SD_API_SUCCESS(sdStatus)) {
return FALSE;
}
/*
* Issue commands to get the manufacturer ID and stuff and compare it
* against the rev Id derived from the ID registered during the
* initialization process. Report the device only in the case there
* is a match.
*/
sdStatus = SDCardInfoQuery(handle, SD_INFO_SDIO,
&sdioInfo, sizeof(sdioInfo));
if (!SD_API_SUCCESS(sdStatus)) {
return FALSE;
}
funcNo = sdioInfo.FunctionNumber;
sdStatus = SDCardInfoQuery(handle, SD_INFO_REGISTER_RCA,
&cardRCA, sizeof(cardRCA));
HIF_DEBUG_PRINTF(ATH_LOG_INF, "Card RCA is 0x%x\n", cardRCA);
/* Configure the SDIO Bus Width */
memset(&ci, 0, sizeof(ci));
if (sdio1bitmode) {
ci.InterfaceMode = SD_INTERFACE_SD_MMC_1BIT;
} else {
ci.InterfaceMode = SD_INTERFACE_SD_4BIT;
}
if (sdiobusspeedlow) {
ci.ClockRate = SDIO_CLOCK_FREQUENCY_REDUCED;
} else {
ci.ClockRate = SDIO_CLOCK_FREQUENCY_DEFAULT;
}
sdStatus = SDSetCardFeature(handle, SD_SET_CARD_INTERFACE,
&ci, sizeof(ci));
if (!SD_API_SUCCESS(sdStatus)) {
return FALSE;
}
/* Check if the target supports block mode */
sdStatus = SDReadWriteRegistersDirect(handle, SD_IO_READ,
0, 0x08, FALSE, &ucRegVal, 1);
if (!SD_API_SUCCESS(sdStatus)) {
return FALSE;
}
blockMode = (ucRegVal & 0x2) >> 1; // SMB is bit 1
if (!blockMode) {
HIF_DEBUG_PRINTF(ATH_LOG_ERR, "Function does not support block mode\n");
return FALSE;
} else {
HIF_DEBUG_PRINTF(ATH_LOG_TRC, "Function supports block mode\n");
blockCap.ReadBlocks = blockCap.WriteBlocks = 8;
blockCap.ReadBlockSize = blockCap.WriteBlockSize = HIF_MBOX_BLOCK_SIZE;
sdStatus = SDCardInfoQuery(handle, SD_INFO_HOST_BLOCK_CAPABILITY,
&blockCap, sizeof(blockCap));
if (blockCap.ReadBlockSize < blockCap.WriteBlockSize) {
maxBlockSize = blockCap.ReadBlockSize;
} else {
maxBlockSize = blockCap.WriteBlockSize;
}
if (blockCap.ReadBlocks < blockCap.WriteBlocks) {
maxBlocks = blockCap.ReadBlocks;
} else {
maxBlocks = blockCap.WriteBlocks;
}
sdStatus = SDGetTuple(handle, SD_CISTPL_FUNCE, NULL, &ulLength, FALSE);
if ((!SD_API_SUCCESS(sdStatus)) || (ulLength > sizeof(rgucTuple)) ) {
return FALSE;
}
sdStatus = SDGetTuple(handle, SD_CISTPL_FUNCE, rgucTuple, &ulLength, FALSE);
if ((!SD_API_SUCCESS(sdStatus)) ||
(pFunce->bType != SD_CISTPL_FUNCE_FUNCTION_TYPE) ) {
return FALSE;
}
if (maxBlockSize > pFunce->wMaxBlkSize) {
maxBlockSize = pFunce->wMaxBlkSize;
}
bData = (DWORD)maxBlockSize;
sdStatus = SDSetCardFeature(handle,
SD_IO_FUNCTION_SET_BLOCK_SIZE,
&bData, sizeof(bData));
}
HIF_DEBUG_PRINTF(ATH_LOG_TRC,
"Bytes Per Block: %d bytes, Block Count:%d \n",
maxBlockSize, maxBlocks);
/* Allocate the slot current */
/* Kowsalya : commenting as there is no equivalent for this in WINCE */
/*
status = SDLIB_GetDefaultOpCurrent(handle, &slotCurrent.SlotCurrent);
if (SDIO_SUCCESS(status)) {
HIF_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Allocating Slot current: %d mA\n",
slotCurrent.SlotCurrent));
status = SDLIB_IssueConfig(handle, SDCONFIG_FUNC_ALLOC_SLOT_CURRENT,
&slotCurrent, sizeof(slotCurrent));
if (!SDIO_SUCCESS(status)) {
HIF_DEBUG_PRINTF(ATH_DEBUG_ERROR,
("Failed to allocate slot current %d\n", status));
return FALSE;
}
}
*/
/* Inform HTC */
if ((htcCallbacks.deviceInsertedHandler(device)) != A_OK) {
HIF_DEBUG_PRINTF(ATH_LOG_TRC, "Device rejected\n");
return FALSE;
}
#ifdef CEPC
NdisInitializeEvent(&hifIRQEvent);
hThread = CreateThread(NULL, 0,
hifIRQThread, (LPVOID)handle, 0, NULL);
CeSetThreadPriority(hThread, 200);
CloseHandle(hThread);
#endif //CEPC
return TRUE;
}
static BOOL SetupSDIOInterface(HIF_DEVICE *device)
{
SD_API_STATUS sdStatus;
SDIO_CARD_INFO sdioInfo;
SD_HOST_BLOCK_CAPABILITY blockCap;
SD_CARD_RCA cardRCA;
A_UCHAR rgucTuple[SD_CISTPLE_MAX_BODY_SIZE];
PSD_CISTPL_FUNCE_FUNCTION pFunce = (PSD_CISTPL_FUNCE_FUNCTION) rgucTuple;
A_UINT32 ulLength = 0;
A_UCHAR ucRegVal;
A_BOOL blockMode;
SD_CARD_INTERFACE ci;
SD_IO_FUNCTION_ENABLE_INFO fData;
DWORD bData;
BOOL doInterfaceChange = FALSE;
SD_DEVICE_HANDLE handle;
int count;
handle = device->handle;
NDIS_DEBUG_PRINTF(1, "%s() : Enter + \r\n",__FUNCTION__);
/* Enable SDIO [dragon] function */
fData.Interval = DEFAULT_SDIO_FUNCTION_RETRY_TIMEOUT;
fData.ReadyRetryCount = DEFAULT_SDIO_FUNCTION_RETRIES;
sdStatus = SDSetCardFeature (handle, SD_IO_FUNCTION_ENABLE,
&fData, sizeof(fData));
if (!SD_API_SUCCESS(sdStatus)) {
NDIS_DEBUG_PRINTF(DBG_ERR, "SDSetCardFeature (0x%x)\n", sdStatus);
return FALSE;
}
/*
* Issue commands to get the manufacturer ID and stuff and compare it
* against the rev Id derived from the ID registered during the
* initialization process. Report the device only in the case there
* is a match.
*/
sdStatus = SDCardInfoQuery(handle, SD_INFO_SDIO,
&sdioInfo, sizeof(sdioInfo));
if (!SD_API_SUCCESS(sdStatus)) {
NDIS_DEBUG_PRINTF(DBG_ERR, "SDCardInfoQuery (0x%x) \r\n", sdStatus);
return FALSE;
}
funcNo = sdioInfo.FunctionNumber;
sdStatus = SDCardInfoQuery(handle, SD_INFO_REGISTER_RCA,
&cardRCA, sizeof(cardRCA));
NDIS_DEBUG_PRINTF(1, "Card RCA is 0x%x \r\n", cardRCA);
/* Configure the SDIO Bus Width */
memset(&ci, 0, sizeof(ci));
/* get current interface settings */
sdStatus = SDCardInfoQuery(handle, SD_INFO_CARD_INTERFACE,
&ci, sizeof(ci));
if (!SD_API_SUCCESS(sdStatus)) {
NDIS_DEBUG_PRINTF(DBG_ERR, "%s() : ERR, SDCardInfoQuery Fail !!\r\n",__FUNCTION__);
return FALSE;
}
//DebugBreak();
#ifdef HIF_SDIO_1BIT
/* force to 1 bit mode */
sdio1bitmode = 1;
#endif
if (sdio1bitmode && (ci.InterfaceMode != SD_INTERFACE_SD_MMC_1BIT)) {
/* force to 1 bit mode */
ci.InterfaceMode = SD_INTERFACE_SD_MMC_1BIT;
doInterfaceChange = TRUE;
}
/* check for forced low speed operation */
if (sdiobusspeedlow) {
/* only set the lower of our current rate and our desired reduced rate,
* otherwise we run at a clock rate that the bus driver setup for us */
ci.ClockRate = min(ci.ClockRate, SDIO_CLOCK_FREQUENCY_REDUCED);
doInterfaceChange = TRUE;
}
if (doInterfaceChange) {
sdStatus = SDSetCardFeature(handle, SD_SET_CARD_INTERFACE,
&ci, sizeof(ci));
if (!SD_API_SUCCESS(sdStatus)) {
NDIS_DEBUG_PRINTF(DBG_ERR, "%s() : SDSetCardFeature Fail !!\r\n",__FUNCTION__);
return FALSE;
}
}
NDIS_DEBUG_PRINTF(DBG_TRACE, ("** SDIO Interface : %s : %d (%s)\r\n",
doInterfaceChange ? "Overridden to" : "Set by busdriver",
ci.ClockRate,
(ci.InterfaceMode == SD_INTERFACE_SD_MMC_1BIT) ?
"1-bit" : "4-bit"));
/* save card interface mode to restore later */
A_MEMCPY(&device->CardInterface, &ci, sizeof(ci));
/* Check if the target supports block mode */
sdStatus = SDReadWriteRegistersDirect(handle, SD_IO_READ,
0, 0x08, FALSE, &ucRegVal, 1);
if (!SD_API_SUCCESS(sdStatus)) {
NDIS_DEBUG_PRINTF(DBG_ERR, "%s() : SDReadWriteRegistersDirect Fail !!\r\n",__FUNCTION__);
return FALSE;
}
blockMode = (ucRegVal & 0x2) >> 1; // SMB is bit 1
if (!blockMode) {
NDIS_DEBUG_PRINTF(DBG_ERR, ("Function does not support block mode\n"));
return FALSE;
} else {
NDIS_DEBUG_PRINTF(DBG_TRACE, ("Function supports block mode \r\n"));
blockCap.ReadBlocks = blockCap.WriteBlocks = 8;
blockCap.ReadBlockSize = blockCap.WriteBlockSize = HIF_MBOX_BLOCK_SIZE;
sdStatus = SDCardInfoQuery(handle, SD_INFO_HOST_BLOCK_CAPABILITY,
&blockCap, sizeof(blockCap));
if (blockCap.ReadBlockSize < blockCap.WriteBlockSize) {
maxBlockSize = blockCap.ReadBlockSize;
} else {
maxBlockSize = blockCap.WriteBlockSize;
}
if (blockCap.ReadBlocks < blockCap.WriteBlocks) {
maxBlocks = blockCap.ReadBlocks;
} else {
maxBlocks = blockCap.WriteBlocks;
}
sdStatus = SDGetTuple(handle, SD_CISTPL_FUNCE, NULL, &ulLength, FALSE);
if ((!SD_API_SUCCESS(sdStatus)) || (ulLength > sizeof(rgucTuple)) ) {
return FALSE;
}
sdStatus = SDGetTuple(handle, SD_CISTPL_FUNCE, rgucTuple, &ulLength, FALSE);
if ((!SD_API_SUCCESS(sdStatus)) ||
(pFunce->bType != SD_CISTPL_FUNCE_FUNCTION_TYPE) ) {
return FALSE;
}
if (maxBlockSize > pFunce->wMaxBlkSize) {
maxBlockSize = pFunce->wMaxBlkSize;
}
bData = (DWORD)maxBlockSize;
sdStatus = SDSetCardFeature(handle,
SD_IO_FUNCTION_SET_BLOCK_SIZE,
&bData, sizeof(bData));
}
NDIS_DEBUG_PRINTF(DBG_TRACE, "Bytes Per Block: %d bytes, Block Count:%d \r\n", maxBlockSize, maxBlocks);
/* Initialize the bus requests to be used later */
A_MEMZERO(device->busRequest, sizeof(device->busRequest));
for (count = 0; count < BUS_REQUEST_MAX_NUM; count ++) {
NdisInitializeEvent(&device->busRequest[count].sem_req);
hifFreeBusRequest(device, &device->busRequest[count]);
}
return TRUE;
}
// Returns with reference count initialized to one.
PTAP_ADAPTER_CONTEXT
tapAdapterContextAllocate(__in NDIS_HANDLE MiniportAdapterHandle) {
PTAP_ADAPTER_CONTEXT adapter = NULL;
adapter = (PTAP_ADAPTER_CONTEXT)NdisAllocateMemoryWithTagPriority(
GlobalData.NdisDriverHandle, sizeof(TAP_ADAPTER_CONTEXT), TAP_ADAPTER_TAG,
NormalPoolPriority);
if (adapter) {
NET_BUFFER_LIST_POOL_PARAMETERS nblPoolParameters = {0};
NdisZeroMemory(adapter, sizeof(TAP_ADAPTER_CONTEXT));
adapter->MiniportAdapterHandle = MiniportAdapterHandle;
// Initialize cancel-safe IRP queue
tapIrpCsqInitialize(&adapter->PendingReadIrpQueue);
// Initialize TAP send packet queue.
tapPacketQueueInitialize(&adapter->SendPacketQueue);
// Allocate the adapter lock.
NdisAllocateSpinLock(&adapter->AdapterLock);
// NBL pool for making TAP receive indications.
NdisZeroMemory(&nblPoolParameters, sizeof(NET_BUFFER_LIST_POOL_PARAMETERS));
// Initialize event used to determine when all receive NBLs have been returned.
NdisInitializeEvent(&adapter->ReceiveNblInFlightCountZeroEvent);
nblPoolParameters.Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
nblPoolParameters.Header.Revision = NET_BUFFER_LIST_POOL_PARAMETERS_REVISION_1;
nblPoolParameters.Header.Size = NDIS_SIZEOF_NET_BUFFER_LIST_POOL_PARAMETERS_REVISION_1;
nblPoolParameters.ProtocolId = NDIS_PROTOCOL_ID_DEFAULT;
nblPoolParameters.ContextSize = 0;
// nblPoolParameters.ContextSize = sizeof(RX_NETBUFLIST_RSVD);
nblPoolParameters.fAllocateNetBuffer = TRUE;
nblPoolParameters.PoolTag = TAP_RX_NBL_TAG;
#pragma warning(suppress : 28197)
adapter->ReceiveNblPool =
NdisAllocateNetBufferListPool(adapter->MiniportAdapterHandle, &nblPoolParameters);
if (adapter->ReceiveNblPool == NULL) {
DEBUGP(("[TAP] Couldn't allocate adapter receive NBL pool\n"));
NdisFreeMemory(adapter, 0, 0);
}
// Add initial reference. Normally removed in AdapterHalt.
adapter->RefCount = 1;
// Safe for multiple removes.
NdisInitializeListHead(&adapter->AdapterListLink);
//
// The miniport adapter is initially powered up
//
adapter->CurrentPowerState = NdisDeviceStateD0;
}
return adapter;
}
NDIS_STATUS
SxLibIssueOidRequest(
_In_ PSX_SWITCH_OBJECT Switch,
_In_ NDIS_REQUEST_TYPE RequestType,
_In_ NDIS_OID Oid,
_In_opt_ PVOID InformationBuffer,
_In_ ULONG InformationBufferLength,
_In_ ULONG OutputBufferLength,
_In_ ULONG MethodId,
_In_ UINT Timeout,
_Out_ PULONG BytesNeeded
)
{
NDIS_STATUS status;
PSX_OID_REQUEST oidRequest;
PNDIS_OID_REQUEST ndisOidRequest;
ULONG bytesNeeded;
BOOLEAN asyncCompletion;
status = NDIS_STATUS_SUCCESS;
oidRequest = NULL;
bytesNeeded = 0;
asyncCompletion = FALSE;
NdisInterlockedIncrement(&Switch->PendingOidCount);
if (Switch->ControlFlowState != SxSwitchAttached)
{
status = NDIS_STATUS_CLOSING;
goto Cleanup;
}
//
// Dynamically allocate filter request so that we can handle asynchronous
// completion.
//
oidRequest = (PSX_OID_REQUEST)ExAllocatePoolWithTag(NonPagedPoolNx,
sizeof(SX_OID_REQUEST),
SxExtAllocationTag);
if (oidRequest == NULL)
{
goto Cleanup;
}
NdisZeroMemory(oidRequest, sizeof(SX_OID_REQUEST));
ndisOidRequest = &oidRequest->NdisOidRequest;
NdisInitializeEvent(&oidRequest->ReqEvent);
ndisOidRequest->Header.Type = NDIS_OBJECT_TYPE_OID_REQUEST;
ndisOidRequest->Header.Revision = NDIS_OID_REQUEST_REVISION_1;
ndisOidRequest->Header.Size = sizeof(NDIS_OID_REQUEST);
ndisOidRequest->RequestType = RequestType;
ndisOidRequest->Timeout = Timeout;
switch (RequestType)
{
case NdisRequestQueryInformation:
ndisOidRequest->DATA.QUERY_INFORMATION.Oid = Oid;
ndisOidRequest->DATA.QUERY_INFORMATION.InformationBuffer =
InformationBuffer;
ndisOidRequest->DATA.QUERY_INFORMATION.InformationBufferLength =
InformationBufferLength;
break;
case NdisRequestSetInformation:
ndisOidRequest->DATA.SET_INFORMATION.Oid = Oid;
ndisOidRequest->DATA.SET_INFORMATION.InformationBuffer =
InformationBuffer;
ndisOidRequest->DATA.SET_INFORMATION.InformationBufferLength =
InformationBufferLength;
break;
case NdisRequestMethod:
ndisOidRequest->DATA.METHOD_INFORMATION.Oid = Oid;
ndisOidRequest->DATA.METHOD_INFORMATION.MethodId = MethodId;
ndisOidRequest->DATA.METHOD_INFORMATION.InformationBuffer =
InformationBuffer;
ndisOidRequest->DATA.METHOD_INFORMATION.InputBufferLength =
InformationBufferLength;
ndisOidRequest->DATA.METHOD_INFORMATION.OutputBufferLength =
OutputBufferLength;
break;
default:
NT_ASSERT(FALSE);
break;
}
ndisOidRequest->RequestId = (PVOID)SxExtOidRequestId;
status = NdisFOidRequest(Switch->NdisFilterHandle, ndisOidRequest);
if (status == NDIS_STATUS_PENDING)
{
asyncCompletion = TRUE;
NdisWaitEvent(&oidRequest->ReqEvent, 0);
}
else
{
SxpNdisCompleteInternalOidRequest(Switch, ndisOidRequest, status);
}
bytesNeeded = oidRequest->BytesNeeded;
status = oidRequest->Status;
Cleanup:
if (BytesNeeded != NULL)
{
*BytesNeeded = bytesNeeded;
}
if (!asyncCompletion)
{
NdisInterlockedDecrement(&Switch->PendingOidCount);
}
if (oidRequest != NULL)
{
ExFreePoolWithTag(oidRequest, SxExtAllocationTag);
}
return status;
}
NTSTATUS NPF_Open(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
PDEVICE_EXTENSION DeviceExtension;
POPEN_INSTANCE Open;
PIO_STACK_LOCATION IrpSp;
NDIS_STATUS Status;
NDIS_STATUS ErrorStatus;
UINT i;
PUCHAR tpointer;
PLIST_ENTRY PacketListEntry;
NTSTATUS returnStatus;
//
// Old registry based WinPcap names
//
// WCHAR EventPrefix[MAX_WINPCAP_KEY_CHARS];
// UINT RegStrLen;
TRACE_ENTER();
DeviceExtension = DeviceObject->DeviceExtension;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
// allocate some memory for the open structure
Open=ExAllocatePoolWithTag(NonPagedPool, sizeof(OPEN_INSTANCE), '0OWA');
if (Open==NULL) {
// no memory
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(
Open,
sizeof(OPEN_INSTANCE)
);
//
// Old registry based WinPcap names
//
// //
// // Get the Event names base from the registry
// //
// RegStrLen = sizeof(EventPrefix)/sizeof(EventPrefix[0]);
//
// NPF_QueryWinpcapRegistryString(NPF_EVENTS_NAMES_REG_KEY_WC,
// EventPrefix,
// RegStrLen,
// NPF_EVENTS_NAMES_WIDECHAR);
//
Open->DeviceExtension=DeviceExtension;
// Allocate a packet pool for our xmit and receive packets
NdisAllocatePacketPool(
&Status,
&Open->PacketPool,
TRANSMIT_PACKETS,
sizeof(PACKET_RESERVED));
if (Status != NDIS_STATUS_SUCCESS) {
TRACE_MESSAGE(PACKET_DEBUG_LOUD, "Failed to allocate packet pool");
ExFreePool(Open);
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INSUFFICIENT_RESOURCES;
}
NdisInitializeEvent(&Open->WriteEvent);
NdisInitializeEvent(&Open->NdisRequestEvent);
NdisInitializeEvent(&Open->NdisWriteCompleteEvent);
NdisInitializeEvent(&Open->DumpEvent);
NdisAllocateSpinLock(&Open->MachineLock);
NdisAllocateSpinLock(&Open->WriteLock);
Open->WriteInProgress = FALSE;
for (i = 0; i < g_NCpu; i++)
{
NdisAllocateSpinLock(&Open->CpuData[i].BufferLock);
}
NdisInitializeEvent(&Open->NdisOpenCloseCompleteEvent);
// list to hold irp's want to reset the adapter
InitializeListHead(&Open->ResetIrpList);
// Initialize the request list
KeInitializeSpinLock(&Open->RequestSpinLock);
InitializeListHead(&Open->RequestList);
#ifdef HAVE_BUGGY_TME_SUPPORT
// Initializes the extended memory of the NPF machine
Open->mem_ex.buffer = ExAllocatePoolWithTag(NonPagedPool, DEFAULT_MEM_EX_SIZE, '2OWA');
if((Open->mem_ex.buffer) == NULL)
{
//
// no memory
//
ExFreePool(Open);
Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_INSUFFICIENT_RESOURCES;
}
Open->mem_ex.size = DEFAULT_MEM_EX_SIZE;
RtlZeroMemory(Open->mem_ex.buffer, DEFAULT_MEM_EX_SIZE);
#endif //HAVE_BUGGY_TME_SUPPORT
//
// Initialize the open instance
//
Open->bpfprogram = NULL; //reset the filter
Open->mode = MODE_CAPT;
Open->Nbytes.QuadPart = 0;
Open->Npackets.QuadPart = 0;
Open->Nwrites = 1;
Open->Multiple_Write_Counter = 0;
Open->MinToCopy = 0;
Open->TimeOut.QuadPart = (LONGLONG)1;
Open->DumpFileName.Buffer = NULL;
Open->DumpFileHandle = NULL;
#ifdef HAVE_BUGGY_TME_SUPPORT
Open->tme.active = TME_NONE_ACTIVE;
#endif // HAVE_BUGGY_TME_SUPPORT
Open->DumpLimitReached = FALSE;
Open->MaxFrameSize = 0;
Open->WriterSN=0;
Open->ReaderSN=0;
Open->Size=0;
Open->SkipSentPackets = FALSE;
Open->ReadEvent = NULL;
//
// we need to keep a counter of the pending IRPs
// so that when the IRP_MJ_CLEANUP dispatcher gets called,
// we can wait for those IRPs to be completed
//
Open->NumPendingIrps = 0;
Open->ClosePending = FALSE;
NdisAllocateSpinLock(&Open->OpenInUseLock);
//
//allocate the spinlock for the statistic counters
//
NdisAllocateSpinLock(&Open->CountersLock);
//
// link up the request stored in our open block
//
for (i = 0 ; i < MAX_REQUESTS ; i++ )
{
NdisInitializeEvent(&Open->Requests[i].InternalRequestCompletedEvent);
ExInterlockedInsertTailList(
&Open->RequestList,
&Open->Requests[i].ListElement,
&Open->RequestSpinLock);
}
NdisResetEvent(&Open->NdisOpenCloseCompleteEvent);
//
// set the proper binding flags before trying to open the MAC
//
Open->AdapterBindingStatus = ADAPTER_BOUND;
Open->AdapterHandleUsageCounter = 0;
NdisAllocateSpinLock(&Open->AdapterHandleLock);
//
// Try to open the MAC
//
TRACE_MESSAGE2(PACKET_DEBUG_LOUD,"Opening the device %ws, BindingContext=%p",DeviceExtension->AdapterName.Buffer, Open);
returnStatus = STATUS_SUCCESS;
NdisOpenAdapter(
&Status,
&ErrorStatus,
&Open->AdapterHandle,
&Open->Medium,
MediumArray,
NUM_NDIS_MEDIA,
g_NdisProtocolHandle,
Open,
&DeviceExtension->AdapterName,
0,
NULL);
TRACE_MESSAGE1(PACKET_DEBUG_LOUD,"Opened the device, Status=%x",Status);
if (Status == NDIS_STATUS_PENDING)
{
NdisWaitEvent(&Open->NdisOpenCloseCompleteEvent, 0);
if (!NT_SUCCESS(Open->OpenCloseStatus))
{
returnStatus = Open->OpenCloseStatus;
}
else
{
returnStatus = STATUS_SUCCESS;
}
}
else
{
//
// request not pending, we know the result, and OpenComplete has not been called.
//
if (Status == NDIS_STATUS_SUCCESS)
{
returnStatus = STATUS_SUCCESS;
}
else
{
//
// this is not completely correct, as we are converting an NDIS_STATUS to a NTSTATUS
//
returnStatus = Status;
}
}
if (returnStatus == STATUS_SUCCESS)
{
ULONG localNumOpenedInstances;
//
// complete the open
//
localNumOpenedInstances = InterlockedIncrement(&g_NumOpenedInstances);
TRACE_MESSAGE1(PACKET_DEBUG_LOUD, "Opened Instances: %u", localNumOpenedInstances);
// Get the absolute value of the system boot time.
// This is used for timestamp conversion.
TIME_SYNCHRONIZE(&G_Start_Time);
returnStatus = NPF_GetDeviceMTU(Open, Irp, &Open->MaxFrameSize);
if (!NT_SUCCESS(returnStatus))
{
//
// Close the binding
//
NPF_CloseBinding(Open);
}
}
if (!NT_SUCCESS(returnStatus))
{
NPF_ReleaseOpenInstanceResources(Open);
//
// Free the open instance itself
//
ExFreePool(Open);
}
else
{
// Save or open here
IrpSp->FileObject->FsContext=Open;
}
Irp->IoStatus.Status = returnStatus;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
TRACE_EXIT();
return returnStatus;
}
BOOL
hifDeviceInserted(SD_DEVICE_HANDLE *handle)
{
HIF_DEVICE *device;
#if 0
SD_API_STATUS sdStatus;
SDIO_CARD_INFO sdioInfo;
SD_HOST_BLOCK_CAPABILITY blockCap;
SD_CARD_RCA cardRCA;
A_UCHAR rgucTuple[SD_CISTPLE_MAX_BODY_SIZE];
PSD_CISTPL_FUNCE_FUNCTION pFunce = (PSD_CISTPL_FUNCE_FUNCTION) rgucTuple;
A_UINT32 ulLength = 0;
A_UCHAR ucRegVal;
A_BOOL blockMode;
SD_CARD_INTERFACE ci;
SD_IO_FUNCTION_ENABLE_INFO fData;
DWORD bData;
//SDCONFIG_FUNC_SLOT_CURRENT_DATA slotCurrent;
//HANDLE hIrqThread;
#endif
HANDLE hThread;
device = addHifDevice(handle);
NDIS_DEBUG_PRINTF(1, "hifDeviceInserted: Enter\r\n");
#if 0
/* Enable SDIO [dragon] function */
fData.Interval = DEFAULT_SDIO_FUNCTION_RETRY_TIMEOUT;
fData.ReadyRetryCount = DEFAULT_SDIO_FUNCTION_RETRIES;
sdStatus = SDSetCardFeature (handle, SD_IO_FUNCTION_ENABLE, &fData, sizeof(fData));
if (!SD_API_SUCCESS(sdStatus))
{
return FALSE;
}
/*
* Issue commands to get the manufacturer ID and stuff and compare it
* against the rev Id derived from the ID registered during the
* initialization process. Report the device only in the case there
* is a match.
*/
sdStatus = SDCardInfoQuery(handle, SD_INFO_SDIO, &sdioInfo, sizeof(sdioInfo));
if (!SD_API_SUCCESS(sdStatus))
{
return FALSE;
}
funcNo = sdioInfo.FunctionNumber;
sdStatus = SDCardInfoQuery(handle, SD_INFO_REGISTER_RCA, &cardRCA, sizeof(cardRCA));
NDIS_DEBUG_PRINTF(1, " Card RCA is 0x%x \r\n", cardRCA);
/* Configure the SDIO Bus Width */
memset(&ci, 0, sizeof(ci));
if (sdio1bitmode) {
ci.InterfaceMode = SD_INTERFACE_SD_MMC_1BIT;
} else {
ci.InterfaceMode = SD_INTERFACE_SD_4BIT;
}
if (sdiobusspeedlow) {
ci.ClockRate = SDIO_CLOCK_FREQUENCY_REDUCED;
} else {
ci.ClockRate = SDIO_CLOCK_FREQUENCY_DEFAULT;
}
sdStatus = SDSetCardFeature(handle, SD_SET_CARD_INTERFACE, &ci, sizeof(ci));
if (!SD_API_SUCCESS(sdStatus)) {
return FALSE;
}
/* Check if the target supports block mode */
sdStatus = SDReadWriteRegistersDirect(handle, SD_IO_READ, 0, 0x08, FALSE, &ucRegVal, 1);
if (!SD_API_SUCCESS(sdStatus)) {
return FALSE;
}
blockMode = (ucRegVal & 0x2) >> 1; // SMB is bit 1
if (!blockMode)
{
NDIS_DEBUG_PRINTF(DBG_ERR, "[HIF] Function does not support block mode \r\n");
return FALSE;
}
else
{
NDIS_DEBUG_PRINTF(DBG_LEVEL_HIF, "[HIF] Function supports block mode \r\n");
blockCap.ReadBlocks = blockCap.WriteBlocks = 8;
blockCap.ReadBlockSize = blockCap.WriteBlockSize = HIF_MBOX_BLOCK_SIZE;
sdStatus = SDCardInfoQuery(handle, SD_INFO_HOST_BLOCK_CAPABILITY,
&blockCap, sizeof(blockCap));
if (blockCap.ReadBlockSize < blockCap.WriteBlockSize) {
maxBlockSize = blockCap.ReadBlockSize;
} else {
maxBlockSize = blockCap.WriteBlockSize;
}
if (blockCap.ReadBlocks < blockCap.WriteBlocks) {
maxBlocks = blockCap.ReadBlocks;
} else {
maxBlocks = blockCap.WriteBlocks;
}
sdStatus = SDGetTuple(handle, SD_CISTPL_FUNCE, NULL, &ulLength, FALSE);
if ((!SD_API_SUCCESS(sdStatus)) || (ulLength > sizeof(rgucTuple)) ) {
return FALSE;
}
sdStatus = SDGetTuple(handle, SD_CISTPL_FUNCE, rgucTuple, &ulLength, FALSE);
if ((!SD_API_SUCCESS(sdStatus)) || (pFunce->bType != SD_CISTPL_FUNCE_FUNCTION_TYPE) ) {
return FALSE;
}
if (maxBlockSize > pFunce->wMaxBlkSize) {
maxBlockSize = pFunce->wMaxBlkSize;
}
bData = (DWORD)maxBlockSize;
sdStatus = SDSetCardFeature(handle, SD_IO_FUNCTION_SET_BLOCK_SIZE, &bData, sizeof(bData));
}
NDIS_DEBUG_PRINTF(DBG_LEVEL_HIF,
"Bytes Per Block: %d bytes, Block Count:%d \r\n",
maxBlockSize, maxBlocks);
/* Allocate the slot current */
/* Kowsalya : commenting as there is no equivalent for this in WINCE */
/*
status = SDLIB_GetDefaultOpCurrent(handle, &slotCurrent.SlotCurrent);
if (SDIO_SUCCESS(status)) {
HIF_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("Allocating Slot current: %d mA\n",
slotCurrent.SlotCurrent));
status = SDLIB_IssueConfig(handle, SDCONFIG_FUNC_ALLOC_SLOT_CURRENT,
&slotCurrent, sizeof(slotCurrent));
if (!SDIO_SUCCESS(status)) {
HIF_DEBUG_PRINTF(ATH_DEBUG_ERROR,
("Failed to allocate slot current %d\n", status));
return FALSE;
}
}
*/
/* Initialize the bus requests to be used later */
A_MEMZERO(device->busRequest, sizeof(device->busRequest));
for (count = 0; count < BUS_REQUEST_MAX_NUM; count ++) {
NdisInitializeEvent(&device->busRequest[count].sem_req);
hifFreeBusRequest(device, &device->busRequest[count]);
}
#else
SetupSlotPowerControl(device);
if (!SetupSDIOInterface(device)) {
return FALSE;
}
#endif
InitializeCriticalSection(&gCriticalSection); //ÃʱâÈ
device->async_shutdown = 0;
hThread = CreateThread(NULL, 0, async_task, (void *)device, 0, NULL);
CeSetThreadPriority(hThread, 200);
CloseHandle(hThread);
NdisInitializeEvent(&device->sem_async);
#if USE_IRQ_THREAD
hThread = CreateThread(NULL, 0, hifIRQThread, (void *)device, 0, NULL);
CeSetThreadPriority(hThread, 200);
CloseHandle(hThread);
NdisInitializeEvent(&hifIRQEvent);
#endif
/* start up inform DRV layer */
if ((osdrvCallbacks.deviceInsertedHandler(osdrvCallbacks.context,device)) != A_OK) {
NDIS_DEBUG_PRINTF(DBG_ERR, "[HIF] AR6000: Device rejected \r\n");
}
NDIS_DEBUG_PRINTF(DBG_LEVEL_HIF, " %s() -Exit \r\n",__FUNCTION__);
return TRUE;
}
VOID
PtBindAdapter(
OUT PNDIS_STATUS Status,
IN NDIS_HANDLE BindContext,
IN PNDIS_STRING DeviceName,
IN PVOID SystemSpecific1,
IN PVOID SystemSpecific2
)
/*++
Routine Description:
Called by NDIS to bind to a miniport below.
Arguments:
Status - Return status of bind here.
BindContext - Can be passed to NdisCompleteBindAdapter if this call is pended.
DeviceName - Device name to bind to. This is passed to NdisOpenAdapter.
SystemSpecific1 - Can be passed to NdisOpenProtocolConfiguration to read per-binding information
SystemSpecific2 - Unused
Return Value:
NDIS_STATUS_PENDING if this call is pended. In this case call NdisCompleteBindAdapter
to complete.
Anything else Completes this call synchronously
--*/
{
NDIS_HANDLE ConfigHandle = NULL;
PNDIS_CONFIGURATION_PARAMETER Param;
NDIS_STRING DeviceStr = NDIS_STRING_CONST("UpperBindings");
PADAPT pAdapt = NULL;
NDIS_STATUS Sts;
UINT MediumIndex;
ULONG TotalSize;
PNDIS_CONFIGURATION_PARAMETER BundleParam;
NDIS_STRING BundleStr = NDIS_STRING_CONST("BundleId");
NDIS_STATUS BundleStatus;
DBGPRINT(("==> Protocol BindAdapter\n"));
do
{
//
// Access the configuration section for our binding-specific
// parameters.
//
NdisOpenProtocolConfiguration(Status,
&ConfigHandle,
SystemSpecific1);
if (*Status != NDIS_STATUS_SUCCESS)
{
break;
}
//
// Read the "UpperBindings" reserved key that contains a list
// of device names representing our miniport instances corresponding
// to this lower binding. Since this is a 1:1 IM driver, this key
// contains exactly one name.
//
// If we want to implement a N:1 mux driver (N adapter instances
// over a single lower binding), then UpperBindings will be a
// MULTI_SZ containing a list of device names - we would loop through
// this list, calling NdisIMInitializeDeviceInstanceEx once for
// each name in it.
//
NdisReadConfiguration(Status,
&Param,
ConfigHandle,
&DeviceStr,
NdisParameterString);
if (*Status != NDIS_STATUS_SUCCESS)
{
break;
}
//
// Allocate memory for the Adapter structure. This represents both the
// protocol context as well as the adapter structure when the miniport
// is initialized.
//
// In addition to the base structure, allocate space for the device
// instance string.
//
TotalSize = sizeof(ADAPT) + Param->ParameterData.StringData.MaximumLength;
NdisAllocateMemoryWithTag(&pAdapt, TotalSize, TAG);
if (pAdapt == NULL)
{
*Status = NDIS_STATUS_RESOURCES;
break;
}
//
// Initialize the adapter structure. We copy in the IM device
// name as well, because we may need to use it in a call to
// NdisIMCancelInitializeDeviceInstance. The string returned
// by NdisReadConfiguration is active (i.e. available) only
// for the duration of this call to our BindAdapter handler.
//
NdisZeroMemory(pAdapt, TotalSize);
pAdapt->DeviceName.MaximumLength = Param->ParameterData.StringData.MaximumLength;
pAdapt->DeviceName.Length = Param->ParameterData.StringData.Length;
pAdapt->DeviceName.Buffer = (PWCHAR)((ULONG_PTR)pAdapt + sizeof(ADAPT));
NdisMoveMemory(pAdapt->DeviceName.Buffer,
Param->ParameterData.StringData.Buffer,
Param->ParameterData.StringData.MaximumLength);
NdisInitializeEvent(&pAdapt->Event);
//
// Allocate a packet pool for sends. We need this to pass sends down.
// We cannot use the same packet descriptor that came down to our send
// handler (see also NDIS 5.1 packet stacking).
//
NdisAllocatePacketPoolEx(Status,
&pAdapt->SendPacketPoolHandle,
MIN_PACKET_POOL_SIZE,
MAX_PACKET_POOL_SIZE - MIN_PACKET_POOL_SIZE,
sizeof(SEND_RSVD));
if (*Status != NDIS_STATUS_SUCCESS)
{
break;
}
//
// Allocate a packet pool for receives. We need this to indicate receives.
// Same consideration as sends (see also NDIS 5.1 packet stacking).
//
NdisAllocatePacketPoolEx(Status,
&pAdapt->RecvPacketPoolHandle,
MIN_PACKET_POOL_SIZE,
MAX_PACKET_POOL_SIZE - MIN_PACKET_POOL_SIZE,
PROTOCOL_RESERVED_SIZE_IN_PACKET);
if (*Status != NDIS_STATUS_SUCCESS)
{
break;
}
//
// Now open the adapter below and complete the initialization
//
NdisOpenAdapter(Status,
&Sts,
&pAdapt->BindingHandle,
&MediumIndex,
MediumArray,
sizeof(MediumArray)/sizeof(NDIS_MEDIUM),
ProtHandle,
pAdapt,
DeviceName,
0,
NULL);
if (*Status == NDIS_STATUS_PENDING)
{
NdisWaitEvent(&pAdapt->Event, 0);
*Status = pAdapt->Status;
}
if (*Status != NDIS_STATUS_SUCCESS)
{
break;
}
pAdapt->Medium = MediumArray[MediumIndex];
//
// Now ask NDIS to initialize our miniport (upper) edge.
// Set the flag below to synchronize with a possible call
// to our protocol Unbind handler that may come in before
// our miniport initialization happens.
//
pAdapt->MiniportInitPending = TRUE;
NdisInitializeEvent(&pAdapt->MiniportInitEvent);
*Status = NdisIMInitializeDeviceInstanceEx(DriverHandle,
&pAdapt->DeviceName,
pAdapt);
if (*Status != NDIS_STATUS_SUCCESS)
{
DBGPRINT(("BindAdapter: Adapt %p, IMInitializeDeviceInstance error %x\n",
pAdapt, *Status));
break;
}
} while(FALSE);
//
// Close the configuration handle now - see comments above with
// the call to NdisIMInitializeDeviceInstanceEx.
//
if (ConfigHandle != NULL)
{
NdisCloseConfiguration(ConfigHandle);
}
if (*Status != NDIS_STATUS_SUCCESS)
{
if (pAdapt != NULL)
{
if (pAdapt->BindingHandle != NULL)
{
NDIS_STATUS LocalStatus;
//
// Close the binding we opened above.
//
NdisCloseAdapter(&LocalStatus, pAdapt->BindingHandle);
pAdapt->BindingHandle = NULL;
if (LocalStatus == NDIS_STATUS_PENDING)
{
NdisWaitEvent(&pAdapt->Event, 0);
LocalStatus = pAdapt->Status;
}
}
if (pAdapt->SendPacketPoolHandle != NULL)
{
NdisFreePacketPool(pAdapt->SendPacketPoolHandle);
}
if (pAdapt->RecvPacketPoolHandle != NULL)
{
NdisFreePacketPool(pAdapt->RecvPacketPoolHandle);
}
NdisFreeMemory(pAdapt, sizeof(ADAPT), 0);
pAdapt = NULL;
}
}
DBGPRINT(("<== Protocol BindAdapter: pAdapt %p, Status %x\n", pAdapt, *Status));
}
s32
MPT_InitializeAdapter(
IN PADAPTER pAdapter,
IN u8 Channel
)
{
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(pAdapter);
s32 rtStatus = _SUCCESS;
PMPT_CONTEXT pMptCtx = &pAdapter->mppriv.MptCtx;
u32 tmpRegA, tmpRegC, TempCCk,ledsetting;
//-------------------------------------------------------------------------
// HW Initialization for 8190 MPT.
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// SW Initialization for 8190 MP.
//-------------------------------------------------------------------------
pMptCtx->bMptDrvUnload = _FALSE;
pMptCtx->bMassProdTest = _FALSE;
pMptCtx->bMptIndexEven = _TRUE; //default gain index is -6.0db
/* Init mpt event. */
#if 0 // for Windows
NdisInitializeEvent( &(pMptCtx->MptWorkItemEvent) );
NdisAllocateSpinLock( &(pMptCtx->MptWorkItemSpinLock) );
PlatformInitializeWorkItem(
Adapter,
&(pMptCtx->MptWorkItem),
(RT_WORKITEM_CALL_BACK)MPT_WorkItemCallback,
(PVOID)Adapter,
"MptWorkItem");
#endif
pMptCtx->bMptWorkItemInProgress = _FALSE;
pMptCtx->CurrMptAct = NULL;
//-------------------------------------------------------------------------
#if 1
// Don't accept any packets
rtw_write32(pAdapter, REG_RCR, 0);
#else
// Accept CRC error and destination address
pHalData->ReceiveConfig |= (RCR_ACRC32|RCR_AAP);
rtw_write32(pAdapter, REG_RCR, pHalData->ReceiveConfig);
#endif
#if 0
// If EEPROM or EFUSE is empty,we assign as RF 2T2R for MP.
if (pHalData->AutoloadFailFlag == TRUE)
{
pHalData->RF_Type = RF_2T2R;
}
#endif
ledsetting = rtw_read32(pAdapter, REG_LEDCFG0);
rtw_write32(pAdapter, REG_LEDCFG0, ledsetting & ~LED0DIS);
#ifdef CONFIG_RTL8192C
PHY_IQCalibrate(pAdapter, _FALSE);
dm_CheckTXPowerTracking(pAdapter); //trigger thermal meter
PHY_LCCalibrate(pAdapter);
#endif
#ifdef CONFIG_RTL8192D
PHY_IQCalibrate(pAdapter);
dm_CheckTXPowerTracking(pAdapter); //trigger thermal meter
PHY_LCCalibrate(pAdapter);
#endif
#ifdef CONFIG_PCI_HCI
PHY_SetRFPathSwitch(pAdapter, 1/*pHalData->bDefaultAntenna*/); //Wifi default use Main
#else
#ifdef CONFIG_RTL8192C
#if 1
if (pHalData->BoardType == BOARD_MINICARD)
PHY_SetRFPathSwitch(pAdapter, 1/*pHalData->bDefaultAntenna*/); //default use Main
#else
if(pAdapter->HalFunc.GetInterfaceSelectionHandler(pAdapter) == INTF_SEL2_MINICARD )
PHY_SetRFPathSwitch(Adapter, pAdapter->MgntInfo.bDefaultAntenna); //default use Main
#endif
#endif
#endif
pMptCtx->backup0xc50 = (u1Byte)PHY_QueryBBReg(pAdapter, rOFDM0_XAAGCCore1, bMaskByte0);
pMptCtx->backup0xc58 = (u1Byte)PHY_QueryBBReg(pAdapter, rOFDM0_XBAGCCore1, bMaskByte0);
pMptCtx->backup0xc30 = (u1Byte)PHY_QueryBBReg(pAdapter, rOFDM0_RxDetector1, bMaskByte0);
return rtStatus;
}
NDIS_STATUS
SecLabDoRequest(
IN PADAPT pAdapt,
IN NDIS_REQUEST_TYPE RequestType,
IN NDIS_OID Oid,
IN PVOID InformationBuffer,
IN UINT InformationBufferLength,
OUT PUINT pBytesProcessed
)
{
SECLAB_REQUEST ReqContext;
PNDIS_REQUEST pNdisRequest = &ReqContext.Request;
NDIS_STATUS Status;
NdisInitializeEvent(&ReqContext.ReqEvent);
ReqContext.Signal=REQUEST_SIGNAL;
pNdisRequest->RequestType = RequestType;
switch (RequestType)
{
case NdisRequestQueryInformation:
pNdisRequest->DATA.QUERY_INFORMATION.Oid = Oid;
pNdisRequest->DATA.QUERY_INFORMATION.InformationBuffer =
InformationBuffer;
pNdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength =
InformationBufferLength;
break;
case NdisRequestSetInformation:
pNdisRequest->DATA.SET_INFORMATION.Oid = Oid;
pNdisRequest->DATA.SET_INFORMATION.InformationBuffer =
InformationBuffer;
pNdisRequest->DATA.SET_INFORMATION.InformationBufferLength =
InformationBufferLength;
break;
default:
break;
}
NdisRequest(&Status,
pAdapt->BindingHandle,
pNdisRequest);
if (Status == NDIS_STATUS_PENDING)
{
NdisWaitEvent(&ReqContext.ReqEvent, 0);
Status = ReqContext.Status;
}
if (Status == NDIS_STATUS_SUCCESS)
{
*pBytesProcessed = (RequestType == NdisRequestQueryInformation)?
pNdisRequest->DATA.QUERY_INFORMATION.BytesWritten:
pNdisRequest->DATA.SET_INFORMATION.BytesRead;
}
return (Status);
}
