LCOV - code coverage report
Current view: top level - src/ap - ieee802_11_vht.c (source / functions) Hit Total Coverage
Test: hostapd hwsim test run 1388167526 Lines: 17 76 22.4 %
Date: 2013-12-27 Functions: 3 4 75.0 %
Branches: 3 41 7.3 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * hostapd / IEEE 802.11ac VHT
       3                 :            :  * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi>
       4                 :            :  *
       5                 :            :  * This program is free software; you can redistribute it and/or modify
       6                 :            :  * it under the terms of BSD license
       7                 :            :  *
       8                 :            :  * See README and COPYING for more details.
       9                 :            :  */
      10                 :            : 
      11                 :            : #include "utils/includes.h"
      12                 :            : 
      13                 :            : #include "utils/common.h"
      14                 :            : #include "common/ieee802_11_defs.h"
      15                 :            : #include "hostapd.h"
      16                 :            : #include "ap_config.h"
      17                 :            : #include "sta_info.h"
      18                 :            : #include "beacon.h"
      19                 :            : #include "ieee802_11.h"
      20                 :            : 
      21                 :            : 
      22                 :       1233 : u8 * hostapd_eid_vht_capabilities(struct hostapd_data *hapd, u8 *eid)
      23                 :            : {
      24                 :            :         struct ieee80211_vht_capabilities *cap;
      25                 :       1233 :         u8 *pos = eid;
      26                 :            : 
      27 [ -  + ][ #  # ]:       1233 :         if (!hapd->iconf->ieee80211ac || !hapd->iface->current_mode ||
                 [ #  # ]
      28                 :          0 :             hapd->conf->disable_11ac)
      29                 :       1233 :                 return eid;
      30                 :            : 
      31                 :          0 :         *pos++ = WLAN_EID_VHT_CAP;
      32                 :          0 :         *pos++ = sizeof(*cap);
      33                 :            : 
      34                 :          0 :         cap = (struct ieee80211_vht_capabilities *) pos;
      35                 :          0 :         os_memset(cap, 0, sizeof(*cap));
      36                 :          0 :         cap->vht_capabilities_info = host_to_le32(
      37                 :            :                 hapd->iface->conf->vht_capab);
      38                 :            : 
      39                 :            :         /* Supported MCS set comes from hw */
      40                 :          0 :         os_memcpy(&cap->vht_supported_mcs_set,
      41                 :            :                   hapd->iface->current_mode->vht_mcs_set, 8);
      42                 :            : 
      43                 :          0 :         pos += sizeof(*cap);
      44                 :            : 
      45                 :       1233 :         return pos;
      46                 :            : }
      47                 :            : 
      48                 :            : 
      49                 :       1233 : u8 * hostapd_eid_vht_operation(struct hostapd_data *hapd, u8 *eid)
      50                 :            : {
      51                 :            :         struct ieee80211_vht_operation *oper;
      52                 :       1233 :         u8 *pos = eid;
      53                 :            : 
      54 [ -  + ][ #  # ]:       1233 :         if (!hapd->iconf->ieee80211ac || hapd->conf->disable_11ac)
      55                 :       1233 :                 return eid;
      56                 :            : 
      57                 :          0 :         *pos++ = WLAN_EID_VHT_OPERATION;
      58                 :          0 :         *pos++ = sizeof(*oper);
      59                 :            : 
      60                 :          0 :         oper = (struct ieee80211_vht_operation *) pos;
      61                 :          0 :         os_memset(oper, 0, sizeof(*oper));
      62                 :            : 
      63                 :            :         /*
      64                 :            :          * center freq = 5 GHz + (5 * index)
      65                 :            :          * So index 42 gives center freq 5.210 GHz
      66                 :            :          * which is channel 42 in 5G band
      67                 :            :          */
      68                 :          0 :         oper->vht_op_info_chan_center_freq_seg0_idx =
      69                 :          0 :                 hapd->iconf->vht_oper_centr_freq_seg0_idx;
      70                 :          0 :         oper->vht_op_info_chan_center_freq_seg1_idx =
      71                 :          0 :                 hapd->iconf->vht_oper_centr_freq_seg1_idx;
      72                 :            : 
      73                 :          0 :         oper->vht_op_info_chwidth = hapd->iconf->vht_oper_chwidth;
      74                 :            : 
      75                 :            :         /* VHT Basic MCS set comes from hw */
      76                 :            :         /* Hard code 1 stream, MCS0-7 is a min Basic VHT MCS rates */
      77                 :          0 :         oper->vht_basic_mcs_set = host_to_le16(0xfffc);
      78                 :          0 :         pos += sizeof(*oper);
      79                 :            : 
      80                 :       1233 :         return pos;
      81                 :            : }
      82                 :            : 
      83                 :            : 
      84                 :        215 : u16 copy_sta_vht_capab(struct hostapd_data *hapd, struct sta_info *sta,
      85                 :            :                        const u8 *vht_capab, size_t vht_capab_len)
      86                 :            : {
      87                 :            :         /* Disable VHT caps for STAs associated to no-VHT BSSes. */
      88 [ -  + ][ #  # ]:        215 :         if (!vht_capab ||
      89         [ #  # ]:          0 :             vht_capab_len < sizeof(struct ieee80211_vht_capabilities) ||
      90                 :          0 :             hapd->conf->disable_11ac) {
      91                 :        215 :                 sta->flags &= ~WLAN_STA_VHT;
      92                 :        215 :                 os_free(sta->vht_capabilities);
      93                 :        215 :                 sta->vht_capabilities = NULL;
      94                 :        215 :                 return WLAN_STATUS_SUCCESS;
      95                 :            :         }
      96                 :            : 
      97         [ #  # ]:          0 :         if (sta->vht_capabilities == NULL) {
      98                 :          0 :                 sta->vht_capabilities =
      99                 :          0 :                         os_zalloc(sizeof(struct ieee80211_vht_capabilities));
     100         [ #  # ]:          0 :                 if (sta->vht_capabilities == NULL)
     101                 :          0 :                         return WLAN_STATUS_UNSPECIFIED_FAILURE;
     102                 :            :         }
     103                 :            : 
     104                 :          0 :         sta->flags |= WLAN_STA_VHT;
     105                 :          0 :         os_memcpy(sta->vht_capabilities, vht_capab,
     106                 :            :                   sizeof(struct ieee80211_vht_capabilities));
     107                 :            : 
     108                 :        215 :         return WLAN_STATUS_SUCCESS;
     109                 :            : }
     110                 :            : 
     111                 :          0 : void hostapd_get_vht_capab(struct hostapd_data *hapd,
     112                 :            :                            struct ieee80211_vht_capabilities *vht_cap,
     113                 :            :                            struct ieee80211_vht_capabilities *neg_vht_cap)
     114                 :            : {
     115                 :            :         u32 cap, own_cap, sym_caps;
     116                 :            : 
     117         [ #  # ]:          0 :         if (vht_cap == NULL)
     118                 :          0 :                 return;
     119                 :          0 :         os_memcpy(neg_vht_cap, vht_cap, sizeof(*neg_vht_cap));
     120                 :            : 
     121                 :          0 :         cap = le_to_host32(neg_vht_cap->vht_capabilities_info);
     122                 :          0 :         own_cap = hapd->iconf->vht_capab;
     123                 :            : 
     124                 :            :         /* mask out symmetric VHT capabilities we don't support */
     125                 :          0 :         sym_caps = VHT_CAP_SHORT_GI_80 | VHT_CAP_SHORT_GI_160;
     126                 :          0 :         cap &= ~sym_caps | (own_cap & sym_caps);
     127                 :            : 
     128                 :            :         /* mask out beamformer/beamformee caps if not supported */
     129         [ #  # ]:          0 :         if (!(own_cap & VHT_CAP_SU_BEAMFORMER_CAPABLE))
     130                 :          0 :                 cap &= ~(VHT_CAP_SU_BEAMFORMEE_CAPABLE |
     131                 :            :                          VHT_CAP_BEAMFORMEE_STS_MAX);
     132                 :            : 
     133         [ #  # ]:          0 :         if (!(own_cap & VHT_CAP_SU_BEAMFORMEE_CAPABLE))
     134                 :          0 :                 cap &= ~(VHT_CAP_SU_BEAMFORMER_CAPABLE |
     135                 :            :                          VHT_CAP_SOUNDING_DIMENSION_MAX);
     136                 :            : 
     137         [ #  # ]:          0 :         if (!(own_cap & VHT_CAP_MU_BEAMFORMER_CAPABLE))
     138                 :          0 :                 cap &= ~VHT_CAP_MU_BEAMFORMEE_CAPABLE;
     139                 :            : 
     140         [ #  # ]:          0 :         if (!(own_cap & VHT_CAP_MU_BEAMFORMEE_CAPABLE))
     141                 :          0 :                 cap &= ~VHT_CAP_MU_BEAMFORMER_CAPABLE;
     142                 :            : 
     143                 :            :         /* mask channel widths we don't support */
     144      [ #  #  # ]:          0 :         switch (own_cap & VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
     145                 :            :         case VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
     146                 :          0 :                 break;
     147                 :            :         case VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
     148         [ #  # ]:          0 :                 if (cap & VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) {
     149                 :          0 :                         cap &= ~VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ;
     150                 :          0 :                         cap |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
     151                 :            :                 }
     152                 :          0 :                 break;
     153                 :            :         default:
     154                 :          0 :                 cap &= ~VHT_CAP_SUPP_CHAN_WIDTH_MASK;
     155                 :          0 :                 break;
     156                 :            :         }
     157                 :            : 
     158         [ #  # ]:          0 :         if (!(cap & VHT_CAP_SUPP_CHAN_WIDTH_MASK))
     159                 :          0 :                 cap &= ~VHT_CAP_SHORT_GI_160;
     160                 :            : 
     161                 :            :         /*
     162                 :            :          * if we don't support RX STBC, mask out TX STBC in the STA's HT caps
     163                 :            :          * if we don't support TX STBC, mask out RX STBC in the STA's HT caps
     164                 :            :          */
     165         [ #  # ]:          0 :         if (!(own_cap & VHT_CAP_RXSTBC_MASK))
     166                 :          0 :                 cap &= ~VHT_CAP_TXSTBC;
     167         [ #  # ]:          0 :         if (!(own_cap & VHT_CAP_TXSTBC))
     168                 :          0 :                 cap &= ~VHT_CAP_RXSTBC_MASK;
     169                 :            : 
     170                 :          0 :         neg_vht_cap->vht_capabilities_info = host_to_le32(cap);
     171                 :            : }

Generated by: LCOV version 1.9