| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries. |
| * All rights reserved. |
| */ |
| |
| #include "wilc_wfi_netdevice.h" |
| |
| #define WILC_HIF_SCAN_TIMEOUT_MS 4000 |
| #define WILC_HIF_CONNECT_TIMEOUT_MS 9500 |
| |
| #define WILC_FALSE_FRMWR_CHANNEL 100 |
| #define WILC_MAX_RATES_SUPPORTED 12 |
| |
| struct wilc_rcvd_mac_info { |
| u8 status; |
| }; |
| |
| struct wilc_set_multicast { |
| u32 enabled; |
| u32 cnt; |
| u8 *mc_list; |
| }; |
| |
| struct wilc_del_all_sta { |
| u8 assoc_sta; |
| u8 mac[WILC_MAX_NUM_STA][ETH_ALEN]; |
| }; |
| |
| struct wilc_op_mode { |
| __le32 mode; |
| }; |
| |
| struct wilc_reg_frame { |
| bool reg; |
| u8 reg_id; |
| __le16 frame_type; |
| } __packed; |
| |
| struct wilc_drv_handler { |
| __le32 handler; |
| u8 mode; |
| } __packed; |
| |
| struct wilc_wep_key { |
| u8 index; |
| u8 key_len; |
| u8 key[0]; |
| } __packed; |
| |
| struct wilc_sta_wpa_ptk { |
| u8 mac_addr[ETH_ALEN]; |
| u8 key_len; |
| u8 key[0]; |
| } __packed; |
| |
| struct wilc_ap_wpa_ptk { |
| u8 mac_addr[ETH_ALEN]; |
| u8 index; |
| u8 key_len; |
| u8 key[0]; |
| } __packed; |
| |
| struct wilc_gtk_key { |
| u8 mac_addr[ETH_ALEN]; |
| u8 rsc[8]; |
| u8 index; |
| u8 key_len; |
| u8 key[0]; |
| } __packed; |
| |
| union wilc_message_body { |
| struct wilc_rcvd_net_info net_info; |
| struct wilc_rcvd_mac_info mac_info; |
| struct wilc_set_multicast mc_info; |
| struct wilc_remain_ch remain_on_ch; |
| char *data; |
| }; |
| |
| struct host_if_msg { |
| union wilc_message_body body; |
| struct wilc_vif *vif; |
| struct work_struct work; |
| void (*fn)(struct work_struct *ws); |
| struct completion work_comp; |
| bool is_sync; |
| }; |
| |
| struct wilc_noa_opp_enable { |
| u8 ct_window; |
| u8 cnt; |
| __le32 duration; |
| __le32 interval; |
| __le32 start_time; |
| } __packed; |
| |
| struct wilc_noa_opp_disable { |
| u8 cnt; |
| __le32 duration; |
| __le32 interval; |
| __le32 start_time; |
| } __packed; |
| |
| struct wilc_join_bss_param { |
| char ssid[IEEE80211_MAX_SSID_LEN]; |
| u8 ssid_terminator; |
| u8 bss_type; |
| u8 ch; |
| __le16 cap_info; |
| u8 sa[ETH_ALEN]; |
| u8 bssid[ETH_ALEN]; |
| __le16 beacon_period; |
| u8 dtim_period; |
| u8 supp_rates[WILC_MAX_RATES_SUPPORTED + 1]; |
| u8 wmm_cap; |
| u8 uapsd_cap; |
| u8 ht_capable; |
| u8 rsn_found; |
| u8 rsn_grp_policy; |
| u8 mode_802_11i; |
| u8 p_suites[3]; |
| u8 akm_suites[3]; |
| u8 rsn_cap[2]; |
| u8 noa_enabled; |
| __le32 tsf_lo; |
| u8 idx; |
| u8 opp_enabled; |
| union { |
| struct wilc_noa_opp_disable opp_dis; |
| struct wilc_noa_opp_enable opp_en; |
| }; |
| } __packed; |
| |
| /* 'msg' should be free by the caller for syc */ |
| static struct host_if_msg* |
| wilc_alloc_work(struct wilc_vif *vif, void (*work_fun)(struct work_struct *), |
| bool is_sync) |
| { |
| struct host_if_msg *msg; |
| |
| if (!work_fun) |
| return ERR_PTR(-EINVAL); |
| |
| msg = kzalloc(sizeof(*msg), GFP_ATOMIC); |
| if (!msg) |
| return ERR_PTR(-ENOMEM); |
| msg->fn = work_fun; |
| msg->vif = vif; |
| msg->is_sync = is_sync; |
| if (is_sync) |
| init_completion(&msg->work_comp); |
| |
| return msg; |
| } |
| |
| static int wilc_enqueue_work(struct host_if_msg *msg) |
| { |
| INIT_WORK(&msg->work, msg->fn); |
| |
| if (!msg->vif || !msg->vif->wilc || !msg->vif->wilc->hif_workqueue) |
| return -EINVAL; |
| |
| if (!queue_work(msg->vif->wilc->hif_workqueue, &msg->work)) |
| return -EINVAL; |
| |
| return 0; |
| } |
| |
| /* The idx starts from 0 to (NUM_CONCURRENT_IFC - 1), but 0 index used as |
| * special purpose in wilc device, so we add 1 to the index to starts from 1. |
| * As a result, the returned index will be 1 to NUM_CONCURRENT_IFC. |
| */ |
| int wilc_get_vif_idx(struct wilc_vif *vif) |
| { |
| return vif->idx + 1; |
| } |
| |
| /* We need to minus 1 from idx which is from wilc device to get real index |
| * of wilc->vif[], because we add 1 when pass to wilc device in the function |
| * wilc_get_vif_idx. |
| * As a result, the index should be between 0 and (NUM_CONCURRENT_IFC - 1). |
| */ |
| static struct wilc_vif *wilc_get_vif_from_idx(struct wilc *wilc, int idx) |
| { |
| int index = idx - 1; |
| |
| if (index < 0 || index >= WILC_NUM_CONCURRENT_IFC) |
| return NULL; |
| |
| return wilc->vif[index]; |
| } |
| |
| static int handle_scan_done(struct wilc_vif *vif, enum scan_event evt) |
| { |
| int result = 0; |
| u8 abort_running_scan; |
| struct wid wid; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| struct wilc_user_scan_req *scan_req; |
| |
| if (evt == SCAN_EVENT_ABORTED) { |
| abort_running_scan = 1; |
| wid.id = WID_ABORT_RUNNING_SCAN; |
| wid.type = WID_CHAR; |
| wid.val = (s8 *)&abort_running_scan; |
| wid.size = sizeof(char); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| |
| if (result) { |
| netdev_err(vif->ndev, "Failed to set abort running\n"); |
| result = -EFAULT; |
| } |
| } |
| |
| if (!hif_drv) { |
| netdev_err(vif->ndev, "%s: hif driver is NULL\n", __func__); |
| return result; |
| } |
| |
| scan_req = &hif_drv->usr_scan_req; |
| if (scan_req->scan_result) { |
| scan_req->scan_result(evt, NULL, scan_req->arg); |
| scan_req->scan_result = NULL; |
| } |
| |
| return result; |
| } |
| |
| int wilc_scan(struct wilc_vif *vif, u8 scan_source, u8 scan_type, |
| u8 *ch_freq_list, u8 ch_list_len, const u8 *ies, size_t ies_len, |
| void (*scan_result_fn)(enum scan_event, |
| struct wilc_rcvd_net_info *, void *), |
| void *user_arg, struct wilc_probe_ssid *search) |
| { |
| int result = 0; |
| struct wid wid_list[5]; |
| u32 index = 0; |
| u32 i; |
| u8 *buffer; |
| u8 valuesize = 0; |
| u8 *search_ssid_vals = NULL; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| |
| if (hif_drv->hif_state >= HOST_IF_SCANNING && |
| hif_drv->hif_state < HOST_IF_CONNECTED) { |
| netdev_err(vif->ndev, "Already scan\n"); |
| result = -EBUSY; |
| goto error; |
| } |
| |
| if (vif->obtaining_ip || vif->connecting) { |
| netdev_err(vif->ndev, "Don't do obss scan\n"); |
| result = -EBUSY; |
| goto error; |
| } |
| |
| hif_drv->usr_scan_req.ch_cnt = 0; |
| |
| if (search) { |
| for (i = 0; i < search->n_ssids; i++) |
| valuesize += ((search->ssid_info[i].ssid_len) + 1); |
| search_ssid_vals = kmalloc(valuesize + 1, GFP_KERNEL); |
| if (search_ssid_vals) { |
| wid_list[index].id = WID_SSID_PROBE_REQ; |
| wid_list[index].type = WID_STR; |
| wid_list[index].val = search_ssid_vals; |
| buffer = wid_list[index].val; |
| |
| *buffer++ = search->n_ssids; |
| |
| for (i = 0; i < search->n_ssids; i++) { |
| *buffer++ = search->ssid_info[i].ssid_len; |
| memcpy(buffer, search->ssid_info[i].ssid, |
| search->ssid_info[i].ssid_len); |
| buffer += search->ssid_info[i].ssid_len; |
| } |
| wid_list[index].size = (s32)(valuesize + 1); |
| index++; |
| } |
| } |
| |
| wid_list[index].id = WID_INFO_ELEMENT_PROBE; |
| wid_list[index].type = WID_BIN_DATA; |
| wid_list[index].val = (s8 *)ies; |
| wid_list[index].size = ies_len; |
| index++; |
| |
| wid_list[index].id = WID_SCAN_TYPE; |
| wid_list[index].type = WID_CHAR; |
| wid_list[index].size = sizeof(char); |
| wid_list[index].val = (s8 *)&scan_type; |
| index++; |
| |
| wid_list[index].id = WID_SCAN_CHANNEL_LIST; |
| wid_list[index].type = WID_BIN_DATA; |
| |
| if (ch_freq_list && ch_list_len > 0) { |
| for (i = 0; i < ch_list_len; i++) { |
| if (ch_freq_list[i] > 0) |
| ch_freq_list[i] -= 1; |
| } |
| } |
| |
| wid_list[index].val = ch_freq_list; |
| wid_list[index].size = ch_list_len; |
| index++; |
| |
| wid_list[index].id = WID_START_SCAN_REQ; |
| wid_list[index].type = WID_CHAR; |
| wid_list[index].size = sizeof(char); |
| wid_list[index].val = (s8 *)&scan_source; |
| index++; |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list, |
| index, |
| wilc_get_vif_idx(vif)); |
| if (result) { |
| netdev_err(vif->ndev, "Failed to send scan parameters\n"); |
| goto error; |
| } |
| |
| hif_drv->usr_scan_req.scan_result = scan_result_fn; |
| hif_drv->usr_scan_req.arg = user_arg; |
| hif_drv->scan_timer_vif = vif; |
| mod_timer(&hif_drv->scan_timer, |
| jiffies + msecs_to_jiffies(WILC_HIF_SCAN_TIMEOUT_MS)); |
| |
| error: |
| if (search) { |
| kfree(search->ssid_info); |
| kfree(search_ssid_vals); |
| } |
| |
| return result; |
| } |
| |
| static int wilc_send_connect_wid(struct wilc_vif *vif) |
| { |
| int result = 0; |
| struct wid wid_list[4]; |
| u32 wid_cnt = 0; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| struct wilc_conn_info *conn_attr = &hif_drv->conn_info; |
| struct wilc_join_bss_param *bss_param = conn_attr->param; |
| |
| wid_list[wid_cnt].id = WID_INFO_ELEMENT_ASSOCIATE; |
| wid_list[wid_cnt].type = WID_BIN_DATA; |
| wid_list[wid_cnt].val = conn_attr->req_ies; |
| wid_list[wid_cnt].size = conn_attr->req_ies_len; |
| wid_cnt++; |
| |
| wid_list[wid_cnt].id = WID_11I_MODE; |
| wid_list[wid_cnt].type = WID_CHAR; |
| wid_list[wid_cnt].size = sizeof(char); |
| wid_list[wid_cnt].val = (s8 *)&conn_attr->security; |
| wid_cnt++; |
| |
| wid_list[wid_cnt].id = WID_AUTH_TYPE; |
| wid_list[wid_cnt].type = WID_CHAR; |
| wid_list[wid_cnt].size = sizeof(char); |
| wid_list[wid_cnt].val = (s8 *)&conn_attr->auth_type; |
| wid_cnt++; |
| |
| wid_list[wid_cnt].id = WID_JOIN_REQ_EXTENDED; |
| wid_list[wid_cnt].type = WID_STR; |
| wid_list[wid_cnt].size = sizeof(*bss_param); |
| wid_list[wid_cnt].val = (u8 *)bss_param; |
| wid_cnt++; |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list, |
| wid_cnt, |
| wilc_get_vif_idx(vif)); |
| if (result) { |
| netdev_err(vif->ndev, "failed to send config packet\n"); |
| goto error; |
| } else { |
| hif_drv->hif_state = HOST_IF_WAITING_CONN_RESP; |
| } |
| |
| return 0; |
| |
| error: |
| |
| kfree(conn_attr->req_ies); |
| conn_attr->req_ies = NULL; |
| |
| return result; |
| } |
| |
| static void handle_connect_timeout(struct work_struct *work) |
| { |
| struct host_if_msg *msg = container_of(work, struct host_if_msg, work); |
| struct wilc_vif *vif = msg->vif; |
| int result; |
| struct wid wid; |
| u16 dummy_reason_code = 0; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| |
| if (!hif_drv) { |
| netdev_err(vif->ndev, "%s: hif driver is NULL\n", __func__); |
| goto out; |
| } |
| |
| hif_drv->hif_state = HOST_IF_IDLE; |
| |
| if (hif_drv->conn_info.conn_result) { |
| hif_drv->conn_info.conn_result(CONN_DISCONN_EVENT_CONN_RESP, |
| WILC_MAC_STATUS_DISCONNECTED, |
| hif_drv->conn_info.arg); |
| |
| } else { |
| netdev_err(vif->ndev, "%s: conn_result is NULL\n", __func__); |
| } |
| |
| wid.id = WID_DISCONNECT; |
| wid.type = WID_CHAR; |
| wid.val = (s8 *)&dummy_reason_code; |
| wid.size = sizeof(char); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to send disconnect\n"); |
| |
| hif_drv->conn_info.req_ies_len = 0; |
| kfree(hif_drv->conn_info.req_ies); |
| hif_drv->conn_info.req_ies = NULL; |
| |
| out: |
| kfree(msg); |
| } |
| |
| void *wilc_parse_join_bss_param(struct cfg80211_bss *bss, |
| struct cfg80211_crypto_settings *crypto) |
| { |
| struct wilc_join_bss_param *param; |
| struct ieee80211_p2p_noa_attr noa_attr; |
| u8 rates_len = 0; |
| const u8 *tim_elm, *ssid_elm, *rates_ie, *supp_rates_ie; |
| const u8 *ht_ie, *wpa_ie, *wmm_ie, *rsn_ie; |
| int ret; |
| const struct cfg80211_bss_ies *ies = rcu_dereference(bss->ies); |
| |
| param = kzalloc(sizeof(*param), GFP_KERNEL); |
| if (!param) |
| return NULL; |
| |
| param->beacon_period = cpu_to_le16(bss->beacon_interval); |
| param->cap_info = cpu_to_le16(bss->capability); |
| param->bss_type = WILC_FW_BSS_TYPE_INFRA; |
| param->ch = ieee80211_frequency_to_channel(bss->channel->center_freq); |
| ether_addr_copy(param->bssid, bss->bssid); |
| |
| ssid_elm = cfg80211_find_ie(WLAN_EID_SSID, ies->data, ies->len); |
| if (ssid_elm) { |
| if (ssid_elm[1] <= IEEE80211_MAX_SSID_LEN) |
| memcpy(param->ssid, ssid_elm + 2, ssid_elm[1]); |
| } |
| |
| tim_elm = cfg80211_find_ie(WLAN_EID_TIM, ies->data, ies->len); |
| if (tim_elm && tim_elm[1] >= 2) |
| param->dtim_period = tim_elm[3]; |
| |
| memset(param->p_suites, 0xFF, 3); |
| memset(param->akm_suites, 0xFF, 3); |
| |
| rates_ie = cfg80211_find_ie(WLAN_EID_SUPP_RATES, ies->data, ies->len); |
| if (rates_ie) { |
| rates_len = rates_ie[1]; |
| param->supp_rates[0] = rates_len; |
| memcpy(¶m->supp_rates[1], rates_ie + 2, rates_len); |
| } |
| |
| supp_rates_ie = cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES, ies->data, |
| ies->len); |
| if (supp_rates_ie) { |
| if (supp_rates_ie[1] > (WILC_MAX_RATES_SUPPORTED - rates_len)) |
| param->supp_rates[0] = WILC_MAX_RATES_SUPPORTED; |
| else |
| param->supp_rates[0] += supp_rates_ie[1]; |
| |
| memcpy(¶m->supp_rates[rates_len + 1], supp_rates_ie + 2, |
| (param->supp_rates[0] - rates_len)); |
| } |
| |
| ht_ie = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, ies->data, ies->len); |
| if (ht_ie) |
| param->ht_capable = true; |
| |
| ret = cfg80211_get_p2p_attr(ies->data, ies->len, |
| IEEE80211_P2P_ATTR_ABSENCE_NOTICE, |
| (u8 *)&noa_attr, sizeof(noa_attr)); |
| if (ret > 0) { |
| param->tsf_lo = cpu_to_le32(ies->tsf); |
| param->noa_enabled = 1; |
| param->idx = noa_attr.index; |
| if (noa_attr.oppps_ctwindow & IEEE80211_P2P_OPPPS_ENABLE_BIT) { |
| param->opp_enabled = 1; |
| param->opp_en.ct_window = noa_attr.oppps_ctwindow; |
| param->opp_en.cnt = noa_attr.desc[0].count; |
| param->opp_en.duration = noa_attr.desc[0].duration; |
| param->opp_en.interval = noa_attr.desc[0].interval; |
| param->opp_en.start_time = noa_attr.desc[0].start_time; |
| } else { |
| param->opp_enabled = 0; |
| param->opp_dis.cnt = noa_attr.desc[0].count; |
| param->opp_dis.duration = noa_attr.desc[0].duration; |
| param->opp_dis.interval = noa_attr.desc[0].interval; |
| param->opp_dis.start_time = noa_attr.desc[0].start_time; |
| } |
| } |
| wmm_ie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT, |
| WLAN_OUI_TYPE_MICROSOFT_WMM, |
| ies->data, ies->len); |
| if (wmm_ie) { |
| struct ieee80211_wmm_param_ie *ie; |
| |
| ie = (struct ieee80211_wmm_param_ie *)wmm_ie; |
| if ((ie->oui_subtype == 0 || ie->oui_subtype == 1) && |
| ie->version == 1) { |
| param->wmm_cap = true; |
| if (ie->qos_info & BIT(7)) |
| param->uapsd_cap = true; |
| } |
| } |
| |
| wpa_ie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT, |
| WLAN_OUI_TYPE_MICROSOFT_WPA, |
| ies->data, ies->len); |
| if (wpa_ie) { |
| param->mode_802_11i = 1; |
| param->rsn_found = true; |
| } |
| |
| rsn_ie = cfg80211_find_ie(WLAN_EID_RSN, ies->data, ies->len); |
| if (rsn_ie) { |
| int offset = 8; |
| |
| param->mode_802_11i = 2; |
| param->rsn_found = true; |
| //extract RSN capabilities |
| offset += (rsn_ie[offset] * 4) + 2; |
| offset += (rsn_ie[offset] * 4) + 2; |
| memcpy(param->rsn_cap, &rsn_ie[offset], 2); |
| } |
| |
| if (param->rsn_found) { |
| int i; |
| |
| param->rsn_grp_policy = crypto->cipher_group & 0xFF; |
| for (i = 0; i < crypto->n_ciphers_pairwise && i < 3; i++) |
| param->p_suites[i] = crypto->ciphers_pairwise[i] & 0xFF; |
| |
| for (i = 0; i < crypto->n_akm_suites && i < 3; i++) |
| param->akm_suites[i] = crypto->akm_suites[i] & 0xFF; |
| } |
| |
| return (void *)param; |
| } |
| |
| static void handle_rcvd_ntwrk_info(struct work_struct *work) |
| { |
| struct host_if_msg *msg = container_of(work, struct host_if_msg, work); |
| struct wilc_rcvd_net_info *rcvd_info = &msg->body.net_info; |
| struct wilc_user_scan_req *scan_req = &msg->vif->hif_drv->usr_scan_req; |
| const u8 *ch_elm; |
| u8 *ies; |
| int ies_len; |
| size_t offset; |
| |
| if (ieee80211_is_probe_resp(rcvd_info->mgmt->frame_control)) |
| offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable); |
| else if (ieee80211_is_beacon(rcvd_info->mgmt->frame_control)) |
| offset = offsetof(struct ieee80211_mgmt, u.beacon.variable); |
| else |
| goto done; |
| |
| ies = rcvd_info->mgmt->u.beacon.variable; |
| ies_len = rcvd_info->frame_len - offset; |
| if (ies_len <= 0) |
| goto done; |
| |
| ch_elm = cfg80211_find_ie(WLAN_EID_DS_PARAMS, ies, ies_len); |
| if (ch_elm && ch_elm[1] > 0) |
| rcvd_info->ch = ch_elm[2]; |
| |
| if (scan_req->scan_result) |
| scan_req->scan_result(SCAN_EVENT_NETWORK_FOUND, rcvd_info, |
| scan_req->arg); |
| |
| done: |
| kfree(rcvd_info->mgmt); |
| kfree(msg); |
| } |
| |
| static void host_int_get_assoc_res_info(struct wilc_vif *vif, |
| u8 *assoc_resp_info, |
| u32 max_assoc_resp_info_len, |
| u32 *rcvd_assoc_resp_info_len) |
| { |
| int result; |
| struct wid wid; |
| |
| wid.id = WID_ASSOC_RES_INFO; |
| wid.type = WID_STR; |
| wid.val = assoc_resp_info; |
| wid.size = max_assoc_resp_info_len; |
| |
| result = wilc_send_config_pkt(vif, WILC_GET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) { |
| *rcvd_assoc_resp_info_len = 0; |
| netdev_err(vif->ndev, "Failed to send association response\n"); |
| return; |
| } |
| |
| *rcvd_assoc_resp_info_len = wid.size; |
| } |
| |
| static s32 wilc_parse_assoc_resp_info(u8 *buffer, u32 buffer_len, |
| struct wilc_conn_info *ret_conn_info) |
| { |
| u8 *ies; |
| u16 ies_len; |
| struct assoc_resp *res = (struct assoc_resp *)buffer; |
| |
| ret_conn_info->status = le16_to_cpu(res->status_code); |
| if (ret_conn_info->status == WLAN_STATUS_SUCCESS) { |
| ies = &buffer[sizeof(*res)]; |
| ies_len = buffer_len - sizeof(*res); |
| |
| ret_conn_info->resp_ies = kmemdup(ies, ies_len, GFP_KERNEL); |
| if (!ret_conn_info->resp_ies) |
| return -ENOMEM; |
| |
| ret_conn_info->resp_ies_len = ies_len; |
| } |
| |
| return 0; |
| } |
| |
| static inline void host_int_parse_assoc_resp_info(struct wilc_vif *vif, |
| u8 mac_status) |
| { |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| struct wilc_conn_info *conn_info = &hif_drv->conn_info; |
| |
| if (mac_status == WILC_MAC_STATUS_CONNECTED) { |
| u32 assoc_resp_info_len; |
| |
| memset(hif_drv->assoc_resp, 0, WILC_MAX_ASSOC_RESP_FRAME_SIZE); |
| |
| host_int_get_assoc_res_info(vif, hif_drv->assoc_resp, |
| WILC_MAX_ASSOC_RESP_FRAME_SIZE, |
| &assoc_resp_info_len); |
| |
| if (assoc_resp_info_len != 0) { |
| s32 err = 0; |
| |
| err = wilc_parse_assoc_resp_info(hif_drv->assoc_resp, |
| assoc_resp_info_len, |
| conn_info); |
| if (err) |
| netdev_err(vif->ndev, |
| "wilc_parse_assoc_resp_info() returned error %d\n", |
| err); |
| } |
| } |
| |
| del_timer(&hif_drv->connect_timer); |
| conn_info->conn_result(CONN_DISCONN_EVENT_CONN_RESP, mac_status, |
| hif_drv->conn_info.arg); |
| |
| if (mac_status == WILC_MAC_STATUS_CONNECTED && |
| conn_info->status == WLAN_STATUS_SUCCESS) { |
| ether_addr_copy(hif_drv->assoc_bssid, conn_info->bssid); |
| wilc_set_power_mgmt(vif, 0, 0); |
| |
| hif_drv->hif_state = HOST_IF_CONNECTED; |
| |
| vif->obtaining_ip = true; |
| mod_timer(&vif->during_ip_timer, |
| jiffies + msecs_to_jiffies(10000)); |
| } else { |
| hif_drv->hif_state = HOST_IF_IDLE; |
| } |
| |
| kfree(conn_info->resp_ies); |
| conn_info->resp_ies = NULL; |
| conn_info->resp_ies_len = 0; |
| |
| kfree(conn_info->req_ies); |
| conn_info->req_ies = NULL; |
| conn_info->req_ies_len = 0; |
| } |
| |
| static inline void host_int_handle_disconnect(struct wilc_vif *vif) |
| { |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| |
| if (hif_drv->usr_scan_req.scan_result) { |
| del_timer(&hif_drv->scan_timer); |
| handle_scan_done(vif, SCAN_EVENT_ABORTED); |
| } |
| |
| if (hif_drv->conn_info.conn_result) { |
| vif->obtaining_ip = false; |
| wilc_set_power_mgmt(vif, 0, 0); |
| |
| hif_drv->conn_info.conn_result(CONN_DISCONN_EVENT_DISCONN_NOTIF, |
| 0, hif_drv->conn_info.arg); |
| } else { |
| netdev_err(vif->ndev, "%s: conn_result is NULL\n", __func__); |
| } |
| |
| eth_zero_addr(hif_drv->assoc_bssid); |
| |
| hif_drv->conn_info.req_ies_len = 0; |
| kfree(hif_drv->conn_info.req_ies); |
| hif_drv->conn_info.req_ies = NULL; |
| hif_drv->hif_state = HOST_IF_IDLE; |
| } |
| |
| static void handle_rcvd_gnrl_async_info(struct work_struct *work) |
| { |
| struct host_if_msg *msg = container_of(work, struct host_if_msg, work); |
| struct wilc_vif *vif = msg->vif; |
| struct wilc_rcvd_mac_info *mac_info = &msg->body.mac_info; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| |
| if (!hif_drv) { |
| netdev_err(vif->ndev, "%s: hif driver is NULL\n", __func__); |
| goto free_msg; |
| } |
| |
| if (!hif_drv->conn_info.conn_result) { |
| netdev_err(vif->ndev, "%s: conn_result is NULL\n", __func__); |
| goto free_msg; |
| } |
| |
| if (hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP) { |
| host_int_parse_assoc_resp_info(vif, mac_info->status); |
| } else if (mac_info->status == WILC_MAC_STATUS_DISCONNECTED) { |
| if (hif_drv->hif_state == HOST_IF_CONNECTED) { |
| host_int_handle_disconnect(vif); |
| } else if (hif_drv->usr_scan_req.scan_result) { |
| del_timer(&hif_drv->scan_timer); |
| handle_scan_done(vif, SCAN_EVENT_ABORTED); |
| } |
| } |
| |
| free_msg: |
| kfree(msg); |
| } |
| |
| int wilc_disconnect(struct wilc_vif *vif) |
| { |
| struct wid wid; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| struct wilc_user_scan_req *scan_req; |
| struct wilc_conn_info *conn_info; |
| int result; |
| u16 dummy_reason_code = 0; |
| |
| wid.id = WID_DISCONNECT; |
| wid.type = WID_CHAR; |
| wid.val = (s8 *)&dummy_reason_code; |
| wid.size = sizeof(char); |
| |
| vif->obtaining_ip = false; |
| wilc_set_power_mgmt(vif, 0, 0); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) { |
| netdev_err(vif->ndev, "Failed to send dissconect\n"); |
| return result; |
| } |
| |
| scan_req = &hif_drv->usr_scan_req; |
| conn_info = &hif_drv->conn_info; |
| |
| if (scan_req->scan_result) { |
| del_timer(&hif_drv->scan_timer); |
| scan_req->scan_result(SCAN_EVENT_ABORTED, NULL, scan_req->arg); |
| scan_req->scan_result = NULL; |
| } |
| |
| if (conn_info->conn_result) { |
| if (hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP) |
| del_timer(&hif_drv->connect_timer); |
| |
| conn_info->conn_result(CONN_DISCONN_EVENT_DISCONN_NOTIF, 0, |
| conn_info->arg); |
| } else { |
| netdev_err(vif->ndev, "%s: conn_result is NULL\n", __func__); |
| } |
| |
| hif_drv->hif_state = HOST_IF_IDLE; |
| |
| eth_zero_addr(hif_drv->assoc_bssid); |
| |
| conn_info->req_ies_len = 0; |
| kfree(conn_info->req_ies); |
| conn_info->req_ies = NULL; |
| |
| return 0; |
| } |
| |
| void wilc_resolve_disconnect_aberration(struct wilc_vif *vif) |
| { |
| if (!vif->hif_drv) |
| return; |
| if (vif->hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP || |
| vif->hif_drv->hif_state == HOST_IF_CONNECTING) |
| wilc_disconnect(vif); |
| } |
| |
| int wilc_get_statistics(struct wilc_vif *vif, struct rf_info *stats) |
| { |
| struct wid wid_list[5]; |
| u32 wid_cnt = 0, result; |
| |
| wid_list[wid_cnt].id = WID_LINKSPEED; |
| wid_list[wid_cnt].type = WID_CHAR; |
| wid_list[wid_cnt].size = sizeof(char); |
| wid_list[wid_cnt].val = (s8 *)&stats->link_speed; |
| wid_cnt++; |
| |
| wid_list[wid_cnt].id = WID_RSSI; |
| wid_list[wid_cnt].type = WID_CHAR; |
| wid_list[wid_cnt].size = sizeof(char); |
| wid_list[wid_cnt].val = (s8 *)&stats->rssi; |
| wid_cnt++; |
| |
| wid_list[wid_cnt].id = WID_SUCCESS_FRAME_COUNT; |
| wid_list[wid_cnt].type = WID_INT; |
| wid_list[wid_cnt].size = sizeof(u32); |
| wid_list[wid_cnt].val = (s8 *)&stats->tx_cnt; |
| wid_cnt++; |
| |
| wid_list[wid_cnt].id = WID_RECEIVED_FRAGMENT_COUNT; |
| wid_list[wid_cnt].type = WID_INT; |
| wid_list[wid_cnt].size = sizeof(u32); |
| wid_list[wid_cnt].val = (s8 *)&stats->rx_cnt; |
| wid_cnt++; |
| |
| wid_list[wid_cnt].id = WID_FAILED_COUNT; |
| wid_list[wid_cnt].type = WID_INT; |
| wid_list[wid_cnt].size = sizeof(u32); |
| wid_list[wid_cnt].val = (s8 *)&stats->tx_fail_cnt; |
| wid_cnt++; |
| |
| result = wilc_send_config_pkt(vif, WILC_GET_CFG, wid_list, |
| wid_cnt, |
| wilc_get_vif_idx(vif)); |
| |
| if (result) { |
| netdev_err(vif->ndev, "Failed to send scan parameters\n"); |
| return result; |
| } |
| |
| if (stats->link_speed > TCP_ACK_FILTER_LINK_SPEED_THRESH && |
| stats->link_speed != DEFAULT_LINK_SPEED) |
| wilc_enable_tcp_ack_filter(vif, true); |
| else if (stats->link_speed != DEFAULT_LINK_SPEED) |
| wilc_enable_tcp_ack_filter(vif, false); |
| |
| return result; |
| } |
| |
| static void handle_get_statistics(struct work_struct *work) |
| { |
| struct host_if_msg *msg = container_of(work, struct host_if_msg, work); |
| struct wilc_vif *vif = msg->vif; |
| struct rf_info *stats = (struct rf_info *)msg->body.data; |
| |
| wilc_get_statistics(vif, stats); |
| |
| kfree(msg); |
| } |
| |
| static void wilc_hif_pack_sta_param(u8 *cur_byte, const u8 *mac, |
| struct station_parameters *params) |
| { |
| ether_addr_copy(cur_byte, mac); |
| cur_byte += ETH_ALEN; |
| |
| put_unaligned_le16(params->aid, cur_byte); |
| cur_byte += 2; |
| |
| *cur_byte++ = params->supported_rates_len; |
| if (params->supported_rates_len > 0) |
| memcpy(cur_byte, params->supported_rates, |
| params->supported_rates_len); |
| cur_byte += params->supported_rates_len; |
| |
| if (params->ht_capa) { |
| *cur_byte++ = true; |
| memcpy(cur_byte, ¶ms->ht_capa, |
| sizeof(struct ieee80211_ht_cap)); |
| } else { |
| *cur_byte++ = false; |
| } |
| cur_byte += sizeof(struct ieee80211_ht_cap); |
| |
| put_unaligned_le16(params->sta_flags_mask, cur_byte); |
| cur_byte += 2; |
| put_unaligned_le16(params->sta_flags_set, cur_byte); |
| } |
| |
| static int handle_remain_on_chan(struct wilc_vif *vif, |
| struct wilc_remain_ch *hif_remain_ch) |
| { |
| int result; |
| u8 remain_on_chan_flag; |
| struct wid wid; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| |
| if (hif_drv->usr_scan_req.scan_result) |
| return -EBUSY; |
| |
| if (hif_drv->hif_state == HOST_IF_WAITING_CONN_RESP) |
| return -EBUSY; |
| |
| if (vif->obtaining_ip || vif->connecting) |
| return -EBUSY; |
| |
| remain_on_chan_flag = true; |
| wid.id = WID_REMAIN_ON_CHAN; |
| wid.type = WID_STR; |
| wid.size = 2; |
| wid.val = kmalloc(wid.size, GFP_KERNEL); |
| if (!wid.val) |
| return -ENOMEM; |
| |
| wid.val[0] = remain_on_chan_flag; |
| wid.val[1] = (s8)hif_remain_ch->ch; |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| kfree(wid.val); |
| if (result) |
| return -EBUSY; |
| |
| hif_drv->remain_on_ch.arg = hif_remain_ch->arg; |
| hif_drv->remain_on_ch.expired = hif_remain_ch->expired; |
| hif_drv->remain_on_ch.ch = hif_remain_ch->ch; |
| hif_drv->remain_on_ch.cookie = hif_remain_ch->cookie; |
| hif_drv->remain_on_ch_timer_vif = vif; |
| |
| return 0; |
| } |
| |
| static void handle_listen_state_expired(struct work_struct *work) |
| { |
| struct host_if_msg *msg = container_of(work, struct host_if_msg, work); |
| struct wilc_vif *vif = msg->vif; |
| struct wilc_remain_ch *hif_remain_ch = &msg->body.remain_on_ch; |
| u8 remain_on_chan_flag; |
| struct wid wid; |
| int result; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| struct wilc_priv *priv = wdev_priv(vif->ndev->ieee80211_ptr); |
| |
| if (priv->p2p_listen_state) { |
| remain_on_chan_flag = false; |
| wid.id = WID_REMAIN_ON_CHAN; |
| wid.type = WID_STR; |
| wid.size = 2; |
| wid.val = kmalloc(wid.size, GFP_KERNEL); |
| |
| if (!wid.val) |
| goto free_msg; |
| |
| wid.val[0] = remain_on_chan_flag; |
| wid.val[1] = WILC_FALSE_FRMWR_CHANNEL; |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| kfree(wid.val); |
| if (result != 0) { |
| netdev_err(vif->ndev, "Failed to set remain channel\n"); |
| goto free_msg; |
| } |
| |
| if (hif_drv->remain_on_ch.expired) { |
| hif_drv->remain_on_ch.expired(hif_drv->remain_on_ch.arg, |
| hif_remain_ch->cookie); |
| } |
| } else { |
| netdev_dbg(vif->ndev, "Not in listen state\n"); |
| } |
| |
| free_msg: |
| kfree(msg); |
| } |
| |
| static void listen_timer_cb(struct timer_list *t) |
| { |
| struct host_if_drv *hif_drv = from_timer(hif_drv, t, |
| remain_on_ch_timer); |
| struct wilc_vif *vif = hif_drv->remain_on_ch_timer_vif; |
| int result; |
| struct host_if_msg *msg; |
| |
| del_timer(&vif->hif_drv->remain_on_ch_timer); |
| |
| msg = wilc_alloc_work(vif, handle_listen_state_expired, false); |
| if (IS_ERR(msg)) |
| return; |
| |
| msg->body.remain_on_ch.cookie = vif->hif_drv->remain_on_ch.cookie; |
| |
| result = wilc_enqueue_work(msg); |
| if (result) { |
| netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__); |
| kfree(msg); |
| } |
| } |
| |
| static void handle_set_mcast_filter(struct work_struct *work) |
| { |
| struct host_if_msg *msg = container_of(work, struct host_if_msg, work); |
| struct wilc_vif *vif = msg->vif; |
| struct wilc_set_multicast *set_mc = &msg->body.mc_info; |
| int result; |
| struct wid wid; |
| u8 *cur_byte; |
| |
| wid.id = WID_SETUP_MULTICAST_FILTER; |
| wid.type = WID_BIN; |
| wid.size = sizeof(struct wilc_set_multicast) + (set_mc->cnt * ETH_ALEN); |
| wid.val = kmalloc(wid.size, GFP_KERNEL); |
| if (!wid.val) |
| goto error; |
| |
| cur_byte = wid.val; |
| put_unaligned_le32(set_mc->enabled, cur_byte); |
| cur_byte += 4; |
| |
| put_unaligned_le32(set_mc->cnt, cur_byte); |
| cur_byte += 4; |
| |
| if (set_mc->cnt > 0 && set_mc->mc_list) |
| memcpy(cur_byte, set_mc->mc_list, set_mc->cnt * ETH_ALEN); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to send setup multicast\n"); |
| |
| error: |
| kfree(set_mc->mc_list); |
| kfree(wid.val); |
| kfree(msg); |
| } |
| |
| static void handle_scan_timer(struct work_struct *work) |
| { |
| struct host_if_msg *msg = container_of(work, struct host_if_msg, work); |
| |
| handle_scan_done(msg->vif, SCAN_EVENT_ABORTED); |
| kfree(msg); |
| } |
| |
| static void handle_scan_complete(struct work_struct *work) |
| { |
| struct host_if_msg *msg = container_of(work, struct host_if_msg, work); |
| struct wilc *wilc = msg->vif->wilc; |
| |
| del_timer(&msg->vif->hif_drv->scan_timer); |
| |
| if (!wilc_wlan_get_num_conn_ifcs(wilc)) |
| wilc_chip_sleep_manually(wilc); |
| |
| handle_scan_done(msg->vif, SCAN_EVENT_DONE); |
| |
| kfree(msg); |
| } |
| |
| static void timer_scan_cb(struct timer_list *t) |
| { |
| struct host_if_drv *hif_drv = from_timer(hif_drv, t, scan_timer); |
| struct wilc_vif *vif = hif_drv->scan_timer_vif; |
| struct host_if_msg *msg; |
| int result; |
| |
| msg = wilc_alloc_work(vif, handle_scan_timer, false); |
| if (IS_ERR(msg)) |
| return; |
| |
| result = wilc_enqueue_work(msg); |
| if (result) |
| kfree(msg); |
| } |
| |
| static void timer_connect_cb(struct timer_list *t) |
| { |
| struct host_if_drv *hif_drv = from_timer(hif_drv, t, |
| connect_timer); |
| struct wilc_vif *vif = hif_drv->connect_timer_vif; |
| struct host_if_msg *msg; |
| int result; |
| |
| msg = wilc_alloc_work(vif, handle_connect_timeout, false); |
| if (IS_ERR(msg)) |
| return; |
| |
| result = wilc_enqueue_work(msg); |
| if (result) |
| kfree(msg); |
| } |
| |
| int wilc_remove_wep_key(struct wilc_vif *vif, u8 index) |
| { |
| struct wid wid; |
| int result; |
| |
| wid.id = WID_REMOVE_WEP_KEY; |
| wid.type = WID_STR; |
| wid.size = sizeof(char); |
| wid.val = &index; |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, |
| "Failed to send remove wep key config packet\n"); |
| return result; |
| } |
| |
| int wilc_set_wep_default_keyid(struct wilc_vif *vif, u8 index) |
| { |
| struct wid wid; |
| int result; |
| |
| wid.id = WID_KEY_ID; |
| wid.type = WID_CHAR; |
| wid.size = sizeof(char); |
| wid.val = &index; |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, |
| "Failed to send wep default key config packet\n"); |
| |
| return result; |
| } |
| |
| int wilc_add_wep_key_bss_sta(struct wilc_vif *vif, const u8 *key, u8 len, |
| u8 index) |
| { |
| struct wid wid; |
| int result; |
| struct wilc_wep_key *wep_key; |
| |
| wid.id = WID_ADD_WEP_KEY; |
| wid.type = WID_STR; |
| wid.size = sizeof(*wep_key) + len; |
| wep_key = kzalloc(wid.size, GFP_KERNEL); |
| if (!wep_key) |
| return -ENOMEM; |
| |
| wid.val = (u8 *)wep_key; |
| |
| wep_key->index = index; |
| wep_key->key_len = len; |
| memcpy(wep_key->key, key, len); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, |
| "Failed to add wep key config packet\n"); |
| |
| kfree(wep_key); |
| return result; |
| } |
| |
| int wilc_add_wep_key_bss_ap(struct wilc_vif *vif, const u8 *key, u8 len, |
| u8 index, u8 mode, enum authtype auth_type) |
| { |
| struct wid wid_list[3]; |
| int result; |
| struct wilc_wep_key *wep_key; |
| |
| wid_list[0].id = WID_11I_MODE; |
| wid_list[0].type = WID_CHAR; |
| wid_list[0].size = sizeof(char); |
| wid_list[0].val = &mode; |
| |
| wid_list[1].id = WID_AUTH_TYPE; |
| wid_list[1].type = WID_CHAR; |
| wid_list[1].size = sizeof(char); |
| wid_list[1].val = (s8 *)&auth_type; |
| |
| wid_list[2].id = WID_WEP_KEY_VALUE; |
| wid_list[2].type = WID_STR; |
| wid_list[2].size = sizeof(*wep_key) + len; |
| wep_key = kzalloc(wid_list[2].size, GFP_KERNEL); |
| if (!wep_key) |
| return -ENOMEM; |
| |
| wid_list[2].val = (u8 *)wep_key; |
| |
| wep_key->index = index; |
| wep_key->key_len = len; |
| memcpy(wep_key->key, key, len); |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list, |
| ARRAY_SIZE(wid_list), |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, |
| "Failed to add wep ap key config packet\n"); |
| |
| kfree(wep_key); |
| return result; |
| } |
| |
| int wilc_add_ptk(struct wilc_vif *vif, const u8 *ptk, u8 ptk_key_len, |
| const u8 *mac_addr, const u8 *rx_mic, const u8 *tx_mic, |
| u8 mode, u8 cipher_mode, u8 index) |
| { |
| int result = 0; |
| u8 t_key_len = ptk_key_len + WILC_RX_MIC_KEY_LEN + WILC_TX_MIC_KEY_LEN; |
| |
| if (mode == WILC_AP_MODE) { |
| struct wid wid_list[2]; |
| struct wilc_ap_wpa_ptk *key_buf; |
| |
| wid_list[0].id = WID_11I_MODE; |
| wid_list[0].type = WID_CHAR; |
| wid_list[0].size = sizeof(char); |
| wid_list[0].val = (s8 *)&cipher_mode; |
| |
| key_buf = kzalloc(sizeof(*key_buf) + t_key_len, GFP_KERNEL); |
| if (!key_buf) |
| return -ENOMEM; |
| |
| ether_addr_copy(key_buf->mac_addr, mac_addr); |
| key_buf->index = index; |
| key_buf->key_len = t_key_len; |
| memcpy(&key_buf->key[0], ptk, ptk_key_len); |
| |
| if (rx_mic) |
| memcpy(&key_buf->key[ptk_key_len], rx_mic, |
| WILC_RX_MIC_KEY_LEN); |
| |
| if (tx_mic) |
| memcpy(&key_buf->key[ptk_key_len + WILC_RX_MIC_KEY_LEN], |
| tx_mic, WILC_TX_MIC_KEY_LEN); |
| |
| wid_list[1].id = WID_ADD_PTK; |
| wid_list[1].type = WID_STR; |
| wid_list[1].size = sizeof(*key_buf) + t_key_len; |
| wid_list[1].val = (u8 *)key_buf; |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list, |
| ARRAY_SIZE(wid_list), |
| wilc_get_vif_idx(vif)); |
| kfree(key_buf); |
| } else if (mode == WILC_STATION_MODE) { |
| struct wid wid; |
| struct wilc_sta_wpa_ptk *key_buf; |
| |
| key_buf = kzalloc(sizeof(*key_buf) + t_key_len, GFP_KERNEL); |
| if (!key_buf) |
| return -ENOMEM; |
| |
| ether_addr_copy(key_buf->mac_addr, mac_addr); |
| key_buf->key_len = t_key_len; |
| memcpy(&key_buf->key[0], ptk, ptk_key_len); |
| |
| if (rx_mic) |
| memcpy(&key_buf->key[ptk_key_len], rx_mic, |
| WILC_RX_MIC_KEY_LEN); |
| |
| if (tx_mic) |
| memcpy(&key_buf->key[ptk_key_len + WILC_RX_MIC_KEY_LEN], |
| tx_mic, WILC_TX_MIC_KEY_LEN); |
| |
| wid.id = WID_ADD_PTK; |
| wid.type = WID_STR; |
| wid.size = sizeof(*key_buf) + t_key_len; |
| wid.val = (s8 *)key_buf; |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| kfree(key_buf); |
| } |
| |
| return result; |
| } |
| |
| int wilc_add_rx_gtk(struct wilc_vif *vif, const u8 *rx_gtk, u8 gtk_key_len, |
| u8 index, u32 key_rsc_len, const u8 *key_rsc, |
| const u8 *rx_mic, const u8 *tx_mic, u8 mode, |
| u8 cipher_mode) |
| { |
| int result = 0; |
| struct wilc_gtk_key *gtk_key; |
| int t_key_len = gtk_key_len + WILC_RX_MIC_KEY_LEN + WILC_TX_MIC_KEY_LEN; |
| |
| gtk_key = kzalloc(sizeof(*gtk_key) + t_key_len, GFP_KERNEL); |
| if (!gtk_key) |
| return -ENOMEM; |
| |
| /* fill bssid value only in station mode */ |
| if (mode == WILC_STATION_MODE && |
| vif->hif_drv->hif_state == HOST_IF_CONNECTED) |
| memcpy(gtk_key->mac_addr, vif->hif_drv->assoc_bssid, ETH_ALEN); |
| |
| if (key_rsc) |
| memcpy(gtk_key->rsc, key_rsc, 8); |
| gtk_key->index = index; |
| gtk_key->key_len = t_key_len; |
| memcpy(>k_key->key[0], rx_gtk, gtk_key_len); |
| |
| if (rx_mic) |
| memcpy(>k_key->key[gtk_key_len], rx_mic, WILC_RX_MIC_KEY_LEN); |
| |
| if (tx_mic) |
| memcpy(>k_key->key[gtk_key_len + WILC_RX_MIC_KEY_LEN], |
| tx_mic, WILC_TX_MIC_KEY_LEN); |
| |
| if (mode == WILC_AP_MODE) { |
| struct wid wid_list[2]; |
| |
| wid_list[0].id = WID_11I_MODE; |
| wid_list[0].type = WID_CHAR; |
| wid_list[0].size = sizeof(char); |
| wid_list[0].val = (s8 *)&cipher_mode; |
| |
| wid_list[1].id = WID_ADD_RX_GTK; |
| wid_list[1].type = WID_STR; |
| wid_list[1].size = sizeof(*gtk_key) + t_key_len; |
| wid_list[1].val = (u8 *)gtk_key; |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list, |
| ARRAY_SIZE(wid_list), |
| wilc_get_vif_idx(vif)); |
| } else if (mode == WILC_STATION_MODE) { |
| struct wid wid; |
| |
| wid.id = WID_ADD_RX_GTK; |
| wid.type = WID_STR; |
| wid.size = sizeof(*gtk_key) + t_key_len; |
| wid.val = (u8 *)gtk_key; |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| } |
| |
| kfree(gtk_key); |
| return result; |
| } |
| |
| int wilc_set_pmkid_info(struct wilc_vif *vif, struct wilc_pmkid_attr *pmkid) |
| { |
| struct wid wid; |
| int result; |
| |
| wid.id = WID_PMKID_INFO; |
| wid.type = WID_STR; |
| wid.size = (pmkid->numpmkid * sizeof(struct wilc_pmkid)) + 1; |
| wid.val = (u8 *)pmkid; |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| |
| return result; |
| } |
| |
| int wilc_get_mac_address(struct wilc_vif *vif, u8 *mac_addr) |
| { |
| int result; |
| struct wid wid; |
| |
| wid.id = WID_MAC_ADDR; |
| wid.type = WID_STR; |
| wid.size = ETH_ALEN; |
| wid.val = mac_addr; |
| |
| result = wilc_send_config_pkt(vif, WILC_GET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to get mac address\n"); |
| |
| return result; |
| } |
| |
| int wilc_set_join_req(struct wilc_vif *vif, u8 *bssid, const u8 *ies, |
| size_t ies_len) |
| { |
| int result; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| struct wilc_conn_info *conn_info = &hif_drv->conn_info; |
| |
| if (bssid) |
| ether_addr_copy(conn_info->bssid, bssid); |
| |
| if (ies) { |
| conn_info->req_ies_len = ies_len; |
| conn_info->req_ies = kmemdup(ies, ies_len, GFP_KERNEL); |
| if (!conn_info->req_ies) { |
| result = -ENOMEM; |
| return result; |
| } |
| } |
| |
| result = wilc_send_connect_wid(vif); |
| if (result) |
| goto free_ies; |
| |
| hif_drv->connect_timer_vif = vif; |
| mod_timer(&hif_drv->connect_timer, |
| jiffies + msecs_to_jiffies(WILC_HIF_CONNECT_TIMEOUT_MS)); |
| |
| return 0; |
| |
| free_ies: |
| kfree(conn_info->req_ies); |
| |
| return result; |
| } |
| |
| int wilc_set_mac_chnl_num(struct wilc_vif *vif, u8 channel) |
| { |
| struct wid wid; |
| int result; |
| |
| wid.id = WID_CURRENT_CHANNEL; |
| wid.type = WID_CHAR; |
| wid.size = sizeof(char); |
| wid.val = &channel; |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to set channel\n"); |
| |
| return result; |
| } |
| |
| int wilc_set_wfi_drv_handler(struct wilc_vif *vif, int index, u8 mode, |
| u8 ifc_id) |
| { |
| struct wid wid; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| int result; |
| struct wilc_drv_handler drv; |
| |
| if (!hif_drv) |
| return -EFAULT; |
| |
| wid.id = WID_SET_DRV_HANDLER; |
| wid.type = WID_STR; |
| wid.size = sizeof(drv); |
| wid.val = (u8 *)&drv; |
| |
| drv.handler = cpu_to_le32(index); |
| drv.mode = (ifc_id | (mode << 1)); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| hif_drv->driver_handler_id); |
| if (result) |
| netdev_err(vif->ndev, "Failed to set driver handler\n"); |
| |
| return result; |
| } |
| |
| int wilc_set_operation_mode(struct wilc_vif *vif, u32 mode) |
| { |
| struct wid wid; |
| struct wilc_op_mode op_mode; |
| int result; |
| |
| wid.id = WID_SET_OPERATION_MODE; |
| wid.type = WID_INT; |
| wid.size = sizeof(op_mode); |
| wid.val = (u8 *)&op_mode; |
| |
| op_mode.mode = cpu_to_le32(mode); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to set operation mode\n"); |
| |
| return result; |
| } |
| |
| s32 wilc_get_inactive_time(struct wilc_vif *vif, const u8 *mac, u32 *out_val) |
| { |
| struct wid wid; |
| s32 result; |
| |
| wid.id = WID_SET_STA_MAC_INACTIVE_TIME; |
| wid.type = WID_STR; |
| wid.size = ETH_ALEN; |
| wid.val = kzalloc(wid.size, GFP_KERNEL); |
| if (!wid.val) |
| return -ENOMEM; |
| |
| ether_addr_copy(wid.val, mac); |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| kfree(wid.val); |
| if (result) { |
| netdev_err(vif->ndev, "Failed to set inactive mac\n"); |
| return result; |
| } |
| |
| wid.id = WID_GET_INACTIVE_TIME; |
| wid.type = WID_INT; |
| wid.val = (s8 *)out_val; |
| wid.size = sizeof(u32); |
| result = wilc_send_config_pkt(vif, WILC_GET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to get inactive time\n"); |
| |
| return result; |
| } |
| |
| int wilc_get_rssi(struct wilc_vif *vif, s8 *rssi_level) |
| { |
| struct wid wid; |
| int result; |
| |
| if (!rssi_level) { |
| netdev_err(vif->ndev, "%s: RSSI level is NULL\n", __func__); |
| return -EFAULT; |
| } |
| |
| wid.id = WID_RSSI; |
| wid.type = WID_CHAR; |
| wid.size = sizeof(char); |
| wid.val = rssi_level; |
| result = wilc_send_config_pkt(vif, WILC_GET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to get RSSI value\n"); |
| |
| return result; |
| } |
| |
| static int wilc_get_stats_async(struct wilc_vif *vif, struct rf_info *stats) |
| { |
| int result; |
| struct host_if_msg *msg; |
| |
| msg = wilc_alloc_work(vif, handle_get_statistics, false); |
| if (IS_ERR(msg)) |
| return PTR_ERR(msg); |
| |
| msg->body.data = (char *)stats; |
| |
| result = wilc_enqueue_work(msg); |
| if (result) { |
| netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__); |
| kfree(msg); |
| return result; |
| } |
| |
| return result; |
| } |
| |
| int wilc_hif_set_cfg(struct wilc_vif *vif, struct cfg_param_attr *param) |
| { |
| struct wid wid_list[4]; |
| int i = 0; |
| int result; |
| |
| if (param->flag & WILC_CFG_PARAM_RETRY_SHORT) { |
| wid_list[i].id = WID_SHORT_RETRY_LIMIT; |
| wid_list[i].val = (s8 *)¶m->short_retry_limit; |
| wid_list[i].type = WID_SHORT; |
| wid_list[i].size = sizeof(u16); |
| i++; |
| } |
| if (param->flag & WILC_CFG_PARAM_RETRY_LONG) { |
| wid_list[i].id = WID_LONG_RETRY_LIMIT; |
| wid_list[i].val = (s8 *)¶m->long_retry_limit; |
| wid_list[i].type = WID_SHORT; |
| wid_list[i].size = sizeof(u16); |
| i++; |
| } |
| if (param->flag & WILC_CFG_PARAM_FRAG_THRESHOLD) { |
| wid_list[i].id = WID_FRAG_THRESHOLD; |
| wid_list[i].val = (s8 *)¶m->frag_threshold; |
| wid_list[i].type = WID_SHORT; |
| wid_list[i].size = sizeof(u16); |
| i++; |
| } |
| if (param->flag & WILC_CFG_PARAM_RTS_THRESHOLD) { |
| wid_list[i].id = WID_RTS_THRESHOLD; |
| wid_list[i].val = (s8 *)¶m->rts_threshold; |
| wid_list[i].type = WID_SHORT; |
| wid_list[i].size = sizeof(u16); |
| i++; |
| } |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list, |
| i, wilc_get_vif_idx(vif)); |
| |
| return result; |
| } |
| |
| static void get_periodic_rssi(struct timer_list *t) |
| { |
| struct wilc_vif *vif = from_timer(vif, t, periodic_rssi); |
| |
| if (!vif->hif_drv) { |
| netdev_err(vif->ndev, "%s: hif driver is NULL", __func__); |
| return; |
| } |
| |
| if (vif->hif_drv->hif_state == HOST_IF_CONNECTED) |
| wilc_get_stats_async(vif, &vif->periodic_stat); |
| |
| mod_timer(&vif->periodic_rssi, jiffies + msecs_to_jiffies(5000)); |
| } |
| |
| int wilc_init(struct net_device *dev, struct host_if_drv **hif_drv_handler) |
| { |
| struct host_if_drv *hif_drv; |
| struct wilc_vif *vif = netdev_priv(dev); |
| struct wilc *wilc = vif->wilc; |
| int i; |
| |
| hif_drv = kzalloc(sizeof(*hif_drv), GFP_KERNEL); |
| if (!hif_drv) |
| return -ENOMEM; |
| |
| *hif_drv_handler = hif_drv; |
| for (i = 0; i < wilc->vif_num; i++) |
| if (dev == wilc->vif[i]->ndev) { |
| wilc->vif[i]->hif_drv = hif_drv; |
| hif_drv->driver_handler_id = i + 1; |
| break; |
| } |
| |
| vif->obtaining_ip = false; |
| |
| if (wilc->clients_count == 0) |
| mutex_init(&wilc->deinit_lock); |
| |
| timer_setup(&vif->periodic_rssi, get_periodic_rssi, 0); |
| mod_timer(&vif->periodic_rssi, jiffies + msecs_to_jiffies(5000)); |
| |
| timer_setup(&hif_drv->scan_timer, timer_scan_cb, 0); |
| timer_setup(&hif_drv->connect_timer, timer_connect_cb, 0); |
| timer_setup(&hif_drv->remain_on_ch_timer, listen_timer_cb, 0); |
| |
| hif_drv->hif_state = HOST_IF_IDLE; |
| |
| hif_drv->p2p_timeout = 0; |
| |
| wilc->clients_count++; |
| |
| return 0; |
| } |
| |
| int wilc_deinit(struct wilc_vif *vif) |
| { |
| int result = 0; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| |
| if (!hif_drv) { |
| netdev_err(vif->ndev, "%s: hif driver is NULL", __func__); |
| return -EFAULT; |
| } |
| |
| mutex_lock(&vif->wilc->deinit_lock); |
| |
| del_timer_sync(&hif_drv->scan_timer); |
| del_timer_sync(&hif_drv->connect_timer); |
| del_timer_sync(&vif->periodic_rssi); |
| del_timer_sync(&hif_drv->remain_on_ch_timer); |
| |
| wilc_set_wfi_drv_handler(vif, 0, 0, 0); |
| |
| if (hif_drv->usr_scan_req.scan_result) { |
| hif_drv->usr_scan_req.scan_result(SCAN_EVENT_ABORTED, NULL, |
| hif_drv->usr_scan_req.arg); |
| hif_drv->usr_scan_req.scan_result = NULL; |
| } |
| |
| hif_drv->hif_state = HOST_IF_IDLE; |
| |
| kfree(hif_drv); |
| vif->hif_drv = NULL; |
| vif->wilc->clients_count--; |
| mutex_unlock(&vif->wilc->deinit_lock); |
| return result; |
| } |
| |
| void wilc_network_info_received(struct wilc *wilc, u8 *buffer, u32 length) |
| { |
| int result; |
| struct host_if_msg *msg; |
| int id; |
| struct host_if_drv *hif_drv; |
| struct wilc_vif *vif; |
| |
| id = get_unaligned_le32(&buffer[length - 4]); |
| vif = wilc_get_vif_from_idx(wilc, id); |
| if (!vif) |
| return; |
| hif_drv = vif->hif_drv; |
| |
| if (!hif_drv) { |
| netdev_err(vif->ndev, "driver not init[%p]\n", hif_drv); |
| return; |
| } |
| |
| msg = wilc_alloc_work(vif, handle_rcvd_ntwrk_info, false); |
| if (IS_ERR(msg)) |
| return; |
| |
| msg->body.net_info.frame_len = get_unaligned_le16(&buffer[6]) - 1; |
| msg->body.net_info.rssi = buffer[8]; |
| msg->body.net_info.mgmt = kmemdup(&buffer[9], |
| msg->body.net_info.frame_len, |
| GFP_KERNEL); |
| if (!msg->body.net_info.mgmt) { |
| kfree(msg); |
| return; |
| } |
| |
| result = wilc_enqueue_work(msg); |
| if (result) { |
| netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__); |
| kfree(msg->body.net_info.mgmt); |
| kfree(msg); |
| } |
| } |
| |
| void wilc_gnrl_async_info_received(struct wilc *wilc, u8 *buffer, u32 length) |
| { |
| int result; |
| struct host_if_msg *msg; |
| int id; |
| struct host_if_drv *hif_drv; |
| struct wilc_vif *vif; |
| |
| mutex_lock(&wilc->deinit_lock); |
| |
| id = get_unaligned_le32(&buffer[length - 4]); |
| vif = wilc_get_vif_from_idx(wilc, id); |
| if (!vif) { |
| mutex_unlock(&wilc->deinit_lock); |
| return; |
| } |
| |
| hif_drv = vif->hif_drv; |
| |
| if (!hif_drv) { |
| mutex_unlock(&wilc->deinit_lock); |
| return; |
| } |
| |
| if (!hif_drv->conn_info.conn_result) { |
| netdev_err(vif->ndev, "%s: conn_result is NULL\n", __func__); |
| mutex_unlock(&wilc->deinit_lock); |
| return; |
| } |
| |
| msg = wilc_alloc_work(vif, handle_rcvd_gnrl_async_info, false); |
| if (IS_ERR(msg)) { |
| mutex_unlock(&wilc->deinit_lock); |
| return; |
| } |
| |
| msg->body.mac_info.status = buffer[7]; |
| result = wilc_enqueue_work(msg); |
| if (result) { |
| netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__); |
| kfree(msg); |
| } |
| |
| mutex_unlock(&wilc->deinit_lock); |
| } |
| |
| void wilc_scan_complete_received(struct wilc *wilc, u8 *buffer, u32 length) |
| { |
| int result; |
| int id; |
| struct host_if_drv *hif_drv; |
| struct wilc_vif *vif; |
| |
| id = get_unaligned_le32(&buffer[length - 4]); |
| vif = wilc_get_vif_from_idx(wilc, id); |
| if (!vif) |
| return; |
| hif_drv = vif->hif_drv; |
| |
| if (!hif_drv) |
| return; |
| |
| if (hif_drv->usr_scan_req.scan_result) { |
| struct host_if_msg *msg; |
| |
| msg = wilc_alloc_work(vif, handle_scan_complete, false); |
| if (IS_ERR(msg)) |
| return; |
| |
| result = wilc_enqueue_work(msg); |
| if (result) { |
| netdev_err(vif->ndev, "%s: enqueue work failed\n", |
| __func__); |
| kfree(msg); |
| } |
| } |
| } |
| |
| int wilc_remain_on_channel(struct wilc_vif *vif, u64 cookie, |
| u32 duration, u16 chan, |
| void (*expired)(void *, u64), |
| void *user_arg) |
| { |
| struct wilc_remain_ch roc; |
| int result; |
| |
| roc.ch = chan; |
| roc.expired = expired; |
| roc.arg = user_arg; |
| roc.duration = duration; |
| roc.cookie = cookie; |
| result = handle_remain_on_chan(vif, &roc); |
| if (result) |
| netdev_err(vif->ndev, "%s: failed to set remain on channel\n", |
| __func__); |
| |
| return result; |
| } |
| |
| int wilc_listen_state_expired(struct wilc_vif *vif, u64 cookie) |
| { |
| int result; |
| struct host_if_msg *msg; |
| struct host_if_drv *hif_drv = vif->hif_drv; |
| |
| if (!hif_drv) { |
| netdev_err(vif->ndev, "%s: hif driver is NULL", __func__); |
| return -EFAULT; |
| } |
| |
| del_timer(&hif_drv->remain_on_ch_timer); |
| |
| msg = wilc_alloc_work(vif, handle_listen_state_expired, false); |
| if (IS_ERR(msg)) |
| return PTR_ERR(msg); |
| |
| msg->body.remain_on_ch.cookie = cookie; |
| |
| result = wilc_enqueue_work(msg); |
| if (result) { |
| netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__); |
| kfree(msg); |
| } |
| |
| return result; |
| } |
| |
| void wilc_frame_register(struct wilc_vif *vif, u16 frame_type, bool reg) |
| { |
| struct wid wid; |
| int result; |
| struct wilc_reg_frame reg_frame; |
| |
| wid.id = WID_REGISTER_FRAME; |
| wid.type = WID_STR; |
| wid.size = sizeof(reg_frame); |
| wid.val = (u8 *)®_frame; |
| |
| memset(®_frame, 0x0, sizeof(reg_frame)); |
| reg_frame.reg = reg; |
| |
| switch (frame_type) { |
| case IEEE80211_STYPE_ACTION: |
| reg_frame.reg_id = WILC_FW_ACTION_FRM_IDX; |
| break; |
| |
| case IEEE80211_STYPE_PROBE_REQ: |
| reg_frame.reg_id = WILC_FW_PROBE_REQ_IDX; |
| break; |
| |
| default: |
| break; |
| } |
| reg_frame.frame_type = cpu_to_le16(frame_type); |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to frame register\n"); |
| } |
| |
| int wilc_add_beacon(struct wilc_vif *vif, u32 interval, u32 dtim_period, |
| struct cfg80211_beacon_data *params) |
| { |
| struct wid wid; |
| int result; |
| u8 *cur_byte; |
| |
| wid.id = WID_ADD_BEACON; |
| wid.type = WID_BIN; |
| wid.size = params->head_len + params->tail_len + 16; |
| wid.val = kzalloc(wid.size, GFP_KERNEL); |
| if (!wid.val) |
| return -ENOMEM; |
| |
| cur_byte = wid.val; |
| put_unaligned_le32(interval, cur_byte); |
| cur_byte += 4; |
| put_unaligned_le32(dtim_period, cur_byte); |
| cur_byte += 4; |
| put_unaligned_le32(params->head_len, cur_byte); |
| cur_byte += 4; |
| |
| if (params->head_len > 0) |
| memcpy(cur_byte, params->head, params->head_len); |
| cur_byte += params->head_len; |
| |
| put_unaligned_le32(params->tail_len, cur_byte); |
| cur_byte += 4; |
| |
| if (params->tail_len > 0) |
| memcpy(cur_byte, params->tail, params->tail_len); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to send add beacon\n"); |
| |
| kfree(wid.val); |
| |
| return result; |
| } |
| |
| int wilc_del_beacon(struct wilc_vif *vif) |
| { |
| int result; |
| struct wid wid; |
| u8 del_beacon = 0; |
| |
| wid.id = WID_DEL_BEACON; |
| wid.type = WID_CHAR; |
| wid.size = sizeof(char); |
| wid.val = &del_beacon; |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to send delete beacon\n"); |
| |
| return result; |
| } |
| |
| int wilc_add_station(struct wilc_vif *vif, const u8 *mac, |
| struct station_parameters *params) |
| { |
| struct wid wid; |
| int result; |
| u8 *cur_byte; |
| |
| wid.id = WID_ADD_STA; |
| wid.type = WID_BIN; |
| wid.size = WILC_ADD_STA_LENGTH + params->supported_rates_len; |
| wid.val = kmalloc(wid.size, GFP_KERNEL); |
| if (!wid.val) |
| return -ENOMEM; |
| |
| cur_byte = wid.val; |
| wilc_hif_pack_sta_param(cur_byte, mac, params); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result != 0) |
| netdev_err(vif->ndev, "Failed to send add station\n"); |
| |
| kfree(wid.val); |
| |
| return result; |
| } |
| |
| int wilc_del_station(struct wilc_vif *vif, const u8 *mac_addr) |
| { |
| struct wid wid; |
| int result; |
| |
| wid.id = WID_REMOVE_STA; |
| wid.type = WID_BIN; |
| wid.size = ETH_ALEN; |
| wid.val = kzalloc(wid.size, GFP_KERNEL); |
| if (!wid.val) |
| return -ENOMEM; |
| |
| if (!mac_addr) |
| eth_broadcast_addr(wid.val); |
| else |
| ether_addr_copy(wid.val, mac_addr); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to del station\n"); |
| |
| kfree(wid.val); |
| |
| return result; |
| } |
| |
| int wilc_del_allstation(struct wilc_vif *vif, u8 mac_addr[][ETH_ALEN]) |
| { |
| struct wid wid; |
| int result; |
| int i; |
| u8 assoc_sta = 0; |
| struct wilc_del_all_sta del_sta; |
| |
| memset(&del_sta, 0x0, sizeof(del_sta)); |
| for (i = 0; i < WILC_MAX_NUM_STA; i++) { |
| if (!is_zero_ether_addr(mac_addr[i])) { |
| assoc_sta++; |
| ether_addr_copy(del_sta.mac[i], mac_addr[i]); |
| } |
| } |
| |
| if (!assoc_sta) |
| return 0; |
| |
| del_sta.assoc_sta = assoc_sta; |
| |
| wid.id = WID_DEL_ALL_STA; |
| wid.type = WID_STR; |
| wid.size = (assoc_sta * ETH_ALEN) + 1; |
| wid.val = (u8 *)&del_sta; |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to send delete all station\n"); |
| |
| return result; |
| } |
| |
| int wilc_edit_station(struct wilc_vif *vif, const u8 *mac, |
| struct station_parameters *params) |
| { |
| struct wid wid; |
| int result; |
| u8 *cur_byte; |
| |
| wid.id = WID_EDIT_STA; |
| wid.type = WID_BIN; |
| wid.size = WILC_ADD_STA_LENGTH + params->supported_rates_len; |
| wid.val = kmalloc(wid.size, GFP_KERNEL); |
| if (!wid.val) |
| return -ENOMEM; |
| |
| cur_byte = wid.val; |
| wilc_hif_pack_sta_param(cur_byte, mac, params); |
| |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to send edit station\n"); |
| |
| kfree(wid.val); |
| return result; |
| } |
| |
| int wilc_set_power_mgmt(struct wilc_vif *vif, bool enabled, u32 timeout) |
| { |
| struct wid wid; |
| int result; |
| s8 power_mode; |
| |
| if (wilc_wlan_get_num_conn_ifcs(vif->wilc) == 2 && enabled) |
| return 0; |
| |
| if (enabled) |
| power_mode = WILC_FW_MIN_FAST_PS; |
| else |
| power_mode = WILC_FW_NO_POWERSAVE; |
| |
| wid.id = WID_POWER_MANAGEMENT; |
| wid.val = &power_mode; |
| wid.size = sizeof(char); |
| result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| if (result) |
| netdev_err(vif->ndev, "Failed to send power management\n"); |
| |
| return result; |
| } |
| |
| int wilc_setup_multicast_filter(struct wilc_vif *vif, u32 enabled, u32 count, |
| u8 *mc_list) |
| { |
| int result; |
| struct host_if_msg *msg; |
| |
| msg = wilc_alloc_work(vif, handle_set_mcast_filter, false); |
| if (IS_ERR(msg)) |
| return PTR_ERR(msg); |
| |
| msg->body.mc_info.enabled = enabled; |
| msg->body.mc_info.cnt = count; |
| msg->body.mc_info.mc_list = mc_list; |
| |
| result = wilc_enqueue_work(msg); |
| if (result) { |
| netdev_err(vif->ndev, "%s: enqueue work failed\n", __func__); |
| kfree(msg); |
| } |
| return result; |
| } |
| |
| int wilc_set_tx_power(struct wilc_vif *vif, u8 tx_power) |
| { |
| int ret; |
| struct wid wid; |
| |
| wid.id = WID_TX_POWER; |
| wid.type = WID_CHAR; |
| wid.val = &tx_power; |
| wid.size = sizeof(char); |
| |
| ret = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| |
| return ret; |
| } |
| |
| int wilc_get_tx_power(struct wilc_vif *vif, u8 *tx_power) |
| { |
| int ret; |
| struct wid wid; |
| |
| wid.id = WID_TX_POWER; |
| wid.type = WID_CHAR; |
| wid.val = tx_power; |
| wid.size = sizeof(char); |
| |
| ret = wilc_send_config_pkt(vif, WILC_GET_CFG, &wid, 1, |
| wilc_get_vif_idx(vif)); |
| |
| return ret; |
| } |