package/kernel/mac80211/patches/304-ath10k-add-FW-API-support-to-test-mode.patch

   1 From: Alan Liu <alanliu@qca.qualcomm.com>
   2 Date: Wed, 28 Oct 2015 21:38:32 +0200
   3 Subject: [PATCH] ath10k: add FW API support to test mode
   4
   5 Add WMI-TLV and FW API support in ath10k testmode.
   6 Ath10k can get right wmi command format from UTF image
   7 to communicate UTF firmware.
   8
   9 Signed-off-by: Alan Liu <alanliu@qca.qualcomm.com>
  10 Signed-off-by: Kalle Valo <kvalo@qca.qualcomm.com>
  11 ---
  12
  13 --- a/drivers/net/wireless/ath/ath10k/core.c
  14 +++ b/drivers/net/wireless/ath/ath10k/core.c
  15 @@ -569,8 +569,8 @@ static int ath10k_download_fw(struct ath
  16                 }
  17                 break;
  18         case ATH10K_FIRMWARE_MODE_UTF:
  19 -               data = ar->testmode.utf->data;
  20 -               data_len = ar->testmode.utf->size;
  21 +               data = ar->testmode.utf_firmware_data;
  22 +               data_len = ar->testmode.utf_firmware_len;
  23                 mode_name = "utf";
  24                 break;
  25         default:
  26 --- a/drivers/net/wireless/ath/ath10k/core.h
  27 +++ b/drivers/net/wireless/ath/ath10k/core.h
  28 @@ -817,9 +817,12 @@ struct ath10k {
  29         struct {
  30                 /* protected by conf_mutex */
  31                 const struct firmware *utf;
  32 +               char utf_version[32];
  33 +               const void *utf_firmware_data;
  34 +               size_t utf_firmware_len;
  35                 DECLARE_BITMAP(orig_fw_features, ATH10K_FW_FEATURE_COUNT);
  36                 enum ath10k_fw_wmi_op_version orig_wmi_op_version;
  37 -
  38 +               enum ath10k_fw_wmi_op_version op_version;
  39                 /* protected by data_lock */
  40                 bool utf_monitor;
  41         } testmode;
  42 --- a/drivers/net/wireless/ath/ath10k/hw.h
  43 +++ b/drivers/net/wireless/ath/ath10k/hw.h
  44 @@ -94,6 +94,7 @@ enum qca6174_chip_id_rev {
  45  #define ATH10K_FW_API5_FILE            "firmware-5.bin"
  46
  47  #define ATH10K_FW_UTF_FILE             "utf.bin"
  48 +#define ATH10K_FW_UTF_API2_FILE                "utf-2.bin"
  49
  50  /* includes also the null byte */
  51  #define ATH10K_FIRMWARE_MAGIC               "QCA-ATH10K"
  52 --- a/drivers/net/wireless/ath/ath10k/testmode.c
  53 +++ b/drivers/net/wireless/ath/ath10k/testmode.c
  54 @@ -139,11 +139,181 @@ static int ath10k_tm_cmd_get_version(str
  55         return cfg80211_testmode_reply(skb);
  56  }
  57
  58 -static int ath10k_tm_cmd_utf_start(struct ath10k *ar, struct nlattr *tb[])
  59 +static int ath10k_tm_fetch_utf_firmware_api_2(struct ath10k *ar)
  60 +{
  61 +       size_t len, magic_len, ie_len;
  62 +       struct ath10k_fw_ie *hdr;
  63 +       char filename[100];
  64 +       __le32 *version;
  65 +       const u8 *data;
  66 +       int ie_id, ret;
  67 +
  68 +       snprintf(filename, sizeof(filename), "%s/%s",
  69 +                ar->hw_params.fw.dir, ATH10K_FW_UTF_API2_FILE);
  70 +
  71 +       /* load utf firmware image */
  72 +       ret = request_firmware(&ar->testmode.utf, filename, ar->dev);
  73 +       if (ret) {
  74 +               ath10k_warn(ar, "failed to retrieve utf firmware '%s': %d\n",
  75 +                           filename, ret);
  76 +               return ret;
  77 +       }
  78 +
  79 +       data = ar->testmode.utf->data;
  80 +       len = ar->testmode.utf->size;
  81 +
  82 +       /* FIXME: call release_firmware() in error cases */
  83 +
  84 +       /* magic also includes the null byte, check that as well */
  85 +       magic_len = strlen(ATH10K_FIRMWARE_MAGIC) + 1;
  86 +
  87 +       if (len < magic_len) {
  88 +               ath10k_err(ar, "utf firmware file is too small to contain magic\n");
  89 +               ret = -EINVAL;
  90 +               goto err;
  91 +       }
  92 +
  93 +       if (memcmp(data, ATH10K_FIRMWARE_MAGIC, magic_len) != 0) {
  94 +               ath10k_err(ar, "invalid firmware magic\n");
  95 +               ret = -EINVAL;
  96 +               goto err;
  97 +       }
  98 +
  99 +       /* jump over the padding */
 100 +       magic_len = ALIGN(magic_len, 4);
 101 +
 102 +       len -= magic_len;
 103 +       data += magic_len;
 104 +
 105 +       /* loop elements */
 106 +       while (len > sizeof(struct ath10k_fw_ie)) {
 107 +               hdr = (struct ath10k_fw_ie *)data;
 108 +
 109 +               ie_id = le32_to_cpu(hdr->id);
 110 +               ie_len = le32_to_cpu(hdr->len);
 111 +
 112 +               len -= sizeof(*hdr);
 113 +               data += sizeof(*hdr);
 114 +
 115 +               if (len < ie_len) {
 116 +                       ath10k_err(ar, "invalid length for FW IE %d (%zu < %zu)\n",
 117 +                                  ie_id, len, ie_len);
 118 +                       ret = -EINVAL;
 119 +                       goto err;
 120 +               }
 121 +
 122 +               switch (ie_id) {
 123 +               case ATH10K_FW_IE_FW_VERSION:
 124 +                       if (ie_len > sizeof(ar->testmode.utf_version) - 1)
 125 +                               break;
 126 +
 127 +                       memcpy(ar->testmode.utf_version, data, ie_len);
 128 +                       ar->testmode.utf_version[ie_len] = '\0';
 129 +
 130 +                       ath10k_dbg(ar, ATH10K_DBG_TESTMODE,
 131 +                                  "testmode found fw utf version %s\n",
 132 +                                  ar->testmode.utf_version);
 133 +                       break;
 134 +               case ATH10K_FW_IE_TIMESTAMP:
 135 +                       /* ignore timestamp, but don't warn about it either */
 136 +                       break;
 137 +               case ATH10K_FW_IE_FW_IMAGE:
 138 +                       ath10k_dbg(ar, ATH10K_DBG_TESTMODE,
 139 +                                  "testmode found fw image ie (%zd B)\n",
 140 +                                  ie_len);
 141 +
 142 +                       ar->testmode.utf_firmware_data = data;
 143 +                       ar->testmode.utf_firmware_len = ie_len;
 144 +                       break;
 145 +               case ATH10K_FW_IE_WMI_OP_VERSION:
 146 +                       if (ie_len != sizeof(u32))
 147 +                               break;
 148 +                       version = (__le32 *)data;
 149 +                       ar->testmode.op_version = le32_to_cpup(version);
 150 +                       ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode found fw ie wmi op version %d\n",
 151 +                                  ar->testmode.op_version);
 152 +                       break;
 153 +               default:
 154 +                       ath10k_warn(ar, "Unknown testmode FW IE: %u\n",
 155 +                                   le32_to_cpu(hdr->id));
 156 +                       break;
 157 +               }
 158 +               /* jump over the padding */
 159 +               ie_len = ALIGN(ie_len, 4);
 160 +
 161 +               len -= ie_len;
 162 +               data += ie_len;
 163 +       }
 164 +
 165 +       if (!ar->testmode.utf_firmware_data || !ar->testmode.utf_firmware_len) {
 166 +               ath10k_err(ar, "No ATH10K_FW_IE_FW_IMAGE found\n");
 167 +               ret = -EINVAL;
 168 +               goto err;
 169 +       }
 170 +
 171 +       return 0;
 172 +
 173 +err:
 174 +       release_firmware(ar->testmode.utf);
 175 +
 176 +       return ret;
 177 +}
 178 +
 179 +static int ath10k_tm_fetch_utf_firmware_api_1(struct ath10k *ar)
 180  {
 181         char filename[100];
 182         int ret;
 183
 184 +       snprintf(filename, sizeof(filename), "%s/%s",
 185 +                ar->hw_params.fw.dir, ATH10K_FW_UTF_FILE);
 186 +
 187 +       /* load utf firmware image */
 188 +       ret = request_firmware(&ar->testmode.utf, filename, ar->dev);
 189 +       if (ret) {
 190 +               ath10k_warn(ar, "failed to retrieve utf firmware '%s': %d\n",
 191 +                           filename, ret);
 192 +               return ret;
 193 +       }
 194 +
 195 +       /* We didn't find FW UTF API 1 ("utf.bin") does not advertise
 196 +        * firmware features. Do an ugly hack where we force the firmware
 197 +        * features to match with 10.1 branch so that wmi.c will use the
 198 +        * correct WMI interface.
 199 +        */
 200 +
 201 +       ar->testmode.op_version = ATH10K_FW_WMI_OP_VERSION_10_1;
 202 +       ar->testmode.utf_firmware_data = ar->testmode.utf->data;
 203 +       ar->testmode.utf_firmware_len = ar->testmode.utf->size;
 204 +
 205 +       return 0;
 206 +}
 207 +
 208 +static int ath10k_tm_fetch_firmware(struct ath10k *ar)
 209 +{
 210 +       int ret;
 211 +
 212 +       ret = ath10k_tm_fetch_utf_firmware_api_2(ar);
 213 +       if (ret == 0) {
 214 +               ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode using fw utf api 2");
 215 +               return 0;
 216 +       }
 217 +
 218 +       ret = ath10k_tm_fetch_utf_firmware_api_1(ar);
 219 +       if (ret) {
 220 +               ath10k_err(ar, "failed to fetch utf firmware binary: %d", ret);
 221 +               return ret;
 222 +       }
 223 +
 224 +       ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode using utf api 1");
 225 +
 226 +       return 0;
 227 +}
 228 +
 229 +static int ath10k_tm_cmd_utf_start(struct ath10k *ar, struct nlattr *tb[])
 230 +{
 231 +       const char *ver;
 232 +       int ret;
 233 +
 234         ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode cmd utf start\n");
 235
 236         mutex_lock(&ar->conf_mutex);
 237 @@ -165,36 +335,27 @@ static int ath10k_tm_cmd_utf_start(struc
 238                 goto err;
 239         }
 240
 241 -       snprintf(filename, sizeof(filename), "%s/%s",
 242 -                ar->hw_params.fw.dir, ATH10K_FW_UTF_FILE);
 243 -
 244 -       /* load utf firmware image */
 245 -       ret = request_firmware(&ar->testmode.utf, filename, ar->dev);
 246 +       ret = ath10k_tm_fetch_firmware(ar);
 247         if (ret) {
 248 -               ath10k_warn(ar, "failed to retrieve utf firmware '%s': %d\n",
 249 -                           filename, ret);
 250 +               ath10k_err(ar, "failed to fetch UTF firmware: %d", ret);
 251                 goto err;
 252         }
 253
 254         spin_lock_bh(&ar->data_lock);
 255 -
 256         ar->testmode.utf_monitor = true;
 257 -
 258         spin_unlock_bh(&ar->data_lock);
 259 -
 260         BUILD_BUG_ON(sizeof(ar->fw_features) !=
 261                      sizeof(ar->testmode.orig_fw_features));
 262
 263         memcpy(ar->testmode.orig_fw_features, ar->fw_features,
 264                sizeof(ar->fw_features));
 265         ar->testmode.orig_wmi_op_version = ar->wmi.op_version;
 266 -
 267 -       /* utf.bin firmware image does not advertise firmware features. Do
 268 -        * an ugly hack where we force the firmware features so that wmi.c
 269 -        * will use the correct WMI interface.
 270 -        */
 271         memset(ar->fw_features, 0, sizeof(ar->fw_features));
 272 -       ar->wmi.op_version = ATH10K_FW_WMI_OP_VERSION_10_1;
 273 +
 274 +       ar->wmi.op_version = ar->testmode.op_version;
 275 +
 276 +       ath10k_dbg(ar, ATH10K_DBG_TESTMODE, "testmode wmi version %d\n",
 277 +                  ar->wmi.op_version);
 278
 279         ret = ath10k_hif_power_up(ar);
 280         if (ret) {
 281 @@ -212,7 +373,12 @@ static int ath10k_tm_cmd_utf_start(struc
 282
 283         ar->state = ATH10K_STATE_UTF;
 284
 285 -       ath10k_info(ar, "UTF firmware started\n");
 286 +       if (strlen(ar->testmode.utf_version) > 0)
 287 +               ver = ar->testmode.utf_version;
 288 +       else
 289 +               ver = "API 1";
 290 +
 291 +       ath10k_info(ar, "UTF firmware %s started\n", ver);
 292
 293         mutex_unlock(&ar->conf_mutex);
 294
 295 --- a/drivers/net/wireless/ath/ath10k/wmi-tlv.c
 296 +++ b/drivers/net/wireless/ath/ath10k/wmi-tlv.c
 297 @@ -23,6 +23,7 @@
 298  #include "wmi-ops.h"
 299  #include "wmi-tlv.h"
 300  #include "p2p.h"
 301 +#include "testmode.h"
 302
 303  /***************/
 304  /* TLV helpers */
 305 @@ -419,6 +420,7 @@ static void ath10k_wmi_tlv_op_rx(struct
 306  {
 307         struct wmi_cmd_hdr *cmd_hdr;
 308         enum wmi_tlv_event_id id;
 309 +       bool consumed;
 310
 311         cmd_hdr = (struct wmi_cmd_hdr *)skb->data;
 312         id = MS(__le32_to_cpu(cmd_hdr->cmd_id), WMI_CMD_HDR_CMD_ID);
 313 @@ -428,6 +430,18 @@ static void ath10k_wmi_tlv_op_rx(struct
 314
 315         trace_ath10k_wmi_event(ar, id, skb->data, skb->len);
 316
 317 +       consumed = ath10k_tm_event_wmi(ar, id, skb);
 318 +
 319 +       /* Ready event must be handled normally also in UTF mode so that we
 320 +        * know the UTF firmware has booted, others we are just bypass WMI
 321 +        * events to testmode.
 322 +        */
 323 +       if (consumed && id != WMI_TLV_READY_EVENTID) {
 324 +               ath10k_dbg(ar, ATH10K_DBG_WMI,
 325 +                          "wmi tlv testmode consumed 0x%x\n", id);
 326 +               goto out;
 327 +       }
 328 +
 329         switch (id) {
 330         case WMI_TLV_MGMT_RX_EVENTID:
 331                 ath10k_wmi_event_mgmt_rx(ar, skb);