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);
}
}
