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