/**
* @brief This function will check if unicast packet need be dropped
*
* @param priv A pointer to mlan_private
* @param mac mac address to find in station list table
*
* @return MLAN_STATUS_FAILURE -- drop packet, otherwise forward to network stack
*/
static mlan_status
wlan_check_unicast_packet(mlan_private * priv, t_u8 * mac)
{
int j;
sta_node *sta_ptr = MNULL;
pmlan_adapter pmadapter = priv->adapter;
pmlan_private pmpriv = MNULL;
t_u8 pkt_type = 0;
mlan_status ret = MLAN_STATUS_SUCCESS;
ENTER();
for (j = 0; j < MLAN_MAX_BSS_NUM; ++j) {
if ((pmpriv = pmadapter->priv[j])) {
if (GET_BSS_ROLE(pmpriv) == MLAN_BSS_ROLE_STA)
continue;
sta_ptr = wlan_get_station_entry(pmpriv, mac);
if (sta_ptr) {
if (pmpriv == priv)
pkt_type = PKT_INTRA_UCAST;
else
pkt_type = PKT_INTER_UCAST;
break;
}
}
}
if ((pkt_type == PKT_INTRA_UCAST) && (priv->pkt_fwd & PKT_FWD_INTRA_UCAST)) {
PRINTM(MDATA, "Drop INTRA_UCAST packet\n");
ret = MLAN_STATUS_FAILURE;
} else if ((pkt_type == PKT_INTER_UCAST) &&
(priv->pkt_fwd & PKT_FWD_INTER_UCAST)) {
PRINTM(MDATA, "Drop INTER_UCAST packet\n");
ret = MLAN_STATUS_FAILURE;
}
LEAVE();
return ret;
}
/**
* @brief This function processes received packet and forwards it
* to kernel/upper layer or send back to firmware
*
* @param priv A pointer to mlan_private
* @param pmbuf A pointer to mlan_buffer which includes the received packet
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_process_uap_rx_packet(IN mlan_private *priv, IN pmlan_buffer pmbuf)
{
pmlan_adapter pmadapter = priv->adapter;
mlan_status ret = MLAN_STATUS_SUCCESS;
UapRxPD *prx_pd;
RxPacketHdr_t *prx_pkt;
pmlan_buffer newbuf = MNULL;
ENTER();
prx_pd = (UapRxPD *)(pmbuf->pbuf + pmbuf->data_offset);
prx_pkt = (RxPacketHdr_t *)((t_u8 *)prx_pd + prx_pd->rx_pkt_offset);
DBG_HEXDUMP(MDAT_D, "uAP RxPD", prx_pd,
MIN(sizeof(UapRxPD), MAX_DATA_DUMP_LEN));
DBG_HEXDUMP(MDAT_D, "uAP Rx Payload",
((t_u8 *)prx_pd + prx_pd->rx_pkt_offset),
MIN(prx_pd->rx_pkt_length, MAX_DATA_DUMP_LEN));
PRINTM(MINFO,
"RX Data: data_len - prx_pd->rx_pkt_offset = %d - %d = %d\n",
pmbuf->data_len, prx_pd->rx_pkt_offset,
pmbuf->data_len - prx_pd->rx_pkt_offset);
PRINTM(MDATA, "Rx dest " MACSTR "\n",
MAC2STR(prx_pkt->eth803_hdr.dest_addr));
/* don't do packet forwarding in disconnected state */
/* don't do packet forwarding when packet > 1514 */
if ((priv->media_connected == MFALSE) ||
((pmbuf->data_len - prx_pd->rx_pkt_offset) > MV_ETH_FRAME_LEN))
goto upload;
if (prx_pkt->eth803_hdr.dest_addr[0] & 0x01) {
if (!(priv->pkt_fwd & PKT_FWD_INTRA_BCAST)) {
/* Multicast pkt */
newbuf = wlan_alloc_mlan_buffer(pmadapter,
MLAN_TX_DATA_BUF_SIZE_2K,
0, MOAL_MALLOC_BUFFER);
if (newbuf) {
newbuf->bss_index = pmbuf->bss_index;
newbuf->buf_type = pmbuf->buf_type;
newbuf->priority = pmbuf->priority;
newbuf->in_ts_sec = pmbuf->in_ts_sec;
newbuf->in_ts_usec = pmbuf->in_ts_usec;
newbuf->data_offset =
(sizeof(UapTxPD) + INTF_HEADER_LEN +
DMA_ALIGNMENT);
util_scalar_increment(pmadapter->pmoal_handle,
&pmadapter->
pending_bridge_pkts,
pmadapter->callbacks.
moal_spin_lock,
pmadapter->callbacks.
moal_spin_unlock);
newbuf->flags |= MLAN_BUF_FLAG_BRIDGE_BUF;
/* copy the data, skip rxpd */
memcpy(pmadapter,
(t_u8 *)newbuf->pbuf +
newbuf->data_offset,
pmbuf->pbuf + pmbuf->data_offset +
prx_pd->rx_pkt_offset,
pmbuf->data_len - prx_pd->rx_pkt_offset);
newbuf->data_len =
pmbuf->data_len - prx_pd->rx_pkt_offset;
wlan_wmm_add_buf_txqueue(pmadapter, newbuf);
if (util_scalar_read(pmadapter->pmoal_handle,
&pmadapter->
pending_bridge_pkts,
pmadapter->callbacks.
moal_spin_lock,
pmadapter->callbacks.
moal_spin_unlock) >
RX_HIGH_THRESHOLD)
wlan_drop_tx_pkts(priv);
wlan_recv_event(priv,
MLAN_EVENT_ID_DRV_DEFER_HANDLING,
MNULL);
}
}
} else {
if ((!(priv->pkt_fwd & PKT_FWD_INTRA_UCAST)) &&
(wlan_get_station_entry
(priv, prx_pkt->eth803_hdr.dest_addr))) {
/* Forwarding Intra-BSS packet */
pmbuf->data_len -= prx_pd->rx_pkt_offset;
pmbuf->data_offset += prx_pd->rx_pkt_offset;
pmbuf->flags |= MLAN_BUF_FLAG_BRIDGE_BUF;
util_scalar_increment(pmadapter->pmoal_handle,
&pmadapter->pending_bridge_pkts,
pmadapter->callbacks.
moal_spin_lock,
pmadapter->callbacks.
moal_spin_unlock);
wlan_wmm_add_buf_txqueue(pmadapter, pmbuf);
if (util_scalar_read(pmadapter->pmoal_handle,
&pmadapter->pending_bridge_pkts,
pmadapter->callbacks.
moal_spin_lock,
pmadapter->callbacks.
moal_spin_unlock) >
RX_HIGH_THRESHOLD)
wlan_drop_tx_pkts(priv);
wlan_recv_event(priv, MLAN_EVENT_ID_DRV_DEFER_HANDLING,
MNULL);
goto done;
} else if (MLAN_STATUS_FAILURE ==
wlan_check_unicast_packet(priv,
prx_pkt->eth803_hdr.
dest_addr)) {
PRINTM(MDATA, "Drop Pkts: Rx dest " MACSTR "\n",
MAC2STR(prx_pkt->eth803_hdr.dest_addr));
pmbuf->status_code = MLAN_ERROR_PKT_INVALID;
wlan_free_mlan_buffer(pmadapter, pmbuf);
goto done;
}
}
upload:
/* Chop off RxPD */
pmbuf->data_len -= prx_pd->rx_pkt_offset;
pmbuf->data_offset += prx_pd->rx_pkt_offset;
pmbuf->pparent = MNULL;
pmadapter->callbacks.moal_get_system_time(pmadapter->pmoal_handle,
&pmbuf->out_ts_sec,
&pmbuf->out_ts_usec);
PRINTM_NETINTF(MDATA, priv);
PRINTM(MDATA, "%lu.%06lu : Data => kernel seq_num=%d tid=%d\n",
pmbuf->out_ts_sec, pmbuf->out_ts_usec, prx_pd->seq_num,
prx_pd->priority);
ret = pmadapter->callbacks.moal_recv_packet(pmadapter->pmoal_handle,
pmbuf);
if (ret == MLAN_STATUS_FAILURE) {
PRINTM(MERROR,
"uAP Rx Error: moal_recv_packet returned error\n");
pmbuf->status_code = MLAN_ERROR_PKT_INVALID;
}
if (ret != MLAN_STATUS_PENDING)
wlan_free_mlan_buffer(pmadapter, pmbuf);
done:
LEAVE();
return ret;
}
/**
* @brief This function processes received packet and forwards it
* to kernel/upper layer or send back to firmware
*
* @param priv A pointer to mlan_private
* @param pmbuf A pointer to mlan_buffer which includes the received packet
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_uap_recv_packet(IN mlan_private *priv, IN pmlan_buffer pmbuf)
{
pmlan_adapter pmadapter = priv->adapter;
mlan_status ret = MLAN_STATUS_SUCCESS;
RxPacketHdr_t *prx_pkt;
pmlan_buffer newbuf = MNULL;
ENTER();
prx_pkt = (RxPacketHdr_t *)((t_u8 *)pmbuf->pbuf + pmbuf->data_offset);
DBG_HEXDUMP(MDAT_D, "uap_recv_packet", pmbuf->pbuf + pmbuf->data_offset,
MIN(pmbuf->data_len, MAX_DATA_DUMP_LEN));
PRINTM(MDATA, "AMSDU dest " MACSTR "\n",
MAC2STR(prx_pkt->eth803_hdr.dest_addr));
/* don't do packet forwarding in disconnected state */
if ((priv->media_connected == MFALSE) ||
(pmbuf->data_len > MV_ETH_FRAME_LEN))
goto upload;
if (prx_pkt->eth803_hdr.dest_addr[0] & 0x01) {
if (!(priv->pkt_fwd & PKT_FWD_INTRA_BCAST)) {
/* Multicast pkt */
newbuf = wlan_alloc_mlan_buffer(pmadapter,
MLAN_TX_DATA_BUF_SIZE_2K,
0, MOAL_MALLOC_BUFFER);
if (newbuf) {
newbuf->bss_index = pmbuf->bss_index;
newbuf->buf_type = pmbuf->buf_type;
newbuf->priority = pmbuf->priority;
newbuf->in_ts_sec = pmbuf->in_ts_sec;
newbuf->in_ts_usec = pmbuf->in_ts_usec;
newbuf->data_offset =
(sizeof(UapTxPD) + INTF_HEADER_LEN +
DMA_ALIGNMENT);
util_scalar_increment(pmadapter->pmoal_handle,
&pmadapter->
pending_bridge_pkts,
pmadapter->callbacks.
moal_spin_lock,
pmadapter->callbacks.
moal_spin_unlock);
newbuf->flags |= MLAN_BUF_FLAG_BRIDGE_BUF;
/* copy the data */
memcpy(pmadapter,
(t_u8 *)newbuf->pbuf +
newbuf->data_offset,
pmbuf->pbuf + pmbuf->data_offset,
pmbuf->data_len);
newbuf->data_len = pmbuf->data_len;
wlan_wmm_add_buf_txqueue(pmadapter, newbuf);
if (util_scalar_read(pmadapter->pmoal_handle,
&pmadapter->
pending_bridge_pkts,
pmadapter->callbacks.
moal_spin_lock,
pmadapter->callbacks.
moal_spin_unlock) >
RX_HIGH_THRESHOLD)
wlan_drop_tx_pkts(priv);
wlan_recv_event(priv,
MLAN_EVENT_ID_DRV_DEFER_HANDLING,
MNULL);
}
}
} else {
if ((!(priv->pkt_fwd & PKT_FWD_INTRA_UCAST)) &&
(wlan_get_station_entry
(priv, prx_pkt->eth803_hdr.dest_addr))) {
/* Intra BSS packet */
newbuf = wlan_alloc_mlan_buffer(pmadapter,
MLAN_TX_DATA_BUF_SIZE_2K,
0, MOAL_MALLOC_BUFFER);
if (newbuf) {
newbuf->bss_index = pmbuf->bss_index;
newbuf->buf_type = pmbuf->buf_type;
newbuf->priority = pmbuf->priority;
newbuf->in_ts_sec = pmbuf->in_ts_sec;
newbuf->in_ts_usec = pmbuf->in_ts_usec;
newbuf->data_offset =
(sizeof(UapTxPD) + INTF_HEADER_LEN +
DMA_ALIGNMENT);
util_scalar_increment(pmadapter->pmoal_handle,
&pmadapter->
pending_bridge_pkts,
pmadapter->callbacks.
moal_spin_lock,
pmadapter->callbacks.
moal_spin_unlock);
newbuf->flags |= MLAN_BUF_FLAG_BRIDGE_BUF;
/* copy the data */
memcpy(pmadapter,
(t_u8 *)newbuf->pbuf +
newbuf->data_offset,
pmbuf->pbuf + pmbuf->data_offset,
pmbuf->data_len);
newbuf->data_len = pmbuf->data_len;
wlan_wmm_add_buf_txqueue(pmadapter, newbuf);
if (util_scalar_read(pmadapter->pmoal_handle,
&pmadapter->
pending_bridge_pkts,
pmadapter->callbacks.
moal_spin_lock,
pmadapter->callbacks.
moal_spin_unlock) >
RX_HIGH_THRESHOLD)
wlan_drop_tx_pkts(priv);
wlan_recv_event(priv,
MLAN_EVENT_ID_DRV_DEFER_HANDLING,
MNULL);
}
goto done;
} else if (MLAN_STATUS_FAILURE ==
wlan_check_unicast_packet(priv,
prx_pkt->eth803_hdr.
dest_addr)) {
/* drop packet */
PRINTM(MDATA, "Drop AMSDU dest " MACSTR "\n",
MAC2STR(prx_pkt->eth803_hdr.dest_addr));
goto done;
}
}
upload:
/** send packet to moal */
ret = pmadapter->callbacks.moal_recv_packet(pmadapter->pmoal_handle,
pmbuf);
done:
LEAVE();
return ret;
}
/**
* @brief This function processes received packet and forwards it
* to kernel/upper layer
*
* @param adapter A pointer to mlan_adapter
* @param pmbuf A pointer to mlan_buffer which includes the received packet
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_ops_uap_process_rx_packet(IN t_void *adapter, IN pmlan_buffer pmbuf)
{
pmlan_adapter pmadapter = (pmlan_adapter)adapter;
mlan_status ret = MLAN_STATUS_SUCCESS;
UapRxPD *prx_pd;
wlan_mgmt_pkt *puap_pkt_hdr = MNULL;
RxPacketHdr_t *prx_pkt;
pmlan_private priv = pmadapter->priv[pmbuf->bss_index];
t_u8 ta[MLAN_MAC_ADDR_LENGTH];
t_u16 rx_pkt_type = 0;
sta_node *sta_ptr = MNULL;
t_u8 adj_rx_rate = 0;
ENTER();
prx_pd = (UapRxPD *)(pmbuf->pbuf + pmbuf->data_offset);
/* Endian conversion */
uap_endian_convert_RxPD(prx_pd);
priv->rxpd_rate = prx_pd->rx_rate;
priv->rxpd_rate_info = prx_pd->rate_info;
if (!priv->adapter->psdio_device->v15_fw_api)
priv->rxpd_rate_info =
wlan_convert_v14_rate_ht_info(priv->rxpd_rate_info);
if (priv->bss_type == MLAN_BSS_TYPE_UAP) {
adj_rx_rate =
wlan_adjust_data_rate(priv, priv->rxpd_rate,
priv->rxpd_rate_info);
pmadapter->callbacks.moal_hist_data_add(pmadapter->pmoal_handle,
pmbuf->bss_index,
adj_rx_rate,
prx_pd->snr, prx_pd->nf,
prx_pd->antenna);
}
rx_pkt_type = prx_pd->rx_pkt_type;
prx_pkt = (RxPacketHdr_t *)((t_u8 *)prx_pd + prx_pd->rx_pkt_offset);
PRINTM(MINFO,
"RX Data: data_len - prx_pd->rx_pkt_offset = %d - %d = %d\n",
pmbuf->data_len, prx_pd->rx_pkt_offset,
pmbuf->data_len - prx_pd->rx_pkt_offset);
if ((prx_pd->rx_pkt_offset + prx_pd->rx_pkt_length) !=
(t_u16)pmbuf->data_len) {
PRINTM(MERROR,
"Wrong rx packet: len=%d,rx_pkt_offset=%d,"
" rx_pkt_length=%d\n", pmbuf->data_len,
prx_pd->rx_pkt_offset, prx_pd->rx_pkt_length);
pmbuf->status_code = MLAN_ERROR_PKT_SIZE_INVALID;
ret = MLAN_STATUS_FAILURE;
wlan_free_mlan_buffer(pmadapter, pmbuf);
goto done;
}
pmbuf->data_len = prx_pd->rx_pkt_offset + prx_pd->rx_pkt_length;
if (pmadapter->priv[pmbuf->bss_index]->mgmt_frame_passthru_mask &&
prx_pd->rx_pkt_type == PKT_TYPE_MGMT_FRAME) {
/* Check if this is mgmt packet and needs to forwarded to app
as an event */
puap_pkt_hdr =
(wlan_mgmt_pkt *)((t_u8 *)prx_pd +
prx_pd->rx_pkt_offset);
puap_pkt_hdr->frm_len = wlan_le16_to_cpu(puap_pkt_hdr->frm_len);
if ((puap_pkt_hdr->wlan_header.
frm_ctl & IEEE80211_FC_MGMT_FRAME_TYPE_MASK) == 0)
wlan_process_802dot11_mgmt_pkt(pmadapter->
priv[pmbuf->bss_index],
(t_u8 *)&puap_pkt_hdr->
wlan_header,
puap_pkt_hdr->frm_len +
sizeof(wlan_mgmt_pkt) -
sizeof(puap_pkt_hdr->
frm_len),
(RxPD *)prx_pd);
wlan_free_mlan_buffer(pmadapter, pmbuf);
goto done;
}
pmbuf->priority = prx_pd->priority;
memcpy(pmadapter, ta, prx_pkt->eth803_hdr.src_addr,
MLAN_MAC_ADDR_LENGTH);
if ((rx_pkt_type != PKT_TYPE_BAR) && (prx_pd->priority < MAX_NUM_TID)) {
sta_ptr = wlan_get_station_entry(priv, ta);
if (sta_ptr)
sta_ptr->rx_seq[prx_pd->priority] = prx_pd->seq_num;
}
/* check if UAP enable 11n */
if (!priv->is_11n_enabled ||
(!wlan_11n_get_rxreorder_tbl
((mlan_private *)priv, prx_pd->priority, ta)
&& (prx_pd->rx_pkt_type != PKT_TYPE_AMSDU)
)) {
if (priv->pkt_fwd)
wlan_process_uap_rx_packet(priv, pmbuf);
else
wlan_upload_uap_rx_packet(pmadapter, pmbuf);
goto done;
}
/* Reorder and send to OS */
ret = mlan_11n_rxreorder_pkt(priv, prx_pd->seq_num,
prx_pd->priority, ta,
(t_u8)prx_pd->rx_pkt_type, (void *)pmbuf);
if (ret || (rx_pkt_type == PKT_TYPE_BAR)) {
wlan_free_mlan_buffer(pmadapter, pmbuf);
}
done:
LEAVE();
return ret;
}
/**
* @brief This function processes the received buffer
*
* @param adapter A pointer to mlan_adapter
* @param pmbuf A pointer to the received buffer
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_ops_sta_process_rx_packet(IN t_void *adapter, IN pmlan_buffer pmbuf)
{
pmlan_adapter pmadapter = (pmlan_adapter)adapter;
mlan_status ret = MLAN_STATUS_SUCCESS;
RxPD *prx_pd;
RxPacketHdr_t *prx_pkt;
pmlan_private priv = pmadapter->priv[pmbuf->bss_index];
t_u8 ta[MLAN_MAC_ADDR_LENGTH];
t_u16 rx_pkt_type = 0;
wlan_mgmt_pkt *pmgmt_pkt_hdr = MNULL;
sta_node *sta_ptr = MNULL;
ENTER();
prx_pd = (RxPD *)(pmbuf->pbuf + pmbuf->data_offset);
/* Endian conversion */
endian_convert_RxPD(prx_pd);
rx_pkt_type = prx_pd->rx_pkt_type;
prx_pkt = (RxPacketHdr_t *)((t_u8 *)prx_pd + prx_pd->rx_pkt_offset);
if ((prx_pd->rx_pkt_offset + prx_pd->rx_pkt_length) >
(t_u16)pmbuf->data_len) {
PRINTM(MERROR,
"Wrong rx packet: len=%d,rx_pkt_offset=%d,"
" rx_pkt_length=%d\n", pmbuf->data_len,
prx_pd->rx_pkt_offset, prx_pd->rx_pkt_length);
pmbuf->status_code = MLAN_ERROR_PKT_SIZE_INVALID;
ret = MLAN_STATUS_FAILURE;
wlan_free_mlan_buffer(pmadapter, pmbuf);
goto done;
}
pmbuf->data_len = prx_pd->rx_pkt_offset + prx_pd->rx_pkt_length;
if (pmadapter->priv[pmbuf->bss_index]->mgmt_frame_passthru_mask &&
prx_pd->rx_pkt_type == PKT_TYPE_MGMT_FRAME) {
/* Check if this is mgmt packet and needs to forwarded to app
as an event */
pmgmt_pkt_hdr =
(wlan_mgmt_pkt *)((t_u8 *)prx_pd +
prx_pd->rx_pkt_offset);
pmgmt_pkt_hdr->frm_len =
wlan_le16_to_cpu(pmgmt_pkt_hdr->frm_len);
if ((pmgmt_pkt_hdr->wlan_header.frm_ctl
& IEEE80211_FC_MGMT_FRAME_TYPE_MASK) == 0){
wlan_process_802dot11_mgmt_pkt(pmadapter->
priv[pmbuf->bss_index],
(t_u8 *)&pmgmt_pkt_hdr->
wlan_header,
pmgmt_pkt_hdr->frm_len +
sizeof(wlan_mgmt_pkt)
-
sizeof(pmgmt_pkt_hdr->
frm_len),prx_pd);
wlan_sta_check_mgmt_frame(pmadapter->priv[pmbuf->bss_index],
(t_u8 *) &pmgmt_pkt_hdr->wlan_header,
pmgmt_pkt_hdr->frm_len +
sizeof(wlan_mgmt_pkt) -
sizeof(pmgmt_pkt_hdr->frm_len),
prx_pd);
}
wlan_free_mlan_buffer(pmadapter, pmbuf);
goto done;
}
/*
* If the packet is not an unicast packet then send the packet
* directly to os. Don't pass thru rx reordering
*/
if ((!IS_11N_ENABLED(priv) &&
!(prx_pd->flags & RXPD_FLAG_PKT_DIRECT_LINK)) ||
memcmp(priv->adapter, priv->curr_addr,
prx_pkt->eth803_hdr.dest_addr, MLAN_MAC_ADDR_LENGTH)) {
wlan_process_rx_packet(pmadapter, pmbuf);
goto done;
}
if (queuing_ra_based(priv) ||
(prx_pd->flags & RXPD_FLAG_PKT_DIRECT_LINK)) {
memcpy(pmadapter, ta, prx_pkt->eth803_hdr.src_addr,
MLAN_MAC_ADDR_LENGTH);
if ((prx_pd->flags & RXPD_FLAG_PKT_DIRECT_LINK) &&
(prx_pd->priority < MAX_NUM_TID)) {
PRINTM(MDATA, "tdls packet %p " MACSTR "\n", pmbuf,
MAC2STR(ta));
sta_ptr = wlan_get_station_entry(priv, ta);
if (sta_ptr) {
sta_ptr->rx_seq[prx_pd->priority] =
prx_pd->seq_num;
sta_ptr->snr = prx_pd->snr;
sta_ptr->nf = prx_pd->nf;
pmadapter->callbacks.
moal_updata_peer_signal(pmadapter->
pmoal_handle,
pmbuf->
bss_index, ta,
prx_pd->snr,
prx_pd->nf);
}
}
} else {
if ((rx_pkt_type != PKT_TYPE_BAR) &&
(prx_pd->priority < MAX_NUM_TID))
priv->rx_seq[prx_pd->priority] = prx_pd->seq_num;
memcpy(pmadapter, ta,
priv->curr_bss_params.bss_descriptor.mac_address,
MLAN_MAC_ADDR_LENGTH);
}
if ((priv->port_ctrl_mode == MTRUE && priv->port_open == MFALSE) &&
(rx_pkt_type != PKT_TYPE_BAR)) {
mlan_11n_rxreorder_pkt(priv, prx_pd->seq_num, prx_pd->priority,
ta, (t_u8)prx_pd->rx_pkt_type,
(t_void *)RX_PKT_DROPPED_IN_FW);
wlan_process_rx_packet(pmadapter, pmbuf);
goto done;
}
/* Reorder and send to OS */
ret = mlan_11n_rxreorder_pkt(priv, prx_pd->seq_num,
prx_pd->priority, ta,
(t_u8)prx_pd->rx_pkt_type, (void *)pmbuf);
if (ret || (rx_pkt_type == PKT_TYPE_BAR)
) {
wlan_free_mlan_buffer(pmadapter, pmbuf);
}
done:
LEAVE();
return ret;
}
/**
* @brief This function will create a entry in rx reordering table for the
* given ta/tid and will initialize it with seq_num, win_size
*
* @param priv A pointer to mlan_private
* @param ta ta to find in reordering table
* @param tid tid to find in reordering table
* @param win_size win_size for the give ta/tid pair.
* @param seq_num Starting sequence number for current entry.
*
* @return N/A
*/
t_void
wlan_11n_create_rxreorder_tbl(mlan_private * priv, t_u8 * ta, int tid,
int win_size, int seq_num)
{
int i;
pmlan_adapter pmadapter = priv->adapter;
RxReorderTbl *rx_reor_tbl_ptr, *new_node;
#ifdef UAP_SUPPORT
sta_node *sta_ptr = MNULL;
#endif
t_u16 last_seq = 0;
ENTER();
/*
* If we get a TID, ta pair which is already present dispatch all the
* the packets and move the window size until the ssn
*/
if ((rx_reor_tbl_ptr = wlan_11n_get_rxreorder_tbl(priv, tid, ta))) {
wlan_11n_dispatch_pkt_until_start_win(priv, rx_reor_tbl_ptr, seq_num);
} else {
PRINTM(MDAT_D, "%s: seq_num %d, tid %d, ta %02x:%02x:%02x:%02x:"
"%02x:%02x, win_size %d\n", __FUNCTION__,
seq_num, tid, ta[0], ta[1], ta[2], ta[3],
ta[4], ta[5], win_size);
if (pmadapter->callbacks.
moal_malloc(pmadapter->pmoal_handle, sizeof(RxReorderTbl),
MLAN_MEM_DEF, (t_u8 **) & new_node)) {
PRINTM(MERROR, "Rx reorder memory allocation failed\n");
return;
}
util_init_list((pmlan_linked_list) new_node);
new_node->tid = tid;
memcpy(pmadapter, new_node->ta, ta, MLAN_MAC_ADDR_LENGTH);
new_node->start_win = seq_num;
if (queuing_ra_based(priv)) {
// TODO for adhoc
#ifdef UAP_SUPPORT
if (GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_UAP) {
if ((sta_ptr = wlan_get_station_entry(priv, ta)))
last_seq = sta_ptr->rx_seq[tid];
}
#endif
PRINTM(MINFO, "UAP/ADHOC:last_seq=%d start_win=%d\n", last_seq,
new_node->start_win);
} else {
last_seq = priv->rx_seq[tid];
}
if (last_seq >= new_node->start_win) {
PRINTM(MDAT_D, "Update start_win: last_seq=%d, start_win=%d\n",
last_seq, new_node->start_win);
new_node->start_win = last_seq + 1;
}
new_node->win_size = win_size;
if (pmadapter->callbacks.
moal_malloc(pmadapter->pmoal_handle, sizeof(t_void *) * win_size,
MLAN_MEM_DEF, (t_u8 **) & new_node->rx_reorder_ptr)) {
PRINTM(MERROR, "Rx reorder table memory allocation" "failed\n");
pmadapter->callbacks.moal_mfree(pmadapter->pmoal_handle,
(t_u8 *) new_node);
return;
}
PRINTM(MDAT_D, "Create ReorderPtr: %p\n", new_node);
new_node->timer_context.ptr = new_node;
new_node->timer_context.priv = priv;
new_node->timer_context.timer_is_set = MFALSE;
pmadapter->callbacks.moal_init_timer(pmadapter->pmoal_handle,
&new_node->timer_context.timer,
wlan_flush_data,
&new_node->timer_context);
for (i = 0; i < win_size; ++i)
new_node->rx_reorder_ptr[i] = MNULL;
util_enqueue_list_tail(pmadapter->pmoal_handle,
&priv->rx_reorder_tbl_ptr,
(pmlan_linked_list) new_node,
pmadapter->callbacks.moal_spin_lock,
pmadapter->callbacks.moal_spin_unlock);
}
LEAVE();
}
/**
* @brief This function will parse the TDLS event for further wlan action
*
* @param priv A pointer to mlan_private
* @param pevent A pointer to event buf
*
* @return N/A
*/
static void
wlan_parse_tdls_event(pmlan_private priv, pmlan_buffer pevent)
{
Event_tdls_generic *tdls_event = (Event_tdls_generic *)
(pevent->pbuf + pevent->data_offset + sizeof(mlan_event_id));
sta_node *sta_ptr = MNULL;
pmlan_adapter pmadapter = priv->adapter;
t_u8 i = 0;
IEEEtypes_HTCap_t *pht_cap = MNULL;
t_u16 ie_len = 0;
mlan_ds_misc_tdls_oper tdls_oper;
t_u8 event_buf[100];
mlan_event *ptdls_event = (mlan_event *)event_buf;
tdls_tear_down_event *tdls_evt =
(tdls_tear_down_event *)ptdls_event->event_buf;
ENTER();
/* reason code is not mandatory, hence less by sizeof(t_u16) */
if (pevent->data_len < (sizeof(Event_tdls_generic) -
sizeof(t_u16) - sizeof(mlan_event_id))) {
PRINTM(MERROR, "Invalid length %d for TDLS event\n",
pevent->data_len);
LEAVE();
return;
}
sta_ptr = wlan_get_station_entry(priv, tdls_event->peer_mac_addr);
PRINTM(MEVENT, "TDLS_EVENT: %d " MACSTR "\n",
wlan_le16_to_cpu(tdls_event->event_type),
MAC2STR(tdls_event->peer_mac_addr));
switch (wlan_le16_to_cpu(tdls_event->event_type)) {
case TDLS_EVENT_TYPE_SETUP_REQ:
if (sta_ptr == MNULL) {
sta_ptr =
wlan_add_station_entry(priv,
tdls_event->
peer_mac_addr);
if (sta_ptr) {
sta_ptr->status = TDLS_SETUP_INPROGRESS;
wlan_hold_tdls_packets(priv,
tdls_event->
peer_mac_addr);
}
}
break;
case TDLS_EVENT_TYPE_LINK_ESTABLISHED:
if (sta_ptr) {
sta_ptr->status = TDLS_SETUP_COMPLETE;
/* parse the TLV for station's capability */
ie_len = wlan_le16_to_cpu(tdls_event->u.ie_data.
ie_length);
if (ie_len) {
pht_cap =
(IEEEtypes_HTCap_t *)
wlan_get_specific_ie(priv,
tdls_event->u.
ie_data.ie_ptr,
ie_len,
HT_CAPABILITY);
if (pht_cap) {
sta_ptr->is_11n_enabled = MTRUE;
if (GETHT_MAXAMSDU
(pht_cap->ht_cap.ht_cap_info))
sta_ptr->max_amsdu =
MLAN_TX_DATA_BUF_SIZE_8K;
else
sta_ptr->max_amsdu =
MLAN_TX_DATA_BUF_SIZE_4K;
}
}
for (i = 0; i < MAX_NUM_TID; i++) {
if (sta_ptr->is_11n_enabled)
sta_ptr->ampdu_sta[i] =
priv->aggr_prio_tbl[i].
ampdu_user;
else
sta_ptr->ampdu_sta[i] =
BA_STREAM_NOT_ALLOWED;
}
memset(priv->adapter, sta_ptr->rx_seq, 0xff,
sizeof(sta_ptr->rx_seq));
wlan_restore_tdls_packets(priv,
tdls_event->peer_mac_addr,
TDLS_SETUP_COMPLETE);
pmadapter->tdls_status = TDLS_IN_BASE_CHANNEL;
}
break;
case TDLS_EVENT_TYPE_SETUP_FAILURE:
wlan_restore_tdls_packets(priv, tdls_event->peer_mac_addr,
TDLS_SETUP_FAILURE);
if (sta_ptr)
wlan_delete_station_entry(priv,
tdls_event->peer_mac_addr);
if (MTRUE == wlan_is_station_list_empty(priv))
pmadapter->tdls_status = TDLS_NOT_SETUP;
else
pmadapter->tdls_status = TDLS_IN_BASE_CHANNEL;
break;
case TDLS_EVENT_TYPE_LINK_TORN_DOWN:
if (sta_ptr) {
if (sta_ptr->external_tdls) {
PRINTM(MMSG,
"Receive TDLS TEAR DOWN event, Disable TDLS LINK\n");
memset(pmadapter, &tdls_oper, 0,
sizeof(tdls_oper));
tdls_oper.tdls_action = WLAN_TDLS_DISABLE_LINK;
memcpy(priv->adapter, tdls_oper.peer_mac,
tdls_event->peer_mac_addr,
MLAN_MAC_ADDR_LENGTH);
/* Send command to firmware to delete tdls link */
wlan_prepare_cmd(priv,
HostCmd_CMD_TDLS_OPERATION,
HostCmd_ACT_GEN_SET,
0,
(t_void *)MNULL, &tdls_oper);
ptdls_event->bss_index = priv->bss_index;
ptdls_event->event_id =
MLAN_EVENT_ID_DRV_TDLS_TEARDOWN_REQ;
ptdls_event->event_len =
sizeof(tdls_tear_down_event);
memcpy(priv->adapter,
(t_u8 *)tdls_evt->peer_mac_addr,
tdls_event->peer_mac_addr,
MLAN_MAC_ADDR_LENGTH);
tdls_evt->reason_code =
wlan_le16_to_cpu(tdls_event->u.
reason_code);
wlan_recv_event(priv,
MLAN_EVENT_ID_DRV_TDLS_TEARDOWN_REQ,
ptdls_event);
/* Signal MOAL to trigger mlan_main_process */
wlan_recv_event(priv,
MLAN_EVENT_ID_DRV_DEFER_HANDLING,
MNULL);
LEAVE();
return;
}
wlan_restore_tdls_packets(priv,
tdls_event->peer_mac_addr,
TDLS_TEAR_DOWN);
if (sta_ptr->is_11n_enabled) {
wlan_cleanup_reorder_tbl(priv,
tdls_event->
peer_mac_addr);
pmadapter->callbacks.moal_spin_lock(pmadapter->
pmoal_handle,
priv->wmm.
ra_list_spinlock);
wlan_11n_cleanup_txbastream_tbl(priv,
tdls_event->
peer_mac_addr);
pmadapter->callbacks.
moal_spin_unlock(pmadapter->
pmoal_handle,
priv->wmm.
ra_list_spinlock);
}
wlan_delete_station_entry(priv,
tdls_event->peer_mac_addr);
if (MTRUE == wlan_is_station_list_empty(priv))
pmadapter->tdls_status = TDLS_NOT_SETUP;
else
pmadapter->tdls_status = TDLS_IN_BASE_CHANNEL;
}
break;
case TDLS_EVENT_TYPE_CHAN_SWITCH_RESULT:
PRINTM(MEVENT,
"TDLS_CHAN_SWITCH_RESULT: status=0x%x, reason=0x%x current_channel=%d\n",
tdls_event->u.switch_result.status,
tdls_event->u.switch_result.reason,
(int)tdls_event->u.switch_result.current_channel);
if (tdls_event->u.switch_result.status == MLAN_STATUS_SUCCESS) {
if (tdls_event->u.switch_result.current_channel ==
TDLS_BASE_CHANNEL) {
/* enable traffic to AP */
if (pmadapter->tdls_status !=
TDLS_IN_BASE_CHANNEL) {
wlan_update_non_tdls_ralist(priv,
tdls_event->
peer_mac_addr,
MFALSE);
pmadapter->tdls_status =
TDLS_IN_BASE_CHANNEL;
}
} else if (tdls_event->u.switch_result.
current_channel == TDLS_OFF_CHANNEL) {
/* pause traffic to AP */
if (pmadapter->tdls_status !=
TDLS_IN_OFF_CHANNEL) {
wlan_update_non_tdls_ralist(priv,
tdls_event->
peer_mac_addr,
MTRUE);
pmadapter->tdls_status =
TDLS_IN_OFF_CHANNEL;
}
}
} else {
if (tdls_event->u.switch_result.current_channel ==
TDLS_BASE_CHANNEL)
pmadapter->tdls_status = TDLS_IN_BASE_CHANNEL;
else if (tdls_event->u.switch_result.current_channel ==
TDLS_OFF_CHANNEL)
pmadapter->tdls_status = TDLS_IN_OFF_CHANNEL;
}
break;
case TDLS_EVENT_TYPE_START_CHAN_SWITCH:
PRINTM(MEVENT, "TDLS start channel switch....\n");
pmadapter->tdls_status = TDLS_SWITCHING_CHANNEL;
break;
case TDLS_EVENT_TYPE_CHAN_SWITCH_STOPPED:
PRINTM(MEVENT, "TDLS channel switch stopped, reason=%d\n",
tdls_event->u.cs_stop_reason);
break;
case TDLS_EVENT_TYPE_DEBUG:
case TDLS_EVENT_TYPE_PACKET:
break;
default:
PRINTM(MERROR, "unknown event type %d\n",
wlan_le16_to_cpu(tdls_event->event_type));
break;
}
LEAVE();
}
/**
* @brief This function will process tx pause event
*
* @param priv A pointer to mlan_private
* @param pevent A pointer to event buf
*
* @return N/A
*/
static void
wlan_process_sta_tx_pause_event(pmlan_private priv, pmlan_buffer pevent)
{
t_u16 tlv_type, tlv_len;
int tlv_buf_left = pevent->data_len - sizeof(t_u32);
MrvlIEtypesHeader_t *tlv =
(MrvlIEtypesHeader_t *)(pevent->pbuf + pevent->data_offset +
sizeof(t_u32));
MrvlIEtypes_tx_pause_t *tx_pause_tlv;
sta_node *sta_ptr = MNULL;
tdlsStatus_e status;
t_u8 *bssid = MNULL;
ENTER();
if (priv->media_connected)
bssid = priv->curr_bss_params.bss_descriptor.mac_address;
while (tlv_buf_left >= (int)sizeof(MrvlIEtypesHeader_t)) {
tlv_type = wlan_le16_to_cpu(tlv->type);
tlv_len = wlan_le16_to_cpu(tlv->len);
if ((sizeof(MrvlIEtypesHeader_t) + tlv_len) >
(unsigned int)tlv_buf_left) {
PRINTM(MERROR, "wrong tlv: tlvLen=%d, tlvBufLeft=%d\n",
tlv_len, tlv_buf_left);
break;
}
if (tlv_type == TLV_TYPE_TX_PAUSE) {
tx_pause_tlv = (MrvlIEtypes_tx_pause_t *)tlv;
PRINTM(MCMND, "TxPause: " MACSTR " pause=%d, pkts=%d\n",
MAC2STR(tx_pause_tlv->peermac),
tx_pause_tlv->tx_pause, tx_pause_tlv->pkt_cnt);
if (bssid &&
!memcmp(priv->adapter, bssid, tx_pause_tlv->peermac,
MLAN_MAC_ADDR_LENGTH)) {
if (tx_pause_tlv->tx_pause)
priv->port_open = MFALSE;
else
priv->port_open = MTRUE;
} else {
status = wlan_get_tdls_link_status(priv,
tx_pause_tlv->
peermac);
if (MTRUE == wlan_is_tdls_link_setup(status)) {
sta_ptr =
wlan_get_station_entry(priv,
tx_pause_tlv->
peermac);
if (sta_ptr) {
if (sta_ptr->tx_pause !=
tx_pause_tlv->tx_pause) {
sta_ptr->tx_pause =
tx_pause_tlv->
tx_pause;
wlan_update_ralist_tx_pause
(priv,
tx_pause_tlv->
peermac,
tx_pause_tlv->
tx_pause);
}
}
}
}
}
tlv_buf_left -= (sizeof(MrvlIEtypesHeader_t) + tlv_len);
tlv = (MrvlIEtypesHeader_t *)((t_u8 *)tlv + tlv_len +
sizeof(MrvlIEtypesHeader_t));
}
LEAVE();
return;
}
/**
* @brief This function processes received packet and forwards it
* to kernel/upper layer or send back to firmware
*
* @param priv A pointer to mlan_private
* @param pmbuf A pointer to mlan_buffer which includes the received packet
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_process_uap_rx_packet(IN mlan_private * priv, IN pmlan_buffer pmbuf)
{
pmlan_adapter pmadapter = priv->adapter;
mlan_status ret = MLAN_STATUS_SUCCESS;
UapRxPD *prx_pd;
RxPacketHdr_t *prx_pkt;
pmlan_buffer newbuf = MNULL;
ENTER();
prx_pd = (UapRxPD *) (pmbuf->pbuf + pmbuf->data_offset);
prx_pkt = (RxPacketHdr_t *) ((t_u8 *) prx_pd + prx_pd->rx_pkt_offset);
DBG_HEXDUMP(MDAT_D, "uAP RxPD", prx_pd,
MIN(sizeof(UapRxPD), MAX_DATA_DUMP_LEN));
DBG_HEXDUMP(MDAT_D, "uAP Rx Payload",
((t_u8 *) prx_pd + prx_pd->rx_pkt_offset),
MIN(prx_pd->rx_pkt_length, MAX_DATA_DUMP_LEN));
PRINTM(MINFO, "RX Data: data_len - prx_pd->rx_pkt_offset = %d - %d = %d\n",
pmbuf->data_len, prx_pd->rx_pkt_offset,
pmbuf->data_len - prx_pd->rx_pkt_offset);
PRINTM(MDATA, "Rx dest %02x:%02x:%02x:%02x:%02x:%02x\n",
prx_pkt->eth803_hdr.dest_addr[0], prx_pkt->eth803_hdr.dest_addr[1],
prx_pkt->eth803_hdr.dest_addr[2], prx_pkt->eth803_hdr.dest_addr[3],
prx_pkt->eth803_hdr.dest_addr[4], prx_pkt->eth803_hdr.dest_addr[5]);
/* don't do packet forwarding in disconnected state */
/* don't do packet forwarding when packet > 1514 */
if ((priv->media_connected == MFALSE) ||
((pmbuf->data_len - prx_pd->rx_pkt_offset) > MV_ETH_FRAME_LEN))
goto upload;
if (prx_pkt->eth803_hdr.dest_addr[0] & 0x01) {
/* Multicast pkt */
if ((newbuf =
wlan_alloc_mlan_buffer(pmadapter, MLAN_TX_DATA_BUF_SIZE_2K, 0,
MTRUE))) {
newbuf->bss_index = pmbuf->bss_index;
newbuf->buf_type = pmbuf->buf_type;
newbuf->priority = pmbuf->priority;
newbuf->in_ts_sec = pmbuf->in_ts_sec;
newbuf->in_ts_usec = pmbuf->in_ts_usec;
newbuf->data_offset =
(sizeof(UapTxPD) + INTF_HEADER_LEN + DMA_ALIGNMENT);
pmadapter->pending_bridge_pkts++;
newbuf->flags |= MLAN_BUF_FLAG_BRIDGE_BUF;
/* copy the data, skip rxpd */
memcpy(pmadapter, (t_u8 *) newbuf->pbuf + newbuf->data_offset,
pmbuf->pbuf + pmbuf->data_offset + prx_pd->rx_pkt_offset,
pmbuf->data_len - prx_pd->rx_pkt_offset);
newbuf->data_len = pmbuf->data_len - prx_pd->rx_pkt_offset;
wlan_wmm_add_buf_txqueue(pmadapter, newbuf);
if (pmadapter->pending_bridge_pkts > RX_HIGH_THRESHOLD)
wlan_drop_tx_pkts(priv);
}
} else {
if (wlan_get_station_entry(priv, prx_pkt->eth803_hdr.dest_addr)) {
/* Forwarding Intra-BSS packet */
pmbuf->data_len -= prx_pd->rx_pkt_offset;
pmbuf->data_offset += prx_pd->rx_pkt_offset;
pmbuf->flags |= MLAN_BUF_FLAG_BRIDGE_BUF;
pmadapter->pending_bridge_pkts++;
wlan_wmm_add_buf_txqueue(pmadapter, pmbuf);
if (pmadapter->pending_bridge_pkts > RX_HIGH_THRESHOLD)
wlan_drop_tx_pkts(priv);
pmadapter->callbacks.moal_recv_complete(pmadapter->pmoal_handle,
MNULL,
MLAN_USB_EP_DATA, ret);
goto done;
}
}
upload:
/* Chop off RxPD */
pmbuf->data_len -= prx_pd->rx_pkt_offset;
pmbuf->data_offset += prx_pd->rx_pkt_offset;
pmbuf->pparent = MNULL;
pmadapter->callbacks.moal_get_system_time(pmadapter->pmoal_handle,
&pmbuf->out_ts_sec,
&pmbuf->out_ts_usec);
PRINTM(MDATA, "%lu.%06lu : Data => kernel seq_num=%d tid=%d\n",
pmbuf->out_ts_sec, pmbuf->out_ts_usec, prx_pd->seq_num,
prx_pd->priority);
ret = pmadapter->callbacks.moal_recv_packet(pmadapter->pmoal_handle, pmbuf);
if (ret == MLAN_STATUS_FAILURE) {
PRINTM(MERROR, "uAP Rx Error: moal_recv_packet returned error\n");
pmbuf->status_code = MLAN_ERROR_PKT_INVALID;
}
if (ret != MLAN_STATUS_PENDING) {
pmadapter->callbacks.moal_recv_complete(pmadapter->pmoal_handle, pmbuf,
MLAN_USB_EP_DATA, ret);
}
done:
LEAVE();
return ret;
}
/**
* @brief This function processes received packet and forwards it
* to kernel/upper layer or send back to firmware
*
* @param priv A pointer to mlan_private
* @param pmbuf A pointer to mlan_buffer which includes the received packet
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_uap_recv_packet(IN mlan_private * priv, IN pmlan_buffer pmbuf)
{
pmlan_adapter pmadapter = priv->adapter;
mlan_status ret = MLAN_STATUS_SUCCESS;
RxPacketHdr_t *prx_pkt;
pmlan_buffer newbuf = MNULL;
ENTER();
prx_pkt = (RxPacketHdr_t *) ((t_u8 *) pmbuf->pbuf + pmbuf->data_offset);
DBG_HEXDUMP(MDAT_D, "uap_recv_packet", pmbuf->pbuf + pmbuf->data_offset,
MIN(pmbuf->data_len, MAX_DATA_DUMP_LEN));
PRINTM(MDATA, "AMSDU dest %02x:%02x:%02x:%02x:%02x:%02x\n",
prx_pkt->eth803_hdr.dest_addr[0], prx_pkt->eth803_hdr.dest_addr[1],
prx_pkt->eth803_hdr.dest_addr[2], prx_pkt->eth803_hdr.dest_addr[3],
prx_pkt->eth803_hdr.dest_addr[4], prx_pkt->eth803_hdr.dest_addr[5]);
/* don't do packet forwarding in disconnected state */
if ((priv->media_connected == MFALSE) ||
(pmbuf->data_len > MV_ETH_FRAME_LEN))
goto upload;
if (prx_pkt->eth803_hdr.dest_addr[0] & 0x01) {
/* Multicast pkt */
if ((newbuf =
wlan_alloc_mlan_buffer(pmadapter, MLAN_TX_DATA_BUF_SIZE_2K, 0,
MTRUE))) {
newbuf->bss_index = pmbuf->bss_index;
newbuf->buf_type = pmbuf->buf_type;
newbuf->priority = pmbuf->priority;
newbuf->in_ts_sec = pmbuf->in_ts_sec;
newbuf->in_ts_usec = pmbuf->in_ts_usec;
newbuf->data_offset =
(sizeof(UapTxPD) + INTF_HEADER_LEN + DMA_ALIGNMENT);
pmadapter->pending_bridge_pkts++;
newbuf->flags |= MLAN_BUF_FLAG_BRIDGE_BUF;
/* copy the data */
memcpy(pmadapter, (t_u8 *) newbuf->pbuf + newbuf->data_offset,
pmbuf->pbuf + pmbuf->data_offset, pmbuf->data_len);
newbuf->data_len = pmbuf->data_len;
wlan_wmm_add_buf_txqueue(pmadapter, newbuf);
if (pmadapter->pending_bridge_pkts > RX_HIGH_THRESHOLD)
wlan_drop_tx_pkts(priv);
}
} else {
if (wlan_get_station_entry(priv, prx_pkt->eth803_hdr.dest_addr)) {
/* Intra BSS packet */
if ((newbuf =
wlan_alloc_mlan_buffer(pmadapter, MLAN_TX_DATA_BUF_SIZE_2K, 0,
MTRUE))) {
newbuf->bss_index = pmbuf->bss_index;
newbuf->buf_type = pmbuf->buf_type;
newbuf->priority = pmbuf->priority;
newbuf->in_ts_sec = pmbuf->in_ts_sec;
newbuf->in_ts_usec = pmbuf->in_ts_usec;
newbuf->data_offset =
(sizeof(UapTxPD) + INTF_HEADER_LEN + DMA_ALIGNMENT);
pmadapter->pending_bridge_pkts++;
newbuf->flags |= MLAN_BUF_FLAG_BRIDGE_BUF;
/* copy the data */
memcpy(pmadapter, (t_u8 *) newbuf->pbuf + newbuf->data_offset,
pmbuf->pbuf + pmbuf->data_offset, pmbuf->data_len);
newbuf->data_len = pmbuf->data_len;
wlan_wmm_add_buf_txqueue(pmadapter, newbuf);
if (pmadapter->pending_bridge_pkts > RX_HIGH_THRESHOLD)
wlan_drop_tx_pkts(priv);
}
goto done;
}
}
upload:
/** send packet to moal */
ret = pmadapter->callbacks.moal_recv_packet(pmadapter->pmoal_handle, pmbuf);
done:
LEAVE();
return ret;
}
/**
* @brief This function processes received packet and forwards it
* to kernel/upper layer
*
* @param adapter A pointer to mlan_adapter
* @param pmbuf A pointer to mlan_buffer which includes the received packet
*
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
*/
mlan_status
wlan_ops_uap_process_rx_packet(IN t_void * adapter, IN pmlan_buffer pmbuf)
{
pmlan_adapter pmadapter = (pmlan_adapter) adapter;
mlan_status ret = MLAN_STATUS_SUCCESS;
UapRxPD *prx_pd;
wlan_mgmt_pkt *puap_pkt_hdr = MNULL;
RxPacketHdr_t *prx_pkt;
pmlan_private priv = pmadapter->priv[pmbuf->bss_index];
t_u8 ta[MLAN_MAC_ADDR_LENGTH];
t_u16 rx_pkt_type = 0;
sta_node *sta_ptr = MNULL;
ENTER();
prx_pd = (UapRxPD *) (pmbuf->pbuf + pmbuf->data_offset);
/* Endian conversion */
uap_endian_convert_RxPD(prx_pd);
rx_pkt_type = prx_pd->rx_pkt_type;
prx_pkt = (RxPacketHdr_t *) ((t_u8 *) prx_pd + prx_pd->rx_pkt_offset);
PRINTM(MINFO, "RX Data: data_len - prx_pd->rx_pkt_offset = %d - %d = %d\n",
pmbuf->data_len, prx_pd->rx_pkt_offset,
pmbuf->data_len - prx_pd->rx_pkt_offset);
if ((prx_pd->rx_pkt_offset + prx_pd->rx_pkt_length) >
(t_u16) pmbuf->data_len) {
PRINTM(MERROR,
"Wrong rx packet: len=%d,rx_pkt_offset=%d,"
" rx_pkt_length=%d\n", pmbuf->data_len, prx_pd->rx_pkt_offset,
prx_pd->rx_pkt_length);
pmbuf->status_code = MLAN_ERROR_PKT_SIZE_INVALID;
ret = MLAN_STATUS_FAILURE;
pmadapter->callbacks.moal_recv_complete(pmadapter->pmoal_handle,
pmbuf, MLAN_USB_EP_DATA, ret);
goto done;
}
pmbuf->data_len = prx_pd->rx_pkt_offset + prx_pd->rx_pkt_length;
if (pmadapter->priv[pmbuf->bss_index]->mgmt_frame_passthru_mask &&
prx_pd->rx_pkt_type == PKT_TYPE_MGMT_FRAME) {
/* Check if this is mgmt packet and needs to forwarded to app as an
event */
puap_pkt_hdr =
(wlan_mgmt_pkt *) ((t_u8 *) prx_pd + prx_pd->rx_pkt_offset);
puap_pkt_hdr->frm_len = wlan_le16_to_cpu(puap_pkt_hdr->frm_len);
if ((puap_pkt_hdr->wlan_header.
frm_ctl & IEEE80211_FC_MGMT_FRAME_TYPE_MASK) == 0)
wlan_process_802dot11_mgmt_pkt(pmadapter->priv[pmbuf->bss_index],
(t_u8 *) & puap_pkt_hdr->wlan_header,
puap_pkt_hdr->frm_len +
sizeof(wlan_mgmt_pkt) -
sizeof(puap_pkt_hdr->frm_len));
}
pmbuf->priority = prx_pd->priority;
if (prx_pd->rx_pkt_type == PKT_TYPE_AMSDU) {
pmbuf->data_len = prx_pd->rx_pkt_length;
pmbuf->data_offset += prx_pd->rx_pkt_offset;
wlan_11n_deaggregate_pkt(priv, pmbuf);
goto done;
}
memcpy(pmadapter, ta, prx_pkt->eth803_hdr.src_addr, MLAN_MAC_ADDR_LENGTH);
if ((rx_pkt_type != PKT_TYPE_BAR) && (prx_pd->priority < MAX_NUM_TID)) {
if ((sta_ptr = wlan_get_station_entry(priv, ta)))
sta_ptr->rx_seq[prx_pd->priority] = prx_pd->seq_num;
}
/* check if UAP enable 11n */
if (!priv->is_11n_enabled ||
!wlan_11n_get_rxreorder_tbl((mlan_private *) priv, prx_pd->priority,
ta)) {
if (priv->pkt_fwd)
wlan_process_uap_rx_packet(priv, pmbuf);
else
wlan_upload_uap_rx_packet(pmadapter, pmbuf);
goto done;
}
/* Reorder and send to OS */
if ((ret = mlan_11n_rxreorder_pkt(priv, prx_pd->seq_num,
prx_pd->priority, ta,
(t_u8) prx_pd->rx_pkt_type,
(void *) pmbuf))
|| (rx_pkt_type == PKT_TYPE_BAR)) {
if ((ret =
pmadapter->callbacks.moal_recv_complete(pmadapter->pmoal_handle,
pmbuf, MLAN_USB_EP_DATA,
ret)))
PRINTM(MERROR, "uAP Rx Error: moal_recv_complete returned error\n");
}
done:
if (priv->is_11n_enabled &&
(pmadapter->pending_bridge_pkts >= RX_MED_THRESHOLD))
wlan_send_delba_to_all_in_reorder_tbl(priv);
LEAVE();
return ret;
}
