drivers/net/wireless/mac80211_hwsim.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * mac80211_hwsim - software simulator of 802.11 radio(s) for mac80211
   4  * Copyright (c) 2008, Jouni Malinen <j@w1.fi>
   5  * Copyright (c) 2011, Javier Lopez <jlopex@gmail.com>
   6  * Copyright (c) 2016 - 2017 Intel Deutschland GmbH
   7  * Copyright (C) 2018 Intel Corporation
   8  */
   9
  10 /*
  11  * TODO:
  12  * - Add TSF sync and fix IBSS beacon transmission by adding
  13  *   competition for "air time" at TBTT
  14  * - RX filtering based on filter configuration (data->rx_filter)
  15  */
  16
  17 #include <linux/list.h>
  18 #include <linux/slab.h>
  19 #include <linux/spinlock.h>
  20 #include <net/dst.h>
  21 #include <net/xfrm.h>
  22 #include <net/mac80211.h>
  23 #include <net/ieee80211_radiotap.h>
  24 #include <linux/if_arp.h>
  25 #include <linux/rtnetlink.h>
  26 #include <linux/etherdevice.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/debugfs.h>
  29 #include <linux/module.h>
  30 #include <linux/ktime.h>
  31 #include <net/genetlink.h>
  32 #include <net/net_namespace.h>
  33 #include <net/netns/generic.h>
  34 #include <linux/rhashtable.h>
  35 #include <linux/nospec.h>
  36 #include "mac80211_hwsim.h"
  37
  38 #define WARN_QUEUE 100
  39 #define MAX_QUEUE 200
  40
  41 MODULE_AUTHOR("Jouni Malinen");
  42 MODULE_DESCRIPTION("Software simulator of 802.11 radio(s) for mac80211");
  43 MODULE_LICENSE("GPL");
  44
  45 static int radios = 2;
  46 module_param(radios, int, 0444);
  47 MODULE_PARM_DESC(radios, "Number of simulated radios");
  48
  49 static int channels = 1;
  50 module_param(channels, int, 0444);
  51 MODULE_PARM_DESC(channels, "Number of concurrent channels");
  52
  53 static bool paged_rx = false;
  54 module_param(paged_rx, bool, 0644);
  55 MODULE_PARM_DESC(paged_rx, "Use paged SKBs for RX instead of linear ones");
  56
  57 static bool rctbl = false;
  58 module_param(rctbl, bool, 0444);
  59 MODULE_PARM_DESC(rctbl, "Handle rate control table");
  60
  61 static bool support_p2p_device = true;
  62 module_param(support_p2p_device, bool, 0444);
  63 MODULE_PARM_DESC(support_p2p_device, "Support P2P-Device interface type");
  64
  65 /**
  66  * enum hwsim_regtest - the type of regulatory tests we offer
  67  *
  68  * These are the different values you can use for the regtest
  69  * module parameter. This is useful to help test world roaming
  70  * and the driver regulatory_hint() call and combinations of these.
  71  * If you want to do specific alpha2 regulatory domain tests simply
  72  * use the userspace regulatory request as that will be respected as
  73  * well without the need of this module parameter. This is designed
  74  * only for testing the driver regulatory request, world roaming
  75  * and all possible combinations.
  76  *
  77  * @HWSIM_REGTEST_DISABLED: No regulatory tests are performed,
  78  *      this is the default value.
  79  * @HWSIM_REGTEST_DRIVER_REG_FOLLOW: Used for testing the driver regulatory
  80  *      hint, only one driver regulatory hint will be sent as such the
  81  *      secondary radios are expected to follow.
  82  * @HWSIM_REGTEST_DRIVER_REG_ALL: Used for testing the driver regulatory
  83  *      request with all radios reporting the same regulatory domain.
  84  * @HWSIM_REGTEST_DIFF_COUNTRY: Used for testing the drivers calling
  85  *      different regulatory domains requests. Expected behaviour is for
  86  *      an intersection to occur but each device will still use their
  87  *      respective regulatory requested domains. Subsequent radios will
  88  *      use the resulting intersection.
  89  * @HWSIM_REGTEST_WORLD_ROAM: Used for testing the world roaming. We accomplish
  90  *      this by using a custom beacon-capable regulatory domain for the first
  91  *      radio. All other device world roam.
  92  * @HWSIM_REGTEST_CUSTOM_WORLD: Used for testing the custom world regulatory
  93  *      domain requests. All radios will adhere to this custom world regulatory
  94  *      domain.
  95  * @HWSIM_REGTEST_CUSTOM_WORLD_2: Used for testing 2 custom world regulatory
  96  *      domain requests. The first radio will adhere to the first custom world
  97  *      regulatory domain, the second one to the second custom world regulatory
  98  *      domain. All other devices will world roam.
  99  * @HWSIM_REGTEST_STRICT_FOLLOW_: Used for testing strict regulatory domain
 100  *      settings, only the first radio will send a regulatory domain request
 101  *      and use strict settings. The rest of the radios are expected to follow.
 102  * @HWSIM_REGTEST_STRICT_ALL: Used for testing strict regulatory domain
 103  *      settings. All radios will adhere to this.
 104  * @HWSIM_REGTEST_STRICT_AND_DRIVER_REG: Used for testing strict regulatory
 105  *      domain settings, combined with secondary driver regulatory domain
 106  *      settings. The first radio will get a strict regulatory domain setting
 107  *      using the first driver regulatory request and the second radio will use
 108  *      non-strict settings using the second driver regulatory request. All
 109  *      other devices should follow the intersection created between the
 110  *      first two.
 111  * @HWSIM_REGTEST_ALL: Used for testing every possible mix. You will need
 112  *      at least 6 radios for a complete test. We will test in this order:
 113  *      1 - driver custom world regulatory domain
 114  *      2 - second custom world regulatory domain
 115  *      3 - first driver regulatory domain request
 116  *      4 - second driver regulatory domain request
 117  *      5 - strict regulatory domain settings using the third driver regulatory
 118  *          domain request
 119  *      6 and on - should follow the intersection of the 3rd, 4rth and 5th radio
 120  *                 regulatory requests.
 121  */
 122 enum hwsim_regtest {
 123         HWSIM_REGTEST_DISABLED = 0,
 124         HWSIM_REGTEST_DRIVER_REG_FOLLOW = 1,
 125         HWSIM_REGTEST_DRIVER_REG_ALL = 2,
 126         HWSIM_REGTEST_DIFF_COUNTRY = 3,
 127         HWSIM_REGTEST_WORLD_ROAM = 4,
 128         HWSIM_REGTEST_CUSTOM_WORLD = 5,
 129         HWSIM_REGTEST_CUSTOM_WORLD_2 = 6,
 130         HWSIM_REGTEST_STRICT_FOLLOW = 7,
 131         HWSIM_REGTEST_STRICT_ALL = 8,
 132         HWSIM_REGTEST_STRICT_AND_DRIVER_REG = 9,
 133         HWSIM_REGTEST_ALL = 10,
 134 };
 135
 136 /* Set to one of the HWSIM_REGTEST_* values above */
 137 static int regtest = HWSIM_REGTEST_DISABLED;
 138 module_param(regtest, int, 0444);
 139 MODULE_PARM_DESC(regtest, "The type of regulatory test we want to run");
 140
 141 static const char *hwsim_alpha2s[] = {
 142         "FI",
 143         "AL",
 144         "US",
 145         "DE",
 146         "JP",
 147         "AL",
 148 };
 149
 150 static const struct ieee80211_regdomain hwsim_world_regdom_custom_01 = {
 151         .n_reg_rules = 5,
 152         .alpha2 =  "99",
 153         .reg_rules = {
 154                 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
 155                 REG_RULE(2484-10, 2484+10, 40, 0, 20, 0),
 156                 REG_RULE(5150-10, 5240+10, 40, 0, 30, 0),
 157                 REG_RULE(5745-10, 5825+10, 40, 0, 30, 0),
 158                 REG_RULE(5855-10, 5925+10, 40, 0, 33, 0),
 159         }
 160 };
 161
 162 static const struct ieee80211_regdomain hwsim_world_regdom_custom_02 = {
 163         .n_reg_rules = 3,
 164         .alpha2 =  "99",
 165         .reg_rules = {
 166                 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0),
 167                 REG_RULE(5725-10, 5850+10, 40, 0, 30,
 168                          NL80211_RRF_NO_IR),
 169                 REG_RULE(5855-10, 5925+10, 40, 0, 33, 0),
 170         }
 171 };
 172
 173 static const struct ieee80211_regdomain *hwsim_world_regdom_custom[] = {
 174         &hwsim_world_regdom_custom_01,
 175         &hwsim_world_regdom_custom_02,
 176 };
 177
 178 struct hwsim_vif_priv {
 179         u32 magic;
 180         u8 bssid[ETH_ALEN];
 181         bool assoc;
 182         bool bcn_en;
 183         u16 aid;
 184 };
 185
 186 #define HWSIM_VIF_MAGIC 0x69537748
 187
 188 static inline void hwsim_check_magic(struct ieee80211_vif *vif)
 189 {
 190         struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 191         WARN(vp->magic != HWSIM_VIF_MAGIC,
 192              "Invalid VIF (%p) magic %#x, %pM, %d/%d\n",
 193              vif, vp->magic, vif->addr, vif->type, vif->p2p);
 194 }
 195
 196 static inline void hwsim_set_magic(struct ieee80211_vif *vif)
 197 {
 198         struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 199         vp->magic = HWSIM_VIF_MAGIC;
 200 }
 201
 202 static inline void hwsim_clear_magic(struct ieee80211_vif *vif)
 203 {
 204         struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 205         vp->magic = 0;
 206 }
 207
 208 struct hwsim_sta_priv {
 209         u32 magic;
 210 };
 211
 212 #define HWSIM_STA_MAGIC 0x6d537749
 213
 214 static inline void hwsim_check_sta_magic(struct ieee80211_sta *sta)
 215 {
 216         struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
 217         WARN_ON(sp->magic != HWSIM_STA_MAGIC);
 218 }
 219
 220 static inline void hwsim_set_sta_magic(struct ieee80211_sta *sta)
 221 {
 222         struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
 223         sp->magic = HWSIM_STA_MAGIC;
 224 }
 225
 226 static inline void hwsim_clear_sta_magic(struct ieee80211_sta *sta)
 227 {
 228         struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
 229         sp->magic = 0;
 230 }
 231
 232 struct hwsim_chanctx_priv {
 233         u32 magic;
 234 };
 235
 236 #define HWSIM_CHANCTX_MAGIC 0x6d53774a
 237
 238 static inline void hwsim_check_chanctx_magic(struct ieee80211_chanctx_conf *c)
 239 {
 240         struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
 241         WARN_ON(cp->magic != HWSIM_CHANCTX_MAGIC);
 242 }
 243
 244 static inline void hwsim_set_chanctx_magic(struct ieee80211_chanctx_conf *c)
 245 {
 246         struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
 247         cp->magic = HWSIM_CHANCTX_MAGIC;
 248 }
 249
 250 static inline void hwsim_clear_chanctx_magic(struct ieee80211_chanctx_conf *c)
 251 {
 252         struct hwsim_chanctx_priv *cp = (void *)c->drv_priv;
 253         cp->magic = 0;
 254 }
 255
 256 static unsigned int hwsim_net_id;
 257
 258 static DEFINE_IDA(hwsim_netgroup_ida);
 259
 260 struct hwsim_net {
 261         int netgroup;
 262         u32 wmediumd;
 263 };
 264
 265 static inline int hwsim_net_get_netgroup(struct net *net)
 266 {
 267         struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);
 268
 269         return hwsim_net->netgroup;
 270 }
 271
 272 static inline int hwsim_net_set_netgroup(struct net *net)
 273 {
 274         struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);
 275
 276         hwsim_net->netgroup = ida_simple_get(&hwsim_netgroup_ida,
 277                                              0, 0, GFP_KERNEL);
 278         return hwsim_net->netgroup >= 0 ? 0 : -ENOMEM;
 279 }
 280
 281 static inline u32 hwsim_net_get_wmediumd(struct net *net)
 282 {
 283         struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);
 284
 285         return hwsim_net->wmediumd;
 286 }
 287
 288 static inline void hwsim_net_set_wmediumd(struct net *net, u32 portid)
 289 {
 290         struct hwsim_net *hwsim_net = net_generic(net, hwsim_net_id);
 291
 292         hwsim_net->wmediumd = portid;
 293 }
 294
 295 static struct class *hwsim_class;
 296
 297 static struct net_device *hwsim_mon; /* global monitor netdev */
 298
 299 #define CHAN2G(_freq)  { \
 300         .band = NL80211_BAND_2GHZ, \
 301         .center_freq = (_freq), \
 302         .hw_value = (_freq), \
 303         .max_power = 20, \
 304 }
 305
 306 #define CHAN5G(_freq) { \
 307         .band = NL80211_BAND_5GHZ, \
 308         .center_freq = (_freq), \
 309         .hw_value = (_freq), \
 310         .max_power = 20, \
 311 }
 312
 313 static const struct ieee80211_channel hwsim_channels_2ghz[] = {
 314         CHAN2G(2412), /* Channel 1 */
 315         CHAN2G(2417), /* Channel 2 */
 316         CHAN2G(2422), /* Channel 3 */
 317         CHAN2G(2427), /* Channel 4 */
 318         CHAN2G(2432), /* Channel 5 */
 319         CHAN2G(2437), /* Channel 6 */
 320         CHAN2G(2442), /* Channel 7 */
 321         CHAN2G(2447), /* Channel 8 */
 322         CHAN2G(2452), /* Channel 9 */
 323         CHAN2G(2457), /* Channel 10 */
 324         CHAN2G(2462), /* Channel 11 */
 325         CHAN2G(2467), /* Channel 12 */
 326         CHAN2G(2472), /* Channel 13 */
 327         CHAN2G(2484), /* Channel 14 */
 328 };
 329
 330 static const struct ieee80211_channel hwsim_channels_5ghz[] = {
 331         CHAN5G(5180), /* Channel 36 */
 332         CHAN5G(5200), /* Channel 40 */
 333         CHAN5G(5220), /* Channel 44 */
 334         CHAN5G(5240), /* Channel 48 */
 335
 336         CHAN5G(5260), /* Channel 52 */
 337         CHAN5G(5280), /* Channel 56 */
 338         CHAN5G(5300), /* Channel 60 */
 339         CHAN5G(5320), /* Channel 64 */
 340
 341         CHAN5G(5500), /* Channel 100 */
 342         CHAN5G(5520), /* Channel 104 */
 343         CHAN5G(5540), /* Channel 108 */
 344         CHAN5G(5560), /* Channel 112 */
 345         CHAN5G(5580), /* Channel 116 */
 346         CHAN5G(5600), /* Channel 120 */
 347         CHAN5G(5620), /* Channel 124 */
 348         CHAN5G(5640), /* Channel 128 */
 349         CHAN5G(5660), /* Channel 132 */
 350         CHAN5G(5680), /* Channel 136 */
 351         CHAN5G(5700), /* Channel 140 */
 352
 353         CHAN5G(5745), /* Channel 149 */
 354         CHAN5G(5765), /* Channel 153 */
 355         CHAN5G(5785), /* Channel 157 */
 356         CHAN5G(5805), /* Channel 161 */
 357         CHAN5G(5825), /* Channel 165 */
 358         CHAN5G(5845), /* Channel 169 */
 359
 360         CHAN5G(5855), /* Channel 171 */
 361         CHAN5G(5860), /* Channel 172 */
 362         CHAN5G(5865), /* Channel 173 */
 363         CHAN5G(5870), /* Channel 174 */
 364
 365         CHAN5G(5875), /* Channel 175 */
 366         CHAN5G(5880), /* Channel 176 */
 367         CHAN5G(5885), /* Channel 177 */
 368         CHAN5G(5890), /* Channel 178 */
 369         CHAN5G(5895), /* Channel 179 */
 370         CHAN5G(5900), /* Channel 180 */
 371         CHAN5G(5905), /* Channel 181 */
 372
 373         CHAN5G(5910), /* Channel 182 */
 374         CHAN5G(5915), /* Channel 183 */
 375         CHAN5G(5920), /* Channel 184 */
 376         CHAN5G(5925), /* Channel 185 */
 377 };
 378
 379 static const struct ieee80211_rate hwsim_rates[] = {
 380         { .bitrate = 10 },
 381         { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 382         { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 383         { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 384         { .bitrate = 60 },
 385         { .bitrate = 90 },
 386         { .bitrate = 120 },
 387         { .bitrate = 180 },
 388         { .bitrate = 240 },
 389         { .bitrate = 360 },
 390         { .bitrate = 480 },
 391         { .bitrate = 540 }
 392 };
 393
 394 static const u32 hwsim_ciphers[] = {
 395         WLAN_CIPHER_SUITE_WEP40,
 396         WLAN_CIPHER_SUITE_WEP104,
 397         WLAN_CIPHER_SUITE_TKIP,
 398         WLAN_CIPHER_SUITE_CCMP,
 399         WLAN_CIPHER_SUITE_CCMP_256,
 400         WLAN_CIPHER_SUITE_GCMP,
 401         WLAN_CIPHER_SUITE_GCMP_256,
 402         WLAN_CIPHER_SUITE_AES_CMAC,
 403         WLAN_CIPHER_SUITE_BIP_CMAC_256,
 404         WLAN_CIPHER_SUITE_BIP_GMAC_128,
 405         WLAN_CIPHER_SUITE_BIP_GMAC_256,
 406 };
 407
 408 #define OUI_QCA 0x001374
 409 #define QCA_NL80211_SUBCMD_TEST 1
 410 enum qca_nl80211_vendor_subcmds {
 411         QCA_WLAN_VENDOR_ATTR_TEST = 8,
 412         QCA_WLAN_VENDOR_ATTR_MAX = QCA_WLAN_VENDOR_ATTR_TEST
 413 };
 414
 415 static const struct nla_policy
 416 hwsim_vendor_test_policy[QCA_WLAN_VENDOR_ATTR_MAX + 1] = {
 417         [QCA_WLAN_VENDOR_ATTR_MAX] = { .type = NLA_U32 },
 418 };
 419
 420 static int mac80211_hwsim_vendor_cmd_test(struct wiphy *wiphy,
 421                                           struct wireless_dev *wdev,
 422                                           const void *data, int data_len)
 423 {
 424         struct sk_buff *skb;
 425         struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_MAX + 1];
 426         int err;
 427         u32 val;
 428
 429         err = nla_parse_deprecated(tb, QCA_WLAN_VENDOR_ATTR_MAX, data,
 430                                    data_len, hwsim_vendor_test_policy, NULL);
 431         if (err)
 432                 return err;
 433         if (!tb[QCA_WLAN_VENDOR_ATTR_TEST])
 434                 return -EINVAL;
 435         val = nla_get_u32(tb[QCA_WLAN_VENDOR_ATTR_TEST]);
 436         wiphy_dbg(wiphy, "%s: test=%u\n", __func__, val);
 437
 438         /* Send a vendor event as a test. Note that this would not normally be
 439          * done within a command handler, but rather, based on some other
 440          * trigger. For simplicity, this command is used to trigger the event
 441          * here.
 442          *
 443          * event_idx = 0 (index in mac80211_hwsim_vendor_commands)
 444          */
 445         skb = cfg80211_vendor_event_alloc(wiphy, wdev, 100, 0, GFP_KERNEL);
 446         if (skb) {
 447                 /* skb_put() or nla_put() will fill up data within
 448                  * NL80211_ATTR_VENDOR_DATA.
 449                  */
 450
 451                 /* Add vendor data */
 452                 nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_TEST, val + 1);
 453
 454                 /* Send the event - this will call nla_nest_end() */
 455                 cfg80211_vendor_event(skb, GFP_KERNEL);
 456         }
 457
 458         /* Send a response to the command */
 459         skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 10);
 460         if (!skb)
 461                 return -ENOMEM;
 462
 463         /* skb_put() or nla_put() will fill up data within
 464          * NL80211_ATTR_VENDOR_DATA
 465          */
 466         nla_put_u32(skb, QCA_WLAN_VENDOR_ATTR_TEST, val + 2);
 467
 468         return cfg80211_vendor_cmd_reply(skb);
 469 }
 470
 471 static struct wiphy_vendor_command mac80211_hwsim_vendor_commands[] = {
 472         {
 473                 .info = { .vendor_id = OUI_QCA,
 474                           .subcmd = QCA_NL80211_SUBCMD_TEST },
 475                 .flags = WIPHY_VENDOR_CMD_NEED_NETDEV,
 476                 .doit = mac80211_hwsim_vendor_cmd_test,
 477                 .policy = hwsim_vendor_test_policy,
 478                 .maxattr = QCA_WLAN_VENDOR_ATTR_MAX,
 479         }
 480 };
 481
 482 /* Advertise support vendor specific events */
 483 static const struct nl80211_vendor_cmd_info mac80211_hwsim_vendor_events[] = {
 484         { .vendor_id = OUI_QCA, .subcmd = 1 },
 485 };
 486
 487 static spinlock_t hwsim_radio_lock;
 488 static LIST_HEAD(hwsim_radios);
 489 static struct rhashtable hwsim_radios_rht;
 490 static int hwsim_radio_idx;
 491 static int hwsim_radios_generation = 1;
 492
 493 static struct platform_driver mac80211_hwsim_driver = {
 494         .driver = {
 495                 .name = "mac80211_hwsim",
 496         },
 497 };
 498
 499 struct mac80211_hwsim_data {
 500         struct list_head list;
 501         struct rhash_head rht;
 502         struct ieee80211_hw *hw;
 503         struct device *dev;
 504         struct ieee80211_supported_band bands[NUM_NL80211_BANDS];
 505         struct ieee80211_channel channels_2ghz[ARRAY_SIZE(hwsim_channels_2ghz)];
 506         struct ieee80211_channel channels_5ghz[ARRAY_SIZE(hwsim_channels_5ghz)];
 507         struct ieee80211_rate rates[ARRAY_SIZE(hwsim_rates)];
 508         struct ieee80211_iface_combination if_combination;
 509         struct ieee80211_iface_limit if_limits[3];
 510         int n_if_limits;
 511
 512         u32 ciphers[ARRAY_SIZE(hwsim_ciphers)];
 513
 514         struct mac_address addresses[2];
 515         int channels, idx;
 516         bool use_chanctx;
 517         bool destroy_on_close;
 518         u32 portid;
 519         char alpha2[2];
 520         const struct ieee80211_regdomain *regd;
 521
 522         struct ieee80211_channel *tmp_chan;
 523         struct ieee80211_channel *roc_chan;
 524         u32 roc_duration;
 525         struct delayed_work roc_start;
 526         struct delayed_work roc_done;
 527         struct delayed_work hw_scan;
 528         struct cfg80211_scan_request *hw_scan_request;
 529         struct ieee80211_vif *hw_scan_vif;
 530         int scan_chan_idx;
 531         u8 scan_addr[ETH_ALEN];
 532         struct {
 533                 struct ieee80211_channel *channel;
 534                 unsigned long next_start, start, end;
 535         } survey_data[ARRAY_SIZE(hwsim_channels_2ghz) +
 536                       ARRAY_SIZE(hwsim_channels_5ghz)];
 537
 538         struct ieee80211_channel *channel;
 539         u64 beacon_int  /* beacon interval in us */;
 540         unsigned int rx_filter;
 541         bool started, idle, scanning;
 542         struct mutex mutex;
 543         struct hrtimer beacon_timer;
 544         enum ps_mode {
 545                 PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL
 546         } ps;
 547         bool ps_poll_pending;
 548         struct dentry *debugfs;
 549
 550         uintptr_t pending_cookie;
 551         struct sk_buff_head pending;    /* packets pending */
 552         /*
 553          * Only radios in the same group can communicate together (the
 554          * channel has to match too). Each bit represents a group. A
 555          * radio can be in more than one group.
 556          */
 557         u64 group;
 558
 559         /* group shared by radios created in the same netns */
 560         int netgroup;
 561         /* wmediumd portid responsible for netgroup of this radio */
 562         u32 wmediumd;
 563
 564         /* difference between this hw's clock and the real clock, in usecs */
 565         s64 tsf_offset;
 566         s64 bcn_delta;
 567         /* absolute beacon transmission time. Used to cover up "tx" delay. */
 568         u64 abs_bcn_ts;
 569
 570         /* Stats */
 571         u64 tx_pkts;
 572         u64 rx_pkts;
 573         u64 tx_bytes;
 574         u64 rx_bytes;
 575         u64 tx_dropped;
 576         u64 tx_failed;
 577 };
 578
 579 static const struct rhashtable_params hwsim_rht_params = {
 580         .nelem_hint = 2,
 581         .automatic_shrinking = true,
 582         .key_len = ETH_ALEN,
 583         .key_offset = offsetof(struct mac80211_hwsim_data, addresses[1]),
 584         .head_offset = offsetof(struct mac80211_hwsim_data, rht),
 585 };
 586
 587 struct hwsim_radiotap_hdr {
 588         struct ieee80211_radiotap_header hdr;
 589         __le64 rt_tsft;
 590         u8 rt_flags;
 591         u8 rt_rate;
 592         __le16 rt_channel;
 593         __le16 rt_chbitmask;
 594 } __packed;
 595
 596 struct hwsim_radiotap_ack_hdr {
 597         struct ieee80211_radiotap_header hdr;
 598         u8 rt_flags;
 599         u8 pad;
 600         __le16 rt_channel;
 601         __le16 rt_chbitmask;
 602 } __packed;
 603
 604 /* MAC80211_HWSIM netlink family */
 605 static struct genl_family hwsim_genl_family;
 606
 607 enum hwsim_multicast_groups {
 608         HWSIM_MCGRP_CONFIG,
 609 };
 610
 611 static const struct genl_multicast_group hwsim_mcgrps[] = {
 612         [HWSIM_MCGRP_CONFIG] = { .name = "config", },
 613 };
 614
 615 /* MAC80211_HWSIM netlink policy */
 616
 617 static const struct nla_policy hwsim_genl_policy[HWSIM_ATTR_MAX + 1] = {
 618         [HWSIM_ATTR_ADDR_RECEIVER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
 619         [HWSIM_ATTR_ADDR_TRANSMITTER] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
 620         [HWSIM_ATTR_FRAME] = { .type = NLA_BINARY,
 621                                .len = IEEE80211_MAX_DATA_LEN },
 622         [HWSIM_ATTR_FLAGS] = { .type = NLA_U32 },
 623         [HWSIM_ATTR_RX_RATE] = { .type = NLA_U32 },
 624         [HWSIM_ATTR_SIGNAL] = { .type = NLA_U32 },
 625         [HWSIM_ATTR_TX_INFO] = { .type = NLA_UNSPEC,
 626                                  .len = IEEE80211_TX_MAX_RATES *
 627                                         sizeof(struct hwsim_tx_rate)},
 628         [HWSIM_ATTR_COOKIE] = { .type = NLA_U64 },
 629         [HWSIM_ATTR_CHANNELS] = { .type = NLA_U32 },
 630         [HWSIM_ATTR_RADIO_ID] = { .type = NLA_U32 },
 631         [HWSIM_ATTR_REG_HINT_ALPHA2] = { .type = NLA_STRING, .len = 2 },
 632         [HWSIM_ATTR_REG_CUSTOM_REG] = { .type = NLA_U32 },
 633         [HWSIM_ATTR_REG_STRICT_REG] = { .type = NLA_FLAG },
 634         [HWSIM_ATTR_SUPPORT_P2P_DEVICE] = { .type = NLA_FLAG },
 635         [HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE] = { .type = NLA_FLAG },
 636         [HWSIM_ATTR_RADIO_NAME] = { .type = NLA_STRING },
 637         [HWSIM_ATTR_NO_VIF] = { .type = NLA_FLAG },
 638         [HWSIM_ATTR_FREQ] = { .type = NLA_U32 },
 639         [HWSIM_ATTR_PERM_ADDR] = { .type = NLA_UNSPEC, .len = ETH_ALEN },
 640         [HWSIM_ATTR_IFTYPE_SUPPORT] = { .type = NLA_U32 },
 641         [HWSIM_ATTR_CIPHER_SUPPORT] = { .type = NLA_BINARY },
 642 };
 643
 644 static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
 645                                     struct sk_buff *skb,
 646                                     struct ieee80211_channel *chan);
 647
 648 /* sysfs attributes */
 649 static void hwsim_send_ps_poll(void *dat, u8 *mac, struct ieee80211_vif *vif)
 650 {
 651         struct mac80211_hwsim_data *data = dat;
 652         struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 653         struct sk_buff *skb;
 654         struct ieee80211_pspoll *pspoll;
 655
 656         if (!vp->assoc)
 657                 return;
 658
 659         wiphy_dbg(data->hw->wiphy,
 660                   "%s: send PS-Poll to %pM for aid %d\n",
 661                   __func__, vp->bssid, vp->aid);
 662
 663         skb = dev_alloc_skb(sizeof(*pspoll));
 664         if (!skb)
 665                 return;
 666         pspoll = skb_put(skb, sizeof(*pspoll));
 667         pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
 668                                             IEEE80211_STYPE_PSPOLL |
 669                                             IEEE80211_FCTL_PM);
 670         pspoll->aid = cpu_to_le16(0xc000 | vp->aid);
 671         memcpy(pspoll->bssid, vp->bssid, ETH_ALEN);
 672         memcpy(pspoll->ta, mac, ETH_ALEN);
 673
 674         rcu_read_lock();
 675         mac80211_hwsim_tx_frame(data->hw, skb,
 676                                 rcu_dereference(vif->chanctx_conf)->def.chan);
 677         rcu_read_unlock();
 678 }
 679
 680 static void hwsim_send_nullfunc(struct mac80211_hwsim_data *data, u8 *mac,
 681                                 struct ieee80211_vif *vif, int ps)
 682 {
 683         struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
 684         struct sk_buff *skb;
 685         struct ieee80211_hdr *hdr;
 686
 687         if (!vp->assoc)
 688                 return;
 689
 690         wiphy_dbg(data->hw->wiphy,
 691                   "%s: send data::nullfunc to %pM ps=%d\n",
 692                   __func__, vp->bssid, ps);
 693
 694         skb = dev_alloc_skb(sizeof(*hdr));
 695         if (!skb)
 696                 return;
 697         hdr = skb_put(skb, sizeof(*hdr) - ETH_ALEN);
 698         hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
 699                                          IEEE80211_STYPE_NULLFUNC |
 700                                          IEEE80211_FCTL_TODS |
 701                                          (ps ? IEEE80211_FCTL_PM : 0));
 702         hdr->duration_id = cpu_to_le16(0);
 703         memcpy(hdr->addr1, vp->bssid, ETH_ALEN);
 704         memcpy(hdr->addr2, mac, ETH_ALEN);
 705         memcpy(hdr->addr3, vp->bssid, ETH_ALEN);
 706
 707         rcu_read_lock();
 708         mac80211_hwsim_tx_frame(data->hw, skb,
 709                                 rcu_dereference(vif->chanctx_conf)->def.chan);
 710         rcu_read_unlock();
 711 }
 712
 713
 714 static void hwsim_send_nullfunc_ps(void *dat, u8 *mac,
 715                                    struct ieee80211_vif *vif)
 716 {
 717         struct mac80211_hwsim_data *data = dat;
 718         hwsim_send_nullfunc(data, mac, vif, 1);
 719 }
 720
 721 static void hwsim_send_nullfunc_no_ps(void *dat, u8 *mac,
 722                                       struct ieee80211_vif *vif)
 723 {
 724         struct mac80211_hwsim_data *data = dat;
 725         hwsim_send_nullfunc(data, mac, vif, 0);
 726 }
 727
 728 static int hwsim_fops_ps_read(void *dat, u64 *val)
 729 {
 730         struct mac80211_hwsim_data *data = dat;
 731         *val = data->ps;
 732         return 0;
 733 }
 734
 735 static int hwsim_fops_ps_write(void *dat, u64 val)
 736 {
 737         struct mac80211_hwsim_data *data = dat;
 738         enum ps_mode old_ps;
 739
 740         if (val != PS_DISABLED && val != PS_ENABLED && val != PS_AUTO_POLL &&
 741             val != PS_MANUAL_POLL)
 742                 return -EINVAL;
 743
 744         if (val == PS_MANUAL_POLL) {
 745                 if (data->ps != PS_ENABLED)
 746                         return -EINVAL;
 747                 local_bh_disable();
 748                 ieee80211_iterate_active_interfaces_atomic(
 749                         data->hw, IEEE80211_IFACE_ITER_NORMAL,
 750                         hwsim_send_ps_poll, data);
 751                 local_bh_enable();
 752                 return 0;
 753         }
 754         old_ps = data->ps;
 755         data->ps = val;
 756
 757         local_bh_disable();
 758         if (old_ps == PS_DISABLED && val != PS_DISABLED) {
 759                 ieee80211_iterate_active_interfaces_atomic(
 760                         data->hw, IEEE80211_IFACE_ITER_NORMAL,
 761                         hwsim_send_nullfunc_ps, data);
 762         } else if (old_ps != PS_DISABLED && val == PS_DISABLED) {
 763                 ieee80211_iterate_active_interfaces_atomic(
 764                         data->hw, IEEE80211_IFACE_ITER_NORMAL,
 765                         hwsim_send_nullfunc_no_ps, data);
 766         }
 767         local_bh_enable();
 768
 769         return 0;
 770 }
 771
 772 DEFINE_DEBUGFS_ATTRIBUTE(hwsim_fops_ps, hwsim_fops_ps_read, hwsim_fops_ps_write,
 773                          "%llu\n");
 774
 775 static int hwsim_write_simulate_radar(void *dat, u64 val)
 776 {
 777         struct mac80211_hwsim_data *data = dat;
 778
 779         ieee80211_radar_detected(data->hw);
 780
 781         return 0;
 782 }
 783
 784 DEFINE_DEBUGFS_ATTRIBUTE(hwsim_simulate_radar, NULL,
 785                          hwsim_write_simulate_radar, "%llu\n");
 786
 787 static int hwsim_fops_group_read(void *dat, u64 *val)
 788 {
 789         struct mac80211_hwsim_data *data = dat;
 790         *val = data->group;
 791         return 0;
 792 }
 793
 794 static int hwsim_fops_group_write(void *dat, u64 val)
 795 {
 796         struct mac80211_hwsim_data *data = dat;
 797         data->group = val;
 798         return 0;
 799 }
 800
 801 DEFINE_DEBUGFS_ATTRIBUTE(hwsim_fops_group,
 802                          hwsim_fops_group_read, hwsim_fops_group_write,
 803                          "%llx\n");
 804
 805 static netdev_tx_t hwsim_mon_xmit(struct sk_buff *skb,
 806                                         struct net_device *dev)
 807 {
 808         /* TODO: allow packet injection */
 809         dev_kfree_skb(skb);
 810         return NETDEV_TX_OK;
 811 }
 812
 813 static inline u64 mac80211_hwsim_get_tsf_raw(void)
 814 {
 815         return ktime_to_us(ktime_get_real());
 816 }
 817
 818 static __le64 __mac80211_hwsim_get_tsf(struct mac80211_hwsim_data *data)
 819 {
 820         u64 now = mac80211_hwsim_get_tsf_raw();
 821         return cpu_to_le64(now + data->tsf_offset);
 822 }
 823
 824 static u64 mac80211_hwsim_get_tsf(struct ieee80211_hw *hw,
 825                                   struct ieee80211_vif *vif)
 826 {
 827         struct mac80211_hwsim_data *data = hw->priv;
 828         return le64_to_cpu(__mac80211_hwsim_get_tsf(data));
 829 }
 830
 831 static void mac80211_hwsim_set_tsf(struct ieee80211_hw *hw,
 832                 struct ieee80211_vif *vif, u64 tsf)
 833 {
 834         struct mac80211_hwsim_data *data = hw->priv;
 835         u64 now = mac80211_hwsim_get_tsf(hw, vif);
 836         u32 bcn_int = data->beacon_int;
 837         u64 delta = abs(tsf - now);
 838
 839         /* adjust after beaconing with new timestamp at old TBTT */
 840         if (tsf > now) {
 841                 data->tsf_offset += delta;
 842                 data->bcn_delta = do_div(delta, bcn_int);
 843         } else {
 844                 data->tsf_offset -= delta;
 845                 data->bcn_delta = -(s64)do_div(delta, bcn_int);
 846         }
 847 }
 848
 849 static void mac80211_hwsim_monitor_rx(struct ieee80211_hw *hw,
 850                                       struct sk_buff *tx_skb,
 851                                       struct ieee80211_channel *chan)
 852 {
 853         struct mac80211_hwsim_data *data = hw->priv;
 854         struct sk_buff *skb;
 855         struct hwsim_radiotap_hdr *hdr;
 856         u16 flags;
 857         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_skb);
 858         struct ieee80211_rate *txrate = ieee80211_get_tx_rate(hw, info);
 859
 860         if (WARN_ON(!txrate))
 861                 return;
 862
 863         if (!netif_running(hwsim_mon))
 864                 return;
 865
 866         skb = skb_copy_expand(tx_skb, sizeof(*hdr), 0, GFP_ATOMIC);
 867         if (skb == NULL)
 868                 return;
 869
 870         hdr = skb_push(skb, sizeof(*hdr));
 871         hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
 872         hdr->hdr.it_pad = 0;
 873         hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
 874         hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
 875                                           (1 << IEEE80211_RADIOTAP_RATE) |
 876                                           (1 << IEEE80211_RADIOTAP_TSFT) |
 877                                           (1 << IEEE80211_RADIOTAP_CHANNEL));
 878         hdr->rt_tsft = __mac80211_hwsim_get_tsf(data);
 879         hdr->rt_flags = 0;
 880         hdr->rt_rate = txrate->bitrate / 5;
 881         hdr->rt_channel = cpu_to_le16(chan->center_freq);
 882         flags = IEEE80211_CHAN_2GHZ;
 883         if (txrate->flags & IEEE80211_RATE_ERP_G)
 884                 flags |= IEEE80211_CHAN_OFDM;
 885         else
 886                 flags |= IEEE80211_CHAN_CCK;
 887         hdr->rt_chbitmask = cpu_to_le16(flags);
 888
 889         skb->dev = hwsim_mon;
 890         skb_reset_mac_header(skb);
 891         skb->ip_summed = CHECKSUM_UNNECESSARY;
 892         skb->pkt_type = PACKET_OTHERHOST;
 893         skb->protocol = htons(ETH_P_802_2);
 894         memset(skb->cb, 0, sizeof(skb->cb));
 895         netif_rx(skb);
 896 }
 897
 898
 899 static void mac80211_hwsim_monitor_ack(struct ieee80211_channel *chan,
 900                                        const u8 *addr)
 901 {
 902         struct sk_buff *skb;
 903         struct hwsim_radiotap_ack_hdr *hdr;
 904         u16 flags;
 905         struct ieee80211_hdr *hdr11;
 906
 907         if (!netif_running(hwsim_mon))
 908                 return;
 909
 910         skb = dev_alloc_skb(100);
 911         if (skb == NULL)
 912                 return;
 913
 914         hdr = skb_put(skb, sizeof(*hdr));
 915         hdr->hdr.it_version = PKTHDR_RADIOTAP_VERSION;
 916         hdr->hdr.it_pad = 0;
 917         hdr->hdr.it_len = cpu_to_le16(sizeof(*hdr));
 918         hdr->hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
 919                                           (1 << IEEE80211_RADIOTAP_CHANNEL));
 920         hdr->rt_flags = 0;
 921         hdr->pad = 0;
 922         hdr->rt_channel = cpu_to_le16(chan->center_freq);
 923         flags = IEEE80211_CHAN_2GHZ;
 924         hdr->rt_chbitmask = cpu_to_le16(flags);
 925
 926         hdr11 = skb_put(skb, 10);
 927         hdr11->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
 928                                            IEEE80211_STYPE_ACK);
 929         hdr11->duration_id = cpu_to_le16(0);
 930         memcpy(hdr11->addr1, addr, ETH_ALEN);
 931
 932         skb->dev = hwsim_mon;
 933         skb_reset_mac_header(skb);
 934         skb->ip_summed = CHECKSUM_UNNECESSARY;
 935         skb->pkt_type = PACKET_OTHERHOST;
 936         skb->protocol = htons(ETH_P_802_2);
 937         memset(skb->cb, 0, sizeof(skb->cb));
 938         netif_rx(skb);
 939 }
 940
 941 struct mac80211_hwsim_addr_match_data {
 942         u8 addr[ETH_ALEN];
 943         bool ret;
 944 };
 945
 946 static void mac80211_hwsim_addr_iter(void *data, u8 *mac,
 947                                      struct ieee80211_vif *vif)
 948 {
 949         struct mac80211_hwsim_addr_match_data *md = data;
 950
 951         if (memcmp(mac, md->addr, ETH_ALEN) == 0)
 952                 md->ret = true;
 953 }
 954
 955 static bool mac80211_hwsim_addr_match(struct mac80211_hwsim_data *data,
 956                                       const u8 *addr)
 957 {
 958         struct mac80211_hwsim_addr_match_data md = {
 959                 .ret = false,
 960         };
 961
 962         if (data->scanning && memcmp(addr, data->scan_addr, ETH_ALEN) == 0)
 963                 return true;
 964
 965         memcpy(md.addr, addr, ETH_ALEN);
 966
 967         ieee80211_iterate_active_interfaces_atomic(data->hw,
 968                                                    IEEE80211_IFACE_ITER_NORMAL,
 969                                                    mac80211_hwsim_addr_iter,
 970                                                    &md);
 971
 972         return md.ret;
 973 }
 974
 975 static bool hwsim_ps_rx_ok(struct mac80211_hwsim_data *data,
 976                            struct sk_buff *skb)
 977 {
 978         switch (data->ps) {
 979         case PS_DISABLED:
 980                 return true;
 981         case PS_ENABLED:
 982                 return false;
 983         case PS_AUTO_POLL:
 984                 /* TODO: accept (some) Beacons by default and other frames only
 985                  * if pending PS-Poll has been sent */
 986                 return true;
 987         case PS_MANUAL_POLL:
 988                 /* Allow unicast frames to own address if there is a pending
 989                  * PS-Poll */
 990                 if (data->ps_poll_pending &&
 991                     mac80211_hwsim_addr_match(data, skb->data + 4)) {
 992                         data->ps_poll_pending = false;
 993                         return true;
 994                 }
 995                 return false;
 996         }
 997
 998         return true;
 999 }
1000
1001 static int hwsim_unicast_netgroup(struct mac80211_hwsim_data *data,
1002                                   struct sk_buff *skb, int portid)
1003 {
1004         struct net *net;
1005         bool found = false;
1006         int res = -ENOENT;
1007
1008         rcu_read_lock();
1009         for_each_net_rcu(net) {
1010                 if (data->netgroup == hwsim_net_get_netgroup(net)) {
1011                         res = genlmsg_unicast(net, skb, portid);
1012                         found = true;
1013                         break;
1014                 }
1015         }
1016         rcu_read_unlock();
1017
1018         if (!found)
1019                 nlmsg_free(skb);
1020
1021         return res;
1022 }
1023
1024 static inline u16 trans_tx_rate_flags_ieee2hwsim(struct ieee80211_tx_rate *rate)
1025 {
1026         u16 result = 0;
1027
1028         if (rate->flags & IEEE80211_TX_RC_USE_RTS_CTS)
1029                 result |= MAC80211_HWSIM_TX_RC_USE_RTS_CTS;
1030         if (rate->flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
1031                 result |= MAC80211_HWSIM_TX_RC_USE_CTS_PROTECT;
1032         if (rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
1033                 result |= MAC80211_HWSIM_TX_RC_USE_SHORT_PREAMBLE;
1034         if (rate->flags & IEEE80211_TX_RC_MCS)
1035                 result |= MAC80211_HWSIM_TX_RC_MCS;
1036         if (rate->flags & IEEE80211_TX_RC_GREEN_FIELD)
1037                 result |= MAC80211_HWSIM_TX_RC_GREEN_FIELD;
1038         if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
1039                 result |= MAC80211_HWSIM_TX_RC_40_MHZ_WIDTH;
1040         if (rate->flags & IEEE80211_TX_RC_DUP_DATA)
1041                 result |= MAC80211_HWSIM_TX_RC_DUP_DATA;
1042         if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
1043                 result |= MAC80211_HWSIM_TX_RC_SHORT_GI;
1044         if (rate->flags & IEEE80211_TX_RC_VHT_MCS)
1045                 result |= MAC80211_HWSIM_TX_RC_VHT_MCS;
1046         if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
1047                 result |= MAC80211_HWSIM_TX_RC_80_MHZ_WIDTH;
1048         if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
1049                 result |= MAC80211_HWSIM_TX_RC_160_MHZ_WIDTH;
1050
1051         return result;
1052 }
1053
1054 static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw,
1055                                        struct sk_buff *my_skb,
1056                                        int dst_portid)
1057 {
1058         struct sk_buff *skb;
1059         struct mac80211_hwsim_data *data = hw->priv;
1060         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) my_skb->data;
1061         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(my_skb);
1062         void *msg_head;
1063         unsigned int hwsim_flags = 0;
1064         int i;
1065         struct hwsim_tx_rate tx_attempts[IEEE80211_TX_MAX_RATES];
1066         struct hwsim_tx_rate_flag tx_attempts_flags[IEEE80211_TX_MAX_RATES];
1067         uintptr_t cookie;
1068
1069         if (data->ps != PS_DISABLED)
1070                 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
1071         /* If the queue contains MAX_QUEUE skb's drop some */
1072         if (skb_queue_len(&data->pending) >= MAX_QUEUE) {
1073                 /* Droping until WARN_QUEUE level */
1074                 while (skb_queue_len(&data->pending) >= WARN_QUEUE) {
1075                         ieee80211_free_txskb(hw, skb_dequeue(&data->pending));
1076                         data->tx_dropped++;
1077                 }
1078         }
1079
1080         skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_ATOMIC);
1081         if (skb == NULL)
1082                 goto nla_put_failure;
1083
1084         msg_head = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0,
1085                                HWSIM_CMD_FRAME);
1086         if (msg_head == NULL) {
1087                 pr_debug("mac80211_hwsim: problem with msg_head\n");
1088                 goto nla_put_failure;
1089         }
1090
1091         if (nla_put(skb, HWSIM_ATTR_ADDR_TRANSMITTER,
1092                     ETH_ALEN, data->addresses[1].addr))
1093                 goto nla_put_failure;
1094
1095         /* We get the skb->data */
1096         if (nla_put(skb, HWSIM_ATTR_FRAME, my_skb->len, my_skb->data))
1097                 goto nla_put_failure;
1098
1099         /* We get the flags for this transmission, and we translate them to
1100            wmediumd flags  */
1101
1102         if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)
1103                 hwsim_flags |= HWSIM_TX_CTL_REQ_TX_STATUS;
1104
1105         if (info->flags & IEEE80211_TX_CTL_NO_ACK)
1106                 hwsim_flags |= HWSIM_TX_CTL_NO_ACK;
1107
1108         if (nla_put_u32(skb, HWSIM_ATTR_FLAGS, hwsim_flags))
1109                 goto nla_put_failure;
1110
1111         if (nla_put_u32(skb, HWSIM_ATTR_FREQ, data->channel->center_freq))
1112                 goto nla_put_failure;
1113
1114         /* We get the tx control (rate and retries) info*/
1115
1116         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
1117                 tx_attempts[i].idx = info->status.rates[i].idx;
1118                 tx_attempts_flags[i].idx = info->status.rates[i].idx;
1119                 tx_attempts[i].count = info->status.rates[i].count;
1120                 tx_attempts_flags[i].flags =
1121                                 trans_tx_rate_flags_ieee2hwsim(
1122                                                 &info->status.rates[i]);
1123         }
1124
1125         if (nla_put(skb, HWSIM_ATTR_TX_INFO,
1126                     sizeof(struct hwsim_tx_rate)*IEEE80211_TX_MAX_RATES,
1127                     tx_attempts))
1128                 goto nla_put_failure;
1129
1130         if (nla_put(skb, HWSIM_ATTR_TX_INFO_FLAGS,
1131                     sizeof(struct hwsim_tx_rate_flag) * IEEE80211_TX_MAX_RATES,
1132                     tx_attempts_flags))
1133                 goto nla_put_failure;
1134
1135         /* We create a cookie to identify this skb */
1136         data->pending_cookie++;
1137         cookie = data->pending_cookie;
1138         info->rate_driver_data[0] = (void *)cookie;
1139         if (nla_put_u64_64bit(skb, HWSIM_ATTR_COOKIE, cookie, HWSIM_ATTR_PAD))
1140                 goto nla_put_failure;
1141
1142         genlmsg_end(skb, msg_head);
1143         if (hwsim_unicast_netgroup(data, skb, dst_portid))
1144                 goto err_free_txskb;
1145
1146         /* Enqueue the packet */
1147         skb_queue_tail(&data->pending, my_skb);
1148         data->tx_pkts++;
1149         data->tx_bytes += my_skb->len;
1150         return;
1151
1152 nla_put_failure:
1153         nlmsg_free(skb);
1154 err_free_txskb:
1155         pr_debug("mac80211_hwsim: error occurred in %s\n", __func__);
1156         ieee80211_free_txskb(hw, my_skb);
1157         data->tx_failed++;
1158 }
1159
1160 static bool hwsim_chans_compat(struct ieee80211_channel *c1,
1161                                struct ieee80211_channel *c2)
1162 {
1163         if (!c1 || !c2)
1164                 return false;
1165
1166         return c1->center_freq == c2->center_freq;
1167 }
1168
1169 struct tx_iter_data {
1170         struct ieee80211_channel *channel;
1171         bool receive;
1172 };
1173
1174 static void mac80211_hwsim_tx_iter(void *_data, u8 *addr,
1175                                    struct ieee80211_vif *vif)
1176 {
1177         struct tx_iter_data *data = _data;
1178
1179         if (!vif->chanctx_conf)
1180                 return;
1181
1182         if (!hwsim_chans_compat(data->channel,
1183                                 rcu_dereference(vif->chanctx_conf)->def.chan))
1184                 return;
1185
1186         data->receive = true;
1187 }
1188
1189 static void mac80211_hwsim_add_vendor_rtap(struct sk_buff *skb)
1190 {
1191         /*
1192          * To enable this code, #define the HWSIM_RADIOTAP_OUI,
1193          * e.g. like this:
1194          * #define HWSIM_RADIOTAP_OUI "\x02\x00\x00"
1195          * (but you should use a valid OUI, not that)
1196          *
1197          * If anyone wants to 'donate' a radiotap OUI/subns code
1198          * please send a patch removing this #ifdef and changing
1199          * the values accordingly.
1200          */
1201 #ifdef HWSIM_RADIOTAP_OUI
1202         struct ieee80211_vendor_radiotap *rtap;
1203
1204         /*
1205          * Note that this code requires the headroom in the SKB
1206          * that was allocated earlier.
1207          */
1208         rtap = skb_push(skb, sizeof(*rtap) + 8 + 4);
1209         rtap->oui[0] = HWSIM_RADIOTAP_OUI[0];
1210         rtap->oui[1] = HWSIM_RADIOTAP_OUI[1];
1211         rtap->oui[2] = HWSIM_RADIOTAP_OUI[2];
1212         rtap->subns = 127;
1213
1214         /*
1215          * Radiotap vendor namespaces can (and should) also be
1216          * split into fields by using the standard radiotap
1217          * presence bitmap mechanism. Use just BIT(0) here for
1218          * the presence bitmap.
1219          */
1220         rtap->present = BIT(0);
1221         /* We have 8 bytes of (dummy) data */
1222         rtap->len = 8;
1223         /* For testing, also require it to be aligned */
1224         rtap->align = 8;
1225         /* And also test that padding works, 4 bytes */
1226         rtap->pad = 4;
1227         /* push the data */
1228         memcpy(rtap->data, "ABCDEFGH", 8);
1229         /* make sure to clear padding, mac80211 doesn't */
1230         memset(rtap->data + 8, 0, 4);
1231
1232         IEEE80211_SKB_RXCB(skb)->flag |= RX_FLAG_RADIOTAP_VENDOR_DATA;
1233 #endif
1234 }
1235
1236 static bool mac80211_hwsim_tx_frame_no_nl(struct ieee80211_hw *hw,
1237                                           struct sk_buff *skb,
1238                                           struct ieee80211_channel *chan)
1239 {
1240         struct mac80211_hwsim_data *data = hw->priv, *data2;
1241         bool ack = false;
1242         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
1243         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1244         struct ieee80211_rx_status rx_status;
1245         u64 now;
1246
1247         memset(&rx_status, 0, sizeof(rx_status));
1248         rx_status.flag |= RX_FLAG_MACTIME_START;
1249         rx_status.freq = chan->center_freq;
1250         rx_status.band = chan->band;
1251         if (info->control.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) {
1252                 rx_status.rate_idx =
1253                         ieee80211_rate_get_vht_mcs(&info->control.rates[0]);
1254                 rx_status.nss =
1255                         ieee80211_rate_get_vht_nss(&info->control.rates[0]);
1256                 rx_status.encoding = RX_ENC_VHT;
1257         } else {
1258                 rx_status.rate_idx = info->control.rates[0].idx;
1259                 if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
1260                         rx_status.encoding = RX_ENC_HT;
1261         }
1262         if (info->control.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
1263                 rx_status.bw = RATE_INFO_BW_40;
1264         else if (info->control.rates[0].flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
1265                 rx_status.bw = RATE_INFO_BW_80;
1266         else if (info->control.rates[0].flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
1267                 rx_status.bw = RATE_INFO_BW_160;
1268         else
1269                 rx_status.bw = RATE_INFO_BW_20;
1270         if (info->control.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
1271                 rx_status.enc_flags |= RX_ENC_FLAG_SHORT_GI;
1272         /* TODO: simulate real signal strength (and optional packet loss) */
1273         rx_status.signal = -50;
1274         if (info->control.vif)
1275                 rx_status.signal += info->control.vif->bss_conf.txpower;
1276
1277         if (data->ps != PS_DISABLED)
1278                 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
1279
1280         /* release the skb's source info */
1281         skb_orphan(skb);
1282         skb_dst_drop(skb);
1283         skb->mark = 0;
1284         skb_ext_reset(skb);
1285         nf_reset_ct(skb);
1286
1287         /*
1288          * Get absolute mactime here so all HWs RX at the "same time", and
1289          * absolute TX time for beacon mactime so the timestamp matches.
1290          * Giving beacons a different mactime than non-beacons looks messy, but
1291          * it helps the Toffset be exact and a ~10us mactime discrepancy
1292          * probably doesn't really matter.
1293          */
1294         if (ieee80211_is_beacon(hdr->frame_control) ||
1295             ieee80211_is_probe_resp(hdr->frame_control)) {
1296                 rx_status.boottime_ns = ktime_get_boottime_ns();
1297                 now = data->abs_bcn_ts;
1298         } else {
1299                 now = mac80211_hwsim_get_tsf_raw();
1300         }
1301
1302         /* Copy skb to all enabled radios that are on the current frequency */
1303         spin_lock(&hwsim_radio_lock);
1304         list_for_each_entry(data2, &hwsim_radios, list) {
1305                 struct sk_buff *nskb;
1306                 struct tx_iter_data tx_iter_data = {
1307                         .receive = false,
1308                         .channel = chan,
1309                 };
1310
1311                 if (data == data2)
1312                         continue;
1313
1314                 if (!data2->started || (data2->idle && !data2->tmp_chan) ||
1315                     !hwsim_ps_rx_ok(data2, skb))
1316                         continue;
1317
1318                 if (!(data->group & data2->group))
1319                         continue;
1320
1321                 if (data->netgroup != data2->netgroup)
1322                         continue;
1323
1324                 if (!hwsim_chans_compat(chan, data2->tmp_chan) &&
1325                     !hwsim_chans_compat(chan, data2->channel)) {
1326                         ieee80211_iterate_active_interfaces_atomic(
1327                                 data2->hw, IEEE80211_IFACE_ITER_NORMAL,
1328                                 mac80211_hwsim_tx_iter, &tx_iter_data);
1329                         if (!tx_iter_data.receive)
1330                                 continue;
1331                 }
1332
1333                 /*
1334                  * reserve some space for our vendor and the normal
1335                  * radiotap header, since we're copying anyway
1336                  */
1337                 if (skb->len < PAGE_SIZE && paged_rx) {
1338                         struct page *page = alloc_page(GFP_ATOMIC);
1339
1340                         if (!page)
1341                                 continue;
1342
1343                         nskb = dev_alloc_skb(128);
1344                         if (!nskb) {
1345                                 __free_page(page);
1346                                 continue;
1347                         }
1348
1349                         memcpy(page_address(page), skb->data, skb->len);
1350                         skb_add_rx_frag(nskb, 0, page, 0, skb->len, skb->len);
1351                 } else {
1352                         nskb = skb_copy(skb, GFP_ATOMIC);
1353                         if (!nskb)
1354                                 continue;
1355                 }
1356
1357                 if (mac80211_hwsim_addr_match(data2, hdr->addr1))
1358                         ack = true;
1359
1360                 rx_status.mactime = now + data2->tsf_offset;
1361
1362                 memcpy(IEEE80211_SKB_RXCB(nskb), &rx_status, sizeof(rx_status));
1363
1364                 mac80211_hwsim_add_vendor_rtap(nskb);
1365
1366                 data2->rx_pkts++;
1367                 data2->rx_bytes += nskb->len;
1368                 ieee80211_rx_irqsafe(data2->hw, nskb);
1369         }
1370         spin_unlock(&hwsim_radio_lock);
1371
1372         return ack;
1373 }
1374
1375 static void mac80211_hwsim_tx(struct ieee80211_hw *hw,
1376                               struct ieee80211_tx_control *control,
1377                               struct sk_buff *skb)
1378 {
1379         struct mac80211_hwsim_data *data = hw->priv;
1380         struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
1381         struct ieee80211_hdr *hdr = (void *)skb->data;
1382         struct ieee80211_chanctx_conf *chanctx_conf;
1383         struct ieee80211_channel *channel;
1384         bool ack;
1385         u32 _portid;
1386
1387         if (WARN_ON(skb->len < 10)) {
1388                 /* Should not happen; just a sanity check for addr1 use */
1389                 ieee80211_free_txskb(hw, skb);
1390                 return;
1391         }
1392
1393         if (!data->use_chanctx) {
1394                 channel = data->channel;
1395         } else if (txi->hw_queue == 4) {
1396                 channel = data->tmp_chan;
1397         } else {
1398                 chanctx_conf = rcu_dereference(txi->control.vif->chanctx_conf);
1399                 if (chanctx_conf)
1400                         channel = chanctx_conf->def.chan;
1401                 else
1402                         channel = NULL;
1403         }
1404
1405         if (WARN(!channel, "TX w/o channel - queue = %d\n", txi->hw_queue)) {
1406                 ieee80211_free_txskb(hw, skb);
1407                 return;
1408         }
1409
1410         if (data->idle && !data->tmp_chan) {
1411                 wiphy_dbg(hw->wiphy, "Trying to TX when idle - reject\n");
1412                 ieee80211_free_txskb(hw, skb);
1413                 return;
1414         }
1415
1416         if (txi->control.vif)
1417                 hwsim_check_magic(txi->control.vif);
1418         if (control->sta)
1419                 hwsim_check_sta_magic(control->sta);
1420
1421         if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE))
1422                 ieee80211_get_tx_rates(txi->control.vif, control->sta, skb,
1423                                        txi->control.rates,
1424                                        ARRAY_SIZE(txi->control.rates));
1425
1426         if (skb->len >= 24 + 8 &&
1427             ieee80211_is_probe_resp(hdr->frame_control)) {
1428                 /* fake header transmission time */
1429                 struct ieee80211_mgmt *mgmt;
1430                 struct ieee80211_rate *txrate;
1431                 u64 ts;
1432
1433                 mgmt = (struct ieee80211_mgmt *)skb->data;
1434                 txrate = ieee80211_get_tx_rate(hw, txi);
1435                 ts = mac80211_hwsim_get_tsf_raw();
1436                 mgmt->u.probe_resp.timestamp =
1437                         cpu_to_le64(ts + data->tsf_offset +
1438                                     24 * 8 * 10 / txrate->bitrate);
1439         }
1440
1441         mac80211_hwsim_monitor_rx(hw, skb, channel);
1442
1443         /* wmediumd mode check */
1444         _portid = READ_ONCE(data->wmediumd);
1445
1446         if (_portid)
1447                 return mac80211_hwsim_tx_frame_nl(hw, skb, _portid);
1448
1449         /* NO wmediumd detected, perfect medium simulation */
1450         data->tx_pkts++;
1451         data->tx_bytes += skb->len;
1452         ack = mac80211_hwsim_tx_frame_no_nl(hw, skb, channel);
1453
1454         if (ack && skb->len >= 16)
1455                 mac80211_hwsim_monitor_ack(channel, hdr->addr2);
1456
1457         ieee80211_tx_info_clear_status(txi);
1458
1459         /* frame was transmitted at most favorable rate at first attempt */
1460         txi->control.rates[0].count = 1;
1461         txi->control.rates[1].idx = -1;
1462
1463         if (!(txi->flags & IEEE80211_TX_CTL_NO_ACK) && ack)
1464                 txi->flags |= IEEE80211_TX_STAT_ACK;
1465         ieee80211_tx_status_irqsafe(hw, skb);
1466 }
1467
1468
1469 static int mac80211_hwsim_start(struct ieee80211_hw *hw)
1470 {
1471         struct mac80211_hwsim_data *data = hw->priv;
1472         wiphy_dbg(hw->wiphy, "%s\n", __func__);
1473         data->started = true;
1474         return 0;
1475 }
1476
1477
1478 static void mac80211_hwsim_stop(struct ieee80211_hw *hw)
1479 {
1480         struct mac80211_hwsim_data *data = hw->priv;
1481         data->started = false;
1482         hrtimer_cancel(&data->beacon_timer);
1483         wiphy_dbg(hw->wiphy, "%s\n", __func__);
1484 }
1485
1486
1487 static int mac80211_hwsim_add_interface(struct ieee80211_hw *hw,
1488                                         struct ieee80211_vif *vif)
1489 {
1490         wiphy_dbg(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
1491                   __func__, ieee80211_vif_type_p2p(vif),
1492                   vif->addr);
1493         hwsim_set_magic(vif);
1494
1495         vif->cab_queue = 0;
1496         vif->hw_queue[IEEE80211_AC_VO] = 0;
1497         vif->hw_queue[IEEE80211_AC_VI] = 1;
1498         vif->hw_queue[IEEE80211_AC_BE] = 2;
1499         vif->hw_queue[IEEE80211_AC_BK] = 3;
1500
1501         return 0;
1502 }
1503
1504
1505 static int mac80211_hwsim_change_interface(struct ieee80211_hw *hw,
1506                                            struct ieee80211_vif *vif,
1507                                            enum nl80211_iftype newtype,
1508                                            bool newp2p)
1509 {
1510         newtype = ieee80211_iftype_p2p(newtype, newp2p);
1511         wiphy_dbg(hw->wiphy,
1512                   "%s (old type=%d, new type=%d, mac_addr=%pM)\n",
1513                   __func__, ieee80211_vif_type_p2p(vif),
1514                     newtype, vif->addr);
1515         hwsim_check_magic(vif);
1516
1517         /*
1518          * interface may change from non-AP to AP in
1519          * which case this needs to be set up again
1520          */
1521         vif->cab_queue = 0;
1522
1523         return 0;
1524 }
1525
1526 static void mac80211_hwsim_remove_interface(
1527         struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1528 {
1529         wiphy_dbg(hw->wiphy, "%s (type=%d mac_addr=%pM)\n",
1530                   __func__, ieee80211_vif_type_p2p(vif),
1531                   vif->addr);
1532         hwsim_check_magic(vif);
1533         hwsim_clear_magic(vif);
1534 }
1535
1536 static void mac80211_hwsim_tx_frame(struct ieee80211_hw *hw,
1537                                     struct sk_buff *skb,
1538                                     struct ieee80211_channel *chan)
1539 {
1540         struct mac80211_hwsim_data *data = hw->priv;
1541         u32 _pid = READ_ONCE(data->wmediumd);
1542
1543         if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE)) {
1544                 struct ieee80211_tx_info *txi = IEEE80211_SKB_CB(skb);
1545                 ieee80211_get_tx_rates(txi->control.vif, NULL, skb,
1546                                        txi->control.rates,
1547                                        ARRAY_SIZE(txi->control.rates));
1548         }
1549
1550         mac80211_hwsim_monitor_rx(hw, skb, chan);
1551
1552         if (_pid)
1553                 return mac80211_hwsim_tx_frame_nl(hw, skb, _pid);
1554
1555         mac80211_hwsim_tx_frame_no_nl(hw, skb, chan);
1556         dev_kfree_skb(skb);
1557 }
1558
1559 static void mac80211_hwsim_beacon_tx(void *arg, u8 *mac,
1560                                      struct ieee80211_vif *vif)
1561 {
1562         struct mac80211_hwsim_data *data = arg;
1563         struct ieee80211_hw *hw = data->hw;
1564         struct ieee80211_tx_info *info;
1565         struct ieee80211_rate *txrate;
1566         struct ieee80211_mgmt *mgmt;
1567         struct sk_buff *skb;
1568
1569         hwsim_check_magic(vif);
1570
1571         if (vif->type != NL80211_IFTYPE_AP &&
1572             vif->type != NL80211_IFTYPE_MESH_POINT &&
1573             vif->type != NL80211_IFTYPE_ADHOC &&
1574             vif->type != NL80211_IFTYPE_OCB)
1575                 return;
1576
1577         skb = ieee80211_beacon_get(hw, vif);
1578         if (skb == NULL)
1579                 return;
1580         info = IEEE80211_SKB_CB(skb);
1581         if (ieee80211_hw_check(hw, SUPPORTS_RC_TABLE))
1582                 ieee80211_get_tx_rates(vif, NULL, skb,
1583                                        info->control.rates,
1584                                        ARRAY_SIZE(info->control.rates));
1585
1586         txrate = ieee80211_get_tx_rate(hw, info);
1587
1588         mgmt = (struct ieee80211_mgmt *) skb->data;
1589         /* fake header transmission time */
1590         data->abs_bcn_ts = mac80211_hwsim_get_tsf_raw();
1591         mgmt->u.beacon.timestamp = cpu_to_le64(data->abs_bcn_ts +
1592                                                data->tsf_offset +
1593                                                24 * 8 * 10 / txrate->bitrate);
1594
1595         mac80211_hwsim_tx_frame(hw, skb,
1596                                 rcu_dereference(vif->chanctx_conf)->def.chan);
1597
1598         if (vif->csa_active && ieee80211_csa_is_complete(vif))
1599                 ieee80211_csa_finish(vif);
1600 }
1601
1602 static enum hrtimer_restart
1603 mac80211_hwsim_beacon(struct hrtimer *timer)
1604 {
1605         struct mac80211_hwsim_data *data =
1606                 container_of(timer, struct mac80211_hwsim_data, beacon_timer);
1607         struct ieee80211_hw *hw = data->hw;
1608         u64 bcn_int = data->beacon_int;
1609
1610         if (!data->started)
1611                 return HRTIMER_NORESTART;
1612
1613         ieee80211_iterate_active_interfaces_atomic(
1614                 hw, IEEE80211_IFACE_ITER_NORMAL,
1615                 mac80211_hwsim_beacon_tx, data);
1616
1617         /* beacon at new TBTT + beacon interval */
1618         if (data->bcn_delta) {
1619                 bcn_int -= data->bcn_delta;
1620                 data->bcn_delta = 0;
1621         }
1622         hrtimer_forward(&data->beacon_timer, hrtimer_get_expires(timer),
1623                         ns_to_ktime(bcn_int * NSEC_PER_USEC));
1624         return HRTIMER_RESTART;
1625 }
1626
1627 static const char * const hwsim_chanwidths[] = {
1628         [NL80211_CHAN_WIDTH_5] = "ht5",
1629         [NL80211_CHAN_WIDTH_10] = "ht10",
1630         [NL80211_CHAN_WIDTH_20_NOHT] = "noht",
1631         [NL80211_CHAN_WIDTH_20] = "ht20",
1632         [NL80211_CHAN_WIDTH_40] = "ht40",
1633         [NL80211_CHAN_WIDTH_80] = "vht80",
1634         [NL80211_CHAN_WIDTH_80P80] = "vht80p80",
1635         [NL80211_CHAN_WIDTH_160] = "vht160",
1636 };
1637
1638 static int mac80211_hwsim_config(struct ieee80211_hw *hw, u32 changed)
1639 {
1640         struct mac80211_hwsim_data *data = hw->priv;
1641         struct ieee80211_conf *conf = &hw->conf;
1642         static const char *smps_modes[IEEE80211_SMPS_NUM_MODES] = {
1643                 [IEEE80211_SMPS_AUTOMATIC] = "auto",
1644                 [IEEE80211_SMPS_OFF] = "off",
1645                 [IEEE80211_SMPS_STATIC] = "static",
1646                 [IEEE80211_SMPS_DYNAMIC] = "dynamic",
1647         };
1648         int idx;
1649
1650         if (conf->chandef.chan)
1651                 wiphy_dbg(hw->wiphy,
1652                           "%s (freq=%d(%d - %d)/%s idle=%d ps=%d smps=%s)\n",
1653                           __func__,
1654                           conf->chandef.chan->center_freq,
1655                           conf->chandef.center_freq1,
1656                           conf->chandef.center_freq2,
1657                           hwsim_chanwidths[conf->chandef.width],
1658                           !!(conf->flags & IEEE80211_CONF_IDLE),
1659                           !!(conf->flags & IEEE80211_CONF_PS),
1660                           smps_modes[conf->smps_mode]);
1661         else
1662                 wiphy_dbg(hw->wiphy,
1663                           "%s (freq=0 idle=%d ps=%d smps=%s)\n",
1664                           __func__,
1665                           !!(conf->flags & IEEE80211_CONF_IDLE),
1666                           !!(conf->flags & IEEE80211_CONF_PS),
1667                           smps_modes[conf->smps_mode]);
1668
1669         data->idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1670
1671         WARN_ON(conf->chandef.chan && data->use_chanctx);
1672
1673         mutex_lock(&data->mutex);
1674         if (data->scanning && conf->chandef.chan) {
1675                 for (idx = 0; idx < ARRAY_SIZE(data->survey_data); idx++) {
1676                         if (data->survey_data[idx].channel == data->channel) {
1677                                 data->survey_data[idx].start =
1678                                         data->survey_data[idx].next_start;
1679                                 data->survey_data[idx].end = jiffies;
1680                                 break;
1681                         }
1682                 }
1683
1684                 data->channel = conf->chandef.chan;
1685
1686                 for (idx = 0; idx < ARRAY_SIZE(data->survey_data); idx++) {
1687                         if (data->survey_data[idx].channel &&
1688                             data->survey_data[idx].channel != data->channel)
1689                                 continue;
1690                         data->survey_data[idx].channel = data->channel;
1691                         data->survey_data[idx].next_start = jiffies;
1692                         break;
1693                 }
1694         } else {
1695                 data->channel = conf->chandef.chan;
1696         }
1697         mutex_unlock(&data->mutex);
1698
1699         if (!data->started || !data->beacon_int)
1700                 hrtimer_cancel(&data->beacon_timer);
1701         else if (!hrtimer_is_queued(&data->beacon_timer)) {
1702                 u64 tsf = mac80211_hwsim_get_tsf(hw, NULL);
1703                 u32 bcn_int = data->beacon_int;
1704                 u64 until_tbtt = bcn_int - do_div(tsf, bcn_int);
1705
1706                 hrtimer_start(&data->beacon_timer,
1707                               ns_to_ktime(until_tbtt * NSEC_PER_USEC),
1708                               HRTIMER_MODE_REL_SOFT);
1709         }
1710
1711         return 0;
1712 }
1713
1714
1715 static void mac80211_hwsim_configure_filter(struct ieee80211_hw *hw,
1716                                             unsigned int changed_flags,
1717                                             unsigned int *total_flags,u64 multicast)
1718 {
1719         struct mac80211_hwsim_data *data = hw->priv;
1720
1721         wiphy_dbg(hw->wiphy, "%s\n", __func__);
1722
1723         data->rx_filter = 0;
1724         if (*total_flags & FIF_ALLMULTI)
1725                 data->rx_filter |= FIF_ALLMULTI;
1726
1727         *total_flags = data->rx_filter;
1728 }
1729
1730 static void mac80211_hwsim_bcn_en_iter(void *data, u8 *mac,
1731                                        struct ieee80211_vif *vif)
1732 {
1733         unsigned int *count = data;
1734         struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
1735
1736         if (vp->bcn_en)
1737                 (*count)++;
1738 }
1739
1740 static void mac80211_hwsim_bss_info_changed(struct ieee80211_hw *hw,
1741                                             struct ieee80211_vif *vif,
1742                                             struct ieee80211_bss_conf *info,
1743                                             u32 changed)
1744 {
1745         struct hwsim_vif_priv *vp = (void *)vif->drv_priv;
1746         struct mac80211_hwsim_data *data = hw->priv;
1747
1748         hwsim_check_magic(vif);
1749
1750         wiphy_dbg(hw->wiphy, "%s(changed=0x%x vif->addr=%pM)\n",
1751                   __func__, changed, vif->addr);
1752
1753         if (changed & BSS_CHANGED_BSSID) {
1754                 wiphy_dbg(hw->wiphy, "%s: BSSID changed: %pM\n",
1755                           __func__, info->bssid);
1756                 memcpy(vp->bssid, info->bssid, ETH_ALEN);
1757         }
1758
1759         if (changed & BSS_CHANGED_ASSOC) {
1760                 wiphy_dbg(hw->wiphy, "  ASSOC: assoc=%d aid=%d\n",
1761                           info->assoc, info->aid);
1762                 vp->assoc = info->assoc;
1763                 vp->aid = info->aid;
1764         }
1765
1766         if (changed & BSS_CHANGED_BEACON_ENABLED) {
1767                 wiphy_dbg(hw->wiphy, "  BCN EN: %d (BI=%u)\n",
1768                           info->enable_beacon, info->beacon_int);
1769                 vp->bcn_en = info->enable_beacon;
1770                 if (data->started &&
1771                     !hrtimer_is_queued(&data->beacon_timer) &&
1772                     info->enable_beacon) {
1773                         u64 tsf, until_tbtt;
1774                         u32 bcn_int;
1775                         data->beacon_int = info->beacon_int * 1024;
1776                         tsf = mac80211_hwsim_get_tsf(hw, vif);
1777                         bcn_int = data->beacon_int;
1778                         until_tbtt = bcn_int - do_div(tsf, bcn_int);
1779
1780                         hrtimer_start(&data->beacon_timer,
1781                                       ns_to_ktime(until_tbtt * NSEC_PER_USEC),
1782                                       HRTIMER_MODE_REL_SOFT);
1783                 } else if (!info->enable_beacon) {
1784                         unsigned int count = 0;
1785                         ieee80211_iterate_active_interfaces_atomic(
1786                                 data->hw, IEEE80211_IFACE_ITER_NORMAL,
1787                                 mac80211_hwsim_bcn_en_iter, &count);
1788                         wiphy_dbg(hw->wiphy, "  beaconing vifs remaining: %u",
1789                                   count);
1790                         if (count == 0) {
1791                                 hrtimer_cancel(&data->beacon_timer);
1792                                 data->beacon_int = 0;
1793                         }
1794                 }
1795         }
1796
1797         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1798                 wiphy_dbg(hw->wiphy, "  ERP_CTS_PROT: %d\n",
1799                           info->use_cts_prot);
1800         }
1801
1802         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1803                 wiphy_dbg(hw->wiphy, "  ERP_PREAMBLE: %d\n",
1804                           info->use_short_preamble);
1805         }
1806
1807         if (changed & BSS_CHANGED_ERP_SLOT) {
1808                 wiphy_dbg(hw->wiphy, "  ERP_SLOT: %d\n", info->use_short_slot);
1809         }
1810
1811         if (changed & BSS_CHANGED_HT) {
1812                 wiphy_dbg(hw->wiphy, "  HT: op_mode=0x%x\n",
1813                           info->ht_operation_mode);
1814         }
1815
1816         if (changed & BSS_CHANGED_BASIC_RATES) {
1817                 wiphy_dbg(hw->wiphy, "  BASIC_RATES: 0x%llx\n",
1818                           (unsigned long long) info->basic_rates);
1819         }
1820
1821         if (changed & BSS_CHANGED_TXPOWER)
1822                 wiphy_dbg(hw->wiphy, "  TX Power: %d dBm\n", info->txpower);
1823 }
1824
1825 static int mac80211_hwsim_sta_add(struct ieee80211_hw *hw,
1826                                   struct ieee80211_vif *vif,
1827                                   struct ieee80211_sta *sta)
1828 {
1829         hwsim_check_magic(vif);
1830         hwsim_set_sta_magic(sta);
1831
1832         return 0;
1833 }
1834
1835 static int mac80211_hwsim_sta_remove(struct ieee80211_hw *hw,
1836                                      struct ieee80211_vif *vif,
1837                                      struct ieee80211_sta *sta)
1838 {
1839         hwsim_check_magic(vif);
1840         hwsim_clear_sta_magic(sta);
1841
1842         return 0;
1843 }
1844
1845 static void mac80211_hwsim_sta_notify(struct ieee80211_hw *hw,
1846                                       struct ieee80211_vif *vif,
1847                                       enum sta_notify_cmd cmd,
1848                                       struct ieee80211_sta *sta)
1849 {
1850         hwsim_check_magic(vif);
1851
1852         switch (cmd) {
1853         case STA_NOTIFY_SLEEP:
1854         case STA_NOTIFY_AWAKE:
1855                 /* TODO: make good use of these flags */
1856                 break;
1857         default:
1858                 WARN(1, "Invalid sta notify: %d\n", cmd);
1859                 break;
1860         }
1861 }
1862
1863 static int mac80211_hwsim_set_tim(struct ieee80211_hw *hw,
1864                                   struct ieee80211_sta *sta,
1865                                   bool set)
1866 {
1867         hwsim_check_sta_magic(sta);
1868         return 0;
1869 }
1870
1871 static int mac80211_hwsim_conf_tx(
1872         struct ieee80211_hw *hw,
1873         struct ieee80211_vif *vif, u16 queue,
1874         const struct ieee80211_tx_queue_params *params)
1875 {
1876         wiphy_dbg(hw->wiphy,
1877                   "%s (queue=%d txop=%d cw_min=%d cw_max=%d aifs=%d)\n",
1878                   __func__, queue,
1879                   params->txop, params->cw_min,
1880                   params->cw_max, params->aifs);
1881         return 0;
1882 }
1883
1884 static int mac80211_hwsim_get_survey(struct ieee80211_hw *hw, int idx,
1885                                      struct survey_info *survey)
1886 {
1887         struct mac80211_hwsim_data *hwsim = hw->priv;
1888
1889         if (idx < 0 || idx >= ARRAY_SIZE(hwsim->survey_data))
1890                 return -ENOENT;
1891
1892         mutex_lock(&hwsim->mutex);
1893         survey->channel = hwsim->survey_data[idx].channel;
1894         if (!survey->channel) {
1895                 mutex_unlock(&hwsim->mutex);
1896                 return -ENOENT;
1897         }
1898
1899         /*
1900          * Magically conjured dummy values --- this is only ok for simulated hardware.
1901          *
1902          * A real driver which cannot determine real values noise MUST NOT
1903          * report any, especially not a magically conjured ones :-)
1904          */
1905         survey->filled = SURVEY_INFO_NOISE_DBM |
1906                          SURVEY_INFO_TIME |
1907                          SURVEY_INFO_TIME_BUSY;
1908         survey->noise = -92;
1909         survey->time =
1910                 jiffies_to_msecs(hwsim->survey_data[idx].end -
1911                                  hwsim->survey_data[idx].start);
1912         /* report 12.5% of channel time is used */
1913         survey->time_busy = survey->time/8;
1914         mutex_unlock(&hwsim->mutex);
1915
1916         return 0;
1917 }
1918
1919 #ifdef CONFIG_NL80211_TESTMODE
1920 /*
1921  * This section contains example code for using netlink
1922  * attributes with the testmode command in nl80211.
1923  */
1924
1925 /* These enums need to be kept in sync with userspace */
1926 enum hwsim_testmode_attr {
1927         __HWSIM_TM_ATTR_INVALID = 0,
1928         HWSIM_TM_ATTR_CMD       = 1,
1929         HWSIM_TM_ATTR_PS        = 2,
1930
1931         /* keep last */
1932         __HWSIM_TM_ATTR_AFTER_LAST,
1933         HWSIM_TM_ATTR_MAX       = __HWSIM_TM_ATTR_AFTER_LAST - 1
1934 };
1935
1936 enum hwsim_testmode_cmd {
1937         HWSIM_TM_CMD_SET_PS             = 0,
1938         HWSIM_TM_CMD_GET_PS             = 1,
1939         HWSIM_TM_CMD_STOP_QUEUES        = 2,
1940         HWSIM_TM_CMD_WAKE_QUEUES        = 3,
1941 };
1942
1943 static const struct nla_policy hwsim_testmode_policy[HWSIM_TM_ATTR_MAX + 1] = {
1944         [HWSIM_TM_ATTR_CMD] = { .type = NLA_U32 },
1945         [HWSIM_TM_ATTR_PS] = { .type = NLA_U32 },
1946 };
1947
1948 static int mac80211_hwsim_testmode_cmd(struct ieee80211_hw *hw,
1949                                        struct ieee80211_vif *vif,
1950                                        void *data, int len)
1951 {
1952         struct mac80211_hwsim_data *hwsim = hw->priv;
1953         struct nlattr *tb[HWSIM_TM_ATTR_MAX + 1];
1954         struct sk_buff *skb;
1955         int err, ps;
1956
1957         err = nla_parse_deprecated(tb, HWSIM_TM_ATTR_MAX, data, len,
1958                                    hwsim_testmode_policy, NULL);
1959         if (err)
1960                 return err;
1961
1962         if (!tb[HWSIM_TM_ATTR_CMD])
1963                 return -EINVAL;
1964
1965         switch (nla_get_u32(tb[HWSIM_TM_ATTR_CMD])) {
1966         case HWSIM_TM_CMD_SET_PS:
1967                 if (!tb[HWSIM_TM_ATTR_PS])
1968                         return -EINVAL;
1969                 ps = nla_get_u32(tb[HWSIM_TM_ATTR_PS]);
1970                 return hwsim_fops_ps_write(hwsim, ps);
1971         case HWSIM_TM_CMD_GET_PS:
1972                 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
1973                                                 nla_total_size(sizeof(u32)));
1974                 if (!skb)
1975                         return -ENOMEM;
1976                 if (nla_put_u32(skb, HWSIM_TM_ATTR_PS, hwsim->ps))
1977                         goto nla_put_failure;
1978                 return cfg80211_testmode_reply(skb);
1979         case HWSIM_TM_CMD_STOP_QUEUES:
1980                 ieee80211_stop_queues(hw);
1981                 return 0;
1982         case HWSIM_TM_CMD_WAKE_QUEUES:
1983                 ieee80211_wake_queues(hw);
1984                 return 0;
1985         default:
1986                 return -EOPNOTSUPP;
1987         }
1988
1989  nla_put_failure:
1990         kfree_skb(skb);
1991         return -ENOBUFS;
1992 }
1993 #endif
1994
1995 static int mac80211_hwsim_ampdu_action(struct ieee80211_hw *hw,
1996                                        struct ieee80211_vif *vif,
1997                                        struct ieee80211_ampdu_params *params)
1998 {
1999         struct ieee80211_sta *sta = params->sta;
2000         enum ieee80211_ampdu_mlme_action action = params->action;
2001         u16 tid = params->tid;
2002
2003         switch (action) {
2004         case IEEE80211_AMPDU_TX_START:
2005                 return IEEE80211_AMPDU_TX_START_IMMEDIATE;
2006         case IEEE80211_AMPDU_TX_STOP_CONT:
2007         case IEEE80211_AMPDU_TX_STOP_FLUSH:
2008         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
2009                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
2010                 break;
2011         case IEEE80211_AMPDU_TX_OPERATIONAL:
2012                 break;
2013         case IEEE80211_AMPDU_RX_START:
2014         case IEEE80211_AMPDU_RX_STOP:
2015                 break;
2016         default:
2017                 return -EOPNOTSUPP;
2018         }
2019
2020         return 0;
2021 }
2022
2023 static void mac80211_hwsim_flush(struct ieee80211_hw *hw,
2024                                  struct ieee80211_vif *vif,
2025                                  u32 queues, bool drop)
2026 {
2027         /* Not implemented, queues only on kernel side */
2028 }
2029
2030 static void hw_scan_work(struct work_struct *work)
2031 {
2032         struct mac80211_hwsim_data *hwsim =
2033                 container_of(work, struct mac80211_hwsim_data, hw_scan.work);
2034         struct cfg80211_scan_request *req = hwsim->hw_scan_request;
2035         int dwell, i;
2036
2037         mutex_lock(&hwsim->mutex);
2038         if (hwsim->scan_chan_idx >= req->n_channels) {
2039                 struct cfg80211_scan_info info = {
2040                         .aborted = false,
2041                 };
2042
2043                 wiphy_dbg(hwsim->hw->wiphy, "hw scan complete\n");
2044                 ieee80211_scan_completed(hwsim->hw, &info);
2045                 hwsim->hw_scan_request = NULL;
2046                 hwsim->hw_scan_vif = NULL;
2047                 hwsim->tmp_chan = NULL;
2048                 mutex_unlock(&hwsim->mutex);
2049                 return;
2050         }
2051
2052         wiphy_dbg(hwsim->hw->wiphy, "hw scan %d MHz\n",
2053                   req->channels[hwsim->scan_chan_idx]->center_freq);
2054
2055         hwsim->tmp_chan = req->channels[hwsim->scan_chan_idx];
2056         if (hwsim->tmp_chan->flags & (IEEE80211_CHAN_NO_IR |
2057                                       IEEE80211_CHAN_RADAR) ||
2058             !req->n_ssids) {
2059                 dwell = 120;
2060         } else {
2061                 dwell = 30;
2062                 /* send probes */
2063                 for (i = 0; i < req->n_ssids; i++) {
2064                         struct sk_buff *probe;
2065                         struct ieee80211_mgmt *mgmt;
2066
2067                         probe = ieee80211_probereq_get(hwsim->hw,
2068                                                        hwsim->scan_addr,
2069                                                        req->ssids[i].ssid,
2070                                                        req->ssids[i].ssid_len,
2071                                                        req->ie_len);
2072                         if (!probe)
2073                                 continue;
2074
2075                         mgmt = (struct ieee80211_mgmt *) probe->data;
2076                         memcpy(mgmt->da, req->bssid, ETH_ALEN);
2077                         memcpy(mgmt->bssid, req->bssid, ETH_ALEN);
2078
2079                         if (req->ie_len)
2080                                 skb_put_data(probe, req->ie, req->ie_len);
2081
2082                         local_bh_disable();
2083                         mac80211_hwsim_tx_frame(hwsim->hw, probe,
2084                                                 hwsim->tmp_chan);
2085                         local_bh_enable();
2086                 }
2087         }
2088         ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan,
2089                                      msecs_to_jiffies(dwell));
2090         hwsim->survey_data[hwsim->scan_chan_idx].channel = hwsim->tmp_chan;
2091         hwsim->survey_data[hwsim->scan_chan_idx].start = jiffies;
2092         hwsim->survey_data[hwsim->scan_chan_idx].end =
2093                 jiffies + msecs_to_jiffies(dwell);
2094         hwsim->scan_chan_idx++;
2095         mutex_unlock(&hwsim->mutex);
2096 }
2097
2098 static int mac80211_hwsim_hw_scan(struct ieee80211_hw *hw,
2099                                   struct ieee80211_vif *vif,
2100                                   struct ieee80211_scan_request *hw_req)
2101 {
2102         struct mac80211_hwsim_data *hwsim = hw->priv;
2103         struct cfg80211_scan_request *req = &hw_req->req;
2104
2105         mutex_lock(&hwsim->mutex);
2106         if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) {
2107                 mutex_unlock(&hwsim->mutex);
2108                 return -EBUSY;
2109         }
2110         hwsim->hw_scan_request = req;
2111         hwsim->hw_scan_vif = vif;
2112         hwsim->scan_chan_idx = 0;
2113         if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR)
2114                 get_random_mask_addr(hwsim->scan_addr,
2115                                      hw_req->req.mac_addr,
2116                                      hw_req->req.mac_addr_mask);
2117         else
2118                 memcpy(hwsim->scan_addr, vif->addr, ETH_ALEN);
2119         memset(hwsim->survey_data, 0, sizeof(hwsim->survey_data));
2120         mutex_unlock(&hwsim->mutex);
2121
2122         wiphy_dbg(hw->wiphy, "hwsim hw_scan request\n");
2123
2124         ieee80211_queue_delayed_work(hwsim->hw, &hwsim->hw_scan, 0);
2125
2126         return 0;
2127 }
2128
2129 static void mac80211_hwsim_cancel_hw_scan(struct ieee80211_hw *hw,
2130                                           struct ieee80211_vif *vif)
2131 {
2132         struct mac80211_hwsim_data *hwsim = hw->priv;
2133         struct cfg80211_scan_info info = {
2134                 .aborted = true,
2135         };
2136
2137         wiphy_dbg(hw->wiphy, "hwsim cancel_hw_scan\n");
2138
2139         cancel_delayed_work_sync(&hwsim->hw_scan);
2140
2141         mutex_lock(&hwsim->mutex);
2142         ieee80211_scan_completed(hwsim->hw, &info);
2143         hwsim->tmp_chan = NULL;
2144         hwsim->hw_scan_request = NULL;
2145         hwsim->hw_scan_vif = NULL;
2146         mutex_unlock(&hwsim->mutex);
2147 }
2148
2149 static void mac80211_hwsim_sw_scan(struct ieee80211_hw *hw,
2150                                    struct ieee80211_vif *vif,
2151                                    const u8 *mac_addr)
2152 {
2153         struct mac80211_hwsim_data *hwsim = hw->priv;
2154
2155         mutex_lock(&hwsim->mutex);
2156
2157         if (hwsim->scanning) {
2158                 pr_debug("two hwsim sw_scans detected!\n");
2159                 goto out;
2160         }
2161
2162         pr_debug("hwsim sw_scan request, prepping stuff\n");
2163
2164         memcpy(hwsim->scan_addr, mac_addr, ETH_ALEN);
2165         hwsim->scanning = true;
2166         memset(hwsim->survey_data, 0, sizeof(hwsim->survey_data));
2167
2168 out:
2169         mutex_unlock(&hwsim->mutex);
2170 }
2171
2172 static void mac80211_hwsim_sw_scan_complete(struct ieee80211_hw *hw,
2173                                             struct ieee80211_vif *vif)
2174 {
2175         struct mac80211_hwsim_data *hwsim = hw->priv;
2176
2177         mutex_lock(&hwsim->mutex);
2178
2179         pr_debug("hwsim sw_scan_complete\n");
2180         hwsim->scanning = false;
2181         eth_zero_addr(hwsim->scan_addr);
2182
2183         mutex_unlock(&hwsim->mutex);
2184 }
2185
2186 static void hw_roc_start(struct work_struct *work)
2187 {
2188         struct mac80211_hwsim_data *hwsim =
2189                 container_of(work, struct mac80211_hwsim_data, roc_start.work);
2190
2191         mutex_lock(&hwsim->mutex);
2192
2193         wiphy_dbg(hwsim->hw->wiphy, "hwsim ROC begins\n");
2194         hwsim->tmp_chan = hwsim->roc_chan;
2195         ieee80211_ready_on_channel(hwsim->hw);
2196
2197         ieee80211_queue_delayed_work(hwsim->hw, &hwsim->roc_done,
2198                                      msecs_to_jiffies(hwsim->roc_duration));
2199
2200         mutex_unlock(&hwsim->mutex);
2201 }
2202
2203 static void hw_roc_done(struct work_struct *work)
2204 {
2205         struct mac80211_hwsim_data *hwsim =
2206                 container_of(work, struct mac80211_hwsim_data, roc_done.work);
2207
2208         mutex_lock(&hwsim->mutex);
2209         ieee80211_remain_on_channel_expired(hwsim->hw);
2210         hwsim->tmp_chan = NULL;
2211         mutex_unlock(&hwsim->mutex);
2212
2213         wiphy_dbg(hwsim->hw->wiphy, "hwsim ROC expired\n");
2214 }
2215
2216 static int mac80211_hwsim_roc(struct ieee80211_hw *hw,
2217                               struct ieee80211_vif *vif,
2218                               struct ieee80211_channel *chan,
2219                               int duration,
2220                               enum ieee80211_roc_type type)
2221 {
2222         struct mac80211_hwsim_data *hwsim = hw->priv;
2223
2224         mutex_lock(&hwsim->mutex);
2225         if (WARN_ON(hwsim->tmp_chan || hwsim->hw_scan_request)) {
2226                 mutex_unlock(&hwsim->mutex);
2227                 return -EBUSY;
2228         }
2229
2230         hwsim->roc_chan = chan;
2231         hwsim->roc_duration = duration;
2232         mutex_unlock(&hwsim->mutex);
2233
2234         wiphy_dbg(hw->wiphy, "hwsim ROC (%d MHz, %d ms)\n",
2235                   chan->center_freq, duration);
2236         ieee80211_queue_delayed_work(hw, &hwsim->roc_start, HZ/50);
2237
2238         return 0;
2239 }
2240
2241 static int mac80211_hwsim_croc(struct ieee80211_hw *hw,
2242                                struct ieee80211_vif *vif)
2243 {
2244         struct mac80211_hwsim_data *hwsim = hw->priv;
2245
2246         cancel_delayed_work_sync(&hwsim->roc_start);
2247         cancel_delayed_work_sync(&hwsim->roc_done);
2248
2249         mutex_lock(&hwsim->mutex);
2250         hwsim->tmp_chan = NULL;
2251         mutex_unlock(&hwsim->mutex);
2252
2253         wiphy_dbg(hw->wiphy, "hwsim ROC canceled\n");
2254
2255         return 0;
2256 }
2257
2258 static int mac80211_hwsim_add_chanctx(struct ieee80211_hw *hw,
2259                                       struct ieee80211_chanctx_conf *ctx)
2260 {
2261         hwsim_set_chanctx_magic(ctx);
2262         wiphy_dbg(hw->wiphy,
2263                   "add channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
2264                   ctx->def.chan->center_freq, ctx->def.width,
2265                   ctx->def.center_freq1, ctx->def.center_freq2);
2266         return 0;
2267 }
2268
2269 static void mac80211_hwsim_remove_chanctx(struct ieee80211_hw *hw,
2270                                           struct ieee80211_chanctx_conf *ctx)
2271 {
2272         wiphy_dbg(hw->wiphy,
2273                   "remove channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
2274                   ctx->def.chan->center_freq, ctx->def.width,
2275                   ctx->def.center_freq1, ctx->def.center_freq2);
2276         hwsim_check_chanctx_magic(ctx);
2277         hwsim_clear_chanctx_magic(ctx);
2278 }
2279
2280 static void mac80211_hwsim_change_chanctx(struct ieee80211_hw *hw,
2281                                           struct ieee80211_chanctx_conf *ctx,
2282                                           u32 changed)
2283 {
2284         hwsim_check_chanctx_magic(ctx);
2285         wiphy_dbg(hw->wiphy,
2286                   "change channel context control: %d MHz/width: %d/cfreqs:%d/%d MHz\n",
2287                   ctx->def.chan->center_freq, ctx->def.width,
2288                   ctx->def.center_freq1, ctx->def.center_freq2);
2289 }
2290
2291 static int mac80211_hwsim_assign_vif_chanctx(struct ieee80211_hw *hw,
2292                                              struct ieee80211_vif *vif,
2293                                              struct ieee80211_chanctx_conf *ctx)
2294 {
2295         hwsim_check_magic(vif);
2296         hwsim_check_chanctx_magic(ctx);
2297
2298         return 0;
2299 }
2300
2301 static void mac80211_hwsim_unassign_vif_chanctx(struct ieee80211_hw *hw,
2302                                                 struct ieee80211_vif *vif,
2303                                                 struct ieee80211_chanctx_conf *ctx)
2304 {
2305         hwsim_check_magic(vif);
2306         hwsim_check_chanctx_magic(ctx);
2307 }
2308
2309 static const char mac80211_hwsim_gstrings_stats[][ETH_GSTRING_LEN] = {
2310         "tx_pkts_nic",
2311         "tx_bytes_nic",
2312         "rx_pkts_nic",
2313         "rx_bytes_nic",
2314         "d_tx_dropped",
2315         "d_tx_failed",
2316         "d_ps_mode",
2317         "d_group",
2318 };
2319
2320 #define MAC80211_HWSIM_SSTATS_LEN ARRAY_SIZE(mac80211_hwsim_gstrings_stats)
2321
2322 static void mac80211_hwsim_get_et_strings(struct ieee80211_hw *hw,
2323                                           struct ieee80211_vif *vif,
2324                                           u32 sset, u8 *data)
2325 {
2326         if (sset == ETH_SS_STATS)
2327                 memcpy(data, *mac80211_hwsim_gstrings_stats,
2328                        sizeof(mac80211_hwsim_gstrings_stats));
2329 }
2330
2331 static int mac80211_hwsim_get_et_sset_count(struct ieee80211_hw *hw,
2332                                             struct ieee80211_vif *vif, int sset)
2333 {
2334         if (sset == ETH_SS_STATS)
2335                 return MAC80211_HWSIM_SSTATS_LEN;
2336         return 0;
2337 }
2338
2339 static void mac80211_hwsim_get_et_stats(struct ieee80211_hw *hw,
2340                                         struct ieee80211_vif *vif,
2341                                         struct ethtool_stats *stats, u64 *data)
2342 {
2343         struct mac80211_hwsim_data *ar = hw->priv;
2344         int i = 0;
2345
2346         data[i++] = ar->tx_pkts;
2347         data[i++] = ar->tx_bytes;
2348         data[i++] = ar->rx_pkts;
2349         data[i++] = ar->rx_bytes;
2350         data[i++] = ar->tx_dropped;
2351         data[i++] = ar->tx_failed;
2352         data[i++] = ar->ps;
2353         data[i++] = ar->group;
2354
2355         WARN_ON(i != MAC80211_HWSIM_SSTATS_LEN);
2356 }
2357
2358 #define HWSIM_COMMON_OPS                                        \
2359         .tx = mac80211_hwsim_tx,                                \
2360         .start = mac80211_hwsim_start,                          \
2361         .stop = mac80211_hwsim_stop,                            \
2362         .add_interface = mac80211_hwsim_add_interface,          \
2363         .change_interface = mac80211_hwsim_change_interface,    \
2364         .remove_interface = mac80211_hwsim_remove_interface,    \
2365         .config = mac80211_hwsim_config,                        \
2366         .configure_filter = mac80211_hwsim_configure_filter,    \
2367         .bss_info_changed = mac80211_hwsim_bss_info_changed,    \
2368         .sta_add = mac80211_hwsim_sta_add,                      \
2369         .sta_remove = mac80211_hwsim_sta_remove,                \
2370         .sta_notify = mac80211_hwsim_sta_notify,                \
2371         .set_tim = mac80211_hwsim_set_tim,                      \
2372         .conf_tx = mac80211_hwsim_conf_tx,                      \
2373         .get_survey = mac80211_hwsim_get_survey,                \
2374         CFG80211_TESTMODE_CMD(mac80211_hwsim_testmode_cmd)      \
2375         .ampdu_action = mac80211_hwsim_ampdu_action,            \
2376         .flush = mac80211_hwsim_flush,                          \
2377         .get_tsf = mac80211_hwsim_get_tsf,                      \
2378         .set_tsf = mac80211_hwsim_set_tsf,                      \
2379         .get_et_sset_count = mac80211_hwsim_get_et_sset_count,  \
2380         .get_et_stats = mac80211_hwsim_get_et_stats,            \
2381         .get_et_strings = mac80211_hwsim_get_et_strings,
2382
2383 static const struct ieee80211_ops mac80211_hwsim_ops = {
2384         HWSIM_COMMON_OPS
2385         .sw_scan_start = mac80211_hwsim_sw_scan,
2386         .sw_scan_complete = mac80211_hwsim_sw_scan_complete,
2387 };
2388
2389 static const struct ieee80211_ops mac80211_hwsim_mchan_ops = {
2390         HWSIM_COMMON_OPS
2391         .hw_scan = mac80211_hwsim_hw_scan,
2392         .cancel_hw_scan = mac80211_hwsim_cancel_hw_scan,
2393         .sw_scan_start = NULL,
2394         .sw_scan_complete = NULL,
2395         .remain_on_channel = mac80211_hwsim_roc,
2396         .cancel_remain_on_channel = mac80211_hwsim_croc,
2397         .add_chanctx = mac80211_hwsim_add_chanctx,
2398         .remove_chanctx = mac80211_hwsim_remove_chanctx,
2399         .change_chanctx = mac80211_hwsim_change_chanctx,
2400         .assign_vif_chanctx = mac80211_hwsim_assign_vif_chanctx,
2401         .unassign_vif_chanctx = mac80211_hwsim_unassign_vif_chanctx,
2402 };
2403
2404 struct hwsim_new_radio_params {
2405         unsigned int channels;
2406         const char *reg_alpha2;
2407         const struct ieee80211_regdomain *regd;
2408         bool reg_strict;
2409         bool p2p_device;
2410         bool use_chanctx;
2411         bool destroy_on_close;
2412         const char *hwname;
2413         bool no_vif;
2414         const u8 *perm_addr;
2415         u32 iftypes;
2416         u32 *ciphers;
2417         u8 n_ciphers;
2418 };
2419
2420 static void hwsim_mcast_config_msg(struct sk_buff *mcast_skb,
2421                                    struct genl_info *info)
2422 {
2423         if (info)
2424                 genl_notify(&hwsim_genl_family, mcast_skb, info,
2425                             HWSIM_MCGRP_CONFIG, GFP_KERNEL);
2426         else
2427                 genlmsg_multicast(&hwsim_genl_family, mcast_skb, 0,
2428                                   HWSIM_MCGRP_CONFIG, GFP_KERNEL);
2429 }
2430
2431 static int append_radio_msg(struct sk_buff *skb, int id,
2432                             struct hwsim_new_radio_params *param)
2433 {
2434         int ret;
2435
2436         ret = nla_put_u32(skb, HWSIM_ATTR_RADIO_ID, id);
2437         if (ret < 0)
2438                 return ret;
2439
2440         if (param->channels) {
2441                 ret = nla_put_u32(skb, HWSIM_ATTR_CHANNELS, param->channels);
2442                 if (ret < 0)
2443                         return ret;
2444         }
2445
2446         if (param->reg_alpha2) {
2447                 ret = nla_put(skb, HWSIM_ATTR_REG_HINT_ALPHA2, 2,
2448                               param->reg_alpha2);
2449                 if (ret < 0)
2450                         return ret;
2451         }
2452
2453         if (param->regd) {
2454                 int i;
2455
2456                 for (i = 0; i < ARRAY_SIZE(hwsim_world_regdom_custom); i++) {
2457                         if (hwsim_world_regdom_custom[i] != param->regd)
2458                                 continue;
2459
2460                         ret = nla_put_u32(skb, HWSIM_ATTR_REG_CUSTOM_REG, i);
2461                         if (ret < 0)
2462                                 return ret;
2463                         break;
2464                 }
2465         }
2466
2467         if (param->reg_strict) {
2468                 ret = nla_put_flag(skb, HWSIM_ATTR_REG_STRICT_REG);
2469                 if (ret < 0)
2470                         return ret;
2471         }
2472
2473         if (param->p2p_device) {
2474                 ret = nla_put_flag(skb, HWSIM_ATTR_SUPPORT_P2P_DEVICE);
2475                 if (ret < 0)
2476                         return ret;
2477         }
2478
2479         if (param->use_chanctx) {
2480                 ret = nla_put_flag(skb, HWSIM_ATTR_USE_CHANCTX);
2481                 if (ret < 0)
2482                         return ret;
2483         }
2484
2485         if (param->hwname) {
2486                 ret = nla_put(skb, HWSIM_ATTR_RADIO_NAME,
2487                               strlen(param->hwname), param->hwname);
2488                 if (ret < 0)
2489                         return ret;
2490         }
2491
2492         return 0;
2493 }
2494
2495 static void hwsim_mcast_new_radio(int id, struct genl_info *info,
2496                                   struct hwsim_new_radio_params *param)
2497 {
2498         struct sk_buff *mcast_skb;
2499         void *data;
2500
2501         mcast_skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2502         if (!mcast_skb)
2503                 return;
2504
2505         data = genlmsg_put(mcast_skb, 0, 0, &hwsim_genl_family, 0,
2506                            HWSIM_CMD_NEW_RADIO);
2507         if (!data)
2508                 goto out_err;
2509
2510         if (append_radio_msg(mcast_skb, id, param) < 0)
2511                 goto out_err;
2512
2513         genlmsg_end(mcast_skb, data);
2514
2515         hwsim_mcast_config_msg(mcast_skb, info);
2516         return;
2517
2518 out_err:
2519         nlmsg_free(mcast_skb);
2520 }
2521
2522 static const struct ieee80211_sband_iftype_data he_capa_2ghz[] = {
2523         {
2524                 /* TODO: should we support other types, e.g., P2P?*/
2525                 .types_mask = BIT(NL80211_IFTYPE_STATION) |
2526                               BIT(NL80211_IFTYPE_AP),
2527                 .he_cap = {
2528                         .has_he = true,
2529                         .he_cap_elem = {
2530                                 .mac_cap_info[0] =
2531                                         IEEE80211_HE_MAC_CAP0_HTC_HE,
2532                                 .mac_cap_info[1] =
2533                                         IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_16US |
2534                                         IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_8,
2535                                 .mac_cap_info[2] =
2536                                         IEEE80211_HE_MAC_CAP2_BSR |
2537                                         IEEE80211_HE_MAC_CAP2_MU_CASCADING |
2538                                         IEEE80211_HE_MAC_CAP2_ACK_EN,
2539                                 .mac_cap_info[3] =
2540                                         IEEE80211_HE_MAC_CAP3_OMI_CONTROL |
2541                                         IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_VHT_2,
2542                                 .mac_cap_info[4] = IEEE80211_HE_MAC_CAP4_AMDSU_IN_AMPDU,
2543                                 .phy_cap_info[1] =
2544                                         IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_MASK |
2545                                         IEEE80211_HE_PHY_CAP1_DEVICE_CLASS_A |
2546                                         IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD |
2547                                         IEEE80211_HE_PHY_CAP1_MIDAMBLE_RX_TX_MAX_NSTS,
2548                                 .phy_cap_info[2] =
2549                                         IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US |
2550                                         IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ |
2551                                         IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ |
2552                                         IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
2553                                         IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO,
2554
2555                                 /* Leave all the other PHY capability bytes
2556                                  * unset, as DCM, beam forming, RU and PPE
2557                                  * threshold information are not supported
2558                                  */
2559                         },
2560                         .he_mcs_nss_supp = {
2561                                 .rx_mcs_80 = cpu_to_le16(0xfffa),
2562                                 .tx_mcs_80 = cpu_to_le16(0xfffa),
2563                                 .rx_mcs_160 = cpu_to_le16(0xffff),
2564                                 .tx_mcs_160 = cpu_to_le16(0xffff),
2565                                 .rx_mcs_80p80 = cpu_to_le16(0xffff),
2566                                 .tx_mcs_80p80 = cpu_to_le16(0xffff),
2567                         },
2568                 },
2569         },
2570 #ifdef CONFIG_MAC80211_MESH
2571         {
2572                 /* TODO: should we support other types, e.g., IBSS?*/
2573                 .types_mask = BIT(NL80211_IFTYPE_MESH_POINT),
2574                 .he_cap = {
2575                         .has_he = true,
2576                         .he_cap_elem = {
2577                                 .mac_cap_info[0] =
2578                                         IEEE80211_HE_MAC_CAP0_HTC_HE,
2579                                 .mac_cap_info[1] =
2580                                         IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_8,
2581                                 .mac_cap_info[2] =
2582                                         IEEE80211_HE_MAC_CAP2_ACK_EN,
2583                                 .mac_cap_info[3] =
2584                                         IEEE80211_HE_MAC_CAP3_OMI_CONTROL |
2585                                         IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_VHT_2,
2586                                 .mac_cap_info[4] = IEEE80211_HE_MAC_CAP4_AMDSU_IN_AMPDU,
2587                                 .phy_cap_info[1] =
2588                                         IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_MASK |
2589                                         IEEE80211_HE_PHY_CAP1_DEVICE_CLASS_A |
2590                                         IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD |
2591                                         IEEE80211_HE_PHY_CAP1_MIDAMBLE_RX_TX_MAX_NSTS,
2592                                 .phy_cap_info[2] = 0,
2593
2594                                 /* Leave all the other PHY capability bytes
2595                                  * unset, as DCM, beam forming, RU and PPE
2596                                  * threshold information are not supported
2597                                  */
2598                         },
2599                         .he_mcs_nss_supp = {
2600                                 .rx_mcs_80 = cpu_to_le16(0xfffa),
2601                                 .tx_mcs_80 = cpu_to_le16(0xfffa),
2602                                 .rx_mcs_160 = cpu_to_le16(0xffff),
2603                                 .tx_mcs_160 = cpu_to_le16(0xffff),
2604                                 .rx_mcs_80p80 = cpu_to_le16(0xffff),
2605                                 .tx_mcs_80p80 = cpu_to_le16(0xffff),
2606                         },
2607                 },
2608         },
2609 #endif
2610 };
2611
2612 static const struct ieee80211_sband_iftype_data he_capa_5ghz[] = {
2613         {
2614                 /* TODO: should we support other types, e.g., P2P?*/
2615                 .types_mask = BIT(NL80211_IFTYPE_STATION) |
2616                               BIT(NL80211_IFTYPE_AP),
2617                 .he_cap = {
2618                         .has_he = true,
2619                         .he_cap_elem = {
2620                                 .mac_cap_info[0] =
2621                                         IEEE80211_HE_MAC_CAP0_HTC_HE,
2622                                 .mac_cap_info[1] =
2623                                         IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_16US |
2624                                         IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_8,
2625                                 .mac_cap_info[2] =
2626                                         IEEE80211_HE_MAC_CAP2_BSR |
2627                                         IEEE80211_HE_MAC_CAP2_MU_CASCADING |
2628                                         IEEE80211_HE_MAC_CAP2_ACK_EN,
2629                                 .mac_cap_info[3] =
2630                                         IEEE80211_HE_MAC_CAP3_OMI_CONTROL |
2631                                         IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_VHT_2,
2632                                 .mac_cap_info[4] = IEEE80211_HE_MAC_CAP4_AMDSU_IN_AMPDU,
2633                                 .phy_cap_info[0] =
2634                                         IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G |
2635                                         IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G |
2636                                         IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G,
2637                                 .phy_cap_info[1] =
2638                                         IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_MASK |
2639                                         IEEE80211_HE_PHY_CAP1_DEVICE_CLASS_A |
2640                                         IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD |
2641                                         IEEE80211_HE_PHY_CAP1_MIDAMBLE_RX_TX_MAX_NSTS,
2642                                 .phy_cap_info[2] =
2643                                         IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US |
2644                                         IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ |
2645                                         IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ |
2646                                         IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
2647                                         IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO,
2648
2649                                 /* Leave all the other PHY capability bytes
2650                                  * unset, as DCM, beam forming, RU and PPE
2651                                  * threshold information are not supported
2652                                  */
2653                         },
2654                         .he_mcs_nss_supp = {
2655                                 .rx_mcs_80 = cpu_to_le16(0xfffa),
2656                                 .tx_mcs_80 = cpu_to_le16(0xfffa),
2657                                 .rx_mcs_160 = cpu_to_le16(0xfffa),
2658                                 .tx_mcs_160 = cpu_to_le16(0xfffa),
2659                                 .rx_mcs_80p80 = cpu_to_le16(0xfffa),
2660                                 .tx_mcs_80p80 = cpu_to_le16(0xfffa),
2661                         },
2662                 },
2663         },
2664 #ifdef CONFIG_MAC80211_MESH
2665         {
2666                 /* TODO: should we support other types, e.g., IBSS?*/
2667                 .types_mask = BIT(NL80211_IFTYPE_MESH_POINT),
2668                 .he_cap = {
2669                         .has_he = true,
2670                         .he_cap_elem = {
2671                                 .mac_cap_info[0] =
2672                                         IEEE80211_HE_MAC_CAP0_HTC_HE,
2673                                 .mac_cap_info[1] =
2674                                         IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_8,
2675                                 .mac_cap_info[2] =
2676                                         IEEE80211_HE_MAC_CAP2_ACK_EN,
2677                                 .mac_cap_info[3] =
2678                                         IEEE80211_HE_MAC_CAP3_OMI_CONTROL |
2679                                         IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_VHT_2,
2680                                 .mac_cap_info[4] = IEEE80211_HE_MAC_CAP4_AMDSU_IN_AMPDU,
2681                                 .phy_cap_info[0] =
2682                                         IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G |
2683                                         IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G |
2684                                         IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G,
2685                                 .phy_cap_info[1] =
2686                                         IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_MASK |
2687                                         IEEE80211_HE_PHY_CAP1_DEVICE_CLASS_A |
2688                                         IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD |
2689                                         IEEE80211_HE_PHY_CAP1_MIDAMBLE_RX_TX_MAX_NSTS,
2690                                 .phy_cap_info[2] = 0,
2691
2692                                 /* Leave all the other PHY capability bytes
2693                                  * unset, as DCM, beam forming, RU and PPE
2694                                  * threshold information are not supported
2695                                  */
2696                         },
2697                         .he_mcs_nss_supp = {
2698                                 .rx_mcs_80 = cpu_to_le16(0xfffa),
2699                                 .tx_mcs_80 = cpu_to_le16(0xfffa),
2700                                 .rx_mcs_160 = cpu_to_le16(0xfffa),
2701                                 .tx_mcs_160 = cpu_to_le16(0xfffa),
2702                                 .rx_mcs_80p80 = cpu_to_le16(0xfffa),
2703                                 .tx_mcs_80p80 = cpu_to_le16(0xfffa),
2704                         },
2705                 },
2706         },
2707 #endif
2708 };
2709
2710 static void mac80211_hwsim_he_capab(struct ieee80211_supported_band *sband)
2711 {
2712         u16 n_iftype_data;
2713
2714         if (sband->band == NL80211_BAND_2GHZ) {
2715                 n_iftype_data = ARRAY_SIZE(he_capa_2ghz);
2716                 sband->iftype_data =
2717                         (struct ieee80211_sband_iftype_data *)he_capa_2ghz;
2718         } else if (sband->band == NL80211_BAND_5GHZ) {
2719                 n_iftype_data = ARRAY_SIZE(he_capa_5ghz);
2720                 sband->iftype_data =
2721                         (struct ieee80211_sband_iftype_data *)he_capa_5ghz;
2722         } else {
2723                 return;
2724         }
2725
2726         sband->n_iftype_data = n_iftype_data;
2727 }
2728
2729 #ifdef CONFIG_MAC80211_MESH
2730 #define HWSIM_MESH_BIT BIT(NL80211_IFTYPE_MESH_POINT)
2731 #else
2732 #define HWSIM_MESH_BIT 0
2733 #endif
2734
2735 #define HWSIM_DEFAULT_IF_LIMIT \
2736         (BIT(NL80211_IFTYPE_STATION) | \
2737          BIT(NL80211_IFTYPE_P2P_CLIENT) | \
2738          BIT(NL80211_IFTYPE_AP) | \
2739          BIT(NL80211_IFTYPE_P2P_GO) | \
2740          HWSIM_MESH_BIT)
2741
2742 #define HWSIM_IFTYPE_SUPPORT_MASK \
2743         (BIT(NL80211_IFTYPE_STATION) | \
2744          BIT(NL80211_IFTYPE_AP) | \
2745          BIT(NL80211_IFTYPE_P2P_CLIENT) | \
2746          BIT(NL80211_IFTYPE_P2P_GO) | \
2747          BIT(NL80211_IFTYPE_ADHOC) | \
2748          BIT(NL80211_IFTYPE_MESH_POINT) | \
2749          BIT(NL80211_IFTYPE_OCB))
2750
2751 static int mac80211_hwsim_new_radio(struct genl_info *info,
2752                                     struct hwsim_new_radio_params *param)
2753 {
2754         int err;
2755         u8 addr[ETH_ALEN];
2756         struct mac80211_hwsim_data *data;
2757         struct ieee80211_hw *hw;
2758         enum nl80211_band band;
2759         const struct ieee80211_ops *ops = &mac80211_hwsim_ops;
2760         struct net *net;
2761         int idx, i;
2762         int n_limits = 0;
2763
2764         if (WARN_ON(param->channels > 1 && !param->use_chanctx))
2765                 return -EINVAL;
2766
2767         spin_lock_bh(&hwsim_radio_lock);
2768         idx = hwsim_radio_idx++;
2769         spin_unlock_bh(&hwsim_radio_lock);
2770
2771         if (param->use_chanctx)
2772                 ops = &mac80211_hwsim_mchan_ops;
2773         hw = ieee80211_alloc_hw_nm(sizeof(*data), ops, param->hwname);
2774         if (!hw) {
2775                 pr_debug("mac80211_hwsim: ieee80211_alloc_hw failed\n");
2776                 err = -ENOMEM;
2777                 goto failed;
2778         }
2779
2780         /* ieee80211_alloc_hw_nm may have used a default name */
2781         param->hwname = wiphy_name(hw->wiphy);
2782
2783         if (info)
2784                 net = genl_info_net(info);
2785         else
2786                 net = &init_net;
2787         wiphy_net_set(hw->wiphy, net);
2788
2789         data = hw->priv;
2790         data->hw = hw;
2791
2792         data->dev = device_create(hwsim_class, NULL, 0, hw, "hwsim%d", idx);
2793         if (IS_ERR(data->dev)) {
2794                 printk(KERN_DEBUG
2795                        "mac80211_hwsim: device_create failed (%ld)\n",
2796                        PTR_ERR(data->dev));
2797                 err = -ENOMEM;
2798                 goto failed_drvdata;
2799         }
2800         data->dev->driver = &mac80211_hwsim_driver.driver;
2801         err = device_bind_driver(data->dev);
2802         if (err != 0) {
2803                 pr_debug("mac80211_hwsim: device_bind_driver failed (%d)\n",
2804                        err);
2805                 goto failed_bind;
2806         }
2807
2808         skb_queue_head_init(&data->pending);
2809
2810         SET_IEEE80211_DEV(hw, data->dev);
2811         if (!param->perm_addr) {
2812                 eth_zero_addr(addr);
2813                 addr[0] = 0x02;
2814                 addr[3] = idx >> 8;
2815                 addr[4] = idx;
2816                 memcpy(data->addresses[0].addr, addr, ETH_ALEN);
2817                 /* Why need here second address ? */
2818                 memcpy(data->addresses[1].addr, addr, ETH_ALEN);
2819                 data->addresses[1].addr[0] |= 0x40;
2820                 hw->wiphy->n_addresses = 2;
2821                 hw->wiphy->addresses = data->addresses;
2822                 /* possible address clash is checked at hash table insertion */
2823         } else {
2824                 memcpy(data->addresses[0].addr, param->perm_addr, ETH_ALEN);
2825                 /* compatibility with automatically generated mac addr */
2826                 memcpy(data->addresses[1].addr, param->perm_addr, ETH_ALEN);
2827                 hw->wiphy->n_addresses = 2;
2828                 hw->wiphy->addresses = data->addresses;
2829         }
2830
2831         data->channels = param->channels;
2832         data->use_chanctx = param->use_chanctx;
2833         data->idx = idx;
2834         data->destroy_on_close = param->destroy_on_close;
2835         if (info)
2836                 data->portid = info->snd_portid;
2837
2838         /* setup interface limits, only on interface types we support */
2839         if (param->iftypes & BIT(NL80211_IFTYPE_ADHOC)) {
2840                 data->if_limits[n_limits].max = 1;
2841                 data->if_limits[n_limits].types = BIT(NL80211_IFTYPE_ADHOC);
2842                 n_limits++;
2843         }
2844
2845         if (param->iftypes & HWSIM_DEFAULT_IF_LIMIT) {
2846                 data->if_limits[n_limits].max = 2048;
2847                 /*
2848                  * For this case, we may only support a subset of
2849                  * HWSIM_DEFAULT_IF_LIMIT, therefore we only want to add the
2850                  * bits that both param->iftype & HWSIM_DEFAULT_IF_LIMIT have.
2851                  */
2852                 data->if_limits[n_limits].types =
2853                                         HWSIM_DEFAULT_IF_LIMIT & param->iftypes;
2854                 n_limits++;
2855         }
2856
2857         if (param->iftypes & BIT(NL80211_IFTYPE_P2P_DEVICE)) {
2858                 data->if_limits[n_limits].max = 1;
2859                 data->if_limits[n_limits].types =
2860                                                 BIT(NL80211_IFTYPE_P2P_DEVICE);
2861                 n_limits++;
2862         }
2863
2864         if (data->use_chanctx) {
2865                 hw->wiphy->max_scan_ssids = 255;
2866                 hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
2867                 hw->wiphy->max_remain_on_channel_duration = 1000;
2868                 data->if_combination.radar_detect_widths = 0;
2869                 data->if_combination.num_different_channels = data->channels;
2870         } else {
2871                 data->if_combination.num_different_channels = 1;
2872                 data->if_combination.radar_detect_widths =
2873                                         BIT(NL80211_CHAN_WIDTH_5) |
2874                                         BIT(NL80211_CHAN_WIDTH_10) |
2875                                         BIT(NL80211_CHAN_WIDTH_20_NOHT) |
2876                                         BIT(NL80211_CHAN_WIDTH_20) |
2877                                         BIT(NL80211_CHAN_WIDTH_40) |
2878                                         BIT(NL80211_CHAN_WIDTH_80) |
2879                                         BIT(NL80211_CHAN_WIDTH_160);
2880         }
2881
2882         if (!n_limits) {
2883                 err = -EINVAL;
2884                 goto failed_hw;
2885         }
2886
2887         data->if_combination.max_interfaces = 0;
2888         for (i = 0; i < n_limits; i++)
2889                 data->if_combination.max_interfaces +=
2890                         data->if_limits[i].max;
2891
2892         data->if_combination.n_limits = n_limits;
2893         data->if_combination.limits = data->if_limits;
2894
2895         /*
2896          * If we actually were asked to support combinations,
2897          * advertise them - if there's only a single thing like
2898          * only IBSS then don't advertise it as combinations.
2899          */
2900         if (data->if_combination.max_interfaces > 1) {
2901                 hw->wiphy->iface_combinations = &data->if_combination;
2902                 hw->wiphy->n_iface_combinations = 1;
2903         }
2904
2905         if (param->ciphers) {
2906                 memcpy(data->ciphers, param->ciphers,
2907                        param->n_ciphers * sizeof(u32));
2908                 hw->wiphy->cipher_suites = data->ciphers;
2909                 hw->wiphy->n_cipher_suites = param->n_ciphers;
2910         }
2911
2912         INIT_DELAYED_WORK(&data->roc_start, hw_roc_start);
2913         INIT_DELAYED_WORK(&data->roc_done, hw_roc_done);
2914         INIT_DELAYED_WORK(&data->hw_scan, hw_scan_work);
2915
2916         hw->queues = 5;
2917         hw->offchannel_tx_hw_queue = 4;
2918
2919         ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
2920         ieee80211_hw_set(hw, CHANCTX_STA_CSA);
2921         ieee80211_hw_set(hw, SUPPORTS_HT_CCK_RATES);
2922         ieee80211_hw_set(hw, QUEUE_CONTROL);
2923         ieee80211_hw_set(hw, WANT_MONITOR_VIF);
2924         ieee80211_hw_set(hw, AMPDU_AGGREGATION);
2925         ieee80211_hw_set(hw, MFP_CAPABLE);
2926         ieee80211_hw_set(hw, SIGNAL_DBM);
2927         ieee80211_hw_set(hw, SUPPORTS_PS);
2928         ieee80211_hw_set(hw, TDLS_WIDER_BW);
2929         if (rctbl)
2930                 ieee80211_hw_set(hw, SUPPORTS_RC_TABLE);
2931         ieee80211_hw_set(hw, SUPPORTS_MULTI_BSSID);
2932
2933         hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |
2934                             WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
2935                             WIPHY_FLAG_AP_UAPSD |
2936                             WIPHY_FLAG_HAS_CHANNEL_SWITCH;
2937         hw->wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR |
2938                                NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
2939                                NL80211_FEATURE_STATIC_SMPS |
2940                                NL80211_FEATURE_DYNAMIC_SMPS |
2941                                NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
2942         wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
2943
2944         hw->wiphy->interface_modes = param->iftypes;
2945
2946         /* ask mac80211 to reserve space for magic */
2947         hw->vif_data_size = sizeof(struct hwsim_vif_priv);
2948         hw->sta_data_size = sizeof(struct hwsim_sta_priv);
2949         hw->chanctx_data_size = sizeof(struct hwsim_chanctx_priv);
2950
2951         memcpy(data->channels_2ghz, hwsim_channels_2ghz,
2952                 sizeof(hwsim_channels_2ghz));
2953         memcpy(data->channels_5ghz, hwsim_channels_5ghz,
2954                 sizeof(hwsim_channels_5ghz));
2955         memcpy(data->rates, hwsim_rates, sizeof(hwsim_rates));
2956
2957         for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
2958                 struct ieee80211_supported_band *sband = &data->bands[band];
2959
2960                 sband->band = band;
2961
2962                 switch (band) {
2963                 case NL80211_BAND_2GHZ:
2964                         sband->channels = data->channels_2ghz;
2965                         sband->n_channels = ARRAY_SIZE(hwsim_channels_2ghz);
2966                         sband->bitrates = data->rates;
2967                         sband->n_bitrates = ARRAY_SIZE(hwsim_rates);
2968                         break;
2969                 case NL80211_BAND_5GHZ:
2970                         sband->channels = data->channels_5ghz;
2971                         sband->n_channels = ARRAY_SIZE(hwsim_channels_5ghz);
2972                         sband->bitrates = data->rates + 4;
2973                         sband->n_bitrates = ARRAY_SIZE(hwsim_rates) - 4;
2974
2975                         sband->vht_cap.vht_supported = true;
2976                         sband->vht_cap.cap =
2977                                 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
2978                                 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ |
2979                                 IEEE80211_VHT_CAP_RXLDPC |
2980                                 IEEE80211_VHT_CAP_SHORT_GI_80 |
2981                                 IEEE80211_VHT_CAP_SHORT_GI_160 |
2982                                 IEEE80211_VHT_CAP_TXSTBC |
2983                                 IEEE80211_VHT_CAP_RXSTBC_4 |
2984                                 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK;
2985                         sband->vht_cap.vht_mcs.rx_mcs_map =
2986                                 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
2987                                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
2988                                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 4 |
2989                                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 6 |
2990                                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 8 |
2991                                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 10 |
2992                                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 12 |
2993                                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 14);
2994                         sband->vht_cap.vht_mcs.tx_mcs_map =
2995                                 sband->vht_cap.vht_mcs.rx_mcs_map;
2996                         break;
2997                 default:
2998                         continue;
2999                 }
3000
3001                 sband->ht_cap.ht_supported = true;
3002                 sband->ht_cap.cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
3003                                     IEEE80211_HT_CAP_GRN_FLD |
3004                                     IEEE80211_HT_CAP_SGI_20 |
3005                                     IEEE80211_HT_CAP_SGI_40 |
3006                                     IEEE80211_HT_CAP_DSSSCCK40;
3007                 sband->ht_cap.ampdu_factor = 0x3;
3008                 sband->ht_cap.ampdu_density = 0x6;
3009                 memset(&sband->ht_cap.mcs, 0,
3010                        sizeof(sband->ht_cap.mcs));
3011                 sband->ht_cap.mcs.rx_mask[0] = 0xff;
3012                 sband->ht_cap.mcs.rx_mask[1] = 0xff;
3013                 sband->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
3014
3015                 mac80211_hwsim_he_capab(sband);
3016
3017                 hw->wiphy->bands[band] = sband;
3018         }
3019
3020         /* By default all radios belong to the first group */
3021         data->group = 1;
3022         mutex_init(&data->mutex);
3023
3024         data->netgroup = hwsim_net_get_netgroup(net);
3025         data->wmediumd = hwsim_net_get_wmediumd(net);
3026
3027         /* Enable frame retransmissions for lossy channels */
3028         hw->max_rates = 4;
3029         hw->max_rate_tries = 11;
3030
3031         hw->wiphy->vendor_commands = mac80211_hwsim_vendor_commands;
3032         hw->wiphy->n_vendor_commands =
3033                 ARRAY_SIZE(mac80211_hwsim_vendor_commands);
3034         hw->wiphy->vendor_events = mac80211_hwsim_vendor_events;
3035         hw->wiphy->n_vendor_events = ARRAY_SIZE(mac80211_hwsim_vendor_events);
3036
3037         if (param->reg_strict)
3038                 hw->wiphy->regulatory_flags |= REGULATORY_STRICT_REG;
3039         if (param->regd) {
3040                 data->regd = param->regd;
3041                 hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
3042                 wiphy_apply_custom_regulatory(hw->wiphy, param->regd);
3043                 /* give the regulatory workqueue a chance to run */
3044                 schedule_timeout_interruptible(1);
3045         }
3046
3047         if (param->no_vif)
3048                 ieee80211_hw_set(hw, NO_AUTO_VIF);
3049
3050         wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
3051
3052         hrtimer_init(&data->beacon_timer, CLOCK_MONOTONIC,
3053                      HRTIMER_MODE_ABS_SOFT);
3054         data->beacon_timer.function = mac80211_hwsim_beacon;
3055
3056         err = ieee80211_register_hw(hw);
3057         if (err < 0) {
3058                 pr_debug("mac80211_hwsim: ieee80211_register_hw failed (%d)\n",
3059                        err);
3060                 goto failed_hw;
3061         }
3062
3063         wiphy_dbg(hw->wiphy, "hwaddr %pM registered\n", hw->wiphy->perm_addr);
3064
3065         if (param->reg_alpha2) {
3066                 data->alpha2[0] = param->reg_alpha2[0];
3067                 data->alpha2[1] = param->reg_alpha2[1];
3068                 regulatory_hint(hw->wiphy, param->reg_alpha2);
3069         }
3070
3071         data->debugfs = debugfs_create_dir("hwsim", hw->wiphy->debugfsdir);
3072         debugfs_create_file("ps", 0666, data->debugfs, data, &hwsim_fops_ps);
3073         debugfs_create_file("group", 0666, data->debugfs, data,
3074                             &hwsim_fops_group);
3075         if (!data->use_chanctx)
3076                 debugfs_create_file("dfs_simulate_radar", 0222,
3077                                     data->debugfs,
3078                                     data, &hwsim_simulate_radar);
3079
3080         spin_lock_bh(&hwsim_radio_lock);
3081         err = rhashtable_insert_fast(&hwsim_radios_rht, &data->rht,
3082                                      hwsim_rht_params);
3083         if (err < 0) {
3084                 if (info) {
3085                         GENL_SET_ERR_MSG(info, "perm addr already present");
3086                         NL_SET_BAD_ATTR(info->extack,
3087                                         info->attrs[HWSIM_ATTR_PERM_ADDR]);
3088                 }
3089                 spin_unlock_bh(&hwsim_radio_lock);
3090                 goto failed_final_insert;
3091         }
3092
3093         list_add_tail(&data->list, &hwsim_radios);
3094         hwsim_radios_generation++;
3095         spin_unlock_bh(&hwsim_radio_lock);
3096
3097         hwsim_mcast_new_radio(idx, info, param);
3098
3099         return idx;
3100
3101 failed_final_insert:
3102         debugfs_remove_recursive(data->debugfs);
3103         ieee80211_unregister_hw(data->hw);
3104 failed_hw:
3105         device_release_driver(data->dev);
3106 failed_bind:
3107         device_unregister(data->dev);
3108 failed_drvdata:
3109         ieee80211_free_hw(hw);
3110 failed:
3111         return err;
3112 }
3113
3114 static void hwsim_mcast_del_radio(int id, const char *hwname,
3115                                   struct genl_info *info)
3116 {
3117         struct sk_buff *skb;
3118         void *data;
3119         int ret;
3120
3121         skb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
3122         if (!skb)
3123                 return;
3124
3125         data = genlmsg_put(skb, 0, 0, &hwsim_genl_family, 0,
3126                            HWSIM_CMD_DEL_RADIO);
3127         if (!data)
3128                 goto error;
3129
3130         ret = nla_put_u32(skb, HWSIM_ATTR_RADIO_ID, id);
3131         if (ret < 0)
3132                 goto error;
3133
3134         ret = nla_put(skb, HWSIM_ATTR_RADIO_NAME, strlen(hwname),
3135                       hwname);
3136         if (ret < 0)
3137                 goto error;
3138
3139         genlmsg_end(skb, data);
3140
3141         hwsim_mcast_config_msg(skb, info);
3142
3143         return;
3144
3145 error:
3146         nlmsg_free(skb);
3147 }
3148
3149 static void mac80211_hwsim_del_radio(struct mac80211_hwsim_data *data,
3150                                      const char *hwname,
3151                                      struct genl_info *info)
3152 {
3153         hwsim_mcast_del_radio(data->idx, hwname, info);
3154         debugfs_remove_recursive(data->debugfs);
3155         ieee80211_unregister_hw(data->hw);
3156         device_release_driver(data->dev);
3157         device_unregister(data->dev);
3158         ieee80211_free_hw(data->hw);
3159 }
3160
3161 static int mac80211_hwsim_get_radio(struct sk_buff *skb,
3162                                     struct mac80211_hwsim_data *data,
3163                                     u32 portid, u32 seq,
3164                                     struct netlink_callback *cb, int flags)
3165 {
3166         void *hdr;
3167         struct hwsim_new_radio_params param = { };
3168         int res = -EMSGSIZE;
3169
3170         hdr = genlmsg_put(skb, portid, seq, &hwsim_genl_family, flags,
3171                           HWSIM_CMD_GET_RADIO);
3172         if (!hdr)
3173                 return -EMSGSIZE;
3174
3175         if (cb)
3176                 genl_dump_check_consistent(cb, hdr);
3177
3178         if (data->alpha2[0] && data->alpha2[1])
3179                 param.reg_alpha2 = data->alpha2;
3180
3181         param.reg_strict = !!(data->hw->wiphy->regulatory_flags &
3182                                         REGULATORY_STRICT_REG);
3183         param.p2p_device = !!(data->hw->wiphy->interface_modes &
3184                                         BIT(NL80211_IFTYPE_P2P_DEVICE));
3185         param.use_chanctx = data->use_chanctx;
3186         param.regd = data->regd;
3187         param.channels = data->channels;
3188         param.hwname = wiphy_name(data->hw->wiphy);
3189
3190         res = append_radio_msg(skb, data->idx, &param);
3191         if (res < 0)
3192                 goto out_err;
3193
3194         genlmsg_end(skb, hdr);
3195         return 0;
3196
3197 out_err:
3198         genlmsg_cancel(skb, hdr);
3199         return res;
3200 }
3201
3202 static void mac80211_hwsim_free(void)
3203 {
3204         struct mac80211_hwsim_data *data;
3205
3206         spin_lock_bh(&hwsim_radio_lock);
3207         while ((data = list_first_entry_or_null(&hwsim_radios,
3208                                                 struct mac80211_hwsim_data,
3209                                                 list))) {
3210                 list_del(&data->list);
3211                 spin_unlock_bh(&hwsim_radio_lock);
3212                 mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy),
3213                                          NULL);
3214                 spin_lock_bh(&hwsim_radio_lock);
3215         }
3216         spin_unlock_bh(&hwsim_radio_lock);
3217         class_destroy(hwsim_class);
3218 }
3219
3220 static const struct net_device_ops hwsim_netdev_ops = {
3221         .ndo_start_xmit         = hwsim_mon_xmit,
3222         .ndo_set_mac_address    = eth_mac_addr,
3223         .ndo_validate_addr      = eth_validate_addr,
3224 };
3225
3226 static void hwsim_mon_setup(struct net_device *dev)
3227 {
3228         dev->netdev_ops = &hwsim_netdev_ops;
3229         dev->needs_free_netdev = true;
3230         ether_setup(dev);
3231         dev->priv_flags |= IFF_NO_QUEUE;
3232         dev->type = ARPHRD_IEEE80211_RADIOTAP;
3233         eth_zero_addr(dev->dev_addr);
3234         dev->dev_addr[0] = 0x12;
3235 }
3236
3237 static struct mac80211_hwsim_data *get_hwsim_data_ref_from_addr(const u8 *addr)
3238 {
3239         return rhashtable_lookup_fast(&hwsim_radios_rht,
3240                                       addr,
3241                                       hwsim_rht_params);
3242 }
3243
3244 static void hwsim_register_wmediumd(struct net *net, u32 portid)
3245 {
3246         struct mac80211_hwsim_data *data;
3247
3248         hwsim_net_set_wmediumd(net, portid);
3249
3250         spin_lock_bh(&hwsim_radio_lock);
3251         list_for_each_entry(data, &hwsim_radios, list) {
3252                 if (data->netgroup == hwsim_net_get_netgroup(net))
3253                         data->wmediumd = portid;
3254         }
3255         spin_unlock_bh(&hwsim_radio_lock);
3256 }
3257
3258 static int hwsim_tx_info_frame_received_nl(struct sk_buff *skb_2,
3259                                            struct genl_info *info)
3260 {
3261
3262         struct ieee80211_hdr *hdr;
3263         struct mac80211_hwsim_data *data2;
3264         struct ieee80211_tx_info *txi;
3265         struct hwsim_tx_rate *tx_attempts;
3266         u64 ret_skb_cookie;
3267         struct sk_buff *skb, *tmp;
3268         const u8 *src;
3269         unsigned int hwsim_flags;
3270         int i;
3271         bool found = false;
3272
3273         if (!info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER] ||
3274             !info->attrs[HWSIM_ATTR_FLAGS] ||
3275             !info->attrs[HWSIM_ATTR_COOKIE] ||
3276             !info->attrs[HWSIM_ATTR_SIGNAL] ||
3277             !info->attrs[HWSIM_ATTR_TX_INFO])
3278                 goto out;
3279
3280         src = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_TRANSMITTER]);
3281         hwsim_flags = nla_get_u32(info->attrs[HWSIM_ATTR_FLAGS]);
3282         ret_skb_cookie = nla_get_u64(info->attrs[HWSIM_ATTR_COOKIE]);
3283
3284         data2 = get_hwsim_data_ref_from_addr(src);
3285         if (!data2)
3286                 goto out;
3287
3288         if (hwsim_net_get_netgroup(genl_info_net(info)) != data2->netgroup)
3289                 goto out;
3290
3291         if (info->snd_portid != data2->wmediumd)
3292                 goto out;
3293
3294         /* look for the skb matching the cookie passed back from user */
3295         skb_queue_walk_safe(&data2->pending, skb, tmp) {
3296                 u64 skb_cookie;
3297
3298                 txi = IEEE80211_SKB_CB(skb);
3299                 skb_cookie = (u64)(uintptr_t)txi->rate_driver_data[0];
3300
3301                 if (skb_cookie == ret_skb_cookie) {
3302                         skb_unlink(skb, &data2->pending);
3303                         found = true;
3304                         break;
3305                 }
3306         }
3307
3308         /* not found */
3309         if (!found)
3310                 goto out;
3311
3312         /* Tx info received because the frame was broadcasted on user space,
3313          so we get all the necessary info: tx attempts and skb control buff */
3314
3315         tx_attempts = (struct hwsim_tx_rate *)nla_data(
3316                        info->attrs[HWSIM_ATTR_TX_INFO]);
3317
3318         /* now send back TX status */
3319         txi = IEEE80211_SKB_CB(skb);
3320
3321         ieee80211_tx_info_clear_status(txi);
3322
3323         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
3324                 txi->status.rates[i].idx = tx_attempts[i].idx;
3325                 txi->status.rates[i].count = tx_attempts[i].count;
3326         }
3327
3328         txi->status.ack_signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);
3329
3330         if (!(hwsim_flags & HWSIM_TX_CTL_NO_ACK) &&
3331            (hwsim_flags & HWSIM_TX_STAT_ACK)) {
3332                 if (skb->len >= 16) {
3333                         hdr = (struct ieee80211_hdr *) skb->data;
3334                         mac80211_hwsim_monitor_ack(data2->channel,
3335                                                    hdr->addr2);
3336                 }
3337                 txi->flags |= IEEE80211_TX_STAT_ACK;
3338         }
3339         ieee80211_tx_status_irqsafe(data2->hw, skb);
3340         return 0;
3341 out:
3342         return -EINVAL;
3343
3344 }
3345
3346 static int hwsim_cloned_frame_received_nl(struct sk_buff *skb_2,
3347                                           struct genl_info *info)
3348 {
3349         struct mac80211_hwsim_data *data2;
3350         struct ieee80211_rx_status rx_status;
3351         struct ieee80211_hdr *hdr;
3352         const u8 *dst;
3353         int frame_data_len;
3354         void *frame_data;
3355         struct sk_buff *skb = NULL;
3356
3357         if (!info->attrs[HWSIM_ATTR_ADDR_RECEIVER] ||
3358             !info->attrs[HWSIM_ATTR_FRAME] ||
3359             !info->attrs[HWSIM_ATTR_RX_RATE] ||
3360             !info->attrs[HWSIM_ATTR_SIGNAL])
3361                 goto out;
3362
3363         dst = (void *)nla_data(info->attrs[HWSIM_ATTR_ADDR_RECEIVER]);
3364         frame_data_len = nla_len(info->attrs[HWSIM_ATTR_FRAME]);
3365         frame_data = (void *)nla_data(info->attrs[HWSIM_ATTR_FRAME]);
3366
3367         /* Allocate new skb here */
3368         skb = alloc_skb(frame_data_len, GFP_KERNEL);
3369         if (skb == NULL)
3370                 goto err;
3371
3372         if (frame_data_len > IEEE80211_MAX_DATA_LEN)
3373                 goto err;
3374
3375         /* Copy the data */
3376         skb_put_data(skb, frame_data, frame_data_len);
3377
3378         data2 = get_hwsim_data_ref_from_addr(dst);
3379         if (!data2)
3380                 goto out;
3381
3382         if (hwsim_net_get_netgroup(genl_info_net(info)) != data2->netgroup)
3383                 goto out;
3384
3385         if (info->snd_portid != data2->wmediumd)
3386                 goto out;
3387
3388         /* check if radio is configured properly */
3389
3390         if (data2->idle || !data2->started)
3391                 goto out;
3392
3393         /* A frame is received from user space */
3394         memset(&rx_status, 0, sizeof(rx_status));
3395         if (info->attrs[HWSIM_ATTR_FREQ]) {
3396                 /* throw away off-channel packets, but allow both the temporary
3397                  * ("hw" scan/remain-on-channel) and regular channel, since the
3398                  * internal datapath also allows this
3399                  */
3400                 mutex_lock(&data2->mutex);
3401                 rx_status.freq = nla_get_u32(info->attrs[HWSIM_ATTR_FREQ]);
3402
3403                 if (rx_status.freq != data2->channel->center_freq &&
3404                     (!data2->tmp_chan ||
3405                      rx_status.freq != data2->tmp_chan->center_freq)) {
3406                         mutex_unlock(&data2->mutex);
3407                         goto out;
3408                 }
3409                 mutex_unlock(&data2->mutex);
3410         } else {
3411                 rx_status.freq = data2->channel->center_freq;
3412         }
3413
3414         rx_status.band = data2->channel->band;
3415         rx_status.rate_idx = nla_get_u32(info->attrs[HWSIM_ATTR_RX_RATE]);
3416         rx_status.signal = nla_get_u32(info->attrs[HWSIM_ATTR_SIGNAL]);
3417
3418         hdr = (void *)skb->data;
3419
3420         if (ieee80211_is_beacon(hdr->frame_control) ||
3421             ieee80211_is_probe_resp(hdr->frame_control))
3422                 rx_status.boottime_ns = ktime_get_boottime_ns();
3423
3424         memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
3425         data2->rx_pkts++;
3426         data2->rx_bytes += skb->len;
3427         ieee80211_rx_irqsafe(data2->hw, skb);
3428
3429         return 0;
3430 err:
3431         pr_debug("mac80211_hwsim: error occurred in %s\n", __func__);
3432 out:
3433         dev_kfree_skb(skb);
3434         return -EINVAL;
3435 }
3436
3437 static int hwsim_register_received_nl(struct sk_buff *skb_2,
3438                                       struct genl_info *info)
3439 {
3440         struct net *net = genl_info_net(info);
3441         struct mac80211_hwsim_data *data;
3442         int chans = 1;
3443
3444         spin_lock_bh(&hwsim_radio_lock);
3445         list_for_each_entry(data, &hwsim_radios, list)
3446                 chans = max(chans, data->channels);
3447         spin_unlock_bh(&hwsim_radio_lock);
3448
3449         /* In the future we should revise the userspace API and allow it
3450          * to set a flag that it does support multi-channel, then we can
3451          * let this pass conditionally on the flag.
3452          * For current userspace, prohibit it since it won't work right.
3453          */
3454         if (chans > 1)
3455                 return -EOPNOTSUPP;
3456
3457         if (hwsim_net_get_wmediumd(net))
3458                 return -EBUSY;
3459
3460         hwsim_register_wmediumd(net, info->snd_portid);
3461
3462         pr_debug("mac80211_hwsim: received a REGISTER, "
3463                "switching to wmediumd mode with pid %d\n", info->snd_portid);
3464
3465         return 0;
3466 }
3467
3468 /* ensures ciphers only include ciphers listed in 'hwsim_ciphers' array */
3469 static bool hwsim_known_ciphers(const u32 *ciphers, int n_ciphers)
3470 {
3471         int i;
3472
3473         for (i = 0; i < n_ciphers; i++) {
3474                 int j;
3475                 int found = 0;
3476
3477                 for (j = 0; j < ARRAY_SIZE(hwsim_ciphers); j++) {
3478                         if (ciphers[i] == hwsim_ciphers[j]) {
3479                                 found = 1;
3480                                 break;
3481                         }
3482                 }
3483
3484                 if (!found)
3485                         return false;
3486         }
3487
3488         return true;
3489 }
3490
3491 static int hwsim_new_radio_nl(struct sk_buff *msg, struct genl_info *info)
3492 {
3493         struct hwsim_new_radio_params param = { 0 };
3494         const char *hwname = NULL;
3495         int ret;
3496
3497         param.reg_strict = info->attrs[HWSIM_ATTR_REG_STRICT_REG];
3498         param.p2p_device = info->attrs[HWSIM_ATTR_SUPPORT_P2P_DEVICE];
3499         param.channels = channels;
3500         param.destroy_on_close =
3501                 info->attrs[HWSIM_ATTR_DESTROY_RADIO_ON_CLOSE];
3502
3503         if (info->attrs[HWSIM_ATTR_CHANNELS])
3504                 param.channels = nla_get_u32(info->attrs[HWSIM_ATTR_CHANNELS]);
3505
3506         if (param.channels < 1) {
3507                 GENL_SET_ERR_MSG(info, "must have at least one channel");
3508                 return -EINVAL;
3509         }
3510
3511         if (param.channels > CFG80211_MAX_NUM_DIFFERENT_CHANNELS) {
3512                 GENL_SET_ERR_MSG(info, "too many channels specified");
3513                 return -EINVAL;
3514         }
3515
3516         if (info->attrs[HWSIM_ATTR_NO_VIF])
3517                 param.no_vif = true;
3518
3519         if (info->attrs[HWSIM_ATTR_USE_CHANCTX])
3520                 param.use_chanctx = true;
3521         else
3522                 param.use_chanctx = (param.channels > 1);
3523
3524         if (info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2])
3525                 param.reg_alpha2 =
3526                         nla_data(info->attrs[HWSIM_ATTR_REG_HINT_ALPHA2]);
3527
3528         if (info->attrs[HWSIM_ATTR_REG_CUSTOM_REG]) {
3529                 u32 idx = nla_get_u32(info->attrs[HWSIM_ATTR_REG_CUSTOM_REG]);
3530
3531                 if (idx >= ARRAY_SIZE(hwsim_world_regdom_custom))
3532                         return -EINVAL;
3533
3534                 idx = array_index_nospec(idx,
3535                                          ARRAY_SIZE(hwsim_world_regdom_custom));
3536                 param.regd = hwsim_world_regdom_custom[idx];
3537         }
3538
3539         if (info->attrs[HWSIM_ATTR_PERM_ADDR]) {
3540                 if (!is_valid_ether_addr(
3541                                 nla_data(info->attrs[HWSIM_ATTR_PERM_ADDR]))) {
3542                         GENL_SET_ERR_MSG(info,"MAC is no valid source addr");
3543                         NL_SET_BAD_ATTR(info->extack,
3544                                         info->attrs[HWSIM_ATTR_PERM_ADDR]);
3545                         return -EINVAL;
3546                 }
3547
3548                 param.perm_addr = nla_data(info->attrs[HWSIM_ATTR_PERM_ADDR]);
3549         }
3550
3551         if (info->attrs[HWSIM_ATTR_IFTYPE_SUPPORT]) {
3552                 param.iftypes =
3553                         nla_get_u32(info->attrs[HWSIM_ATTR_IFTYPE_SUPPORT]);
3554
3555                 if (param.iftypes & ~HWSIM_IFTYPE_SUPPORT_MASK) {
3556                         NL_SET_ERR_MSG_ATTR(info->extack,
3557                                             info->attrs[HWSIM_ATTR_IFTYPE_SUPPORT],
3558                                             "cannot support more iftypes than kernel");
3559                         return -EINVAL;
3560                 }
3561         } else {
3562                 param.iftypes = HWSIM_IFTYPE_SUPPORT_MASK;
3563         }
3564
3565         /* ensure both flag and iftype support is honored */
3566         if (param.p2p_device ||
3567             param.iftypes & BIT(NL80211_IFTYPE_P2P_DEVICE)) {
3568                 param.iftypes |= BIT(NL80211_IFTYPE_P2P_DEVICE);
3569                 param.p2p_device = true;
3570         }
3571
3572         if (info->attrs[HWSIM_ATTR_CIPHER_SUPPORT]) {
3573                 u32 len = nla_len(info->attrs[HWSIM_ATTR_CIPHER_SUPPORT]);
3574
3575                 param.ciphers =
3576                         nla_data(info->attrs[HWSIM_ATTR_CIPHER_SUPPORT]);
3577
3578                 if (len % sizeof(u32)) {
3579                         NL_SET_ERR_MSG_ATTR(info->extack,
3580                                             info->attrs[HWSIM_ATTR_CIPHER_SUPPORT],
3581                                             "bad cipher list length");
3582                         return -EINVAL;
3583                 }
3584
3585                 param.n_ciphers = len / sizeof(u32);
3586
3587                 if (param.n_ciphers > ARRAY_SIZE(hwsim_ciphers)) {
3588                         NL_SET_ERR_MSG_ATTR(info->extack,
3589                                             info->attrs[HWSIM_ATTR_CIPHER_SUPPORT],
3590                                             "too many ciphers specified");
3591                         return -EINVAL;
3592                 }
3593
3594                 if (!hwsim_known_ciphers(param.ciphers, param.n_ciphers)) {
3595                         NL_SET_ERR_MSG_ATTR(info->extack,
3596                                             info->attrs[HWSIM_ATTR_CIPHER_SUPPORT],
3597                                             "unsupported ciphers specified");
3598                         return -EINVAL;
3599                 }
3600         }
3601
3602         if (info->attrs[HWSIM_ATTR_RADIO_NAME]) {
3603                 hwname = kasprintf(GFP_KERNEL, "%.*s",
3604                                    nla_len(info->attrs[HWSIM_ATTR_RADIO_NAME]),
3605                                    (char *)nla_data(info->attrs[HWSIM_ATTR_RADIO_NAME]));
3606                 if (!hwname)
3607                         return -ENOMEM;
3608                 param.hwname = hwname;
3609         }
3610
3611         ret = mac80211_hwsim_new_radio(info, &param);
3612         kfree(hwname);
3613         return ret;
3614 }
3615
3616 static int hwsim_del_radio_nl(struct sk_buff *msg, struct genl_info *info)
3617 {
3618         struct mac80211_hwsim_data *data;
3619         s64 idx = -1;
3620         const char *hwname = NULL;
3621
3622         if (info->attrs[HWSIM_ATTR_RADIO_ID]) {
3623                 idx = nla_get_u32(info->attrs[HWSIM_ATTR_RADIO_ID]);
3624         } else if (info->attrs[HWSIM_ATTR_RADIO_NAME]) {
3625                 hwname = kasprintf(GFP_KERNEL, "%.*s",
3626                                    nla_len(info->attrs[HWSIM_ATTR_RADIO_NAME]),
3627                                    (char *)nla_data(info->attrs[HWSIM_ATTR_RADIO_NAME]));
3628                 if (!hwname)
3629                         return -ENOMEM;
3630         } else
3631                 return -EINVAL;
3632
3633         spin_lock_bh(&hwsim_radio_lock);
3634         list_for_each_entry(data, &hwsim_radios, list) {
3635                 if (idx >= 0) {
3636                         if (data->idx != idx)
3637                                 continue;
3638                 } else {
3639                         if (!hwname ||
3640                             strcmp(hwname, wiphy_name(data->hw->wiphy)))
3641                                 continue;
3642                 }
3643
3644                 if (!net_eq(wiphy_net(data->hw->wiphy), genl_info_net(info)))
3645                         continue;
3646
3647                 list_del(&data->list);
3648                 rhashtable_remove_fast(&hwsim_radios_rht, &data->rht,
3649                                        hwsim_rht_params);
3650                 hwsim_radios_generation++;
3651                 spin_unlock_bh(&hwsim_radio_lock);
3652                 mac80211_hwsim_del_radio(data, wiphy_name(data->hw->wiphy),
3653                                          info);
3654                 kfree(hwname);
3655                 return 0;
3656         }
3657         spin_unlock_bh(&hwsim_radio_lock);
3658
3659         kfree(hwname);
3660         return -ENODEV;
3661 }
3662
3663 static int hwsim_get_radio_nl(struct sk_buff *msg, struct genl_info *info)
3664 {
3665         struct mac80211_hwsim_data *data;
3666         struct sk_buff *skb;
3667         int idx, res = -ENODEV;
3668
3669         if (!info->attrs[HWSIM_ATTR_RADIO_ID])
3670                 return -EINVAL;
3671         idx = nla_get_u32(info->attrs[HWSIM_ATTR_RADIO_ID]);
3672
3673         spin_lock_bh(&hwsim_radio_lock);
3674         list_for_each_entry(data, &hwsim_radios, list) {
3675                 if (data->idx != idx)
3676                         continue;
3677
3678                 if (!net_eq(wiphy_net(data->hw->wiphy), genl_info_net(info)))
3679                         continue;
3680
3681                 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
3682                 if (!skb) {
3683                         res = -ENOMEM;
3684                         goto out_err;
3685                 }
3686
3687                 res = mac80211_hwsim_get_radio(skb, data, info->snd_portid,
3688                                                info->snd_seq, NULL, 0);
3689                 if (res < 0) {
3690                         nlmsg_free(skb);
3691                         goto out_err;
3692                 }
3693
3694                 res = genlmsg_reply(skb, info);
3695                 break;
3696         }
3697
3698 out_err:
3699         spin_unlock_bh(&hwsim_radio_lock);
3700
3701         return res;
3702 }
3703
3704 static int hwsim_dump_radio_nl(struct sk_buff *skb,
3705                                struct netlink_callback *cb)
3706 {
3707         int last_idx = cb->args[0] - 1;
3708         struct mac80211_hwsim_data *data = NULL;
3709         int res = 0;
3710         void *hdr;
3711
3712         spin_lock_bh(&hwsim_radio_lock);
3713         cb->seq = hwsim_radios_generation;
3714
3715         if (last_idx >= hwsim_radio_idx-1)
3716                 goto done;
3717
3718         list_for_each_entry(data, &hwsim_radios, list) {
3719                 if (data->idx <= last_idx)
3720                         continue;
3721
3722                 if (!net_eq(wiphy_net(data->hw->wiphy), sock_net(skb->sk)))
3723                         continue;
3724
3725                 res = mac80211_hwsim_get_radio(skb, data,
3726                                                NETLINK_CB(cb->skb).portid,
3727                                                cb->nlh->nlmsg_seq, cb,
3728                                                NLM_F_MULTI);
3729                 if (res < 0)
3730                         break;
3731
3732                 last_idx = data->idx;
3733         }
3734
3735         cb->args[0] = last_idx + 1;
3736
3737         /* list changed, but no new element sent, set interrupted flag */
3738         if (skb->len == 0 && cb->prev_seq && cb->seq != cb->prev_seq) {
3739                 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
3740                                   cb->nlh->nlmsg_seq, &hwsim_genl_family,
3741                                   NLM_F_MULTI, HWSIM_CMD_GET_RADIO);
3742                 if (hdr) {
3743                         genl_dump_check_consistent(cb, hdr);
3744                         genlmsg_end(skb, hdr);
3745                 } else {
3746                         res = -EMSGSIZE;
3747                 }
3748         }
3749
3750 done:
3751         spin_unlock_bh(&hwsim_radio_lock);
3752         return res ?: skb->len;
3753 }
3754
3755 /* Generic Netlink operations array */
3756 static const struct genl_ops hwsim_ops[] = {
3757         {
3758                 .cmd = HWSIM_CMD_REGISTER,
3759                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
3760                 .doit = hwsim_register_received_nl,
3761                 .flags = GENL_UNS_ADMIN_PERM,
3762         },
3763         {
3764                 .cmd = HWSIM_CMD_FRAME,
3765                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
3766                 .doit = hwsim_cloned_frame_received_nl,
3767         },
3768         {
3769                 .cmd = HWSIM_CMD_TX_INFO_FRAME,
3770                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
3771                 .doit = hwsim_tx_info_frame_received_nl,
3772         },
3773         {
3774                 .cmd = HWSIM_CMD_NEW_RADIO,
3775                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
3776                 .doit = hwsim_new_radio_nl,
3777                 .flags = GENL_UNS_ADMIN_PERM,
3778         },
3779         {
3780                 .cmd = HWSIM_CMD_DEL_RADIO,
3781                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
3782                 .doit = hwsim_del_radio_nl,
3783                 .flags = GENL_UNS_ADMIN_PERM,
3784         },
3785         {
3786                 .cmd = HWSIM_CMD_GET_RADIO,
3787                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
3788                 .doit = hwsim_get_radio_nl,
3789                 .dumpit = hwsim_dump_radio_nl,
3790         },
3791 };
3792
3793 static struct genl_family hwsim_genl_family __ro_after_init = {
3794         .name = "MAC80211_HWSIM",
3795         .version = 1,
3796         .maxattr = HWSIM_ATTR_MAX,
3797         .policy = hwsim_genl_policy,
3798         .netnsok = true,
3799         .module = THIS_MODULE,
3800         .ops = hwsim_ops,
3801         .n_ops = ARRAY_SIZE(hwsim_ops),
3802         .mcgrps = hwsim_mcgrps,
3803         .n_mcgrps = ARRAY_SIZE(hwsim_mcgrps),
3804 };
3805
3806 static void remove_user_radios(u32 portid)
3807 {
3808         struct mac80211_hwsim_data *entry, *tmp;
3809         LIST_HEAD(list);
3810
3811         spin_lock_bh(&hwsim_radio_lock);
3812         list_for_each_entry_safe(entry, tmp, &hwsim_radios, list) {
3813                 if (entry->destroy_on_close && entry->portid == portid) {
3814                         list_move(&entry->list, &list);
3815                         rhashtable_remove_fast(&hwsim_radios_rht, &entry->rht,
3816                                                hwsim_rht_params);
3817                         hwsim_radios_generation++;
3818                 }
3819         }
3820         spin_unlock_bh(&hwsim_radio_lock);
3821
3822         list_for_each_entry_safe(entry, tmp, &list, list) {
3823                 list_del(&entry->list);
3824                 mac80211_hwsim_del_radio(entry, wiphy_name(entry->hw->wiphy),
3825                                          NULL);
3826         }
3827 }
3828
3829 static int mac80211_hwsim_netlink_notify(struct notifier_block *nb,
3830                                          unsigned long state,
3831                                          void *_notify)
3832 {
3833         struct netlink_notify *notify = _notify;
3834
3835         if (state != NETLINK_URELEASE)
3836                 return NOTIFY_DONE;
3837
3838         remove_user_radios(notify->portid);
3839
3840         if (notify->portid == hwsim_net_get_wmediumd(notify->net)) {
3841                 printk(KERN_INFO "mac80211_hwsim: wmediumd released netlink"
3842                        " socket, switching to perfect channel medium\n");
3843                 hwsim_register_wmediumd(notify->net, 0);
3844         }
3845         return NOTIFY_DONE;
3846
3847 }
3848
3849 static struct notifier_block hwsim_netlink_notifier = {
3850         .notifier_call = mac80211_hwsim_netlink_notify,
3851 };
3852
3853 static int __init hwsim_init_netlink(void)
3854 {
3855         int rc;
3856
3857         printk(KERN_INFO "mac80211_hwsim: initializing netlink\n");
3858
3859         rc = genl_register_family(&hwsim_genl_family);
3860         if (rc)
3861                 goto failure;
3862
3863         rc = netlink_register_notifier(&hwsim_netlink_notifier);
3864         if (rc) {
3865                 genl_unregister_family(&hwsim_genl_family);
3866                 goto failure;
3867         }
3868
3869         return 0;
3870
3871 failure:
3872         pr_debug("mac80211_hwsim: error occurred in %s\n", __func__);
3873         return -EINVAL;
3874 }
3875
3876 static __net_init int hwsim_init_net(struct net *net)
3877 {
3878         return hwsim_net_set_netgroup(net);
3879 }
3880
3881 static void __net_exit hwsim_exit_net(struct net *net)
3882 {
3883         struct mac80211_hwsim_data *data, *tmp;
3884         LIST_HEAD(list);
3885
3886         spin_lock_bh(&hwsim_radio_lock);
3887         list_for_each_entry_safe(data, tmp, &hwsim_radios, list) {
3888                 if (!net_eq(wiphy_net(data->hw->wiphy), net))
3889                         continue;
3890
3891                 /* Radios created in init_net are returned to init_net. */
3892                 if (data->netgroup == hwsim_net_get_netgroup(&init_net))
3893                         continue;
3894
3895                 list_move(&data->list, &list);
3896                 rhashtable_remove_fast(&hwsim_radios_rht, &data->rht,
3897                                        hwsim_rht_params);
3898                 hwsim_radios_generation++;
3899         }
3900         spin_unlock_bh(&hwsim_radio_lock);
3901
3902         list_for_each_entry_safe(data, tmp, &list, list) {
3903                 list_del(&data->list);
3904                 mac80211_hwsim_del_radio(data,
3905                                          wiphy_name(data->hw->wiphy),
3906                                          NULL);
3907         }
3908
3909         ida_simple_remove(&hwsim_netgroup_ida, hwsim_net_get_netgroup(net));
3910 }
3911
3912 static struct pernet_operations hwsim_net_ops = {
3913         .init = hwsim_init_net,
3914         .exit = hwsim_exit_net,
3915         .id   = &hwsim_net_id,
3916         .size = sizeof(struct hwsim_net),
3917 };
3918
3919 static void hwsim_exit_netlink(void)
3920 {
3921         /* unregister the notifier */
3922         netlink_unregister_notifier(&hwsim_netlink_notifier);
3923         /* unregister the family */
3924         genl_unregister_family(&hwsim_genl_family);
3925 }
3926
3927 static int __init init_mac80211_hwsim(void)
3928 {
3929         int i, err;
3930
3931         if (radios < 0 || radios > 100)
3932                 return -EINVAL;
3933
3934         if (channels < 1)
3935                 return -EINVAL;
3936
3937         spin_lock_init(&hwsim_radio_lock);
3938
3939         err = rhashtable_init(&hwsim_radios_rht, &hwsim_rht_params);
3940         if (err)
3941                 return err;
3942
3943         err = register_pernet_device(&hwsim_net_ops);
3944         if (err)
3945                 goto out_free_rht;
3946
3947         err = platform_driver_register(&mac80211_hwsim_driver);
3948         if (err)
3949                 goto out_unregister_pernet;
3950
3951         err = hwsim_init_netlink();
3952         if (err)
3953                 goto out_unregister_driver;
3954
3955         hwsim_class = class_create(THIS_MODULE, "mac80211_hwsim");
3956         if (IS_ERR(hwsim_class)) {
3957                 err = PTR_ERR(hwsim_class);
3958                 goto out_exit_netlink;
3959         }
3960
3961         for (i = 0; i < radios; i++) {
3962                 struct hwsim_new_radio_params param = { 0 };
3963
3964                 param.channels = channels;
3965
3966                 switch (regtest) {
3967                 case HWSIM_REGTEST_DIFF_COUNTRY:
3968                         if (i < ARRAY_SIZE(hwsim_alpha2s))
3969                                 param.reg_alpha2 = hwsim_alpha2s[i];
3970                         break;
3971                 case HWSIM_REGTEST_DRIVER_REG_FOLLOW:
3972                         if (!i)
3973                                 param.reg_alpha2 = hwsim_alpha2s[0];
3974                         break;
3975                 case HWSIM_REGTEST_STRICT_ALL:
3976                         param.reg_strict = true;
3977                         /* fall through */
3978                 case HWSIM_REGTEST_DRIVER_REG_ALL:
3979                         param.reg_alpha2 = hwsim_alpha2s[0];
3980                         break;
3981                 case HWSIM_REGTEST_WORLD_ROAM:
3982                         if (i == 0)
3983                                 param.regd = &hwsim_world_regdom_custom_01;
3984                         break;
3985                 case HWSIM_REGTEST_CUSTOM_WORLD:
3986                         param.regd = &hwsim_world_regdom_custom_01;
3987                         break;
3988                 case HWSIM_REGTEST_CUSTOM_WORLD_2:
3989                         if (i == 0)
3990                                 param.regd = &hwsim_world_regdom_custom_01;
3991                         else if (i == 1)
3992                                 param.regd = &hwsim_world_regdom_custom_02;
3993                         break;
3994                 case HWSIM_REGTEST_STRICT_FOLLOW:
3995                         if (i == 0) {
3996                                 param.reg_strict = true;
3997                                 param.reg_alpha2 = hwsim_alpha2s[0];
3998                         }
3999                         break;
4000                 case HWSIM_REGTEST_STRICT_AND_DRIVER_REG:
4001                         if (i == 0) {
4002                                 param.reg_strict = true;
4003                                 param.reg_alpha2 = hwsim_alpha2s[0];
4004                         } else if (i == 1) {
4005                                 param.reg_alpha2 = hwsim_alpha2s[1];
4006                         }
4007                         break;
4008                 case HWSIM_REGTEST_ALL:
4009                         switch (i) {
4010                         case 0:
4011                                 param.regd = &hwsim_world_regdom_custom_01;
4012                                 break;
4013                         case 1:
4014                                 param.regd = &hwsim_world_regdom_custom_02;
4015                                 break;
4016                         case 2:
4017                                 param.reg_alpha2 = hwsim_alpha2s[0];
4018                                 break;
4019                         case 3:
4020                                 param.reg_alpha2 = hwsim_alpha2s[1];
4021                                 break;
4022                         case 4:
4023                                 param.reg_strict = true;
4024                                 param.reg_alpha2 = hwsim_alpha2s[2];
4025                                 break;
4026                         }
4027                         break;
4028                 default:
4029                         break;
4030                 }
4031
4032                 param.p2p_device = support_p2p_device;
4033                 param.use_chanctx = channels > 1;
4034                 param.iftypes = HWSIM_IFTYPE_SUPPORT_MASK;
4035                 if (param.p2p_device)
4036                         param.iftypes |= BIT(NL80211_IFTYPE_P2P_DEVICE);
4037
4038                 err = mac80211_hwsim_new_radio(NULL, &param);
4039                 if (err < 0)
4040                         goto out_free_radios;
4041         }
4042
4043         hwsim_mon = alloc_netdev(0, "hwsim%d", NET_NAME_UNKNOWN,
4044                                  hwsim_mon_setup);
4045         if (hwsim_mon == NULL) {
4046                 err = -ENOMEM;
4047                 goto out_free_radios;
4048         }
4049
4050         rtnl_lock();
4051         err = dev_alloc_name(hwsim_mon, hwsim_mon->name);
4052         if (err < 0) {
4053                 rtnl_unlock();
4054                 goto out_free_mon;
4055         }
4056
4057         err = register_netdevice(hwsim_mon);
4058         if (err < 0) {
4059                 rtnl_unlock();
4060                 goto out_free_mon;
4061         }
4062         rtnl_unlock();
4063
4064         return 0;
4065
4066 out_free_mon:
4067         free_netdev(hwsim_mon);
4068 out_free_radios:
4069         mac80211_hwsim_free();
4070 out_exit_netlink:
4071         hwsim_exit_netlink();
4072 out_unregister_driver:
4073         platform_driver_unregister(&mac80211_hwsim_driver);
4074 out_unregister_pernet:
4075         unregister_pernet_device(&hwsim_net_ops);
4076 out_free_rht:
4077         rhashtable_destroy(&hwsim_radios_rht);
4078         return err;
4079 }
4080 module_init(init_mac80211_hwsim);
4081
4082 static void __exit exit_mac80211_hwsim(void)
4083 {
4084         pr_debug("mac80211_hwsim: unregister radios\n");
4085
4086         hwsim_exit_netlink();
4087
4088         mac80211_hwsim_free();
4089
4090         rhashtable_destroy(&hwsim_radios_rht);
4091         unregister_netdev(hwsim_mon);
4092         platform_driver_unregister(&mac80211_hwsim_driver);
4093         unregister_pernet_device(&hwsim_net_ops);
4094 }
4095 module_exit(exit_mac80211_hwsim);