CMD_STATUS CmdSetTxPowerLevel(PWLAN_ADAPTER pAdapter, USHORT nPowerLevel) { CMD_STATUS stat = CmdQueryBuffer(pAdapter); WORD nRet; if (1) { OID_MRVL_DS_TPC_CFG cfg; POID_MRVL_DS_TPC_CFG pTpcCfg = &cfg; PHostCmd_DS_802_11_TPC_CFG pCmd = (PHostCmd_DS_802_11_TPC_CFG)&pAdapter->m_ucCmdBuffer[0]; ZeroMemory(&cfg,sizeof(cfg)); pCmd->Action = CMD_ACT_SET; MoveMemory(&pCmd->Enable, &pTpcCfg->Enable,sizeof(*pCmd)-MEMBER_OFFSET(HostCmd_DS_802_11_TPC_CFG,Enable)); CmdSetCmdInfo(pAdapter, HostCmd_CMD_802_11_TPC_CFG, pCmd, sizeof(*pCmd), pCmd, ADAPTER_CMD_BUFFER_LENGTH); nRet = CmdProcessCmd(pAdapter, CMD_TIMEOUT_MAX); if (nRet != sizeof(*pCmd)) stat = CMD_ERROR_UNKNOWN; } if(1) { //stat == CMD_ERROR_SUCCESS) { USHORT bEnablePA=TRUE; int nTxSize; MrvlIEtypes_PowerAdapt_Group_t iePag; MrvlIEtypes_PowerAdapt_Group_t* pIePag = &iePag; PHostCmd_DS_802_11_POWER_ADAPT_CFG_EXT pCmd = (PHostCmd_DS_802_11_POWER_ADAPT_CFG_EXT)&pAdapter->m_ucCmdBuffer[0]; iePag.Header.Type=0x114; iePag.Header.Len=sizeof(PA_Group_t)*3; iePag.PA_Group[0].PowerAdaptLevel = nPowerLevel; iePag.PA_Group[0].RateBitmap=0x1800; iePag.PA_Group[1].PowerAdaptLevel = nPowerLevel; iePag.PA_Group[1].RateBitmap=0x07e0; iePag.PA_Group[2].PowerAdaptLevel = nPowerLevel; iePag.PA_Group[2].RateBitmap=0x000f; pCmd->Action = CMD_ACT_SET; pCmd->EnablePA = bEnablePA; MoveMemory(&pCmd->PowerAdaptGroup,pIePag,sizeof(*pIePag)); nTxSize = MEMBER_OFFSET(HostCmd_DS_802_11_POWER_ADAPT_CFG_EXT,PowerAdaptGroup); nTxSize+=sizeof(pCmd->PowerAdaptGroup.Header)+pCmd->PowerAdaptGroup.Header.Len; CmdSetCmdInfo(pAdapter, HostCmd_CMD_802_11_POWER_ADAPT_CFG_EXT, pCmd, nTxSize, pCmd, ADAPTER_CMD_BUFFER_LENGTH); nRet = CmdProcessCmd(pAdapter, CMD_TIMEOUT_MAX); if (nRet != nTxSize) stat = CMD_ERROR_UNKNOWN; } CmdReleaseBuffer(pAdapter); return stat; }
static void get_rchan_offsets(void) { rchan_offsets.subbuf_size = MEMBER_OFFSET("rchan", "subbuf_size"); if (rchan_offsets.subbuf_size < 0) goto ERR; rchan_offsets.n_subbufs = MEMBER_OFFSET("rchan", "n_subbufs"); if (rchan_offsets.n_subbufs < 0) goto ERR; rchan_offsets.buf = MEMBER_OFFSET("rchan", "buf"); if (rchan_offsets.buf < 0) goto ERR; rchan_offsets.buf_start = MEMBER_OFFSET("rchan_buf", "start"); if (rchan_offsets.buf_start < 0) goto ERR; rchan_offsets.buf_offset = MEMBER_OFFSET("rchan_buf", "offset"); if (rchan_offsets.buf_offset < 0) goto ERR; rchan_offsets.buf_subbufs_produced = MEMBER_OFFSET("rchan_buf", "subbufs_produced"); if (rchan_offsets.buf_subbufs_produced < 0) goto ERR; rchan_offsets.buf_padding = MEMBER_OFFSET("rchan_buf", "padding"); if (rchan_offsets.buf_padding < 0) goto ERR; return; ERR: error(FATAL, "cannot get rchan offset\n"); }
INTERFACE[ppc32]: #include "entry_frame.h" #include "member_offs.h" #include "types.h" class Continuation { MEMBER_OFFSET(); private:
INTERFACE [sched_fp_wfq]: #include "ready_queue_fp.h" #include "ready_queue_wfq.h" class Sched_context { MEMBER_OFFSET(); friend class Jdb_list_timeouts; friend class Jdb_thread_list; public:
static void CmdSetupScanCmd(PWLAN_ADAPTER pAdapter, char* pszSsid) { PBYTE pCur = &pAdapter->m_ucCmdBuffer[0]; PHostCmd_DS_802_11_SCAN pCmd = (PHostCmd_DS_802_11_SCAN) pCur; pCmd->BSSType = HostCmd_BSS_TYPE_ANY; FillMemory(pCmd->BSSID, 0xff, sizeof(pCmd->BSSID)); pCur += MEMBER_OFFSET(HostCmd_DS_802_11_SCAN, SsIdParamSet); if (strlen(pszSsid) > 0) { MrvlIEtypes_SsIdParamSet_t* pSsid = (MrvlIEtypes_SsIdParamSet_t*)pCur; pSsid->Header.Type = TLV_TYPE_SSID; pSsid->Header.Len = (USHORT)strlen(pszSsid); MoveMemory(pSsid->SsId, pszSsid, strlen(pszSsid)); pCur += sizeof(pSsid->Header) + pSsid->Header.Len; } if (1) { int i; MrvlIEtypes_ChanListParamSet_t* pChanList = (MrvlIEtypes_ChanListParamSet_t*)pCur; ChanScanParamSet_t* pChanScan; pChanList->Header.Type = TLV_TYPE_CHANLIST; pChanList->Header.Len = 0; pCur += sizeof(pChanList->Header); for (i = CMD_SCAN_CHANNEL_MIN; i <= CMD_SCAN_CHANNEL_MAX; i++) { pChanScan = (ChanScanParamSet_t*)pCur; pChanScan->ChanNumber = i; pChanScan->RadioType = HostCmd_SCAN_RADIO_TYPE_BG; pChanScan->ScanType = HostCmd_SCAN_TYPE_ACTIVE; pChanScan->MinScanTime = HostCmd_SCAN_MIN_CH_TIME; pChanScan->ScanTime = HostCmd_SCAN_MIN_CH_TIME; pChanList->Header.Len += sizeof(ChanScanParamSet_t); pCur += sizeof(ChanScanParamSet_t); } } if(1) { MrvlIEtypes_RatesParamSet_t* pRates=(MrvlIEtypes_RatesParamSet_t*)pCur; pRates->Header.Type=TLV_TYPE_RATES; pRates->Header.Len=sizeof(m_aSupportRate_G); MoveMemory(pRates->Rates, m_aSupportRate_G, pRates->Header.Len); pCur+=sizeof(pRates->Header)+pRates->Header.Len; } CmdSetCmdInfo(pAdapter, HostCmd_CMD_802_11_SCAN, pCmd, pCur - (PBYTE)pCmd, pCmd, ADAPTER_CMD_BUFFER_LENGTH); return ; }
INTERFACE [sched_fixed_prio]: #include <dlist> #include "member_offs.h" #include "types.h" #include "globals.h" #include "ready_queue_fp.h" class Sched_context : public cxx::D_list_item { MEMBER_OFFSET(); friend class Jdb_list_timeouts; friend class Jdb_thread_list;
INTERFACE[ux]: #include "gdt.h" #include "emulation.h" #include "entry_frame.h" #include "member_offs.h" #include "regdefs.h" #include "types.h" class Continuation { MEMBER_OFFSET(); private:
static ulong get_rchan_addr(ulong stp_relay_data) { long offset; /* * If we can get the member offset of struct * stp_relay_data.flushing, we'll assume this is a system * using STP_TRANSPORT_VERSION 1. Note that this will fail if * the debuginfo of the trace module isn't available. */ if ((offset = MEMBER_OFFSET("_stp_relay_data_type", "flushing")) > 0) { old_format = 1; } /* * If we can't get the member offset of struct * stp_relay_data.rchan, i.e. the debuginfo of the trace * module isn't available, we use 0 as the offset * instead. Currently struct _stp_relay_data_type is defined * as below: * * struct _stp_relay_data_type { * struct rchan *rchan; * ... * } * * If the definision of struct _stp_relay_data_type changes, * we must check if this code is correct. */ if ((offset = MEMBER_OFFSET("_stp_relay_data_type", "rchan")) < 0) { error(WARNING, "The debuginfo of the trace module hasn't been loaded.\n" "You may not be able to retrieve the correct trace data.\n"); offset = 0; } return (stp_relay_data + (ulong)offset); }
CMD_STATUS CmdAssociateExt(PWLAN_ADAPTER pAdapter, PBSSINFO pBssInfo) { CMD_STATUS stat = CmdQueryBuffer(pAdapter); WORD nRet; if (stat != CMD_ERROR_SUCCESS) return stat; TRACE("+CmdAssociateExt()\r\n"); // Setup command CmdSetupAssociateCmd(pAdapter, pBssInfo); nRet = CmdProcessCmd(pAdapter, CMD_TIMEOUT_MAX); if (nRet) { PHostCmd_DS_802_11_ASSOCIATE_RESULT pCmdR = (PHostCmd_DS_802_11_ASSOCIATE_RESULT)&pAdapter->m_ucCmdBuffer[0]; //TRACEDATA("CmdAssocData",pCmd,pCur-PBYTE(pCmd)); stat = (nRet >= sizeof(*pCmdR) && pCmdR->StatusCode == 0) ? CMD_ERROR_SUCCESS : CMD_ERROR_UNKNOWN; TRACE("Wlan.CmdAssociateExt: rc=%08x,SC=%04x,AID=%04x\r\n", nRet, pCmdR->StatusCode, pCmdR->AssociationID, pCmdR->AssociationID); if (stat == CMD_ERROR_SUCCESS) { PNDIS_802_11_ASSOCIATION_INFORMATION pAI = (PNDIS_802_11_ASSOCIATION_INFORMATION)pAdapter->m_ucAssocInfo; int nBufLen, nIeLen = (int)pCmdR->Size - MEMBER_OFFSET(HostCmd_DS_802_11_ASSOCIATE_RESULT, IELength); pAI->ResponseFixedIEs.Capabilities = pCmdR->CapInfo; pAI->ResponseFixedIEs.StatusCode = pCmdR->StatusCode; pAI->ResponseFixedIEs.AssociationId = pCmdR->AssociationID; pAI->AvailableResponseFixedIEs |= NDIS_802_11_AI_RESFI_CAPABILITIES; pAI->AvailableResponseFixedIEs |= NDIS_802_11_AI_RESFI_STATUSCODE; pAI->AvailableResponseFixedIEs |= NDIS_802_11_AI_RESFI_ASSOCIATIONID; nBufLen = (int)sizeof(pAdapter->m_ucAssocInfo) - (int)pAI->OffsetResponseIEs; nIeLen = MAX(0, MIN(nBufLen, nIeLen)); MoveMemory((void*)((PBYTE)pAI + pAI->OffsetResponseIEs), (void*)&pCmdR->IELength, nIeLen); pAI->ResponseIELength = (ULONG)nIeLen; WIFI_SET_FLAG(pAdapter, FLAG_MEDIA_CONNECTED); } } else stat = CMD_ERROR_UNKNOWN; CmdReleaseBuffer(pAdapter); TRACE("-CmdAssociateExt()\r\n"); return stat; }
static void get_diskdump_regs_ppc(struct bt_info *bt, ulong *eip, ulong *esp) { Elf32_Nhdr *note; int len; if (KDUMP_CMPRS_VALID() && (bt->task == tt->panic_task || (is_task_active(bt->task) && dd->num_prstatus_notes > 1))) { note = (Elf32_Nhdr*) dd->nt_prstatus_percpu[bt->tc->processor]; if (!note) error(FATAL, "cannot determine NT_PRSTATUS ELF note " "for %s task: %lx\n", (bt->task == tt->panic_task) ? "panic" : "active", bt->task); len = sizeof(Elf32_Nhdr); len = roundup(len + note->n_namesz, 4); bt->machdep = (void *)((char *)note + len + MEMBER_OFFSET("elf_prstatus", "pr_reg")); } machdep->get_stack_frame(bt, eip, esp); }
CMD_STATUS CmdAdHocStart(PWLAN_ADAPTER pAdapter, PBSSINFO pBssInfo) { CMD_STATUS stat = CmdQueryBuffer(pAdapter); PHostCmd_DS_802_11_AD_HOC_START pCmd = (PHostCmd_DS_802_11_AD_HOC_START)&pAdapter->m_ucCmdBuffer[0]; PHostCmd_DS_802_11_AD_HOC_RESULT pCmdR = (PHostCmd_DS_802_11_AD_HOC_RESULT)(pCmd+1); PNDIS_WLAN_BSSID_EX pBid = (PNDIS_WLAN_BSSID_EX)(&pBssInfo->Bssid); PNDIS_802_11_FIXED_IEs pFie = &pBssInfo->IEsFixed; WORD nRet; ZeroMemory(pCmd,sizeof(*pCmd)); //Configure Cmd Parameters strcpy((char*)pCmd->SSID, pAdapter->m_CurProfile.szSSID); pCmd->BSSType = HostCmd_BSS_TYPE_IBSS; pCmd->BeaconPeriod = cmdAdhocBacconPeriod; pCmd->DTIMPeriod = (UCHAR)cmdPsNumDtims; pCmd->SsParamSet.IbssParamSet.ElementId = IBSS_PARAM_SET; pCmd->SsParamSet.IbssParamSet.Len = 2; pCmd->SsParamSet.IbssParamSet.AtimWindow = cmdAdhocAtimWindow; pCmd->PhyParamSet.DsParamSet.ElementId = DS_PARAM_SET; pCmd->PhyParamSet.DsParamSet.Len = 1; pCmd->PhyParamSet.DsParamSet.CurrentChan = cmdAdhocChannel; pCmd->ProbeDelay = HostCmd_SCAN_PROBE_DELAY_TIME; pCmd->Cap.Ibss = 1; pCmd->Cap.ShortPreamble = 1; pCmd->Cap.Privacy = (pAdapter->m_CurProfile.EncMode== EncryMode_WEP?1:0); MoveMemory(pCmd->BasicDataRates, m_aSupportRate_G, sizeof(m_aSupportRate_G)); CmdSetCmdInfo(pAdapter, HostCmd_CMD_802_11_AD_HOC_START, pCmd, sizeof(*pCmd), pCmd + 1, ADAPTER_CMD_BUFFER_LENGTH - sizeof(*pCmd)); nRet = CmdProcessCmd(pAdapter, CMD_TIMEOUT_MAX); if (nRet < sizeof(*pCmdR)) stat = CMD_ERROR_UNKNOWN; if(stat == CMD_ERROR_SUCCESS) { ZeroMemory(pBssInfo,sizeof(*pBssInfo)); //Configure BssInfo MoveMemory(pBid->MacAddress,pCmdR->BSSID,sizeof(pBid->MacAddress)); pBssInfo->nScanCounter = 0; //////??? pBssInfo->IELength=sizeof(*pFie); pBid->Rssi = -10; pBid->Configuration.Length=sizeof(NDIS_802_11_CONFIGURATION); MoveMemory(&pFie->Capabilities,&pCmd->Cap,sizeof(pFie->Capabilities)); pBid->Privacy = pAdapter->m_CurProfile.EncMode== EncryMode_WEP? Ndis802_11PrivFilter8021xWEP:Ndis802_11PrivFilterAcceptAll; pBid->InfrastructureMode = Ndis802_11IBSS; pBid->Ssid.SsidLength = strlen(pAdapter->m_CurProfile.szSSID); MoveMemory(pBid->Ssid.Ssid, pAdapter->m_CurProfile.szSSID, strlen(pAdapter->m_CurProfile.szSSID)); if(1) { INT nLen = 2 + pCmd->PhyParamSet.DsParamSet.Len; PBYTE pCur = (PBYTE)(&pBssInfo->IEsFixed) + pBssInfo->IELength; IEEEtypes_DsParamSet_t* pDS = (IEEEtypes_DsParamSet_t *)pCur; MoveMemory(pDS, &pCmd->PhyParamSet.DsParamSet, nLen); pBid->NetworkTypeInUse = Ndis802_11OFDM24; pBid->Configuration.DSConfig = 2407+(pDS->CurrentChan*5); pBssInfo->nChannel = pDS->CurrentChan; pBssInfo->IELength += nLen; } if(1) { INT nLen = 2 + pCmd->SsParamSet.IbssParamSet.Len; PBYTE pCur = (PBYTE)(&pBssInfo->IEsFixed) + pBssInfo->IELength; IEEEtypes_IbssParamSet_t* pIbss = (IEEEtypes_IbssParamSet_t*)pCur; MoveMemory(pIbss,&pCmd->SsParamSet.IbssParamSet,nLen); pBssInfo->pIbssParamSet = pIbss; pBssInfo->IELength += nLen; } pBid->Length = MEMBER_OFFSET(NDIS_WLAN_BSSID_EX, IEs)+pBssInfo->IELength; pBid->Length = (pBid->Length+3) & ~3; } CmdReleaseBuffer(pAdapter); return stat; }
static void CmdScanInterpret2(PWLAN_ADAPTER pAdapter, PBYTE pCur, PBYTE pEnd, PBSSINFO pBssInfo) { PSrBssDesc pbd = (PSrBssDesc)pCur; PNDIS_WLAN_BSSID_EX pBid = (PNDIS_WLAN_BSSID_EX)&pBssInfo->Bssid; PNDIS_802_11_FIXED_IEs pFie = &pBssInfo->IEsFixed; int nRateCnt = 0; TRACE("+CmdScanInterpret2()\r\n"); TRACE("CmdScanInterpret2: Rssi=%d TsInterval=%04x Cap=%04x\n" "\r\nAP Address=%02x%02x%02x-%02x%02x%02x\n", -(int)(pbd->nRssi & 0x7f), pbd->nTsInterval, pbd->nCapability, pbd->aApPhyAddr[0], pbd->aApPhyAddr[1], pbd->aApPhyAddr[2], pbd->aApPhyAddr[3], pbd->aApPhyAddr[4], pbd->aApPhyAddr[5]); MoveMemory(pBid->MacAddress, pbd->aApPhyAddr, sizeof(pBid->MacAddress)); pBid->Rssi = -(LONG)(pbd->nRssi & 0x7f); MoveMemory(pFie->Timestamp, pbd->aTimeStamp, sizeof(pFie->Timestamp)); pFie->BeaconInterval = pbd->nTsInterval; pBid->Configuration.Length = sizeof(NDIS_802_11_CONFIGURATION); pBid->Configuration.BeaconPeriod = pbd->nTsInterval; pFie->Capabilities = pbd->nCapability; if (1) { IEEEtypes_CapInfo_t cap; *(PUSHORT)(&cap) = pbd->nCapability; MoveMemory((void*)&cap, (void*)&pbd->nCapability, sizeof(cap)); pBid->Privacy = cap.Privacy ? Ndis802_11PrivFilter8021xWEP : Ndis802_11PrivFilterAcceptAll; pBid->InfrastructureMode = cap.Ibss ? Ndis802_11IBSS : Ndis802_11Infrastructure; } pCur += sizeof(SrBssDesc); pBssInfo->IELength = sizeof(*pFie); if (pCur + 2 < pEnd) { ULONG nLen = MIN(pEnd - pCur, sizeof(pBssInfo->IEsVariable)); pBssInfo->IELength += nLen; MoveMemory(pBssInfo->IEsVariable, pCur, nLen); pCur = pBssInfo->IEsVariable; pEnd = pCur + nLen; } pBid->Length = MEMBER_OFFSET(NDIS_WLAN_BSSID_EX, IEs) + pBssInfo->IELength; pBid->Length = ALIGN_UP(pBid->Length, 4); while (pCur + (2 + pCur[1]) <= pEnd) { switch (pCur[0]) { //IE Type case SSID: { char szSsid[33]; CopyMemory(szSsid, pCur + 2, pCur[1]); szSsid[pCur[1]] = 0; TRACE("CmdScanInterpret2: Find SSID(%d,%s)\r\n", pCur[1], szSsid); if (pCur[1]) { pBid->Ssid.SsidLength = MIN(pCur[1], sizeof(pBid->Ssid.Ssid)); MoveMemory(pBid->Ssid.Ssid, pCur + 2, pBid->Ssid.SsidLength); pBid->Ssid.Ssid[pBid->Ssid.SsidLength] = 0; } break; } case SUPPORTED_RATES: TRACE("CmdScanInterpret2: Find Rates(%d)\r\n", pCur[1]); if (pCur[1]) { nRateCnt = MIN(pCur[1], sizeof(pBid->SupportedRates)); MoveMemory(pBid->SupportedRates, pCur + 2, nRateCnt); } break; case FH_PARAM_SET: TRACE("CmdScanInterpret2: Find Frequency Hopping(%d)\r\n", pCur[1]); if (pCur[1]) { IEEEtypes_FhParamSet_t* pFH = (IEEEtypes_FhParamSet_t*)pCur; pBid->NetworkTypeInUse = Ndis802_11FH; pBid->Configuration.DSConfig = 0; pBid->Configuration.FHConfig.Length = sizeof(NDIS_802_11_CONFIGURATION_FH); pBid->Configuration.FHConfig.HopPattern = pFH->HopPattern; pBid->Configuration.FHConfig.HopSet = pFH->HopSet; pBid->Configuration.FHConfig.DwellTime = pFH->DwellTime; pBssInfo->nChannel = 0; } break; case DS_PARAM_SET: TRACE("CmdScanInterpret2: Find Direct Spectrum(%d)\r\n", pCur[1]); if (pCur[1]) { //should add A B G support IEEEtypes_DsParamSet_t* pDS = (IEEEtypes_DsParamSet_t *)pCur; pBid->NetworkTypeInUse = Ndis802_11OFDM24; pBid->Configuration.DSConfig = 2407 + (pDS->CurrentChan * 5); pBssInfo->nChannel = pDS->CurrentChan; TRACE("CmdScanInterpret2: Find DS Channel %d(%s)\r\n", pDS->CurrentChan, pBid->Ssid.Ssid); break; } break; case CF_PARAM_SET: TRACE("CmdScanInterpret2: CF(%d)\r\n", pCur[1]); if (pCur[1]) { pBssInfo->pCfParamSet = (IEEEtypes_CfParamSet_t*)pCur; } break; case IBSS_PARAM_SET: TRACE("CmdScanInterpret2: IBSS(%d)\r\n", pCur[1]); if (pCur[1]) { IEEEtypes_IbssParamSet_t* pIbss = (IEEEtypes_IbssParamSet_t*)pCur; pBid->Configuration.ATIMWindow = pIbss->AtimWindow; pBssInfo->pIbssParamSet = pIbss; } break; case COUNTRY_INFO: TRACE("CmdScanInterpret2: Country(%d)\r\n", pCur[1]); if (pCur[1]) { pBssInfo->pCountryInfo = (IEEEtypes_CountryInfoFullSet_t*)pCur; } break; case ERP_INFO: TRACE("CmdScanInterpret2: ERP(%d)\r\n", pCur[1]); if (pCur[1]) { IEEEtypes_ERPInfo_t* pERP = (IEEEtypes_ERPInfo_t*)pCur; pBssInfo->nERPFlags = pERP->ERPFlags; } break; case EXTENDED_SUPPORTED_RATES: TRACE("CmdScanInterpret2: Extend supported rates(%d)\r\n", pCur[1]); if (pCur[1] && nRateCnt) { int nRateCnt2 = MIN(pCur[1], sizeof(pBid->SupportedRates) - nRateCnt); MoveMemory((PBYTE)(pBid->SupportedRates) + nRateCnt, pCur + 2, nRateCnt2); } break; case ELE_CISCO_CLIENT_TX_PWR: TRACE("CmdScanInterpret2: ccx tpc(%d)\r\n", pCur[1]); if (pCur[1]) { // need to do } break; } pCur += 2 + pCur[1]; //IE Length; } TRACE("-CmdScanInterpret2()\r\n"); }
static void CmdSetupAssociateCmd(PWLAN_ADAPTER pAdapter, PBSSINFO pBssInfo) { PBYTE pCur = &pAdapter->m_ucCmdBuffer[0]; PHostCmd_DS_802_11_ASSOCIATE_EXT pCmd = (PHostCmd_DS_802_11_ASSOCIATE_EXT)pCur; if (1) { IEEEtypes_CapInfo_t cap = *(IEEEtypes_CapInfo_t*)&pBssInfo->IEsFixed.Capabilities; cap.QoS = 0; MoveMemory(&pCmd->PeerStaAddr, &pBssInfo->Bssid.MacAddress, sizeof(pCmd->PeerStaAddr)); pCmd->CapInfo = cap; pCmd->ListenInterval = 0x14; pCmd->BcnPeriod = pBssInfo->IEsFixed.BeaconInterval; pCmd->DtimPeriod = 3; pCur += MEMBER_OFFSET(HostCmd_DS_802_11_ASSOCIATE_EXT, SsIdParamSet); } if (1) { MrvlIEtypes_SsIdParamSet_t* pSsid = (MrvlIEtypes_SsIdParamSet_t*)pCur; pSsid->Header.Type = TLV_TYPE_SSID; pSsid->Header.Len = (USHORT)pBssInfo->Bssid.Ssid.SsidLength; MoveMemory(pSsid->SsId, pBssInfo->Bssid.Ssid.Ssid, pSsid->Header.Len); pCur += sizeof(pSsid->Header) + pSsid->Header.Len; } if (1) { MrvlIEtypes_PhyParamSet_t* pPhy = (MrvlIEtypes_PhyParamSet_t*)pCur; pPhy->Header.Type = TLV_TYPE_PHY_DS; pPhy->Header.Len = sizeof(pPhy->fh_ds.DsParamSet); MoveMemory(&pPhy->fh_ds.DsParamSet, &pBssInfo->nChannel, sizeof(pPhy->fh_ds.DsParamSet)); pCur += sizeof(pPhy->Header) + pPhy->Header.Len; } if (1) { int f, cbDest; PBYTE pDest; MrvlIEtypes_RatesParamSet_t* pRate = (MrvlIEtypes_RatesParamSet_t*)pCur; pDest = pRate->Rates; cbDest = 0; for (f = 0; f < sizeof(m_aSupportRate_G); f++) pDest[cbDest++] = m_aSupportRate_G[f]; pRate->Header.Type = TLV_TYPE_RATES; pRate->Header.Len = cbDest; pCur += sizeof(pRate->Header) + pRate->Header.Len; } if (1) { MrvlIEtypesHeader_t* pHead = (MrvlIEtypesHeader_t*)pCur; pHead->Type = TLV_TYPE_TSFTIMESTAMP; pHead->Len = sizeof(ULONGLONG) * 2; pCur += sizeof(*pHead); MoveMemory(pCur, &pBssInfo->nNetworkTSF, sizeof(ULONGLONG)); pCur += sizeof(ULONGLONG); MoveMemory(pCur, &pBssInfo->IEsFixed.Timestamp, sizeof(ULONGLONG)); pCur += sizeof(ULONGLONG); } if (1) { MrvlIEtypes_AuthType_t* pAt = (MrvlIEtypes_AuthType_t*)pCur; pAt->Header.Type = TLV_TYPE_AUTH_TYPE; pAt->Header.Len = sizeof(pAt->AuthType); switch (pAdapter->m_CurProfile.AuthMode) { case AuthMode_Open: pAt->AuthType = Wlan802_11AuthModeOpen; break; case AuthMode_Shared: pAt->AuthType = Wlan802_11AuthModeShared; break; default: pAt->AuthType = (USHORT) - 1; } pCur += sizeof(pAt->Header) + pAt->Header.Len; } CmdSetCmdInfo(pAdapter, HostCmd_CMD_802_11_ASSOCIATE_EXT, pCmd, pCur - (PBYTE)pCmd, pCmd, ADAPTER_CMD_BUFFER_LENGTH); }
static inline uint32_t KL_INT(void* ptr, char* struct_name, char* member_name) { return UINT(ptr+MEMBER_OFFSET(struct_name,member_name)); }
static inline unsigned long KL_ULONG(void* ptr, char* struct_name, char* member_name) { return ULONG(ptr+MEMBER_OFFSET(struct_name,member_name)); }
static inline void* K_PTR(void* addr, char* struct_name, char* member_name) { return addr+MEMBER_OFFSET(struct_name,member_name); }