drivers/net/wireless/ath/ath10k/testmode.c

   1 // SPDX-License-Identifier: ISC
   2 /*
   3  * Copyright (c) 2014-2017 Qualcomm Atheros, Inc.
   4  */
   5
   6 #include "testmode.h"
   7
   8 #include <net/netlink.h>
   9 #include <linux/firmware.h>
  10
  11 #include "debug.h"
  12 #include "wmi.h"
  13 #include "hif.h"
  14 #include "hw.h"
  15 #include "core.h"
  16
  17 #include "testmode_i.h"
  18
  19 static const struct nla_policy ath10k_tm_policy[ATH10K_TM_ATTR_MAX + 1] = {
  20         [ATH10K_TM_ATTR_CMD]            = { .type = NLA_U32 },
  21         [ATH10K_TM_ATTR_DATA]           = { .type = NLA_BINARY,
  22                                             .len = ATH10K_TM_DATA_MAX_LEN },
  23         [ATH10K_TM_ATTR_WMI_CMDID]      = { .type = NLA_U32 },
  24         [ATH10K_TM_ATTR_VERSION_MAJOR]  = { .type = NLA_U32 },
  25         [ATH10K_TM_ATTR_VERSION_MINOR]  = { .type = NLA_U32 },
  26 };
  27
  28 /* Returns true if callee consumes the skb and the skb should be discarded.
  29  * Returns false if skb is not used. Does not sleep.
  30  */
  31 bool ath10k_tm_event_wmi(struct ath10k *ar, u32 cmd_id, struct sk_buff *skb)
  32 {
  33         struct sk_buff *nl_skb;
  34         bool consumed;
  35         int ret;
  36
  37         ath10k_dbg(ar, ATH10K_DBG_TESTMODE,
  38                    "testmode event wmi cmd_id %d skb %pK skb->len %d\n",
  39                    cmd_id, skb, skb->len);
  40
  41         ath10k_dbg_dump(ar, ATH10K_DBG_TESTMODE, NULL, "", skb->data, skb->len);
  42
  43         spin_lock_bh(&ar->data_lock);
  44
  45         if (!ar->testmode.utf_monitor) {
  46                 consumed = false;
  47                 goto out;
  48         }
  49
  50         /* Only testmode.c should be handling events from utf firmware,
  51          * otherwise all sort of problems will arise as mac80211 operations
  52          * are not initialised.
  53          */
  54         consumed = true;
  55
  56         nl_skb = cfg80211_testmode_alloc_event_skb(ar->hw->wiphy,
  57                                                    2 * sizeof(u32) + skb->len,
  58                                                    GFP_ATOMIC);
  59         if (!nl_skb) {
  60                 ath10k_warn(ar,
  61                             "failed to allocate skb for testmode wmi event\n");
  62                 goto out;
  63         }
  64
  65         ret = nla_put_u32(nl_skb, ATH10K_TM_ATTR_CMD, ATH10K_TM_CMD_WMI);
  66         if (ret) {
  67                 ath10k_warn(ar,
  68                             "failed to put testmode wmi event cmd attribute: %d\n",
  69                             ret);
  70                 kfree_skb(nl_skb);
  71                 goto out;
  72         }
  73
  74         ret = nla_put_u32(nl_skb, ATH10K_TM_ATTR_WMI_CMDID, cmd_id);
  75         if (ret) {
  76                 ath10k_warn(ar,
  77                             "failed to put testmode wmi event cmd_id: %d\n",
  78                             ret);
  79                 kfree_skb(nl_skb);
  80                 goto out;
  81         }
  82
  83         ret = nla_put(nl_skb, ATH10K_TM_ATTR_DATA, skb->len, skb->data);
  84         if (ret) {
  85                 ath10k_warn(ar,
  86                             "failed to copy skb to testmode wmi event: %d\n",
  87                             ret);
  88                 kfree_skb(nl_skb);
  89                 goto out;
  90         }
  91
  92         cfg80211_testmode_event(nl_skb, GFP_ATOMIC);
  93
  94 out:
  95         spin_unlock_bh(&ar->data_lock);
  96
  97         return consumed;
  98 }
  99
 100 static int ath10k_tm_cmd_get_version(struct ath10k *ar, struct nlattr *tb[])
 101 {
 102         struct sk_buff *skb;
 103         int ret;
 104
 105         ath10k_dbg(ar, ATH10K_DBG_TESTMODE,
 106                    "testmode cmd get version_major %d version_minor %d\n",
 107                    ATH10K_TESTMODE_VERSION_MAJOR,
 108                    ATH10K_TESTMODE_VERSION_MINOR);
 109
 110         skb = cfg80211_testmode_alloc_reply_skb(ar->hw->wiphy,
 111                                                 nla_total_size(sizeof(u32)));
 112         if (!skb)
 113                 return -ENOMEM;
 114
 115         ret = nla_put_u32(skb, ATH10K_TM_ATTR_VERSION_MAJOR,
 116                           ATH10K_TESTMODE_VERSION_MAJOR);
 117         if (ret) {
 118                 kfree_skb(skb);
 119                 return ret;
 120         }
 121
 122         ret = nla_put_u32(skb, ATH10K_TM_ATTR_VERSION_MINOR,
 123                           ATH10K_TESTMODE_VERSION_MINOR);
 124         if (ret) {
 125                 kfree_skb(skb);
 126                 return ret;
 127         }
 128
 129         ret = nla_put_u32(skb, ATH10K_TM_ATTR_WMI_OP_VERSION,
 130                           ar->normal_mode_fw.fw_file.wmi_op_version);
 131         if (ret) {
 132                 kfree_skb(skb);
 133                 return ret;
 134         }
 135
 136         return cfg80211_testmode_reply(skb);
 137 }
 138
 139 static int ath10k_tm_fetch_utf_firmware_api_1(struct ath10k *ar,
 140                                               struct ath10k_fw_file *fw_file)
 141 {
 142         char filename[100];
 143         int ret;
 144
 145         snprintf(filename, sizeof(filename), "%s/%s",
 146                  ar->hw_params.fw.dir, ATH10K_FW_UTF_FILE);
 147
 148         /* load utf firmware image */
 149         ret = firmware_request_nowarn(&fw_file->firmware, filename, ar->dev);
 150         ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode fw request '%s': %d\n",
 151                    filename, ret);
 152
 153         if (ret) {
 154                 ath10k_warn(ar, "failed to retrieve utf firmware '%s': %d\n",
 155                             filename, ret);
 156                 return ret;
 157         }
 158
 159         /* We didn't find FW UTF API 1 ("utf.bin") does not advertise
 160          * firmware features. Do an ugly hack where we force the firmware
 161          * features to match with 10.1 branch so that wmi.c will use the
 162          * correct WMI interface.
 163          */
 164
 165         fw_file->wmi_op_version = ATH10K_FW_WMI_OP_VERSION_10_1;
 166         fw_file->htt_op_version = ATH10K_FW_HTT_OP_VERSION_10_1;
 167         fw_file->firmware_data = fw_file->firmware->data;
 168         fw_file->firmware_len = fw_file->firmware->size;
 169
 170         return 0;
 171 }
 172
 173 static int ath10k_tm_fetch_firmware(struct ath10k *ar)
 174 {
 175         struct ath10k_fw_components *utf_mode_fw;
 176         int ret;
 177         char fw_name[100];
 178         int fw_api2 = 2;
 179
 180         switch (ar->hif.bus) {
 181         case ATH10K_BUS_SDIO:
 182         case ATH10K_BUS_USB:
 183                 scnprintf(fw_name, sizeof(fw_name), "%s-%s-%d.bin",
 184                           ATH10K_FW_UTF_FILE_BASE, ath10k_bus_str(ar->hif.bus),
 185                           fw_api2);
 186                 break;
 187         default:
 188                 scnprintf(fw_name, sizeof(fw_name), "%s-%d.bin",
 189                           ATH10K_FW_UTF_FILE_BASE, fw_api2);
 190                 break;
 191         }
 192
 193         ret = ath10k_core_fetch_firmware_api_n(ar, fw_name,
 194                                                &ar->testmode.utf_mode_fw.fw_file);
 195         if (ret == 0) {
 196                 ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode using fw utf api 2");
 197                 goto out;
 198         }
 199
 200         ret = ath10k_tm_fetch_utf_firmware_api_1(ar, &ar->testmode.utf_mode_fw.fw_file);
 201         if (ret) {
 202                 ath10k_err(ar, "failed to fetch utf firmware binary: %d", ret);
 203                 return ret;
 204         }
 205
 206         ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode using utf api 1");
 207
 208 out:
 209         utf_mode_fw = &ar->testmode.utf_mode_fw;
 210
 211         /* Use the same board data file as the normal firmware uses (but
 212          * it's still "owned" by normal_mode_fw so we shouldn't free it.
 213          */
 214         utf_mode_fw->board_data = ar->normal_mode_fw.board_data;
 215         utf_mode_fw->board_len = ar->normal_mode_fw.board_len;
 216
 217         if (!utf_mode_fw->fw_file.otp_data) {
 218                 ath10k_info(ar, "utf.bin didn't contain otp binary, taking it from the normal mode firmware");
 219                 utf_mode_fw->fw_file.otp_data = ar->normal_mode_fw.fw_file.otp_data;
 220                 utf_mode_fw->fw_file.otp_len = ar->normal_mode_fw.fw_file.otp_len;
 221         }
 222
 223         return 0;
 224 }
 225
 226 static int ath10k_tm_cmd_utf_start(struct ath10k *ar, struct nlattr *tb[])
 227 {
 228         const char *ver;
 229         int ret;
 230
 231         ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode cmd utf start\n");
 232
 233         mutex_lock(&ar->conf_mutex);
 234
 235         if (ar->state == ATH10K_STATE_UTF) {
 236                 ret = -EALREADY;
 237                 goto err;
 238         }
 239
 240         /* start utf only when the driver is not in use  */
 241         if (ar->state != ATH10K_STATE_OFF) {
 242                 ret = -EBUSY;
 243                 goto err;
 244         }
 245
 246         if (WARN_ON(ar->testmode.utf_mode_fw.fw_file.firmware != NULL)) {
 247                 /* utf image is already downloaded, it shouldn't be */
 248                 ret = -EEXIST;
 249                 goto err;
 250         }
 251
 252         ret = ath10k_tm_fetch_firmware(ar);
 253         if (ret) {
 254                 ath10k_err(ar, "failed to fetch UTF firmware: %d", ret);
 255                 goto err;
 256         }
 257
 258         if (ar->testmode.utf_mode_fw.fw_file.codeswap_data &&
 259             ar->testmode.utf_mode_fw.fw_file.codeswap_len) {
 260                 ret = ath10k_swap_code_seg_init(ar,
 261                                                 &ar->testmode.utf_mode_fw.fw_file);
 262                 if (ret) {
 263                         ath10k_warn(ar,
 264                                     "failed to init utf code swap segment: %d\n",
 265                                     ret);
 266                         goto err_release_utf_mode_fw;
 267                 }
 268         }
 269
 270         spin_lock_bh(&ar->data_lock);
 271         ar->testmode.utf_monitor = true;
 272         spin_unlock_bh(&ar->data_lock);
 273
 274         ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode wmi version %d\n",
 275                    ar->testmode.utf_mode_fw.fw_file.wmi_op_version);
 276
 277         ret = ath10k_hif_power_up(ar, ATH10K_FIRMWARE_MODE_UTF);
 278         if (ret) {
 279                 ath10k_err(ar, "failed to power up hif (testmode): %d\n", ret);
 280                 ar->state = ATH10K_STATE_OFF;
 281                 goto err_release_utf_mode_fw;
 282         }
 283
 284         ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_UTF,
 285                                 &ar->testmode.utf_mode_fw);
 286         if (ret) {
 287                 ath10k_err(ar, "failed to start core (testmode): %d\n", ret);
 288                 ar->state = ATH10K_STATE_OFF;
 289                 goto err_power_down;
 290         }
 291
 292         ar->state = ATH10K_STATE_UTF;
 293
 294         if (strlen(ar->testmode.utf_mode_fw.fw_file.fw_version) > 0)
 295                 ver = ar->testmode.utf_mode_fw.fw_file.fw_version;
 296         else
 297                 ver = "API 1";
 298
 299         ath10k_info(ar, "UTF firmware %s started\n", ver);
 300
 301         mutex_unlock(&ar->conf_mutex);
 302
 303         return 0;
 304
 305 err_power_down:
 306         ath10k_hif_power_down(ar);
 307
 308 err_release_utf_mode_fw:
 309         if (ar->testmode.utf_mode_fw.fw_file.codeswap_data &&
 310             ar->testmode.utf_mode_fw.fw_file.codeswap_len)
 311                 ath10k_swap_code_seg_release(ar,
 312                                              &ar->testmode.utf_mode_fw.fw_file);
 313
 314         release_firmware(ar->testmode.utf_mode_fw.fw_file.firmware);
 315         ar->testmode.utf_mode_fw.fw_file.firmware = NULL;
 316
 317 err:
 318         mutex_unlock(&ar->conf_mutex);
 319
 320         return ret;
 321 }
 322
 323 static void __ath10k_tm_cmd_utf_stop(struct ath10k *ar)
 324 {
 325         lockdep_assert_held(&ar->conf_mutex);
 326
 327         ath10k_core_stop(ar);
 328         ath10k_hif_power_down(ar);
 329
 330         spin_lock_bh(&ar->data_lock);
 331
 332         ar->testmode.utf_monitor = false;
 333
 334         spin_unlock_bh(&ar->data_lock);
 335
 336         if (ar->testmode.utf_mode_fw.fw_file.codeswap_data &&
 337             ar->testmode.utf_mode_fw.fw_file.codeswap_len)
 338                 ath10k_swap_code_seg_release(ar,
 339                                              &ar->testmode.utf_mode_fw.fw_file);
 340
 341         release_firmware(ar->testmode.utf_mode_fw.fw_file.firmware);
 342         ar->testmode.utf_mode_fw.fw_file.firmware = NULL;
 343
 344         ar->state = ATH10K_STATE_OFF;
 345 }
 346
 347 static int ath10k_tm_cmd_utf_stop(struct ath10k *ar, struct nlattr *tb[])
 348 {
 349         int ret;
 350
 351         ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode cmd utf stop\n");
 352
 353         mutex_lock(&ar->conf_mutex);
 354
 355         if (ar->state != ATH10K_STATE_UTF) {
 356                 ret = -ENETDOWN;
 357                 goto out;
 358         }
 359
 360         __ath10k_tm_cmd_utf_stop(ar);
 361
 362         ret = 0;
 363
 364         ath10k_info(ar, "UTF firmware stopped\n");
 365
 366 out:
 367         mutex_unlock(&ar->conf_mutex);
 368         return ret;
 369 }
 370
 371 static int ath10k_tm_cmd_wmi(struct ath10k *ar, struct nlattr *tb[])
 372 {
 373         struct sk_buff *skb;
 374         int ret, buf_len;
 375         u32 cmd_id;
 376         void *buf;
 377
 378         mutex_lock(&ar->conf_mutex);
 379
 380         if (ar->state != ATH10K_STATE_UTF) {
 381                 ret = -ENETDOWN;
 382                 goto out;
 383         }
 384
 385         if (!tb[ATH10K_TM_ATTR_DATA]) {
 386                 ret = -EINVAL;
 387                 goto out;
 388         }
 389
 390         if (!tb[ATH10K_TM_ATTR_WMI_CMDID]) {
 391                 ret = -EINVAL;
 392                 goto out;
 393         }
 394
 395         buf = nla_data(tb[ATH10K_TM_ATTR_DATA]);
 396         buf_len = nla_len(tb[ATH10K_TM_ATTR_DATA]);
 397         cmd_id = nla_get_u32(tb[ATH10K_TM_ATTR_WMI_CMDID]);
 398
 399         ath10k_dbg(ar, ATH10K_DBG_TESTMODE,
 400                    "testmode cmd wmi cmd_id %d buf %pK buf_len %d\n",
 401                    cmd_id, buf, buf_len);
 402
 403         ath10k_dbg_dump(ar, ATH10K_DBG_TESTMODE, NULL, "", buf, buf_len);
 404
 405         skb = ath10k_wmi_alloc_skb(ar, buf_len);
 406         if (!skb) {
 407                 ret = -ENOMEM;
 408                 goto out;
 409         }
 410
 411         memcpy(skb->data, buf, buf_len);
 412
 413         ret = ath10k_wmi_cmd_send(ar, skb, cmd_id);
 414         if (ret) {
 415                 ath10k_warn(ar, "failed to transmit wmi command (testmode): %d\n",
 416                             ret);
 417                 goto out;
 418         }
 419
 420         ret = 0;
 421
 422 out:
 423         mutex_unlock(&ar->conf_mutex);
 424         return ret;
 425 }
 426
 427 int ath10k_tm_cmd(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 428                   void *data, int len)
 429 {
 430         struct ath10k *ar = hw->priv;
 431         struct nlattr *tb[ATH10K_TM_ATTR_MAX + 1];
 432         int ret;
 433
 434         ret = nla_parse_deprecated(tb, ATH10K_TM_ATTR_MAX, data, len,
 435                                    ath10k_tm_policy, NULL);
 436         if (ret)
 437                 return ret;
 438
 439         if (!tb[ATH10K_TM_ATTR_CMD])
 440                 return -EINVAL;
 441
 442         switch (nla_get_u32(tb[ATH10K_TM_ATTR_CMD])) {
 443         case ATH10K_TM_CMD_GET_VERSION:
 444                 return ath10k_tm_cmd_get_version(ar, tb);
 445         case ATH10K_TM_CMD_UTF_START:
 446                 return ath10k_tm_cmd_utf_start(ar, tb);
 447         case ATH10K_TM_CMD_UTF_STOP:
 448                 return ath10k_tm_cmd_utf_stop(ar, tb);
 449         case ATH10K_TM_CMD_WMI:
 450                 return ath10k_tm_cmd_wmi(ar, tb);
 451         default:
 452                 return -EOPNOTSUPP;
 453         }
 454 }
 455
 456 void ath10k_testmode_destroy(struct ath10k *ar)
 457 {
 458         mutex_lock(&ar->conf_mutex);
 459
 460         if (ar->state != ATH10K_STATE_UTF) {
 461                 /* utf firmware is not running, nothing to do */
 462                 goto out;
 463         }
 464
 465         __ath10k_tm_cmd_utf_stop(ar);
 466
 467 out:
 468         mutex_unlock(&ar->conf_mutex);
 469 }