drivers/net/wireless/mediatek/mt76/mt7603/mcu.c

   1 // SPDX-License-Identifier: ISC
   2
   3 #include <linux/firmware.h>
   4 #include "mt7603.h"
   5 #include "mcu.h"
   6 #include "eeprom.h"
   7
   8 #define MCU_SKB_RESERVE 8
   9
  10 struct mt7603_fw_trailer {
  11         char fw_ver[10];
  12         char build_date[15];
  13         __le32 dl_len;
  14 } __packed;
  15
  16 static int
  17 mt7603_mcu_parse_response(struct mt76_dev *mdev, int cmd,
  18                           struct sk_buff *skb, int seq)
  19 {
  20         struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
  21         struct mt7603_mcu_rxd *rxd;
  22
  23         if (!skb) {
  24                 dev_err(mdev->dev,
  25                         "MCU message %d (seq %d) timed out\n",
  26                         cmd, seq);
  27                 dev->mcu_hang = MT7603_WATCHDOG_TIMEOUT;
  28                 return -ETIMEDOUT;
  29         }
  30
  31         rxd = (struct mt7603_mcu_rxd *)skb->data;
  32         if (seq != rxd->seq)
  33                 return -EAGAIN;
  34
  35         return 0;
  36 }
  37
  38 static int
  39 __mt7603_mcu_msg_send(struct mt7603_dev *dev, struct sk_buff *skb,
  40                       int cmd, int *wait_seq)
  41 {
  42         int hdrlen = dev->mcu_running ? sizeof(struct mt7603_mcu_txd) : 12;
  43         struct mt76_dev *mdev = &dev->mt76;
  44         struct mt7603_mcu_txd *txd;
  45         u8 seq;
  46
  47         seq = ++mdev->mcu.msg_seq & 0xf;
  48         if (!seq)
  49                 seq = ++mdev->mcu.msg_seq & 0xf;
  50
  51         txd = (struct mt7603_mcu_txd *)skb_push(skb, hdrlen);
  52
  53         txd->len = cpu_to_le16(skb->len);
  54         if (cmd == -MCU_CMD_FW_SCATTER)
  55                 txd->pq_id = cpu_to_le16(MCU_PORT_QUEUE_FW);
  56         else
  57                 txd->pq_id = cpu_to_le16(MCU_PORT_QUEUE);
  58         txd->pkt_type = MCU_PKT_ID;
  59         txd->seq = seq;
  60
  61         if (cmd < 0) {
  62                 txd->cid = -cmd;
  63                 txd->set_query = MCU_Q_NA;
  64         } else {
  65                 txd->cid = MCU_CMD_EXT_CID;
  66                 txd->ext_cid = cmd;
  67                 txd->set_query = MCU_Q_SET;
  68                 txd->ext_cid_ack = 1;
  69         }
  70
  71         if (wait_seq)
  72                 *wait_seq = seq;
  73
  74         return mt76_tx_queue_skb_raw(dev, MT_TXQ_MCU, skb, 0);
  75 }
  76
  77 static int
  78 mt7603_mcu_msg_send(struct mt76_dev *mdev, int cmd, const void *data,
  79                     int len, bool wait_resp)
  80 {
  81         struct mt7603_dev *dev = container_of(mdev, struct mt7603_dev, mt76);
  82         unsigned long expires = jiffies + 3 * HZ;
  83         struct sk_buff *skb;
  84         int ret, seq;
  85
  86         skb = mt76_mcu_msg_alloc(mdev, data, len);
  87         if (!skb)
  88                 return -ENOMEM;
  89
  90         mutex_lock(&mdev->mcu.mutex);
  91
  92         ret = __mt7603_mcu_msg_send(dev, skb, cmd, &seq);
  93         if (ret)
  94                 goto out;
  95
  96         while (wait_resp) {
  97                 skb = mt76_mcu_get_response(&dev->mt76, expires);
  98                 ret = mt7603_mcu_parse_response(mdev, cmd, skb, seq);
  99                 dev_kfree_skb(skb);
 100                 if (ret != -EAGAIN)
 101                         break;
 102         }
 103
 104 out:
 105         mutex_unlock(&mdev->mcu.mutex);
 106
 107         return ret;
 108 }
 109
 110 static int
 111 mt7603_mcu_init_download(struct mt7603_dev *dev, u32 addr, u32 len)
 112 {
 113         struct {
 114                 __le32 addr;
 115                 __le32 len;
 116                 __le32 mode;
 117         } req = {
 118                 .addr = cpu_to_le32(addr),
 119                 .len = cpu_to_le32(len),
 120                 .mode = cpu_to_le32(BIT(31)),
 121         };
 122
 123         return mt76_mcu_send_msg(&dev->mt76, -MCU_CMD_TARGET_ADDRESS_LEN_REQ,
 124                                  &req, sizeof(req), true);
 125 }
 126
 127 static int
 128 mt7603_mcu_send_firmware(struct mt7603_dev *dev, const void *data, int len)
 129 {
 130         int cur_len, ret = 0;
 131
 132         while (len > 0) {
 133                 cur_len = min_t(int, 4096 - sizeof(struct mt7603_mcu_txd),
 134                                 len);
 135
 136                 ret = mt76_mcu_send_msg(&dev->mt76, -MCU_CMD_FW_SCATTER, data,
 137                                         cur_len, false);
 138                 if (ret)
 139                         break;
 140
 141                 data += cur_len;
 142                 len -= cur_len;
 143         }
 144
 145         return ret;
 146 }
 147
 148 static int
 149 mt7603_mcu_start_firmware(struct mt7603_dev *dev, u32 addr)
 150 {
 151         struct {
 152                 __le32 override;
 153                 __le32 addr;
 154         } req = {
 155                 .override = cpu_to_le32(addr ? 1 : 0),
 156                 .addr = cpu_to_le32(addr),
 157         };
 158
 159         return mt76_mcu_send_msg(&dev->mt76, -MCU_CMD_FW_START_REQ, &req,
 160                                  sizeof(req), true);
 161 }
 162
 163 static int
 164 mt7603_mcu_restart(struct mt76_dev *dev)
 165 {
 166         return mt76_mcu_send_msg(dev, -MCU_CMD_RESTART_DL_REQ, NULL, 0, true);
 167 }
 168
 169 static int mt7603_load_firmware(struct mt7603_dev *dev)
 170 {
 171         const struct firmware *fw;
 172         const struct mt7603_fw_trailer *hdr;
 173         const char *firmware;
 174         int dl_len;
 175         u32 addr, val;
 176         int ret;
 177
 178         if (is_mt7628(dev)) {
 179                 if (mt76xx_rev(dev) == MT7628_REV_E1)
 180                         firmware = MT7628_FIRMWARE_E1;
 181                 else
 182                         firmware = MT7628_FIRMWARE_E2;
 183         } else {
 184                 if (mt76xx_rev(dev) < MT7603_REV_E2)
 185                         firmware = MT7603_FIRMWARE_E1;
 186                 else
 187                         firmware = MT7603_FIRMWARE_E2;
 188         }
 189
 190         ret = request_firmware(&fw, firmware, dev->mt76.dev);
 191         if (ret)
 192                 return ret;
 193
 194         if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
 195                 dev_err(dev->mt76.dev, "Invalid firmware\n");
 196                 ret = -EINVAL;
 197                 goto out;
 198         }
 199
 200         hdr = (const struct mt7603_fw_trailer *)(fw->data + fw->size -
 201                                                  sizeof(*hdr));
 202
 203         dev_info(dev->mt76.dev, "Firmware Version: %.10s\n", hdr->fw_ver);
 204         dev_info(dev->mt76.dev, "Build Time: %.15s\n", hdr->build_date);
 205
 206         addr = mt7603_reg_map(dev, 0x50012498);
 207         mt76_wr(dev, addr, 0x5);
 208         mt76_wr(dev, addr, 0x5);
 209         udelay(1);
 210
 211         /* switch to bypass mode */
 212         mt76_rmw(dev, MT_SCH_4, MT_SCH_4_FORCE_QID,
 213                  MT_SCH_4_BYPASS | FIELD_PREP(MT_SCH_4_FORCE_QID, 5));
 214
 215         val = mt76_rr(dev, MT_TOP_MISC2);
 216         if (val & BIT(1)) {
 217                 dev_info(dev->mt76.dev, "Firmware already running...\n");
 218                 goto running;
 219         }
 220
 221         if (!mt76_poll_msec(dev, MT_TOP_MISC2, BIT(0) | BIT(1), BIT(0), 500)) {
 222                 dev_err(dev->mt76.dev, "Timeout waiting for ROM code to become ready\n");
 223                 ret = -EIO;
 224                 goto out;
 225         }
 226
 227         dl_len = le32_to_cpu(hdr->dl_len) + 4;
 228         ret = mt7603_mcu_init_download(dev, MCU_FIRMWARE_ADDRESS, dl_len);
 229         if (ret) {
 230                 dev_err(dev->mt76.dev, "Download request failed\n");
 231                 goto out;
 232         }
 233
 234         ret = mt7603_mcu_send_firmware(dev, fw->data, dl_len);
 235         if (ret) {
 236                 dev_err(dev->mt76.dev, "Failed to send firmware to device\n");
 237                 goto out;
 238         }
 239
 240         ret = mt7603_mcu_start_firmware(dev, MCU_FIRMWARE_ADDRESS);
 241         if (ret) {
 242                 dev_err(dev->mt76.dev, "Failed to start firmware\n");
 243                 goto out;
 244         }
 245
 246         if (!mt76_poll_msec(dev, MT_TOP_MISC2, BIT(1), BIT(1), 500)) {
 247                 dev_err(dev->mt76.dev, "Timeout waiting for firmware to initialize\n");
 248                 ret = -EIO;
 249                 goto out;
 250         }
 251
 252 running:
 253         mt76_clear(dev, MT_SCH_4, MT_SCH_4_FORCE_QID | MT_SCH_4_BYPASS);
 254
 255         mt76_set(dev, MT_SCH_4, BIT(8));
 256         mt76_clear(dev, MT_SCH_4, BIT(8));
 257
 258         dev->mcu_running = true;
 259         snprintf(dev->mt76.hw->wiphy->fw_version,
 260                  sizeof(dev->mt76.hw->wiphy->fw_version),
 261                  "%.10s-%.15s", hdr->fw_ver, hdr->build_date);
 262         dev_info(dev->mt76.dev, "firmware init done\n");
 263
 264 out:
 265         release_firmware(fw);
 266
 267         return ret;
 268 }
 269
 270 int mt7603_mcu_init(struct mt7603_dev *dev)
 271 {
 272         static const struct mt76_mcu_ops mt7603_mcu_ops = {
 273                 .headroom = sizeof(struct mt7603_mcu_txd),
 274                 .mcu_send_msg = mt7603_mcu_msg_send,
 275                 .mcu_parse_response = mt7603_mcu_parse_response,
 276                 .mcu_restart = mt7603_mcu_restart,
 277         };
 278
 279         dev->mt76.mcu_ops = &mt7603_mcu_ops;
 280         return mt7603_load_firmware(dev);
 281 }
 282
 283 void mt7603_mcu_exit(struct mt7603_dev *dev)
 284 {
 285         __mt76_mcu_restart(&dev->mt76);
 286         skb_queue_purge(&dev->mt76.mcu.res_q);
 287 }
 288
 289 int mt7603_mcu_set_eeprom(struct mt7603_dev *dev)
 290 {
 291         static const u16 req_fields[] = {
 292 #define WORD(_start)                    \
 293                 _start,                 \
 294                 _start + 1
 295 #define GROUP_2G(_start)                \
 296                 WORD(_start),           \
 297                 WORD(_start + 2),       \
 298                 WORD(_start + 4)
 299
 300                 MT_EE_NIC_CONF_0 + 1,
 301                 WORD(MT_EE_NIC_CONF_1),
 302                 MT_EE_WIFI_RF_SETTING,
 303                 MT_EE_TX_POWER_DELTA_BW40,
 304                 MT_EE_TX_POWER_DELTA_BW80 + 1,
 305                 MT_EE_TX_POWER_EXT_PA_5G,
 306                 MT_EE_TEMP_SENSOR_CAL,
 307                 GROUP_2G(MT_EE_TX_POWER_0_START_2G),
 308                 GROUP_2G(MT_EE_TX_POWER_1_START_2G),
 309                 WORD(MT_EE_TX_POWER_CCK),
 310                 WORD(MT_EE_TX_POWER_OFDM_2G_6M),
 311                 WORD(MT_EE_TX_POWER_OFDM_2G_24M),
 312                 WORD(MT_EE_TX_POWER_OFDM_2G_54M),
 313                 WORD(MT_EE_TX_POWER_HT_BPSK_QPSK),
 314                 WORD(MT_EE_TX_POWER_HT_16_64_QAM),
 315                 WORD(MT_EE_TX_POWER_HT_64_QAM),
 316                 MT_EE_ELAN_RX_MODE_GAIN,
 317                 MT_EE_ELAN_RX_MODE_NF,
 318                 MT_EE_ELAN_RX_MODE_P1DB,
 319                 MT_EE_ELAN_BYPASS_MODE_GAIN,
 320                 MT_EE_ELAN_BYPASS_MODE_NF,
 321                 MT_EE_ELAN_BYPASS_MODE_P1DB,
 322                 WORD(MT_EE_STEP_NUM_NEG_6_7),
 323                 WORD(MT_EE_STEP_NUM_NEG_4_5),
 324                 WORD(MT_EE_STEP_NUM_NEG_2_3),
 325                 WORD(MT_EE_STEP_NUM_NEG_0_1),
 326                 WORD(MT_EE_REF_STEP_24G),
 327                 WORD(MT_EE_STEP_NUM_PLUS_1_2),
 328                 WORD(MT_EE_STEP_NUM_PLUS_3_4),
 329                 WORD(MT_EE_STEP_NUM_PLUS_5_6),
 330                 MT_EE_STEP_NUM_PLUS_7,
 331                 MT_EE_XTAL_FREQ_OFFSET,
 332                 MT_EE_XTAL_TRIM_2_COMP,
 333                 MT_EE_XTAL_TRIM_3_COMP,
 334                 MT_EE_XTAL_WF_RFCAL,
 335
 336                 /* unknown fields below */
 337                 WORD(0x24),
 338                 0x34,
 339                 0x39,
 340                 0x3b,
 341                 WORD(0x42),
 342                 WORD(0x9e),
 343                 0xf2,
 344                 WORD(0xf8),
 345                 0xfa,
 346                 0x12e,
 347                 WORD(0x130), WORD(0x132), WORD(0x134), WORD(0x136),
 348                 WORD(0x138), WORD(0x13a), WORD(0x13c), WORD(0x13e),
 349
 350 #undef GROUP_2G
 351 #undef WORD
 352
 353         };
 354         struct req_data {
 355                 __le16 addr;
 356                 u8 val;
 357                 u8 pad;
 358         } __packed;
 359         struct {
 360                 u8 buffer_mode;
 361                 u8 len;
 362                 u8 pad[2];
 363         } req_hdr = {
 364                 .buffer_mode = 1,
 365                 .len = ARRAY_SIZE(req_fields) - 1,
 366         };
 367         const int size = 0xff * sizeof(struct req_data);
 368         u8 *req, *eep = (u8 *)dev->mt76.eeprom.data;
 369         int i, ret, len = sizeof(req_hdr) + size;
 370         struct req_data *data;
 371
 372         BUILD_BUG_ON(ARRAY_SIZE(req_fields) * sizeof(*data) > size);
 373
 374         req = kmalloc(len, GFP_KERNEL);
 375         if (!req)
 376                 return -ENOMEM;
 377
 378         memcpy(req, &req_hdr, sizeof(req_hdr));
 379         data = (struct req_data *)(req + sizeof(req_hdr));
 380         memset(data, 0, size);
 381         for (i = 0; i < ARRAY_SIZE(req_fields); i++) {
 382                 data[i].addr = cpu_to_le16(req_fields[i]);
 383                 data[i].val = eep[req_fields[i]];
 384         }
 385
 386         ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_BUFFER_MODE,
 387                                 req, len, true);
 388         kfree(req);
 389
 390         return ret;
 391 }
 392
 393 static int mt7603_mcu_set_tx_power(struct mt7603_dev *dev)
 394 {
 395         struct {
 396                 u8 center_channel;
 397                 u8 tssi;
 398                 u8 temp_comp;
 399                 u8 target_power[2];
 400                 u8 rate_power_delta[14];
 401                 u8 bw_power_delta;
 402                 u8 ch_power_delta[6];
 403                 u8 temp_comp_power[17];
 404                 u8 reserved;
 405         } req = {
 406                 .center_channel = dev->mphy.chandef.chan->hw_value,
 407 #define EEP_VAL(n) ((u8 *)dev->mt76.eeprom.data)[n]
 408                 .tssi = EEP_VAL(MT_EE_NIC_CONF_1 + 1),
 409                 .temp_comp = EEP_VAL(MT_EE_NIC_CONF_1),
 410                 .target_power = {
 411                         EEP_VAL(MT_EE_TX_POWER_0_START_2G + 2),
 412                         EEP_VAL(MT_EE_TX_POWER_1_START_2G + 2)
 413                 },
 414                 .bw_power_delta = EEP_VAL(MT_EE_TX_POWER_DELTA_BW40),
 415                 .ch_power_delta = {
 416                         EEP_VAL(MT_EE_TX_POWER_0_START_2G + 3),
 417                         EEP_VAL(MT_EE_TX_POWER_0_START_2G + 4),
 418                         EEP_VAL(MT_EE_TX_POWER_0_START_2G + 5),
 419                         EEP_VAL(MT_EE_TX_POWER_1_START_2G + 3),
 420                         EEP_VAL(MT_EE_TX_POWER_1_START_2G + 4),
 421                         EEP_VAL(MT_EE_TX_POWER_1_START_2G + 5)
 422                 },
 423 #undef EEP_VAL
 424         };
 425         u8 *eep = (u8 *)dev->mt76.eeprom.data;
 426
 427         memcpy(req.rate_power_delta, eep + MT_EE_TX_POWER_CCK,
 428                sizeof(req.rate_power_delta));
 429
 430         memcpy(req.temp_comp_power, eep + MT_EE_STEP_NUM_NEG_6_7,
 431                sizeof(req.temp_comp_power));
 432
 433         return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_SET_TX_POWER_CTRL,
 434                                  &req, sizeof(req), true);
 435 }
 436
 437 int mt7603_mcu_set_channel(struct mt7603_dev *dev)
 438 {
 439         struct cfg80211_chan_def *chandef = &dev->mphy.chandef;
 440         struct ieee80211_hw *hw = mt76_hw(dev);
 441         int n_chains = hweight8(dev->mphy.antenna_mask);
 442         struct {
 443                 u8 control_chan;
 444                 u8 center_chan;
 445                 u8 bw;
 446                 u8 tx_streams;
 447                 u8 rx_streams;
 448                 u8 _res0[7];
 449                 u8 txpower[21];
 450                 u8 _res1[3];
 451         } req = {
 452                 .control_chan = chandef->chan->hw_value,
 453                 .center_chan = chandef->chan->hw_value,
 454                 .bw = MT_BW_20,
 455                 .tx_streams = n_chains,
 456                 .rx_streams = n_chains,
 457         };
 458         s8 tx_power;
 459         int i, ret;
 460
 461         if (dev->mphy.chandef.width == NL80211_CHAN_WIDTH_40) {
 462                 req.bw = MT_BW_40;
 463                 if (chandef->center_freq1 > chandef->chan->center_freq)
 464                         req.center_chan += 2;
 465                 else
 466                         req.center_chan -= 2;
 467         }
 468
 469         tx_power = hw->conf.power_level * 2;
 470         if (dev->mphy.antenna_mask == 3)
 471                 tx_power -= 6;
 472         tx_power = min(tx_power, dev->tx_power_limit);
 473
 474         dev->mphy.txpower_cur = tx_power;
 475
 476         for (i = 0; i < ARRAY_SIZE(req.txpower); i++)
 477                 req.txpower[i] = tx_power;
 478
 479         ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_CHANNEL_SWITCH, &req,
 480                                 sizeof(req), true);
 481         if (ret)
 482                 return ret;
 483
 484         return mt7603_mcu_set_tx_power(dev);
 485 }