int proc_get_survey_info(struct seq_file *m, void *v) { _irqL irqL; struct net_device *dev = m->private; _adapter *padapter = (_adapter *)rtw_netdev_priv(dev); struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); _queue *queue = &(pmlmepriv->scanned_queue); struct wlan_network *pnetwork = NULL; _list *plist, *phead; s32 notify_signal; u16 index = 0; _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); phead = get_list_head(queue); plist = get_next(phead); if ((!phead) || (!plist)) return 0; DBG_871X_SEL_NL(m, "%5s %-17s %3s %-3s %-4s %5s %s\n","index", "bssid", "ch", "dBm", "SdBm", "age", "ssid"); while(1) { if (rtw_end_of_queue_search(phead,plist)== _TRUE) break; pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); if (!pnetwork) break; if ( check_fwstate(pmlmepriv, _FW_LINKED)== _TRUE && is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)) { notify_signal = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);//dbm } else { notify_signal = translate_percentage_to_dbm(pnetwork->network.PhyInfo.SignalStrength);//dbm } DBG_871X_SEL_NL(m, "%5d "MAC_FMT" %3d %3d %4d %5d %s\n", ++index, MAC_ARG(pnetwork->network.MacAddress), pnetwork->network.Configuration.DSConfig, (int)pnetwork->network.Rssi, notify_signal, rtw_get_passing_time_ms((u32)pnetwork->last_scanned), //translate_percentage_to_dbm(pnetwork->network.PhyInfo.SignalStrength), pnetwork->network.Ssid.Ssid); plist = get_next(plist); } _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL); return 0; }
/*! Sets the item list for the listbox \author jfpatry \date Created: 2000-09-23 \date Modified: 2000-09-23 */ void listbox_set_item_list( listbox_t *listbox, list_t item_list, listbox_list_elem_to_string_fptr_t func ) { check_assertion( listbox != NULL, "listbox is NULL" ); listbox->item_list = item_list; listbox->cur_item = get_list_head(item_list); listbox->label_gen_func = func; update_button_enabled_states( listbox ); ui_set_dirty(); }
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; }
u8 rtw_access_ctrl(_adapter *padapter, u8 *mac_addr) { u8 res = _TRUE; #ifdef CONFIG_AP_MODE _irqL irqL; _list *plist, *phead; struct rtw_wlan_acl_node *paclnode; u8 match = _FALSE; struct sta_priv *pstapriv = &padapter->stapriv; struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; _queue *pacl_node_q =&pacl_list->acl_node_q; _enter_critical_bh(&(pacl_node_q->lock), &irqL); phead = get_list_head(pacl_node_q); plist = get_next(phead); while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) { paclnode = LIST_CONTAINOR(plist, struct rtw_wlan_acl_node, list); plist = get_next(plist); if(_rtw_memcmp(paclnode->addr, mac_addr, ETH_ALEN)) { if(paclnode->valid == _TRUE) { match = _TRUE; break; } } } _exit_critical_bh(&(pacl_node_q->lock), &irqL); if(pacl_list->mode == 1)//accept unless in deny list { res = (match == _TRUE) ? _FALSE:_TRUE; } else if(pacl_list->mode == 2)//deny unless in accept list { res = (match == _TRUE) ? _TRUE:_FALSE; } else { res = _TRUE; } #endif return res; }
struct xmit_buf *rtw_alloc_xmitbuf(PADAPTER padapter)//(_queue *pfree_xmit_queue) { /* Please remember to use all the osdep_service api, and lock/unlock or _enter/_exit critical to protect pfree_xmit_queue */ _irqL irqL; struct xmit_buf *pxmitbuf = NULL; struct xmit_priv *pxmitpriv = &padapter->xmitpriv; _list *plist, *phead; _queue *pfree_xmit_queue = &pxmitpriv->free_xmit_queue; _func_enter_; _enter_critical(&pfree_xmit_queue->lock, &irqL); if (_rtw_queue_empty(pfree_xmit_queue) == _TRUE) { DBG_871X("rtw_alloc_xmitbuf failed!\n"); pxmitbuf= NULL; } else { phead = get_list_head(pfree_xmit_queue); plist = get_next(phead); pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list); rtw_list_delete(&(pxmitbuf->list)); } if(pxmitbuf){ pxmitpriv->free_xmitbuf_cnt--; #ifdef DBG_XMIT_BUF DBG_871X("DBG_XMIT_BUF ALLOC no=%d, free_xmitbuf_cnt=%d\n",pxmitbuf->no, pxmitpriv->free_xmitbuf_cnt); #endif #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI) pxmitbuf->pkt_len = 0; pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead; #endif } _exit_critical(&pfree_xmit_queue->lock, &irqL); _func_exit_; return pxmitbuf; }
static void mfree_all_stainfo(struct sta_priv *pstapriv) { unsigned long irqL; struct list_head *plist, *phead; struct sta_info *psta = NULL; spin_lock_irqsave(&pstapriv->sta_hash_lock, irqL); phead = get_list_head(&pstapriv->free_sta_queue); plist = get_next(phead); while ((end_of_queue_search(phead, plist)) == false) { psta = LIST_CONTAINOR(plist, struct sta_info, list); plist = get_next(plist); } spin_unlock_irqrestore(&pstapriv->sta_hash_lock, irqL); }
struct xmit_buf* rtw_dequeue_xmitbuf(PADAPTER padapter) { _irqL irqL; _list *plist, *phead; struct xmit_buf *pxmitbuf = NULL; _queue *pframe_queue = NULL; struct xmit_priv *pxmitpriv = &padapter->xmitpriv; pframe_queue = &pxmitpriv->xmitbuf_pending_queue; _func_enter_; _enter_critical_bh(&pframe_queue->lock, &irqL); phead = get_list_head(pframe_queue); plist = get_next(phead); if(plist != phead) { pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list); rtw_list_delete(&pxmitbuf->list); }
void kfree_all_stainfo(struct sta_priv *pstapriv) { struct list_head *plist, *phead; struct sta_info *psta = NULL; spin_lock_bh(&pstapriv->sta_hash_lock); phead = get_list_head(&pstapriv->free_sta_queue); plist = get_next(phead); while (phead != plist) { psta = LIST_CONTAINOR(plist, struct sta_info, list); plist = get_next(plist); } spin_unlock_bh(&pstapriv->sta_hash_lock); }
void r8712_free_stainfo(struct _adapter *padapter, struct sta_info *psta) { int i; unsigned long irqL0; struct __queue *pfree_sta_queue; struct recv_reorder_ctrl *preorder_ctrl; struct sta_xmit_priv *pstaxmitpriv; struct xmit_priv *pxmitpriv = &padapter->xmitpriv; struct sta_priv *pstapriv = &padapter->stapriv; if (psta == NULL) return; pfree_sta_queue = &pstapriv->free_sta_queue; pstaxmitpriv = &psta->sta_xmitpriv; spin_lock_irqsave(&(pxmitpriv->vo_pending.lock), irqL0); r8712_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->vo_q.sta_pending); list_delete(&(pstaxmitpriv->vo_q.tx_pending)); spin_unlock_irqrestore(&(pxmitpriv->vo_pending.lock), irqL0); spin_lock_irqsave(&(pxmitpriv->vi_pending.lock), irqL0); r8712_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->vi_q.sta_pending); list_delete(&(pstaxmitpriv->vi_q.tx_pending)); spin_unlock_irqrestore(&(pxmitpriv->vi_pending.lock), irqL0); spin_lock_irqsave(&(pxmitpriv->bk_pending.lock), irqL0); r8712_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->bk_q.sta_pending); list_delete(&(pstaxmitpriv->bk_q.tx_pending)); spin_unlock_irqrestore(&(pxmitpriv->bk_pending.lock), irqL0); spin_lock_irqsave(&(pxmitpriv->be_pending.lock), irqL0); r8712_free_xmitframe_queue(pxmitpriv, &pstaxmitpriv->be_q.sta_pending); list_delete(&(pstaxmitpriv->be_q.tx_pending)); spin_unlock_irqrestore(&(pxmitpriv->be_pending.lock), irqL0); list_delete(&psta->hash_list); pstapriv->asoc_sta_count--; /* */ _r8712_init_sta_xmit_priv(&psta->sta_xmitpriv); _r8712_init_sta_recv_priv(&psta->sta_recvpriv); /* */ for (i = 0; i < 16; i++) { preorder_ctrl = &psta->recvreorder_ctrl[i]; _cancel_timer_ex(&preorder_ctrl->reordering_ctrl_timer); } spin_lock(&(pfree_sta_queue->lock)); /* */ list_insert_tail(&psta->list, get_list_head(pfree_sta_queue)); spin_unlock(&(pfree_sta_queue->lock)); }
static struct xmit_frame *dequeue_one_xmitframe(struct xmit_priv *pxmitpriv, struct hw_xmit *phwxmit, struct tx_servq *ptxservq, struct __queue *pframe_queue) { struct list_head *xmitframe_plist, *xmitframe_phead; struct xmit_frame *pxmitframe = NULL; xmitframe_phead = get_list_head(pframe_queue); xmitframe_plist = get_next(xmitframe_phead); if ((end_of_queue_search(xmitframe_phead, xmitframe_plist)) == false) { pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list); list_delete(&pxmitframe->list); ptxservq->qcnt--; phwxmit->txcmdcnt++; }
u8 rtw_access_ctrl(_adapter *padapter, u8 *mac_addr) { u8 res = true; _list *plist, *phead; struct rtw_wlan_acl_node *paclnode; u8 match = false; struct sta_priv *pstapriv = &padapter->stapriv; struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; _queue *pacl_node_q =&pacl_list->acl_node_q; spin_lock_bh(&(pacl_node_q->lock)); phead = get_list_head(pacl_node_q); plist = get_next(phead); while (phead != plist) { paclnode = LIST_CONTAINOR(plist, struct rtw_wlan_acl_node, list); plist = get_next(plist); if(!memcmp(paclnode->addr, mac_addr, ETH_ALEN)) { if(paclnode->valid == true) { match = true; break; } } } spin_unlock_bh(&(pacl_node_q->lock)); if(pacl_list->mode == 1)//accept unless in deny list { res = (match == true) ? false:true; } else if(pacl_list->mode == 2)//deny unless in accept list { res = (match == true) ? true:false; } else { res = true; } return res; }
/* Return 1-based index for a course_name or 0 if not found */ unsigned int get_course_index(const char* course_name) { int course_index = 0; list_t course_list=get_score_courses_list(); list_elem_t cur_elem=get_list_head(course_list); while (cur_elem != NULL) { open_course_data_t *data = (open_course_data_t*) get_list_elem_data(cur_elem); if (strcmp(data->course, course_name) == 0) { return course_index + 1; } ++course_index; cur_elem=(open_course_data_t*) get_next_list_elem(course_list, cur_elem); } return 0U; }
static void _free_network_queue(struct _adapter *padapter) { unsigned long irqL; struct list_head *phead, *plist; struct wlan_network *pnetwork; struct mlme_priv *pmlmepriv = &padapter->mlmepriv; struct __queue *scanned_queue = &pmlmepriv->scanned_queue; spin_lock_irqsave(&scanned_queue->lock, irqL); phead = get_list_head(scanned_queue); plist = get_next(phead); while (end_of_queue_search(phead, plist) == false) { pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); plist = get_next(plist); _free_network(pmlmepriv, pnetwork); } spin_unlock_irqrestore(&scanned_queue->lock, irqL); }
int in_reg2_list(CTXTdeclc Psc psc) { Cell list,term; list = reg[2]; XSB_Deref(list); if (isnil(list)) return TRUE; /* if filter is empty, return all */ while (!isnil(list)) { term = get_list_head(list); XSB_Deref(term); if (isconstr(term)) { if (psc == get_str_psc(term)) return TRUE; } else if (isstring(term)) { if (get_name(psc) == string_val(term)) return TRUE; } list = get_list_tail(list); } return FALSE; }
void init_scoreboard_arrays() { int course, rank; list_t course_list=get_score_courses_list(); list_elem_t cur_elem=get_list_head(course_list); if (!arrays_initialized) { unsigned int u; for (u = 0; u < SCOREBOARD_SIZE; ++u) { SCORE_ITEM* score = &scoreboard[u]; memset(score->rank, 0, MAX_RANK); memset(score->name, 0, MAX_NAME); memset(score->score, 0, MAX_SCORE); } arrays_initialized=True; } }
/*! Returns true iff the current race is the first incomplete race \author jfpatry \date Created: 2000-09-24 \date Modified: 2000-09-24 */ static bool_t is_current_race_first_incomplete( void ) { check_assertion( cur_elem != NULL, "current race is null" ); if ( last_completed_race == NULL ) { if ( cur_elem == get_list_head( race_list ) ) { return True; } else { return False; } } if ( compare_race_positions( cup_data, last_completed_race, cur_elem ) == 1 ) { return True; } return False; }
void rtl8723bs_free_xmit_priv(PADAPTER padapter) { PHAL_DATA_TYPE phal; struct xmit_priv *pxmitpriv; struct xmit_buf *pxmitbuf; _queue *pqueue; _list *plist, *phead; _list tmplist; _irqL irql; phal = GET_HAL_DATA(padapter); pxmitpriv = &padapter->xmitpriv; pqueue = &pxmitpriv->pending_xmitbuf_queue; phead = get_list_head(pqueue); _rtw_init_listhead(&tmplist); _enter_critical_bh(&pqueue->lock, &irql); if (_rtw_queue_empty(pqueue) == _FALSE) { // Insert tmplist to end of queue, and delete phead // then tmplist become head of queue. rtw_list_insert_tail(&tmplist, phead); rtw_list_delete(phead); } _exit_critical_bh(&pqueue->lock, &irql); phead = &tmplist; while (rtw_is_list_empty(phead) == _FALSE) { plist = get_next(phead); rtw_list_delete(plist); pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list); rtw_free_xmitframe(pxmitpriv, (struct xmit_frame*)pxmitbuf->priv_data); pxmitbuf->priv_data = NULL; rtw_free_xmitbuf(pxmitpriv, pxmitbuf); } _rtw_spinlock_free(&phal->SdioTxFIFOFreePageLock); }
/*! Updates the enabled states of the arrow buttons \author jfpatry \date Created: 2000-09-17 \date Modified: 2000-09-17 */ static void update_button_enabled_states( listbox_t *listbox ) { check_assertion( listbox != NULL, "listbox is NULL" ); if ( listbox->cur_item == NULL ) { /* No items in list */ button_set_enabled( listbox->up_button, False ); button_set_enabled( listbox->down_button, False ); } else { if ( listbox->cur_item == get_list_head( listbox->item_list ) ) { button_set_enabled( listbox->up_button, False ); } else { button_set_enabled( listbox->up_button, True ); } if ( listbox->cur_item == get_list_tail( listbox->item_list ) ) { button_set_enabled( listbox->down_button, False ); } else { button_set_enabled( listbox->down_button, True ); } } }
void rtl8723bs_free_xmit_priv(PADAPTER padapter) { PHAL_DATA_TYPE phal; struct xmit_priv *pxmitpriv; struct xmit_buf *pxmitbuf; _queue *pqueue; _list *plist, *phead; _list tmplist; _irqL irql; phal = GET_HAL_DATA(padapter); pxmitpriv = &padapter->xmitpriv; pqueue = &pxmitpriv->pending_xmitbuf_queue; phead = get_list_head(pqueue); INIT_LIST_HEAD(&tmplist); spin_lock_bh(&pqueue->lock); if (!list_empty(&pqueue->queue)) { // Insert tmplist to end of queue, and delete phead // then tmplist become head of queue. list_add_tail(&tmplist, phead); list_del_init(phead); } spin_unlock_bh(&pqueue->lock); phead = &tmplist; while (list_empty(phead) == false) { plist = get_next(phead); list_del_init(plist); pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list); rtw_free_xmitframe(pxmitpriv, (struct xmit_frame*)pxmitbuf->priv_data); pxmitbuf->priv_data = NULL; rtw_free_xmitbuf(pxmitpriv, pxmitbuf); } }
union recv_frame *alloc_recvframe (_queue *pfree_recv_queue) { _irqL irqL; union recv_frame *precvframe; _list *plist, *phead; _adapter *padapter; struct recv_priv *precvpriv; _func_enter_; _enter_critical(&pfree_recv_queue->lock, &irqL); if(_queue_empty(pfree_recv_queue) == _TRUE) { precvframe = NULL; } else { phead = get_list_head(pfree_recv_queue); plist = get_next(phead); precvframe = LIST_CONTAINOR(plist, union recv_frame, u); list_delete(&precvframe->u.hdr.list); padapter=precvframe->u.hdr.adapter; if(padapter !=NULL){ precvpriv=&padapter->recvpriv; if(pfree_recv_queue == &precvpriv->free_recv_queue) precvpriv->free_recvframe_cnt--; } } _exit_critical(&pfree_recv_queue->lock, &irqL); _func_exit_; return precvframe; }
/* return the wlan_network with the matching addr Shall be calle under atomic context... to avoid possible racing condition... */ static struct wlan_network *_r8712_find_network(struct __queue *scanned_queue, u8 *addr) { unsigned long irqL; struct list_head *phead, *plist; struct wlan_network *pnetwork = NULL; u8 zero_addr[ETH_ALEN] = {0, 0, 0, 0, 0, 0}; if (!memcmp(zero_addr, addr, ETH_ALEN)) return NULL; spin_lock_irqsave(&scanned_queue->lock, irqL); phead = get_list_head(scanned_queue); plist = get_next(phead); while (plist != phead) { pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list); plist = get_next(plist); if (!memcmp(addr, pnetwork->network.MacAddress, ETH_ALEN)) break; } spin_unlock_irqrestore(&scanned_queue->lock, irqL); return pnetwork; }
void rtl8723bs_free_xmit_priv(struct adapter *padapter) { struct hal_com_data *phal; struct xmit_priv *pxmitpriv; struct xmit_buf *pxmitbuf; struct __queue *pqueue; struct list_head *plist, *phead; struct list_head tmplist; phal = GET_HAL_DATA(padapter); pxmitpriv = &padapter->xmitpriv; pqueue = &pxmitpriv->pending_xmitbuf_queue; phead = get_list_head(pqueue); INIT_LIST_HEAD(&tmplist); critical_enter_bh(&pqueue->lock); if (!list_empty(&pqueue->queue)) { /* Insert tmplist to end of queue, and delete phead */ /* then tmplist become head of queue. */ list_add_tail(&tmplist, phead); list_del_init(phead); } critical_exit_bh(&pqueue->lock); phead = &tmplist; while (list_empty(phead) == false) { plist = get_next(phead); list_del_init(plist); pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list); rtw_free_xmitframe(pxmitpriv, (struct xmit_frame*)pxmitbuf->priv_data); pxmitbuf->priv_data = NULL; rtw_free_xmitbuf(pxmitpriv, pxmitbuf); } }
u8 rtw_access_ctrl(struct adapter *padapter, u8 *mac_addr) { u8 res = true; #ifdef CONFIG_88EU_AP_MODE struct list_head *plist, *phead; struct rtw_wlan_acl_node *paclnode; u8 match = false; struct sta_priv *pstapriv = &padapter->stapriv; struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; struct __queue *pacl_node_q = &pacl_list->acl_node_q; spin_lock_bh(&pacl_node_q->lock); phead = get_list_head(pacl_node_q); plist = phead->next; while (phead != plist) { paclnode = container_of(plist, struct rtw_wlan_acl_node, list); plist = plist->next; if (!memcmp(paclnode->addr, mac_addr, ETH_ALEN)) { if (paclnode->valid) { match = true; break; } } } spin_unlock_bh(&pacl_node_q->lock); if (pacl_list->mode == 1)/* accept unless in deny list */ res = (match) ? false : true; else if (pacl_list->mode == 2)/* deny unless in accept list */ res = (match) ? true : false; else res = true; #endif return res; }
// this function is used to free the memory of lock || sema for all stainfos void rtw_mfree_all_stainfo(struct sta_priv *pstapriv ) { _irqL irqL; _list *plist, *phead; struct sta_info *psta = NULL; SPIN_LOCK_BH(pstapriv->sta_hash_lock, &irqL); phead = get_list_head(&pstapriv->free_sta_queue); plist = get_next(phead); while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) { psta = LIST_CONTAINOR(plist, struct sta_info ,list); plist = get_next(plist); rtw_mfree_stainfo(psta); } SPIN_UNLOCK_BH(pstapriv->sta_hash_lock, &irqL); }
/*! Returns the event data for the event with specified name \author jfpatry \date Created: 2000-09-23 \date Modified: 2000-09-23 */ list_elem_t get_event_by_name( char *event_name ) { list_elem_t cur_event = NULL; event_data_t *data; cur_event = get_list_head( event_list ); while (1) { if ( cur_event == NULL ) { return NULL; } data = (event_data_t*) get_list_elem_data( cur_event ); if ( strcmp( data->name, event_name ) == 0 ) { return cur_event; } cur_event = get_next_list_elem( event_list, cur_event ); } return NULL; }
/*! Returns the cup data for the specified cup name \author jfpatry \date Created: 2000-09-23 \date Modified: 2000-09-23 */ list_elem_t get_event_cup_by_name( event_data_t *event, char *name ) { list_elem_t cur_cup; cup_data_t *data; cur_cup = get_list_head( event->cup_list ); while (1) { if ( cur_cup == NULL ) { return NULL; } data = (cup_data_t*)get_list_elem_data( cur_cup ); if ( strcmp( data->name, name ) == 0 ) { return cur_cup; } cur_cup = get_next_list_elem( event->cup_list, cur_cup ); } return NULL; }
struct wlan_network *r8712_get_oldest_wlan_network( struct __queue *scanned_queue) { struct list_head *plist, *phead; struct wlan_network *pwlan = NULL; struct wlan_network *oldest = NULL; phead = get_list_head(scanned_queue); plist = get_next(phead); while (1) { if (end_of_queue_search(phead, plist) == true) break; pwlan = LIST_CONTAINOR(plist, struct wlan_network, list); if (pwlan->fixed != true) { if (oldest == NULL || time_after((unsigned long)oldest->last_scanned, (unsigned long)pwlan->last_scanned)) oldest = pwlan; } plist = get_next(plist); } return oldest; }
u8 rtw_access_ctrl(struct adapter *padapter, u8 *mac_addr) { bool res = true; struct list_head *plist, *phead; struct rtw_wlan_acl_node *paclnode; bool match = false; struct sta_priv *pstapriv = &padapter->stapriv; struct wlan_acl_pool *pacl_list = &pstapriv->acl_list; struct __queue *pacl_node_q = &pacl_list->acl_node_q; spin_lock_bh(&(pacl_node_q->lock)); phead = get_list_head(pacl_node_q); plist = get_next(phead); while (phead != plist) { paclnode = LIST_CONTAINOR(plist, struct rtw_wlan_acl_node, list); plist = get_next(plist); if (!memcmp(paclnode->addr, mac_addr, ETH_ALEN)) if (paclnode->valid == true) { match = true; break; } } spin_unlock_bh(&(pacl_node_q->lock)); if (pacl_list->mode == 1) /* accept unless in deny list */ res = !match; else if (pacl_list->mode == 2)/* deny unless in accept list */ res = match; else res = true; return res; }
int get_incr_sccs(CTXTdeclc Cell listterm) { Cell orig_listterm, intterm, node; long int node_num=0; int i = 0, dfn, component = 1; int * dfn_stack; int dfn_top = 0, ret; SCCNode * nodes; struct hashtable_itr *itr; struct hashtable* hasht; XSB_Deref(listterm); hasht = create_hashtable1(HASH_TABLE_SIZE, hashid, equalkeys); orig_listterm = listterm; intterm = get_list_head(listterm); XSB_Deref(intterm); // printf("listptr %p @%p\n",listptr,(CPtr) int_val(*listptr)); insert_some(hasht,(void *) oint_val(intterm),(void *) node_num); node_num++; listterm = get_list_tail(listterm); XSB_Deref(listterm); while (!isnil(listterm)) { intterm = get_list_head(listterm); XSB_Deref(intterm); node = oint_val(intterm); if (NULL == search_some(hasht, (void *)node)) { insert_some(hasht,(void *)node,(void *)node_num); node_num++; } listterm = get_list_tail(listterm); XSB_Deref(listterm); } nodes = (SCCNode *) mem_calloc(node_num, sizeof(SCCNode),OTHER_SPACE); dfn_stack = (int *) mem_alloc(node_num*sizeof(int),OTHER_SPACE); listterm = orig_listterm;; //printf("listptr %p @%p\n",listptr,(void *)int_val(*(listptr))); intterm = get_list_head(listterm); XSB_Deref(intterm); nodes[0].node = (CPtr) oint_val(intterm); listterm = get_list_tail(listterm); XSB_Deref(listterm); i = 1; while (!isnil(listterm)) { intterm = get_list_head(listterm); XSB_Deref(intterm); node = oint_val(intterm); nodes[i].node = (CPtr) node; listterm = get_list_tail(listterm); XSB_Deref(listterm); i++; } itr = hashtable1_iterator(hasht); SQUASH_LINUX_COMPILER_WARN(itr); // do { // printf("k %p val %p\n",hashtable1_iterator_key(itr),hashtable1_iterator_value(itr)); // } while (hashtable1_iterator_advance(itr)); listterm = orig_listterm; // printf("2: k %p v %p\n",(void *) int_val(*listptr), // search_some(hasht,(void *) int_val(*listptr))); // while (!isnil(*listptr)) { now all wrong... // listptr = listptr + 1; // node = int_val(*clref_val(listptr)); // printf("2: k %p v %p\n",(CPtr) node,search_some(hasht,(void *) node)); // listptr = listptr + 1; // } dfn = 1; for (i = 0; i < node_num; i++) { if (nodes[i].dfn == 0) xsb_compute_scc(nodes,dfn_stack,i,&dfn_top,hasht,&dfn,&component); // printf("++component for node %d is %d (high %d)\n",i,nodes[i].component,component); } ret = return_scc_list(CTXTc nodes, node_num); hashtable1_destroy(hasht,0); mem_dealloc(nodes,node_num*sizeof(SCCNode),OTHER_SPACE); mem_dealloc(dfn_stack,node_num*sizeof(int),OTHER_SPACE); return ret; }
s32 rtl8812au_xmitframe_complete(_adapter *padapter, struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf) { HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter); struct xmit_frame *pxmitframe = NULL; struct xmit_frame *pfirstframe = NULL; // aggregate variable struct hw_xmit *phwxmit; struct sta_info *psta = NULL; struct tx_servq *ptxservq = NULL; _irqL irqL; _list *xmitframe_plist = NULL, *xmitframe_phead = NULL; u32 pbuf; // next pkt address u32 pbuf_tail; // last pkt tail u32 len; // packet length, except TXDESC_SIZE and PKT_OFFSET u32 bulkSize = pHalData->UsbBulkOutSize; u8 descCount; u32 bulkPtr; // dump frame variable u32 ff_hwaddr; #ifndef IDEA_CONDITION int res = _SUCCESS; #endif RT_TRACE(_module_rtl8192c_xmit_c_, _drv_info_, ("+xmitframe_complete\n")); // check xmitbuffer is ok if (pxmitbuf == NULL) { pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv); if (pxmitbuf == NULL){ //DBG_871X("%s #1, connot alloc xmitbuf!!!! \n",__FUNCTION__); return _FALSE; } } //DBG_8192C("%s ===================================== \n",__FUNCTION__); //3 1. pick up first frame do { rtw_free_xmitframe(pxmitpriv, pxmitframe); pxmitframe = rtw_dequeue_xframe(pxmitpriv, pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry); if (pxmitframe == NULL) { // no more xmit frame, release xmit buffer //DBG_8192C("no more xmit frame ,return\n"); rtw_free_xmitbuf(pxmitpriv, pxmitbuf); return _FALSE; } #ifndef IDEA_CONDITION if (pxmitframe->frame_tag != DATA_FRAMETAG) { RT_TRACE(_module_rtl8192c_xmit_c_, _drv_err_, ("xmitframe_complete: frame tag(%d) is not DATA_FRAMETAG(%d)!\n", pxmitframe->frame_tag, DATA_FRAMETAG)); // rtw_free_xmitframe(pxmitpriv, pxmitframe); continue; } // TID 0~15 if ((pxmitframe->attrib.priority < 0) || (pxmitframe->attrib.priority > 15)) { RT_TRACE(_module_rtl8192c_xmit_c_, _drv_err_, ("xmitframe_complete: TID(%d) should be 0~15!\n", pxmitframe->attrib.priority)); // rtw_free_xmitframe(pxmitpriv, pxmitframe); continue; } #endif //DBG_8192C("==> pxmitframe->attrib.priority:%d\n",pxmitframe->attrib.priority); pxmitframe->pxmitbuf = pxmitbuf; pxmitframe->buf_addr = pxmitbuf->pbuf; pxmitbuf->priv_data = pxmitframe; pxmitframe->agg_num = 1; // alloc xmitframe should assign to 1. #ifdef CONFIG_TX_EARLY_MODE pxmitframe->pkt_offset = (PACKET_OFFSET_SZ/8)+1; // 2; // first frame of aggregation, reserve one offset for EM info ,another for usb bulk-out block check #else pxmitframe->pkt_offset = (PACKET_OFFSET_SZ/8); // 1; // first frame of aggregation, reserve offset #endif if (rtw_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe) == _FALSE) { DBG_871X("%s coalesce 1st xmitframe failed \n",__FUNCTION__); continue; } // always return ndis_packet after rtw_xmitframe_coalesce rtw_os_xmit_complete(padapter, pxmitframe); break; } while (1); //3 2. aggregate same priority and same DA(AP or STA) frames pfirstframe = pxmitframe; len = xmitframe_need_length(pfirstframe) + TXDESC_SIZE+(pfirstframe->pkt_offset*PACKET_OFFSET_SZ); pbuf_tail = len; pbuf = _RND8(pbuf_tail); // check pkt amount in one bulk descCount = 0; bulkPtr = bulkSize; if (pbuf < bulkPtr) descCount++; if (descCount == pHalData->UsbTxAggDescNum) goto agg_end; else { descCount = 0; bulkPtr = ((pbuf / bulkSize) + 1) * bulkSize; // round to next bulkSize } // dequeue same priority packet from station tx queue psta = pfirstframe->attrib.psta; switch (pfirstframe->attrib.priority) { case 1: case 2: ptxservq = &(psta->sta_xmitpriv.bk_q); phwxmit = pxmitpriv->hwxmits + 3; break; case 4: case 5: ptxservq = &(psta->sta_xmitpriv.vi_q); phwxmit = pxmitpriv->hwxmits + 1; break; case 6: case 7: ptxservq = &(psta->sta_xmitpriv.vo_q); phwxmit = pxmitpriv->hwxmits; break; case 0: case 3: default: ptxservq = &(psta->sta_xmitpriv.be_q); phwxmit = pxmitpriv->hwxmits + 2; break; } //DBG_8192C("==> pkt_no=%d,pkt_len=%d,len=%d,RND8_LEN=%d,pkt_offset=0x%02x\n", //pxmitframe->agg_num,pxmitframe->attrib.last_txcmdsz,len,pbuf,pxmitframe->pkt_offset ); _enter_critical_bh(&pxmitpriv->lock, &irqL); xmitframe_phead = get_list_head(&ptxservq->sta_pending); xmitframe_plist = get_next(xmitframe_phead); while (rtw_end_of_queue_search(xmitframe_phead, xmitframe_plist) == _FALSE) { pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list); xmitframe_plist = get_next(xmitframe_plist); if(_FAIL == rtw_hal_busagg_qsel_check(padapter,pfirstframe->attrib.qsel,pxmitframe->attrib.qsel)) break; pxmitframe->agg_num = 0; // not first frame of aggregation #ifdef CONFIG_TX_EARLY_MODE pxmitframe->pkt_offset = 1;// not first frame of aggregation,reserve offset for EM Info #else pxmitframe->pkt_offset = 0; // not first frame of aggregation, no need to reserve offset #endif len = xmitframe_need_length(pxmitframe) + TXDESC_SIZE +(pxmitframe->pkt_offset*PACKET_OFFSET_SZ); if (_RND8(pbuf + len) > MAX_XMITBUF_SZ) //if (_RND8(pbuf + len) > (MAX_XMITBUF_SZ/2))//to do : for TX TP finial tune , Georgia 2012-0323 { //DBG_8192C("%s....len> MAX_XMITBUF_SZ\n",__FUNCTION__); pxmitframe->agg_num = 1; pxmitframe->pkt_offset = 1; break; } rtw_list_delete(&pxmitframe->list); ptxservq->qcnt--; phwxmit->accnt--; #ifndef IDEA_CONDITION // suppose only data frames would be in queue if (pxmitframe->frame_tag != DATA_FRAMETAG) { RT_TRACE(_module_rtl8192c_xmit_c_, _drv_err_, ("xmitframe_complete: frame tag(%d) is not DATA_FRAMETAG(%d)!\n", pxmitframe->frame_tag, DATA_FRAMETAG)); rtw_free_xmitframe(pxmitpriv, pxmitframe); continue; } // TID 0~15 if ((pxmitframe->attrib.priority < 0) || (pxmitframe->attrib.priority > 15)) { RT_TRACE(_module_rtl8192c_xmit_c_, _drv_err_, ("xmitframe_complete: TID(%d) should be 0~15!\n", pxmitframe->attrib.priority)); rtw_free_xmitframe(pxmitpriv, pxmitframe); continue; } #endif // pxmitframe->pxmitbuf = pxmitbuf; pxmitframe->buf_addr = pxmitbuf->pbuf + pbuf; if (rtw_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe) == _FALSE) { DBG_871X("%s coalesce failed \n",__FUNCTION__); rtw_free_xmitframe(pxmitpriv, pxmitframe); continue; } //DBG_8192C("==> pxmitframe->attrib.priority:%d\n",pxmitframe->attrib.priority); // always return ndis_packet after rtw_xmitframe_coalesce rtw_os_xmit_complete(padapter, pxmitframe); // (len - TXDESC_SIZE) == pxmitframe->attrib.last_txcmdsz update_txdesc(pxmitframe, pxmitframe->buf_addr, pxmitframe->attrib.last_txcmdsz,_TRUE); // don't need xmitframe any more rtw_free_xmitframe(pxmitpriv, pxmitframe); // handle pointer and stop condition pbuf_tail = pbuf + len; pbuf = _RND8(pbuf_tail); pfirstframe->agg_num++; #ifdef CONFIG_TX_EARLY_MODE pxmitpriv->agg_pkt[pfirstframe->agg_num-1].offset = _RND8(len); pxmitpriv->agg_pkt[pfirstframe->agg_num-1].pkt_len = pxmitframe->attrib.last_txcmdsz; #endif if (MAX_TX_AGG_PACKET_NUMBER == pfirstframe->agg_num) break; if (pbuf < bulkPtr) { descCount++; if (descCount == pHalData->UsbTxAggDescNum) break; } else { descCount = 0; bulkPtr = ((pbuf / bulkSize) + 1) * bulkSize; } }//end while( aggregate same priority and same DA(AP or STA) frames) if (_rtw_queue_empty(&ptxservq->sta_pending) == _TRUE) rtw_list_delete(&ptxservq->tx_pending); _exit_critical_bh(&pxmitpriv->lock, &irqL); agg_end: #ifdef CONFIG_80211N_HT if ((pfirstframe->attrib.ether_type != 0x0806) && (pfirstframe->attrib.ether_type != 0x888e) && (pfirstframe->attrib.ether_type != 0x88b4) && (pfirstframe->attrib.dhcp_pkt != 1)) { rtw_issue_addbareq_cmd(padapter, pfirstframe); } #endif //CONFIG_80211N_HT #ifndef CONFIG_USE_USB_BUFFER_ALLOC_TX //3 3. update first frame txdesc if ((PACKET_OFFSET_SZ != 0) && ((pbuf_tail % bulkSize) == 0)) { // remove pkt_offset pbuf_tail -= PACKET_OFFSET_SZ; pfirstframe->buf_addr += PACKET_OFFSET_SZ; pfirstframe->pkt_offset--; //DBG_8192C("$$$$$ buf size equal to USB block size $$$$$$\n"); } #endif // CONFIG_USE_USB_BUFFER_ALLOC_TX update_txdesc(pfirstframe, pfirstframe->buf_addr, pfirstframe->attrib.last_txcmdsz,_TRUE); #ifdef CONFIG_TX_EARLY_MODE //prepare EM info for first frame, agg_num value start from 1 pxmitpriv->agg_pkt[0].offset = _RND8(pfirstframe->attrib.last_txcmdsz +TXDESC_SIZE +(pfirstframe->pkt_offset*PACKET_OFFSET_SZ)); pxmitpriv->agg_pkt[0].pkt_len = pfirstframe->attrib.last_txcmdsz;//get from rtw_xmitframe_coalesce UpdateEarlyModeInfo8812(pxmitpriv,pxmitbuf ); #endif //3 4. write xmit buffer to USB FIFO ff_hwaddr = rtw_get_ff_hwaddr(pfirstframe); //DBG_8192C("%s ===================================== write port,buf_size(%d) \n",__FUNCTION__,pbuf_tail); // xmit address == ((xmit_frame*)pxmitbuf->priv_data)->buf_addr rtw_write_port(padapter, ff_hwaddr, pbuf_tail, (u8*)pxmitbuf); //3 5. update statisitc pbuf_tail -= (pfirstframe->agg_num * TXDESC_SIZE); pbuf_tail -= (pfirstframe->pkt_offset * PACKET_OFFSET_SZ); rtw_count_tx_stats(padapter, pfirstframe, pbuf_tail); rtw_free_xmitframe(pxmitpriv, pfirstframe); return _TRUE; }