u32 _r8712_init_sta_priv(struct sta_priv *pstapriv) { struct sta_info *psta; s32 i; pstapriv->pallocated_stainfo_buf = _malloc(sizeof(struct sta_info) * NUM_STA + 4); if (pstapriv->pallocated_stainfo_buf == NULL) return _FAIL; pstapriv->pstainfo_buf = pstapriv->pallocated_stainfo_buf + 4 - ((addr_t)(pstapriv->pallocated_stainfo_buf) & 3); _init_queue(&pstapriv->free_sta_queue); spin_lock_init(&pstapriv->sta_hash_lock); pstapriv->asoc_sta_count = 0; _init_queue(&pstapriv->sleep_q); _init_queue(&pstapriv->wakeup_q); psta = (struct sta_info *)(pstapriv->pstainfo_buf); for (i = 0; i < NUM_STA; i++) { _init_stainfo(psta); _init_listhead(&(pstapriv->sta_hash[i])); list_insert_tail(&psta->list, get_list_head(&pstapriv->free_sta_queue)); psta++; } _init_listhead(&pstapriv->asoc_list); _init_listhead(&pstapriv->auth_list); return _SUCCESS; }
u32 _r8712_init_sta_priv(struct sta_priv *pstapriv) { struct sta_info *psta; s32 i; pstapriv->pallocated_stainfo_buf = kmalloc(sizeof(struct sta_info) * NUM_STA + 4, GFP_ATOMIC); if (!pstapriv->pallocated_stainfo_buf) return _FAIL; pstapriv->pstainfo_buf = pstapriv->pallocated_stainfo_buf + 4 - ((addr_t)(pstapriv->pallocated_stainfo_buf) & 3); _init_queue(&pstapriv->free_sta_queue); spin_lock_init(&pstapriv->sta_hash_lock); pstapriv->asoc_sta_count = 0; _init_queue(&pstapriv->sleep_q); _init_queue(&pstapriv->wakeup_q); psta = (struct sta_info *)(pstapriv->pstainfo_buf); for (i = 0; i < NUM_STA; i++) { _init_stainfo(psta); INIT_LIST_HEAD(&(pstapriv->sta_hash[i])); list_add_tail(&psta->list, &pstapriv->free_sta_queue.queue); psta++; } INIT_LIST_HEAD(&pstapriv->asoc_list); INIT_LIST_HEAD(&pstapriv->auth_list); return _SUCCESS; }
u32 _init_sta_priv(struct sta_priv *pstapriv) { struct sta_info *psta; s32 i; _func_enter_; pstapriv->pallocated_stainfo_buf = _malloc (sizeof(struct sta_info) * NUM_STA+ 4); if(!pstapriv->pallocated_stainfo_buf) return _FAIL; pstapriv->pstainfo_buf = pstapriv->pallocated_stainfo_buf + 4 - ((unsigned int)(pstapriv->pallocated_stainfo_buf ) & 3); _init_queue(&pstapriv->free_sta_queue); _spinlock_init(&pstapriv->sta_hash_lock); //_init_queue(&pstapriv->asoc_q); pstapriv->asoc_sta_count = 0; _init_queue(&pstapriv->sleep_q); _init_queue(&pstapriv->wakeup_q); psta = (struct sta_info *)(pstapriv->pstainfo_buf); for(i = 0; i < NUM_STA; i++) { _init_stainfo(psta); _init_listhead(&(pstapriv->sta_hash[i])); list_insert_tail(&psta->list, get_list_head(&pstapriv->free_sta_queue)); psta++; } #ifdef CONFIG_NATIVEAP_MLME _init_listhead(&pstapriv->asoc_list); _init_listhead(&pstapriv->auth_list); //pstapriv->auth_to = ???; //pstapriv->assoc_to = ???; //pstapriv->expire_to = ???; #endif _func_exit_; return _SUCCESS; }
sint _init_evt_priv(struct evt_priv *pevtpriv) { sint res=_SUCCESS; _func_enter_; #ifdef CONFIG_EVENT_THREAD_MODE _init_sema(&(pevtpriv->evt_notify), 0); _init_sema(&(pevtpriv->terminate_evtthread_sema), 0); #endif #ifdef CONFIG_H2CLBK _init_sema(&(pevtpriv->lbkevt_done), 0); pevtpriv->lbkevt_limit = 0; pevtpriv->lbkevt_num = 0; pevtpriv->cmdevt_parm = NULL; #endif //allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf pevtpriv->event_seq = 0; pevtpriv->evt_allocated_buf = _malloc(MAX_EVTSZ + 4); if (pevtpriv->evt_allocated_buf == NULL){ res= _FAIL; goto exit; } pevtpriv->evt_buf = pevtpriv->evt_allocated_buf + 4 - ((unsigned int)(pevtpriv->evt_allocated_buf) & 3); pevtpriv->evt_done_cnt = 0; #ifdef CONFIG_SDIO_HCI pevtpriv->allocated_c2h_mem = _malloc(C2H_MEM_SZ +4); if (pevtpriv->allocated_c2h_mem == NULL){ res= _FAIL; goto exit; } pevtpriv->c2h_mem = pevtpriv->allocated_c2h_mem + 4\ - ( (u32)(pevtpriv->allocated_c2h_mem) & 3); #ifdef PLATFORM_OS_XP pevtpriv->pc2h_mdl= IoAllocateMdl((u8 *)pevtpriv->c2h_mem, C2H_MEM_SZ , FALSE, FALSE, NULL); if(pevtpriv->pc2h_mdl == NULL){ res= _FAIL; goto exit; } MmBuildMdlForNonPagedPool(pevtpriv->pc2h_mdl); #endif #endif exit: #ifdef CONFIG_RECV_BH _init_queue(&(pevtpriv->evt_queue)); #endif _func_exit_; return res; }
static int init_mp_priv(struct mp_priv *pmp_priv) { int i, res; struct mp_xmit_frame *pmp_xmitframe; _init_mp_priv_(pmp_priv); _init_queue(&pmp_priv->free_mp_xmitqueue); pmp_priv->pallocated_mp_xmitframe_buf = NULL; pmp_priv->pallocated_mp_xmitframe_buf = kmalloc(NR_MP_XMITFRAME * sizeof(struct mp_xmit_frame) + 4, GFP_ATOMIC); if (pmp_priv->pallocated_mp_xmitframe_buf == NULL) { res = _FAIL; goto _exit_init_mp_priv; } pmp_priv->pmp_xmtframe_buf = pmp_priv->pallocated_mp_xmitframe_buf + 4 - ((addr_t)(pmp_priv->pallocated_mp_xmitframe_buf) & 3); pmp_xmitframe = (struct mp_xmit_frame *)pmp_priv->pmp_xmtframe_buf; for (i = 0; i < NR_MP_XMITFRAME; i++) { INIT_LIST_HEAD(&(pmp_xmitframe->list)); list_add_tail(&(pmp_xmitframe->list), &(pmp_priv->free_mp_xmitqueue.queue)); pmp_xmitframe->pkt = NULL; pmp_xmitframe->frame_tag = MP_FRAMETAG; pmp_xmitframe->padapter = pmp_priv->papdater; pmp_xmitframe++; } pmp_priv->free_mp_xmitframe_cnt = NR_MP_XMITFRAME; res = _SUCCESS; _exit_init_mp_priv: return res; }
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_; }
static sint _init_cmd_priv(struct cmd_priv *pcmdpriv) { sema_init(&(pcmdpriv->cmd_queue_sema), 0); sema_init(&(pcmdpriv->terminate_cmdthread_sema), 0); _init_queue(&(pcmdpriv->cmd_queue)); /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */ pcmdpriv->cmd_seq = 1; pcmdpriv->cmd_allocated_buf = kmalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ, GFP_ATOMIC); if (pcmdpriv->cmd_allocated_buf == NULL) return _FAIL; pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf + CMDBUFF_ALIGN_SZ - ((addr_t)(pcmdpriv->cmd_allocated_buf) & (CMDBUFF_ALIGN_SZ-1)); pcmdpriv->rsp_allocated_buf = kmalloc(MAX_RSPSZ + 4, GFP_ATOMIC); if (pcmdpriv->rsp_allocated_buf == NULL) return _FAIL; pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf + 4 - ((addr_t)(pcmdpriv->rsp_allocated_buf) & 3); pcmdpriv->cmd_issued_cnt = 0; pcmdpriv->cmd_done_cnt = 0; pcmdpriv->rsp_cnt = 0; return _SUCCESS; }
static inline int KTrieSearchQBC( KTRIE_STRUCT * ks, unsigned char * T, int n, int(*match)(void * id, void *tree, int index, void *data, void *neg_list), void * data ) { int tshift; unsigned char *Tend; short *bcShift = (short*)ks->bcShift; int bcSize = ks->bcSize; _init_queue(&ks->q); Tend = T + n - bcSize; bcSize--; for( ;T <= Tend; n--, T++ ) { while( (tshift = bcShift[ T[bcSize] ]) > 0 ) { T += tshift; if( T > Tend ) return 0; } if( KTriePrefixMatchQ( ks, T, n, match, data ) ) return 0; } _process_queue(&ks->q,match,data); return 0; }
struct sta_info *r8712_alloc_stainfo(struct sta_priv *pstapriv, u8 *hwaddr) { uint tmp_aid; s32 index; struct list_head *phash_list; struct sta_info *psta; struct __queue *pfree_sta_queue; struct recv_reorder_ctrl *preorder_ctrl; int i = 0; u16 wRxSeqInitialValue = 0xffff; unsigned long flags; pfree_sta_queue = &pstapriv->free_sta_queue; spin_lock_irqsave(&(pfree_sta_queue->lock), flags); if (_queue_empty(pfree_sta_queue) == true) psta = NULL; else { psta = LIST_CONTAINOR(get_next(&pfree_sta_queue->queue), struct sta_info, list); list_delete(&(psta->list)); tmp_aid = psta->aid; _init_stainfo(psta); memcpy(psta->hwaddr, hwaddr, ETH_ALEN); index = wifi_mac_hash(hwaddr); if (index >= NUM_STA) { psta = NULL; goto exit; } phash_list = &(pstapriv->sta_hash[index]); list_insert_tail(&psta->hash_list, phash_list); pstapriv->asoc_sta_count++ ; /* */ for (i = 0; i < 16; i++) memcpy(&psta->sta_recvpriv.rxcache.tid_rxseq[i], &wRxSeqInitialValue, 2); /* */ for (i = 0; i < 16 ; i++) { preorder_ctrl = &psta->recvreorder_ctrl[i]; preorder_ctrl->padapter = pstapriv->padapter; preorder_ctrl->indicate_seq = 0xffff; preorder_ctrl->wend_b = 0xffff; preorder_ctrl->wsize_b = 64; _init_queue(&preorder_ctrl->pending_recvframe_queue); r8712_init_recv_timer(preorder_ctrl); } } exit: spin_unlock_irqrestore(&(pfree_sta_queue->lock), flags); return psta; }
struct sta_info *r8712_alloc_stainfo(struct sta_priv *pstapriv, u8 *hwaddr) { uint tmp_aid; s32 index; struct list_head *phash_list; struct sta_info *psta; struct __queue *pfree_sta_queue; struct recv_reorder_ctrl *preorder_ctrl; int i = 0; u16 wRxSeqInitialValue = 0xffff; unsigned long flags; pfree_sta_queue = &pstapriv->free_sta_queue; spin_lock_irqsave(&(pfree_sta_queue->lock), flags); if (_queue_empty(pfree_sta_queue) == true) psta = NULL; else { psta = LIST_CONTAINOR(get_next(&pfree_sta_queue->queue), struct sta_info, list); list_delete(&(psta->list)); tmp_aid = psta->aid; _init_stainfo(psta); memcpy(psta->hwaddr, hwaddr, ETH_ALEN); index = wifi_mac_hash(hwaddr); if (index >= NUM_STA) { psta = NULL; goto exit; } phash_list = &(pstapriv->sta_hash[index]); list_insert_tail(&psta->hash_list, phash_list); pstapriv->asoc_sta_count++; /* For the SMC router, the sequence number of first packet of WPS handshake * will be 0. In this case, this packet will be dropped by recv_decache function * if we use the 0x00 as the default value for tid_rxseq variable. So, we * initialize the tid_rxseq variable as the 0xffff. */ for (i = 0; i < 16; i++) memcpy(&psta->sta_recvpriv.rxcache.tid_rxseq[i], &wRxSeqInitialValue, 2); /* for A-MPDU Rx reordering buffer control */ for (i = 0; i < 16; i++) { preorder_ctrl = &psta->recvreorder_ctrl[i]; preorder_ctrl->padapter = pstapriv->padapter; preorder_ctrl->indicate_seq = 0xffff; preorder_ctrl->wend_b = 0xffff; preorder_ctrl->wsize_b = 64; _init_queue(&preorder_ctrl->pending_recvframe_queue); r8712_init_recv_timer(preorder_ctrl); } } exit: spin_unlock_irqrestore(&(pfree_sta_queue->lock), flags); return psta; }
static sint _init_mlme_priv(struct _adapter *padapter) { sint i; u8 *pbuf; struct wlan_network *pnetwork; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; memset((u8 *)pmlmepriv, 0, sizeof(struct mlme_priv)); pmlmepriv->nic_hdl = (u8 *)padapter; pmlmepriv->pscanned = NULL; pmlmepriv->fw_state = 0; pmlmepriv->cur_network.network.InfrastructureMode = Ndis802_11AutoUnknown; /* Maybe someday we should rename this variable to "active_mode"(Jeff)*/ pmlmepriv->passive_mode = 1; /* 1: active, 0: passive. */ spin_lock_init(&(pmlmepriv->lock)); spin_lock_init(&(pmlmepriv->lock2)); _init_queue(&(pmlmepriv->free_bss_pool)); _init_queue(&(pmlmepriv->scanned_queue)); set_scanned_network_val(pmlmepriv, 0); memset(&pmlmepriv->assoc_ssid, 0, sizeof(struct ndis_802_11_ssid)); pbuf = _malloc(MAX_BSS_CNT * (sizeof(struct wlan_network))); if (pbuf == NULL) return _FAIL; pmlmepriv->free_bss_buf = pbuf; pnetwork = (struct wlan_network *)pbuf; for (i = 0; i < MAX_BSS_CNT; i++) { _init_listhead(&(pnetwork->list)); list_insert_tail(&(pnetwork->list), &(pmlmepriv->free_bss_pool.queue)); pnetwork++; } pmlmepriv->sitesurveyctrl.last_rx_pkts = 0; pmlmepriv->sitesurveyctrl.last_tx_pkts = 0; pmlmepriv->sitesurveyctrl.traffic_busy = false; /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */ r8712_init_mlme_timer(padapter); return _SUCCESS; }
static inline int KTrieSearchQ( KTRIE_STRUCT * ks, unsigned char * T, int n, int(*match)(void * id, void *tree, int index, void *data, void *neg_list), void * data ) { _init_queue(&ks->q); while( n > 0 ) { if( KTriePrefixMatchQ( ks, T++, n--, match, data ) ) return 0; } _process_queue(&ks->q,match,data); return 0; }
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 _init_sta_recv_priv(struct sta_recv_priv *psta_recvpriv) { _func_enter_; _memset((u8 *)psta_recvpriv, 0, sizeof (struct sta_recv_priv)); _spinlock_init(&psta_recvpriv->lock); //for(i=0; i<MAX_RX_NUMBLKS; i++) // _init_queue(&psta_recvpriv->blk_strms[i]); _init_queue(&psta_recvpriv->defrag_q); _func_exit_; }
sint _init_cmd_priv (struct cmd_priv *pcmdpriv) { sint res=_SUCCESS; _func_enter_; _init_sema(&(pcmdpriv->cmd_queue_sema), 0); //_init_sema(&(pcmdpriv->cmd_done_sema), 0); _init_sema(&(pcmdpriv->terminate_cmdthread_sema), 0); _init_queue(&(pcmdpriv->cmd_queue)); //allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf pcmdpriv->cmd_seq = 1; pcmdpriv->cmd_allocated_buf = _malloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ); if (pcmdpriv->cmd_allocated_buf == NULL){ res= _FAIL; goto exit; } pcmdpriv->cmd_buf = pcmdpriv->cmd_allocated_buf + CMDBUFF_ALIGN_SZ - ( (uint)(pcmdpriv->cmd_allocated_buf) & (CMDBUFF_ALIGN_SZ-1)); pcmdpriv->rsp_allocated_buf = _malloc(MAX_RSPSZ + 4); if (pcmdpriv->rsp_allocated_buf == NULL){ res= _FAIL; goto exit; } pcmdpriv->rsp_buf = pcmdpriv->rsp_allocated_buf + 4 - ( (uint)(pcmdpriv->rsp_allocated_buf) & 3); pcmdpriv->cmd_issued_cnt = pcmdpriv->cmd_done_cnt = pcmdpriv->rsp_cnt = 0; exit: _func_exit_; return res; }
sint _init_recv_priv(struct recv_priv *precvpriv, _adapter *padapter) { sint i; union recv_frame *precvframe; sint res=_SUCCESS; _func_enter_; _memset((unsigned char *)precvpriv, 0, sizeof (struct recv_priv)); _spinlock_init(&precvpriv->lock); _init_queue(&precvpriv->free_recv_queue); _init_queue(&precvpriv->recv_pending_queue); precvpriv->adapter = padapter; precvpriv->free_recvframe_cnt = NR_RECVFRAME; os_recv_resource_init(precvpriv, padapter); precvpriv->pallocated_frame_buf = _malloc(NR_RECVFRAME * sizeof(union recv_frame) + RXFRAME_ALIGN_SZ); if(precvpriv->pallocated_frame_buf==NULL){ res= _FAIL; goto exit; } _memset(precvpriv->pallocated_frame_buf, 0, NR_RECVFRAME * sizeof(union recv_frame) + RXFRAME_ALIGN_SZ); precvpriv->precv_frame_buf = precvpriv->pallocated_frame_buf + RXFRAME_ALIGN_SZ - ((uint) (precvpriv->pallocated_frame_buf) &(RXFRAME_ALIGN_SZ-1)); precvframe = (union recv_frame*) precvpriv->precv_frame_buf; for(i=0; i < NR_RECVFRAME ; i++) { _init_listhead(&(precvframe->u.list)); list_insert_tail(&(precvframe->u.list), &(precvpriv->free_recv_queue.queue)); res = os_recv_resource_alloc(padapter, precvframe); precvframe->u.hdr.adapter =padapter; precvframe++; } #ifdef CONFIG_USB_HCI precvpriv->rx_pending_cnt=1; _init_sema(&precvpriv->allrxreturnevt, 0); #endif res = init_recv_priv(precvpriv, padapter); exit: _func_exit_; return res; }
static void _init_txservq(struct tx_servq *ptxservq) { INIT_LIST_HEAD(&ptxservq->tx_pending); _init_queue(&ptxservq->sta_pending); ptxservq->qcnt = 0; }
sint _r8712_init_xmit_priv(struct xmit_priv *pxmitpriv, struct _adapter *padapter) { sint i; struct xmit_buf *pxmitbuf; struct xmit_frame *pxframe; memset((unsigned char *)pxmitpriv, 0, sizeof(struct xmit_priv)); spin_lock_init(&pxmitpriv->lock); sema_init(&pxmitpriv->xmit_sema, 0); sema_init(&pxmitpriv->terminate_xmitthread_sema, 0); /* Please insert all the queue initializaiton using _init_queue below */ pxmitpriv->adapter = padapter; _init_queue(&pxmitpriv->be_pending); _init_queue(&pxmitpriv->bk_pending); _init_queue(&pxmitpriv->vi_pending); _init_queue(&pxmitpriv->vo_pending); _init_queue(&pxmitpriv->bm_pending); _init_queue(&pxmitpriv->legacy_dz_queue); _init_queue(&pxmitpriv->apsd_queue); _init_queue(&pxmitpriv->free_xmit_queue); /* Please allocate memory with the sz = (struct xmit_frame) * NR_XMITFRAME, and initialize free_xmit_frame below. Please also apply free_txobj to link_up all the xmit_frames... */ pxmitpriv->pallocated_frame_buf = _malloc(NR_XMITFRAME * sizeof(struct xmit_frame) + 4); if (pxmitpriv->pallocated_frame_buf == NULL) { pxmitpriv->pxmit_frame_buf = NULL; return _FAIL; } pxmitpriv->pxmit_frame_buf = pxmitpriv->pallocated_frame_buf + 4 - ((addr_t) (pxmitpriv->pallocated_frame_buf) & 3); pxframe = (struct xmit_frame *) pxmitpriv->pxmit_frame_buf; for (i = 0; i < NR_XMITFRAME; i++) { _init_listhead(&(pxframe->list)); pxframe->padapter = padapter; pxframe->frame_tag = DATA_FRAMETAG; pxframe->pkt = NULL; pxframe->buf_addr = NULL; pxframe->pxmitbuf = NULL; list_insert_tail(&(pxframe->list), &(pxmitpriv->free_xmit_queue.queue)); pxframe++; } pxmitpriv->free_xmitframe_cnt = NR_XMITFRAME; /* init xmit hw_txqueue */ _r8712_init_hw_txqueue(&pxmitpriv->be_txqueue, BE_QUEUE_INX); _r8712_init_hw_txqueue(&pxmitpriv->bk_txqueue, BK_QUEUE_INX); _r8712_init_hw_txqueue(&pxmitpriv->vi_txqueue, VI_QUEUE_INX); _r8712_init_hw_txqueue(&pxmitpriv->vo_txqueue, VO_QUEUE_INX); _r8712_init_hw_txqueue(&pxmitpriv->bmc_txqueue, BMC_QUEUE_INX); pxmitpriv->frag_len = MAX_FRAG_THRESHOLD; pxmitpriv->txirp_cnt = 1; sema_init(&(pxmitpriv->tx_retevt), 0); /*per AC pending irp*/ pxmitpriv->beq_cnt = 0; pxmitpriv->bkq_cnt = 0; pxmitpriv->viq_cnt = 0; pxmitpriv->voq_cnt = 0; /*init xmit_buf*/ _init_queue(&pxmitpriv->free_xmitbuf_queue); _init_queue(&pxmitpriv->pending_xmitbuf_queue); pxmitpriv->pallocated_xmitbuf = _malloc(NR_XMITBUFF * sizeof(struct xmit_buf) + 4); if (pxmitpriv->pallocated_xmitbuf == NULL) return _FAIL; pxmitpriv->pxmitbuf = pxmitpriv->pallocated_xmitbuf + 4 - ((addr_t)(pxmitpriv->pallocated_xmitbuf) & 3); pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf; for (i = 0; i < NR_XMITBUFF; i++) { _init_listhead(&pxmitbuf->list); pxmitbuf->pallocated_buf = _malloc(MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ); if (pxmitbuf->pallocated_buf == NULL) return _FAIL; pxmitbuf->pbuf = pxmitbuf->pallocated_buf + XMITBUF_ALIGN_SZ - ((addr_t) (pxmitbuf->pallocated_buf) & (XMITBUF_ALIGN_SZ - 1)); r8712_xmit_resource_alloc(padapter, pxmitbuf); list_insert_tail(&pxmitbuf->list, &(pxmitpriv->free_xmitbuf_queue.queue)); pxmitbuf++; } pxmitpriv->free_xmitbuf_cnt = NR_XMITBUFF; alloc_hwxmits(padapter); init_hwxmits(pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry); tasklet_init(&pxmitpriv->xmit_tasklet, (void(*)(addr_t))r8712_xmit_bh, (addr_t)padapter); return _SUCCESS; }
static void _init_txservq(struct tx_servq *ptxservq) { _init_listhead(&ptxservq->tx_pending); _init_queue(&ptxservq->sta_pending); ptxservq->qcnt = 0; }
u32 _init_sta_priv(struct sta_priv *pstapriv) { struct sta_info *psta; s32 i; _func_enter_; #ifdef MEM_ALLOC_REFINE pstapriv->pallocated_stainfo_buf = rtw_zvmalloc (sizeof(struct sta_info) * NUM_STA+ 4); #else pstapriv->pallocated_stainfo_buf = rtw_zmalloc (sizeof(struct sta_info) * NUM_STA+ 4); #endif if(!pstapriv->pallocated_stainfo_buf) return _FAIL; pstapriv->pstainfo_buf = pstapriv->pallocated_stainfo_buf + 4 - ((SIZE_PTR)(pstapriv->pallocated_stainfo_buf ) & 3); _init_queue(&pstapriv->free_sta_queue); _spinlock_init(&pstapriv->sta_hash_lock); //_init_queue(&pstapriv->asoc_q); pstapriv->asoc_sta_count = 0; _init_queue(&pstapriv->sleep_q); _init_queue(&pstapriv->wakeup_q); psta = (struct sta_info *)(pstapriv->pstainfo_buf); for(i = 0; i < NUM_STA; i++) { _init_stainfo(psta); _init_listhead(&(pstapriv->sta_hash[i])); list_insert_tail(&psta->list, get_list_head(&pstapriv->free_sta_queue)); psta++; } #ifdef CONFIG_AP_MODE pstapriv->sta_dz_bitmap = 0; pstapriv->tim_bitmap = 0; _init_listhead(&pstapriv->asoc_list); _init_listhead(&pstapriv->auth_list); pstapriv->auth_to = 3; // 3*2 = 6 sec pstapriv->assoc_to = 3; pstapriv->expire_to = 900;// 900*2 = 1800 sec = 30 min, expire after no any traffic. pstapriv->max_num_sta = NUM_STA; #endif _func_exit_; return _SUCCESS; }
//struct sta_info *alloc_stainfo(_queue *pfree_sta_queue, unsigned char *hwaddr) struct sta_info *alloc_stainfo(struct sta_priv *pstapriv, u8 *hwaddr) { _irqL irqL, irqL2; uint tmp_aid; s32 index; _list *phash_list; struct sta_info *psta; _queue *pfree_sta_queue; struct recv_reorder_ctrl *preorder_ctrl; int i = 0; u16 wRxSeqInitialValue = 0xffff; _func_enter_; pfree_sta_queue = &pstapriv->free_sta_queue; _enter_critical_bh(&(pfree_sta_queue->lock), &irqL); if (_queue_empty(pfree_sta_queue) == _TRUE) { psta = NULL; } else { psta = LIST_CONTAINOR(get_next(&pfree_sta_queue->queue), struct sta_info, list); list_delete(&(psta->list)); tmp_aid = psta->aid; _init_stainfo(psta); _memcpy(psta->hwaddr, hwaddr, ETH_ALEN); index = wifi_mac_hash(hwaddr); RT_TRACE(_module_rtl871x_sta_mgt_c_,_drv_info_,("alloc_stainfo: index = %x", index)); if(index >= NUM_STA){ RT_TRACE(_module_rtl871x_sta_mgt_c_,_drv_err_,("ERROR=> alloc_stainfo: index >= NUM_STA")); psta= NULL; goto exit; } phash_list = &(pstapriv->sta_hash[index]); _enter_critical_bh(&(pstapriv->sta_hash_lock), &irqL2); list_insert_tail(&psta->hash_list, phash_list); pstapriv->asoc_sta_count ++ ; _exit_critical_bh(&(pstapriv->sta_hash_lock), &irqL2); // Commented by Albert 2009/08/13 // For the SMC router, the sequence number of first packet of WPS handshake will be 0. // In this case, this packet will be dropped by recv_decache function if we use the 0x00 as the default value for tid_rxseq variable. // So, we initialize the tid_rxseq variable as the 0xffff. for( i = 0; i < 16; i++ ) { _memcpy( &psta->sta_recvpriv.rxcache.tid_rxseq[ i ], &wRxSeqInitialValue, 2 ); } RT_TRACE(_module_rtl871x_sta_mgt_c_,_drv_info_,("alloc number_%d stainfo with hwaddr = %x %x %x %x %x %x \n", pstapriv->asoc_sta_count , hwaddr[0], hwaddr[1], hwaddr[2],hwaddr[3],hwaddr[4],hwaddr[5])); init_addba_retry_timer(pstapriv->padapter, psta); //for A-MPDU Rx reordering buffer control for(i=0; i < 16 ; i++) { preorder_ctrl = &psta->recvreorder_ctrl[i]; preorder_ctrl->padapter = pstapriv->padapter; preorder_ctrl->enable = _FALSE; preorder_ctrl->indicate_seq = 0xffff; preorder_ctrl->wend_b= 0xffff; //preorder_ctrl->wsize_b = (NR_RECVBUFF-2); preorder_ctrl->wsize_b = 64;//64; _init_queue(&preorder_ctrl->pending_recvframe_queue); init_recv_timer(preorder_ctrl); } } exit: _exit_critical_bh(&(pfree_sta_queue->lock), &irqL); _func_exit_; return psta; }