| /*- |
| * Copyright (c) 2001 Atsushi Onoe |
| * Copyright (c) 2002-2005 Sam Leffler, Errno Consulting |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * Alternatively, this software may be distributed under the terms of the |
| * GNU General Public License ("GPL") version 2 as published by the Free |
| * Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * $Id: ieee80211.c 2617 2007-07-26 14:38:46Z mrenzmann $ |
| */ |
| #ifndef EXPORT_SYMTAB |
| #define EXPORT_SYMTAB |
| #endif |
| |
| /* |
| * IEEE 802.11 generic handler |
| */ |
| #ifndef AUTOCONF_INCLUDED |
| #include <linux/config.h> |
| #endif |
| #include <linux/version.h> |
| #include <linux/module.h> |
| #include <linux/skbuff.h> |
| #include <linux/netdevice.h> |
| #include <linux/rtnetlink.h> /* XXX for rtnl_lock */ |
| |
| #include <asm/board/pm.h> |
| |
| #include "net80211/if_media.h" |
| |
| #include "net80211/ieee80211_var.h" |
| #include "net80211/_ieee80211.h" |
| #include "net80211/ieee80211_tpc.h" |
| |
| #include <qtn/qtn_buffers.h> |
| #include <qtn/qtn_global.h> |
| #include "../qdrv/qdrv_vap.h" |
| |
| const char *ieee80211_phymode_name[] = { |
| "auto", /* IEEE80211_MODE_AUTO */ |
| "11a", /* IEEE80211_MODE_11A */ |
| "11b", /* IEEE80211_MODE_11B */ |
| "11g", /* IEEE80211_MODE_11G */ |
| "FH", /* IEEE80211_MODE_FH */ |
| "turboA", /* IEEE80211_MODE_TURBO_A */ |
| "turboG", /* IEEE80211_MODE_TURBO_G */ |
| "11na", /* IEEE80211_MODE_11NA */ |
| "11ng", /* IEEE80211_MODE_11NG */ |
| "11ng40", /* IEEE80211_MODE_11NG_HT40PM */ |
| "11na40", /* IEEE80211_MODE_11NA_HT40PM */ |
| "11ac20", /* IEEE80211_MODE_11AC_VHT20PM */ |
| "11ac40", /* IEEE80211_MODE_11AC_VHT40PM */ |
| "11ac80", /* IEEE80211_MODE_11AC_VHT80PM */ |
| "11ac160", /* IEEE80211_MODE_11AC_VHT160PM */ |
| }; |
| EXPORT_SYMBOL(ieee80211_phymode_name); |
| |
| /* integer portion of HT rates */ |
| const u_int16_t ht_rate_table_20MHz_400[] = { |
| 7, |
| 14, |
| 21, |
| 28, |
| 43, |
| 57, |
| 65, |
| 72, |
| 14, |
| 28, |
| 43, |
| 57, |
| 86, |
| 115, |
| 130, |
| 144 |
| }; |
| |
| const u_int16_t ht_rate_table_20MHz_800[] = { |
| 6, |
| 13, |
| 19, |
| 26, |
| 39, |
| 52, |
| 58, |
| 65, |
| 13, |
| 26, |
| 39, |
| 52, |
| 78, |
| 104, |
| 117, |
| 130 |
| }; |
| |
| const u_int16_t ht_rate_table_40MHz_400[] = { |
| 15, |
| 30, |
| 45, |
| 60, |
| 90, |
| 120, |
| 135, |
| 150, |
| 30, |
| 60, |
| 90, |
| 120, |
| 180, |
| 240, |
| 270, |
| 300 |
| }; |
| |
| const u_int16_t ht_rate_table_40MHz_800[] = { |
| 13, |
| 27, |
| 40, |
| 54, |
| 81, |
| 108, |
| 121, |
| 135, |
| 27, |
| 54, |
| 81, |
| 108, |
| 162, |
| 216, |
| 243, |
| 270 |
| }; |
| |
| EXPORT_SYMBOL(ht_rate_table_40MHz_800); |
| EXPORT_SYMBOL(ht_rate_table_40MHz_400); |
| EXPORT_SYMBOL(ht_rate_table_20MHz_800); |
| EXPORT_SYMBOL(ht_rate_table_20MHz_400); |
| |
| /* Please update it when the definition of ieee80211_phymode changed */ |
| static const u_int ieee80211_chanflags[] = { |
| 0, /* IEEE80211_MODE_AUTO */ |
| IEEE80211_CHAN_A, /* IEEE80211_MODE_11A */ |
| IEEE80211_CHAN_B, /* IEEE80211_MODE_11B */ |
| IEEE80211_CHAN_PUREG, /* IEEE80211_MODE_11G */ |
| IEEE80211_CHAN_FHSS, /* IEEE80211_MODE_FH */ |
| IEEE80211_CHAN_108A, /* IEEE80211_MODE_TURBO_A */ |
| IEEE80211_CHAN_108G, /* IEEE80211_MODE_TURBO_G */ |
| IEEE80211_CHAN_11NA, /* IEEE80211_MODE_11NA */ |
| IEEE80211_CHAN_11NG, /* IEEE80211_MODE_11NG */ |
| IEEE80211_CHAN_11NG_HT40, /* IEEE80211_MODE_11NG_HT40PM */ |
| IEEE80211_CHAN_11NA_HT40, /* IEEE80211_MODE_11NA_HT40PM */ |
| IEEE80211_CHAN_11AC, |
| IEEE80211_CHAN_11AC_VHT40, |
| IEEE80211_CHAN_11AC_VHT80, |
| }; |
| |
| static void ieee80211com_media_status(void *, struct ifmediareq *); |
| static int ieee80211com_media_change(void *); |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0) |
| static struct rtnl_link_stats64 *ieee80211_getstats64(struct net_device *dev, struct rtnl_link_stats64 *stats64); |
| #else |
| static struct net_device_stats *ieee80211_getstats(struct net_device *); |
| #endif |
| static int ieee80211_change_mtu(struct net_device *, int); |
| static void ieee80211_set_multicast_list(struct net_device *); |
| |
| MALLOC_DEFINE(M_80211_VAP, "80211vap", "802.11 vap state"); |
| |
| /* |
| * Country Code Table for code-to-string conversion. |
| */ |
| struct country_code_to_string { |
| u_int16_t iso_code; |
| const char *iso_name; |
| }; |
| |
| static const struct country_code_to_string country_strings[] = { |
| {CTRY_DEBUG, "DB" }, |
| {CTRY_DEFAULT, "NA" }, |
| {CTRY_AFGHANISTAN, "AF" }, |
| {CTRY_ALBANIA, "AL" }, |
| {CTRY_ALGERIA, "DZ" }, |
| {CTRY_AMERICAN_SAMOA, "AS" }, |
| {CTRY_ANDORRA, "AD" }, |
| {CTRY_ANGOLA, "AO" }, |
| {CTRY_ANGUILLA, "AI" }, |
| {CTRY_ANTARTICA, "AQ" }, |
| {CTRY_ANTIGUA, "AG" }, |
| {CTRY_ARGENTINA, "AR" }, |
| {CTRY_ARMENIA, "AM" }, |
| {CTRY_ARUBA, "AW" }, |
| {CTRY_AUSTRALIA, "AU" }, |
| {CTRY_AUSTRIA, "AT" }, |
| {CTRY_AZERBAIJAN, "AZ" }, |
| {CTRY_BAHAMAS, "BS" }, |
| {CTRY_BAHRAIN, "BH" }, |
| {CTRY_BANGLADESH, "BD" }, |
| {CTRY_BARBADOS, "BB" }, |
| {CTRY_BELARUS, "BY" }, |
| {CTRY_BELGIUM, "BE" }, |
| {CTRY_BELIZE, "BZ" }, |
| {CTRY_BENIN, "BJ" }, |
| {CTRY_BERMUDA, "BM" }, |
| {CTRY_BHUTAN, "BT" }, |
| {CTRY_BOLIVIA, "BO" }, |
| {CTRY_BOSNIA_AND_HERZEGOWINA, "BA" }, |
| {CTRY_BOTSWANA, "BW" }, |
| {CTRY_BOUVET_ISLAND, "BV" }, |
| {CTRY_BRAZIL, "BR" }, |
| {CTRY_BRITISH_INDIAN_OCEAN_TERRITORY, "IO" }, |
| {CTRY_BRUNEI_DARUSSALAM, "BN" }, |
| {CTRY_BULGARIA, "BG" }, |
| {CTRY_BURKINA_FASO, "BF" }, |
| {CTRY_BURUNDI, "BI" }, |
| {CTRY_CAMBODIA, "KH" }, |
| {CTRY_CAMEROON, "CM" }, |
| {CTRY_CANADA, "CA" }, |
| {CTRY_CAPE_VERDE, "CV" }, |
| {CTRY_CAYMAN_ISLANDS, "KY" }, |
| {CTRY_CENTRAL_AFRICAN_REPUBLIC, "CF" }, |
| {CTRY_CHAD, "TD" }, |
| {CTRY_CHILE, "CL" }, |
| {CTRY_CHINA, "CN" }, |
| {CTRY_CHRISTMAS_ISLAND, "CX" }, |
| {CTRY_COCOS_ISLANDS, "CC" }, |
| {CTRY_COLOMBIA, "CO" }, |
| {CTRY_COMOROS, "KM" }, |
| {CTRY_CONGO, "CG" }, |
| {CTRY_COOK_ISLANDS, "CK" }, |
| {CTRY_COSTA_RICA, "CR" }, |
| {CTRY_COTE_DIVOIRE, "CI" }, |
| {CTRY_CROATIA, "HR" }, |
| {CTRY_CYPRUS, "CY" }, |
| {CTRY_CZECH, "CZ" }, |
| {CTRY_DENMARK, "DK" }, |
| {CTRY_DJIBOUTI, "DJ" }, |
| {CTRY_DOMINICA, "DM" }, |
| {CTRY_DOMINICAN_REPUBLIC, "DO" }, |
| {CTRY_ECUADOR, "EC" }, |
| {CTRY_EGYPT, "EG" }, |
| {CTRY_EL_SALVADOR, "SV" }, |
| {CTRY_EQUATORIAL_GUINEA, "GQ" }, |
| {CTRY_ERITREA, "ER" }, |
| {CTRY_ESTONIA, "EE" }, |
| {CTRY_ETHIOPIA, "ET" }, |
| {CTRY_FALKLAND_ISLANDS, "FK" }, |
| {CTRY_EUROPE, "EU" }, |
| {CTRY_FIJI, "FJ" }, |
| {CTRY_FINLAND, "FI" }, |
| {CTRY_FRANCE, "FR" }, |
| {CTRY_FRANCE2, "F2" }, |
| {CTRY_FRENCH_GUIANA, "GF" }, |
| {CTRY_FRENCH_POLYNESIA, "PF" }, |
| {CTRY_FRENCH_SOUTHERN_TERRITORIES, "TF" }, |
| {CTRY_GABON, "GA" }, |
| {CTRY_GAMBIA, "GM" }, |
| {CTRY_GEORGIA, "GE" }, |
| {CTRY_GERMANY, "DE" }, |
| {CTRY_GHANA, "GH" }, |
| {CTRY_GIBRALTAR, "GI" }, |
| {CTRY_GREECE, "GR" }, |
| {CTRY_GREENLAND, "GL" }, |
| {CTRY_GRENADA, "GD" }, |
| {CTRY_GUADELOUPE, "GP" }, |
| {CTRY_GUAM, "GU" }, |
| {CTRY_GUATEMALA, "GT" }, |
| {CTRY_GUINEA, "GN" }, |
| {CTRY_GUINEA_BISSAU, "GW" }, |
| {CTRY_GUYANA, "GY" }, |
| {CTRY_HAITI, "HT" }, |
| {CTRY_HONDURAS, "HN" }, |
| {CTRY_HONG_KONG, "HK" }, |
| {CTRY_HUNGARY, "HU" }, |
| {CTRY_ICELAND, "IS" }, |
| {CTRY_INDIA, "IN" }, |
| {CTRY_INDONESIA, "ID" }, |
| {CTRY_IRAN, "IR" }, |
| {CTRY_IRELAND, "IE" }, |
| {CTRY_ISRAEL, "IL" }, |
| {CTRY_ITALY, "IT" }, |
| {CTRY_JAPAN, "JP" }, |
| {CTRY_JAPAN1, "J1" }, |
| {CTRY_JAPAN2, "J2" }, |
| {CTRY_JAPAN3, "J3" }, |
| {CTRY_JAPAN4, "J4" }, |
| {CTRY_JAPAN5, "J5" }, |
| {CTRY_JAPAN7, "JP" }, |
| {CTRY_JAPAN6, "JP" }, |
| {CTRY_JAPAN8, "JP" }, |
| {CTRY_JAPAN9, "JP" }, |
| {CTRY_JAPAN10, "JP" }, |
| {CTRY_JAPAN11, "JP" }, |
| {CTRY_JAPAN12, "JP" }, |
| {CTRY_JAPAN13, "JP" }, |
| {CTRY_JAPAN14, "JP" }, |
| {CTRY_JAPAN15, "JP" }, |
| {CTRY_JAPAN16, "JP" }, |
| {CTRY_JAPAN17, "JP" }, |
| {CTRY_JAPAN18, "JP" }, |
| {CTRY_JAPAN19, "JP" }, |
| {CTRY_JAPAN20, "JP" }, |
| {CTRY_JAPAN21, "JP" }, |
| {CTRY_JAPAN22, "JP" }, |
| {CTRY_JAPAN23, "JP" }, |
| {CTRY_JAPAN24, "JP" }, |
| {CTRY_JAPAN25, "JP" }, |
| {CTRY_JAPAN26, "JP" }, |
| {CTRY_JAPAN27, "JP" }, |
| {CTRY_JAPAN28, "JP" }, |
| {CTRY_JAPAN29, "JP" }, |
| {CTRY_JAPAN30, "JP" }, |
| {CTRY_JAPAN31, "JP" }, |
| {CTRY_JAPAN32, "JP" }, |
| {CTRY_JAPAN33, "JP" }, |
| {CTRY_JAPAN34, "JP" }, |
| {CTRY_JAPAN35, "JP" }, |
| {CTRY_JAPAN36, "JP" }, |
| {CTRY_JAPAN37, "JP" }, |
| {CTRY_JAPAN38, "JP" }, |
| {CTRY_JAPAN39, "JP" }, |
| {CTRY_JAPAN40, "JP" }, |
| {CTRY_JAPAN41, "JP" }, |
| {CTRY_JAPAN42, "JP" }, |
| {CTRY_JAPAN43, "JP" }, |
| {CTRY_JAPAN44, "JP" }, |
| {CTRY_JAPAN45, "JP" }, |
| {CTRY_JAPAN46, "JP" }, |
| {CTRY_JAPAN47, "JP" }, |
| {CTRY_JAPAN48, "JP" }, |
| {CTRY_JORDAN, "JO" }, |
| {CTRY_KAZAKHSTAN, "KZ" }, |
| {CTRY_KOREA_NORTH, "KP" }, |
| {CTRY_KOREA_ROC, "KR" }, |
| {CTRY_KOREA_ROC2, "K2" }, |
| {CTRY_KUWAIT, "KW" }, |
| {CTRY_LATVIA, "LV" }, |
| {CTRY_LEBANON, "LB" }, |
| {CTRY_LIECHTENSTEIN, "LI" }, |
| {CTRY_LITHUANIA, "LT" }, |
| {CTRY_LUXEMBOURG, "LU" }, |
| {CTRY_MACAU, "MO" }, |
| {CTRY_MACEDONIA, "MK" }, |
| {CTRY_MALAYSIA, "MY" }, |
| {CTRY_MEXICO, "MX" }, |
| {CTRY_MONACO, "MC" }, |
| {CTRY_MOROCCO, "MA" }, |
| {CTRY_NEPAL, "NP" }, |
| {CTRY_NETHERLANDS, "NL" }, |
| {CTRY_NEW_ZEALAND, "NZ" }, |
| {CTRY_NORWAY, "NO" }, |
| {CTRY_OMAN, "OM" }, |
| {CTRY_PAKISTAN, "PK" }, |
| {CTRY_PANAMA, "PA" }, |
| {CTRY_PERU, "PE" }, |
| {CTRY_PHILIPPINES, "PH" }, |
| {CTRY_POLAND, "PL" }, |
| {CTRY_PORTUGAL, "PT" }, |
| {CTRY_PUERTO_RICO, "PR" }, |
| {CTRY_QATAR, "QA" }, |
| {CTRY_ROMANIA, "RO" }, |
| {CTRY_RUSSIA, "RU" }, |
| {CTRY_SAUDI_ARABIA, "SA" }, |
| {CTRY_SINGAPORE, "SG" }, |
| {CTRY_SLOVAKIA, "SK" }, |
| {CTRY_SLOVENIA, "SI" }, |
| {CTRY_SOUTH_AFRICA, "ZA" }, |
| {CTRY_SPAIN, "ES" }, |
| {CTRY_SRILANKA, "LK" }, |
| {CTRY_SWEDEN, "SE" }, |
| {CTRY_SWITZERLAND, "CH" }, |
| {CTRY_SYRIA, "SY" }, |
| {CTRY_TAIWAN, "TW" }, |
| {CTRY_THAILAND, "TH" }, |
| {CTRY_TRINIDAD_Y_TOBAGO, "TT" }, |
| {CTRY_TUNISIA, "TN" }, |
| {CTRY_TURKEY, "TR" }, |
| {CTRY_UKRAINE, "UA" }, |
| {CTRY_UAE, "AE" }, |
| {CTRY_UNITED_KINGDOM, "GB" }, |
| {CTRY_UNITED_STATES, "US" }, |
| {CTRY_UNITED_STATES_FCC49, "US" }, |
| {CTRY_URUGUAY, "UY" }, |
| {CTRY_UZBEKISTAN, "UZ" }, |
| {CTRY_VENEZUELA, "VE" }, |
| {CTRY_VIET_NAM, "VN" }, |
| {CTRY_YEMEN, "YE" }, |
| {CTRY_ZIMBABWE, "ZW" } |
| }; |
| |
| static const struct operating_class_table us_oper_class_table[] = { |
| {1, 115, 20, {36,40,44,48}, 0}, |
| {2, 118, 20, {52,56,60,64}, IEEE80211_OC_BEHAV_DFS_50_100}, |
| {3, 124, 20, {149,153,157,161}, IEEE80211_OC_BEHAV_NOMADIC}, |
| {4, 121, 20, {100,104,108,112,116,120,124,128,132,136,140}, |
| IEEE80211_OC_BEHAV_DFS_50_100 | IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| {5, 125, 20, {149,153,157,161,165}, IEEE80211_OC_BEHAV_LICEN_EXEP}, |
| {12, 81, 25, {1,2,3,4,5,6,7,8,9,10,11}, IEEE80211_OC_BEHAV_LICEN_EXEP}, |
| {22, 116, 40, {36,44}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {23, 119, 40, {52,60}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {24, 122, 40, {100,108,116,124,132}, IEEE80211_OC_BEHAV_CHAN_LOWWER | |
| IEEE80211_OC_BEHAV_DFS_50_100 | IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| {25, 126, 40, {149,157}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {26, 126, 40, {149,157}, IEEE80211_OC_BEHAV_LICEN_EXEP | IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {27, 117, 40, {40,48}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {28, 120, 40, {56,64}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {29, 123, 40, {104,112,120,128,136}, IEEE80211_OC_BEHAV_NOMADIC | |
| IEEE80211_OC_BEHAV_CHAN_UPPER | IEEE80211_OC_BEHAV_DFS_50_100 | IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| {30, 127, 40, {153,161}, IEEE80211_OC_BEHAV_NOMADIC | IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {31, 127, 40, {153,161}, IEEE80211_OC_BEHAV_LICEN_EXEP | IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {32, 83, 40, {1,2,3,4,5,6,7}, IEEE80211_OC_BEHAV_LICEN_EXEP | IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {33, 84, 40, {5,6,7,8,9,10,11}, IEEE80211_OC_BEHAV_LICEN_EXEP | IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {128, 128, 80, {36,40,44,48,52,56,60,64,100,104,108,112,116,120,124,128,132,136,140,144,149,153,157,161}, |
| IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| {130, 130, 80, {36,40,44,48,52,56,60,64,100,104,108,112,116,120,124,128,132,136,140,144,149,153,157,161}, |
| IEEE80211_OC_BEHAV_80PLUS | IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| }; |
| |
| static const struct operating_class_table eu_oper_class_table[] = { |
| {1, 115, 20, {36,40,44,48},0}, |
| {2, 118, 20, {52,56,60,64}, IEEE80211_OC_BEHAV_NOMADIC}, |
| {3, 121, 20, {100,104,108,112,116,120,124,128,132,136,140}, 0}, |
| {4, 81, 25, {1,2,3,4,5,6,7,8,9,10,11,12,13}, 0}, |
| {5, 116, 40, {36,44}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {6, 119, 40, {52,60}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {7, 122, 40, {100,108,116,124,132}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {8, 117, 40, {40,48}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {9, 120, 40, {56,64}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {10, 123, 40, {104,112,120,128,136}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {11, 83, 40, {1,2,3,4,5,6,7,8,9}, IEEE80211_OC_BEHAV_LICEN_EXEP | IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {12, 84, 40, {5,6,7,8,9,10,11,12,13}, IEEE80211_OC_BEHAV_LICEN_EXEP | IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {128, 128, 80, {36,40,44,48,52,56,60,64,100,104,108,112,116,120,124,128}, |
| IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| {130, 130, 80, {36,40,44,48,52,56,60,64,100,104,108,112,116,120,124,128}, |
| IEEE80211_OC_BEHAV_80PLUS | IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| }; |
| |
| static const struct operating_class_table jp_oper_class_table[] = { |
| {1, 115, 20, {36,40,44,48}, 0}, |
| {30, 81, 25, {1,2,3,4,5,6,7,8,9,10,11,12,13}, IEEE80211_OC_BEHAV_LICEN_EXEP}, |
| {31, 82, 25, {14}, IEEE80211_OC_BEHAV_LICEN_EXEP}, |
| {32, 118, 20, {52,56,60,64}, 0}, |
| {33, 118, 20, {52,56,60,64}, 0}, |
| {34, 121, 20, {100,104,108,112,116,120,124,128,132,136,140}, IEEE80211_OC_BEHAV_DFS_50_100}, |
| {35, 121, 20, {100,104,108,112,116,120,124,128,132,136,140}, IEEE80211_OC_BEHAV_DFS_50_100}, |
| {36, 116, 40, {36,44}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {37, 119, 40, {52,60}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {38, 119, 40, {52,60}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {39, 122, 40, {100,108,116,124,132}, IEEE80211_OC_BEHAV_CHAN_LOWWER|IEEE80211_OC_BEHAV_DFS_50_100}, |
| {40, 122, 40, {100,108,116,124,132}, IEEE80211_OC_BEHAV_CHAN_LOWWER|IEEE80211_OC_BEHAV_DFS_50_100}, |
| {41, 117, 40, {40,48}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {42, 120, 40, {56,64}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {43, 120, 40, {56,64}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {44, 123, 40, {104,112,120,128,136}, IEEE80211_OC_BEHAV_CHAN_UPPER|IEEE80211_OC_BEHAV_DFS_50_100}, |
| {45, 123, 40, {104,112,120,128,136}, IEEE80211_OC_BEHAV_CHAN_UPPER|IEEE80211_OC_BEHAV_DFS_50_100}, |
| {56, 83, 40, {1,2,3,4,5,6,7,8,9}, IEEE80211_OC_BEHAV_LICEN_EXEP | IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {57, 84, 40, {5,6,7,8,9,10,11,12,13}, IEEE80211_OC_BEHAV_LICEN_EXEP | IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {128, 128, 80, {36,40,44,48,52,56,60,64,100,104,108,112,116,120,124,128}, |
| IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| {130, 130, 80, {36,40,44,48,52,56,60,64,100,104,108,112,116,120,124,128}, |
| IEEE80211_OC_BEHAV_80PLUS | IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| }; |
| |
| static const struct operating_class_table gb_oper_class_table[] = { |
| {81, 81, 25, {1,2,3,4,5,6,7,8,9,10,11,12,13}, 0}, |
| {82, 82, 25, {14}, 0}, |
| {83, 83, 40, {1,2,3,4,5,6,7,8,9}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {84, 84, 40, {5,6,7,8,9,10,11,12,13}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {115, 115, 20, {36,40,44,48}, 0}, |
| {116, 116, 40, {36,44}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {117, 117, 40, {40,48}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {118, 118, 20, {52,56,60,64}, IEEE80211_OC_BEHAV_DFS_50_100}, |
| {119, 119, 40, {52,60}, IEEE80211_OC_BEHAV_CHAN_LOWWER|IEEE80211_OC_BEHAV_DFS_50_100}, |
| {120, 120, 40, {56,64}, IEEE80211_OC_BEHAV_CHAN_UPPER|IEEE80211_OC_BEHAV_DFS_50_100}, |
| {121, 121, 20, {100,104,108,112,116,120,124,128,132,136,140,144}, IEEE80211_OC_BEHAV_DFS_50_100}, |
| {122, 122, 40, {100,108,116,124,132,140}, IEEE80211_OC_BEHAV_CHAN_LOWWER|IEEE80211_OC_BEHAV_DFS_50_100}, |
| {123, 123, 40, {104,112,120,128,136,144}, IEEE80211_OC_BEHAV_CHAN_UPPER|IEEE80211_OC_BEHAV_DFS_50_100}, |
| {124, 124, 20, {149,153,157,161}, IEEE80211_OC_BEHAV_NOMADIC}, |
| {126, 126, 40, {149,157}, IEEE80211_OC_BEHAV_CHAN_LOWWER}, |
| {127, 127, 40, {153,161}, IEEE80211_OC_BEHAV_CHAN_UPPER}, |
| {128, 128, 80, {36,40,44,48,52,56,60,64,100,104,108,112,116,120,124,128,132,136,140,144,149,153,157,161}, |
| IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| {130, 130, 80, {36,40,44,48,52,56,60,64,100,104,108,112,116,120,124,128,132,136,140,144,149,153,157,161}, |
| IEEE80211_OC_BEHAV_80PLUS | IEEE80211_OC_BEHAV_EIRP_TXPOWENV}, |
| }; |
| |
| /* Make sure the global class entry must be the last one */ |
| static const struct region_to_oper_class oper_class_table[] = { |
| {"US", 17, {1,2,3,4,5,22,23,24,25,26,27,28,29,30,31,128,130}, 3, {12,32,33}, us_oper_class_table}, |
| {"EU", 11, {1,2,3,5,6,7,8,9,10,128,130}, 3, {4,11,12}, eu_oper_class_table}, |
| {"JP", 17, {1,32,33,34,35,36,37,38,39,40,41,42,43,44,45,128,130}, 4, {30,31,56,57}, jp_oper_class_table}, |
| {"GB", 14, {115,116,117,118,119,120,121,122,123,124,126,127,128,130}, 4, {81,82,83,84}, gb_oper_class_table}, |
| }; |
| #define OPER_CLASS_GB_INDEX (ARRAY_SIZE(oper_class_table) - 1) |
| |
| static struct ieee80211_band_info ieee80211_bands[IEEE80211_BAND_IDX_MAX] = { |
| /* {band_chan_step, band_first_chan, band_chan_cnt} */ |
| {IEEE80211_24G_CHAN_SEC_SHIFT, 1, 13}, |
| {IEEE80211_24G_CHAN_SEC_SHIFT, 14, 1}, |
| {IEEE80211_CHAN_SEC_SHIFT, 36, 4}, |
| {IEEE80211_CHAN_SEC_SHIFT, 52, 4}, |
| {IEEE80211_CHAN_SEC_SHIFT, 100, 12}, |
| {IEEE80211_CHAN_SEC_SHIFT, 149, 4}, |
| /* isolate chan 165 for IOT as per sniffer capture */ |
| {IEEE80211_CHAN_SEC_SHIFT, 165, 1}, |
| }; |
| |
| struct ieee80211_band_info *ieee80211_get_band_info(int band_idx) |
| { |
| if (band_idx >= IEEE80211_BAND_IDX_MAX) |
| return NULL; |
| |
| return &ieee80211_bands[band_idx]; |
| } |
| |
| #if defined(QBMPS_ENABLE) |
| /*******************************************************************************/ |
| /* ieee80211_sta_bmps_update: allocate, re-allocate or free BMPS NULL frame */ |
| /* */ |
| /* NOTE: this function should be called whenever a new assocation */ |
| /* happens, because node id associated with the frame needs */ |
| /* to be updated */ |
| /*******************************************************************************/ |
| int ieee80211_sta_bmps_update(struct ieee80211vap *vap) |
| { |
| struct ieee80211com *ic = vap->iv_ic; |
| struct ieee80211_node *ni = vap->iv_bss; |
| struct sk_buff *skb = NULL; |
| |
| if (!ni) |
| return -1; |
| |
| ieee80211_ref_node(ni); |
| |
| if (ic->ic_flags_qtn & IEEE80211_QTN_BMPS) { |
| /* set null frame */ |
| skb = ieee80211_get_nulldata(ni); |
| if (!skb) { |
| ieee80211_free_node(ni); |
| return -1; |
| } |
| if (ic->ic_bmps_set_frame(ic, ni, skb)) { |
| dev_kfree_skb(skb); |
| ieee80211_free_node(ni); |
| return -1; |
| } |
| } else { |
| /* free null frame */ |
| ic->ic_bmps_release_frame(ic); |
| } |
| |
| ieee80211_free_node(ni); |
| |
| return 0; |
| } |
| EXPORT_SYMBOL(ieee80211_sta_bmps_update); |
| #endif |
| |
| int ieee80211_is_idle_state(struct ieee80211com *ic) |
| { |
| int ret = 1; |
| struct ieee80211vap *vap; |
| int wds_link_active = 0; |
| struct ieee80211_node *wds_ni; |
| struct ieee80211vap *sta_vap = NULL; |
| int nvaps = 0; |
| #if defined(QBMPS_ENABLE) |
| struct qdrv_vap *qv; |
| #endif |
| |
| IEEE80211_LOCK_IRQ(ic); |
| |
| if (ic->ic_ocac.ocac_running) { |
| ret = 0; |
| goto quit; |
| } |
| |
| TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) { |
| nvaps ++; |
| if (vap->iv_opmode == IEEE80211_M_STA) |
| sta_vap = vap; |
| } |
| |
| |
| /* Checking non-sta mode for WDS link */ |
| if (!(sta_vap && (nvaps == 1)) && (ic->ic_sta_assoc > 0)) { |
| if (ic->ic_wds_links == ic->ic_sta_assoc) { |
| TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) { |
| if (vap->iv_opmode == IEEE80211_M_WDS) { |
| wds_ni = ieee80211_get_wds_peer_node_noref(vap); |
| if (wds_ni) { |
| if (IEEE80211_BA_IS_COMPLETE(wds_ni->ni_ba_rx[IEEE80211_WDS_LINK_MAINTAIN_BA_TID].state) || |
| IEEE80211_BA_IS_COMPLETE(wds_ni->ni_ba_tx[IEEE80211_WDS_LINK_MAINTAIN_BA_TID].state)) { |
| wds_link_active = 1; |
| break; |
| } |
| } |
| } |
| } |
| |
| if (!wds_link_active) { |
| ret = 1; |
| goto quit; |
| } |
| } |
| |
| ret = 0; |
| goto quit; |
| } |
| |
| #if defined(QBMPS_ENABLE) |
| /* here is the logic which decide should power-save or not */ |
| if (sta_vap) { |
| ret = 0; |
| if (nvaps > 1) { |
| /* multiple VAPS, and one of them is STA */ |
| /* force power-saving off */ |
| goto quit; |
| } |
| if ((sta_vap->iv_state == IEEE80211_S_RUN) && |
| (ic->ic_flags_qtn & IEEE80211_QTN_BMPS) && |
| !(ic->ic_flags & IEEE80211_F_SCAN) && |
| !(ic->ic_flags_qtn & IEEE80211_QTN_BGSCAN) && |
| !(ic->ic_flags_qtn & IEEE80211_QTN_SAMP_CHAN) && |
| !sta_vap->iv_swbmiss_bmps_warning) { |
| /* for single STA VAP: mark as idle only if */ |
| /* 1. BMPS power-saving is enabled, and */ |
| /* 2. not in SCAN process, and */ |
| /* 3. not in SCS sample channel process, and */ |
| /* 4. no beacon missing warning */ |
| qv = container_of(sta_vap, struct qdrv_vap, iv); |
| if (qv->qv_bmps_mode == BMPS_MODE_MANUAL) { |
| /* manual mode */ |
| ret = 1; |
| goto quit; |
| } else if ((qv->qv_bmps_mode == BMPS_MODE_AUTO) && |
| (!sta_vap->iv_bmps_tput_high)) { |
| /* auto mode */ |
| /* and tput is low */ |
| ret = 1; |
| goto quit; |
| } |
| } |
| } |
| #else |
| if (sta_vap) { |
| ret = 0; |
| goto quit; |
| } |
| #endif |
| |
| quit: |
| IEEE80211_UNLOCK_IRQ(ic); |
| |
| return ret; |
| } |
| EXPORT_SYMBOL(ieee80211_is_idle_state); |
| |
| int ieee80211_is_on_weather_channel(struct ieee80211com *ic, struct ieee80211_channel *chan) |
| { |
| int is_weather_chan; |
| int cur_bw; |
| |
| if (chan == NULL || chan == IEEE80211_CHAN_ANYC) |
| return 0; |
| |
| cur_bw = ieee80211_get_bw(ic); |
| is_weather_chan = chan->ic_flags & IEEE80211_CHAN_WEATHER; |
| |
| if (cur_bw >= BW_HT40) { |
| is_weather_chan |= chan->ic_flags & IEEE80211_CHAN_WEATHER_40M; |
| if (cur_bw >= BW_HT80) |
| is_weather_chan |= chan->ic_flags & IEEE80211_CHAN_WEATHER_80M; |
| } |
| |
| return !!is_weather_chan; |
| } |
| EXPORT_SYMBOL(ieee80211_is_on_weather_channel); |
| |
| #if defined(QBMPS_ENABLE) |
| /************************************************************/ |
| /* ieee80211_bmps_tput_check: calculate TX/RX tput */ |
| /* */ |
| /* NOTE: this tput information will be used to decide */ |
| /* entering/exiting power-saving state automatically */ |
| /* while BMPS works in AUTO mode */ |
| /************************************************************/ |
| static void |
| ieee80211_bmps_tput_check(unsigned long arg) |
| { |
| struct ieee80211com *ic = (struct ieee80211com *)arg; |
| struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0) |
| struct rtnl_link_stats64 *stats; |
| uint64_t rx_bytes_diff, tx_bytes_diff, curr_tput_kbps; |
| #else |
| struct net_device_stats *stats; |
| uint32_t rx_bytes_diff, tx_bytes_diff, curr_tput_kbps; |
| #endif |
| |
| if (vap) { |
| stats = &vap->iv_devstats; |
| if (vap->iv_ic->ic_get_shared_vap_stats) { |
| /* get VAP TX/RX bytes stats info */ |
| vap->iv_ic->ic_get_shared_vap_stats(vap); |
| /* calculate overall TX & RX tput */ |
| /* over the past measuring period */ |
| rx_bytes_diff = stats->rx_bytes - |
| ic->ic_bmps_tput_check.prev_rx_bytes; |
| tx_bytes_diff = stats->tx_bytes - |
| ic->ic_bmps_tput_check.prev_tx_bytes; |
| |
| ic->ic_bmps_tput_check.prev_rx_bytes = stats->rx_bytes; |
| ic->ic_bmps_tput_check.prev_tx_bytes = stats->tx_bytes; |
| |
| curr_tput_kbps = ((rx_bytes_diff + tx_bytes_diff) * 8) / |
| (BMPS_TPUT_MEASURE_PERIOD_MS); |
| if (curr_tput_kbps > BMPS_TPUT_THRESHOLD_UPPER) { |
| /* tput is above upper threshold */ |
| /* it is time to exit BMPS power-saving */ |
| if (!vap->iv_bmps_tput_high || |
| (vap->iv_bmps_tput_high == -1)) { |
| vap->iv_bmps_tput_high = 1; |
| ic->ic_pm_reason = IEEE80211_PM_LEVEL_TPUT_ABOVE_UPPER_THRSH; |
| ieee80211_pm_queue_work(ic); |
| } |
| } else if (curr_tput_kbps < BMPS_TPUT_THRESHOLD_LOWER){ |
| /* tput is below lower threshold */ |
| /* it is time to enter BMPS power-saving */ |
| if (vap->iv_bmps_tput_high || |
| (vap->iv_bmps_tput_high == -1)) { |
| vap->iv_bmps_tput_high = 0; |
| ic->ic_pm_reason = IEEE80211_PM_LEVEL_TPUT_BELOW_LOWER_THRSH; |
| ieee80211_pm_queue_work(ic); |
| } |
| } |
| } |
| } |
| |
| mod_timer(&ic->ic_bmps_tput_check.tput_timer, |
| jiffies + (BMPS_TPUT_MEASURE_PERIOD_MS / 1000) * HZ); |
| } |
| #endif |
| |
| static char *trigger_reason_str[] = {"","IEEE80211_PM_LEVEL_REMAIN_CHANNEL_WORK", |
| "IEEE80211_PM_LEVEL_CCA_WORK", |
| "IEEE80211_PM_LEVEL_TPUT_ABOVE_UPPER_THRSH", |
| "IEEE80211_PM_LEVEL_TPUT_BELOW_LOWER_THRSH", |
| "IEEE80211_PM_LEVEL_VAP_ATTACH", |
| "IEEE80211_PM_LEVEL_VAP_DETACH", |
| "IEEE80211_PM_LEVEL_RCVD_ADDBA_REQ", |
| "IEEE80211_PM_LEVEL_RCVD_ADDBA_RESP", |
| "IEEE80211_PM_LEVEL_SWBCN_MISS", |
| "IEEE80211_PM_LEVEL_JOIN_BSS", |
| "IEEE80211_PM_LEVEL_LEAVE_BSS", |
| "IEEE80211_PM_LEVEL_INACTIVITY_IN_WDS", |
| "IEEE80211_PM_LEVEL_NODE_JOIN", |
| "IEEE80211_PM_LEVEL_NODE_LEFT", |
| "IEEE80211_PM_LEVEL_DEVICE_INIT", |
| "IEEE80211_PM_LEVEL_SWBCN_MISS_2", |
| "IEEE80211_PM_LEVEL_NEW_STATE_IEEE80211_S_RUN", |
| "IEEE80211_PM_LEVEL_SCAN_START", |
| "IEEE80211_PM_LEVEL_SCAN_STOP", |
| "IEEE80211_PM_LEVEL_SIWFREQ", |
| "IEEE80211_PM_LEVEL_SIWSCAN", |
| "IEEE80211_PM_LEVEL_STOP_OCAC_SDFS", |
| "IEEE80211_PM_LEVEL_BCN_SCHEME_CHANGED_FOR_2VAPS", |
| "IEEE80211_PM_LEVEL_OCAC_SDFS_TIMER", |
| "IEEE80211_PM_LEVEL_BCN_SCHEME_CHANGED", |
| "IEEE80211_PM_LEVEL_CAC_COMPLETED", |
| "IEEE80211_PM_LEVEL_CSA_DFS_ACTION", |
| "IEEE80211_PM_LEVEL_ICAC_COMPLETE_ACTION", |
| }; |
| |
| const char * ieee80211_get_pm_level_change_trigger_reason(int pm_reason) |
| { |
| |
| if ((pm_reason < IEEE80211_PM_LEVEL_CCA_WORK ) || (pm_reason >= IEEE80211_PM_LEVEL_REASON_MAX)) |
| return " "; |
| |
| return trigger_reason_str[pm_reason]; |
| } |
| |
| static void ieee80211_coc_pm_trigger_channel_switch(unsigned long arg) |
| { |
| struct ieee80211com *ic = (struct ieee80211com *)arg; |
| /* Get the level again, to be safer */ |
| int level = ieee80211_is_idle_state(ic) ? BOARD_PM_LEVEL_IDLE : PM_QOS_DEFAULT_VALUE; |
| |
| if (unlikely(IEEE80211_CSW_REASON_COC != ic->ic_csa_reason)) { |
| /* Race in channel change is highly unlikely. |
| * Add a safe check; |
| */ |
| ic->ic_coc_cc_reason = IEEE80211_CSW_REASON_UNKNOWN; |
| return; |
| } |
| |
| ieee80211_finish_csa((unsigned long) ic); |
| pm_qos_update_requirement(PM_QOS_POWER_SAVE, BOARD_PM_GOVERNOR_WLAN, level); |
| |
| if (ic->ic_curchan) { |
| COC_DBG_QEVT(ic2dev(ic), "CoC: Channel changed to %d as PM level changed to %d\n", |
| ic->ic_curchan->ic_ieee, level); |
| } |
| } |
| |
| static int ieee80211_coc_pm_action_trigger_channel_change(struct ieee80211com *ic, int pick_flags) |
| { |
| struct ieee80211_channel *best_channel = NULL; |
| int best_chan_ieee; |
| int ret; |
| |
| best_chan_ieee = ieee80211_scs_pick_channel(ic, |
| pick_flags, |
| IEEE80211_SCS_NA_CC); |
| |
| best_channel = ieee80211_find_channel_by_ieee(ic, best_chan_ieee); |
| |
| if ((NULL == best_channel) || (!ic->ic_check_channel(ic, best_channel, 0, 0))) { |
| return IEEE80211_COC_BEST_CHANNEL_NOT_FOUND; |
| } else { |
| /* Schedule a channel switch; |
| * 1. Option1 : Since no STAs are connected Stack can change |
| * the channel to selected non-dfs immediately without CSA |
| * 2. Option2 : While channel change is in progress, |
| * an association attempt by a STA could trigger races |
| * Hence let us invoke CSA logic all the time |
| */ |
| ret = ieee80211_enter_csa(ic, best_channel, ieee80211_coc_pm_trigger_channel_switch, |
| IEEE80211_CSW_REASON_COC, |
| IEEE80211_DEFAULT_CHANCHANGE_TBTT_COUNT, |
| IEEE80211_CSA_MUST_STOP_TX, |
| IEEE80211_CSA_F_BEACON | IEEE80211_CSA_F_ACTION); |
| if (ret == 0) { |
| /* CSA scheduled successfully */ |
| return IEEE80211_COC_REASON_SUCCESS; |
| |
| } else { |
| return IEEE80211_COC_REASON_CSA_NOT_TRIGGERED; |
| } |
| } |
| } |
| |
| static bool ieee80211_coc_resolve_valid_modes(struct ieee80211com *ic) |
| { |
| struct ieee80211vap *vap = NULL; |
| |
| /* If one of the VAPs is STA and is associated, |
| * Channel change is always driven by connected AP |
| */ |
| IEEE80211_LOCK_IRQ(ic); |
| TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) { |
| if ((vap->iv_opmode == IEEE80211_M_STA) && |
| (vap->iv_state == IEEE80211_S_RUN)) { |
| return false; |
| } |
| } |
| IEEE80211_UNLOCK_IRQ(ic); |
| |
| /* All other cases are valid*/ |
| return true; |
| } |
| |
| static bool ieee80211_pm_change_should_trigger_channel_change(struct ieee80211com *ic, int dest_pm_level) |
| { |
| bool cc_flag = ic->ic_dfs_is_eu_region() && ieee80211_coc_resolve_valid_modes(ic); |
| |
| bool cur_chan_is_dfs = (is_ieee80211_chan_valid(ic->ic_curchan)) && |
| (ic->ic_curchan->ic_flags & IEEE80211_CHAN_DFS); |
| |
| /* ETSI : While changing to pm level 1:PM_QOS_DEFAULT_VALUE, |
| * try to move to best DFS channel |
| * 1. if we had earlier transitioned from DFS_channel-->Non_DFS_Channel |
| * because of CoC, |
| * 2. OCAC/SDFS is not running on current non-dfs channel. |
| * 3. Change to pm level was triggered by STA association; |
| * 4. And current channel is non-dfs channel |
| */ |
| if (PM_QOS_DEFAULT_VALUE == dest_pm_level) { |
| return ((ic->ic_coc_move_to_ndfs) && |
| (!ic->ic_ocac.ocac_running) && |
| (false == cur_chan_is_dfs) && |
| (cc_flag) && |
| (IEEE80211_CSW_REASON_COC == ic->ic_coc_cc_reason) && |
| (IEEE80211_PM_LEVEL_NODE_JOIN == ic->ic_pm_reason)); |
| } |
| |
| /* ETSI : While changing to pm level 5:BOARD_PM_LEVEL_IDLE, |
| * try to move to best non-dfs channel |
| * 1. if the current channel is DFS channel |
| */ |
| |
| return ((true == cur_chan_is_dfs) && cc_flag && (ic->ic_coc_move_to_ndfs)); |
| } |
| |
| |
| static bool ieee80211_pm_channel_change(struct ieee80211com *ic, int dest_pm_level, unsigned int pick_flags) |
| { |
| if (ieee80211_pm_change_should_trigger_channel_change(ic, dest_pm_level)) { |
| if (IEEE80211_COC_REASON_SUCCESS == ieee80211_coc_pm_action_trigger_channel_change(ic, |
| (pick_flags))) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| static void ieee80211_coc_pm_action(struct ieee80211com *ic) |
| { |
| int dest_pm_level = ieee80211_is_idle_state(ic) ? BOARD_PM_LEVEL_IDLE : PM_QOS_DEFAULT_VALUE; |
| |
| if ((!ic->ic_coc_move_to_ndfs) || /* When ic_coc_move_to_ndfs is zero always accept pm change */ |
| (!ic->ic_dfs_is_eu_region()) || /* FCC : Accept the pm level change to 1 and 5 for FCC */ |
| (PM_QOS_DEFAULT_VALUE == dest_pm_level) || /* ETSI : Accept the pm level change to 1 in ETSI*/ |
| (is_ieee80211_chan_valid(ic->ic_curchan) && |
| (!(ic->ic_curchan->ic_flags & IEEE80211_CHAN_DFS)))) /* ETSI : Accept the pm level change to 5 for ETSI, If current channel is non-dfs */ |
| { |
| pm_qos_update_requirement(PM_QOS_POWER_SAVE, BOARD_PM_GOVERNOR_WLAN, dest_pm_level); |
| |
| if (ieee80211_pm_channel_change(ic, dest_pm_level, IEEE80211_SCS_PICK_AVAILABLE_DFS_ONLY | IEEE80211_SCS_PICK_ANYWAY)) { |
| ic->ic_coc_cc_reason = IEEE80211_CSW_REASON_UNKNOWN; |
| } |
| |
| return; |
| } |
| |
| /* DFS:1 ---> NDFS:5 |
| * Moving to pm level 5 in ETSI; |
| * 1. First move to best non-dfs channel |
| * 2. After successful channel change, move the pm level to 5 |
| * 3. If CSA fails for any reason, |
| * pm level remains at previous value which is 1 |
| */ |
| if (ieee80211_pm_channel_change(ic, dest_pm_level, IEEE80211_SCS_PICK_NON_DFS_ONLY | IEEE80211_SCS_PICK_ANYWAY)) { |
| ic->ic_coc_cc_reason = IEEE80211_CSW_REASON_COC; |
| } |
| } |
| |
| static void |
| ieee80211_update_pm(struct work_struct *work) |
| { |
| struct ieee80211com *ic = container_of(work, struct ieee80211com, pm_work.work); |
| |
| if (ic->ic_curchan->ic_flags & IEEE80211_CHAN_DFS_CAC_IN_PROGRESS) |
| return; |
| |
| ieee80211_coc_pm_action(ic); |
| } |
| |
| static void |
| ieee80211_pm_period_change(unsigned long arg) |
| { |
| struct ieee80211com *ic = (struct ieee80211com *)arg; |
| struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); |
| static int cnt = 0; |
| int value; |
| int v = 0; |
| int period_cnt = BOARD_PM_PERIOD_CNT; |
| int period_change_interval = BOARD_PM_PERIOD_CHANGE_INTERVAL; |
| |
| if (vap && vap->iv_bss) { |
| if ((ic->ic_pm_state[QTN_PM_PERIOD_CNT] >= 1) && |
| (ic->ic_pm_state[QTN_PM_PERIOD_CNT] <= BOARD_PM_PERIOD_CNT)) { |
| period_cnt = ic->ic_pm_state[QTN_PM_PERIOD_CNT]; |
| } |
| |
| v = (ic->ic_pm_state[QTN_PM_PERIOD_GROUP] >> (8 * (cnt % period_cnt))) & 0xFF; |
| value = QTN_PM_PACK_PARAM_VALUE(QTN_PM_PDUTY_PERIOD_MS, v); |
| ic->ic_setparam(vap->iv_bss, IEEE80211_PARAM_PWR_SAVE, value, NULL, 0); |
| } |
| |
| if (ic->ic_pm_state[QTN_PM_PERIOD_CHANGE_INTERVAL] >= BOARD_PM_PERIOD_CHANGE_INTERVAL) { |
| period_change_interval = ic->ic_pm_state[QTN_PM_PERIOD_CHANGE_INTERVAL]; |
| } |
| |
| mod_timer(&ic->ic_pm_period_change, jiffies + period_change_interval * HZ); |
| cnt++; |
| } |
| |
| void |
| ieee80211_pm_queue_work_custom(struct ieee80211com *ic, unsigned long delay) |
| { |
| pm_queue_work(&ic->pm_work, delay); |
| } |
| EXPORT_SYMBOL(ieee80211_pm_queue_work_custom); |
| |
| void |
| ieee80211_pm_queue_work(struct ieee80211com *ic) |
| { |
| unsigned long delay; |
| int idle = ieee80211_is_idle_state(ic); |
| |
| if (idle) { |
| #if defined(QBMPS_ENABLE) |
| if ((ic->ic_flags_qtn & IEEE80211_QTN_BMPS) && |
| (ic->ic_opmode & IEEE80211_M_STA)) |
| delay = BOARD_PM_WLAN_STA_IDLE_TIMEOUT; |
| else |
| #endif |
| delay = BOARD_PM_WLAN_IDLE_TIMEOUT; |
| } else |
| delay = BOARD_PM_WLAN_DEFAULT_TIMEOUT; |
| |
| pm_queue_work(&ic->pm_work, delay); |
| } |
| EXPORT_SYMBOL(ieee80211_pm_queue_work); |
| |
| static void |
| ieee80211_vap_remove_ie(struct ieee80211vap *vap) |
| { |
| int i; |
| |
| for (i = 0; i < IEEE80211_APPIE_NUM_OF_FRAME; i++) { |
| if (vap->app_ie[i].ie != NULL) { |
| FREE(vap->app_ie[i].ie, M_DEVBUF); |
| vap->app_ie[i].ie = NULL; |
| vap->app_ie[i].length = 0; |
| } |
| } |
| |
| if (vap->iv_opt_ie != NULL) { |
| FREE(vap->iv_opt_ie, M_DEVBUF); |
| vap->iv_opt_ie = NULL; |
| vap->iv_opt_ie_len = 0; |
| } |
| |
| if (vap->qtn_pairing_ie.ie != NULL) { |
| FREE(vap->qtn_pairing_ie.ie, M_DEVBUF); |
| vap->qtn_pairing_ie.ie = NULL; |
| vap->qtn_pairing_ie.length = 0; |
| } |
| |
| } |
| |
| void init_wowlan_params(struct ieee80211_wowlan *wowlan) |
| { |
| wowlan->host_state = 0; |
| wowlan->wowlan_match = 0; |
| wowlan->L2_ether_type = 0x0842; |
| wowlan->L3_udp_port = 0xffff; |
| wowlan->pattern.len = 0; |
| memset(wowlan->pattern.magic_pattern, 0, 256); |
| } |
| |
| static void |
| ieee80211_extender_start_scan(unsigned long arg) |
| { |
| struct ieee80211com *ic = (struct ieee80211com *)arg; |
| struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); |
| |
| if (ic->ic_extender_role != IEEE80211_EXTENDER_ROLE_RBS) |
| return; |
| |
| if (!vap || vap->iv_opmode != IEEE80211_M_HOSTAP) { |
| mod_timer(&ic->ic_extender_scan_timer, jiffies + |
| IEEE80211_EXTENDER_SCAN_MBS_INTERVAL * HZ); |
| return; |
| } |
| |
| if (time_after(jiffies, ic->ic_extender_mbs_detected_jiffies + |
| IEEE80211_EXTENDER_MBS_INVALID_TIMEOUT * HZ)) { |
| (void) ieee80211_start_scan(vap, |
| IEEE80211_SCAN_ACTIVE | |
| IEEE80211_SCAN_ONCE | |
| IEEE80211_SCAN_QTN_SEARCH_MBS | |
| IEEE80211_SCAN_NOPICK, |
| IEEE80211_SCAN_FOREVER, |
| 0, NULL); |
| } |
| |
| mod_timer(&ic->ic_extender_scan_timer, jiffies + |
| IEEE80211_EXTENDER_SCAN_MBS_INTERVAL * HZ); |
| } |
| |
| int |
| ieee80211_ifattach(struct ieee80211com *ic) |
| { |
| struct ieee80211_channel *c; |
| struct ifmediareq imr; |
| int i; |
| |
| _MOD_INC_USE(THIS_MODULE, return -ENODEV); |
| |
| /* |
| * Pick an initial operating mode until we have a vap |
| * created to lock it down correctly. This is only |
| * drivers have something defined for configuring the |
| * hardware at startup. |
| */ |
| ic->ic_opmode = IEEE80211_M_STA; /* everyone supports this */ |
| |
| /* |
| * Fill in 802.11 available channel set, mark |
| * all available channels as active, and pick |
| * a default channel if not already specified. |
| */ |
| KASSERT(0 < ic->ic_nchans && ic->ic_nchans < IEEE80211_CHAN_MAX, |
| ("invalid number of channels specified: %u", ic->ic_nchans)); |
| memset(ic->ic_chan_avail, 0, sizeof(ic->ic_chan_avail)); |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_AUTO; |
| for (i = 0; i < ic->ic_nchans; i++) { |
| c = &ic->ic_channels[i]; |
| KASSERT(c->ic_flags != 0, ("channel with no flags")); |
| KASSERT(c->ic_ieee < IEEE80211_CHAN_MAX, |
| ("channel with bogus ieee number %u", c->ic_ieee)); |
| /* make sure only valid 2.4G or 5G channels are set as available */ |
| if (((c->ic_ieee >= QTN_2G_FIRST_OPERATING_CHAN) && (c->ic_ieee <= QTN_2G_LAST_OPERATING_CHAN)) || |
| ((c->ic_ieee >= QTN_5G_FIRST_OPERATING_CHAN) && (c->ic_ieee <= QTN_5G_LAST_OPERATING_CHAN))) { |
| setbit(ic->ic_chan_avail, c->ic_ieee); |
| } |
| |
| /* |
| * Identify mode capabilities. |
| */ |
| if (IEEE80211_IS_CHAN_A(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11A; |
| if (IEEE80211_IS_CHAN_B(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11B; |
| if (IEEE80211_IS_CHAN_PUREG(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11G; |
| if (IEEE80211_IS_CHAN_FHSS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_FH; |
| if (IEEE80211_IS_CHAN_108A(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_TURBO_A; |
| if (IEEE80211_IS_CHAN_108G(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_TURBO_G; |
| if (IEEE80211_IS_CHAN_11NG(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11NG; |
| if (IEEE80211_IS_CHAN_11NA(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11NA; |
| if (IEEE80211_IS_CHAN_11NG_HT40PLUS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11NG_HT40PM; |
| if (IEEE80211_IS_CHAN_11NG_HT40MINUS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11NG_HT40PM; |
| if (IEEE80211_IS_CHAN_11NA_HT40PLUS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11NA_HT40PM; |
| if (IEEE80211_IS_CHAN_11NA_HT40MINUS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11NA_HT40PM; |
| if (IEEE80211_IS_CHAN_11AC(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11AC_VHT20PM; |
| if (IEEE80211_IS_CHAN_11AC_VHT40PLUS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11AC_VHT40PM; |
| if (IEEE80211_IS_CHAN_11AC_VHT40MINUS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11AC_VHT40PM; |
| if (IEEE80211_IS_CHAN_11AC_VHT80_EDGEPLUS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11AC_VHT80PM; |
| if (IEEE80211_IS_CHAN_11AC_VHT80_CNTRPLUS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11AC_VHT80PM; |
| if (IEEE80211_IS_CHAN_11AC_VHT80_CNTRMINUS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11AC_VHT80PM; |
| if (IEEE80211_IS_CHAN_11AC_VHT80_EDGEMINUS(c)) |
| ic->ic_modecaps |= 1<<IEEE80211_MODE_11AC_VHT80PM; |
| } |
| /* initialize candidate channels to all available */ |
| memcpy(ic->ic_chan_active, ic->ic_chan_avail, |
| sizeof(ic->ic_chan_avail)); |
| |
| memset(ic->ic_chan_availability_status, IEEE80211_CHANNEL_STATUS_AVAILABLE, sizeof(ic->ic_chan_availability_status)); |
| /* validate ic->ic_curmode */ |
| if ((ic->ic_modecaps & (1<<ic->ic_curmode)) == 0) |
| ic->ic_curmode = IEEE80211_MODE_AUTO; |
| /* |
| * When 11g is supported, force the rate set to |
| * include basic rates suitable for a mixed b/g bss. |
| */ |
| if (ic->ic_modecaps & (1<<IEEE80211_MODE_11G)) |
| ieee80211_set11gbasicrates( |
| &ic->ic_sup_rates[IEEE80211_MODE_11G], |
| IEEE80211_MODE_11G); |
| |
| /* 11n also checks for 11g basic rates for capabilities */ |
| if (ic->ic_modecaps & (1<<IEEE80211_MODE_11NG)) |
| ieee80211_set11gbasicrates( |
| &ic->ic_sup_rates[IEEE80211_MODE_11NG], |
| IEEE80211_MODE_11G); |
| |
| /* setup initial channel settings */ |
| ic->ic_bsschan = IEEE80211_CHAN_ANYC; |
| ic->ic_des_chan = IEEE80211_CHAN_ANYC; |
| |
| /* arbitrarily pick the first channel */ |
| ic->ic_curchan = &ic->ic_channels[1]; |
| ic->ic_prevchan = ic->ic_curchan; |
| |
| /* Enable marking of dfs by default */ |
| ic->ic_flags_ext |= IEEE80211_FEXT_MARKDFS; |
| |
| /* Phytype OFDM. FIXME: this may change with RFIC5 */ |
| ic->ic_phytype = IEEE80211_T_OFDM; |
| |
| /* Enable LDPC by default */ |
| ic->ldpc_enabled = 1; |
| |
| ic->ic_gi_select_enable = QTN_GLOBAL_INIT_SELECT_GI_ENABLE; |
| ic->ic_pppc_select_enable = QTN_GLOBAL_INIT_SELECT_PPPC_ENABLE; |
| |
| ic->ic_def_matrix = QTN_GLOBAL_INIT_DEF_MATRIX; |
| |
| /* |
| * Enable WME by default if we're capable. |
| */ |
| if (ic->ic_caps & IEEE80211_C_WME) |
| ic->ic_flags |= IEEE80211_F_WME; |
| (void) ieee80211_setmode(ic, ic->ic_curmode); |
| |
| if (ic->ic_lintval == 0) { |
| ic->ic_lintval = IEEE80211_BINTVAL_DEFAULT; |
| ic->ic_lintval_backup = IEEE80211_BINTVAL_DEFAULT; |
| } |
| if (ic->ic_bcn_hang_timeout == 0) |
| ic->ic_bcn_hang_timeout = IEEE80211_BEACON_HANG_TIMEOUT_DFLT; |
| ic->ic_bmisstimeout = 7 * ic->ic_lintval; /* default 7 beacons */ |
| IEEE80211_LOCK_INIT(ic, "ieee80211com"); |
| IEEE80211_VAPS_LOCK_INIT(ic, "ieee80211com_vaps"); |
| TAILQ_INIT(&ic->ic_vaps); |
| |
| ic->ic_txpowlimit = IEEE80211_TXPOWER_MAX; |
| ic->ic_txpowlimit = IEEE80211_TXPOWER_MIN; |
| ic->ic_newtxpowlimit = IEEE80211_TXPOWER_MAX; |
| |
| ic->ic_extender_role = IEEE80211_EXTENDER_ROLE_NONE; |
| ic->ic_extender_mbs_best_rssi = IEEE80211_EXTENDER_DEFAULT_MBS_BEST_RSSI; |
| ic->ic_extender_rbs_best_rssi = IEEE80211_EXTENDER_DEFAULT_RBS_BEST_RSSI; |
| ic->ic_extender_mbs_wgt = IEEE80211_EXTENDER_DEFAULT_MBS_WGT; |
| ic->ic_extender_rbs_wgt = IEEE80211_EXTENDER_DEFAULT_RBS_WGT; |
| init_timer(&ic->ic_extender_scan_timer); |
| ic->ic_extender_scan_timer.function = ieee80211_extender_start_scan; |
| ic->ic_extender_scan_timer.data = (unsigned long)ic; |
| ic->ic_extender_mbs_detected_jiffies = jiffies; |
| ic->ic_extender_rssi_continue = 0; |
| ic->ic_scan_opchan_enable = 0; |
| ic->ic_extender_bgscanintvl = IEEE80211_BGSCAN_INTVAL_DEFAULT * HZ; |
| ic->ic_extender_mbs_rssi_margin = IEEE80211_EXTENDER_DEFAULT_MBS_RSSI_MARGIN; |
| ic->ic_scan_tbl_len_max = IEEE80211_SCAN_TBL_LEN_MAX_DFLT; |
| ic->ic_bw_auto_select = 0; |
| ic->ic_max_system_bw = BW_HT80; |
| ic->ic_bss_bw = ic->ic_max_system_bw; |
| ic->ic_oper_class_table = &oper_class_table[OPER_CLASS_GB_INDEX]; |
| ic->ic_autochan_dbg_level = CHAN_SEL_LOG_ERR; |
| |
| ieee80211_crypto_attach(ic); |
| ieee80211_node_attach(ic); |
| ieee80211_power_attach(ic); |
| ieee80211_proto_attach(ic); |
| ieee80211_scan_attach(ic); |
| ieee80211_tpc_query_init(&ic->ic_tpc_query_info, ic, TPC_INTERVAL_DEFAULT); |
| ieee80211_doth_measurement_init(ic); |
| |
| ieee80211_media_setup(ic, &ic->ic_media, ic->ic_caps, |
| ieee80211com_media_change, ieee80211com_media_status); |
| ieee80211com_media_status((void *) ic, &imr); |
| ifmedia_set(&ic->ic_media, imr.ifm_active); |
| |
| INIT_DELAYED_WORK(&ic->pm_work, ieee80211_update_pm); |
| pm_qos_add_requirement(PM_QOS_POWER_SAVE, BOARD_PM_GOVERNOR_WLAN, PM_QOS_DEFAULT_VALUE); |
| init_timer(&ic->ic_pm_period_change); |
| ic->ic_pm_period_change.function = ieee80211_pm_period_change; |
| ic->ic_pm_period_change.data = (unsigned long) ic; |
| |
| #if defined(QBMPS_ENABLE) |
| init_timer(&ic->ic_bmps_tput_check.tput_timer); |
| ic->ic_bmps_tput_check.tput_timer.function = ieee80211_bmps_tput_check; |
| ic->ic_bmps_tput_check.tput_timer.data = (unsigned long) ic; |
| #endif |
| |
| ic->ic_offchan_protect.offchan_stop_expire.function = ieee80211_off_channel_timeout; |
| init_timer(&ic->ic_offchan_protect.offchan_stop_expire); |
| |
| init_waitqueue_head(&ic->ic_scan_comp); |
| |
| init_wowlan_params(&ic->ic_wowlan); |
| |
| ic->ic_vap_default_state = IEEE80211_VAP_STATE_ENABLED; |
| |
| ic->ic_max_boot_cac_duration = -1; |
| |
| ic->ic_boot_cac_end_jiffy = 0; |
| ic->ic_rx_bar_sync = QTN_RX_BAR_SYNC_QTN; |
| |
| ic->ic_vopt.state = IEEE80211_VOPT_DISABLED; |
| ic->ic_vopt.cur_state = IEEE80211_VOPT_DISABLED; |
| ic->ic_vopt.bbf = QTN_GLOBAL_PSEL_MATRIX_ENABLE; |
| ic->ic_vopt.pppc = ic->ic_pppc_select_enable; |
| ic->ic_vopt.airfair = ic->ic_airfair; |
| |
| return 0; |
| } |
| EXPORT_SYMBOL(ieee80211_ifattach); |
| |
| void |
| ieee80211_ifdetach(struct ieee80211com *ic) |
| { |
| struct ieee80211vap *vap; |
| |
| #if defined(QBMPS_ENABLE) |
| del_timer(&ic->ic_bmps_tput_check.tput_timer); |
| #endif |
| del_timer_sync(&ic->ic_offchan_protect.offchan_stop_expire); |
| |
| pm_flush_work(&ic->pm_work); |
| pm_qos_remove_requirement(PM_QOS_POWER_SAVE, BOARD_PM_GOVERNOR_WLAN); |
| |
| rtnl_lock(); |
| while ((vap = TAILQ_FIRST(&ic->ic_vaps)) != NULL) |
| ic->ic_vap_delete(vap); |
| rtnl_unlock(); |
| |
| ieee80211_clean_chanset_values(ic); |
| ieee80211_scs_free_tdls_stats_list(ic); |
| ieee80211_doth_measurement_deinit(ic); |
| ieee80211_tpc_query_deinit(&ic->ic_tpc_query_info); |
| ieee80211_scan_detach(ic); |
| ieee80211_proto_detach(ic); |
| ieee80211_crypto_detach(ic); |
| ieee80211_power_detach(ic); |
| ieee80211_node_detach(ic); |
| ifmedia_removeall(&ic->ic_media); |
| |
| IEEE80211_VAPS_LOCK_DESTROY(ic); |
| IEEE80211_LOCK_DESTROY(ic); |
| |
| _MOD_DEC_USE(THIS_MODULE); |
| } |
| EXPORT_SYMBOL(ieee80211_ifdetach); |
| |
| static void ieee80211_vap_init_tdls(struct ieee80211vap *vap) |
| { |
| if (vap->iv_opmode == IEEE80211_M_STA) { |
| /* AP support tdls and STA disable tdls by default */ |
| vap->iv_flags_ext |= IEEE80211_FEXT_TDLS_PROHIB; |
| vap->iv_flags_ext &= ~IEEE80211_FEXT_TDLS_CS_PROHIB; |
| vap->iv_flags_ext &= ~IEEE80211_FEXT_AP_TDLS_PROHIB; |
| vap->tdls_discovery_interval = DEFAULT_TDLS_DISCOVER_INTERVAL; |
| vap->tdls_node_life_cycle = DEFAULT_TDLS_LIFE_CYCLE; |
| vap->tdls_path_sel_prohibited = DEFAULT_TDLS_PATH_SEL_MODE; |
| vap->tdls_timeout_time = DEFAULT_TDLS_TIMEOUT_TIME; |
| vap->tdls_path_sel_weight = DEFAULT_TDLS_LINK_WEIGHT; |
| vap->tdls_training_pkt_cnt = DEFAULT_TDLS_RATE_DETECTION_PKT_CNT; |
| vap->tdls_uapsd_indicat_wnd = DEFAULT_TDLS_UAPSD_INDICATION_WND; |
| vap->tdls_path_sel_pps_thrshld = DEFAULT_TDLS_PATH_SEL_PPS_THRSHLD; |
| vap->tdls_path_sel_rate_thrshld = DEFAULT_TDLS_PATH_SEL_RATE_THRSHLD; |
| vap->tdls_verbose = DEFAULT_TDLS_VERBOSE; |
| vap->tdls_min_valid_rssi = DEFAULT_TDLS_MIN_RSSI; |
| vap->tdls_switch_ints = DEFAULT_TDLS_LINK_SWITCH_INV; |
| vap->tdls_phy_rate_wgt = DEFAULT_TDLS_PHY_RATE_WEIGHT; |
| vap->tdls_fixed_off_chan = DEFAULT_TDLS_FIXED_OFF_CHAN; |
| vap->tdls_fixed_off_chan_bw = BW_INVALID; |
| vap->tdls_chan_switching = 0; |
| vap->tdls_cs_disassoc_pending = 0; |
| vap->tdls_cs_node = NULL; |
| spin_lock_init(&vap->tdls_ps_lock); |
| } |
| } |
| |
| int |
| ieee80211_vap_setup(struct ieee80211com *ic, struct net_device *dev, |
| const char *name, int unit, int opmode, int flags) |
| { |
| #define IEEE80211_C_OPMODE \ |
| (IEEE80211_C_IBSS | IEEE80211_C_HOSTAP | IEEE80211_C_AHDEMO | \ |
| IEEE80211_C_MONITOR) |
| struct ieee80211vap *vap = netdev_priv(dev); |
| struct net_device_ops *pndo = (struct net_device_ops *)dev->netdev_ops; |
| int err; |
| |
| if (name != NULL) { |
| if (strchr(name, '%')) { |
| if ((err = dev_alloc_name(dev, name)) < 0) { |
| printk(KERN_ERR "can't alloc name %s\n", name); |
| return err; |
| } |
| } else { |
| strncpy(dev->name, name, sizeof(dev->name)); |
| } |
| } |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0) |
| pndo->ndo_get_stats64 = ieee80211_getstats64; |
| #else |
| pndo->ndo_get_stats = ieee80211_getstats; |
| #endif |
| pndo->ndo_open = ieee80211_open; |
| pndo->ndo_stop = ieee80211_stop; |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0) |
| pndo->ndo_set_rx_mode = ieee80211_set_multicast_list; |
| #else |
| pndo->ndo_set_multicast_list = ieee80211_set_multicast_list; |
| #endif |
| pndo->ndo_change_mtu = ieee80211_change_mtu; |
| dev->tx_queue_len = QTN_BUFS_WMAC_TX_QDISC; |
| |
| /* |
| * The caller is assumed to allocate the device with |
| * alloc_etherdev or similar so we arrange for the |
| * space to be reclaimed accordingly. |
| */ |
| dev->destructor = free_netdev; |
| |
| vap->iv_ic = ic; |
| vap->iv_dev = dev; /* back pointer */ |
| vap->iv_unit = unit; |
| vap->iv_flags = ic->ic_flags; /* propagate common flags */ |
| vap->iv_flags_ext = ic->ic_flags_ext; |
| vap->iv_xrvap = NULL; |
| vap->iv_ath_cap = ic->ic_ath_cap; |
| /* Default Multicast traffic to lowest rate of 1000 Kbps*/ |
| vap->iv_mcast_rate = 1000; |
| |
| vap->iv_caps = ic->ic_caps &~ IEEE80211_C_OPMODE; |
| |
| /* Enabling short GI by default. This may be right place to set it */ |
| vap->iv_ht_flags |= IEEE80211_HTF_SHORTGI_ENABLED; |
| vap->iv_ht_flags |= IEEE80211_HTF_LDPC_ENABLED; |
| |
| /* Initialize vht capability flags */ |
| vap->iv_vht_flags = ic->ic_vhtcap.cap_flags; |
| |
| /* Disable STBC by default */ |
| vap->iv_ht_flags &= ~(IEEE80211_HTCAP_C_TXSTBC | IEEE80211_HTCAP_C_RXSTBC); |
| vap->iv_vht_flags &= ~(IEEE80211_VHTCAP_C_TX_STBC); |
| |
| vap->iv_rx_amsdu_enable = QTN_RX_AMSDU_DYNAMIC; |
| vap->iv_rx_amsdu_threshold_cca = IEEE80211_RX_AMSDU_THRESHOLD_CCA; |
| vap->iv_rx_amsdu_threshold_pmbl = IEEE80211_RX_AMSDU_THRESHOLD_PMBL; |
| vap->iv_rx_amsdu_pmbl_wf_sp = IEEE80211_RX_AMSDU_PMBL_WF_SP; |
| vap->iv_rx_amsdu_pmbl_wf_lp = IEEE80211_RX_AMSDU_PMBL_WF_LP; |
| |
| switch (opmode) { |
| case IEEE80211_M_STA: |
| /* WDS/Repeater */ |
| if (flags & IEEE80211_NO_STABEACONS) |
| { |
| vap->iv_flags_ext |= IEEE80211_FEXT_SWBMISS; |
| vap->iv_link_loss_enabled = 1; |
| vap->iv_bcn_miss_thr = 0; |
| } |
| vap->iv_caps |= IEEE80211_C_WDS; |
| vap->iv_flags_ext |= IEEE80211_FEXT_WDS; |
| /* do DBS specific initialization, keep it open for all chipset, |
| * as we don't want chip specific execution here, for RF with no |
| * dual band support, these initiazation won't be referenced. |
| */ |
| vap->iv_pref_band = IEEE80211_5Ghz; |
| /* 2,4ghz specific station profile */ |
| vap->iv_2_4ghz_prof.phy_mode = IEEE80211_MODE_11NG_HT40PM; |
| vap->iv_2_4ghz_prof.vht = 0; |
| vap->iv_2_4ghz_prof.bw = 40; |
| |
| /* 5ghz specific station profile */ |
| vap->iv_5ghz_prof.phy_mode = IEEE80211_MODE_11AC_VHT80PM; |
| vap->iv_5ghz_prof.vht = 1; |
| vap->iv_5ghz_prof.bw = 80; |
| break; |
| case IEEE80211_M_IBSS: |
| vap->iv_caps |= IEEE80211_C_IBSS; |
| vap->iv_ath_cap &= ~IEEE80211_ATHC_XR; |
| break; |
| case IEEE80211_M_AHDEMO: |
| vap->iv_caps |= IEEE80211_C_AHDEMO; |
| vap->iv_ath_cap &= ~IEEE80211_ATHC_XR; |
| break; |
| case IEEE80211_M_HOSTAP: |
| vap->iv_caps |= IEEE80211_C_HOSTAP; |
| vap->iv_ath_cap &= ~IEEE80211_ATHC_TURBOP; |
| if ((vap->iv_flags & IEEE80211_VAP_XR) == 0) |
| vap->iv_ath_cap &= ~IEEE80211_ATHC_XR; |
| vap->iv_caps |= IEEE80211_C_WDS; |
| vap->iv_flags_ext |= IEEE80211_FEXT_WDS; |
| vap->iv_flags |= IEEE80211_F_DROPUNENC; |
| vap->iv_flags_ext2 = IEEE80211_FEXT_SYNC_CONFIG; |
| break; |
| case IEEE80211_M_MONITOR: |
| vap->iv_caps |= IEEE80211_C_MONITOR; |
| vap->iv_ath_cap &= ~(IEEE80211_ATHC_XR | IEEE80211_ATHC_TURBOP); |
| break; |
| case IEEE80211_M_WDS: |
| vap->iv_caps |= IEEE80211_C_WDS; |
| vap->iv_ath_cap &= ~(IEEE80211_ATHC_XR | IEEE80211_ATHC_TURBOP); |
| vap->iv_flags_ext |= IEEE80211_FEXT_WDS; |
| /* Set WDS according to Extender Role */ |
| ieee80211_vap_wds_mode_change(vap); |
| break; |
| } |
| vap->iv_opmode = opmode; |
| IEEE80211_INIT_TQUEUE(&vap->iv_stajoin1tq, ieee80211_sta_join1_tasklet, vap); |
| |
| vap->iv_chanchange_count = 0; |
| |
| /* |
| * Enable various functionality by default if we're capable. |
| */ |
| if (vap->iv_caps & IEEE80211_C_WME) |
| vap->iv_flags |= IEEE80211_F_WME; |
| if (vap->iv_caps & IEEE80211_C_FF) |
| vap->iv_flags |= IEEE80211_F_FF; |
| |
| vap->iv_dtim_period = IEEE80211_DTIM_DEFAULT; |
| |
| vap->iv_monitor_crc_errors = 0; |
| vap->iv_monitor_phy_errors = 0; |
| |
| /* Defaults for implicit BA and global BA mask */ |
| vap->iv_ba_control = 0xFFFF; |
| vap->iv_implicit_ba = 0x1; |
| vap->iv_max_ba_win_size = IEEE80211_DEFAULT_BA_WINSIZE; |
| |
| vap->iv_mcs_config = IEEE80211_MCS_AUTO_RATE_ENABLE; |
| |
| /* initialize TDLS Function */ |
| ieee80211_vap_init_tdls(vap); |
| |
| /* Only need the peer entry in AID table for WDS mode VAP */ |
| if (opmode == IEEE80211_M_WDS) |
| vap->iv_max_aid = 1; |
| |
| IEEE80211_ADDR_COPY(vap->iv_myaddr, dev->dev_addr); |
| /* NB: defer setting dev_addr so driver can override */ |
| |
| vap->iv_blacklist_timeout = msecs_to_jiffies(IEEE80211_BLACKLIST_TIMEOUT * MSEC_PER_SEC); |
| #define IEEE80211_RATE_TRAINING_COUNT_DEFAULT 300 |
| #define IEEE80211_RATE_TRAINING_BURST_COUNT_DEFAULT 32 |
| vap->iv_rate_training_count = IEEE80211_RATE_TRAINING_COUNT_DEFAULT; |
| vap->iv_rate_training_burst_count = IEEE80211_RATE_TRAINING_BURST_COUNT_DEFAULT; |
| vap->iv_mc_to_uc = IEEE80211_QTN_MC_TO_UC_LEGACY; |
| vap->iv_reliable_bcst = 1; |
| vap->iv_ap_fwd_lncb = 1; |
| vap->iv_tx_amsdu = 1; |
| vap->iv_tx_amsdu_11n = 1; |
| vap->iv_tx_max_amsdu = IEEE80211_VHTCAP_MAX_MPDU_11454; |
| vap->allow_tkip_for_vht = 0; |
| vap->is_block_all_assoc = 0; |
| vap->iv_vap_state = IEEE80211_VAP_STATE_ENABLED; |
| |
| ieee80211_crypto_vattach(vap); |
| ieee80211_node_vattach(vap); |
| ieee80211_power_vattach(vap); |
| ieee80211_proto_vattach(vap); |
| ieee80211_scan_vattach(vap); |
| ieee80211_vlan_vattach(vap); |
| ieee80211_ioctl_vattach(vap); |
| ieee80211_sysctl_vattach(vap); |
| |
| return 1; |
| #undef IEEE80211_C_OPMODE |
| } |
| EXPORT_SYMBOL(ieee80211_vap_setup); |
| |
| int |
| ieee80211_vap_attach(struct ieee80211vap *vap, |
| ifm_change_cb_t media_change, ifm_stat_cb_t media_status) |
| { |
| struct net_device *dev = vap->iv_dev; |
| struct ieee80211com *ic = vap->iv_ic; |
| struct ifmediareq imr; |
| |
| ieee80211_node_latevattach(vap); /* XXX move into vattach */ |
| ieee80211_power_latevattach(vap); /* XXX move into vattach */ |
| |
| memset(vap->wds_mac, 0x00, IEEE80211_ADDR_LEN); |
| |
| (void) ieee80211_media_setup(ic, &vap->iv_media, |
| vap->iv_caps, media_change, media_status); |
| ieee80211_media_status((void *) vap, &imr); |
| ifmedia_set(&vap->iv_media, imr.ifm_active); |
| |
| IEEE80211_LOCK_IRQ(ic); |
| TAILQ_INSERT_TAIL(&ic->ic_vaps, vap, iv_next); |
| IEEE80211_UNLOCK_IRQ(ic); |
| |
| IEEE80211_ADDR_COPY(dev->dev_addr, vap->iv_myaddr); |
| |
| ieee80211_scanner_get(vap->iv_opmode, 1); |
| |
| ic->ic_pm_reason = IEEE80211_PM_LEVEL_VAP_ATTACH; |
| |
| ieee80211_pm_queue_work(ic); |
| |
| ieee80211_wme_initparams(vap); |
| |
| /* Fix issue that tx power will be abnormal when dynamically switch from station mode to AP mode*/ |
| ieee80211_pwr_adjust(vap, 0); |
| |
| ieee80211_tdls_vattach(vap); |
| |
| INIT_LIST_HEAD(&vap->sample_sta_list); |
| spin_lock_init(&vap->sample_sta_lock); |
| vap->sample_sta_count = 0; |
| |
| /* NB: rtnl is held on entry so don't use register_netdev */ |
| if (register_netdevice(dev)) { |
| printk(KERN_ERR "%s: unable to register device\n", dev->name); |
| return 0; |
| } else { |
| return 1; |
| } |
| } |
| EXPORT_SYMBOL(ieee80211_vap_attach); |
| |
| void |
| ieee80211_vap_detach(struct ieee80211vap *vap) |
| { |
| struct ieee80211com *ic = vap->iv_ic; |
| |
| IEEE80211_CANCEL_TQUEUE(&vap->iv_stajoin1tq); |
| IEEE80211_LOCK_IRQ(ic); |
| TAILQ_REMOVE(&ic->ic_vaps, vap, iv_next); |
| if (TAILQ_EMPTY(&ic->ic_vaps)) /* reset to supported mode */ |
| ic->ic_opmode = IEEE80211_M_STA; |
| IEEE80211_UNLOCK_IRQ(ic); |
| |
| /* |
| * Change state to 'INIT' to disassociate WDS peer node |
| */ |
| if (vap->iv_opmode == IEEE80211_M_WDS) |
| ieee80211_new_state(vap, IEEE80211_S_INIT, 0); |
| |
| ifmedia_removeall(&vap->iv_media); |
| |
| sample_rel_client_data(vap); |
| ieee80211_mac_acl(vap, IEEE80211_MACCMD_DETACH); |
| ieee80211_sysctl_vdetach(vap); |
| ieee80211_proc_cleanup(vap); |
| ieee80211_ioctl_vdetach(vap); |
| ieee80211_vlan_vdetach(vap); |
| ieee80211_scan_vdetach(vap); |
| ieee80211_proto_vdetach(vap); |
| ieee80211_crypto_vdetach(vap); |
| ieee80211_power_vdetach(vap); |
| ieee80211_tdls_vdetach(vap); |
| ieee80211_node_vdetach(vap); |
| ieee80211_vap_remove_ie(vap); |
| ieee80211_extender_vdetach(vap); |
| |
| ic->ic_pm_reason = IEEE80211_PM_LEVEL_VAP_DETACH; |
| |
| ieee80211_pm_queue_work(ic); |
| |
| } |
| EXPORT_SYMBOL(ieee80211_vap_detach); |
| |
| void |
| ieee80211_vap_detach_late(struct ieee80211vap *vap) |
| { |
| /* NB: rtnl is held on entry so don't use unregister_netdev */ |
| unregister_netdevice(vap->iv_dev); |
| } |
| EXPORT_SYMBOL(ieee80211_vap_detach_late); |
| |
| /* |
| * Convert MHz frequency to IEEE channel number. |
| */ |
| u_int |
| ieee80211_mhz2ieee(u_int freq, u_int flags) |
| { |
| if (flags & IEEE80211_CHAN_2GHZ) { /* 2GHz band */ |
| if (freq == 2484) /* Japan */ |
| return 14; |
| if ((freq >= 2412) && (freq < 2484)) /* don't number non-IEEE channels */ |
| return (freq - 2407) / 5; |
| return 0; |
| } else if (flags & IEEE80211_CHAN_5GHZ) { /* 5Ghz band */ |
| if ((freq >= 5150) && (freq <= 5845)) /* don't number non-IEEE channels */ |
| return (freq - 5000) / 5; |
| return 0; |
| } else { |
| /* something is fishy, don't do anything */ |
| return 0; |
| } |
| } |
| EXPORT_SYMBOL(ieee80211_mhz2ieee); |
| |
| /* |
| * Convert channel to IEEE channel number. |
| */ |
| u_int |
| ieee80211_chan2ieee(struct ieee80211com *ic, const struct ieee80211_channel *c) |
| { |
| if (c == NULL) { |
| printk("invalid channel (NULL)\n"); |
| return 0; |
| } |
| return (c == IEEE80211_CHAN_ANYC ? IEEE80211_CHAN_ANY : c->ic_ieee); |
| } |
| EXPORT_SYMBOL(ieee80211_chan2ieee); |
| |
| /* |
| * Convert IEEE channel number to MHz frequency. |
| */ |
| u_int |
| ieee80211_ieee2mhz(u_int chan, u_int flags) |
| { |
| if (flags & IEEE80211_CHAN_2GHZ) { /* 2GHz band */ |
| if (chan == 14) |
| return 2484; |
| if (chan < 14) |
| return 2407 + chan * 5; |
| else |
| return 2512 + ((chan - 15) * 20); |
| } else if (flags & IEEE80211_CHAN_5GHZ) { /* 5Ghz band */ |
| return 5000 + (chan * 5); |
| } else { /* either, guess */ |
| if (chan == 14) |
| return 2484; |
| if (chan < 14) /* 0-13 */ |
| return 2407 + chan * 5; |
| if (chan < 27) /* 15-26 */ |
| return 2512 + ((chan - 15) * 20); |
| return 5000 + (chan * 5); |
| } |
| } |
| EXPORT_SYMBOL(ieee80211_ieee2mhz); |
| |
| /* |
| * Locate a channel given a frequency+flags. We cache |
| * the previous lookup to optimize swithing between two |
| * channels--as happens with dynamic turbo. |
| */ |
| struct ieee80211_channel * |
| ieee80211_find_channel(struct ieee80211com *ic, int freq, int flags) |
| { |
| struct ieee80211_channel *c; |
| int i; |
| |
| flags &= IEEE80211_CHAN_ALLTURBO; |
| c = ic->ic_prevchan; |
| if (c != NULL && c->ic_freq == freq && |
| (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags) |
| return c; |
| /* brute force search */ |
| for (i = 0; i < ic->ic_nchans; i++) { |
| c = &ic->ic_channels[i]; |
| if (c->ic_freq == freq) /* && |
| (c->ic_flags & IEEE80211_CHAN_ALLTURBO) == flags) */ |
| return c; |
| } |
| return NULL; |
| } |
| EXPORT_SYMBOL(ieee80211_find_channel); |
| |
| /* |
| * Setup the media data structures according to the channel and |
| * rate tables. This must be called by the driver after |
| * ieee80211_attach and before most anything else. |
| */ |
| int |
| ieee80211_media_setup(struct ieee80211com *ic, |
| struct ifmedia *media, u_int32_t caps, |
| ifm_change_cb_t media_change, ifm_stat_cb_t media_stat) |
| { |
| #define ADD(_media, _s, _o) \ |
| ifmedia_add(_media, IFM_MAKEWORD(IFM_IEEE80211, (_s), (_o), 0), 0, NULL) |
| int i, j, mode, rate, maxrate, mword, mopt, r; |
| struct ieee80211_rateset *rs; |
| struct ieee80211_rateset allrates; |
| |
| /* |
| * Fill in media characteristics. |
| */ |
| ifmedia_init(media, 0, media_change, media_stat); |
| maxrate = 0; |
| memset(&allrates, 0, sizeof(allrates)); |
| for (mode = IEEE80211_MODE_AUTO; mode < IEEE80211_MODE_MAX; mode++) { |
| static const u_int mopts[] = { |
| IFM_AUTO, |
| IFM_IEEE80211_11A, |
| IFM_IEEE80211_11B, |
| IFM_IEEE80211_11G, |
| IFM_IEEE80211_FH, |
| IFM_IEEE80211_11A | IFM_IEEE80211_TURBO, |
| IFM_IEEE80211_11G | IFM_IEEE80211_TURBO, |
| IFM_IEEE80211_11NA, |
| IFM_IEEE80211_11NG, |
| IFM_IEEE80211_11NG_HT40PM, |
| IFM_IEEE80211_11NA_HT40PM, |
| IFM_IEEE80211_11AC_VHT20PM, |
| IFM_IEEE80211_11AC_VHT40PM, |
| IFM_IEEE80211_11AC_VHT80PM, |
| IFM_IEEE80211_11AC_VHT160PM, |
| }; |
| if ((ic->ic_modecaps & (1<<mode)) == 0) |
| continue; |
| mopt = mopts[mode]; |
| ADD(media, IFM_AUTO, mopt); /* e.g. 11a auto */ |
| if (caps & IEEE80211_C_IBSS) |
| ADD(media, IFM_AUTO, mopt | IFM_IEEE80211_ADHOC); |
| if (caps & IEEE80211_C_HOSTAP) |
| ADD(media, IFM_AUTO, mopt | IFM_IEEE80211_HOSTAP); |
| if (caps & IEEE80211_C_AHDEMO) |
| ADD(media, IFM_AUTO, mopt | IFM_IEEE80211_ADHOC | IFM_FLAG0); |
| if (caps & IEEE80211_C_MONITOR) |
| ADD(media, IFM_AUTO, mopt | IFM_IEEE80211_MONITOR); |
| if (caps & IEEE80211_C_WDS) |
| ADD(media, IFM_AUTO, mopt | IFM_IEEE80211_WDS); |
| if (mode == IEEE80211_MODE_AUTO) |
| continue; |
| rs = &ic->ic_sup_rates[mode]; |
| for (i = 0; i < rs->rs_nrates; i++) { |
| rate = rs->rs_rates[i]; |
| if(mode < IEEE80211_MODE_11NA) |
| mword = ieee80211_rate2media(ic, rate, mode); |
| else |
| { |
| /* This may contain both legacy and 11n rates */ |
| if(i < IEEE80211_RATE_SIZE) // 8 Legacy rates |
| rate = rate & IEEE80211_RATE_VAL; |
| |
| mword = ieee80211_mcs2media(ic, rate, mode); |
| } |
| |
| if (mword == 0) |
| continue; |
| ADD(media, mword, mopt); |
| if (caps & IEEE80211_C_IBSS) |
| ADD(media, mword, mopt | IFM_IEEE80211_ADHOC); |
| if (caps & IEEE80211_C_HOSTAP) |
| ADD(media, mword, mopt | IFM_IEEE80211_HOSTAP); |
| if (caps & IEEE80211_C_AHDEMO) |
| ADD(media, mword, mopt | IFM_IEEE80211_ADHOC | IFM_FLAG0); |
| if (caps & IEEE80211_C_MONITOR) |
| ADD(media, mword, mopt | IFM_IEEE80211_MONITOR); |
| if (caps & IEEE80211_C_WDS) |
| ADD(media, mword, mopt | IFM_IEEE80211_WDS); |
| /* |
| * Add rate to the collection of all rates. |
| */ |
| r = rate & IEEE80211_RATE_VAL; |
| for (j = 0; j < allrates.rs_nrates; j++) |
| if (allrates.rs_rates[j] == r) |
| break; |
| if (j == allrates.rs_nrates) { |
| /* unique, add to the set */ |
| allrates.rs_rates[j] = r; |
| allrates.rs_nrates++; |
| } |
| rate = (rate & IEEE80211_RATE_VAL) / 2; |
| if (rate > maxrate) |
| maxrate = rate; |
| } |
| } |
| for (i = 0; i < allrates.rs_nrates; i++) { |
| if(mode < IEEE80211_MODE_11NA) |
| mword = ieee80211_rate2media(ic, allrates.rs_rates[i], |
| IEEE80211_MODE_AUTO); |
| else |
| mword = ieee80211_mcs2media(ic, allrates.rs_rates[i], |
| IEEE80211_MODE_AUTO); |
| if (mword == 0) |
| continue; |
| mword = IFM_SUBTYPE(mword); /* remove media options */ |
| ADD(media, mword, 0); |
| if (caps & IEEE80211_C_IBSS) |
| ADD(media, mword, IFM_IEEE80211_ADHOC); |
| if (caps & IEEE80211_C_HOSTAP) |
| ADD(media, mword, IFM_IEEE80211_HOSTAP); |
| if (caps & IEEE80211_C_AHDEMO) |
| ADD(media, mword, IFM_IEEE80211_ADHOC | IFM_FLAG0); |
| if (caps & IEEE80211_C_MONITOR) |
| ADD(media, mword, IFM_IEEE80211_MONITOR); |
| if (caps & IEEE80211_C_WDS) |
| ADD(media, mword, IFM_IEEE80211_WDS); |
| } |
| return maxrate; |
| #undef ADD |
| } |
| |
| void |
| ieee80211_announce(struct ieee80211com *ic) |
| { |
| int i, mode, rate, mword; |
| struct ieee80211_rateset *rs; |
| |
| for (mode = IEEE80211_MODE_11A; mode < IEEE80211_MODE_MAX; mode++) { |
| if ((ic->ic_modecaps & (1<<mode)) == 0) |
| continue; |
| printk("%s rates: ", ieee80211_phymode_name[mode]); |
| rs = &ic->ic_sup_rates[mode]; |
| for (i = 0; i < rs->rs_nrates; i++) { |
| rate = rs->rs_rates[i]; |
| mword = ieee80211_rate2media(ic, rate, mode); |
| if (mword == 0) |
| continue; |
| printf("%s%d%sMbps", (i != 0 ? " " : ""), |
| (rate & IEEE80211_RATE_VAL) / 2, |
| ((rate & 0x1) != 0 ? ".5" : "")); |
| } |
| printf("\n"); |
| } |
| |
| printk("H/W encryption support:"); |
| |
| if (ic->ic_caps & IEEE80211_C_WEP) |
| printk(" WEP"); |
| if (ic->ic_caps & IEEE80211_C_AES) |
| printk(" AES"); |
| if (ic->ic_caps & IEEE80211_C_AES_CCM) |
| printk(" AES_CCM"); |
| if (ic->ic_caps & IEEE80211_C_CKIP) |
| printk(" CKIP"); |
| if (ic->ic_caps & IEEE80211_C_TKIP) |
| printk(" TKIP"); |
| printk("\n"); |
| } |
| EXPORT_SYMBOL(ieee80211_announce); |
| |
| void |
| ieee80211_announce_channels(struct ieee80211com *ic) |
| { |
| const struct ieee80211_channel *c; |
| char type; |
| int i; |
| |
| printf("Chan Freq RegPwr MinPwr MaxPwr\n"); |
| for (i = 0; i < ic->ic_nchans; i++) { |
| c = &ic->ic_channels[i]; |
| if (IEEE80211_IS_CHAN_ST(c)) |
| type = 'S'; |
| else if (IEEE80211_IS_CHAN_108A(c)) |
| type = 'T'; |
| else if (IEEE80211_IS_CHAN_108G(c)) |
| type = 'G'; |
| else if (IEEE80211_IS_CHAN_A(c)) |
| type = 'a'; |
| else if (IEEE80211_IS_CHAN_11NG(c)) |
| type = 'n'; |
| else if (IEEE80211_IS_CHAN_11NA(c)) |
| type = 'n'; |
| else if (IEEE80211_IS_CHAN_ANYG(c)) |
| type = 'g'; |
| else if (IEEE80211_IS_CHAN_B(c)) |
| type = 'b'; |
| else |
| type = 'f'; |
| printf("%4d %4d%c %6d %6d %6d\n" |
| , c->ic_ieee, c->ic_freq, type |
| , c->ic_maxregpower |
| , c->ic_minpower, c->ic_maxpower |
| ); |
| } |
| } |
| EXPORT_SYMBOL(ieee80211_announce_channels); |
| |
| /* |
| * Common code to calculate the media status word |
| */ |
| static int |
| media_status(enum ieee80211_opmode opmode, u_int16_t mode) |
| { |
| int status; |
| |
| status = IFM_IEEE80211; |
| switch (opmode) { |
| case IEEE80211_M_STA: |
| break; |
| case IEEE80211_M_AHDEMO: |
| status |= IFM_IEEE80211_ADHOC | IFM_FLAG0; |
| break; |
| case IEEE80211_M_IBSS: |
| status |= IFM_IEEE80211_ADHOC; |
| break; |
| case IEEE80211_M_HOSTAP: |
| status |= IFM_IEEE80211_HOSTAP; |
| break; |
| case IEEE80211_M_MONITOR: |
| status |= IFM_IEEE80211_MONITOR; |
| break; |
| case IEEE80211_M_WDS: |
| status |= IFM_IEEE80211_WDS; |
| break; |
| } |
| |
| status |= IFM_MAKEMODE(mode); |
| |
| return status; |
| } |
| |
| /* |
| * Handle a media requests on the base interface. |
| */ |
| static void |
| ieee80211com_media_status(void *data, struct ifmediareq *imr) |
| { |
| struct ieee80211com *ic = (struct ieee80211com *) data; |
| |
| imr->ifm_status = IFM_AVALID; |
| if (!TAILQ_EMPTY(&ic->ic_vaps)) |
| imr->ifm_status |= IFM_ACTIVE; |
| imr->ifm_active = media_status(ic->ic_opmode, 0); |
| } |
| |
| /* |
| * Convert a media specification to an 802.11 phy mode. |
| */ |
| static int |
| media2mode(const struct ifmedia_entry *ime, enum ieee80211_phymode *mode) |
| { |
| |
| switch (IFM_MODE(ime->ifm_media)) { |
| case IFM_IEEE80211_11A: |
| *mode = IEEE80211_MODE_11A; |
| break; |
| case IFM_IEEE80211_11B: |
| *mode = IEEE80211_MODE_11B; |
| break; |
| case IFM_IEEE80211_11G: |
| *mode = IEEE80211_MODE_11G; |
| break; |
| case IFM_IEEE80211_11NG: |
| *mode = IEEE80211_MODE_11NG; |
| break; |
| case IFM_IEEE80211_11NA: |
| *mode = IEEE80211_MODE_11NA; |
| break; |
| case IFM_IEEE80211_11NG_HT40PM: |
| *mode = IEEE80211_MODE_11NG_HT40PM; |
| break; |
| case IFM_IEEE80211_11NA_HT40PM: |
| *mode = IEEE80211_MODE_11NA_HT40PM; |
| break; |
| case IFM_IEEE80211_FH: |
| *mode = IEEE80211_MODE_FH; |
| break; |
| case IFM_IEEE80211_11AC_VHT20PM: |
| *mode = IEEE80211_MODE_11AC_VHT20PM; |
| break; |
| case IFM_IEEE80211_11AC_VHT40PM: |
| *mode = IEEE80211_MODE_11AC_VHT40PM; |
| break; |
| case IFM_IEEE80211_11AC_VHT80PM: |
| *mode = IEEE80211_MODE_11AC_VHT80PM; |
| break; |
| case IFM_IEEE80211_11AC_VHT160PM: |
| *mode = IEEE80211_MODE_11AC_VHT160PM; |
| break; |
| case IFM_AUTO: |
| *mode = IEEE80211_MODE_AUTO; |
| break; |
| default: |
| return 0; |
| } |
| /* |
| * Turbo mode is an ``option''. |
| * XXX: Turbo currently does not apply to AUTO |
| */ |
| if (ime->ifm_media & IFM_IEEE80211_TURBO) { |
| if (*mode == IEEE80211_MODE_11A) |
| *mode = IEEE80211_MODE_TURBO_A; |
| else if (*mode == IEEE80211_MODE_11G) |
| *mode = IEEE80211_MODE_TURBO_G; |
| else |
| return 0; |
| } |
| return 1; |
| } |
| |
| static int |
| ieee80211com_media_change(void *data) |
| { |
| struct ieee80211com *ic = (struct ieee80211com *) data; |
| struct ieee80211vap *vap; |
| struct ifmedia_entry *ime = ic->ic_media.ifm_cur; |
| enum ieee80211_phymode newphymode; |
| int j, error = 0; |
| |
| /* XXX is rtnl held here? */ |
| /* |
| * First, identify the phy mode. |
| */ |
| if (!media2mode(ime, &newphymode)) |
| return -EINVAL; |
| /* NB: mode must be supported, no need to check */ |
| /* |
| * Autoselect doesn't make sense when operating as an AP. |
| * If no phy mode has been selected, pick one and lock it |
| * down so rate tables can be used in forming beacon frames |
| * and the like. |
| */ |
| |
| if (ic->ic_opmode == IEEE80211_M_HOSTAP && |
| newphymode == IEEE80211_MODE_AUTO) { |
| for (j = IEEE80211_MODE_11A; j < IEEE80211_MODE_MAX; j++) |
| if (ic->ic_modecaps & (1 << j)) { |
| newphymode = j; |
| break; |
| } |
| } |
| |
| /* |
| * Handle phy mode change. |
| */ |
| |
| IEEE80211_LOCK_IRQ(ic); |
| if (ic->ic_curmode != newphymode) { /* change phy mode */ |
| error = ieee80211_setmode(ic, newphymode); |
| if (error != 0) { |
| IEEE80211_UNLOCK_IRQ_EARLY(ic); |
| return error; |
| } |
| TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) { |
| /* reset WME state */ |
| ieee80211_wme_initparams_locked(vap); |
| ieee80211_adjust_wme_by_vappri(ic); |
| /* |
| * Setup an initial rate set according to the |
| * current/default channel selected above. This |
| * will be changed when scanning but must exist |
| * now so drivers have a consistent state. |
| */ |
| KASSERT(vap->iv_bss != NULL, ("no bss node")); |
| vap->iv_bss->ni_rates = ic->ic_sup_rates[newphymode]; |
| } |
| error = -ENETRESET; |
| } |
| IEEE80211_UNLOCK_IRQ(ic); |
| |
| #ifdef notdef |
| if (error == 0) |
| ifp->if_baudrate = ifmedia_baudrate(ime->ifm_media); |
| #endif |
| return error; |
| } |
| |
| static int |
| findrate(struct ieee80211com *ic, enum ieee80211_phymode mode, int rate) |
| { |
| #define IEEERATE(_ic,_m,_i) \ |
| ((_ic)->ic_sup_rates[_m].rs_rates[_i] & IEEE80211_RATE_VAL) |
| #define IEEE11NRATE(_ic,_m,_i) \ |
| ((_ic)->ic_sup_rates[_m].rs_rates[_i]) |
| int i, nrates = ic->ic_sup_rates[mode].rs_nrates; |
| for (i = 0; i < nrates; i++) |
| { |
| if(i < IEEE80211_RATE_SIZE) |
| { |
| /* Legacy Rates */ |
| if (IEEERATE(ic, mode, i) == rate) |
| return i; |
| } |
| else |
| { |
| /* 11n rates */ |
| if (IEEE11NRATE(ic, mode, i) == rate) |
| return i; |
| } |
| } |
| return -1; |
| #undef IEEERATE |
| #undef IEEE11NRATE |
| } |
| |
| /* |
| * Convert a media specification to a rate index and possibly a mode |
| * (if the rate is fixed and the mode is specified as ``auto'' then |
| * we need to lock down the mode so the index is meaningful). |
| */ |
| static int |
| checkrate(struct ieee80211com *ic, enum ieee80211_phymode mode, int rate) |
| { |
| |
| /* |
| * Check the rate table for the specified/current phy. |
| */ |
| if (mode == IEEE80211_MODE_AUTO) { |
| int i; |
| /* |
| * In autoselect mode search for the rate. |
| */ |
| for (i = IEEE80211_MODE_11A; i < IEEE80211_MODE_MAX; i++) { |
| if ((ic->ic_modecaps & (1 << i)) && |
| findrate(ic, i, rate) != -1) |
| return 1; |
| } |
| return 0; |
| } else { |
| /* |
| * Mode is fixed, check for rate. |
| */ |
| return (findrate(ic, mode, rate) != -1); |
| } |
| } |
| |
| /* |
| * Handle a media change request; the only per-vap |
| * information that is meaningful is the fixed rate |
| * and desired phy mode. |
| */ |
| int |
| ieee80211_media_change(void *data) |
| { |
| struct ieee80211vap *vap = (struct ieee80211vap *) data; |
| struct ieee80211com *ic = vap->iv_ic; |
| struct ifmedia_entry *ime = vap->iv_media.ifm_cur; |
| enum ieee80211_phymode newmode; |
| int newrate, error; |
| |
| /* |
| * First, identify the desired phy mode. |
| */ |
| if (!media2mode(ime, &newmode)) { |
| return -EINVAL; |
| } |
| |
| /* |
| * Check for fixed/variable rate. |
| */ |
| if (IFM_SUBTYPE(ime->ifm_media) != IFM_AUTO) { |
| /* |
| * Convert media subtype to rate and potentially |
| * lock down the mode. |
| */ |
| |
| if(newmode >= IEEE80211_MODE_11NA) |
| newrate = ieee80211_media2mcs(ime->ifm_media); |
| else |
| newrate = ieee80211_media2rate(ime->ifm_media); |
| |
| if (newrate == 0 || !checkrate(ic, newmode, newrate)) |
| { |
| return -EINVAL; |
| } |
| } else |
| newrate = IEEE80211_FIXED_RATE_NONE; |
| |
| /* |
| * Install the rate+mode settings. |
| */ |
| error = 0; |
| if (vap->iv_fixed_rate != newrate || |
| newrate == IEEE80211_FIXED_RATE_NONE) { |
| vap->iv_fixed_rate = newrate; /* fixed tx rate */ |
| error = -ENETRESET; |
| |
| if (newrate == IEEE80211_FIXED_RATE_NONE) |
| newrate = 0x90; // To put MuC in Auto Rate |
| |
| /* Forward these parameters to the driver and MuC */ |
| ieee80211_param_to_qdrv(vap, IEEE80211_PARAM_FIXED_TX_RATE, newrate, NULL, 0); |
| } |
| |
| if (ic->ic_des_mode != newmode) { |
| ic->ic_des_mode = newmode; /* desired phymode */ |
| error = -ENETRESET; |
| } |
| return error; |
| } |
| EXPORT_SYMBOL(ieee80211_media_change); |
| |
| void |
| ieee80211_media_status(void *data, struct ifmediareq *imr) |
| { |
| struct ieee80211vap *vap = (struct ieee80211vap *) data; |
| struct ieee80211com *ic = vap->iv_ic; |
| enum ieee80211_phymode mode; |
| int mediarate = IFM_AUTO; |
| |
| imr->ifm_status = IFM_AVALID; |
| /* |
| * NB: use the current channel's mode to lock down a xmit |
| * rate only when running; otherwise we may have a mismatch |
| * in which case the rate will not be convertible. |
| */ |
| if (vap->iv_state == IEEE80211_S_RUN) { |
| imr->ifm_status |= IFM_ACTIVE; |
| mode = ic->ic_curmode; |
| } else { |
| mode = IEEE80211_MODE_AUTO; |
| } |
| |
| /* |
| * FIXME: Bug #2324 |
| * Assumption that QTN devices support 5Ghz N channels so we |
| * calculate the IFM based on desired mode only |
| */ |
| imr->ifm_active = media_status(vap->iv_opmode, ic->ic_des_mode); |
| |
| /* |
| * Calculate a current rate if possible. |
| */ |
| if (vap->iv_state == IEEE80211_S_RUN) { |
| if (vap->iv_fixed_rate != IEEE80211_FIXED_RATE_NONE) { |
| /* |
| * A fixed rate is set, report that. |
| */ |
| if (mode < IEEE80211_MODE_11NA) { |
| /* Legacy mode */ |
| imr->ifm_active |= ieee80211_rate2media(ic, |
| vap->iv_fixed_rate, mode); |
| } else { |
| /* 11n mode */ |
| mediarate |= ieee80211_mcs2media(ic, |
| vap->iv_fixed_rate, mode); |
| if (IFM_AUTO == mediarate) |
| SCSDBG(SCSLOG_INFO, "Couldn't find compatible mediarate\n"); |
| imr->ifm_active |= mediarate; |
| } |
| } else { |
| imr->ifm_active |= IFM_AUTO; |
| } |
| } |
| } |
| EXPORT_SYMBOL(ieee80211_media_status); |
| |
| /* |
| * Set the current phy mode. |
| */ |
| int |
| ieee80211_setmode(struct ieee80211com *ic, enum ieee80211_phymode mode) |
| { |
| if (ic->ic_des_mode != IEEE80211_MODE_11B && |
| ic->ic_des_mode != IEEE80211_MODE_11A) { |
| ieee80211_reset_erp(ic, mode); /* reset ERP state */ |
| } |
| |
| ic->ic_curmode = mode; /* NB: must do post reset_erp */ |
| return 0; |
| } |
| EXPORT_SYMBOL(ieee80211_setmode); |
| |
| /* |
| * Return the phy mode for with the specified channel. |
| */ |
| enum ieee80211_phymode |
| ieee80211_chan2mode(const struct ieee80211_channel *chan) |
| { |
| /* |
| * Callers should handle this case properly, rather than |
| * just relying that this function returns a sane value. |
| * XXX Probably needs to be revised. |
| */ |
| KASSERT(chan != IEEE80211_CHAN_ANYC, ("channel not setup")); |
| |
| if (IEEE80211_IS_CHAN_11AC_VHT80_EDGEPLUS(chan)) |
| return IEEE80211_MODE_11AC_VHT80PM; |
| else if (IEEE80211_IS_CHAN_11AC_VHT80_CNTRPLUS(chan)) |
| return IEEE80211_MODE_11AC_VHT80PM; |
| else if (IEEE80211_IS_CHAN_11AC_VHT80_CNTRMINUS(chan)) |
| return IEEE80211_MODE_11AC_VHT80PM; |
| else if (IEEE80211_IS_CHAN_11AC_VHT80_EDGEMINUS(chan)) |
| return IEEE80211_MODE_11AC_VHT80PM; |
| if (IEEE80211_IS_CHAN_11AC_VHT40PLUS(chan)) |
| return IEEE80211_MODE_11AC_VHT40PM; |
| else if (IEEE80211_IS_CHAN_11AC_VHT40MINUS(chan)) |
| return IEEE80211_MODE_11AC_VHT40PM; |
| if (IEEE80211_IS_CHAN_11AC(chan)) |
| return IEEE80211_MODE_11AC_VHT20PM; |
| if (IEEE80211_IS_CHAN_11NG_HT40PLUS(chan)) |
| return IEEE80211_MODE_11NG_HT40PM; |
| else if (IEEE80211_IS_CHAN_11NG_HT40MINUS(chan)) |
| return IEEE80211_MODE_11NG_HT40PM; |
| if (IEEE80211_IS_CHAN_11NA_HT40PLUS(chan)) |
| return IEEE80211_MODE_11NA_HT40PM; |
| else if (IEEE80211_IS_CHAN_11NA_HT40MINUS(chan)) |
| return IEEE80211_MODE_11NA_HT40PM; |
| if (IEEE80211_IS_CHAN_11NG(chan)) |
| return IEEE80211_MODE_11NG; |
| else if (IEEE80211_IS_CHAN_11NA(chan)) |
| return IEEE80211_MODE_11NA; |
| else if (IEEE80211_IS_CHAN_108G(chan)) |
| return IEEE80211_MODE_TURBO_G; |
| else if (IEEE80211_IS_CHAN_TURBO(chan)) |
| return IEEE80211_MODE_TURBO_A; |
| else if (IEEE80211_IS_CHAN_A(chan)) |
| return IEEE80211_MODE_11A; |
| else if (IEEE80211_IS_CHAN_ANYG(chan)) |
| return IEEE80211_MODE_11G; |
| else if (IEEE80211_IS_CHAN_B(chan)) |
| return IEEE80211_MODE_11B; |
| else if (IEEE80211_IS_CHAN_FHSS(chan)) |
| return IEEE80211_MODE_FH; |
| |
| /* NB: should not get here */ |
| printk("%s: cannot map channel to mode; freq %u flags 0x%x\n", |
| __func__, chan->ic_freq, chan->ic_flags); |
| return IEEE80211_MODE_11B; |
| } |
| EXPORT_SYMBOL(ieee80211_chan2mode); |
| |
| /* |
| * convert IEEE80211 rate value to ifmedia subtype. |
| * ieee80211 rate is in unit of 0.5Mbps. |
| */ |
| int |
| ieee80211_rate2media(struct ieee80211com *ic, int rate, enum ieee80211_phymode mode) |
| { |
| #define N(a) (sizeof(a) / sizeof(a[0])) |
| static const struct { |
| u_int m; /* rate + mode */ |
| u_int r; /* if_media rate */ |
| } rates[] = { |
| { 2 | IFM_IEEE80211_FH, IFM_IEEE80211_FH1 }, |
| { 4 | IFM_IEEE80211_FH, IFM_IEEE80211_FH2 }, |
| { 2 | IFM_IEEE80211_11B, IFM_IEEE80211_DS1 }, |
| { 4 | IFM_IEEE80211_11B, IFM_IEEE80211_DS2 }, |
| { 11 | IFM_IEEE80211_11B, IFM_IEEE80211_DS5 }, |
| { 22 | IFM_IEEE80211_11B, IFM_IEEE80211_DS11 }, |
| { 44 | IFM_IEEE80211_11B, IFM_IEEE80211_DS22 }, |
| { 3 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM1_50 }, |
| { 4 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM2_25 }, |
| { 6 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM3 }, |
| { 9 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM4_50 }, |
| { 12 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM6 }, |
| { 18 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM9 }, |
| { 24 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM12 }, |
| { 27 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM13_5 }, |
| { 36 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM18 }, |
| { 48 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM24 }, |
| { 54 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM27 }, |
| { 72 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM36 }, |
| { 96 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM48 }, |
| { 108 | IFM_IEEE80211_11A, IFM_IEEE80211_OFDM54 }, |
| { 2 | IFM_IEEE80211_11G, IFM_IEEE80211_DS1 }, |
| { 4 | IFM_IEEE80211_11G, IFM_IEEE80211_DS2 }, |
| { 11 | IFM_IEEE80211_11G, IFM_IEEE80211_DS5 }, |
| { 22 | IFM_IEEE80211_11G, IFM_IEEE80211_DS11 }, |
| { 12 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM6 }, |
| { 18 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM9 }, |
| { 24 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM12 }, |
| { 36 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM18 }, |
| { 48 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM24 }, |
| { 72 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM36 }, |
| { 96 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM48 }, |
| { 108 | IFM_IEEE80211_11G, IFM_IEEE80211_OFDM54 }, |
| /* NB: OFDM72 doesn't really exist so we don't handle it */ |
| }; |
| u_int mask, i; |
| |
| mask = rate & IEEE80211_RATE_VAL; |
| switch (mode) { |
| case IEEE80211_MODE_11A: |
| case IEEE80211_MODE_TURBO_A: |
| mask |= IFM_IEEE80211_11A; |
| break; |
| case IEEE80211_MODE_11B: |
| mask |= IFM_IEEE80211_11B; |
| break; |
| case IEEE80211_MODE_FH: |
| mask |= IFM_IEEE80211_FH; |
| break; |
| case IEEE80211_MODE_AUTO: |
| /* NB: ic may be NULL for some drivers */ |
| if (ic && ic->ic_phytype == IEEE80211_T_FH) { |
| mask |= IFM_IEEE80211_FH; |
| break; |
| } |
| /* NB: hack, 11g matches both 11b+11a rates */ |
| /* fall thru... */ |
| case IEEE80211_MODE_11G: |
| case IEEE80211_MODE_TURBO_G: |
| mask |= IFM_IEEE80211_11G; |
| break; |
| default: |
| break; |
| } |
| for (i = 0; i < N(rates); i++) |
| if (rates[i].m == mask) |
| return rates[i].r; |
| return IFM_AUTO; |
| #undef N |
| } |
| EXPORT_SYMBOL(ieee80211_rate2media); |
| |
| int |
| ieee80211_mcs2media(struct ieee80211com *ic, int mcs, enum ieee80211_phymode mode) |
| { |
| #define N(a) (sizeof(a) / sizeof(a[0])) |
| static const struct { |
| u_int m; /* rate + mode */ |
| u_int r; /* if_media rate */ |
| } rates[] = { |
| |
| /* Only MCS0-MCS15 (2 streams) are supported */ |
| { 12 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_LEG_6 }, |
| { 18 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_LEG_9 }, |
| { 24 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_LEG_12 }, |
| { 36 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_LEG_18 }, |
| { 48 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_LEG_24 }, |
| { 72 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_LEG_36 }, |
| { 96 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_LEG_48 }, |
| { 108 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_LEG_54 }, |
| { 12 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_LEG_6 }, |
| { 18 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_LEG_9 }, |
| { 24 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_LEG_12 }, |
| { 36 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_LEG_18 }, |
| { 48 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_LEG_24 }, |
| { 72 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_LEG_36 }, |
| { 96 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_LEG_48 }, |
| { 108 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_LEG_54 }, |
| |
| { 12 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_6 }, |
| { 18 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_9 }, |
| { 24 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_12 }, |
| { 36 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_18 }, |
| { 48 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_24 }, |
| { 72 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_36 }, |
| { 96 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_48 }, |
| { 108 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_54 }, |
| { 12 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_6 }, |
| { 18 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_9 }, |
| { 24 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_12 }, |
| { 36 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_18 }, |
| { 48 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_24 }, |
| { 72 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_36 }, |
| { 96 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_48 }, |
| { 108 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_LEG_54 }, |
| #if 0 |
| { 13 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_0 }, |
| { 26 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_1 }, |
| { 39 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_2 }, |
| { 52 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_3 }, |
| { 78 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_4 }, |
| { 104 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_5 }, |
| { 117 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_6 }, |
| { 130 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_7 }, |
| { 26 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_8 }, |
| { 52 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_9 }, |
| { 78 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_10 }, |
| { 104 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_11 }, |
| { 156 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_12 }, |
| { 208 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_13 }, |
| { 234 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_14 }, |
| { 260 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_15 }, |
| { 13 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_0 }, |
| { 26 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_1 }, |
| { 39 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_2 }, |
| { 52 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_3 }, |
| { 78 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_4 }, |
| { 104 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_5 }, |
| { 117 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_6 }, |
| { 130 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_7 }, |
| { 26 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_8 }, |
| { 52 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_9 }, |
| { 78 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_10 }, |
| { 104 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_11 }, |
| { 156 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_12 }, |
| { 208 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_13 }, |
| { 234 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_14 }, |
| { 260 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_15 }, |
| #else |
| { 0x80 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_0 }, |
| { 0x81 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_1 }, |
| { 0x82 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_2 }, |
| { 0x83 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_3 }, |
| { 0x84 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_4 }, |
| { 0x85 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_5 }, |
| { 0x86 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_6 }, |
| { 0x87 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_7 }, |
| { 0x88 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_8 }, |
| { 0x89 | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_9 }, |
| { 0x8A | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_10 }, |
| { 0x8B | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_11 }, |
| { 0x8C | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_12 }, |
| { 0x8D | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_13 }, |
| { 0x8E | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_14 }, |
| { 0x8F | IFM_IEEE80211_11NA, IFM_IEEE80211_OFDM_HT_15 }, |
| { 0x80 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_0 }, |
| { 0x81 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_1 }, |
| { 0x82 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_2 }, |
| { 0x83 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_3 }, |
| { 0x84 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_4 }, |
| { 0x85 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_5 }, |
| { 0x86 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_6 }, |
| { 0x87 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_7 }, |
| { 0x88 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_8 }, |
| { 0x89 | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_9 }, |
| { 0x8A | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_10 }, |
| { 0x8B | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_11 }, |
| { 0x8C | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_12 }, |
| { 0x8D | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_13 }, |
| { 0x8E | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_14 }, |
| { 0x8F | IFM_IEEE80211_11NG, IFM_IEEE80211_OFDM_HT_15 }, |
| |
| { 0x80 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_0 }, |
| { 0x81 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_1 }, |
| { 0x82 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_2 }, |
| { 0x83 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_3 }, |
| { 0x84 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_4 }, |
| { 0x85 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_5 }, |
| { 0x86 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_6 }, |
| { 0x87 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_7 }, |
| { 0x88 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_8 }, |
| { 0x89 | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_9 }, |
| { 0x8A | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_10 }, |
| { 0x8B | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_11 }, |
| { 0x8C | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_12 }, |
| { 0x8D | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_13 }, |
| { 0x8E | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_14 }, |
| { 0x8F | IFM_IEEE80211_11NA_HT40PM, IFM_IEEE80211_OFDM_HT_15 }, |
| { 0x80 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_0 }, |
| { 0x81 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_1 }, |
| { 0x82 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_2 }, |
| { 0x83 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_3 }, |
| { 0x84 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_4 }, |
| { 0x85 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_5 }, |
| { 0x86 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_6 }, |
| { 0x87 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_7 }, |
| { 0x88 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_8 }, |
| { 0x89 | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_9 }, |
| { 0x8A | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_10 }, |
| { 0x8B | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_11 }, |
| { 0x8C | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_12 }, |
| { 0x8D | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_13 }, |
| { 0x8E | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_14 }, |
| { 0x8F | IFM_IEEE80211_11NG_HT40PM, IFM_IEEE80211_OFDM_HT_15 }, |
| #endif |
| |
| }; |
| u_int mask, i; |
| |
| mask = mcs; |
| switch (mode) { |
| case IEEE80211_MODE_11NA: |
| mask |= IFM_IEEE80211_11NA; |
| break; |
| case IEEE80211_MODE_11NG: |
| mask |= IFM_IEEE80211_11NG; |
| break; |
| case IEEE80211_MODE_11NA_HT40PM: |
| mask |= IFM_IEEE80211_11NA_HT40PM; |
| break; |
| case IEEE80211_MODE_11NG_HT40PM: |
| mask |= IFM_IEEE80211_11NG_HT40PM; |
| break; |
| case IEEE80211_MODE_11AC_VHT20PM: |
| mask |= IFM_IEEE80211_11AC_VHT20PM; |
| break; |
| case IEEE80211_MODE_11AC_VHT40PM: |
| mask |= IFM_IEEE80211_11AC_VHT40PM; |
| break; |
| case IEEE80211_MODE_11AC_VHT80PM: |
| mask |= IFM_IEEE80211_11AC_VHT80PM; |
| break; |
| default: |
| break; |
| } |
| for (i = 0; i < N(rates); i++) |
| if (rates[i].m == mask) |
| return rates[i].r; |
| return IFM_AUTO; |
| #undef N |
| } |
| EXPORT_SYMBOL(ieee80211_mcs2media); |
| |
| int |
| ieee80211_mcs2rate(int mcs, int mode, int sgi, int vht) |
| { |
| #define N(a) (sizeof(a[0]) / sizeof(a[0][0][0])) |
| u_int32_t rates[2][2][77] = {{{ |
| |
| /* LGI & 20 MHz */ |
| /* MCS0-MC31 (4 streams) are supported */ |
| 13, 26, 39, 52, 78, 104, 117, 130, |
| 26, 52, 78, 104, 156, 208, 234, 260, |
| 39, 78, 117, 156, 234, 312, 351, 390, |
| 52, 104, 156, 208, 312, 416, 468, 520, |
| |
| 12, 78, 104, 130, 117, 156, 195, 104, /* UEQM */ |
| 130, 130, 156, 182, 182, 208, 156, 195, |
| 195, 234, 273, 273, 312, 130, 156, 182, |
| 156, 182, 208, 234, 208, 234, 260, 260, |
| 286, 195, 234, 273, 234, 273, 312, 351, |
| 312, 351, 390, 390, 429}, |
| { |
| |
| /* LGI & 40 MHz */ |
| /* MCS0-MCS31 (4 streams) are supported */ |
| 27, 54, 81, 108, 162, 216, 243, 270, |
| 54, 108, 162, 216, 324, 432, 486, 540, |
| 81, 162, 243, 324, 486, 648, 729, 810, |
| 108, 216, 324, 432, 648, 864, 972, 1080, |
| |
| 12, 162, 216, 270, 243, 324, 405, 216, /* UEQM */ |
| 270, 270, 324, 378, 378, 432, 324, 405, |
| 405, 486, 567, 567, 648, 270, 324, 378, |
| 324, 378, 432, 486, 432, 486, 540, 540, |
| 594, 405, 486, 567, 486, 567, 648, 729, |
| 648, 729, 810, 810, 891}}, |
| {{ |
| |
| /* SGI & 20 MHz */ |
| /* MCS0-MC31 (4 streams) are supported */ |
| 14, 28, 42, 56, 86, 114, 130, 144, |
| 28, 56, 86, 114, 172, 230, 260, 288, |
| 42, 86, 130, 172, 260, 346, 390, 432, |
| 56, 114, 172, 230, 346, 462, 520, 576, |
| |
| 12, 86, 114, 144, 130, 172, 216, 86, /* UEQM */ |
| 114, 114, 172, 202, 202, 230, 172, 216, |
| 216, 260, 302, 302, 346, 144, 172, 202, |
| 172, 202, 230, 260, 230, 260, 288, 288, |
| 316, 216, 260, 302, 260, 302, 346, 390, |
| 346, 390, 432, 432, 476}, |
| { |
| |
| /* SGI * 40 MHz */ |
| /* MCS0-MC31 (4 streams) are supported */ |
| 30, 60, 90, 120, 180, 240, 270, 300, |
| 60, 120, 180, 240, 360, 480, 540, 600, |
| 90, 180, 270, 360, 540, 720, 810, 900, |
| 120, 240, 360, 480, 720, 960, 1080,1200, |
| |
| 12, 180, 240, 300, 270, 360, 450, 240, /* UEQM */ |
| 300, 300, 360, 420, 420, 480, 360, 450, |
| 450, 540, 630, 630, 720, 300, 360, 420, |
| 360, 420, 480, 540, 480, 540, 600, 600, |
| 660, 450, 540, 630, 540, 630, 720, 810, |
| 720, 810, 900, 900, 990}} |
| }; |
| |
| u_int32_t vht_rates[2][2][10] = { |
| {{ |
| /* LGI & 80 MHz */ |
| /* MCS0-MC9 */ |
| 59, 117, 176, 234, 351, 468, 527, 585, 702, 780 |
| }, |
| { |
| /* LGI & 160/80+80 MHz */ |
| /* MCS0-MC9 */ |
| 117, 234, 351, 468, 702, 936, 1053, 1170, 1404, 1560 |
| }}, |
| {{ |
| /* SGI & 80 MHz */ |
| /* MCS0-MC9 */ |
| 65, 130, 195, 260, 390, 520, 585, 650, 780, 867 |
| }, |
| { |
| /* SGI & 160 MHz */ |
| /* MCS0-MC9 */ |
| 130, 260, 390, 520, 780, 1040, 1170, 1300, 1560, 1733 |
| }}}; |
| if (vht) { |
| if(mcs >= 10) |
| return -1; |
| |
| return (vht_rates[sgi][mode][mcs]); |
| } else { |
| if(mcs >= N(rates)) |
| return -1; |
| |
| return (rates[sgi][mode][mcs]); |
| } |
| |
| #undef N |
| } |
| EXPORT_SYMBOL(ieee80211_mcs2rate); |
| |
| int |
| ieee80211_rate2mcs(int rate, int mode, int sgi) |
| { |
| #define N(a) (sizeof(a[0]) / sizeof(a[0][0][0])) |
| static const struct { |
| u_int r; /* rate */ |
| u_int m; /* mcs */ |
| } rates[2][2][16] = {{{ |
| |
| /* Only MCS0-MCS15 (2 streams) are supported */ |
| {13, 0x80 }, |
| {26, 0x81 }, |
| {39, 0x82 }, |
| {52, 0x83 }, |
| {78, 0x84 }, |
| {104, 0x85 }, |
| {117, 0x86 }, |
| {130, 0x87 }, |
| {26, 0x88 }, |
| {52, 0x89 }, |
| {78, 0x8A }, |
| {104, 0x8B }, |
| {156, 0x8C }, |
| {208, 0x8D }, |
| {234, 0x8E }, |
| {260, 0x8F }, |
| }, |
| { |
| |
| /* Only MCS0-MCS15 (2 streams) are supported */ |
| {27, 0x80 }, |
| {54, 0x81 }, |
| {81, 0x82 }, |
| {108, 0x83 }, |
| {162, 0x84 }, |
| {216, 0x85 }, |
| {243, 0x86 }, |
| {270, 0x87 }, |
| {54, 0x88 }, |
| {108, 0x89 }, |
| {162, 0x8A }, |
| {216, 0x8B }, |
| {324, 0x8C }, |
| {432, 0x8D }, |
| {486, 0x8E }, |
| {540, 0x8F }, |
| }}, |
| {{ |
| |
| /* Only MCS0-MCS15 (2 streams) are supported */ |
| {14, 0x80 }, |
| {28, 0x81 }, |
| {42, 0x82 }, |
| {56, 0x83 }, |
| {86, 0x84 }, |
| {114, 0x85 }, |
| {130, 0x86 }, |
| {144, 0x87 }, |
| {28, 0x88 }, |
| {56, 0x89 }, |
| {86, 0x8A }, |
| {114, 0x8B }, |
| {172, 0x8C }, |
| {230, 0x8D }, |
| {260, 0x8E }, |
| {288, 0x8F }, |
| }, |
| { |
| |
| /* Only MCS0-MCS15 (2 streams) are supported */ |
| {30, 0x80 }, |
| {60, 0x81 }, |
| {90, 0x82 }, |
| {120, 0x83 }, |
| {180, 0x84 }, |
| {240, 0x85 }, |
| {270, 0x86 }, |
| {300, 0x87 }, |
| {60, 0x88 }, |
| {120, 0x89 }, |
| {180, 0x8A }, |
| {240, 0x8B }, |
| {360, 0x8C }, |
| {480, 0x8D }, |
| {540, 0x8E }, |
| {600, 0x8F }, |
| }}}; |
| int i; |
| |
| for (i = 0; i < N(rates); i++) |
| { |
| if (rates[sgi][mode][i].r == rate) |
| return (rates[sgi][mode][i].m); |
| } |
| return -1; |
| |
| #undef N |
| } |
| EXPORT_SYMBOL(ieee80211_rate2mcs); |
| |
| int |
| ieee80211_media2rate(int mword) |
| { |
| #define N(a) (sizeof(a) / sizeof(a[0])) |
| static const int ieeerates[] = { |
| -1, /* IFM_AUTO */ |
| 0, /* IFM_MANUAL */ |
| 0, /* IFM_NONE */ |
| 2, /* IFM_IEEE80211_FH1 */ |
| 4, /* IFM_IEEE80211_FH2 */ |
| 2, /* IFM_IEEE80211_DS1 */ |
| 4, /* IFM_IEEE80211_DS2 */ |
| 11, /* IFM_IEEE80211_DS5 */ |
| 22, /* IFM_IEEE80211_DS11 */ |
| 44, /* IFM_IEEE80211_DS22 */ |
| 3, /* IFM_IEEE80211_OFDM1_50 */ |
| 4, /* IFM_IEEE80211_OFDM2_25 */ |
| 6, /* IFM_IEEE80211_OFDM3 */ |
| 9, /* IFM_IEEE80211_OFDM4_50 */ |
| 12, /* IFM_IEEE80211_OFDM6 */ |
| 18, /* IFM_IEEE80211_OFDM9 */ |
| 24, /* IFM_IEEE80211_OFDM12 */ |
| 27, /* IFM_IEEE80211_OFDM13_5 */ |
| 36, /* IFM_IEEE80211_OFDM18 */ |
| 48, /* IFM_IEEE80211_OFDM24 */ |
| 54, /* IFM_IEEE80211_OFDM27 */ |
| 72, /* IFM_IEEE80211_OFDM36 */ |
| 96, /* IFM_IEEE80211_OFDM48 */ |
| 108, /* IFM_IEEE80211_OFDM54 */ |
| 144, /* IFM_IEEE80211_OFDM72 */ |
| }; |
| return IFM_SUBTYPE(mword) < N(ieeerates) ? |
| ieeerates[IFM_SUBTYPE(mword)] : 0; |
| #undef N |
| } |
| EXPORT_SYMBOL(ieee80211_media2rate); |
| |
| int |
| ieee80211_media2mcs(int mword) |
| { |
| #define N(a) (sizeof(a) / sizeof(a[0])) |
| static const int ieee11nrates[] = { |
| -1, /* IFM_AUTO */ |
| 12, /* IFM_IEEE80211_OFDM_HT_LEG6 */ |
| 18, /* IFM_IEEE80211_OFDM_HT_LEG9 */ |
| 24, /* IFM_IEEE80211_OFDM_HT_LEG12 */ |
| 36, /* IFM_IEEE80211_OFDM_HT_LEG18 */ |
| 48, /* IFM_IEEE80211_OFDM_HT_LEG24 */ |
| 72, /* IFM_IEEE80211_OFDM_HT_LEG36 */ |
| 96, /* IFM_IEEE80211_OFDM_HT_LEG48 */ |
| 108, /* IFM_IEEE80211_OFDM_HT_LEG54 */ |
| 0x80, /* IFM_MCS_0 */ |
| 0x81, /* IFM_MCS_1 */ |
| 0x82, /* IFM_MCS_2 */ |
| 0x83, /* IFM_MCS_3 */ |
| 0x84, /* IFM_MCS_4 */ |
| 0x85, /* IFM_MCS_5 */ |
| 0x86, /* IFM_MCS_6 */ |
| 0x87, /* IFM_MCS_7 */ |
| 0x88, /* IFM_MCS_8 */ |
| 0x89, /* IFM_MCS_9 */ |
| 0x8A, /* IFM_MCS_10 */ |
| 0x8B, /* IFM_MCS_11 */ |
| 0x8C, /* IFM_MCS_12 */ |
| 0x8D, /* IFM_MCS_13 */ |
| 0x8E, /* IFM_MCS_14 */ |
| 0x8F, /* IFM_MCS_15 */ |
| }; |
| return IFM_SUBTYPE(mword) < N(ieee11nrates) ? |
| ieee11nrates[IFM_SUBTYPE(mword)] : 0; |
| #undef N |
| } |
| EXPORT_SYMBOL(ieee80211_media2mcs); |
| /* |
| * Return netdevice statistics. |
| */ |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0) |
| static struct rtnl_link_stats64 * |
| ieee80211_getstats64(struct net_device *dev, struct rtnl_link_stats64 *stats64) |
| #else |
| static struct net_device_stats * |
| ieee80211_getstats(struct net_device *dev) |
| #endif |
| { |
| struct ieee80211vap *vap = netdev_priv(dev); |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0) |
| struct rtnl_link_stats64 *stats = &vap->iv_devstats; |
| #else |
| struct net_device_stats *stats = &vap->iv_devstats; |
| #endif |
| uint32_t extra_tx_errors, extra_tx_dropped, extra_rx_errors; |
| if (vap->iv_ic->ic_get_shared_vap_stats && (vap->iv_ic->ic_get_shared_vap_stats(vap)) < 0) |
| return stats; |
| |
| extra_tx_errors = vap->iv_stats.is_tx_nodefkey |
| + vap->iv_stats.is_tx_noheadroom |
| + vap->iv_stats.is_crypto_enmicfail; |
| extra_tx_dropped = vap->iv_stats.is_tx_nobuf |
| + vap->iv_stats.is_tx_nonode |
| + vap->iv_stats.is_tx_unknownmgt |
| + vap->iv_stats.is_tx_badcipher |
| + vap->iv_stats.is_tx_nodefkey; |
| extra_rx_errors = vap->iv_stats.is_rx_tooshort |
| + vap->iv_stats.is_rx_wepfail |
| + vap->iv_stats.is_rx_decap |
| + vap->iv_stats.is_rx_nobuf |
| + vap->iv_stats.is_rx_decryptcrc |
| + vap->iv_stats.is_rx_ccmpmic |
| + vap->iv_stats.is_rx_tkipmic |
| + vap->iv_stats.is_rx_tkipicv; |
| |
| vap->iv_stats.is_tx_nodefkey = 0; |
| vap->iv_stats.is_tx_noheadroom = 0; |
| vap->iv_stats.is_crypto_enmicfail = 0; |
| |
| vap->iv_stats.is_tx_nobuf = 0; |
| vap->iv_stats.is_tx_nonode = 0; |
| vap->iv_stats.is_tx_unknownmgt = 0; |
| vap->iv_stats.is_tx_badcipher = 0; |
| vap->iv_stats.is_tx_nodefkey = 0; |
| |
| vap->iv_stats.is_rx_tooshort = 0; |
| vap->iv_stats.is_rx_wepfail = 0; |
| vap->iv_stats.is_rx_decap = 0; |
| vap->iv_stats.is_rx_nobuf = 0; |
| vap->iv_stats.is_rx_decryptcrc = 0; |
| vap->iv_stats.is_rx_ccmpmic = 0; |
| vap->iv_stats.is_rx_tkipmic = 0; |
| vap->iv_stats.is_rx_tkipicv = 0; |
| |
| /* XXX total guess as to what to count where */ |
| /* update according to private statistics */ |
| stats->tx_errors += extra_tx_errors; |
| stats->tx_dropped += extra_tx_dropped; |
| stats->rx_errors += extra_rx_errors; |
| stats->rx_crc_errors = 0; |
| |
| #if LINUX_VERSION_CODE >= KERNEL_VERSION(4,7,0) |
| memcpy(stats64, stats, sizeof(*stats)); |
| return stats64; |
| #else |
| return stats; |
| #endif |
| } |
| |
| static int |
| ieee80211_change_mtu(struct net_device *dev, int mtu) |
| { |
| if (!(IEEE80211_MTU_MIN < mtu && mtu <= IEEE80211_MTU_MAX)) |
| return -EINVAL; |
| dev->mtu = mtu; |
| /* XXX coordinate with parent device */ |
| return 0; |
| } |
| |
| static void |
| ieee80211_set_multicast_list(struct net_device *dev) |
| { |
| struct ieee80211vap *vap = netdev_priv(dev); |
| struct ieee80211com *ic = vap->iv_ic; |
| |
| IEEE80211_LOCK_IRQ(ic); |
| if (dev->flags & IFF_PROMISC) { |
| if ((vap->iv_flags & IEEE80211_F_PROMISC) == 0) { |
| vap->iv_flags |= IEEE80211_F_PROMISC; |
| ic->ic_promisc++; |
| } |
| } else { |
| if (vap->iv_flags & IEEE80211_F_PROMISC) { |
| vap->iv_flags &= ~IEEE80211_F_PROMISC; |
| ic->ic_promisc--; |
| } |
| } |
| if (dev->flags & IFF_ALLMULTI) { |
| if ((vap->iv_flags & IEEE80211_F_ALLMULTI) == 0) { |
| vap->iv_flags |= IEEE80211_F_ALLMULTI; |
| ic->ic_allmulti++; |
| } |
| } else { |
| if (vap->iv_flags & IEEE80211_F_ALLMULTI) { |
| vap->iv_flags &= ~IEEE80211_F_ALLMULTI; |
| ic->ic_allmulti--; |
| } |
| } |
| IEEE80211_UNLOCK_IRQ(ic); |
| |
| } |
| |
| /* |
| * 0: OK |
| * <0: NOK, with value derived from errno vals. |
| */ |
| |
| #define N(a) (sizeof (a) / sizeof (a[0])) |
| |
| int |
| ieee80211_country_string_to_countryid( const char *input_str, u_int16_t *p_iso_code ) |
| { |
| int retval = -EINVAL; |
| int iter; |
| |
| if (strnlen( input_str, 3 ) >= 3) { |
| return( -E2BIG ); |
| } |
| |
| for (iter = 0; iter < N(country_strings) && retval < 0; iter++) { |
| if (strcasecmp( country_strings[iter].iso_name, input_str ) == 0) { |
| *p_iso_code = country_strings[iter].iso_code; |
| retval = 0; |
| } |
| } |
| |
| return( retval ); |
| } |
| |
| int |
| ieee80211_countryid_to_country_string( const u_int16_t iso_code, char *output_str ) |
| { |
| int retval = -EINVAL; |
| int iter; |
| |
| for (iter = 0; iter < N(country_strings) && retval < 0; iter++) { |
| if (iso_code == country_strings[iter].iso_code) { |
| strncpy( output_str, country_strings[iter].iso_name, 2 ); |
| output_str[ 2 ] = '\0'; |
| retval = 0; |
| } |
| } |
| |
| return( retval ); |
| } |
| |
| int |
| ieee80211_region_to_operating_class(struct ieee80211com *ic, char *region_str) |
| { |
| int retval = -EINVAL; |
| int i; |
| int j; |
| |
| for (i = 0; i < ARRAY_SIZE(oper_class_table); i++) { |
| if (strcasecmp(oper_class_table[i].region_name, region_str) == 0) { |
| for (j = 0; j < oper_class_table[i].class_num_5g; j++) |
| setbit(ic->ic_oper_class, oper_class_table[i].classes_5g[j]); |
| |
| if (ic->ic_rf_chipid == CHIPID_DUAL) { |
| for (j = 0; j < oper_class_table[i].class_num_24g; j++) |
| setbit(ic->ic_oper_class, oper_class_table[i].classes_24g[j]); |
| } |
| |
| ic->ic_oper_class_table = &oper_class_table[i]; |
| |
| retval = 0; |
| break; |
| } |
| } |
| |
| if (retval < 0) { |
| for (j = 0; j < oper_class_table[OPER_CLASS_GB_INDEX].class_num_5g; j++) |
| setbit(ic->ic_oper_class, oper_class_table[OPER_CLASS_GB_INDEX].classes_5g[j]); |
| |
| if (ic->ic_rf_chipid == CHIPID_DUAL) { |
| for (j = 0; j < oper_class_table[OPER_CLASS_GB_INDEX].class_num_24g; j++) |
| setbit(ic->ic_oper_class, oper_class_table[OPER_CLASS_GB_INDEX].classes_24g[j]); |
| } |
| |
| ic->ic_oper_class_table = &oper_class_table[OPER_CLASS_GB_INDEX]; |
| |
| retval = 0; |
| } |
| |
| return retval; |
| } |
| |
| void |
| ieee80211_get_prichan_list_by_operating_class(struct ieee80211com *ic, |
| int bw, |
| uint8_t *chan_list, |
| uint32_t flag) |
| { |
| int i; |
| int j; |
| uint32_t table_size = ic->ic_oper_class_table->class_num_5g + |
| ic->ic_oper_class_table->class_num_24g; |
| |
| KASSERT(ic->ic_oper_class_table, ("Uninitialized operating table")); |
| |
| for (i = 0; i < table_size; i++) { |
| if (ic->ic_oper_class_table->class_table[i].bandwidth == bw && |
| (ic->ic_oper_class_table->class_table[i].behavior & flag)) { |
| for (j = 0; j < ARRAY_SIZE(ic->ic_oper_class_table->class_table[i].chan_set) && |
| ic->ic_oper_class_table->class_table[i].chan_set[j]; j++) { |
| setbit(chan_list, ic->ic_oper_class_table->class_table[i].chan_set[j]); |
| } |
| } |
| } |
| } |
| |
| int |
| ieee80211_get_current_operating_class(uint16_t iso_code, int chan, int bw) |
| { |
| int i; |
| int j; |
| |
| switch (iso_code) { |
| case CTRY_UNITED_STATES: |
| for (i = 0; i < ARRAY_SIZE(us_oper_class_table); i++) { |
| if (us_oper_class_table[i].bandwidth == bw) { |
| for (j = 0; j < sizeof(us_oper_class_table[i].chan_set); j++) { |
| if (us_oper_class_table[i].chan_set[j] == chan) |
| return us_oper_class_table[i].index; |
| } |
| } |
| } |
| break; |
| case CTRY_EUROPE: |
| for (i = 0; i < ARRAY_SIZE(eu_oper_class_table); i++) { |
| if (eu_oper_class_table[i].bandwidth == bw) { |
| for (j = 0; j < sizeof(eu_oper_class_table[i].chan_set); j++) { |
| if (eu_oper_class_table[i].chan_set[j] == chan) |
| return eu_oper_class_table[i].index; |
| } |
| } |
| } |
| break; |
| case CTRY_JAPAN: |
| for (i = 0; i < ARRAY_SIZE(jp_oper_class_table); i++) { |
| if (jp_oper_class_table[i].bandwidth == bw) { |
| for (j = 0; j < sizeof(jp_oper_class_table[i].chan_set); j++) { |
| if (jp_oper_class_table[i].chan_set[j] == chan) |
| return jp_oper_class_table[i].index; |
| } |
| } |
| } |
| break; |
| default: |
| for (i = 0; i < ARRAY_SIZE(gb_oper_class_table); i++) { |
| if (gb_oper_class_table[i].bandwidth == bw) { |
| for (j = 0; j < sizeof(gb_oper_class_table[i].chan_set); j++) { |
| if (gb_oper_class_table[i].chan_set[j] == chan) |
| return gb_oper_class_table[i].index; |
| } |
| } |
| } |
| break; |
| } |
| |
| return 0; |
| } |
| |
| void |
| ieee80211_build_countryie(struct ieee80211com *ic) |
| { |
| int i, j, chanflags, found; |
| struct ieee80211_channel *c; |
| u_int8_t chanlist[IEEE80211_CHAN_MAX + 1]; |
| u_int8_t chancnt = 0; |
| u_int8_t *cur_runlen, *cur_chan, *cur_pow, prevchan; |
| |
| /* |
| * Fill in country IE. |
| */ |
| memset(&ic->ic_country_ie, 0, sizeof(ic->ic_country_ie)); |
| ic->ic_country_ie.country_id = IEEE80211_ELEMID_COUNTRY; |
| ic->ic_country_ie.country_len = 0; /* init needed by following code */ |
| |
| /* initialize country IE */ |
| found = -EINVAL; |
| if (ic->ic_spec_country_code != CTRY_DEFAULT) { |
| found = ieee80211_countryid_to_country_string(ic->ic_spec_country_code, |
| (char *)ic->ic_country_ie.country_str); |
| } else { |
| found = ieee80211_countryid_to_country_string(ic->ic_country_code, |
| (char *)ic->ic_country_ie.country_str); |
| } |
| if (found < 0) { |
| printk("bad country string ignored: %d\n", |
| ic->ic_country_code); |
| ic->ic_country_ie.country_str[0] = ' '; |
| ic->ic_country_ie.country_str[1] = ' '; |
| } |
| |
| /* |
| * indoor/outdoor portion in country string. |
| * It should be one of: |
| * 'I' indoor only |
| * 'O' outdoor only |
| * ' ' all enviroments |
| * Default: we currently support both indoor and outdoor. |
| * If we need support other options later, |
| * use 'ic->ic_country_outdoor' to control it. |
| */ |
| ic->ic_country_ie.country_str[2] = ' '; |
| |
| ic->ic_country_ie.country_len += 3; /* Country string - 3 characters added in */ |
| |
| /* |
| * runlength encoded channel max tx power info. |
| */ |
| cur_runlen = &ic->ic_country_ie.country_triplet[1]; |
| cur_chan = &ic->ic_country_ie.country_triplet[0]; |
| cur_pow = &ic->ic_country_ie.country_triplet[2]; |
| prevchan = 0; |
| |
| if ((ic->ic_flags_ext & IEEE80211_FEXT_REGCLASS) && ic->ic_nregclass) { |
| /* |
| * Add regulatory triplets. |
| * chan/no_of_chans/tx power triplet is overridden as |
| * as follows: |
| * cur_chan == REGULATORY EXTENSION ID. |
| * cur_runlen = Regulatory class. |
| * cur_pow = coverage class. |
| */ |
| for (i=0; i < ic->ic_nregclass; i++) { |
| *cur_chan = IEEE80211_REG_EXT_ID; |
| *cur_runlen = ic->ic_regclassids[i]; |
| *cur_pow = ic->ic_coverageclass; |
| |
| cur_runlen +=3; |
| cur_chan += 3; |
| cur_pow += 3; |
| ic->ic_country_ie.country_len += 3; |
| } |
| } else if (ic->ic_bsschan != IEEE80211_CHAN_ANYC) { |
| if (IEEE80211_IS_CHAN_5GHZ(ic->ic_bsschan)) |
| chanflags = IEEE80211_CHAN_5GHZ; |
| else |
| chanflags = IEEE80211_CHAN_2GHZ; |
| |
| memset(&chanlist[0], 0, sizeof(chanlist)); |
| /* XXX not right due to duplicate entries */ |
| for (i = 0; i < ic->ic_nchans; i++) { |
| c = &ic->ic_channels[i]; |
| |
| if (c == NULL || isclr(ic->ic_chan_active, c->ic_ieee)) |
| continue; |
| |
| /* Does channel belong to current operation mode */ |
| if (!(c->ic_flags & chanflags)) |
| continue; |
| |
| /* Skip previously reported channels */ |
| for (j = 0; j < chancnt; j++) |
| if (c->ic_ieee == chanlist[j]) |
| break; |
| |
| if (j != chancnt) /* found a match */ |
| continue; |
| |
| chanlist[chancnt] = c->ic_ieee; |
| chancnt++; |
| |
| /* Skip turbo channels */ |
| if (IEEE80211_IS_CHAN_TURBO(c)) |
| continue; |
| |
| /* Skip half/quarter rate channels */ |
| if (IEEE80211_IS_CHAN_HALF(c) || |
| IEEE80211_IS_CHAN_QUARTER(c)) |
| continue; |
| |
| if (*cur_runlen == 0) { |
| (*cur_runlen)++; |
| *cur_pow = c->ic_maxregpower; |
| *cur_chan = c->ic_ieee; |
| prevchan = c->ic_ieee; |
| ic->ic_country_ie.country_len += 3; |
| } else if (*cur_pow == c->ic_maxregpower && |
| c->ic_ieee == prevchan + 1) { |
| (*cur_runlen)++; |
| prevchan = c->ic_ieee; |
| } else { |
| cur_runlen +=3; |
| cur_chan += 3; |
| cur_pow += 3; |
| (*cur_runlen)++; |
| *cur_pow = c->ic_maxregpower; |
| *cur_chan = c->ic_ieee; |
| prevchan = c->ic_ieee; |
| ic->ic_country_ie.country_len += 3; |
| } |
| } |
| } |
| |
| /* pad */ |
| if (ic->ic_country_ie.country_len & 1) |
| ic->ic_country_ie.country_len++; |
| |
| #undef N |
| } |
| |
| u_int |
| ieee80211_get_chanflags(enum ieee80211_phymode mode) |
| { |
| KASSERT(mode < ARRAY_SIZE(ieee80211_chanflags), ("Unexpected mode %u", mode)); |
| return ieee80211_chanflags[mode]; |
| } |
| EXPORT_SYMBOL(ieee80211_get_chanflags); |
| |
| /* |
| * Change the WDS mode of a specified WDS VAP, called in following circumstances: |
| * WDS VAP initialization |
| * WDS Extender Role changing |
| */ |
| int |
| ieee80211_vap_wds_mode_change(struct ieee80211vap *vap) |
| { |
| struct ieee80211com *ic = vap->iv_ic; |
| |
| switch (ic->ic_extender_role) { |
| case IEEE80211_EXTENDER_ROLE_MBS: |
| IEEE80211_VAP_WDS_SET_MBS(vap); |
| break; |
| case IEEE80211_EXTENDER_ROLE_RBS: |
| IEEE80211_VAP_WDS_SET_RBS(vap); |
| break; |
| case IEEE80211_EXTENDER_ROLE_NONE: |
| IEEE80211_VAP_WDS_SET_NONE(vap); |
| default: |
| break; |
| } |
| |
| return 0; |
| } |
| |
| int |
| ieee80211_dual_sec_chan_supported(struct ieee80211com *ic, int chan) |
| { |
| int max_chan; |
| |
| if (ic->ic_country_code == CTRY_UNITED_STATES) |
| max_chan = IEEE80211_MAX_DUAL_EXT_CHAN_24G_US; |
| else |
| max_chan = IEEE80211_MAX_DUAL_EXT_CHAN_24G; |
| |
| if ((chan >= IEEE80211_MIN_DUAL_EXT_CHAN_24G) && |
| (chan <= max_chan)) |
| return 1; |
| |
| return 0; |
| } |
| |
| void |
| ieee80211_update_sec_chan_offset(struct ieee80211_channel *chan, int offset) |
| { |
| if (offset == IEEE80211_HTINFO_CHOFF_SCA) { |
| chan->ic_flags |= IEEE80211_CHAN_HT40U; |
| chan->ic_flags &= ~IEEE80211_CHAN_HT40D; |
| chan->ic_center_f_40MHz = chan->ic_ieee + IEEE80211_40M_CENT_FREQ_OFFSET; |
| } else if (offset == IEEE80211_HTINFO_CHOFF_SCB) { |
| chan->ic_flags |= IEEE80211_CHAN_HT40D; |
| chan->ic_flags &= ~IEEE80211_CHAN_HT40U; |
| chan->ic_center_f_40MHz = chan->ic_ieee - IEEE80211_40M_CENT_FREQ_OFFSET; |
| } |
| } |
| |
| int |
| ieee80211_get_ap_sec_chan_offset(const struct ieee80211_scan_entry *se) |
| { |
| struct ieee80211_ie_htinfo *htinfo = |
| (struct ieee80211_ie_htinfo *)se->se_htinfo_ie; |
| int sec20_offset; |
| |
| if (!htinfo) |
| sec20_offset = IEEE80211_HTINFO_CHOFF_SCN; |
| else |
| sec20_offset = IEEE80211_HTINFO_B1_EXT_CHOFFSET(htinfo); |
| |
| return sec20_offset; |
| } |
| |
| int |
| ieee80211_get_max_ap_bw(const struct ieee80211_scan_entry *se) |
| { |
| struct ieee80211_ie_htcap *htcap = |
| (struct ieee80211_ie_htcap *)se->se_htcap_ie; |
| struct ieee80211_ie_htinfo *htinfo = |
| (struct ieee80211_ie_htinfo *)se->se_htinfo_ie; |
| struct ieee80211_ie_vhtcap *vhtcap = |
| (struct ieee80211_ie_vhtcap *)se->se_vhtcap_ie; |
| struct ieee80211_ie_vhtop *vhtop = |
| (struct ieee80211_ie_vhtop *)se->se_vhtop_ie; |
| int max_bw = BW_HT20; |
| |
| if (htinfo) { |
| if (htinfo->hi_byte1 & IEEE80211_HTINFO_B1_SEC_CHAN_OFFSET) |
| max_bw = BW_HT40; |
| } else if (htcap) { |
| if (htcap->hc_cap[0] & IEEE80211_HTCAP_C_CHWIDTH40) |
| max_bw = BW_HT40; |
| } |
| |
| if (vhtop) { |
| int vhtop_bw = IEEE80211_VHTOP_GET_CHANWIDTH(vhtop); |
| if ((vhtop_bw == IEEE80211_VHTOP_CHAN_WIDTH_160MHZ) || |
| (vhtop_bw == IEEE80211_VHTOP_CHAN_WIDTH_80PLUS80MHZ)) |
| max_bw = BW_HT160; |
| else if (vhtop_bw == IEEE80211_VHTOP_CHAN_WIDTH_80MHZ) |
| max_bw = BW_HT80; |
| } else if (vhtcap) { |
| int vhtcap_bw = IEEE80211_VHTCAP_GET_CHANWIDTH(vhtcap); |
| if (vhtcap_bw == IEEE80211_VHTCAP_CW_80M_ONLY) |
| max_bw = BW_HT80; |
| else if ((vhtcap_bw == IEEE80211_VHTCAP_CW_160M) || |
| (vhtcap_bw == IEEE80211_VHTCAP_CW_160_AND_80P80M)) |
| max_bw = BW_HT160; |
| } |
| |
| return max_bw; |
| } |
| |
| int |
| ieee80211_get_max_node_bw(struct ieee80211_node *ni) |
| { |
| int max_bw = BW_HT20; |
| |
| if (IEEE80211_NODE_IS_HT(ni)) { |
| if (ni->ni_htcap.cap & IEEE80211_HTCAP_C_CHWIDTH40) |
| max_bw = BW_HT40; |
| } |
| |
| if (IEEE80211_NODE_IS_VHT(ni)) { |
| if (ni->ni_vhtcap.chanwidth == IEEE80211_VHTCAP_CW_80M_ONLY) |
| max_bw = BW_HT80; |
| else if ((ni->ni_vhtcap.chanwidth == IEEE80211_VHTCAP_CW_160M) || |
| (ni->ni_vhtcap.chanwidth == IEEE80211_VHTCAP_CW_160_AND_80P80M)) |
| max_bw = BW_HT160; |
| } |
| |
| return max_bw; |
| } |
| |
| int |
| ieee80211_get_max_system_bw(struct ieee80211com *ic) |
| { |
| int max_bw = ic->ic_max_system_bw; |
| |
| if (max_bw >= BW_HT80) { |
| if (!IS_IEEE80211_VHT_ENABLED(ic) || |
| !ieee80211_swfeat_is_supported(SWFEAT_ID_VHT, 1)) |
| max_bw = BW_HT40; |
| } |
| |
| if (max_bw >= BW_HT40) { |
| if (ic->ic_curmode <= IEEE80211_MODE_11NG) |
| max_bw = BW_HT20; |
| } |
| |
| return max_bw; |
| } |
| |
| int |
| ieee80211_get_max_channel_bw(struct ieee80211com *ic, int channel) |
| { |
| if (isset(ic->ic_chan_active_80, channel)) |
| return BW_HT80; |
| else if (isset(ic->ic_chan_active_40, channel)) |
| return BW_HT40; |
| else |
| return BW_HT20; |
| } |
| |
| int |
| ieee80211_get_max_bw(struct ieee80211vap *vap, |
| struct ieee80211_node *ni, uint32_t chan) |
| { |
| struct ieee80211com *ic = vap->iv_ic; |
| int max_bw = ieee80211_get_max_node_bw(ni); |
| int ic_bw = ieee80211_get_max_system_bw(ic); |
| int chan_bw = ieee80211_get_max_channel_bw(ic, chan); |
| |
| max_bw = MIN(max_bw, ic_bw); |
| max_bw = MIN(max_bw, chan_bw); |
| |
| return max_bw; |
| } |
| |
