drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 // Copyright (c) 2016-2017 Hisilicon Limited.
   3
   4 #include "hclge_main.h"
   5 #include "hclge_mbx.h"
   6 #include "hnae3.h"
   7
   8 /* hclge_gen_resp_to_vf: used to generate a synchronous response to VF when PF
   9  * receives a mailbox message from VF.
  10  * @vport: pointer to struct hclge_vport
  11  * @vf_to_pf_req: pointer to hclge_mbx_vf_to_pf_cmd of the original mailbox
  12  *                message
  13  * @resp_status: indicate to VF whether its request success(0) or failed.
  14  */
  15 static int hclge_gen_resp_to_vf(struct hclge_vport *vport,
  16                                 struct hclge_mbx_vf_to_pf_cmd *vf_to_pf_req,
  17                                 int resp_status,
  18                                 u8 *resp_data, u16 resp_data_len)
  19 {
  20         struct hclge_mbx_pf_to_vf_cmd *resp_pf_to_vf;
  21         struct hclge_dev *hdev = vport->back;
  22         enum hclge_cmd_status status;
  23         struct hclge_desc desc;
  24
  25         resp_pf_to_vf = (struct hclge_mbx_pf_to_vf_cmd *)desc.data;
  26
  27         if (resp_data_len > HCLGE_MBX_MAX_RESP_DATA_SIZE) {
  28                 dev_err(&hdev->pdev->dev,
  29                         "PF fail to gen resp to VF len %d exceeds max len %d\n",
  30                         resp_data_len,
  31                         HCLGE_MBX_MAX_RESP_DATA_SIZE);
  32         }
  33
  34         hclge_cmd_setup_basic_desc(&desc, HCLGEVF_OPC_MBX_PF_TO_VF, false);
  35
  36         resp_pf_to_vf->dest_vfid = vf_to_pf_req->mbx_src_vfid;
  37         resp_pf_to_vf->msg_len = vf_to_pf_req->msg_len;
  38
  39         resp_pf_to_vf->msg[0] = HCLGE_MBX_PF_VF_RESP;
  40         resp_pf_to_vf->msg[1] = vf_to_pf_req->msg[0];
  41         resp_pf_to_vf->msg[2] = vf_to_pf_req->msg[1];
  42         resp_pf_to_vf->msg[3] = (resp_status == 0) ? 0 : 1;
  43
  44         if (resp_data && resp_data_len > 0)
  45                 memcpy(&resp_pf_to_vf->msg[4], resp_data, resp_data_len);
  46
  47         status = hclge_cmd_send(&hdev->hw, &desc, 1);
  48         if (status)
  49                 dev_err(&hdev->pdev->dev,
  50                         "PF failed(=%d) to send response to VF\n", status);
  51
  52         return status;
  53 }
  54
  55 static int hclge_send_mbx_msg(struct hclge_vport *vport, u8 *msg, u16 msg_len,
  56                               u16 mbx_opcode, u8 dest_vfid)
  57 {
  58         struct hclge_mbx_pf_to_vf_cmd *resp_pf_to_vf;
  59         struct hclge_dev *hdev = vport->back;
  60         enum hclge_cmd_status status;
  61         struct hclge_desc desc;
  62
  63         resp_pf_to_vf = (struct hclge_mbx_pf_to_vf_cmd *)desc.data;
  64
  65         hclge_cmd_setup_basic_desc(&desc, HCLGEVF_OPC_MBX_PF_TO_VF, false);
  66
  67         resp_pf_to_vf->dest_vfid = dest_vfid;
  68         resp_pf_to_vf->msg_len = msg_len;
  69         resp_pf_to_vf->msg[0] = mbx_opcode;
  70
  71         memcpy(&resp_pf_to_vf->msg[1], msg, msg_len);
  72
  73         status = hclge_cmd_send(&hdev->hw, &desc, 1);
  74         if (status)
  75                 dev_err(&hdev->pdev->dev,
  76                         "PF failed(=%d) to send mailbox message to VF\n",
  77                         status);
  78
  79         return status;
  80 }
  81
  82 int hclge_inform_reset_assert_to_vf(struct hclge_vport *vport)
  83 {
  84         struct hclge_dev *hdev = vport->back;
  85         enum hnae3_reset_type reset_type;
  86         u8 msg_data[2];
  87         u8 dest_vfid;
  88
  89         dest_vfid = (u8)vport->vport_id;
  90
  91         if (hdev->reset_type == HNAE3_FUNC_RESET)
  92                 reset_type = HNAE3_VF_PF_FUNC_RESET;
  93         else
  94                 return -EINVAL;
  95
  96         memcpy(&msg_data[0], &reset_type, sizeof(u16));
  97
  98         /* send this requested info to VF */
  99         return hclge_send_mbx_msg(vport, msg_data, sizeof(msg_data),
 100                                   HCLGE_MBX_ASSERTING_RESET, dest_vfid);
 101 }
 102
 103 static void hclge_free_vector_ring_chain(struct hnae3_ring_chain_node *head)
 104 {
 105         struct hnae3_ring_chain_node *chain_tmp, *chain;
 106
 107         chain = head->next;
 108
 109         while (chain) {
 110                 chain_tmp = chain->next;
 111                 kzfree(chain);
 112                 chain = chain_tmp;
 113         }
 114 }
 115
 116 /* hclge_get_ring_chain_from_mbx: get ring type & tqp id & int_gl idx
 117  * from mailbox message
 118  * msg[0]: opcode
 119  * msg[1]: <not relevant to this function>
 120  * msg[2]: ring_num
 121  * msg[3]: first ring type (TX|RX)
 122  * msg[4]: first tqp id
 123  * msg[5]: first int_gl idx
 124  * msg[6] ~ msg[14]: other ring type, tqp id and int_gl idx
 125  */
 126 static int hclge_get_ring_chain_from_mbx(
 127                         struct hclge_mbx_vf_to_pf_cmd *req,
 128                         struct hnae3_ring_chain_node *ring_chain,
 129                         struct hclge_vport *vport)
 130 {
 131         struct hnae3_ring_chain_node *cur_chain, *new_chain;
 132         int ring_num;
 133         int i;
 134
 135         ring_num = req->msg[2];
 136
 137         if (ring_num > ((HCLGE_MBX_VF_MSG_DATA_NUM -
 138                 HCLGE_MBX_RING_MAP_BASIC_MSG_NUM) /
 139                 HCLGE_MBX_RING_NODE_VARIABLE_NUM))
 140                 return -ENOMEM;
 141
 142         hnae3_set_bit(ring_chain->flag, HNAE3_RING_TYPE_B, req->msg[3]);
 143         ring_chain->tqp_index =
 144                         hclge_get_queue_id(vport->nic.kinfo.tqp[req->msg[4]]);
 145         hnae3_set_field(ring_chain->int_gl_idx, HNAE3_RING_GL_IDX_M,
 146                         HNAE3_RING_GL_IDX_S,
 147                         req->msg[5]);
 148
 149         cur_chain = ring_chain;
 150
 151         for (i = 1; i < ring_num; i++) {
 152                 new_chain = kzalloc(sizeof(*new_chain), GFP_KERNEL);
 153                 if (!new_chain)
 154                         goto err;
 155
 156                 hnae3_set_bit(new_chain->flag, HNAE3_RING_TYPE_B,
 157                               req->msg[HCLGE_MBX_RING_NODE_VARIABLE_NUM * i +
 158                               HCLGE_MBX_RING_MAP_BASIC_MSG_NUM]);
 159
 160                 new_chain->tqp_index =
 161                 hclge_get_queue_id(vport->nic.kinfo.tqp
 162                         [req->msg[HCLGE_MBX_RING_NODE_VARIABLE_NUM * i +
 163                         HCLGE_MBX_RING_MAP_BASIC_MSG_NUM + 1]]);
 164
 165                 hnae3_set_field(new_chain->int_gl_idx, HNAE3_RING_GL_IDX_M,
 166                                 HNAE3_RING_GL_IDX_S,
 167                                 req->msg[HCLGE_MBX_RING_NODE_VARIABLE_NUM * i +
 168                                 HCLGE_MBX_RING_MAP_BASIC_MSG_NUM + 2]);
 169
 170                 cur_chain->next = new_chain;
 171                 cur_chain = new_chain;
 172         }
 173
 174         return 0;
 175 err:
 176         hclge_free_vector_ring_chain(ring_chain);
 177         return -ENOMEM;
 178 }
 179
 180 static int hclge_map_unmap_ring_to_vf_vector(struct hclge_vport *vport, bool en,
 181                                              struct hclge_mbx_vf_to_pf_cmd *req)
 182 {
 183         struct hnae3_ring_chain_node ring_chain;
 184         int vector_id = req->msg[1];
 185         int ret;
 186
 187         memset(&ring_chain, 0, sizeof(ring_chain));
 188         ret = hclge_get_ring_chain_from_mbx(req, &ring_chain, vport);
 189         if (ret)
 190                 return ret;
 191
 192         ret = hclge_bind_ring_with_vector(vport, vector_id, en, &ring_chain);
 193         if (ret)
 194                 return ret;
 195
 196         hclge_free_vector_ring_chain(&ring_chain);
 197
 198         return 0;
 199 }
 200
 201 static int hclge_set_vf_promisc_mode(struct hclge_vport *vport,
 202                                      struct hclge_mbx_vf_to_pf_cmd *req)
 203 {
 204         bool en_uc = req->msg[1] ? true : false;
 205         bool en_mc = req->msg[2] ? true : false;
 206         struct hclge_promisc_param param;
 207
 208         /* always enable broadcast promisc bit */
 209         hclge_promisc_param_init(&param, en_uc, en_mc, true, vport->vport_id);
 210         return hclge_cmd_set_promisc_mode(vport->back, &param);
 211 }
 212
 213 static int hclge_set_vf_uc_mac_addr(struct hclge_vport *vport,
 214                                     struct hclge_mbx_vf_to_pf_cmd *mbx_req,
 215                                     bool gen_resp)
 216 {
 217         const u8 *mac_addr = (const u8 *)(&mbx_req->msg[2]);
 218         struct hclge_dev *hdev = vport->back;
 219         int status;
 220
 221         if (mbx_req->msg[1] == HCLGE_MBX_MAC_VLAN_UC_MODIFY) {
 222                 const u8 *old_addr = (const u8 *)(&mbx_req->msg[8]);
 223
 224                 hclge_rm_uc_addr_common(vport, old_addr);
 225                 status = hclge_add_uc_addr_common(vport, mac_addr);
 226                 if (status)
 227                         hclge_add_uc_addr_common(vport, old_addr);
 228         } else if (mbx_req->msg[1] == HCLGE_MBX_MAC_VLAN_UC_ADD) {
 229                 status = hclge_add_uc_addr_common(vport, mac_addr);
 230         } else if (mbx_req->msg[1] == HCLGE_MBX_MAC_VLAN_UC_REMOVE) {
 231                 status = hclge_rm_uc_addr_common(vport, mac_addr);
 232         } else {
 233                 dev_err(&hdev->pdev->dev,
 234                         "failed to set unicast mac addr, unknown subcode %d\n",
 235                         mbx_req->msg[1]);
 236                 return -EIO;
 237         }
 238
 239         if (gen_resp)
 240                 hclge_gen_resp_to_vf(vport, mbx_req, status, NULL, 0);
 241
 242         return 0;
 243 }
 244
 245 static int hclge_set_vf_mc_mac_addr(struct hclge_vport *vport,
 246                                     struct hclge_mbx_vf_to_pf_cmd *mbx_req,
 247                                     bool gen_resp)
 248 {
 249         const u8 *mac_addr = (const u8 *)(&mbx_req->msg[2]);
 250         struct hclge_dev *hdev = vport->back;
 251         u8 resp_len = 0;
 252         u8 resp_data;
 253         int status;
 254
 255         if (mbx_req->msg[1] == HCLGE_MBX_MAC_VLAN_MC_ADD) {
 256                 status = hclge_add_mc_addr_common(vport, mac_addr);
 257         } else if (mbx_req->msg[1] == HCLGE_MBX_MAC_VLAN_MC_REMOVE) {
 258                 status = hclge_rm_mc_addr_common(vport, mac_addr);
 259         } else {
 260                 dev_err(&hdev->pdev->dev,
 261                         "failed to set mcast mac addr, unknown subcode %d\n",
 262                         mbx_req->msg[1]);
 263                 return -EIO;
 264         }
 265
 266         if (gen_resp)
 267                 hclge_gen_resp_to_vf(vport, mbx_req, status,
 268                                      &resp_data, resp_len);
 269
 270         return 0;
 271 }
 272
 273 static int hclge_set_vf_vlan_cfg(struct hclge_vport *vport,
 274                                  struct hclge_mbx_vf_to_pf_cmd *mbx_req,
 275                                  bool gen_resp)
 276 {
 277         int status = 0;
 278
 279         if (mbx_req->msg[1] == HCLGE_MBX_VLAN_FILTER) {
 280                 struct hnae3_handle *handle = &vport->nic;
 281                 u16 vlan, proto;
 282                 bool is_kill;
 283
 284                 is_kill = !!mbx_req->msg[2];
 285                 memcpy(&vlan, &mbx_req->msg[3], sizeof(vlan));
 286                 memcpy(&proto, &mbx_req->msg[5], sizeof(proto));
 287                 status = hclge_set_vlan_filter(handle, cpu_to_be16(proto),
 288                                                vlan, is_kill);
 289         } else if (mbx_req->msg[1] == HCLGE_MBX_VLAN_RX_OFF_CFG) {
 290                 struct hnae3_handle *handle = &vport->nic;
 291                 bool en = mbx_req->msg[2] ? true : false;
 292
 293                 status = hclge_en_hw_strip_rxvtag(handle, en);
 294         }
 295
 296         if (gen_resp)
 297                 status = hclge_gen_resp_to_vf(vport, mbx_req, status, NULL, 0);
 298
 299         return status;
 300 }
 301
 302 static int hclge_get_vf_tcinfo(struct hclge_vport *vport,
 303                                struct hclge_mbx_vf_to_pf_cmd *mbx_req,
 304                                bool gen_resp)
 305 {
 306         struct hclge_dev *hdev = vport->back;
 307         int ret;
 308
 309         ret = hclge_gen_resp_to_vf(vport, mbx_req, 0, &hdev->hw_tc_map,
 310                                    sizeof(u8));
 311
 312         return ret;
 313 }
 314
 315 static int hclge_get_vf_queue_info(struct hclge_vport *vport,
 316                                    struct hclge_mbx_vf_to_pf_cmd *mbx_req,
 317                                    bool gen_resp)
 318 {
 319 #define HCLGE_TQPS_RSS_INFO_LEN         8
 320         u8 resp_data[HCLGE_TQPS_RSS_INFO_LEN];
 321         struct hclge_dev *hdev = vport->back;
 322
 323         /* get the queue related info */
 324         memcpy(&resp_data[0], &vport->alloc_tqps, sizeof(u16));
 325         memcpy(&resp_data[2], &vport->nic.kinfo.rss_size, sizeof(u16));
 326         memcpy(&resp_data[4], &hdev->num_desc, sizeof(u16));
 327         memcpy(&resp_data[6], &hdev->rx_buf_len, sizeof(u16));
 328
 329         return hclge_gen_resp_to_vf(vport, mbx_req, 0, resp_data,
 330                                     HCLGE_TQPS_RSS_INFO_LEN);
 331 }
 332
 333 static int hclge_get_link_info(struct hclge_vport *vport,
 334                                struct hclge_mbx_vf_to_pf_cmd *mbx_req)
 335 {
 336         struct hclge_dev *hdev = vport->back;
 337         u16 link_status;
 338         u8 msg_data[8];
 339         u8 dest_vfid;
 340         u16 duplex;
 341
 342         /* mac.link can only be 0 or 1 */
 343         link_status = (u16)hdev->hw.mac.link;
 344         duplex = hdev->hw.mac.duplex;
 345         memcpy(&msg_data[0], &link_status, sizeof(u16));
 346         memcpy(&msg_data[2], &hdev->hw.mac.speed, sizeof(u32));
 347         memcpy(&msg_data[6], &duplex, sizeof(u16));
 348         dest_vfid = mbx_req->mbx_src_vfid;
 349
 350         /* send this requested info to VF */
 351         return hclge_send_mbx_msg(vport, msg_data, sizeof(msg_data),
 352                                   HCLGE_MBX_LINK_STAT_CHANGE, dest_vfid);
 353 }
 354
 355 static void hclge_mbx_reset_vf_queue(struct hclge_vport *vport,
 356                                      struct hclge_mbx_vf_to_pf_cmd *mbx_req)
 357 {
 358         u16 queue_id;
 359
 360         memcpy(&queue_id, &mbx_req->msg[2], sizeof(queue_id));
 361
 362         hclge_reset_vf_queue(vport, queue_id);
 363
 364         /* send response msg to VF after queue reset complete*/
 365         hclge_gen_resp_to_vf(vport, mbx_req, 0, NULL, 0);
 366 }
 367
 368 static void hclge_reset_vf(struct hclge_vport *vport,
 369                            struct hclge_mbx_vf_to_pf_cmd *mbx_req)
 370 {
 371         struct hclge_dev *hdev = vport->back;
 372         int ret;
 373
 374         dev_warn(&hdev->pdev->dev, "PF received VF reset request from VF %d!",
 375                  vport->vport_id);
 376
 377         ret = hclge_func_reset_cmd(hdev, vport->vport_id);
 378         hclge_gen_resp_to_vf(vport, mbx_req, ret, NULL, 0);
 379 }
 380
 381 static bool hclge_cmd_crq_empty(struct hclge_hw *hw)
 382 {
 383         u32 tail = hclge_read_dev(hw, HCLGE_NIC_CRQ_TAIL_REG);
 384
 385         return tail == hw->cmq.crq.next_to_use;
 386 }
 387
 388 void hclge_mbx_handler(struct hclge_dev *hdev)
 389 {
 390         struct hclge_cmq_ring *crq = &hdev->hw.cmq.crq;
 391         struct hclge_mbx_vf_to_pf_cmd *req;
 392         struct hclge_vport *vport;
 393         struct hclge_desc *desc;
 394         int ret, flag;
 395
 396         /* handle all the mailbox requests in the queue */
 397         while (!hclge_cmd_crq_empty(&hdev->hw)) {
 398                 if (test_bit(HCLGE_STATE_CMD_DISABLE, &hdev->state)) {
 399                         dev_warn(&hdev->pdev->dev,
 400                                  "command queue needs re-initializing\n");
 401                         return;
 402                 }
 403
 404                 desc = &crq->desc[crq->next_to_use];
 405                 req = (struct hclge_mbx_vf_to_pf_cmd *)desc->data;
 406
 407                 flag = le16_to_cpu(crq->desc[crq->next_to_use].flag);
 408                 if (unlikely(!hnae3_get_bit(flag, HCLGE_CMDQ_RX_OUTVLD_B))) {
 409                         dev_warn(&hdev->pdev->dev,
 410                                  "dropped invalid mailbox message, code = %d\n",
 411                                  req->msg[0]);
 412
 413                         /* dropping/not processing this invalid message */
 414                         crq->desc[crq->next_to_use].flag = 0;
 415                         hclge_mbx_ring_ptr_move_crq(crq);
 416                         continue;
 417                 }
 418
 419                 vport = &hdev->vport[req->mbx_src_vfid];
 420
 421                 switch (req->msg[0]) {
 422                 case HCLGE_MBX_MAP_RING_TO_VECTOR:
 423                         ret = hclge_map_unmap_ring_to_vf_vector(vport, true,
 424                                                                 req);
 425                         break;
 426                 case HCLGE_MBX_UNMAP_RING_TO_VECTOR:
 427                         ret = hclge_map_unmap_ring_to_vf_vector(vport, false,
 428                                                                 req);
 429                         break;
 430                 case HCLGE_MBX_SET_PROMISC_MODE:
 431                         ret = hclge_set_vf_promisc_mode(vport, req);
 432                         if (ret)
 433                                 dev_err(&hdev->pdev->dev,
 434                                         "PF fail(%d) to set VF promisc mode\n",
 435                                         ret);
 436                         break;
 437                 case HCLGE_MBX_SET_UNICAST:
 438                         ret = hclge_set_vf_uc_mac_addr(vport, req, true);
 439                         if (ret)
 440                                 dev_err(&hdev->pdev->dev,
 441                                         "PF fail(%d) to set VF UC MAC Addr\n",
 442                                         ret);
 443                         break;
 444                 case HCLGE_MBX_SET_MULTICAST:
 445                         ret = hclge_set_vf_mc_mac_addr(vport, req, false);
 446                         if (ret)
 447                                 dev_err(&hdev->pdev->dev,
 448                                         "PF fail(%d) to set VF MC MAC Addr\n",
 449                                         ret);
 450                         break;
 451                 case HCLGE_MBX_SET_VLAN:
 452                         ret = hclge_set_vf_vlan_cfg(vport, req, false);
 453                         if (ret)
 454                                 dev_err(&hdev->pdev->dev,
 455                                         "PF failed(%d) to config VF's VLAN\n",
 456                                         ret);
 457                         break;
 458                 case HCLGE_MBX_GET_QINFO:
 459                         ret = hclge_get_vf_queue_info(vport, req, true);
 460                         if (ret)
 461                                 dev_err(&hdev->pdev->dev,
 462                                         "PF failed(%d) to get Q info for VF\n",
 463                                         ret);
 464                         break;
 465                 case HCLGE_MBX_GET_TCINFO:
 466                         ret = hclge_get_vf_tcinfo(vport, req, true);
 467                         if (ret)
 468                                 dev_err(&hdev->pdev->dev,
 469                                         "PF failed(%d) to get TC info for VF\n",
 470                                         ret);
 471                         break;
 472                 case HCLGE_MBX_GET_LINK_STATUS:
 473                         ret = hclge_get_link_info(vport, req);
 474                         if (ret)
 475                                 dev_err(&hdev->pdev->dev,
 476                                         "PF fail(%d) to get link stat for VF\n",
 477                                         ret);
 478                         break;
 479                 case HCLGE_MBX_QUEUE_RESET:
 480                         hclge_mbx_reset_vf_queue(vport, req);
 481                         break;
 482                 case HCLGE_MBX_RESET:
 483                         hclge_reset_vf(vport, req);
 484                         break;
 485                 default:
 486                         dev_err(&hdev->pdev->dev,
 487                                 "un-supported mailbox message, code = %d\n",
 488                                 req->msg[0]);
 489                         break;
 490                 }
 491                 crq->desc[crq->next_to_use].flag = 0;
 492                 hclge_mbx_ring_ptr_move_crq(crq);
 493         }
 494
 495         /* Write back CMDQ_RQ header pointer, M7 need this pointer */
 496         hclge_write_dev(&hdev->hw, HCLGE_NIC_CRQ_HEAD_REG, crq->next_to_use);
 497 }