linux/drivers/net/wireless/ath/ath10k/testmode.c
<<
>>
Prefs
   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
  19static 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 */
  31bool 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 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 to put testmode wmi even 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
  94out:
  95        spin_unlock_bh(&ar->data_lock);
  96
  97        return consumed;
  98}
  99
 100static 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
 139static 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
 173static 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
 208out:
 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
 226static 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
 305err_power_down:
 306        ath10k_hif_power_down(ar);
 307
 308err_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
 317err:
 318        mutex_unlock(&ar->conf_mutex);
 319
 320        return ret;
 321}
 322
 323static 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
 347static 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
 366out:
 367        mutex_unlock(&ar->conf_mutex);
 368        return ret;
 369}
 370
 371static 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
 422out:
 423        mutex_unlock(&ar->conf_mutex);
 424        return ret;
 425}
 426
 427int 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
 456void 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
 467out:
 468        mutex_unlock(&ar->conf_mutex);
 469}
 470