void os_indicate_disconnect( _adapter *adapter ) { //RT_PMKID_LIST backupPMKIDList[ NUM_PMKID_CACHE ]; u8 backupPMKIDIndex = 0; u8 backupTKIPCountermeasure = 0x00; _func_enter_; indicate_wx_disassoc_event(adapter); netif_carrier_off(adapter->pnetdev); if(adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)//802.1x { // Added by Albert 2009/02/18 // We have to backup the PMK information for WiFi PMK Caching test item. // // Backup the btkip_countermeasure information. // When the countermeasure is trigger, the driver have to disconnect with AP for 60 seconds. _memset( &backupPMKIDList[ 0 ], 0x00, sizeof( RT_PMKID_LIST ) * NUM_PMKID_CACHE ); _memcpy( &backupPMKIDList[ 0 ], &adapter->securitypriv.PMKIDList[ 0 ], sizeof( RT_PMKID_LIST ) * NUM_PMKID_CACHE ); backupPMKIDIndex = adapter->securitypriv.PMKIDIndex; backupTKIPCountermeasure = adapter->securitypriv.btkip_countermeasure; _memset((unsigned char *)&adapter->securitypriv, 0, sizeof (struct security_priv)); _init_timer(&(adapter->securitypriv.tkip_timer),adapter->pnetdev, use_tkipkey_handler, adapter); // Added by Albert 2009/02/18 // Restore the PMK information to securitypriv structure for the following connection. _memcpy( &adapter->securitypriv.PMKIDList[ 0 ], &backupPMKIDList[ 0 ], sizeof( RT_PMKID_LIST ) * NUM_PMKID_CACHE ); adapter->securitypriv.PMKIDIndex = backupPMKIDIndex; adapter->securitypriv.btkip_countermeasure = backupTKIPCountermeasure; adapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen; adapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled; } else //reset values in securitypriv { //if(adapter->mlmepriv.fw_state & WIFI_STATION_STATE) //{ struct security_priv *psec_priv=&adapter->securitypriv; psec_priv->dot11AuthAlgrthm =dot11AuthAlgrthm_Open; //open system psec_priv->dot11PrivacyAlgrthm = _NO_PRIVACY_; psec_priv->dot11PrivacyKeyIndex = 0; psec_priv->dot118021XGrpPrivacy = _NO_PRIVACY_; psec_priv->dot118021XGrpKeyid = 1; psec_priv->ndisauthtype = Ndis802_11AuthModeOpen; psec_priv->ndisencryptstatus = Ndis802_11WEPDisabled; psec_priv->wps_phase = _FALSE; //} } _func_exit_; }
// NES init void PSPEMU_NES_Init(void) { // major struct zero clear _memset(&g_NES, 0x00, sizeof(g_NES)); _memset(&g_PPU, 0x00, sizeof(g_PPU)); _memset(&g_APU, 0x00, sizeof(g_APU)); _memset(&g_NESConfig, 0x00, sizeof(g_NESConfig)); }
void report_sec_ie(_adapter *adapter,u8 authmode,u8 *sec_ie) { uint len; u8 *buff,*p,i; union iwreq_data wrqu; _func_enter_; RT_TRACE(_module_mlme_osdep_c_,_drv_info_,("+report_sec_ie, authmode=%d\n", authmode)); buff = NULL; if(authmode==_WPA_IE_ID_) { RT_TRACE(_module_mlme_osdep_c_,_drv_info_,("report_sec_ie, authmode=%d\n", authmode)); buff = _malloc(IW_CUSTOM_MAX); if(buff == NULL) { RT_TRACE(_module_mlme_osdep_c_,_drv_info_,("report_sec_ie, _malloc fail !\n")); return; } _memset(buff,0,IW_CUSTOM_MAX); p=buff; p+=sprintf(p,"ASSOCINFO(ReqIEs="); len = sec_ie[1]+2; len = (len < IW_CUSTOM_MAX) ? len:IW_CUSTOM_MAX; for(i=0; i<len; i++) { p+=sprintf(p,"%02x",sec_ie[i]); } p+=sprintf(p,")"); _memset(&wrqu,0,sizeof(wrqu)); wrqu.data.length=p-buff; wrqu.data.length = (wrqu.data.length<IW_CUSTOM_MAX) ? wrqu.data.length:IW_CUSTOM_MAX; wireless_send_event(adapter->pnetdev,IWEVCUSTOM,&wrqu,buff); if(buff) _mfree(buff, IW_CUSTOM_MAX); } _func_exit_; }
u8 set_802_11_remove_key(_adapter* padapter, NDIS_802_11_REMOVE_KEY *key){ uint encryptionalgo; u8 * pbssid; struct sta_info *stainfo; u8 bgroup = (key->KeyIndex & 0x4000000) > 0 ? _FALSE: _TRUE; u8 keyIndex = (u8)key->KeyIndex & 0x03; u8 ret=_SUCCESS; _func_enter_; if ((key->KeyIndex & 0xbffffffc) > 0) { ret=_FAIL; goto exit; } if (bgroup == _TRUE) { encryptionalgo= padapter->securitypriv.dot118021XGrpPrivacy; // clear group key by index //NdisZeroMemory(Adapter->MgntInfo.SecurityInfo.KeyBuf[keyIndex], MAX_WEP_KEY_LEN); //Adapter->MgntInfo.SecurityInfo.KeyLen[keyIndex] = 0; _memset(&padapter->securitypriv.dot118021XGrpKey[keyIndex-1], 0, 16); //! \todo Send a H2C Command to Firmware for removing this Key in CAM Entry. } else { pbssid=get_bssid(&padapter->mlmepriv); stainfo=get_stainfo(&padapter->stapriv , pbssid ); if(stainfo !=NULL){ encryptionalgo=stainfo->dot118021XPrivacy; // clear key by BSSID _memset(&stainfo->dot118021x_UncstKey, 0, 16); //! \todo Send a H2C Command to Firmware for disable this Key in CAM Entry. } else{ ret= _FAIL; goto exit; } } exit: _func_exit_; return _TRUE; }
void pwmout_init(pwmout_t* obj, PinName pin) { uint32_t peripheral; u32 pwm_idx; u32 pin_sel; DBG_PWM_INFO("%s: Init PWM for pin(0x%x)\n", __FUNCTION__, pin); // Get the peripheral name from the pin and assign it to the object peripheral = pinmap_peripheral(pin, PinMap_PWM); if (unlikely(peripheral == NC)) { DBG_PWM_ERR("%s: Cannot find matched pwm for this pin(0x%x)\n", __FUNCTION__, pin); return; } pwm_idx = RTL_GET_PERI_IDX(peripheral); pin_sel = RTL_GET_PERI_SEL(peripheral); obj->pwm_idx = pwm_idx; obj->pin_sel = pin_sel; obj->period = 0; obj->pulse = 0; _memset((void *)&obj->pwm_hal_adp, 0, sizeof(HAL_PWM_ADAPTER)); if (HAL_OK != HAL_Pwm_Init(&obj->pwm_hal_adp, pwm_idx, pin_sel)) { DBG_PWM_ERR("pwmout_init Err!\n"); return; } pwmout_period_us(obj, 20000); // 20 ms per default HAL_Pwm_Enable(&obj->pwm_hal_adp); }
static void _init_stainfo(struct sta_info *psta) { _func_enter_; _memset((u8 *)psta, 0, sizeof (struct sta_info)); _spinlock_init(&psta->lock); _init_listhead(&psta->list); _init_listhead(&psta->hash_list); //_init_listhead(&psta->asoc_list); //_init_listhead(&psta->sleep_list); //_init_listhead(&psta->wakeup_list); _init_queue(&psta->sleep_q); psta->sleepq_len = 0; _init_sta_xmit_priv(&psta->sta_xmitpriv); _init_sta_recv_priv(&psta->sta_recvpriv); #ifdef CONFIG_NATIVEAP_MLME _init_listhead(&psta->asoc_list); _init_listhead(&psta->auth_list); #endif _func_exit_; }
Int RcmClient_construct(RcmClient_Struct *structPtr, String server, const RcmClient_Params *params) { RcmClient_Object *obj = (RcmClient_Object*)structPtr; Int status = RcmClient_S_SUCCESS; Log_print1(Diags_ENTRY, "--> %s: ()", (IArg)FXNN); /* TODO: add check that params was initialized correctly */ Log_print1(Diags_LIFECYCLE, FXNN": instance construct: 0x%x", (IArg)obj); /* ensure the constructed object is zeroed */ _memset((Void *)obj, 0, sizeof(RcmClient_Object)); /* object-specific initialization */ status = RcmClient_Instance_init(obj, server, params); if (status < 0) { RcmClient_Instance_finalize(obj); goto leave; } leave: Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status); return(status); }
void create_partitions(void){ if (is_mbr_loaded()) { unsigned long start, length; char type; _memset(mbr_buf,0,SECTOR_SIZE); start=1; length=2*1024*1024/SECTOR_SIZE; //2 Mb type=1; // FAT primary mbr_buf[0x1BE + 4]=type; mbr_buf[0x1BE + 8]=start; mbr_buf[0x1BE + 9]=start>>8; mbr_buf[0x1BE + 10]=start>>16; mbr_buf[0x1BE + 11]=start>>24; mbr_buf[0x1BE + 12]=length; mbr_buf[0x1BE + 13]=length>>8; mbr_buf[0x1BE + 14]=length>>16; mbr_buf[0x1BE + 15]=length>>24; start=start+length; length=drive_sectors-start-1; type=0x0B; //FAT32 primary; mbr_buf[0x1CE + 4]=type; mbr_buf[0x1CE + 8]=start; mbr_buf[0x1CE + 9]=start>>8; mbr_buf[0x1CE + 10]=start>>16; mbr_buf[0x1CE + 11]=start>>24; mbr_buf[0x1CE + 12]=length; mbr_buf[0x1CE + 13]=length>>8; mbr_buf[0x1CE + 14]=length>>16; mbr_buf[0x1CE + 15]=length>>24; mbr_buf[0x1FE]=0x55; mbr_buf[0x1FF]=0xAA; // signature; _WriteSDCard(0,0,1,mbr_buf); } }
char *cmph_op_clear(bot_t * bot, cmphx_t ** cmphx, char *string) { cmphx_t *cmphx_ptr = NULL; char *str = NULL; if (!bot || !cmphx) return NULL; cmphx_ptr = *cmphx; /* if(!cmphx_ptr) return NULL; if(!cmphx_ptr->hash) return NULL; if(cmphx_ptr->config) cmph_config_destroy(cmphx_ptr->config); if(cmphx_ptr->source) cmph_io_vector_adapter_destroy(cmphx_ptr->source); if(cmphx_ptr->fp) fclose(cmphx_ptr->fp); cmph_destroy(cmphx_ptr->hash); */ _memset(cmphx_ptr, 0, sizeof(cmphx_t)); //free(cmphx_ptr); //*cmphx = NULL; puts("GRRRRRRRRRR"); sleep(5); return str; }
void Terminal::scrollUp() { --_row; memcpy(vga::buffer, &vga::buffer[vga::coordToIndex(0, 1)], (vga::width * (vga::height - 1)) * sizeof(vga::Entry)); _memset(&vga::buffer[vga::coordToIndex(0, vga::height - 1)], static_cast<uint16_t>(_emptyCell), vga::width); }
void bit_vec_zero(bit_vector_t * bv) { if (!bv) return; _memset(bv->vec, 0, bv->sz * 8); return; }
char *map_change_string(dlist_t * dlist_node, bot_t * bot, char *string, int opt, char *opt_sep, char *opt_append, char *opt_str) { dlist_t *dl, *dptr; char *str = NULL, *tok_ptr; char buf[MAX_BUF_SZ]; char *sep_ptr; if (!string || !opt_str || !opt_sep || !opt_append) return NULL; sep_ptr = str_find_sep(string); if (sep_ptr) string = sep_ptr; dl = tokenize(bot, string, TOKENIZE_NORMAL | TOKENIZE_LEAVEQUOTES | TOKENIZE_LEAVESEP, opt_sep); if (!dl) return NULL; _memset(buf, 0, sizeof(buf)); dlist_fornext(dl, dptr) { tok_ptr = (char *)dlist_data(dptr); if (!tok_ptr) continue; strlcatfmt_buf(buf, "%s %s%s", opt_str, tok_ptr, opt_append); }
bot_t *shake1_fini(dlist_t * dlist_node, bot_t * bot) { debug(bot, "shake1_fini: Entered\n"); shake1_info.initialized = 0; if (shake1_info.fp_1) fclose(shake1_info.fp_1); if (shake1_info.fp_1_offsets) free(shake1_info.fp_1_offsets); if (shake1_info.fp_2) fclose(shake1_info.fp_2); if (shake1_info.fp_2_offsets) free(shake1_info.fp_2_offsets); if (shake1_info.fp_3) fclose(shake1_info.fp_3); if (shake1_info.fp_3_offsets) free(shake1_info.fp_3_offsets); _memset(&shake1_info, 0, sizeof(shake1_info)); return NULL; }
char *gnull_process_options(gnull_t * gnull, char *string) { char *str = NULL; char buf[MAX_BUF_SZ]; char *sep_ptr; dlist_t *dl = NULL, *dptr; debug(NULL, "gnull_process_options: Entered\n"); if (!gnull || !string) return NULL; sep_ptr = str_find_sep(string); if (sep_ptr) string = sep_ptr; _memset(buf, 0, sizeof(buf)); dl = tokenize(NULL, string, TOKENIZE_NORMAL | TOKENIZE_LEAVEQUOTES, "..."); if (!dl) return NULL; dlist_fornext(dl, dptr) { gnull_process_options_parse(gnull, (char *)dlist_data(dptr)); }
u8 set_802_11_remove_wep(_adapter* padapter, u32 keyindex) { u8 ret = _SUCCESS; _func_enter_; if (keyindex >= 0x80000000 || padapter == NULL) { ret=_FALSE; goto exit; } else { int res; struct security_priv* psecuritypriv = &padapter->securitypriv; if (keyindex < WEP_KEYS) { _memset(&psecuritypriv->dot11DefKey[keyindex], 0, 16); res = set_key(padapter,psecuritypriv, keyindex); psecuritypriv->dot11DefKeylen[keyindex] = 0; if (res == _FAIL) ret=_FAIL; } else { ret=_FAIL; } } exit: _func_exit_; return ret; }
void set_supported_rate(u8* SupportedRates, uint mode) { _func_enter_; _memset(SupportedRates, 0, NDIS_802_11_LENGTH_RATES_EX); switch (mode) { case WIRELESS_11B: _memcpy(SupportedRates, WIFI_CCKRATES, IEEE80211_CCK_RATE_LEN); break; case WIRELESS_11G: case WIRELESS_11A: _memcpy(SupportedRates, WIFI_OFDMRATES, IEEE80211_NUM_OFDM_RATESLEN); break; case WIRELESS_11BG: _memcpy(SupportedRates, WIFI_CCKRATES, IEEE80211_CCK_RATE_LEN); _memcpy(SupportedRates + IEEE80211_CCK_RATE_LEN, WIFI_OFDMRATES, IEEE80211_NUM_OFDM_RATESLEN); break; } _func_exit_; }
char *quote_change_string(char *string, char *opt_title) { dlist_t *dptr_pair = NULL; xdb_pair_t *pair = NULL; char *str; char buf[MAX_BUF_SZ]; char *sep_ptr; str = NULL; sep_ptr = str_find_sep(string); if (sep_ptr) string = sep_ptr; _memset(buf, 0, sizeof(buf)); if (!opt_title) { dptr_pair = (dlist_t *) dlist_node_rand(dl_quote_pairs); if (!dptr_pair) return NULL; pair = (xdb_pair_t *) dlist_data(dptr_pair); } else { pair = xdb_pair_find_by_key(dl_quote_pairs, opt_title); } if (!pair) return NULL; str = quote_get(pair, string); return str; }
bot_t *me_run(dlist_t * dlist_node, bot_t * bot) { char *dl_module_arg_after_options, *dl_options_ptr; int opt = 0; me_t me; debug(bot, "me_run: Entered\n"); if (!dlist_node || !bot) return NULL; debug(bot, "me_run: Entered: initial output buf=[%s], input buf=[%s], mod_arg=[%s]\n", bot->txt_data_out, bot->txt_data_in, bot->dl_module_arg); stat_inc(bot, bot->trig_called); if (_bot_shouldreturn(bot)) return NULL; _memset(&me, 0, sizeof(me)); MOD_OPTIONS_TOP_HALF; me_parse_options(dl_options_ptr, &me); MOD_OPTIONS_BOTTOM_HALF; bot->shouldsend = 1; MOD_PARSE_TOP_HALF_NODL; l_new_str = me_change_string(l_str_ptr, opt, &me); MOD_PARSE_BOTTOM_HALF_NODL; return bot; }
char * clean_quote (char *str) { int i; char buf[QUOTE_BUF_SZ]; i = 0; _memset (buf, 0, sizeof (buf)); while (*str) { if (*str == ' ' || *str == '\t') { buf[i] = *str; i++; while (*str == ' ' || *str == '\t') str++; //str++; continue; } else buf[i] = *str; i++; str++; } return strdup (buf); }
void memset(void *target, unsigned char c, size_t len) { int ch = DMA_CHANNEL; unsigned int d; unsigned char *dp; if(len < 32) _memset(target,c,len); else { if(((unsigned int)target < 0xa0000000) && len) dma_cache_wback_inv((unsigned long)target, len); dp = (unsigned char *)((unsigned int)(&d) | 0xa0000000); *(dp + 0) = c; *(dp + 1) = c; *(dp + 2) = c; *(dp + 3) = c; REG_DMAC_DSAR(ch) = PHYSADDR((unsigned long)dp); REG_DMAC_DTAR(ch) = PHYSADDR((unsigned long)target); REG_DMAC_DTCR(ch) = len / 32; REG_DMAC_DRSR(ch) = DMAC_DRSR_RS_AUTO; REG_DMAC_DCMD(ch) = DMAC_DCMD_DAI | DMAC_DCMD_SWDH_32 | DMAC_DCMD_DWDH_32 | DMAC_DCMD_DS_32BYTE; REG_DMAC_DCCSR(ch) = DMAC_DCCSR_EN | DMAC_DCCSR_NDES; while (REG_DMAC_DTCR(ch)); if(len % 32) { dp = (unsigned char *)((unsigned int)target + (len & (32 - 1))); for(d = 0;d < (len % 32); d++) *dp++ = c; } } }
void RAMInit(void) { u32 vmode = *(vu32*)0x800000CC; _memset( (void*)0x80000020, 0, 0xE0 ); //Keep ISO Header _memset( (void*)0x80003000, 0, 0x12FD000 ); sync_before_exec( (void*)0x80003000, 0x12FD000 ); _memset( (void*)0x81310000, 0, 0x4F0000 ); sync_before_exec( (void*)0x81340000, 0x4F0000 ); *(vu32*)0x80000020 = 0x0D15EA5E; *(vu32*)0x80000028 = 0x01800000; *(vu32*)0x8000002C = *(vu32*)0xCC00302C >> 28; // console type *(vu32*)0x800000CC = vmode; //Assuming it didnt change *(vu32*)0x800000F0 = 0x01800000; *(vu16*)0xCC00501A = 156; }
int bot_unix_init(void) { struct sockaddr_un *un; int s; struct stat st; debug(NULL, "bot_unix_init: Entered\n"); if (global_info.fd_unix > 0) return 0; if (!_sNULL(global_info.fd_unix_path)) strlcat_buf(global_info.fd_unix_path, str_unite_static("%s/%s", gi->confdir, BOT_UNIX_SOCKPATH)); debug(NULL, "bot_unix_init: fd_unix_path=%s\n", gi->fd_unix_path); un = (struct sockaddr_un *)&global_info.fd_unix_un; if (stat(global_info.fd_unix_path, &st) >= 0) { unlink(global_info.fd_unix_path); } _memset(un, 0, sizeof(struct sockaddr_un)); un->sun_family = AF_UNIX; strlcpy_buf(un->sun_path, global_info.fd_unix_path); s = socket(AF_UNIX, SOCK_STREAM, 0); if (s < 0) { perror("socket "); return -1; } if (bind(s, (struct sockaddr *)un, sizeof(struct sockaddr_un)) < 0) { perror("bind "); goto cleanup; } if (listen(s, 10) < 0) { perror("listen "); goto cleanup; } global_info.fd_unix = s; safe_event_set(&global_info.ev_unix, global_info.fd_unix, EV_READ | EV_PERSIST, bot_evhook_unix_accept, NULL); safe_event_add(&global_info.ev_unix, NULL); return 0; cleanup: if (s) safe_close(s); return -1; }
void handle_tkip_mic_err(_adapter *padapter,u8 bgroup) { #ifdef CONFIG_IOCTL_CFG80211 enum nl80211_key_type key_type; #endif //CONFIG_IOCTL_CFG80211 union iwreq_data wrqu; struct iw_michaelmicfailure ev; struct mlme_priv* pmlmepriv = &padapter->mlmepriv; _memset( &ev, 0x00, sizeof( ev ) ); #ifdef CONFIG_IOCTL_CFG80211 if ( bgroup ) { key_type |= NL80211_KEYTYPE_GROUP; } else { key_type |= NL80211_KEYTYPE_PAIRWISE; } cfg80211_michael_mic_failure(padapter->pnetdev, (u8 *)&pmlmepriv->assoc_bssid[ 0 ], key_type, -1, NULL, GFP_ATOMIC); #endif if ( bgroup ) { ev.flags |= IW_MICFAILURE_GROUP; } else { ev.flags |= IW_MICFAILURE_PAIRWISE; } ev.src_addr.sa_family = ARPHRD_ETHER; _memcpy( ev.src_addr.sa_data, &pmlmepriv->assoc_bssid[ 0 ], ETH_ALEN ); _memset( &wrqu, 0x00, sizeof( wrqu ) ); wrqu.data.length = sizeof( ev ); wireless_send_event( padapter->pnetdev, IWEVMICHAELMICFAILURE, &wrqu, (char*) &ev ); }
void unregister_intf_hdl(struct intf_hdl *pintfhdl) { _func_enter_; _unload_intf_hdl(pintfhdl->pintfpriv); _memset((u8 *)pintfhdl, 0, sizeof(struct intf_hdl)); _func_exit_; }
// // // notes: Review: Is 8 hard code a problem here since it appears to only be for some LCDs? // void _reentrant SMVBlackBackground(void) { int i,iTempWidth,iTempHeight; iTempWidth=stc_iVideoWidth; iTempHeight=stc_iVideoHeight; stc_iVideoWidth=LCD_SIZE_X; stc_iVideoHeight=LCD_SIZE_Y; _memset( SmvInputBuffer, 0, LCD_SIZE_X * 8 ); for(i=0;i<LCD_SIZE_Y;i+=8) HALDisplaySendData(0,i,LCD_SIZE_X,8,SmvInputBuffer,DISPLAY_COLOR); stc_iVideoWidth=iTempWidth; stc_iVideoHeight=iTempHeight; }
bot_t *mongodb_fini(bot_t * bot) { /* SUPERFIX */ mongo_destroy(&gi->mongo_conn); _memset(&gi->mongo_conn, 0, sizeof(gi->mongo_conn)); debug(bot, "mongodb_fini: Destroying mongo connection\n"); return bot; }
//--------------------------------------------------------------------------------------------------- //Function Name: // RtkI2CIrqDeInit // // Description: // I2C interrupt de-initialization function. // According to the given I2C device number, the I2C interrupt will be unreigster // from the platform and the relative interrupt handler will be cleared. // // Arguments: // [in] VOID *Data - // I2C SAL handle // // Return: // The status of the I2C interrupt de-initialization process. // _EXIT_SUCCESS if the RtkI2CIrqDeInit succeeded. // _EXIT_FAILURE if the RtkI2CIrqDeInit failed. // // Note: // NA // // See Also: // NA // // Author: // By Jason Deng, 2014-04-03. // //---------------------------------------------------------------------------------------------------- static RTK_STATUS RtkDACDMADeInit( IN PSAL_DAC_HND pSalDACHND ){ PSAL_DAC_HND_PRIV pSalDACHNDPriv = NULL; PSAL_DAC_MNGT_ADPT pSalDACMngtAdpt = NULL; PHAL_GDMA_ADAPTER pHALDACGdmaAdpt = NULL; PHAL_GDMA_OP pHALDACGdmaOp = NULL; PIRQ_HANDLE pIrqHandleDACGdma = NULL; /*To Get the SAL_I2C_MNGT_ADPT Pointer*/ pSalDACHNDPriv = CONTAINER_OF(pSalDACHND, SAL_DAC_HND_PRIV, SalDACHndPriv); pSalDACMngtAdpt = CONTAINER_OF(pSalDACHNDPriv->ppSalDACHnd, SAL_DAC_MNGT_ADPT, pSalHndPriv); pHALDACGdmaAdpt = pSalDACMngtAdpt->pHalGdmaAdp; pHALDACGdmaOp = pSalDACMngtAdpt->pHalGdmaOp; pIrqHandleDACGdma = pSalDACMngtAdpt->pIrqGdmaHnd; if (RtkDACIdxChk(pSalDACHND->DevNum)) return _EXIT_FAILURE; HalGdmaOpInit(pHALDACGdmaOp); pHALDACGdmaAdpt->IsrCtrl = DISABLE; pHALDACGdmaOp->HalGdmaChIsrEnAndDis((VOID*)pHALDACGdmaAdpt); pHALDACGdmaOp->HalGdmaChIsrClean((VOID*)pHALDACGdmaAdpt); pHALDACGdmaOp->HalGdmaChDis((VOID*)pHALDACGdmaAdpt); InterruptUnRegister(pIrqHandleDACGdma); #if 0 _memset((void *)pIrqHandleDACGdma , 0, sizeof(IRQ_HANDLE)); _memset((void *)pHALDACGdmaOp , 0, sizeof(HAL_GDMA_OP)); _memset((void *)pHALDACGdmaAdpt , 0, sizeof(HAL_GDMA_ADAPTER)); #endif return _EXIT_SUCCESS; }
/* sitesurvey_cmd(~) ### NOTE:#### (!!!!) MUST TAKE CARE THAT BEFORE CALLING THIS FUNC, YOU SHOULD HAVE LOCKED pmlmepriv->lock */ u8 sitesurvey_cmd(_adapter *padapter, NDIS_802_11_SSID *pssid) { struct cmd_obj* ph2c; struct sitesurvey_parm* psurveyPara; struct cmd_priv *pcmdpriv = &padapter->cmdpriv; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; _func_enter_; ph2c = (struct cmd_obj*)_malloc(sizeof(struct cmd_obj)); if (ph2c == NULL) return _FAIL; psurveyPara = (struct sitesurvey_parm*)_malloc(sizeof(struct sitesurvey_parm)); if (psurveyPara == NULL) { _mfree((unsigned char*) ph2c, sizeof(struct cmd_obj)); return _FAIL; } free_network_queue(padapter); RT_TRACE(_module_rtl871x_cmd_c_, _drv_info_, ("\nflush network queue\n\n")); init_h2fwcmd_w_parm_no_rsp(ph2c, psurveyPara, GEN_CMD_CODE(_SiteSurvey)); psurveyPara->bsslimit = cpu_to_le32(48); psurveyPara->passive_mode = cpu_to_le32(1); psurveyPara->ss_ssidlen= cpu_to_le32(0);// pssid->SsidLength; if (pssid->SsidLength) { _memcpy(psurveyPara->ss_ssid, pssid->Ssid, pssid->SsidLength); psurveyPara->ss_ssidlen = cpu_to_le32(pssid->SsidLength); } else { _memset(psurveyPara->ss_ssid, 0, IW_ESSID_MAX_SIZE + 1); } set_fwstate(pmlmepriv, _FW_UNDER_SURVEY); enqueue_cmd(pcmdpriv, ph2c); _set_timer(&pmlmepriv->scan_to_timer, SCANNING_TIMEOUT); _func_exit_; return _SUCCESS; }
static void _init_stainfo(struct sta_info *psta) { _func_enter_; _memset((u8 *)psta, 0, sizeof (struct sta_info)); _spinlock_init(&psta->lock); _init_listhead(&psta->list); _init_listhead(&psta->hash_list); //_init_listhead(&psta->asoc_list); //_init_listhead(&psta->sleep_list); //_init_listhead(&psta->wakeup_list); _init_queue(&psta->sleep_q); psta->sleepq_len = 0; _init_sta_xmit_priv(&psta->sta_xmitpriv); _init_sta_recv_priv(&psta->sta_recvpriv); #ifdef CONFIG_AP_MODE _init_listhead(&psta->asoc_list); _init_listhead(&psta->auth_list); psta->expire_to = 0; psta->flags = 0; psta->capability = 0; #ifdef CONFIG_NATIVEAP_MLME psta->nonerp_set = 0; psta->no_short_slot_time_set = 0; psta->no_short_preamble_set = 0; psta->no_ht_gf_set = 0; psta->no_ht_set = 0; psta->ht_20mhz_set = 0; #endif #endif _func_exit_; }
void _reentrant ConvName(_packed BYTE *fname, int DeviceNumber) { INT i,byte; INT off0 = 0, off1 = 0; _memset(namebuffer,0, 86); // 86*3 = 258 byte = FSGetByte(fname,0,Y_MEMORY); if (byte == 0x2f) { namebuffer[0] = 0x2f3a00 | DriveLetter[DeviceNumber]; off0 = 1; off1 = 3; } for (i = 0; i < 253; i++) { byte = FSGetByte(fname,i+off0,Y_MEMORY); PutByte(namebuffer,byte,i+off1,Y_MEMORY); } }