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