static int mwifiex_ret_tdls_oper(struct mwifiex_private *priv, struct host_cmd_ds_command *resp) { struct host_cmd_ds_tdls_oper *cmd_tdls_oper = &resp->params.tdls_oper; u16 reason = le16_to_cpu(cmd_tdls_oper->reason); u16 action = le16_to_cpu(cmd_tdls_oper->tdls_action); struct mwifiex_sta_node *node = mwifiex_get_sta_entry(priv, cmd_tdls_oper->peer_mac); switch (action) { case ACT_TDLS_DELETE: if (reason) { if (!node || reason == TDLS_ERR_LINK_NONEXISTENT) mwifiex_dbg(priv->adapter, MSG, "TDLS link delete for %pM failed: reason %d\n", cmd_tdls_oper->peer_mac, reason); else mwifiex_dbg(priv->adapter, ERROR, "TDLS link delete for %pM failed: reason %d\n", cmd_tdls_oper->peer_mac, reason); } else { mwifiex_dbg(priv->adapter, MSG, "TDLS link delete for %pM successful\n", cmd_tdls_oper->peer_mac); } break; case ACT_TDLS_CREATE: if (reason) { mwifiex_dbg(priv->adapter, ERROR, "TDLS link creation for %pM failed: reason %d", cmd_tdls_oper->peer_mac, reason); if (node && reason != TDLS_ERR_LINK_EXISTS) node->tdls_status = TDLS_SETUP_FAILURE; } else { mwifiex_dbg(priv->adapter, MSG, "TDLS link creation for %pM successful", cmd_tdls_oper->peer_mac); } break; case ACT_TDLS_CONFIG: if (reason) { mwifiex_dbg(priv->adapter, ERROR, "TDLS link config for %pM failed, reason %d\n", cmd_tdls_oper->peer_mac, reason); if (node) node->tdls_status = TDLS_SETUP_FAILURE; } else { mwifiex_dbg(priv->adapter, MSG, "TDLS link config for %pM successful\n", cmd_tdls_oper->peer_mac); } break; default: mwifiex_dbg(priv->adapter, ERROR, "Unknown TDLS command action response %d", action); return -1; } return 0; }
static void mwifiex_process_uap_tx_pause(struct mwifiex_private *priv, struct mwifiex_ie_types_header *tlv) { struct mwifiex_tx_pause_tlv *tp; struct mwifiex_sta_node *sta_ptr; unsigned long flags; tp = (void *)tlv; mwifiex_dbg(priv->adapter, EVENT, "uap tx_pause: %pM pause=%d, pkts=%d\n", tp->peermac, tp->tx_pause, tp->pkt_cnt); if (ether_addr_equal(tp->peermac, priv->netdev->dev_addr)) { if (tp->tx_pause) priv->port_open = false; else priv->port_open = true; } else if (is_multicast_ether_addr(tp->peermac)) { mwifiex_update_ralist_tx_pause(priv, tp->peermac, tp->tx_pause); } else { spin_lock_irqsave(&priv->sta_list_spinlock, flags); sta_ptr = mwifiex_get_sta_entry(priv, tp->peermac); if (sta_ptr && sta_ptr->tx_pause != tp->tx_pause) { sta_ptr->tx_pause = tp->tx_pause; mwifiex_update_ralist_tx_pause(priv, tp->peermac, tp->tx_pause); } spin_unlock_irqrestore(&priv->sta_list_spinlock, flags); } }
/* * This function contains logic for AP packet forwarding. * * If a packet is multicast/broadcast, it is sent to kernel/upper layer * as well as queued back to AP TX queue so that it can be sent to other * associated stations. * If a packet is unicast and RA is present in associated station list, * it is again requeued into AP TX queue. * If a packet is unicast and RA is not in associated station list, * packet is forwarded to kernel to handle routing logic. */ int mwifiex_handle_uap_rx_forward(struct mwifiex_private *priv, struct sk_buff *skb) { struct mwifiex_adapter *adapter = priv->adapter; struct uap_rxpd *uap_rx_pd; struct rx_packet_hdr *rx_pkt_hdr; u8 ra[ETH_ALEN]; struct sk_buff *skb_uap; uap_rx_pd = (struct uap_rxpd *)(skb->data); rx_pkt_hdr = (void *)uap_rx_pd + le16_to_cpu(uap_rx_pd->rx_pkt_offset); /* don't do packet forwarding in disconnected state */ if (!priv->media_connected) { dev_err(adapter->dev, "drop packet in disconnected state.\n"); dev_kfree_skb_any(skb); return 0; } memcpy(ra, rx_pkt_hdr->eth803_hdr.h_dest, ETH_ALEN); if (is_multicast_ether_addr(ra)) { skb_uap = skb_copy(skb, GFP_ATOMIC); mwifiex_uap_queue_bridged_pkt(priv, skb_uap); } else { if (mwifiex_get_sta_entry(priv, ra)) { /* Requeue Intra-BSS packet */ mwifiex_uap_queue_bridged_pkt(priv, skb); return 0; } } /* Forward unicat/Inter-BSS packets to kernel. */ return mwifiex_process_rx_packet(adapter, skb); }
static int mwifiex_ret_uap_sta_list(struct mwifiex_private *priv, struct host_cmd_ds_command *resp) { struct host_cmd_ds_sta_list *sta_list = &resp->params.sta_list; struct mwifiex_ie_types_sta_info *sta_info = (void *)&sta_list->tlv; int i; struct mwifiex_sta_node *sta_node; for (i = 0; i < (le16_to_cpu(sta_list->sta_count)); i++) { sta_node = mwifiex_get_sta_entry(priv, sta_info->mac); if (unlikely(!sta_node)) continue; sta_node->stats.rssi = sta_info->rssi; sta_info++; } return 0; }
static int mwifiex_parse_tdls_event(struct mwifiex_private *priv, struct sk_buff *event_skb) { int ret = 0; struct mwifiex_adapter *adapter = priv->adapter; struct mwifiex_sta_node *sta_ptr; struct mwifiex_tdls_generic_event *tdls_evt = (void *)event_skb->data + sizeof(adapter->event_cause); /* reserved 2 bytes are not mandatory in tdls event */ if (event_skb->len < (sizeof(struct mwifiex_tdls_generic_event) - sizeof(u16) - sizeof(adapter->event_cause))) { dev_err(adapter->dev, "Invalid event length!\n"); return -1; } sta_ptr = mwifiex_get_sta_entry(priv, tdls_evt->peer_mac); if (!sta_ptr) { dev_err(adapter->dev, "cannot get sta entry!\n"); return -1; } switch (le16_to_cpu(tdls_evt->type)) { case TDLS_EVENT_LINK_TEAR_DOWN: cfg80211_tdls_oper_request(priv->netdev, tdls_evt->peer_mac, NL80211_TDLS_TEARDOWN, le16_to_cpu(tdls_evt->u.reason_code), GFP_KERNEL); ret = mwifiex_tdls_oper(priv, tdls_evt->peer_mac, MWIFIEX_TDLS_DISABLE_LINK); queue_work(adapter->workqueue, &adapter->main_work); break; default: break; } return ret; }
static void mwifiex_process_sta_tx_pause(struct mwifiex_private *priv, struct mwifiex_ie_types_header *tlv) { struct mwifiex_tx_pause_tlv *tp; struct mwifiex_sta_node *sta_ptr; int status; unsigned long flags; tp = (void *)tlv; mwifiex_dbg(priv->adapter, EVENT, "sta tx_pause: %pM pause=%d, pkts=%d\n", tp->peermac, tp->tx_pause, tp->pkt_cnt); if (ether_addr_equal(tp->peermac, priv->cfg_bssid)) { if (tp->tx_pause) priv->port_open = false; else priv->port_open = true; } else { if (!ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info)) return; status = mwifiex_get_tdls_link_status(priv, tp->peermac); if (mwifiex_is_tdls_link_setup(status)) { spin_lock_irqsave(&priv->sta_list_spinlock, flags); sta_ptr = mwifiex_get_sta_entry(priv, tp->peermac); spin_unlock_irqrestore(&priv->sta_list_spinlock, flags); if (sta_ptr && sta_ptr->tx_pause != tp->tx_pause) { sta_ptr->tx_pause = tp->tx_pause; mwifiex_update_ralist_tx_pause(priv, tp->peermac, tp->tx_pause); } } } }
/* * This function handles events generated by firmware. * * This is a generic function and handles all events. * * Event specific routines are called by this function based * upon the generated event cause. * * For the following events, the function just forwards them to upper * layers, optionally recording the change - * - EVENT_LINK_SENSED * - EVENT_MIC_ERR_UNICAST * - EVENT_MIC_ERR_MULTICAST * - EVENT_PORT_RELEASE * - EVENT_RSSI_LOW * - EVENT_SNR_LOW * - EVENT_MAX_FAIL * - EVENT_RSSI_HIGH * - EVENT_SNR_HIGH * - EVENT_DATA_RSSI_LOW * - EVENT_DATA_SNR_LOW * - EVENT_DATA_RSSI_HIGH * - EVENT_DATA_SNR_HIGH * - EVENT_LINK_QUALITY * - EVENT_PRE_BEACON_LOST * - EVENT_IBSS_COALESCED * - EVENT_IBSS_STA_CONNECT * - EVENT_IBSS_STA_DISCONNECT * - EVENT_WEP_ICV_ERR * - EVENT_BW_CHANGE * - EVENT_HOSTWAKE_STAIE * * For the following events, no action is taken - * - EVENT_MIB_CHANGED * - EVENT_INIT_DONE * - EVENT_DUMMY_HOST_WAKEUP_SIGNAL * * Rest of the supported events requires driver handling - * - EVENT_DEAUTHENTICATED * - EVENT_DISASSOCIATED * - EVENT_LINK_LOST * - EVENT_PS_SLEEP * - EVENT_PS_AWAKE * - EVENT_DEEP_SLEEP_AWAKE * - EVENT_HS_ACT_REQ * - EVENT_ADHOC_BCN_LOST * - EVENT_BG_SCAN_REPORT * - EVENT_WMM_STATUS_CHANGE * - EVENT_ADDBA * - EVENT_DELBA * - EVENT_BA_STREAM_TIEMOUT * - EVENT_AMSDU_AGGR_CTRL * - EVENT_FW_DUMP_INFO */ int mwifiex_process_sta_event(struct mwifiex_private *priv) { struct mwifiex_adapter *adapter = priv->adapter; int ret = 0, i; u32 eventcause = adapter->event_cause; u16 ctrl, reason_code; u8 ibss_sta_addr[ETH_ALEN]; struct mwifiex_sta_node *sta_ptr; switch (eventcause) { case EVENT_DUMMY_HOST_WAKEUP_SIGNAL: mwifiex_dbg(adapter, ERROR, "invalid EVENT: DUMMY_HOST_WAKEUP_SIGNAL, ignore it\n"); break; case EVENT_LINK_SENSED: mwifiex_dbg(adapter, EVENT, "event: LINK_SENSED\n"); if (!netif_carrier_ok(priv->netdev)) netif_carrier_on(priv->netdev); mwifiex_wake_up_net_dev_queue(priv->netdev, adapter); break; case EVENT_DEAUTHENTICATED: mwifiex_dbg(adapter, EVENT, "event: Deauthenticated\n"); if (priv->wps.session_enable) { mwifiex_dbg(adapter, INFO, "info: receive deauth event in wps session\n"); break; } adapter->dbg.num_event_deauth++; if (priv->media_connected) { reason_code = get_unaligned_le16(adapter->event_body); mwifiex_reset_connect_state(priv, reason_code, true); } break; case EVENT_DISASSOCIATED: mwifiex_dbg(adapter, EVENT, "event: Disassociated\n"); if (priv->wps.session_enable) { mwifiex_dbg(adapter, INFO, "info: receive disassoc event in wps session\n"); break; } adapter->dbg.num_event_disassoc++; if (priv->media_connected) { reason_code = get_unaligned_le16(adapter->event_body); mwifiex_reset_connect_state(priv, reason_code, true); } break; case EVENT_LINK_LOST: mwifiex_dbg(adapter, EVENT, "event: Link lost\n"); adapter->dbg.num_event_link_lost++; if (priv->media_connected) { reason_code = get_unaligned_le16(adapter->event_body); mwifiex_reset_connect_state(priv, reason_code, true); } break; case EVENT_PS_SLEEP: mwifiex_dbg(adapter, EVENT, "info: EVENT: SLEEP\n"); adapter->ps_state = PS_STATE_PRE_SLEEP; mwifiex_check_ps_cond(adapter); break; case EVENT_PS_AWAKE: mwifiex_dbg(adapter, EVENT, "info: EVENT: AWAKE\n"); if (!adapter->pps_uapsd_mode && (priv->port_open || (priv->bss_mode == NL80211_IFTYPE_ADHOC)) && priv->media_connected && adapter->sleep_period.period) { adapter->pps_uapsd_mode = true; mwifiex_dbg(adapter, EVENT, "event: PPS/UAPSD mode activated\n"); } adapter->tx_lock_flag = false; if (adapter->pps_uapsd_mode && adapter->gen_null_pkt) { if (mwifiex_check_last_packet_indication(priv)) { if (adapter->data_sent || (adapter->if_ops.is_port_ready && !adapter->if_ops.is_port_ready(priv))) { adapter->ps_state = PS_STATE_AWAKE; adapter->pm_wakeup_card_req = false; adapter->pm_wakeup_fw_try = false; del_timer(&adapter->wakeup_timer); break; } if (!mwifiex_send_null_packet (priv, MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET | MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET)) adapter->ps_state = PS_STATE_SLEEP; return 0; } } adapter->ps_state = PS_STATE_AWAKE; adapter->pm_wakeup_card_req = false; adapter->pm_wakeup_fw_try = false; del_timer(&adapter->wakeup_timer); break; case EVENT_DEEP_SLEEP_AWAKE: adapter->if_ops.wakeup_complete(adapter); mwifiex_dbg(adapter, EVENT, "event: DS_AWAKE\n"); if (adapter->is_deep_sleep) adapter->is_deep_sleep = false; break; case EVENT_HS_ACT_REQ: mwifiex_dbg(adapter, EVENT, "event: HS_ACT_REQ\n"); ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_HS_CFG_ENH, 0, 0, NULL, false); break; case EVENT_MIC_ERR_UNICAST: mwifiex_dbg(adapter, EVENT, "event: UNICAST MIC ERROR\n"); cfg80211_michael_mic_failure(priv->netdev, priv->cfg_bssid, NL80211_KEYTYPE_PAIRWISE, -1, NULL, GFP_KERNEL); break; case EVENT_MIC_ERR_MULTICAST: mwifiex_dbg(adapter, EVENT, "event: MULTICAST MIC ERROR\n"); cfg80211_michael_mic_failure(priv->netdev, priv->cfg_bssid, NL80211_KEYTYPE_GROUP, -1, NULL, GFP_KERNEL); break; case EVENT_MIB_CHANGED: case EVENT_INIT_DONE: break; case EVENT_ADHOC_BCN_LOST: mwifiex_dbg(adapter, EVENT, "event: ADHOC_BCN_LOST\n"); priv->adhoc_is_link_sensed = false; mwifiex_clean_txrx(priv); mwifiex_stop_net_dev_queue(priv->netdev, adapter); if (netif_carrier_ok(priv->netdev)) netif_carrier_off(priv->netdev); break; case EVENT_BG_SCAN_REPORT: mwifiex_dbg(adapter, EVENT, "event: BGS_REPORT\n"); ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_BG_SCAN_QUERY, HostCmd_ACT_GEN_GET, 0, NULL, false); break; case EVENT_BG_SCAN_STOPPED: dev_dbg(adapter->dev, "event: BGS_STOPPED\n"); cfg80211_sched_scan_stopped(priv->wdev.wiphy, 0); if (priv->sched_scanning) priv->sched_scanning = false; break; case EVENT_PORT_RELEASE: mwifiex_dbg(adapter, EVENT, "event: PORT RELEASE\n"); priv->port_open = true; break; case EVENT_EXT_SCAN_REPORT: mwifiex_dbg(adapter, EVENT, "event: EXT_SCAN Report\n"); /* We intend to skip this event during suspend, but handle * it in interface disabled case */ if (adapter->ext_scan && (!priv->scan_aborting || !netif_running(priv->netdev))) ret = mwifiex_handle_event_ext_scan_report(priv, adapter->event_skb->data); break; case EVENT_WMM_STATUS_CHANGE: mwifiex_dbg(adapter, EVENT, "event: WMM status changed\n"); ret = mwifiex_send_cmd(priv, HostCmd_CMD_WMM_GET_STATUS, 0, 0, NULL, false); break; case EVENT_RSSI_LOW: cfg80211_cqm_rssi_notify(priv->netdev, NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW, 0, GFP_KERNEL); mwifiex_send_cmd(priv, HostCmd_CMD_RSSI_INFO, HostCmd_ACT_GEN_GET, 0, NULL, false); priv->subsc_evt_rssi_state = RSSI_LOW_RECVD; mwifiex_dbg(adapter, EVENT, "event: Beacon RSSI_LOW\n"); break; case EVENT_SNR_LOW: mwifiex_dbg(adapter, EVENT, "event: Beacon SNR_LOW\n"); break; case EVENT_MAX_FAIL: mwifiex_dbg(adapter, EVENT, "event: MAX_FAIL\n"); break; case EVENT_RSSI_HIGH: cfg80211_cqm_rssi_notify(priv->netdev, NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH, 0, GFP_KERNEL); mwifiex_send_cmd(priv, HostCmd_CMD_RSSI_INFO, HostCmd_ACT_GEN_GET, 0, NULL, false); priv->subsc_evt_rssi_state = RSSI_HIGH_RECVD; mwifiex_dbg(adapter, EVENT, "event: Beacon RSSI_HIGH\n"); break; case EVENT_SNR_HIGH: mwifiex_dbg(adapter, EVENT, "event: Beacon SNR_HIGH\n"); break; case EVENT_DATA_RSSI_LOW: mwifiex_dbg(adapter, EVENT, "event: Data RSSI_LOW\n"); break; case EVENT_DATA_SNR_LOW: mwifiex_dbg(adapter, EVENT, "event: Data SNR_LOW\n"); break; case EVENT_DATA_RSSI_HIGH: mwifiex_dbg(adapter, EVENT, "event: Data RSSI_HIGH\n"); break; case EVENT_DATA_SNR_HIGH: mwifiex_dbg(adapter, EVENT, "event: Data SNR_HIGH\n"); break; case EVENT_LINK_QUALITY: mwifiex_dbg(adapter, EVENT, "event: Link Quality\n"); break; case EVENT_PRE_BEACON_LOST: mwifiex_dbg(adapter, EVENT, "event: Pre-Beacon Lost\n"); break; case EVENT_IBSS_COALESCED: mwifiex_dbg(adapter, EVENT, "event: IBSS_COALESCED\n"); ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_IBSS_COALESCING_STATUS, HostCmd_ACT_GEN_GET, 0, NULL, false); break; case EVENT_IBSS_STA_CONNECT: ether_addr_copy(ibss_sta_addr, adapter->event_body + 2); mwifiex_dbg(adapter, EVENT, "event: IBSS_STA_CONNECT %pM\n", ibss_sta_addr); sta_ptr = mwifiex_add_sta_entry(priv, ibss_sta_addr); if (sta_ptr && adapter->adhoc_11n_enabled) { mwifiex_check_ibss_peer_capabilties(priv, sta_ptr, adapter->event_skb); if (sta_ptr->is_11n_enabled) for (i = 0; i < MAX_NUM_TID; i++) sta_ptr->ampdu_sta[i] = priv->aggr_prio_tbl[i].ampdu_user; else for (i = 0; i < MAX_NUM_TID; i++) sta_ptr->ampdu_sta[i] = BA_STREAM_NOT_ALLOWED; memset(sta_ptr->rx_seq, 0xff, sizeof(sta_ptr->rx_seq)); } break; case EVENT_IBSS_STA_DISCONNECT: ether_addr_copy(ibss_sta_addr, adapter->event_body + 2); mwifiex_dbg(adapter, EVENT, "event: IBSS_STA_DISCONNECT %pM\n", ibss_sta_addr); sta_ptr = mwifiex_get_sta_entry(priv, ibss_sta_addr); if (sta_ptr && sta_ptr->is_11n_enabled) { mwifiex_11n_del_rx_reorder_tbl_by_ta(priv, ibss_sta_addr); mwifiex_del_tx_ba_stream_tbl_by_ra(priv, ibss_sta_addr); } mwifiex_wmm_del_peer_ra_list(priv, ibss_sta_addr); mwifiex_del_sta_entry(priv, ibss_sta_addr); break; case EVENT_ADDBA: mwifiex_dbg(adapter, EVENT, "event: ADDBA Request\n"); mwifiex_send_cmd(priv, HostCmd_CMD_11N_ADDBA_RSP, HostCmd_ACT_GEN_SET, 0, adapter->event_body, false); break; case EVENT_DELBA: mwifiex_dbg(adapter, EVENT, "event: DELBA Request\n"); mwifiex_11n_delete_ba_stream(priv, adapter->event_body); break; case EVENT_BA_STREAM_TIEMOUT: mwifiex_dbg(adapter, EVENT, "event: BA Stream timeout\n"); mwifiex_11n_ba_stream_timeout(priv, (struct host_cmd_ds_11n_batimeout *) adapter->event_body); break; case EVENT_AMSDU_AGGR_CTRL: ctrl = get_unaligned_le16(adapter->event_body); mwifiex_dbg(adapter, EVENT, "event: AMSDU_AGGR_CTRL %d\n", ctrl); adapter->tx_buf_size = min_t(u16, adapter->curr_tx_buf_size, ctrl); mwifiex_dbg(adapter, EVENT, "event: tx_buf_size %d\n", adapter->tx_buf_size); break; case EVENT_WEP_ICV_ERR: mwifiex_dbg(adapter, EVENT, "event: WEP ICV error\n"); break; case EVENT_BW_CHANGE: mwifiex_dbg(adapter, EVENT, "event: BW Change\n"); break; case EVENT_HOSTWAKE_STAIE: mwifiex_dbg(adapter, EVENT, "event: HOSTWAKE_STAIE %d\n", eventcause); break; case EVENT_REMAIN_ON_CHAN_EXPIRED: mwifiex_dbg(adapter, EVENT, "event: Remain on channel expired\n"); cfg80211_remain_on_channel_expired(&priv->wdev, priv->roc_cfg.cookie, &priv->roc_cfg.chan, GFP_ATOMIC); memset(&priv->roc_cfg, 0x00, sizeof(struct mwifiex_roc_cfg)); break; case EVENT_CHANNEL_SWITCH_ANN: mwifiex_dbg(adapter, EVENT, "event: Channel Switch Announcement\n"); priv->csa_expire_time = jiffies + msecs_to_jiffies(DFS_CHAN_MOVE_TIME); priv->csa_chan = priv->curr_bss_params.bss_descriptor.channel; ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_DEAUTHENTICATE, HostCmd_ACT_GEN_SET, 0, priv->curr_bss_params.bss_descriptor.mac_address, false); break; case EVENT_TDLS_GENERIC_EVENT: ret = mwifiex_parse_tdls_event(priv, adapter->event_skb); break; case EVENT_TX_DATA_PAUSE: mwifiex_dbg(adapter, EVENT, "event: TX DATA PAUSE\n"); mwifiex_process_tx_pause_event(priv, adapter->event_skb); break; case EVENT_MULTI_CHAN_INFO: mwifiex_dbg(adapter, EVENT, "event: multi-chan info\n"); mwifiex_process_multi_chan_event(priv, adapter->event_skb); break; case EVENT_TX_STATUS_REPORT: mwifiex_dbg(adapter, EVENT, "event: TX_STATUS Report\n"); mwifiex_parse_tx_status_event(priv, adapter->event_body); break; case EVENT_CHANNEL_REPORT_RDY: mwifiex_dbg(adapter, EVENT, "event: Channel Report\n"); ret = mwifiex_11h_handle_chanrpt_ready(priv, adapter->event_skb); break; case EVENT_RADAR_DETECTED: mwifiex_dbg(adapter, EVENT, "event: Radar detected\n"); ret = mwifiex_11h_handle_radar_detected(priv, adapter->event_skb); break; case EVENT_BT_COEX_WLAN_PARA_CHANGE: dev_dbg(adapter->dev, "EVENT: BT coex wlan param update\n"); mwifiex_bt_coex_wlan_param_update_event(priv, adapter->event_skb); break; case EVENT_RXBA_SYNC: dev_dbg(adapter->dev, "EVENT: RXBA_SYNC\n"); mwifiex_11n_rxba_sync_event(priv, adapter->event_body, adapter->event_skb->len - sizeof(eventcause)); break; case EVENT_FW_DUMP_INFO: mwifiex_dbg(adapter, EVENT, "event: firmware debug info\n"); mwifiex_fw_dump_info_event(priv, adapter->event_skb); break; /* Debugging event; not used, but let's not print an ERROR for it. */ case EVENT_UNKNOWN_DEBUG: mwifiex_dbg(adapter, EVENT, "event: debug\n"); break; default: mwifiex_dbg(adapter, ERROR, "event: unknown event id: %#x\n", eventcause); break; } return ret; }
static int mwifiex_parse_tdls_event(struct mwifiex_private *priv, struct sk_buff *event_skb) { int ret = 0; struct mwifiex_adapter *adapter = priv->adapter; struct mwifiex_sta_node *sta_ptr; struct mwifiex_tdls_generic_event *tdls_evt = (void *)event_skb->data + sizeof(adapter->event_cause); u8 *mac = tdls_evt->peer_mac; /* reserved 2 bytes are not mandatory in tdls event */ if (event_skb->len < (sizeof(struct mwifiex_tdls_generic_event) - sizeof(u16) - sizeof(adapter->event_cause))) { mwifiex_dbg(adapter, ERROR, "Invalid event length!\n"); return -1; } sta_ptr = mwifiex_get_sta_entry(priv, tdls_evt->peer_mac); if (!sta_ptr) { mwifiex_dbg(adapter, ERROR, "cannot get sta entry!\n"); return -1; } switch (le16_to_cpu(tdls_evt->type)) { case TDLS_EVENT_LINK_TEAR_DOWN: cfg80211_tdls_oper_request(priv->netdev, tdls_evt->peer_mac, NL80211_TDLS_TEARDOWN, le16_to_cpu(tdls_evt->u.reason_code), GFP_KERNEL); break; case TDLS_EVENT_CHAN_SWITCH_RESULT: mwifiex_dbg(adapter, EVENT, "tdls channel switch result :\n"); mwifiex_dbg(adapter, EVENT, "status=0x%x, reason=0x%x cur_chan=%d\n", tdls_evt->u.switch_result.status, tdls_evt->u.switch_result.reason, tdls_evt->u.switch_result.cur_chan); /* tdls channel switch failed */ if (tdls_evt->u.switch_result.status != 0) { switch (tdls_evt->u.switch_result.cur_chan) { case TDLS_BASE_CHANNEL: sta_ptr->tdls_status = TDLS_IN_BASE_CHAN; break; case TDLS_OFF_CHANNEL: sta_ptr->tdls_status = TDLS_IN_OFF_CHAN; break; default: break; } return ret; } /* tdls channel switch success */ switch (tdls_evt->u.switch_result.cur_chan) { case TDLS_BASE_CHANNEL: if (sta_ptr->tdls_status == TDLS_IN_BASE_CHAN) break; mwifiex_update_ralist_tx_pause_in_tdls_cs(priv, mac, false); sta_ptr->tdls_status = TDLS_IN_BASE_CHAN; break; case TDLS_OFF_CHANNEL: if (sta_ptr->tdls_status == TDLS_IN_OFF_CHAN) break; mwifiex_update_ralist_tx_pause_in_tdls_cs(priv, mac, true); sta_ptr->tdls_status = TDLS_IN_OFF_CHAN; break; default: break; } break; case TDLS_EVENT_START_CHAN_SWITCH: mwifiex_dbg(adapter, EVENT, "tdls start channel switch...\n"); sta_ptr->tdls_status = TDLS_CHAN_SWITCHING; break; case TDLS_EVENT_CHAN_SWITCH_STOPPED: mwifiex_dbg(adapter, EVENT, "tdls chan switch stopped, reason=%d\n", tdls_evt->u.cs_stop_reason); break; default: break; } return ret; }
/* * This function processes the received buffer. * * The function looks into the RxPD and performs sanity tests on the * received buffer to ensure its a valid packet, before processing it * further. If the packet is determined to be aggregated, it is * de-aggregated accordingly. Non-unicast packets are sent directly to * the kernel/upper layers. Unicast packets are handed over to the * Rx reordering routine if 11n is enabled. * * The completion callback is called after processing in complete. */ int mwifiex_process_sta_rx_packet(struct mwifiex_private *priv, struct sk_buff *skb) { struct mwifiex_adapter *adapter = priv->adapter; int ret = 0; struct rxpd *local_rx_pd; struct rx_packet_hdr *rx_pkt_hdr; u8 ta[ETH_ALEN]; u16 rx_pkt_type, rx_pkt_offset, rx_pkt_length, seq_num; struct mwifiex_sta_node *sta_ptr; local_rx_pd = (struct rxpd *) (skb->data); rx_pkt_type = le16_to_cpu(local_rx_pd->rx_pkt_type); rx_pkt_offset = le16_to_cpu(local_rx_pd->rx_pkt_offset); rx_pkt_length = le16_to_cpu(local_rx_pd->rx_pkt_length); seq_num = le16_to_cpu(local_rx_pd->seq_num); rx_pkt_hdr = (void *)local_rx_pd + rx_pkt_offset; if ((rx_pkt_offset + rx_pkt_length) > (u16) skb->len) { dev_err(adapter->dev, "wrong rx packet: len=%d, rx_pkt_offset=%d, rx_pkt_length=%d\n", skb->len, rx_pkt_offset, rx_pkt_length); priv->stats.rx_dropped++; dev_kfree_skb_any(skb); return ret; } if (rx_pkt_type == PKT_TYPE_MGMT) { ret = mwifiex_process_mgmt_packet(priv, skb); if (ret) dev_err(adapter->dev, "Rx of mgmt packet failed"); dev_kfree_skb_any(skb); return ret; } /* * 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) && !(ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) && !(local_rx_pd->flags & MWIFIEX_RXPD_FLAGS_TDLS_PACKET))) || !ether_addr_equal_unaligned(priv->curr_addr, rx_pkt_hdr->eth803_hdr.h_dest)) { mwifiex_process_rx_packet(priv, skb); return ret; } if (mwifiex_queuing_ra_based(priv) || (ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) && local_rx_pd->flags & MWIFIEX_RXPD_FLAGS_TDLS_PACKET)) { memcpy(ta, rx_pkt_hdr->eth803_hdr.h_source, ETH_ALEN); if (local_rx_pd->flags & MWIFIEX_RXPD_FLAGS_TDLS_PACKET && local_rx_pd->priority < MAX_NUM_TID) { sta_ptr = mwifiex_get_sta_entry(priv, ta); if (sta_ptr) sta_ptr->rx_seq[local_rx_pd->priority] = le16_to_cpu(local_rx_pd->seq_num); } } else { if (rx_pkt_type != PKT_TYPE_BAR) priv->rx_seq[local_rx_pd->priority] = seq_num; memcpy(ta, priv->curr_bss_params.bss_descriptor.mac_address, ETH_ALEN); } /* Reorder and send to OS */ ret = mwifiex_11n_rx_reorder_pkt(priv, seq_num, local_rx_pd->priority, ta, (u8) rx_pkt_type, skb); if (ret || (rx_pkt_type == PKT_TYPE_BAR)) dev_kfree_skb_any(skb); if (ret) priv->stats.rx_dropped++; return ret; }
/* * This function processes the packet received on AP interface. * * The function looks into the RxPD and performs sanity tests on the * received buffer to ensure its a valid packet before processing it * further. If the packet is determined to be aggregated, it is * de-aggregated accordingly. Then skb is passed to AP packet forwarding logic. * * The completion callback is called after processing is complete. */ int mwifiex_process_uap_rx_packet(struct mwifiex_adapter *adapter, struct sk_buff *skb) { int ret; struct uap_rxpd *uap_rx_pd; struct mwifiex_rxinfo *rx_info = MWIFIEX_SKB_RXCB(skb); struct rx_packet_hdr *rx_pkt_hdr; u16 rx_pkt_type; u8 ta[ETH_ALEN], pkt_type; struct mwifiex_sta_node *node; struct mwifiex_private *priv = mwifiex_get_priv_by_id(adapter, rx_info->bss_num, rx_info->bss_type); if (!priv) return -1; uap_rx_pd = (struct uap_rxpd *)(skb->data); rx_pkt_type = le16_to_cpu(uap_rx_pd->rx_pkt_type); rx_pkt_hdr = (void *)uap_rx_pd + le16_to_cpu(uap_rx_pd->rx_pkt_offset); if ((le16_to_cpu(uap_rx_pd->rx_pkt_offset) + le16_to_cpu(uap_rx_pd->rx_pkt_length)) > (u16) skb->len) { dev_err(adapter->dev, "wrong rx packet: len=%d, offset=%d, length=%d\n", skb->len, le16_to_cpu(uap_rx_pd->rx_pkt_offset), le16_to_cpu(uap_rx_pd->rx_pkt_length)); priv->stats.rx_dropped++; if (adapter->if_ops.data_complete) adapter->if_ops.data_complete(adapter, skb); else dev_kfree_skb_any(skb); return 0; } if (le16_to_cpu(uap_rx_pd->rx_pkt_type) == PKT_TYPE_AMSDU) { struct sk_buff_head list; struct sk_buff *rx_skb; __skb_queue_head_init(&list); skb_pull(skb, le16_to_cpu(uap_rx_pd->rx_pkt_offset)); skb_trim(skb, le16_to_cpu(uap_rx_pd->rx_pkt_length)); ieee80211_amsdu_to_8023s(skb, &list, priv->curr_addr, priv->wdev->iftype, 0, false); while (!skb_queue_empty(&list)) { rx_skb = __skb_dequeue(&list); ret = mwifiex_recv_packet(adapter, rx_skb); if (ret) dev_err(adapter->dev, "AP:Rx A-MSDU failed"); } return 0; } memcpy(ta, rx_pkt_hdr->eth803_hdr.h_source, ETH_ALEN); if (rx_pkt_type != PKT_TYPE_BAR && uap_rx_pd->priority < MAX_NUM_TID) { node = mwifiex_get_sta_entry(priv, ta); if (node) node->rx_seq[uap_rx_pd->priority] = le16_to_cpu(uap_rx_pd->seq_num); } if (!priv->ap_11n_enabled || (!mwifiex_11n_get_rx_reorder_tbl(priv, uap_rx_pd->priority, ta) && (le16_to_cpu(uap_rx_pd->rx_pkt_type) != PKT_TYPE_AMSDU))) { ret = mwifiex_handle_uap_rx_forward(priv, skb); return ret; } /* Reorder and send to kernel */ pkt_type = (u8)le16_to_cpu(uap_rx_pd->rx_pkt_type); ret = mwifiex_11n_rx_reorder_pkt(priv, le16_to_cpu(uap_rx_pd->seq_num), uap_rx_pd->priority, ta, pkt_type, skb); if (ret || (rx_pkt_type == PKT_TYPE_BAR)) { if (adapter->if_ops.data_complete) adapter->if_ops.data_complete(adapter, skb); else dev_kfree_skb_any(skb); } if (ret) priv->stats.rx_dropped++; return ret; }