drivers/net/wireless/realtek/rtw88/fw.c

   1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2 /* Copyright(c) 2018-2019  Realtek Corporation
   3  */
   4
   5 #include "main.h"
   6 #include "coex.h"
   7 #include "fw.h"
   8 #include "tx.h"
   9 #include "reg.h"
  10 #include "sec.h"
  11 #include "debug.h"
  12 #include "util.h"
  13
  14 static void rtw_fw_c2h_cmd_handle_ext(struct rtw_dev *rtwdev,
  15                                       struct sk_buff *skb)
  16 {
  17         struct rtw_c2h_cmd *c2h;
  18         u8 sub_cmd_id;
  19
  20         c2h = get_c2h_from_skb(skb);
  21         sub_cmd_id = c2h->payload[0];
  22
  23         switch (sub_cmd_id) {
  24         case C2H_CCX_RPT:
  25                 rtw_tx_report_handle(rtwdev, skb);
  26                 break;
  27         default:
  28                 break;
  29         }
  30 }
  31
  32 static u16 get_max_amsdu_len(u32 bit_rate)
  33 {
  34         /* lower than ofdm, do not aggregate */
  35         if (bit_rate < 550)
  36                 return 1;
  37
  38         /* lower than 20M 2ss mcs8, make it small */
  39         if (bit_rate < 1800)
  40                 return 1200;
  41
  42         /* lower than 40M 2ss mcs9, make it medium */
  43         if (bit_rate < 4000)
  44                 return 2600;
  45
  46         /* not yet 80M 2ss mcs8/9, make it twice regular packet size */
  47         if (bit_rate < 7000)
  48                 return 3500;
  49
  50         /* unlimited */
  51         return 0;
  52 }
  53
  54 struct rtw_fw_iter_ra_data {
  55         struct rtw_dev *rtwdev;
  56         u8 *payload;
  57 };
  58
  59 static void rtw_fw_ra_report_iter(void *data, struct ieee80211_sta *sta)
  60 {
  61         struct rtw_fw_iter_ra_data *ra_data = data;
  62         struct rtw_sta_info *si = (struct rtw_sta_info *)sta->drv_priv;
  63         u8 mac_id, rate, sgi, bw;
  64         u8 mcs, nss;
  65         u32 bit_rate;
  66
  67         mac_id = GET_RA_REPORT_MACID(ra_data->payload);
  68         if (si->mac_id != mac_id)
  69                 return;
  70
  71         si->ra_report.txrate.flags = 0;
  72
  73         rate = GET_RA_REPORT_RATE(ra_data->payload);
  74         sgi = GET_RA_REPORT_SGI(ra_data->payload);
  75         bw = GET_RA_REPORT_BW(ra_data->payload);
  76
  77         if (rate < DESC_RATEMCS0) {
  78                 si->ra_report.txrate.legacy = rtw_desc_to_bitrate(rate);
  79                 goto legacy;
  80         }
  81
  82         rtw_desc_to_mcsrate(rate, &mcs, &nss);
  83         if (rate >= DESC_RATEVHT1SS_MCS0)
  84                 si->ra_report.txrate.flags |= RATE_INFO_FLAGS_VHT_MCS;
  85         else if (rate >= DESC_RATEMCS0)
  86                 si->ra_report.txrate.flags |= RATE_INFO_FLAGS_MCS;
  87
  88         if (rate >= DESC_RATEMCS0) {
  89                 si->ra_report.txrate.mcs = mcs;
  90                 si->ra_report.txrate.nss = nss;
  91         }
  92
  93         if (sgi)
  94                 si->ra_report.txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
  95
  96         if (bw == RTW_CHANNEL_WIDTH_80)
  97                 si->ra_report.txrate.bw = RATE_INFO_BW_80;
  98         else if (bw == RTW_CHANNEL_WIDTH_40)
  99                 si->ra_report.txrate.bw = RATE_INFO_BW_40;
 100         else
 101                 si->ra_report.txrate.bw = RATE_INFO_BW_20;
 102
 103 legacy:
 104         bit_rate = cfg80211_calculate_bitrate(&si->ra_report.txrate);
 105
 106         si->ra_report.desc_rate = rate;
 107         si->ra_report.bit_rate = bit_rate;
 108
 109         sta->max_rc_amsdu_len = get_max_amsdu_len(bit_rate);
 110 }
 111
 112 static void rtw_fw_ra_report_handle(struct rtw_dev *rtwdev, u8 *payload,
 113                                     u8 length)
 114 {
 115         struct rtw_fw_iter_ra_data ra_data;
 116
 117         if (WARN(length < 7, "invalid ra report c2h length\n"))
 118                 return;
 119
 120         ra_data.rtwdev = rtwdev;
 121         ra_data.payload = payload;
 122         rtw_iterate_stas_atomic(rtwdev, rtw_fw_ra_report_iter, &ra_data);
 123 }
 124
 125 void rtw_fw_c2h_cmd_handle(struct rtw_dev *rtwdev, struct sk_buff *skb)
 126 {
 127         struct rtw_c2h_cmd *c2h;
 128         u32 pkt_offset;
 129         u8 len;
 130
 131         pkt_offset = *((u32 *)skb->cb);
 132         c2h = (struct rtw_c2h_cmd *)(skb->data + pkt_offset);
 133         len = skb->len - pkt_offset - 2;
 134
 135         mutex_lock(&rtwdev->mutex);
 136
 137         switch (c2h->id) {
 138         case C2H_BT_INFO:
 139                 rtw_coex_bt_info_notify(rtwdev, c2h->payload, len);
 140                 break;
 141         case C2H_WLAN_INFO:
 142                 rtw_coex_wl_fwdbginfo_notify(rtwdev, c2h->payload, len);
 143                 break;
 144         case C2H_HALMAC:
 145                 rtw_fw_c2h_cmd_handle_ext(rtwdev, skb);
 146                 break;
 147         case C2H_RA_RPT:
 148                 rtw_fw_ra_report_handle(rtwdev, c2h->payload, len);
 149                 break;
 150         default:
 151                 break;
 152         }
 153
 154         mutex_unlock(&rtwdev->mutex);
 155 }
 156
 157 void rtw_fw_c2h_cmd_rx_irqsafe(struct rtw_dev *rtwdev, u32 pkt_offset,
 158                                struct sk_buff *skb)
 159 {
 160         struct rtw_c2h_cmd *c2h;
 161         u8 len;
 162
 163         c2h = (struct rtw_c2h_cmd *)(skb->data + pkt_offset);
 164         len = skb->len - pkt_offset - 2;
 165         *((u32 *)skb->cb) = pkt_offset;
 166
 167         rtw_dbg(rtwdev, RTW_DBG_FW, "recv C2H, id=0x%02x, seq=0x%02x, len=%d\n",
 168                 c2h->id, c2h->seq, len);
 169
 170         switch (c2h->id) {
 171         case C2H_BT_MP_INFO:
 172                 rtw_coex_info_response(rtwdev, skb);
 173                 break;
 174         default:
 175                 /* pass offset for further operation */
 176                 *((u32 *)skb->cb) = pkt_offset;
 177                 skb_queue_tail(&rtwdev->c2h_queue, skb);
 178                 ieee80211_queue_work(rtwdev->hw, &rtwdev->c2h_work);
 179                 break;
 180         }
 181 }
 182 EXPORT_SYMBOL(rtw_fw_c2h_cmd_rx_irqsafe);
 183
 184 static void rtw_fw_send_h2c_command(struct rtw_dev *rtwdev,
 185                                     u8 *h2c)
 186 {
 187         u8 box;
 188         u8 box_state;
 189         u32 box_reg, box_ex_reg;
 190         u32 h2c_wait;
 191         int idx;
 192
 193         rtw_dbg(rtwdev, RTW_DBG_FW,
 194                 "send H2C content %02x%02x%02x%02x %02x%02x%02x%02x\n",
 195                 h2c[3], h2c[2], h2c[1], h2c[0],
 196                 h2c[7], h2c[6], h2c[5], h2c[4]);
 197
 198         spin_lock(&rtwdev->h2c.lock);
 199
 200         box = rtwdev->h2c.last_box_num;
 201         switch (box) {
 202         case 0:
 203                 box_reg = REG_HMEBOX0;
 204                 box_ex_reg = REG_HMEBOX0_EX;
 205                 break;
 206         case 1:
 207                 box_reg = REG_HMEBOX1;
 208                 box_ex_reg = REG_HMEBOX1_EX;
 209                 break;
 210         case 2:
 211                 box_reg = REG_HMEBOX2;
 212                 box_ex_reg = REG_HMEBOX2_EX;
 213                 break;
 214         case 3:
 215                 box_reg = REG_HMEBOX3;
 216                 box_ex_reg = REG_HMEBOX3_EX;
 217                 break;
 218         default:
 219                 WARN(1, "invalid h2c mail box number\n");
 220                 goto out;
 221         }
 222
 223         h2c_wait = 20;
 224         do {
 225                 box_state = rtw_read8(rtwdev, REG_HMETFR);
 226         } while ((box_state >> box) & 0x1 && --h2c_wait > 0);
 227
 228         if (!h2c_wait) {
 229                 rtw_err(rtwdev, "failed to send h2c command\n");
 230                 goto out;
 231         }
 232
 233         for (idx = 0; idx < 4; idx++)
 234                 rtw_write8(rtwdev, box_reg + idx, h2c[idx]);
 235         for (idx = 0; idx < 4; idx++)
 236                 rtw_write8(rtwdev, box_ex_reg + idx, h2c[idx + 4]);
 237
 238         if (++rtwdev->h2c.last_box_num >= 4)
 239                 rtwdev->h2c.last_box_num = 0;
 240
 241 out:
 242         spin_unlock(&rtwdev->h2c.lock);
 243 }
 244
 245 static void rtw_fw_send_h2c_packet(struct rtw_dev *rtwdev, u8 *h2c_pkt)
 246 {
 247         int ret;
 248
 249         spin_lock(&rtwdev->h2c.lock);
 250
 251         FW_OFFLOAD_H2C_SET_SEQ_NUM(h2c_pkt, rtwdev->h2c.seq);
 252         ret = rtw_hci_write_data_h2c(rtwdev, h2c_pkt, H2C_PKT_SIZE);
 253         if (ret)
 254                 rtw_err(rtwdev, "failed to send h2c packet\n");
 255         rtwdev->h2c.seq++;
 256
 257         spin_unlock(&rtwdev->h2c.lock);
 258 }
 259
 260 void
 261 rtw_fw_send_general_info(struct rtw_dev *rtwdev)
 262 {
 263         struct rtw_fifo_conf *fifo = &rtwdev->fifo;
 264         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 265         u16 total_size = H2C_PKT_HDR_SIZE + 4;
 266
 267         rtw_h2c_pkt_set_header(h2c_pkt, H2C_PKT_GENERAL_INFO);
 268
 269         SET_PKT_H2C_TOTAL_LEN(h2c_pkt, total_size);
 270
 271         GENERAL_INFO_SET_FW_TX_BOUNDARY(h2c_pkt,
 272                                         fifo->rsvd_fw_txbuf_addr -
 273                                         fifo->rsvd_boundary);
 274
 275         rtw_fw_send_h2c_packet(rtwdev, h2c_pkt);
 276 }
 277
 278 void
 279 rtw_fw_send_phydm_info(struct rtw_dev *rtwdev)
 280 {
 281         struct rtw_hal *hal = &rtwdev->hal;
 282         struct rtw_efuse *efuse = &rtwdev->efuse;
 283         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 284         u16 total_size = H2C_PKT_HDR_SIZE + 8;
 285         u8 fw_rf_type = 0;
 286
 287         if (hal->rf_type == RF_1T1R)
 288                 fw_rf_type = FW_RF_1T1R;
 289         else if (hal->rf_type == RF_2T2R)
 290                 fw_rf_type = FW_RF_2T2R;
 291
 292         rtw_h2c_pkt_set_header(h2c_pkt, H2C_PKT_PHYDM_INFO);
 293
 294         SET_PKT_H2C_TOTAL_LEN(h2c_pkt, total_size);
 295         PHYDM_INFO_SET_REF_TYPE(h2c_pkt, efuse->rfe_option);
 296         PHYDM_INFO_SET_RF_TYPE(h2c_pkt, fw_rf_type);
 297         PHYDM_INFO_SET_CUT_VER(h2c_pkt, hal->cut_version);
 298         PHYDM_INFO_SET_RX_ANT_STATUS(h2c_pkt, hal->antenna_tx);
 299         PHYDM_INFO_SET_TX_ANT_STATUS(h2c_pkt, hal->antenna_rx);
 300
 301         rtw_fw_send_h2c_packet(rtwdev, h2c_pkt);
 302 }
 303
 304 void rtw_fw_do_iqk(struct rtw_dev *rtwdev, struct rtw_iqk_para *para)
 305 {
 306         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 307         u16 total_size = H2C_PKT_HDR_SIZE + 1;
 308
 309         rtw_h2c_pkt_set_header(h2c_pkt, H2C_PKT_IQK);
 310         SET_PKT_H2C_TOTAL_LEN(h2c_pkt, total_size);
 311         IQK_SET_CLEAR(h2c_pkt, para->clear);
 312         IQK_SET_SEGMENT_IQK(h2c_pkt, para->segment_iqk);
 313
 314         rtw_fw_send_h2c_packet(rtwdev, h2c_pkt);
 315 }
 316
 317 void rtw_fw_query_bt_info(struct rtw_dev *rtwdev)
 318 {
 319         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 320
 321         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_QUERY_BT_INFO);
 322
 323         SET_QUERY_BT_INFO(h2c_pkt, true);
 324
 325         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 326 }
 327
 328 void rtw_fw_wl_ch_info(struct rtw_dev *rtwdev, u8 link, u8 ch, u8 bw)
 329 {
 330         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 331
 332         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_WL_CH_INFO);
 333
 334         SET_WL_CH_INFO_LINK(h2c_pkt, link);
 335         SET_WL_CH_INFO_CHNL(h2c_pkt, ch);
 336         SET_WL_CH_INFO_BW(h2c_pkt, bw);
 337
 338         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 339 }
 340
 341 void rtw_fw_query_bt_mp_info(struct rtw_dev *rtwdev,
 342                              struct rtw_coex_info_req *req)
 343 {
 344         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 345
 346         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_QUERY_BT_MP_INFO);
 347
 348         SET_BT_MP_INFO_SEQ(h2c_pkt, req->seq);
 349         SET_BT_MP_INFO_OP_CODE(h2c_pkt, req->op_code);
 350         SET_BT_MP_INFO_PARA1(h2c_pkt, req->para1);
 351         SET_BT_MP_INFO_PARA2(h2c_pkt, req->para2);
 352         SET_BT_MP_INFO_PARA3(h2c_pkt, req->para3);
 353
 354         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 355 }
 356
 357 void rtw_fw_force_bt_tx_power(struct rtw_dev *rtwdev, u8 bt_pwr_dec_lvl)
 358 {
 359         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 360         u8 index = 0 - bt_pwr_dec_lvl;
 361
 362         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_FORCE_BT_TX_POWER);
 363
 364         SET_BT_TX_POWER_INDEX(h2c_pkt, index);
 365
 366         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 367 }
 368
 369 void rtw_fw_bt_ignore_wlan_action(struct rtw_dev *rtwdev, bool enable)
 370 {
 371         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 372
 373         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_IGNORE_WLAN_ACTION);
 374
 375         SET_IGNORE_WLAN_ACTION_EN(h2c_pkt, enable);
 376
 377         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 378 }
 379
 380 void rtw_fw_coex_tdma_type(struct rtw_dev *rtwdev,
 381                            u8 para1, u8 para2, u8 para3, u8 para4, u8 para5)
 382 {
 383         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 384
 385         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_COEX_TDMA_TYPE);
 386
 387         SET_COEX_TDMA_TYPE_PARA1(h2c_pkt, para1);
 388         SET_COEX_TDMA_TYPE_PARA2(h2c_pkt, para2);
 389         SET_COEX_TDMA_TYPE_PARA3(h2c_pkt, para3);
 390         SET_COEX_TDMA_TYPE_PARA4(h2c_pkt, para4);
 391         SET_COEX_TDMA_TYPE_PARA5(h2c_pkt, para5);
 392
 393         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 394 }
 395
 396 void rtw_fw_bt_wifi_control(struct rtw_dev *rtwdev, u8 op_code, u8 *data)
 397 {
 398         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 399
 400         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_BT_WIFI_CONTROL);
 401
 402         SET_BT_WIFI_CONTROL_OP_CODE(h2c_pkt, op_code);
 403
 404         SET_BT_WIFI_CONTROL_DATA1(h2c_pkt, *data);
 405         SET_BT_WIFI_CONTROL_DATA2(h2c_pkt, *(data + 1));
 406         SET_BT_WIFI_CONTROL_DATA3(h2c_pkt, *(data + 2));
 407         SET_BT_WIFI_CONTROL_DATA4(h2c_pkt, *(data + 3));
 408         SET_BT_WIFI_CONTROL_DATA5(h2c_pkt, *(data + 4));
 409
 410         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 411 }
 412
 413 void rtw_fw_send_rssi_info(struct rtw_dev *rtwdev, struct rtw_sta_info *si)
 414 {
 415         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 416         u8 rssi = ewma_rssi_read(&si->avg_rssi);
 417         bool stbc_en = si->stbc_en ? true : false;
 418
 419         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_RSSI_MONITOR);
 420
 421         SET_RSSI_INFO_MACID(h2c_pkt, si->mac_id);
 422         SET_RSSI_INFO_RSSI(h2c_pkt, rssi);
 423         SET_RSSI_INFO_STBC(h2c_pkt, stbc_en);
 424
 425         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 426 }
 427
 428 void rtw_fw_send_ra_info(struct rtw_dev *rtwdev, struct rtw_sta_info *si)
 429 {
 430         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 431         bool no_update = si->updated;
 432         bool disable_pt = true;
 433
 434         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_RA_INFO);
 435
 436         SET_RA_INFO_MACID(h2c_pkt, si->mac_id);
 437         SET_RA_INFO_RATE_ID(h2c_pkt, si->rate_id);
 438         SET_RA_INFO_INIT_RA_LVL(h2c_pkt, si->init_ra_lv);
 439         SET_RA_INFO_SGI_EN(h2c_pkt, si->sgi_enable);
 440         SET_RA_INFO_BW_MODE(h2c_pkt, si->bw_mode);
 441         SET_RA_INFO_LDPC(h2c_pkt, si->ldpc_en);
 442         SET_RA_INFO_NO_UPDATE(h2c_pkt, no_update);
 443         SET_RA_INFO_VHT_EN(h2c_pkt, si->vht_enable);
 444         SET_RA_INFO_DIS_PT(h2c_pkt, disable_pt);
 445         SET_RA_INFO_RA_MASK0(h2c_pkt, (si->ra_mask & 0xff));
 446         SET_RA_INFO_RA_MASK1(h2c_pkt, (si->ra_mask & 0xff00) >> 8);
 447         SET_RA_INFO_RA_MASK2(h2c_pkt, (si->ra_mask & 0xff0000) >> 16);
 448         SET_RA_INFO_RA_MASK3(h2c_pkt, (si->ra_mask & 0xff000000) >> 24);
 449
 450         si->init_ra_lv = 0;
 451         si->updated = true;
 452
 453         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 454 }
 455
 456 void rtw_fw_media_status_report(struct rtw_dev *rtwdev, u8 mac_id, bool connect)
 457 {
 458         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 459
 460         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_MEDIA_STATUS_RPT);
 461         MEDIA_STATUS_RPT_SET_OP_MODE(h2c_pkt, connect);
 462         MEDIA_STATUS_RPT_SET_MACID(h2c_pkt, mac_id);
 463
 464         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 465 }
 466
 467 void rtw_fw_set_pwr_mode(struct rtw_dev *rtwdev)
 468 {
 469         struct rtw_lps_conf *conf = &rtwdev->lps_conf;
 470         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 471
 472         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_SET_PWR_MODE);
 473
 474         SET_PWR_MODE_SET_MODE(h2c_pkt, conf->mode);
 475         SET_PWR_MODE_SET_RLBM(h2c_pkt, conf->rlbm);
 476         SET_PWR_MODE_SET_SMART_PS(h2c_pkt, conf->smart_ps);
 477         SET_PWR_MODE_SET_AWAKE_INTERVAL(h2c_pkt, conf->awake_interval);
 478         SET_PWR_MODE_SET_PORT_ID(h2c_pkt, conf->port_id);
 479         SET_PWR_MODE_SET_PWR_STATE(h2c_pkt, conf->state);
 480
 481         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 482 }
 483
 484 static u8 rtw_get_rsvd_page_location(struct rtw_dev *rtwdev,
 485                                      enum rtw_rsvd_packet_type type)
 486 {
 487         struct rtw_rsvd_page *rsvd_pkt;
 488         u8 location = 0;
 489
 490         list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list) {
 491                 if (type == rsvd_pkt->type)
 492                         location = rsvd_pkt->page;
 493         }
 494
 495         return location;
 496 }
 497
 498 void rtw_fw_set_pg_info(struct rtw_dev *rtwdev)
 499 {
 500         struct rtw_lps_conf *conf = &rtwdev->lps_conf;
 501         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 502         u8 loc_pg, loc_dpk;
 503
 504         loc_pg = rtw_get_rsvd_page_location(rtwdev, RSVD_LPS_PG_INFO);
 505         loc_dpk = rtw_get_rsvd_page_location(rtwdev, RSVD_LPS_PG_DPK);
 506
 507         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_LPS_PG_INFO);
 508
 509         LPS_PG_INFO_LOC(h2c_pkt, loc_pg);
 510         LPS_PG_DPK_LOC(h2c_pkt, loc_dpk);
 511         LPS_PG_SEC_CAM_EN(h2c_pkt, conf->sec_cam_backup);
 512
 513         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 514 }
 515
 516 void rtw_send_rsvd_page_h2c(struct rtw_dev *rtwdev)
 517 {
 518         u8 h2c_pkt[H2C_PKT_SIZE] = {0};
 519         u8 location = 0;
 520
 521         SET_H2C_CMD_ID_CLASS(h2c_pkt, H2C_CMD_RSVD_PAGE);
 522
 523         location = rtw_get_rsvd_page_location(rtwdev, RSVD_PROBE_RESP);
 524         *(h2c_pkt + 1) = location;
 525         rtw_dbg(rtwdev, RTW_DBG_FW, "RSVD_PROBE_RESP loc: %d\n", location);
 526
 527         location = rtw_get_rsvd_page_location(rtwdev, RSVD_PS_POLL);
 528         *(h2c_pkt + 2) = location;
 529         rtw_dbg(rtwdev, RTW_DBG_FW, "RSVD_PS_POLL loc: %d\n", location);
 530
 531         location = rtw_get_rsvd_page_location(rtwdev, RSVD_NULL);
 532         *(h2c_pkt + 3) = location;
 533         rtw_dbg(rtwdev, RTW_DBG_FW, "RSVD_NULL loc: %d\n", location);
 534
 535         location = rtw_get_rsvd_page_location(rtwdev, RSVD_QOS_NULL);
 536         *(h2c_pkt + 4) = location;
 537         rtw_dbg(rtwdev, RTW_DBG_FW, "RSVD_QOS_NULL loc: %d\n", location);
 538
 539         rtw_fw_send_h2c_command(rtwdev, h2c_pkt);
 540 }
 541
 542 static struct sk_buff *
 543 rtw_beacon_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
 544 {
 545         struct sk_buff *skb_new;
 546
 547         if (vif->type != NL80211_IFTYPE_AP &&
 548             vif->type != NL80211_IFTYPE_ADHOC &&
 549             !ieee80211_vif_is_mesh(vif)) {
 550                 skb_new = alloc_skb(1, GFP_KERNEL);
 551                 if (!skb_new)
 552                         return NULL;
 553                 skb_put(skb_new, 1);
 554         } else {
 555                 skb_new = ieee80211_beacon_get(hw, vif);
 556         }
 557
 558         return skb_new;
 559 }
 560
 561 static struct sk_buff *rtw_lps_pg_dpk_get(struct ieee80211_hw *hw)
 562 {
 563         struct rtw_dev *rtwdev = hw->priv;
 564         struct rtw_chip_info *chip = rtwdev->chip;
 565         struct rtw_dpk_info *dpk_info = &rtwdev->dm_info.dpk_info;
 566         struct rtw_lps_pg_dpk_hdr *dpk_hdr;
 567         struct sk_buff *skb;
 568         u32 size;
 569
 570         size = chip->tx_pkt_desc_sz + sizeof(*dpk_hdr);
 571         skb = alloc_skb(size, GFP_KERNEL);
 572         if (!skb)
 573                 return NULL;
 574
 575         skb_reserve(skb, chip->tx_pkt_desc_sz);
 576         dpk_hdr = skb_put_zero(skb, sizeof(*dpk_hdr));
 577         dpk_hdr->dpk_ch = dpk_info->dpk_ch;
 578         dpk_hdr->dpk_path_ok = dpk_info->dpk_path_ok[0];
 579         memcpy(dpk_hdr->dpk_txagc, dpk_info->dpk_txagc, 2);
 580         memcpy(dpk_hdr->dpk_gs, dpk_info->dpk_gs, 4);
 581         memcpy(dpk_hdr->coef, dpk_info->coef, 160);
 582
 583         return skb;
 584 }
 585
 586 static struct sk_buff *rtw_lps_pg_info_get(struct ieee80211_hw *hw,
 587                                            struct ieee80211_vif *vif)
 588 {
 589         struct rtw_dev *rtwdev = hw->priv;
 590         struct rtw_chip_info *chip = rtwdev->chip;
 591         struct rtw_lps_conf *conf = &rtwdev->lps_conf;
 592         struct rtw_lps_pg_info_hdr *pg_info_hdr;
 593         struct sk_buff *skb;
 594         u32 size;
 595
 596         size = chip->tx_pkt_desc_sz + sizeof(*pg_info_hdr);
 597         skb = alloc_skb(size, GFP_KERNEL);
 598         if (!skb)
 599                 return NULL;
 600
 601         skb_reserve(skb, chip->tx_pkt_desc_sz);
 602         pg_info_hdr = skb_put_zero(skb, sizeof(*pg_info_hdr));
 603         pg_info_hdr->tx_bu_page_count = rtwdev->fifo.rsvd_drv_pg_num;
 604         pg_info_hdr->macid = find_first_bit(rtwdev->mac_id_map, RTW_MAX_MAC_ID_NUM);
 605         pg_info_hdr->sec_cam_count =
 606                 rtw_sec_cam_pg_backup(rtwdev, pg_info_hdr->sec_cam);
 607
 608         conf->sec_cam_backup = pg_info_hdr->sec_cam_count != 0;
 609
 610         return skb;
 611 }
 612
 613 static struct sk_buff *rtw_get_rsvd_page_skb(struct ieee80211_hw *hw,
 614                                              struct ieee80211_vif *vif,
 615                                              enum rtw_rsvd_packet_type type)
 616 {
 617         struct sk_buff *skb_new;
 618
 619         switch (type) {
 620         case RSVD_BEACON:
 621                 skb_new = rtw_beacon_get(hw, vif);
 622                 break;
 623         case RSVD_PS_POLL:
 624                 skb_new = ieee80211_pspoll_get(hw, vif);
 625                 break;
 626         case RSVD_PROBE_RESP:
 627                 skb_new = ieee80211_proberesp_get(hw, vif);
 628                 break;
 629         case RSVD_NULL:
 630                 skb_new = ieee80211_nullfunc_get(hw, vif, false);
 631                 break;
 632         case RSVD_QOS_NULL:
 633                 skb_new = ieee80211_nullfunc_get(hw, vif, true);
 634                 break;
 635         case RSVD_LPS_PG_DPK:
 636                 skb_new = rtw_lps_pg_dpk_get(hw);
 637                 break;
 638         case RSVD_LPS_PG_INFO:
 639                 skb_new = rtw_lps_pg_info_get(hw, vif);
 640                 break;
 641         default:
 642                 return NULL;
 643         }
 644
 645         if (!skb_new)
 646                 return NULL;
 647
 648         return skb_new;
 649 }
 650
 651 static void rtw_fill_rsvd_page_desc(struct rtw_dev *rtwdev, struct sk_buff *skb)
 652 {
 653         struct rtw_tx_pkt_info pkt_info;
 654         struct rtw_chip_info *chip = rtwdev->chip;
 655         u8 *pkt_desc;
 656
 657         memset(&pkt_info, 0, sizeof(pkt_info));
 658         rtw_rsvd_page_pkt_info_update(rtwdev, &pkt_info, skb);
 659         pkt_desc = skb_push(skb, chip->tx_pkt_desc_sz);
 660         memset(pkt_desc, 0, chip->tx_pkt_desc_sz);
 661         rtw_tx_fill_tx_desc(&pkt_info, skb);
 662 }
 663
 664 static inline u8 rtw_len_to_page(unsigned int len, u8 page_size)
 665 {
 666         return DIV_ROUND_UP(len, page_size);
 667 }
 668
 669 static void rtw_rsvd_page_list_to_buf(struct rtw_dev *rtwdev, u8 page_size,
 670                                       u8 page_margin, u32 page, u8 *buf,
 671                                       struct rtw_rsvd_page *rsvd_pkt)
 672 {
 673         struct sk_buff *skb = rsvd_pkt->skb;
 674
 675         if (rsvd_pkt->add_txdesc)
 676                 rtw_fill_rsvd_page_desc(rtwdev, skb);
 677
 678         if (page >= 1)
 679                 memcpy(buf + page_margin + page_size * (page - 1),
 680                        skb->data, skb->len);
 681         else
 682                 memcpy(buf, skb->data, skb->len);
 683 }
 684
 685 void rtw_add_rsvd_page(struct rtw_dev *rtwdev, enum rtw_rsvd_packet_type type,
 686                        bool txdesc)
 687 {
 688         struct rtw_rsvd_page *rsvd_pkt;
 689
 690         lockdep_assert_held(&rtwdev->mutex);
 691
 692         list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list) {
 693                 if (rsvd_pkt->type == type)
 694                         return;
 695         }
 696
 697         rsvd_pkt = kmalloc(sizeof(*rsvd_pkt), GFP_KERNEL);
 698         if (!rsvd_pkt)
 699                 return;
 700
 701         rsvd_pkt->type = type;
 702         rsvd_pkt->add_txdesc = txdesc;
 703         list_add_tail(&rsvd_pkt->list, &rtwdev->rsvd_page_list);
 704 }
 705
 706 void rtw_reset_rsvd_page(struct rtw_dev *rtwdev)
 707 {
 708         struct rtw_rsvd_page *rsvd_pkt, *tmp;
 709
 710         lockdep_assert_held(&rtwdev->mutex);
 711
 712         list_for_each_entry_safe(rsvd_pkt, tmp, &rtwdev->rsvd_page_list, list) {
 713                 if (rsvd_pkt->type == RSVD_BEACON)
 714                         continue;
 715                 list_del(&rsvd_pkt->list);
 716                 kfree(rsvd_pkt);
 717         }
 718 }
 719
 720 int rtw_fw_write_data_rsvd_page(struct rtw_dev *rtwdev, u16 pg_addr,
 721                                 u8 *buf, u32 size)
 722 {
 723         u8 bckp[2];
 724         u8 val;
 725         u16 rsvd_pg_head;
 726         int ret;
 727
 728         lockdep_assert_held(&rtwdev->mutex);
 729
 730         if (!size)
 731                 return -EINVAL;
 732
 733         pg_addr &= BIT_MASK_BCN_HEAD_1_V1;
 734         rtw_write16(rtwdev, REG_FIFOPAGE_CTRL_2, pg_addr | BIT_BCN_VALID_V1);
 735
 736         val = rtw_read8(rtwdev, REG_CR + 1);
 737         bckp[0] = val;
 738         val |= BIT_ENSWBCN >> 8;
 739         rtw_write8(rtwdev, REG_CR + 1, val);
 740
 741         val = rtw_read8(rtwdev, REG_FWHW_TXQ_CTRL + 2);
 742         bckp[1] = val;
 743         val &= ~(BIT_EN_BCNQ_DL >> 16);
 744         rtw_write8(rtwdev, REG_FWHW_TXQ_CTRL + 2, val);
 745
 746         ret = rtw_hci_write_data_rsvd_page(rtwdev, buf, size);
 747         if (ret) {
 748                 rtw_err(rtwdev, "failed to write data to rsvd page\n");
 749                 goto restore;
 750         }
 751
 752         if (!check_hw_ready(rtwdev, REG_FIFOPAGE_CTRL_2, BIT_BCN_VALID_V1, 1)) {
 753                 rtw_err(rtwdev, "error beacon valid\n");
 754                 ret = -EBUSY;
 755         }
 756
 757 restore:
 758         rsvd_pg_head = rtwdev->fifo.rsvd_boundary;
 759         rtw_write16(rtwdev, REG_FIFOPAGE_CTRL_2,
 760                     rsvd_pg_head | BIT_BCN_VALID_V1);
 761         rtw_write8(rtwdev, REG_FWHW_TXQ_CTRL + 2, bckp[1]);
 762         rtw_write8(rtwdev, REG_CR + 1, bckp[0]);
 763
 764         return ret;
 765 }
 766
 767 static int rtw_download_drv_rsvd_page(struct rtw_dev *rtwdev, u8 *buf, u32 size)
 768 {
 769         u32 pg_size;
 770         u32 pg_num = 0;
 771         u16 pg_addr = 0;
 772
 773         pg_size = rtwdev->chip->page_size;
 774         pg_num = size / pg_size + ((size & (pg_size - 1)) ? 1 : 0);
 775         if (pg_num > rtwdev->fifo.rsvd_drv_pg_num)
 776                 return -ENOMEM;
 777
 778         pg_addr = rtwdev->fifo.rsvd_drv_addr;
 779
 780         return rtw_fw_write_data_rsvd_page(rtwdev, pg_addr, buf, size);
 781 }
 782
 783 static u8 *rtw_build_rsvd_page(struct rtw_dev *rtwdev,
 784                                struct ieee80211_vif *vif, u32 *size)
 785 {
 786         struct ieee80211_hw *hw = rtwdev->hw;
 787         struct rtw_chip_info *chip = rtwdev->chip;
 788         struct sk_buff *iter;
 789         struct rtw_rsvd_page *rsvd_pkt;
 790         u32 page = 0;
 791         u8 total_page = 0;
 792         u8 page_size, page_margin, tx_desc_sz;
 793         u8 *buf;
 794
 795         page_size = chip->page_size;
 796         tx_desc_sz = chip->tx_pkt_desc_sz;
 797         page_margin = page_size - tx_desc_sz;
 798
 799         list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list) {
 800                 iter = rtw_get_rsvd_page_skb(hw, vif, rsvd_pkt->type);
 801                 if (!iter) {
 802                         rtw_err(rtwdev, "fail to build rsvd packet\n");
 803                         goto release_skb;
 804                 }
 805                 rsvd_pkt->skb = iter;
 806                 rsvd_pkt->page = total_page;
 807                 if (rsvd_pkt->add_txdesc)
 808                         total_page += rtw_len_to_page(iter->len + tx_desc_sz,
 809                                                       page_size);
 810                 else
 811                         total_page += rtw_len_to_page(iter->len, page_size);
 812         }
 813
 814         if (total_page > rtwdev->fifo.rsvd_drv_pg_num) {
 815                 rtw_err(rtwdev, "rsvd page over size: %d\n", total_page);
 816                 goto release_skb;
 817         }
 818
 819         *size = (total_page - 1) * page_size + page_margin;
 820         buf = kzalloc(*size, GFP_KERNEL);
 821         if (!buf)
 822                 goto release_skb;
 823
 824         list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list) {
 825                 rtw_rsvd_page_list_to_buf(rtwdev, page_size, page_margin,
 826                                           page, buf, rsvd_pkt);
 827                 page += rtw_len_to_page(rsvd_pkt->skb->len, page_size);
 828         }
 829         list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list)
 830                 kfree_skb(rsvd_pkt->skb);
 831
 832         return buf;
 833
 834 release_skb:
 835         list_for_each_entry(rsvd_pkt, &rtwdev->rsvd_page_list, list)
 836                 kfree_skb(rsvd_pkt->skb);
 837
 838         return NULL;
 839 }
 840
 841 static int
 842 rtw_download_beacon(struct rtw_dev *rtwdev, struct ieee80211_vif *vif)
 843 {
 844         struct ieee80211_hw *hw = rtwdev->hw;
 845         struct sk_buff *skb;
 846         int ret = 0;
 847
 848         skb = rtw_beacon_get(hw, vif);
 849         if (!skb) {
 850                 rtw_err(rtwdev, "failed to get beacon skb\n");
 851                 ret = -ENOMEM;
 852                 goto out;
 853         }
 854
 855         ret = rtw_download_drv_rsvd_page(rtwdev, skb->data, skb->len);
 856         if (ret)
 857                 rtw_err(rtwdev, "failed to download drv rsvd page\n");
 858
 859         dev_kfree_skb(skb);
 860
 861 out:
 862         return ret;
 863 }
 864
 865 int rtw_fw_download_rsvd_page(struct rtw_dev *rtwdev, struct ieee80211_vif *vif)
 866 {
 867         u8 *buf;
 868         u32 size;
 869         int ret;
 870
 871         buf = rtw_build_rsvd_page(rtwdev, vif, &size);
 872         if (!buf) {
 873                 rtw_err(rtwdev, "failed to build rsvd page pkt\n");
 874                 return -ENOMEM;
 875         }
 876
 877         ret = rtw_download_drv_rsvd_page(rtwdev, buf, size);
 878         if (ret) {
 879                 rtw_err(rtwdev, "failed to download drv rsvd page\n");
 880                 goto free;
 881         }
 882
 883         ret = rtw_download_beacon(rtwdev, vif);
 884         if (ret) {
 885                 rtw_err(rtwdev, "failed to download beacon\n");
 886                 goto free;
 887         }
 888
 889 free:
 890         kfree(buf);
 891
 892         return ret;
 893 }
 894
 895 int rtw_dump_drv_rsvd_page(struct rtw_dev *rtwdev,
 896                            u32 offset, u32 size, u32 *buf)
 897 {
 898         struct rtw_fifo_conf *fifo = &rtwdev->fifo;
 899         u32 residue, i;
 900         u16 start_pg;
 901         u16 idx = 0;
 902         u16 ctl;
 903         u8 rcr;
 904
 905         if (size & 0x3) {
 906                 rtw_warn(rtwdev, "should be 4-byte aligned\n");
 907                 return -EINVAL;
 908         }
 909
 910         offset += fifo->rsvd_boundary << TX_PAGE_SIZE_SHIFT;
 911         residue = offset & (FIFO_PAGE_SIZE - 1);
 912         start_pg = offset >> FIFO_PAGE_SIZE_SHIFT;
 913         start_pg += RSVD_PAGE_START_ADDR;
 914
 915         rcr = rtw_read8(rtwdev, REG_RCR + 2);
 916         ctl = rtw_read16(rtwdev, REG_PKTBUF_DBG_CTRL) & 0xf000;
 917
 918         /* disable rx clock gate */
 919         rtw_write8(rtwdev, REG_RCR, rcr | BIT(3));
 920
 921         do {
 922                 rtw_write16(rtwdev, REG_PKTBUF_DBG_CTRL, start_pg | ctl);
 923
 924                 for (i = FIFO_DUMP_ADDR + residue;
 925                      i < FIFO_DUMP_ADDR + FIFO_PAGE_SIZE; i += 4) {
 926                         buf[idx++] = rtw_read32(rtwdev, i);
 927                         size -= 4;
 928                         if (size == 0)
 929                                 goto out;
 930                 }
 931
 932                 residue = 0;
 933                 start_pg++;
 934         } while (size);
 935
 936 out:
 937         rtw_write16(rtwdev, REG_PKTBUF_DBG_CTRL, ctl);
 938         rtw_write8(rtwdev, REG_RCR + 2, rcr);
 939         return 0;
 940 }