static int qtnf_change_beacon(struct wiphy *wiphy, struct net_device *dev, struct cfg80211_beacon_data *info) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); return qtnf_mgmt_set_appie(vif, info); }
void qtnf_virtual_intf_cleanup(struct net_device *ndev) { struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); struct qtnf_wmac *mac = wiphy_priv(vif->wdev.wiphy); if (vif->wdev.iftype == NL80211_IFTYPE_STATION) { switch (vif->sta_state) { case QTNF_STA_DISCONNECTED: break; case QTNF_STA_CONNECTING: cfg80211_connect_result(vif->netdev, vif->bss_cfg.bssid, NULL, 0, NULL, 0, WLAN_STATUS_UNSPECIFIED_FAILURE, GFP_KERNEL); qtnf_disconnect(vif->wdev.wiphy, ndev, WLAN_REASON_DEAUTH_LEAVING); break; case QTNF_STA_CONNECTED: cfg80211_disconnected(vif->netdev, WLAN_REASON_DEAUTH_LEAVING, NULL, 0, 1, GFP_KERNEL); qtnf_disconnect(vif->wdev.wiphy, ndev, WLAN_REASON_DEAUTH_LEAVING); break; } vif->sta_state = QTNF_STA_DISCONNECTED; qtnf_scan_done(mac, true); } }
static int qtnf_change_virtual_intf(struct wiphy *wiphy, struct net_device *dev, enum nl80211_iftype type, struct vif_params *params) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); u8 *mac_addr; int ret; if (params) mac_addr = params->macaddr; else mac_addr = NULL; qtnf_scan_done(vif->mac, true); ret = qtnf_cmd_send_change_intf_type(vif, type, mac_addr); if (ret) { pr_err("VIF%u.%u: failed to change VIF type: %d\n", vif->mac->macid, vif->vifid, ret); return ret; } vif->wdev.iftype = type; return 0; }
int qtnf_del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev) { struct net_device *netdev = wdev->netdev; struct qtnf_vif *vif; if (WARN_ON(!netdev)) return -EFAULT; vif = qtnf_netdev_get_priv(wdev->netdev); if (qtnf_cmd_send_del_intf(vif)) pr_err("VIF%u.%u: failed to delete VIF\n", vif->mac->macid, vif->vifid); /* Stop data */ netif_tx_stop_all_queues(netdev); if (netif_carrier_ok(netdev)) netif_carrier_off(netdev); if (netdev->reg_state == NETREG_REGISTERED) unregister_netdevice(netdev); vif->netdev->ieee80211_ptr = NULL; vif->netdev = NULL; vif->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED; eth_zero_addr(vif->mac_addr); return 0; }
void qtnf_netdev_updown(struct net_device *ndev, bool up) { struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); if (qtnf_cmd_send_updown_intf(vif, up)) pr_err("failed to send up/down command to FW\n"); }
static int qtnf_get_channel(struct wiphy *wiphy, struct wireless_dev *wdev, struct cfg80211_chan_def *chandef) { struct net_device *ndev = wdev->netdev; struct qtnf_vif *vif; int ret; if (!ndev) return -ENODEV; vif = qtnf_netdev_get_priv(wdev->netdev); ret = qtnf_cmd_get_channel(vif, chandef); if (ret) { pr_err("%s: failed to get channel: %d\n", ndev->name, ret); goto out; } if (!cfg80211_chandef_valid(chandef)) { pr_err("%s: bad chan freq1=%u freq2=%u bw=%u\n", ndev->name, chandef->center_freq1, chandef->center_freq2, chandef->width); ret = -ENODATA; } out: return ret; }
static int qtnf_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev, struct cfg80211_mgmt_tx_params *params, u64 *cookie) { struct qtnf_vif *vif = qtnf_netdev_get_priv(wdev->netdev); const struct ieee80211_mgmt *mgmt_frame = (void *)params->buf; u32 short_cookie = prandom_u32(); u16 flags = 0; *cookie = short_cookie; if (params->offchan) flags |= QLINK_MGMT_FRAME_TX_FLAG_OFFCHAN; if (params->no_cck) flags |= QLINK_MGMT_FRAME_TX_FLAG_NO_CCK; if (params->dont_wait_for_ack) flags |= QLINK_MGMT_FRAME_TX_FLAG_ACK_NOWAIT; pr_debug("%s freq:%u; FC:%.4X; DA:%pM; len:%zu; C:%.8X; FL:%.4X\n", wdev->netdev->name, params->chan->center_freq, le16_to_cpu(mgmt_frame->frame_control), mgmt_frame->da, params->len, short_cookie, flags); return qtnf_cmd_send_mgmt_frame(vif, short_cookie, flags, params->chan->center_freq, params->buf, params->len); }
static int qtnf_connect(struct wiphy *wiphy, struct net_device *dev, struct cfg80211_connect_params *sme) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; if (vif->wdev.iftype != NL80211_IFTYPE_STATION) return -EOPNOTSUPP; if (vif->sta_state != QTNF_STA_DISCONNECTED) return -EBUSY; if (sme->bssid) ether_addr_copy(vif->bssid, sme->bssid); else eth_zero_addr(vif->bssid); ret = qtnf_cmd_send_connect(vif, sme); if (ret) { pr_err("VIF%u.%u: failed to connect\n", vif->mac->macid, vif->vifid); return ret; } vif->sta_state = QTNF_STA_CONNECTING; return 0; }
static int qtnf_dump_station(struct wiphy *wiphy, struct net_device *dev, int idx, u8 *mac, struct station_info *sinfo) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); const struct qtnf_sta_node *sta_node; int ret; sta_node = qtnf_sta_list_lookup_index(&vif->sta_list, idx); if (unlikely(!sta_node)) return -ENOENT; ether_addr_copy(mac, sta_node->mac_addr); ret = qtnf_cmd_get_sta_info(vif, sta_node->mac_addr, sinfo); if (unlikely(ret == -ENOENT)) { qtnf_sta_list_del(&vif->sta_list, mac); cfg80211_del_sta(vif->netdev, mac, GFP_KERNEL); sinfo->filled = 0; } return ret; }
static int qtnf_get_station(struct wiphy *wiphy, struct net_device *dev, const u8 *mac, struct station_info *sinfo) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); return qtnf_cmd_get_sta_info(vif, mac, sinfo); }
static int qtnf_change_beacon(struct wiphy *wiphy, struct net_device *dev, struct cfg80211_beacon_data *info) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); if (!(vif->bss_status & QTNF_STATE_AP_START)) { pr_err("VIF%u.%u: not started\n", vif->mac->macid, vif->vifid); return -EFAULT; } return qtnf_mgmt_set_appie(vif, info); }
static int qtnf_channel_switch(struct wiphy *wiphy, struct net_device *dev, struct cfg80211_csa_settings *params) { struct qtnf_wmac *mac = wiphy_priv(wiphy); struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; pr_debug("%s: chan(%u) count(%u) radar(%u) block_tx(%u)\n", dev->name, params->chandef.chan->hw_value, params->count, params->radar_required, params->block_tx); switch (vif->wdev.iftype) { case NL80211_IFTYPE_AP: if (!(vif->bss_status & QTNF_STATE_AP_START)) { pr_warn("AP not started on %s\n", dev->name); return -ENOTCONN; } break; default: pr_err("unsupported vif type (%d) on %s\n", vif->wdev.iftype, dev->name); return -EOPNOTSUPP; } if (vif->vifid != 0) { if (!(mac->status & QTNF_MAC_CSA_ACTIVE)) return -EOPNOTSUPP; if (!cfg80211_chandef_identical(¶ms->chandef, &mac->csa_chandef)) return -EINVAL; return 0; } if (!cfg80211_chandef_valid(¶ms->chandef)) { pr_err("%s: invalid channel\n", dev->name); return -EINVAL; } if (cfg80211_chandef_identical(¶ms->chandef, &mac->chandef)) { pr_err("%s: switch request to the same channel\n", dev->name); return -EALREADY; } ret = qtnf_cmd_send_chan_switch(mac, params); if (ret) pr_warn("%s: failed to switch to channel (%u)\n", dev->name, params->chandef.chan->hw_value); return ret; }
static int qtnf_start_ap(struct wiphy *wiphy, struct net_device *dev, struct cfg80211_ap_settings *settings) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; ret = qtnf_cmd_send_start_ap(vif, settings); if (ret) pr_err("VIF%u.%u: failed to start AP\n", vif->mac->macid, vif->vifid); return ret; }
static int qtnf_del_key(struct wiphy *wiphy, struct net_device *dev, u8 key_index, bool pairwise, const u8 *mac_addr) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; ret = qtnf_cmd_send_del_key(vif, key_index, pairwise, mac_addr); if (ret) pr_err("VIF%u.%u: failed to delete key: idx=%u pw=%u\n", vif->mac->macid, vif->vifid, key_index, pairwise); return ret; }
static void qtnf_mgmt_frame_register(struct wiphy *wiphy, struct wireless_dev *wdev, u16 frame_type, bool reg) { struct qtnf_vif *vif = qtnf_netdev_get_priv(wdev->netdev); u16 mgmt_type; u16 new_mask; u16 qlink_frame_type = 0; mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4; if (reg) new_mask = vif->mgmt_frames_bitmask | BIT(mgmt_type); else new_mask = vif->mgmt_frames_bitmask & ~BIT(mgmt_type); if (new_mask == vif->mgmt_frames_bitmask) return; switch (frame_type & IEEE80211_FCTL_STYPE) { case IEEE80211_STYPE_REASSOC_REQ: case IEEE80211_STYPE_ASSOC_REQ: qlink_frame_type = QLINK_MGMT_FRAME_ASSOC_REQ; break; case IEEE80211_STYPE_AUTH: qlink_frame_type = QLINK_MGMT_FRAME_AUTH; break; case IEEE80211_STYPE_PROBE_REQ: qlink_frame_type = QLINK_MGMT_FRAME_PROBE_REQ; break; case IEEE80211_STYPE_ACTION: qlink_frame_type = QLINK_MGMT_FRAME_ACTION; break; default: pr_warn("VIF%u.%u: unsupported frame type: %X\n", vif->mac->macid, vif->vifid, (frame_type & IEEE80211_FCTL_STYPE) >> 4); return; } if (qtnf_cmd_send_register_mgmt(vif, qlink_frame_type, reg)) { pr_warn("VIF%u.%u: failed to %sregister mgmt frame type 0x%x\n", vif->mac->macid, vif->vifid, reg ? "" : "un", frame_type); return; } vif->mgmt_frames_bitmask = new_mask; pr_debug("VIF%u.%u: %sregistered mgmt frame type 0x%x\n", vif->mac->macid, vif->vifid, reg ? "" : "un", frame_type); }
static int qtnf_change_station(struct wiphy *wiphy, struct net_device *dev, const u8 *mac, struct station_parameters *params) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; ret = qtnf_cmd_send_change_sta(vif, mac, params); if (ret) pr_err("VIF%u.%u: failed to change STA %pM\n", vif->mac->macid, vif->vifid, mac); return ret; }
static int qtnf_set_default_mgmt_key(struct wiphy *wiphy, struct net_device *dev, u8 key_index) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; ret = qtnf_cmd_send_set_default_mgmt_key(vif, key_index); if (ret) pr_err("VIF%u.%u: failed to set default MGMT key: idx=%u\n", vif->mac->macid, vif->vifid, key_index); return ret; }
static int qtnf_set_default_key(struct wiphy *wiphy, struct net_device *dev, u8 key_index, bool unicast, bool multicast) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; ret = qtnf_cmd_send_set_default_key(vif, key_index, unicast, multicast); if (ret) pr_err("VIF%u.%u: failed to set dflt key: idx=%u uc=%u mc=%u\n", vif->mac->macid, vif->vifid, key_index, unicast, multicast); return ret; }
static int qtnf_add_key(struct wiphy *wiphy, struct net_device *dev, u8 key_index, bool pairwise, const u8 *mac_addr, struct key_params *params) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; ret = qtnf_cmd_send_add_key(vif, key_index, pairwise, mac_addr, params); if (ret) pr_err("VIF%u.%u: failed to add key: cipher=%x idx=%u pw=%u\n", vif->mac->macid, vif->vifid, params->cipher, key_index, pairwise); return ret; }
static int qtnf_stop_ap(struct wiphy *wiphy, struct net_device *dev) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; ret = qtnf_cmd_send_stop_ap(vif); if (ret) { pr_err("VIF%u.%u: failed to stop AP operation in FW\n", vif->mac->macid, vif->vifid); vif->bss_status &= ~QTNF_STATE_AP_START; vif->bss_status &= ~QTNF_STATE_AP_CONFIG; netif_carrier_off(vif->netdev); } return ret; }
static int qtnf_stop_ap(struct wiphy *wiphy, struct net_device *dev) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; qtnf_scan_done(vif->mac, true); ret = qtnf_cmd_send_stop_ap(vif); if (ret) { pr_err("VIF%u.%u: failed to stop AP operation in FW\n", vif->mac->macid, vif->vifid); netif_carrier_off(vif->netdev); } return ret; }
static int qtnf_del_station(struct wiphy *wiphy, struct net_device *dev, struct station_del_parameters *params) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; if (params->mac && (vif->wdev.iftype == NL80211_IFTYPE_AP) && !is_broadcast_ether_addr(params->mac) && !qtnf_sta_list_lookup(&vif->sta_list, params->mac)) return 0; ret = qtnf_cmd_send_del_sta(vif, params); if (ret) pr_err("VIF%u.%u: failed to delete STA %pM\n", vif->mac->macid, vif->vifid, params->mac); return ret; }
/* Netdev handler for data transmission. */ static int qtnf_netdev_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev) { struct qtnf_vif *vif; struct qtnf_wmac *mac; vif = qtnf_netdev_get_priv(ndev); if (unlikely(skb->dev != ndev)) { pr_err_ratelimited("invalid skb->dev"); dev_kfree_skb_any(skb); return 0; } if (unlikely(vif->wdev.iftype == NL80211_IFTYPE_UNSPECIFIED)) { pr_err_ratelimited("%s: VIF not initialized\n", ndev->name); dev_kfree_skb_any(skb); return 0; } mac = vif->mac; if (unlikely(!mac)) { pr_err_ratelimited("%s: NULL mac pointer", ndev->name); dev_kfree_skb_any(skb); return 0; } if (!skb->len || (skb->len > ETH_FRAME_LEN)) { pr_err_ratelimited("%s: invalid skb len %d\n", ndev->name, skb->len); dev_kfree_skb_any(skb); ndev->stats.tx_dropped++; return 0; } /* tx path is enabled: reset vif timeout */ vif->cons_tx_timeout_cnt = 0; return qtnf_bus_data_tx(mac->bus, skb); }
static int qtnf_channel_switch(struct wiphy *wiphy, struct net_device *dev, struct cfg80211_csa_settings *params) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); int ret; pr_debug("%s: chan(%u) count(%u) radar(%u) block_tx(%u)\n", dev->name, params->chandef.chan->hw_value, params->count, params->radar_required, params->block_tx); if (!cfg80211_chandef_valid(¶ms->chandef)) { pr_err("%s: invalid channel\n", dev->name); return -EINVAL; } ret = qtnf_cmd_send_chan_switch(vif, params); if (ret) pr_warn("%s: failed to switch to channel (%u)\n", dev->name, params->chandef.chan->hw_value); return ret; }
static int qtnf_get_channel(struct wiphy *wiphy, struct wireless_dev *wdev, struct cfg80211_chan_def *chandef) { struct qtnf_wmac *mac = wiphy_priv(wiphy); struct net_device *ndev = wdev->netdev; struct qtnf_vif *vif; if (!ndev) return -ENODEV; vif = qtnf_netdev_get_priv(wdev->netdev); switch (vif->wdev.iftype) { case NL80211_IFTYPE_STATION: if (vif->sta_state == QTNF_STA_DISCONNECTED) { pr_warn("%s: STA disconnected\n", ndev->name); return -ENODATA; } break; case NL80211_IFTYPE_AP: if (!(vif->bss_status & QTNF_STATE_AP_START)) { pr_warn("%s: AP not started\n", ndev->name); return -ENODATA; } break; default: pr_err("unsupported vif type (%d)\n", vif->wdev.iftype); return -ENODATA; } if (!cfg80211_chandef_valid(&mac->chandef)) { pr_err("invalid channel settings on %s\n", ndev->name); return -ENODATA; } memcpy(chandef, &mac->chandef, sizeof(*chandef)); return 0; }
/* Netdev handler for transmission timeout. */ static void qtnf_netdev_tx_timeout(struct net_device *ndev) { struct qtnf_vif *vif = qtnf_netdev_get_priv(ndev); struct qtnf_wmac *mac; struct qtnf_bus *bus; if (unlikely(!vif || !vif->mac || !vif->mac->bus)) return; mac = vif->mac; bus = mac->bus; pr_warn("VIF%u.%u: Tx timeout- %lu\n", mac->macid, vif->vifid, jiffies); qtnf_bus_data_tx_timeout(bus, ndev); ndev->stats.tx_errors++; if (++vif->cons_tx_timeout_cnt > QTNF_TX_TIMEOUT_TRSHLD) { pr_err("Tx timeout threshold exceeded !\n"); pr_err("schedule interface %s reset !\n", netdev_name(ndev)); queue_work(bus->workqueue, &vif->reset_work); } }
static int qtnf_connect(struct wiphy *wiphy, struct net_device *dev, struct cfg80211_connect_params *sme) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); struct qtnf_wmac *mac = wiphy_priv(wiphy); struct cfg80211_chan_def chandef; struct qtnf_bss_config *bss_cfg; int ret; if (vif->wdev.iftype != NL80211_IFTYPE_STATION) return -EOPNOTSUPP; if (vif->sta_state != QTNF_STA_DISCONNECTED) return -EBUSY; bss_cfg = &vif->bss_cfg; memset(bss_cfg, 0, sizeof(*bss_cfg)); if (sme->channel) { /* FIXME: need to set proper nl80211_channel_type value */ cfg80211_chandef_create(&chandef, sme->channel, NL80211_CHAN_HT20); /* fall-back to minimal safe chandef description */ if (!cfg80211_chandef_valid(&chandef)) cfg80211_chandef_create(&chandef, sme->channel, NL80211_CHAN_HT20); memcpy(&mac->chandef, &chandef, sizeof(mac->chandef)); } bss_cfg->ssid_len = sme->ssid_len; memcpy(&bss_cfg->ssid, sme->ssid, bss_cfg->ssid_len); bss_cfg->auth_type = sme->auth_type; bss_cfg->privacy = sme->privacy; bss_cfg->mfp = sme->mfp; if ((sme->bg_scan_period > 0) && (sme->bg_scan_period <= QTNF_MAX_BG_SCAN_PERIOD)) bss_cfg->bg_scan_period = sme->bg_scan_period; else if (sme->bg_scan_period == -1) bss_cfg->bg_scan_period = QTNF_DEFAULT_BG_SCAN_PERIOD; else bss_cfg->bg_scan_period = 0; /* disabled */ bss_cfg->connect_flags = 0; if (sme->flags & ASSOC_REQ_DISABLE_HT) bss_cfg->connect_flags |= QLINK_STA_CONNECT_DISABLE_HT; if (sme->flags & ASSOC_REQ_DISABLE_VHT) bss_cfg->connect_flags |= QLINK_STA_CONNECT_DISABLE_VHT; if (sme->flags & ASSOC_REQ_USE_RRM) bss_cfg->connect_flags |= QLINK_STA_CONNECT_USE_RRM; memcpy(&bss_cfg->crypto, &sme->crypto, sizeof(bss_cfg->crypto)); if (sme->bssid) ether_addr_copy(bss_cfg->bssid, sme->bssid); else eth_zero_addr(bss_cfg->bssid); ret = qtnf_cmd_send_connect(vif, sme); if (ret) { pr_err("VIF%u.%u: failed to connect\n", vif->mac->macid, vif->vifid); return ret; } vif->sta_state = QTNF_STA_CONNECTING; return 0; }
static int qtnf_start_ap(struct wiphy *wiphy, struct net_device *dev, struct cfg80211_ap_settings *settings) { struct qtnf_vif *vif = qtnf_netdev_get_priv(dev); struct qtnf_wmac *mac = wiphy_priv(wiphy); struct qtnf_bss_config *bss_cfg; int ret; if (!cfg80211_chandef_identical(&mac->chandef, &settings->chandef)) { memcpy(&mac->chandef, &settings->chandef, sizeof(mac->chandef)); if (vif->vifid != 0) pr_warn("%s: unexpected chan %u (%u MHz)\n", dev->name, settings->chandef.chan->hw_value, settings->chandef.chan->center_freq); } bss_cfg = &vif->bss_cfg; memset(bss_cfg, 0, sizeof(*bss_cfg)); bss_cfg->bcn_period = settings->beacon_interval; bss_cfg->dtim = settings->dtim_period; bss_cfg->auth_type = settings->auth_type; bss_cfg->privacy = settings->privacy; bss_cfg->ssid_len = settings->ssid_len; memcpy(&bss_cfg->ssid, settings->ssid, bss_cfg->ssid_len); memcpy(&bss_cfg->crypto, &settings->crypto, sizeof(struct cfg80211_crypto_settings)); ret = qtnf_cmd_send_config_ap(vif); if (ret) { pr_err("VIF%u.%u: failed to push config to FW\n", vif->mac->macid, vif->vifid); goto out; } if (!(vif->bss_status & QTNF_STATE_AP_CONFIG)) { pr_err("VIF%u.%u: AP config failed in FW\n", vif->mac->macid, vif->vifid); ret = -EFAULT; goto out; } ret = qtnf_mgmt_set_appie(vif, &settings->beacon); if (ret) { pr_err("VIF%u.%u: failed to add IEs to beacon\n", vif->mac->macid, vif->vifid); goto out; } ret = qtnf_cmd_send_start_ap(vif); if (ret) { pr_err("VIF%u.%u: failed to start AP\n", vif->mac->macid, vif->vifid); goto out; } if (!(vif->bss_status & QTNF_STATE_AP_START)) { pr_err("VIF%u.%u: FW failed to start AP operation\n", vif->mac->macid, vif->vifid); ret = -EFAULT; } out: return ret; }
static int qtnf_dump_survey(struct wiphy *wiphy, struct net_device *dev, int idx, struct survey_info *survey) { struct qtnf_wmac *mac = wiphy_priv(wiphy); struct ieee80211_supported_band *sband; struct cfg80211_chan_def *chandef; struct ieee80211_channel *chan; struct qtnf_chan_stats stats; struct qtnf_vif *vif; int ret; vif = qtnf_netdev_get_priv(dev); chandef = &mac->chandef; sband = wiphy->bands[NL80211_BAND_2GHZ]; if (sband && idx >= sband->n_channels) { idx -= sband->n_channels; sband = NULL; } if (!sband) sband = wiphy->bands[NL80211_BAND_5GHZ]; if (!sband || idx >= sband->n_channels) return -ENOENT; chan = &sband->channels[idx]; memset(&stats, 0, sizeof(stats)); survey->channel = chan; survey->filled = 0x0; if (chandef->chan) { if (chan->hw_value == chandef->chan->hw_value) survey->filled = SURVEY_INFO_IN_USE; } ret = qtnf_cmd_get_chan_stats(mac, chan->hw_value, &stats); switch (ret) { case 0: if (unlikely(stats.chan_num != chan->hw_value)) { pr_err("received stats for channel %d instead of %d\n", stats.chan_num, chan->hw_value); ret = -EINVAL; break; } survey->filled |= SURVEY_INFO_TIME | SURVEY_INFO_TIME_SCAN | SURVEY_INFO_TIME_BUSY | SURVEY_INFO_TIME_RX | SURVEY_INFO_TIME_TX | SURVEY_INFO_NOISE_DBM; survey->time_scan = stats.cca_try; survey->time = stats.cca_try; survey->time_tx = stats.cca_tx; survey->time_rx = stats.cca_rx; survey->time_busy = stats.cca_busy; survey->noise = stats.chan_noise; break; case -ENOENT: pr_debug("no stats for channel %u\n", chan->hw_value); ret = 0; break; default: pr_debug("failed to get chan(%d) stats from card\n", chan->hw_value); ret = -EINVAL; break; } return ret; }