drivers/net/ethernet/intel/iavf/iavf_virtchnl.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2013 - 2018 Intel Corporation. */
   3
   4 #include "iavf.h"
   5 #include "iavf_prototype.h"
   6 #include "iavf_client.h"
   7
   8 /* busy wait delay in msec */
   9 #define IAVF_BUSY_WAIT_DELAY 10
  10 #define IAVF_BUSY_WAIT_COUNT 50
  11
  12 /**
  13  * iavf_send_pf_msg
  14  * @adapter: adapter structure
  15  * @op: virtual channel opcode
  16  * @msg: pointer to message buffer
  17  * @len: message length
  18  *
  19  * Send message to PF and print status if failure.
  20  **/
  21 static int iavf_send_pf_msg(struct iavf_adapter *adapter,
  22                             enum virtchnl_ops op, u8 *msg, u16 len)
  23 {
  24         struct iavf_hw *hw = &adapter->hw;
  25         enum iavf_status err;
  26
  27         if (adapter->flags & IAVF_FLAG_PF_COMMS_FAILED)
  28                 return 0; /* nothing to see here, move along */
  29
  30         err = iavf_aq_send_msg_to_pf(hw, op, 0, msg, len, NULL);
  31         if (err)
  32                 dev_dbg(&adapter->pdev->dev, "Unable to send opcode %d to PF, err %s, aq_err %s\n",
  33                         op, iavf_stat_str(hw, err),
  34                         iavf_aq_str(hw, hw->aq.asq_last_status));
  35         return err;
  36 }
  37
  38 /**
  39  * iavf_send_api_ver
  40  * @adapter: adapter structure
  41  *
  42  * Send API version admin queue message to the PF. The reply is not checked
  43  * in this function. Returns 0 if the message was successfully
  44  * sent, or one of the IAVF_ADMIN_QUEUE_ERROR_ statuses if not.
  45  **/
  46 int iavf_send_api_ver(struct iavf_adapter *adapter)
  47 {
  48         struct virtchnl_version_info vvi;
  49
  50         vvi.major = VIRTCHNL_VERSION_MAJOR;
  51         vvi.minor = VIRTCHNL_VERSION_MINOR;
  52
  53         return iavf_send_pf_msg(adapter, VIRTCHNL_OP_VERSION, (u8 *)&vvi,
  54                                 sizeof(vvi));
  55 }
  56
  57 /**
  58  * iavf_verify_api_ver
  59  * @adapter: adapter structure
  60  *
  61  * Compare API versions with the PF. Must be called after admin queue is
  62  * initialized. Returns 0 if API versions match, -EIO if they do not,
  63  * IAVF_ERR_ADMIN_QUEUE_NO_WORK if the admin queue is empty, and any errors
  64  * from the firmware are propagated.
  65  **/
  66 int iavf_verify_api_ver(struct iavf_adapter *adapter)
  67 {
  68         struct virtchnl_version_info *pf_vvi;
  69         struct iavf_hw *hw = &adapter->hw;
  70         struct iavf_arq_event_info event;
  71         enum virtchnl_ops op;
  72         enum iavf_status err;
  73
  74         event.buf_len = IAVF_MAX_AQ_BUF_SIZE;
  75         event.msg_buf = kzalloc(event.buf_len, GFP_KERNEL);
  76         if (!event.msg_buf) {
  77                 err = -ENOMEM;
  78                 goto out;
  79         }
  80
  81         while (1) {
  82                 err = iavf_clean_arq_element(hw, &event, NULL);
  83                 /* When the AQ is empty, iavf_clean_arq_element will return
  84                  * nonzero and this loop will terminate.
  85                  */
  86                 if (err)
  87                         goto out_alloc;
  88                 op =
  89                     (enum virtchnl_ops)le32_to_cpu(event.desc.cookie_high);
  90                 if (op == VIRTCHNL_OP_VERSION)
  91                         break;
  92         }
  93
  94
  95         err = (enum iavf_status)le32_to_cpu(event.desc.cookie_low);
  96         if (err)
  97                 goto out_alloc;
  98
  99         if (op != VIRTCHNL_OP_VERSION) {
 100                 dev_info(&adapter->pdev->dev, "Invalid reply type %d from PF\n",
 101                         op);
 102                 err = -EIO;
 103                 goto out_alloc;
 104         }
 105
 106         pf_vvi = (struct virtchnl_version_info *)event.msg_buf;
 107         adapter->pf_version = *pf_vvi;
 108
 109         if ((pf_vvi->major > VIRTCHNL_VERSION_MAJOR) ||
 110             ((pf_vvi->major == VIRTCHNL_VERSION_MAJOR) &&
 111              (pf_vvi->minor > VIRTCHNL_VERSION_MINOR)))
 112                 err = -EIO;
 113
 114 out_alloc:
 115         kfree(event.msg_buf);
 116 out:
 117         return err;
 118 }
 119
 120 /**
 121  * iavf_send_vf_config_msg
 122  * @adapter: adapter structure
 123  *
 124  * Send VF configuration request admin queue message to the PF. The reply
 125  * is not checked in this function. Returns 0 if the message was
 126  * successfully sent, or one of the IAVF_ADMIN_QUEUE_ERROR_ statuses if not.
 127  **/
 128 int iavf_send_vf_config_msg(struct iavf_adapter *adapter)
 129 {
 130         u32 caps;
 131
 132         caps = VIRTCHNL_VF_OFFLOAD_L2 |
 133                VIRTCHNL_VF_OFFLOAD_RSS_PF |
 134                VIRTCHNL_VF_OFFLOAD_RSS_AQ |
 135                VIRTCHNL_VF_OFFLOAD_RSS_REG |
 136                VIRTCHNL_VF_OFFLOAD_VLAN |
 137                VIRTCHNL_VF_OFFLOAD_WB_ON_ITR |
 138                VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2 |
 139                VIRTCHNL_VF_OFFLOAD_ENCAP |
 140                VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM |
 141                VIRTCHNL_VF_OFFLOAD_REQ_QUEUES |
 142                VIRTCHNL_VF_OFFLOAD_ADQ;
 143
 144         adapter->current_op = VIRTCHNL_OP_GET_VF_RESOURCES;
 145         adapter->aq_required &= ~IAVF_FLAG_AQ_GET_CONFIG;
 146         if (PF_IS_V11(adapter))
 147                 return iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_VF_RESOURCES,
 148                                         (u8 *)&caps, sizeof(caps));
 149         else
 150                 return iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_VF_RESOURCES,
 151                                         NULL, 0);
 152 }
 153
 154 /**
 155  * iavf_validate_num_queues
 156  * @adapter: adapter structure
 157  *
 158  * Validate that the number of queues the PF has sent in
 159  * VIRTCHNL_OP_GET_VF_RESOURCES is not larger than the VF can handle.
 160  **/
 161 static void iavf_validate_num_queues(struct iavf_adapter *adapter)
 162 {
 163         if (adapter->vf_res->num_queue_pairs > IAVF_MAX_REQ_QUEUES) {
 164                 struct virtchnl_vsi_resource *vsi_res;
 165                 int i;
 166
 167                 dev_info(&adapter->pdev->dev, "Received %d queues, but can only have a max of %d\n",
 168                          adapter->vf_res->num_queue_pairs,
 169                          IAVF_MAX_REQ_QUEUES);
 170                 dev_info(&adapter->pdev->dev, "Fixing by reducing queues to %d\n",
 171                          IAVF_MAX_REQ_QUEUES);
 172                 adapter->vf_res->num_queue_pairs = IAVF_MAX_REQ_QUEUES;
 173                 for (i = 0; i < adapter->vf_res->num_vsis; i++) {
 174                         vsi_res = &adapter->vf_res->vsi_res[i];
 175                         vsi_res->num_queue_pairs = IAVF_MAX_REQ_QUEUES;
 176                 }
 177         }
 178 }
 179
 180 /**
 181  * iavf_get_vf_config
 182  * @adapter: private adapter structure
 183  *
 184  * Get VF configuration from PF and populate hw structure. Must be called after
 185  * admin queue is initialized. Busy waits until response is received from PF,
 186  * with maximum timeout. Response from PF is returned in the buffer for further
 187  * processing by the caller.
 188  **/
 189 int iavf_get_vf_config(struct iavf_adapter *adapter)
 190 {
 191         struct iavf_hw *hw = &adapter->hw;
 192         struct iavf_arq_event_info event;
 193         enum virtchnl_ops op;
 194         enum iavf_status err;
 195         u16 len;
 196
 197         len =  sizeof(struct virtchnl_vf_resource) +
 198                 IAVF_MAX_VF_VSI * sizeof(struct virtchnl_vsi_resource);
 199         event.buf_len = len;
 200         event.msg_buf = kzalloc(event.buf_len, GFP_KERNEL);
 201         if (!event.msg_buf) {
 202                 err = -ENOMEM;
 203                 goto out;
 204         }
 205
 206         while (1) {
 207                 /* When the AQ is empty, iavf_clean_arq_element will return
 208                  * nonzero and this loop will terminate.
 209                  */
 210                 err = iavf_clean_arq_element(hw, &event, NULL);
 211                 if (err)
 212                         goto out_alloc;
 213                 op =
 214                     (enum virtchnl_ops)le32_to_cpu(event.desc.cookie_high);
 215                 if (op == VIRTCHNL_OP_GET_VF_RESOURCES)
 216                         break;
 217         }
 218
 219         err = (enum iavf_status)le32_to_cpu(event.desc.cookie_low);
 220         memcpy(adapter->vf_res, event.msg_buf, min(event.msg_len, len));
 221
 222         /* some PFs send more queues than we should have so validate that
 223          * we aren't getting too many queues
 224          */
 225         if (!err)
 226                 iavf_validate_num_queues(adapter);
 227         iavf_vf_parse_hw_config(hw, adapter->vf_res);
 228 out_alloc:
 229         kfree(event.msg_buf);
 230 out:
 231         return err;
 232 }
 233
 234 /**
 235  * iavf_configure_queues
 236  * @adapter: adapter structure
 237  *
 238  * Request that the PF set up our (previously allocated) queues.
 239  **/
 240 void iavf_configure_queues(struct iavf_adapter *adapter)
 241 {
 242         struct virtchnl_vsi_queue_config_info *vqci;
 243         struct virtchnl_queue_pair_info *vqpi;
 244         int pairs = adapter->num_active_queues;
 245         int i, max_frame = IAVF_MAX_RXBUFFER;
 246         size_t len;
 247
 248         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 249                 /* bail because we already have a command pending */
 250                 dev_err(&adapter->pdev->dev, "Cannot configure queues, command %d pending\n",
 251                         adapter->current_op);
 252                 return;
 253         }
 254         adapter->current_op = VIRTCHNL_OP_CONFIG_VSI_QUEUES;
 255         len = struct_size(vqci, qpair, pairs);
 256         vqci = kzalloc(len, GFP_KERNEL);
 257         if (!vqci)
 258                 return;
 259
 260         /* Limit maximum frame size when jumbo frames is not enabled */
 261         if (!(adapter->flags & IAVF_FLAG_LEGACY_RX) &&
 262             (adapter->netdev->mtu <= ETH_DATA_LEN))
 263                 max_frame = IAVF_RXBUFFER_1536 - NET_IP_ALIGN;
 264
 265         vqci->vsi_id = adapter->vsi_res->vsi_id;
 266         vqci->num_queue_pairs = pairs;
 267         vqpi = vqci->qpair;
 268         /* Size check is not needed here - HW max is 16 queue pairs, and we
 269          * can fit info for 31 of them into the AQ buffer before it overflows.
 270          */
 271         for (i = 0; i < pairs; i++) {
 272                 vqpi->txq.vsi_id = vqci->vsi_id;
 273                 vqpi->txq.queue_id = i;
 274                 vqpi->txq.ring_len = adapter->tx_rings[i].count;
 275                 vqpi->txq.dma_ring_addr = adapter->tx_rings[i].dma;
 276                 vqpi->rxq.vsi_id = vqci->vsi_id;
 277                 vqpi->rxq.queue_id = i;
 278                 vqpi->rxq.ring_len = adapter->rx_rings[i].count;
 279                 vqpi->rxq.dma_ring_addr = adapter->rx_rings[i].dma;
 280                 vqpi->rxq.max_pkt_size = max_frame;
 281                 vqpi->rxq.databuffer_size =
 282                         ALIGN(adapter->rx_rings[i].rx_buf_len,
 283                               BIT_ULL(IAVF_RXQ_CTX_DBUFF_SHIFT));
 284                 vqpi++;
 285         }
 286
 287         adapter->aq_required &= ~IAVF_FLAG_AQ_CONFIGURE_QUEUES;
 288         iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_VSI_QUEUES,
 289                          (u8 *)vqci, len);
 290         kfree(vqci);
 291 }
 292
 293 /**
 294  * iavf_enable_queues
 295  * @adapter: adapter structure
 296  *
 297  * Request that the PF enable all of our queues.
 298  **/
 299 void iavf_enable_queues(struct iavf_adapter *adapter)
 300 {
 301         struct virtchnl_queue_select vqs;
 302
 303         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 304                 /* bail because we already have a command pending */
 305                 dev_err(&adapter->pdev->dev, "Cannot enable queues, command %d pending\n",
 306                         adapter->current_op);
 307                 return;
 308         }
 309         adapter->current_op = VIRTCHNL_OP_ENABLE_QUEUES;
 310         vqs.vsi_id = adapter->vsi_res->vsi_id;
 311         vqs.tx_queues = BIT(adapter->num_active_queues) - 1;
 312         vqs.rx_queues = vqs.tx_queues;
 313         adapter->aq_required &= ~IAVF_FLAG_AQ_ENABLE_QUEUES;
 314         iavf_send_pf_msg(adapter, VIRTCHNL_OP_ENABLE_QUEUES,
 315                          (u8 *)&vqs, sizeof(vqs));
 316 }
 317
 318 /**
 319  * iavf_disable_queues
 320  * @adapter: adapter structure
 321  *
 322  * Request that the PF disable all of our queues.
 323  **/
 324 void iavf_disable_queues(struct iavf_adapter *adapter)
 325 {
 326         struct virtchnl_queue_select vqs;
 327
 328         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 329                 /* bail because we already have a command pending */
 330                 dev_err(&adapter->pdev->dev, "Cannot disable queues, command %d pending\n",
 331                         adapter->current_op);
 332                 return;
 333         }
 334         adapter->current_op = VIRTCHNL_OP_DISABLE_QUEUES;
 335         vqs.vsi_id = adapter->vsi_res->vsi_id;
 336         vqs.tx_queues = BIT(adapter->num_active_queues) - 1;
 337         vqs.rx_queues = vqs.tx_queues;
 338         adapter->aq_required &= ~IAVF_FLAG_AQ_DISABLE_QUEUES;
 339         iavf_send_pf_msg(adapter, VIRTCHNL_OP_DISABLE_QUEUES,
 340                          (u8 *)&vqs, sizeof(vqs));
 341 }
 342
 343 /**
 344  * iavf_map_queues
 345  * @adapter: adapter structure
 346  *
 347  * Request that the PF map queues to interrupt vectors. Misc causes, including
 348  * admin queue, are always mapped to vector 0.
 349  **/
 350 void iavf_map_queues(struct iavf_adapter *adapter)
 351 {
 352         struct virtchnl_irq_map_info *vimi;
 353         struct virtchnl_vector_map *vecmap;
 354         struct iavf_q_vector *q_vector;
 355         int v_idx, q_vectors;
 356         size_t len;
 357
 358         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 359                 /* bail because we already have a command pending */
 360                 dev_err(&adapter->pdev->dev, "Cannot map queues to vectors, command %d pending\n",
 361                         adapter->current_op);
 362                 return;
 363         }
 364         adapter->current_op = VIRTCHNL_OP_CONFIG_IRQ_MAP;
 365
 366         q_vectors = adapter->num_msix_vectors - NONQ_VECS;
 367
 368         len = struct_size(vimi, vecmap, adapter->num_msix_vectors);
 369         vimi = kzalloc(len, GFP_KERNEL);
 370         if (!vimi)
 371                 return;
 372
 373         vimi->num_vectors = adapter->num_msix_vectors;
 374         /* Queue vectors first */
 375         for (v_idx = 0; v_idx < q_vectors; v_idx++) {
 376                 q_vector = &adapter->q_vectors[v_idx];
 377                 vecmap = &vimi->vecmap[v_idx];
 378
 379                 vecmap->vsi_id = adapter->vsi_res->vsi_id;
 380                 vecmap->vector_id = v_idx + NONQ_VECS;
 381                 vecmap->txq_map = q_vector->ring_mask;
 382                 vecmap->rxq_map = q_vector->ring_mask;
 383                 vecmap->rxitr_idx = IAVF_RX_ITR;
 384                 vecmap->txitr_idx = IAVF_TX_ITR;
 385         }
 386         /* Misc vector last - this is only for AdminQ messages */
 387         vecmap = &vimi->vecmap[v_idx];
 388         vecmap->vsi_id = adapter->vsi_res->vsi_id;
 389         vecmap->vector_id = 0;
 390         vecmap->txq_map = 0;
 391         vecmap->rxq_map = 0;
 392
 393         adapter->aq_required &= ~IAVF_FLAG_AQ_MAP_VECTORS;
 394         iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_IRQ_MAP,
 395                          (u8 *)vimi, len);
 396         kfree(vimi);
 397 }
 398
 399 /**
 400  * iavf_add_ether_addrs
 401  * @adapter: adapter structure
 402  *
 403  * Request that the PF add one or more addresses to our filters.
 404  **/
 405 void iavf_add_ether_addrs(struct iavf_adapter *adapter)
 406 {
 407         struct virtchnl_ether_addr_list *veal;
 408         struct iavf_mac_filter *f;
 409         int i = 0, count = 0;
 410         bool more = false;
 411         size_t len;
 412
 413         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 414                 /* bail because we already have a command pending */
 415                 dev_err(&adapter->pdev->dev, "Cannot add filters, command %d pending\n",
 416                         adapter->current_op);
 417                 return;
 418         }
 419
 420         spin_lock_bh(&adapter->mac_vlan_list_lock);
 421
 422         list_for_each_entry(f, &adapter->mac_filter_list, list) {
 423                 if (f->add)
 424                         count++;
 425         }
 426         if (!count) {
 427                 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_MAC_FILTER;
 428                 spin_unlock_bh(&adapter->mac_vlan_list_lock);
 429                 return;
 430         }
 431         adapter->current_op = VIRTCHNL_OP_ADD_ETH_ADDR;
 432
 433         len = struct_size(veal, list, count);
 434         if (len > IAVF_MAX_AQ_BUF_SIZE) {
 435                 dev_warn(&adapter->pdev->dev, "Too many add MAC changes in one request\n");
 436                 count = (IAVF_MAX_AQ_BUF_SIZE -
 437                          sizeof(struct virtchnl_ether_addr_list)) /
 438                         sizeof(struct virtchnl_ether_addr);
 439                 len = struct_size(veal, list, count);
 440                 more = true;
 441         }
 442
 443         veal = kzalloc(len, GFP_ATOMIC);
 444         if (!veal) {
 445                 spin_unlock_bh(&adapter->mac_vlan_list_lock);
 446                 return;
 447         }
 448
 449         veal->vsi_id = adapter->vsi_res->vsi_id;
 450         veal->num_elements = count;
 451         list_for_each_entry(f, &adapter->mac_filter_list, list) {
 452                 if (f->add) {
 453                         ether_addr_copy(veal->list[i].addr, f->macaddr);
 454                         i++;
 455                         f->add = false;
 456                         if (i == count)
 457                                 break;
 458                 }
 459         }
 460         if (!more)
 461                 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_MAC_FILTER;
 462
 463         spin_unlock_bh(&adapter->mac_vlan_list_lock);
 464
 465         iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_ETH_ADDR, (u8 *)veal, len);
 466         kfree(veal);
 467 }
 468
 469 /**
 470  * iavf_del_ether_addrs
 471  * @adapter: adapter structure
 472  *
 473  * Request that the PF remove one or more addresses from our filters.
 474  **/
 475 void iavf_del_ether_addrs(struct iavf_adapter *adapter)
 476 {
 477         struct virtchnl_ether_addr_list *veal;
 478         struct iavf_mac_filter *f, *ftmp;
 479         int i = 0, count = 0;
 480         bool more = false;
 481         size_t len;
 482
 483         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 484                 /* bail because we already have a command pending */
 485                 dev_err(&adapter->pdev->dev, "Cannot remove filters, command %d pending\n",
 486                         adapter->current_op);
 487                 return;
 488         }
 489
 490         spin_lock_bh(&adapter->mac_vlan_list_lock);
 491
 492         list_for_each_entry(f, &adapter->mac_filter_list, list) {
 493                 if (f->remove)
 494                         count++;
 495         }
 496         if (!count) {
 497                 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_MAC_FILTER;
 498                 spin_unlock_bh(&adapter->mac_vlan_list_lock);
 499                 return;
 500         }
 501         adapter->current_op = VIRTCHNL_OP_DEL_ETH_ADDR;
 502
 503         len = struct_size(veal, list, count);
 504         if (len > IAVF_MAX_AQ_BUF_SIZE) {
 505                 dev_warn(&adapter->pdev->dev, "Too many delete MAC changes in one request\n");
 506                 count = (IAVF_MAX_AQ_BUF_SIZE -
 507                          sizeof(struct virtchnl_ether_addr_list)) /
 508                         sizeof(struct virtchnl_ether_addr);
 509                 len = struct_size(veal, list, count);
 510                 more = true;
 511         }
 512         veal = kzalloc(len, GFP_ATOMIC);
 513         if (!veal) {
 514                 spin_unlock_bh(&adapter->mac_vlan_list_lock);
 515                 return;
 516         }
 517
 518         veal->vsi_id = adapter->vsi_res->vsi_id;
 519         veal->num_elements = count;
 520         list_for_each_entry_safe(f, ftmp, &adapter->mac_filter_list, list) {
 521                 if (f->remove) {
 522                         ether_addr_copy(veal->list[i].addr, f->macaddr);
 523                         i++;
 524                         list_del(&f->list);
 525                         kfree(f);
 526                         if (i == count)
 527                                 break;
 528                 }
 529         }
 530         if (!more)
 531                 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_MAC_FILTER;
 532
 533         spin_unlock_bh(&adapter->mac_vlan_list_lock);
 534
 535         iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_ETH_ADDR, (u8 *)veal, len);
 536         kfree(veal);
 537 }
 538
 539 /**
 540  * iavf_add_vlans
 541  * @adapter: adapter structure
 542  *
 543  * Request that the PF add one or more VLAN filters to our VSI.
 544  **/
 545 void iavf_add_vlans(struct iavf_adapter *adapter)
 546 {
 547         struct virtchnl_vlan_filter_list *vvfl;
 548         int len, i = 0, count = 0;
 549         struct iavf_vlan_filter *f;
 550         bool more = false;
 551
 552         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 553                 /* bail because we already have a command pending */
 554                 dev_err(&adapter->pdev->dev, "Cannot add VLANs, command %d pending\n",
 555                         adapter->current_op);
 556                 return;
 557         }
 558
 559         spin_lock_bh(&adapter->mac_vlan_list_lock);
 560
 561         list_for_each_entry(f, &adapter->vlan_filter_list, list) {
 562                 if (f->add)
 563                         count++;
 564         }
 565         if (!count) {
 566                 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_VLAN_FILTER;
 567                 spin_unlock_bh(&adapter->mac_vlan_list_lock);
 568                 return;
 569         }
 570         adapter->current_op = VIRTCHNL_OP_ADD_VLAN;
 571
 572         len = sizeof(struct virtchnl_vlan_filter_list) +
 573               (count * sizeof(u16));
 574         if (len > IAVF_MAX_AQ_BUF_SIZE) {
 575                 dev_warn(&adapter->pdev->dev, "Too many add VLAN changes in one request\n");
 576                 count = (IAVF_MAX_AQ_BUF_SIZE -
 577                          sizeof(struct virtchnl_vlan_filter_list)) /
 578                         sizeof(u16);
 579                 len = sizeof(struct virtchnl_vlan_filter_list) +
 580                       (count * sizeof(u16));
 581                 more = true;
 582         }
 583         vvfl = kzalloc(len, GFP_ATOMIC);
 584         if (!vvfl) {
 585                 spin_unlock_bh(&adapter->mac_vlan_list_lock);
 586                 return;
 587         }
 588
 589         vvfl->vsi_id = adapter->vsi_res->vsi_id;
 590         vvfl->num_elements = count;
 591         list_for_each_entry(f, &adapter->vlan_filter_list, list) {
 592                 if (f->add) {
 593                         vvfl->vlan_id[i] = f->vlan;
 594                         i++;
 595                         f->add = false;
 596                         if (i == count)
 597                                 break;
 598                 }
 599         }
 600         if (!more)
 601                 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_VLAN_FILTER;
 602
 603         spin_unlock_bh(&adapter->mac_vlan_list_lock);
 604
 605         iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_VLAN, (u8 *)vvfl, len);
 606         kfree(vvfl);
 607 }
 608
 609 /**
 610  * iavf_del_vlans
 611  * @adapter: adapter structure
 612  *
 613  * Request that the PF remove one or more VLAN filters from our VSI.
 614  **/
 615 void iavf_del_vlans(struct iavf_adapter *adapter)
 616 {
 617         struct virtchnl_vlan_filter_list *vvfl;
 618         struct iavf_vlan_filter *f, *ftmp;
 619         int len, i = 0, count = 0;
 620         bool more = false;
 621
 622         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 623                 /* bail because we already have a command pending */
 624                 dev_err(&adapter->pdev->dev, "Cannot remove VLANs, command %d pending\n",
 625                         adapter->current_op);
 626                 return;
 627         }
 628
 629         spin_lock_bh(&adapter->mac_vlan_list_lock);
 630
 631         list_for_each_entry(f, &adapter->vlan_filter_list, list) {
 632                 if (f->remove)
 633                         count++;
 634         }
 635         if (!count) {
 636                 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_VLAN_FILTER;
 637                 spin_unlock_bh(&adapter->mac_vlan_list_lock);
 638                 return;
 639         }
 640         adapter->current_op = VIRTCHNL_OP_DEL_VLAN;
 641
 642         len = sizeof(struct virtchnl_vlan_filter_list) +
 643               (count * sizeof(u16));
 644         if (len > IAVF_MAX_AQ_BUF_SIZE) {
 645                 dev_warn(&adapter->pdev->dev, "Too many delete VLAN changes in one request\n");
 646                 count = (IAVF_MAX_AQ_BUF_SIZE -
 647                          sizeof(struct virtchnl_vlan_filter_list)) /
 648                         sizeof(u16);
 649                 len = sizeof(struct virtchnl_vlan_filter_list) +
 650                       (count * sizeof(u16));
 651                 more = true;
 652         }
 653         vvfl = kzalloc(len, GFP_ATOMIC);
 654         if (!vvfl) {
 655                 spin_unlock_bh(&adapter->mac_vlan_list_lock);
 656                 return;
 657         }
 658
 659         vvfl->vsi_id = adapter->vsi_res->vsi_id;
 660         vvfl->num_elements = count;
 661         list_for_each_entry_safe(f, ftmp, &adapter->vlan_filter_list, list) {
 662                 if (f->remove) {
 663                         vvfl->vlan_id[i] = f->vlan;
 664                         i++;
 665                         list_del(&f->list);
 666                         kfree(f);
 667                         if (i == count)
 668                                 break;
 669                 }
 670         }
 671         if (!more)
 672                 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_VLAN_FILTER;
 673
 674         spin_unlock_bh(&adapter->mac_vlan_list_lock);
 675
 676         iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_VLAN, (u8 *)vvfl, len);
 677         kfree(vvfl);
 678 }
 679
 680 /**
 681  * iavf_set_promiscuous
 682  * @adapter: adapter structure
 683  * @flags: bitmask to control unicast/multicast promiscuous.
 684  *
 685  * Request that the PF enable promiscuous mode for our VSI.
 686  **/
 687 void iavf_set_promiscuous(struct iavf_adapter *adapter, int flags)
 688 {
 689         struct virtchnl_promisc_info vpi;
 690         int promisc_all;
 691
 692         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 693                 /* bail because we already have a command pending */
 694                 dev_err(&adapter->pdev->dev, "Cannot set promiscuous mode, command %d pending\n",
 695                         adapter->current_op);
 696                 return;
 697         }
 698
 699         promisc_all = FLAG_VF_UNICAST_PROMISC |
 700                       FLAG_VF_MULTICAST_PROMISC;
 701         if ((flags & promisc_all) == promisc_all) {
 702                 adapter->flags |= IAVF_FLAG_PROMISC_ON;
 703                 adapter->aq_required &= ~IAVF_FLAG_AQ_REQUEST_PROMISC;
 704                 dev_info(&adapter->pdev->dev, "Entering promiscuous mode\n");
 705         }
 706
 707         if (flags & FLAG_VF_MULTICAST_PROMISC) {
 708                 adapter->flags |= IAVF_FLAG_ALLMULTI_ON;
 709                 adapter->aq_required &= ~IAVF_FLAG_AQ_REQUEST_ALLMULTI;
 710                 dev_info(&adapter->pdev->dev, "Entering multicast promiscuous mode\n");
 711         }
 712
 713         if (!flags) {
 714                 adapter->flags &= ~(IAVF_FLAG_PROMISC_ON |
 715                                     IAVF_FLAG_ALLMULTI_ON);
 716                 adapter->aq_required &= ~(IAVF_FLAG_AQ_RELEASE_PROMISC |
 717                                           IAVF_FLAG_AQ_RELEASE_ALLMULTI);
 718                 dev_info(&adapter->pdev->dev, "Leaving promiscuous mode\n");
 719         }
 720
 721         adapter->current_op = VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE;
 722         vpi.vsi_id = adapter->vsi_res->vsi_id;
 723         vpi.flags = flags;
 724         iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE,
 725                          (u8 *)&vpi, sizeof(vpi));
 726 }
 727
 728 /**
 729  * iavf_request_stats
 730  * @adapter: adapter structure
 731  *
 732  * Request VSI statistics from PF.
 733  **/
 734 void iavf_request_stats(struct iavf_adapter *adapter)
 735 {
 736         struct virtchnl_queue_select vqs;
 737
 738         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 739                 /* no error message, this isn't crucial */
 740                 return;
 741         }
 742         adapter->current_op = VIRTCHNL_OP_GET_STATS;
 743         vqs.vsi_id = adapter->vsi_res->vsi_id;
 744         /* queue maps are ignored for this message - only the vsi is used */
 745         if (iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_STATS, (u8 *)&vqs,
 746                              sizeof(vqs)))
 747                 /* if the request failed, don't lock out others */
 748                 adapter->current_op = VIRTCHNL_OP_UNKNOWN;
 749 }
 750
 751 /**
 752  * iavf_get_hena
 753  * @adapter: adapter structure
 754  *
 755  * Request hash enable capabilities from PF
 756  **/
 757 void iavf_get_hena(struct iavf_adapter *adapter)
 758 {
 759         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 760                 /* bail because we already have a command pending */
 761                 dev_err(&adapter->pdev->dev, "Cannot get RSS hash capabilities, command %d pending\n",
 762                         adapter->current_op);
 763                 return;
 764         }
 765         adapter->current_op = VIRTCHNL_OP_GET_RSS_HENA_CAPS;
 766         adapter->aq_required &= ~IAVF_FLAG_AQ_GET_HENA;
 767         iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_RSS_HENA_CAPS, NULL, 0);
 768 }
 769
 770 /**
 771  * iavf_set_hena
 772  * @adapter: adapter structure
 773  *
 774  * Request the PF to set our RSS hash capabilities
 775  **/
 776 void iavf_set_hena(struct iavf_adapter *adapter)
 777 {
 778         struct virtchnl_rss_hena vrh;
 779
 780         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 781                 /* bail because we already have a command pending */
 782                 dev_err(&adapter->pdev->dev, "Cannot set RSS hash enable, command %d pending\n",
 783                         adapter->current_op);
 784                 return;
 785         }
 786         vrh.hena = adapter->hena;
 787         adapter->current_op = VIRTCHNL_OP_SET_RSS_HENA;
 788         adapter->aq_required &= ~IAVF_FLAG_AQ_SET_HENA;
 789         iavf_send_pf_msg(adapter, VIRTCHNL_OP_SET_RSS_HENA, (u8 *)&vrh,
 790                          sizeof(vrh));
 791 }
 792
 793 /**
 794  * iavf_set_rss_key
 795  * @adapter: adapter structure
 796  *
 797  * Request the PF to set our RSS hash key
 798  **/
 799 void iavf_set_rss_key(struct iavf_adapter *adapter)
 800 {
 801         struct virtchnl_rss_key *vrk;
 802         int len;
 803
 804         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 805                 /* bail because we already have a command pending */
 806                 dev_err(&adapter->pdev->dev, "Cannot set RSS key, command %d pending\n",
 807                         adapter->current_op);
 808                 return;
 809         }
 810         len = sizeof(struct virtchnl_rss_key) +
 811               (adapter->rss_key_size * sizeof(u8)) - 1;
 812         vrk = kzalloc(len, GFP_KERNEL);
 813         if (!vrk)
 814                 return;
 815         vrk->vsi_id = adapter->vsi.id;
 816         vrk->key_len = adapter->rss_key_size;
 817         memcpy(vrk->key, adapter->rss_key, adapter->rss_key_size);
 818
 819         adapter->current_op = VIRTCHNL_OP_CONFIG_RSS_KEY;
 820         adapter->aq_required &= ~IAVF_FLAG_AQ_SET_RSS_KEY;
 821         iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_RSS_KEY, (u8 *)vrk, len);
 822         kfree(vrk);
 823 }
 824
 825 /**
 826  * iavf_set_rss_lut
 827  * @adapter: adapter structure
 828  *
 829  * Request the PF to set our RSS lookup table
 830  **/
 831 void iavf_set_rss_lut(struct iavf_adapter *adapter)
 832 {
 833         struct virtchnl_rss_lut *vrl;
 834         int len;
 835
 836         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 837                 /* bail because we already have a command pending */
 838                 dev_err(&adapter->pdev->dev, "Cannot set RSS LUT, command %d pending\n",
 839                         adapter->current_op);
 840                 return;
 841         }
 842         len = sizeof(struct virtchnl_rss_lut) +
 843               (adapter->rss_lut_size * sizeof(u8)) - 1;
 844         vrl = kzalloc(len, GFP_KERNEL);
 845         if (!vrl)
 846                 return;
 847         vrl->vsi_id = adapter->vsi.id;
 848         vrl->lut_entries = adapter->rss_lut_size;
 849         memcpy(vrl->lut, adapter->rss_lut, adapter->rss_lut_size);
 850         adapter->current_op = VIRTCHNL_OP_CONFIG_RSS_LUT;
 851         adapter->aq_required &= ~IAVF_FLAG_AQ_SET_RSS_LUT;
 852         iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_RSS_LUT, (u8 *)vrl, len);
 853         kfree(vrl);
 854 }
 855
 856 /**
 857  * iavf_enable_vlan_stripping
 858  * @adapter: adapter structure
 859  *
 860  * Request VLAN header stripping to be enabled
 861  **/
 862 void iavf_enable_vlan_stripping(struct iavf_adapter *adapter)
 863 {
 864         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 865                 /* bail because we already have a command pending */
 866                 dev_err(&adapter->pdev->dev, "Cannot enable stripping, command %d pending\n",
 867                         adapter->current_op);
 868                 return;
 869         }
 870         adapter->current_op = VIRTCHNL_OP_ENABLE_VLAN_STRIPPING;
 871         adapter->aq_required &= ~IAVF_FLAG_AQ_ENABLE_VLAN_STRIPPING;
 872         iavf_send_pf_msg(adapter, VIRTCHNL_OP_ENABLE_VLAN_STRIPPING, NULL, 0);
 873 }
 874
 875 /**
 876  * iavf_disable_vlan_stripping
 877  * @adapter: adapter structure
 878  *
 879  * Request VLAN header stripping to be disabled
 880  **/
 881 void iavf_disable_vlan_stripping(struct iavf_adapter *adapter)
 882 {
 883         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 884                 /* bail because we already have a command pending */
 885                 dev_err(&adapter->pdev->dev, "Cannot disable stripping, command %d pending\n",
 886                         adapter->current_op);
 887                 return;
 888         }
 889         adapter->current_op = VIRTCHNL_OP_DISABLE_VLAN_STRIPPING;
 890         adapter->aq_required &= ~IAVF_FLAG_AQ_DISABLE_VLAN_STRIPPING;
 891         iavf_send_pf_msg(adapter, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING, NULL, 0);
 892 }
 893
 894 /**
 895  * iavf_print_link_message - print link up or down
 896  * @adapter: adapter structure
 897  *
 898  * Log a message telling the world of our wonderous link status
 899  */
 900 static void iavf_print_link_message(struct iavf_adapter *adapter)
 901 {
 902         struct net_device *netdev = adapter->netdev;
 903         char *speed = "Unknown ";
 904
 905         if (!adapter->link_up) {
 906                 netdev_info(netdev, "NIC Link is Down\n");
 907                 return;
 908         }
 909
 910         switch (adapter->link_speed) {
 911         case IAVF_LINK_SPEED_40GB:
 912                 speed = "40 G";
 913                 break;
 914         case IAVF_LINK_SPEED_25GB:
 915                 speed = "25 G";
 916                 break;
 917         case IAVF_LINK_SPEED_20GB:
 918                 speed = "20 G";
 919                 break;
 920         case IAVF_LINK_SPEED_10GB:
 921                 speed = "10 G";
 922                 break;
 923         case IAVF_LINK_SPEED_1GB:
 924                 speed = "1000 M";
 925                 break;
 926         case IAVF_LINK_SPEED_100MB:
 927                 speed = "100 M";
 928                 break;
 929         default:
 930                 break;
 931         }
 932
 933         netdev_info(netdev, "NIC Link is Up %sbps Full Duplex\n", speed);
 934 }
 935
 936 /**
 937  * iavf_enable_channel
 938  * @adapter: adapter structure
 939  *
 940  * Request that the PF enable channels as specified by
 941  * the user via tc tool.
 942  **/
 943 void iavf_enable_channels(struct iavf_adapter *adapter)
 944 {
 945         struct virtchnl_tc_info *vti = NULL;
 946         size_t len;
 947         int i;
 948
 949         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 950                 /* bail because we already have a command pending */
 951                 dev_err(&adapter->pdev->dev, "Cannot configure mqprio, command %d pending\n",
 952                         adapter->current_op);
 953                 return;
 954         }
 955
 956         len = struct_size(vti, list, adapter->num_tc - 1);
 957         vti = kzalloc(len, GFP_KERNEL);
 958         if (!vti)
 959                 return;
 960         vti->num_tc = adapter->num_tc;
 961         for (i = 0; i < vti->num_tc; i++) {
 962                 vti->list[i].count = adapter->ch_config.ch_info[i].count;
 963                 vti->list[i].offset = adapter->ch_config.ch_info[i].offset;
 964                 vti->list[i].pad = 0;
 965                 vti->list[i].max_tx_rate =
 966                                 adapter->ch_config.ch_info[i].max_tx_rate;
 967         }
 968
 969         adapter->ch_config.state = __IAVF_TC_RUNNING;
 970         adapter->flags |= IAVF_FLAG_REINIT_ITR_NEEDED;
 971         adapter->current_op = VIRTCHNL_OP_ENABLE_CHANNELS;
 972         adapter->aq_required &= ~IAVF_FLAG_AQ_ENABLE_CHANNELS;
 973         iavf_send_pf_msg(adapter, VIRTCHNL_OP_ENABLE_CHANNELS, (u8 *)vti, len);
 974         kfree(vti);
 975 }
 976
 977 /**
 978  * iavf_disable_channel
 979  * @adapter: adapter structure
 980  *
 981  * Request that the PF disable channels that are configured
 982  **/
 983 void iavf_disable_channels(struct iavf_adapter *adapter)
 984 {
 985         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
 986                 /* bail because we already have a command pending */
 987                 dev_err(&adapter->pdev->dev, "Cannot configure mqprio, command %d pending\n",
 988                         adapter->current_op);
 989                 return;
 990         }
 991
 992         adapter->ch_config.state = __IAVF_TC_INVALID;
 993         adapter->flags |= IAVF_FLAG_REINIT_ITR_NEEDED;
 994         adapter->current_op = VIRTCHNL_OP_DISABLE_CHANNELS;
 995         adapter->aq_required &= ~IAVF_FLAG_AQ_DISABLE_CHANNELS;
 996         iavf_send_pf_msg(adapter, VIRTCHNL_OP_DISABLE_CHANNELS, NULL, 0);
 997 }
 998
 999 /**
1000  * iavf_print_cloud_filter
1001  * @adapter: adapter structure
1002  * @f: cloud filter to print
1003  *
1004  * Print the cloud filter
1005  **/
1006 static void iavf_print_cloud_filter(struct iavf_adapter *adapter,
1007                                     struct virtchnl_filter *f)
1008 {
1009         switch (f->flow_type) {
1010         case VIRTCHNL_TCP_V4_FLOW:
1011                 dev_info(&adapter->pdev->dev, "dst_mac: %pM src_mac: %pM vlan_id: %hu dst_ip: %pI4 src_ip %pI4 dst_port %hu src_port %hu\n",
1012                          &f->data.tcp_spec.dst_mac,
1013                          &f->data.tcp_spec.src_mac,
1014                          ntohs(f->data.tcp_spec.vlan_id),
1015                          &f->data.tcp_spec.dst_ip[0],
1016                          &f->data.tcp_spec.src_ip[0],
1017                          ntohs(f->data.tcp_spec.dst_port),
1018                          ntohs(f->data.tcp_spec.src_port));
1019                 break;
1020         case VIRTCHNL_TCP_V6_FLOW:
1021                 dev_info(&adapter->pdev->dev, "dst_mac: %pM src_mac: %pM vlan_id: %hu dst_ip: %pI6 src_ip %pI6 dst_port %hu src_port %hu\n",
1022                          &f->data.tcp_spec.dst_mac,
1023                          &f->data.tcp_spec.src_mac,
1024                          ntohs(f->data.tcp_spec.vlan_id),
1025                          &f->data.tcp_spec.dst_ip,
1026                          &f->data.tcp_spec.src_ip,
1027                          ntohs(f->data.tcp_spec.dst_port),
1028                          ntohs(f->data.tcp_spec.src_port));
1029                 break;
1030         }
1031 }
1032
1033 /**
1034  * iavf_add_cloud_filter
1035  * @adapter: adapter structure
1036  *
1037  * Request that the PF add cloud filters as specified
1038  * by the user via tc tool.
1039  **/
1040 void iavf_add_cloud_filter(struct iavf_adapter *adapter)
1041 {
1042         struct iavf_cloud_filter *cf;
1043         struct virtchnl_filter *f;
1044         int len = 0, count = 0;
1045
1046         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
1047                 /* bail because we already have a command pending */
1048                 dev_err(&adapter->pdev->dev, "Cannot add cloud filter, command %d pending\n",
1049                         adapter->current_op);
1050                 return;
1051         }
1052         list_for_each_entry(cf, &adapter->cloud_filter_list, list) {
1053                 if (cf->add) {
1054                         count++;
1055                         break;
1056                 }
1057         }
1058         if (!count) {
1059                 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_CLOUD_FILTER;
1060                 return;
1061         }
1062         adapter->current_op = VIRTCHNL_OP_ADD_CLOUD_FILTER;
1063
1064         len = sizeof(struct virtchnl_filter);
1065         f = kzalloc(len, GFP_KERNEL);
1066         if (!f)
1067                 return;
1068
1069         list_for_each_entry(cf, &adapter->cloud_filter_list, list) {
1070                 if (cf->add) {
1071                         memcpy(f, &cf->f, sizeof(struct virtchnl_filter));
1072                         cf->add = false;
1073                         cf->state = __IAVF_CF_ADD_PENDING;
1074                         iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_CLOUD_FILTER,
1075                                          (u8 *)f, len);
1076                 }
1077         }
1078         kfree(f);
1079 }
1080
1081 /**
1082  * iavf_del_cloud_filter
1083  * @adapter: adapter structure
1084  *
1085  * Request that the PF delete cloud filters as specified
1086  * by the user via tc tool.
1087  **/
1088 void iavf_del_cloud_filter(struct iavf_adapter *adapter)
1089 {
1090         struct iavf_cloud_filter *cf, *cftmp;
1091         struct virtchnl_filter *f;
1092         int len = 0, count = 0;
1093
1094         if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
1095                 /* bail because we already have a command pending */
1096                 dev_err(&adapter->pdev->dev, "Cannot remove cloud filter, command %d pending\n",
1097                         adapter->current_op);
1098                 return;
1099         }
1100         list_for_each_entry(cf, &adapter->cloud_filter_list, list) {
1101                 if (cf->del) {
1102                         count++;
1103                         break;
1104                 }
1105         }
1106         if (!count) {
1107                 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_CLOUD_FILTER;
1108                 return;
1109         }
1110         adapter->current_op = VIRTCHNL_OP_DEL_CLOUD_FILTER;
1111
1112         len = sizeof(struct virtchnl_filter);
1113         f = kzalloc(len, GFP_KERNEL);
1114         if (!f)
1115                 return;
1116
1117         list_for_each_entry_safe(cf, cftmp, &adapter->cloud_filter_list, list) {
1118                 if (cf->del) {
1119                         memcpy(f, &cf->f, sizeof(struct virtchnl_filter));
1120                         cf->del = false;
1121                         cf->state = __IAVF_CF_DEL_PENDING;
1122                         iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_CLOUD_FILTER,
1123                                          (u8 *)f, len);
1124                 }
1125         }
1126         kfree(f);
1127 }
1128
1129 /**
1130  * iavf_request_reset
1131  * @adapter: adapter structure
1132  *
1133  * Request that the PF reset this VF. No response is expected.
1134  **/
1135 void iavf_request_reset(struct iavf_adapter *adapter)
1136 {
1137         /* Don't check CURRENT_OP - this is always higher priority */
1138         iavf_send_pf_msg(adapter, VIRTCHNL_OP_RESET_VF, NULL, 0);
1139         adapter->current_op = VIRTCHNL_OP_UNKNOWN;
1140 }
1141
1142 /**
1143  * iavf_virtchnl_completion
1144  * @adapter: adapter structure
1145  * @v_opcode: opcode sent by PF
1146  * @v_retval: retval sent by PF
1147  * @msg: message sent by PF
1148  * @msglen: message length
1149  *
1150  * Asynchronous completion function for admin queue messages. Rather than busy
1151  * wait, we fire off our requests and assume that no errors will be returned.
1152  * This function handles the reply messages.
1153  **/
1154 void iavf_virtchnl_completion(struct iavf_adapter *adapter,
1155                               enum virtchnl_ops v_opcode,
1156                               enum iavf_status v_retval, u8 *msg, u16 msglen)
1157 {
1158         struct net_device *netdev = adapter->netdev;
1159
1160         if (v_opcode == VIRTCHNL_OP_EVENT) {
1161                 struct virtchnl_pf_event *vpe =
1162                         (struct virtchnl_pf_event *)msg;
1163                 bool link_up = vpe->event_data.link_event.link_status;
1164
1165                 switch (vpe->event) {
1166                 case VIRTCHNL_EVENT_LINK_CHANGE:
1167                         adapter->link_speed =
1168                                 vpe->event_data.link_event.link_speed;
1169
1170                         /* we've already got the right link status, bail */
1171                         if (adapter->link_up == link_up)
1172                                 break;
1173
1174                         if (link_up) {
1175                                 /* If we get link up message and start queues
1176                                  * before our queues are configured it will
1177                                  * trigger a TX hang. In that case, just ignore
1178                                  * the link status message,we'll get another one
1179                                  * after we enable queues and actually prepared
1180                                  * to send traffic.
1181                                  */
1182                                 if (adapter->state != __IAVF_RUNNING)
1183                                         break;
1184
1185                                 /* For ADq enabled VF, we reconfigure VSIs and
1186                                  * re-allocate queues. Hence wait till all
1187                                  * queues are enabled.
1188                                  */
1189                                 if (adapter->flags &
1190                                     IAVF_FLAG_QUEUES_DISABLED)
1191                                         break;
1192                         }
1193
1194                         adapter->link_up = link_up;
1195                         if (link_up) {
1196                                 netif_tx_start_all_queues(netdev);
1197                                 netif_carrier_on(netdev);
1198                         } else {
1199                                 netif_tx_stop_all_queues(netdev);
1200                                 netif_carrier_off(netdev);
1201                         }
1202                         iavf_print_link_message(adapter);
1203                         break;
1204                 case VIRTCHNL_EVENT_RESET_IMPENDING:
1205                         dev_info(&adapter->pdev->dev, "Reset warning received from the PF\n");
1206                         if (!(adapter->flags & IAVF_FLAG_RESET_PENDING)) {
1207                                 adapter->flags |= IAVF_FLAG_RESET_PENDING;
1208                                 dev_info(&adapter->pdev->dev, "Scheduling reset task\n");
1209                                 queue_work(iavf_wq, &adapter->reset_task);
1210                         }
1211                         break;
1212                 default:
1213                         dev_err(&adapter->pdev->dev, "Unknown event %d from PF\n",
1214                                 vpe->event);
1215                         break;
1216                 }
1217                 return;
1218         }
1219         if (v_retval) {
1220                 switch (v_opcode) {
1221                 case VIRTCHNL_OP_ADD_VLAN:
1222                         dev_err(&adapter->pdev->dev, "Failed to add VLAN filter, error %s\n",
1223                                 iavf_stat_str(&adapter->hw, v_retval));
1224                         break;
1225                 case VIRTCHNL_OP_ADD_ETH_ADDR:
1226                         dev_err(&adapter->pdev->dev, "Failed to add MAC filter, error %s\n",
1227                                 iavf_stat_str(&adapter->hw, v_retval));
1228                         /* restore administratively set MAC address */
1229                         ether_addr_copy(adapter->hw.mac.addr, netdev->dev_addr);
1230                         break;
1231                 case VIRTCHNL_OP_DEL_VLAN:
1232                         dev_err(&adapter->pdev->dev, "Failed to delete VLAN filter, error %s\n",
1233                                 iavf_stat_str(&adapter->hw, v_retval));
1234                         break;
1235                 case VIRTCHNL_OP_DEL_ETH_ADDR:
1236                         dev_err(&adapter->pdev->dev, "Failed to delete MAC filter, error %s\n",
1237                                 iavf_stat_str(&adapter->hw, v_retval));
1238                         break;
1239                 case VIRTCHNL_OP_ENABLE_CHANNELS:
1240                         dev_err(&adapter->pdev->dev, "Failed to configure queue channels, error %s\n",
1241                                 iavf_stat_str(&adapter->hw, v_retval));
1242                         adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED;
1243                         adapter->ch_config.state = __IAVF_TC_INVALID;
1244                         netdev_reset_tc(netdev);
1245                         netif_tx_start_all_queues(netdev);
1246                         break;
1247                 case VIRTCHNL_OP_DISABLE_CHANNELS:
1248                         dev_err(&adapter->pdev->dev, "Failed to disable queue channels, error %s\n",
1249                                 iavf_stat_str(&adapter->hw, v_retval));
1250                         adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED;
1251                         adapter->ch_config.state = __IAVF_TC_RUNNING;
1252                         netif_tx_start_all_queues(netdev);
1253                         break;
1254                 case VIRTCHNL_OP_ADD_CLOUD_FILTER: {
1255                         struct iavf_cloud_filter *cf, *cftmp;
1256
1257                         list_for_each_entry_safe(cf, cftmp,
1258                                                  &adapter->cloud_filter_list,
1259                                                  list) {
1260                                 if (cf->state == __IAVF_CF_ADD_PENDING) {
1261                                         cf->state = __IAVF_CF_INVALID;
1262                                         dev_info(&adapter->pdev->dev, "Failed to add cloud filter, error %s\n",
1263                                                  iavf_stat_str(&adapter->hw,
1264                                                                v_retval));
1265                                         iavf_print_cloud_filter(adapter,
1266                                                                 &cf->f);
1267                                         list_del(&cf->list);
1268                                         kfree(cf);
1269                                         adapter->num_cloud_filters--;
1270                                 }
1271                         }
1272                         }
1273                         break;
1274                 case VIRTCHNL_OP_DEL_CLOUD_FILTER: {
1275                         struct iavf_cloud_filter *cf;
1276
1277                         list_for_each_entry(cf, &adapter->cloud_filter_list,
1278                                             list) {
1279                                 if (cf->state == __IAVF_CF_DEL_PENDING) {
1280                                         cf->state = __IAVF_CF_ACTIVE;
1281                                         dev_info(&adapter->pdev->dev, "Failed to del cloud filter, error %s\n",
1282                                                  iavf_stat_str(&adapter->hw,
1283                                                                v_retval));
1284                                         iavf_print_cloud_filter(adapter,
1285                                                                 &cf->f);
1286                                 }
1287                         }
1288                         }
1289                         break;
1290                 default:
1291                         dev_err(&adapter->pdev->dev, "PF returned error %d (%s) to our request %d\n",
1292                                 v_retval, iavf_stat_str(&adapter->hw, v_retval),
1293                                 v_opcode);
1294                 }
1295         }
1296         switch (v_opcode) {
1297         case VIRTCHNL_OP_ADD_ETH_ADDR: {
1298                 if (!ether_addr_equal(netdev->dev_addr, adapter->hw.mac.addr))
1299                         ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr);
1300                 }
1301                 break;
1302         case VIRTCHNL_OP_GET_STATS: {
1303                 struct iavf_eth_stats *stats =
1304                         (struct iavf_eth_stats *)msg;
1305                 netdev->stats.rx_packets = stats->rx_unicast +
1306                                            stats->rx_multicast +
1307                                            stats->rx_broadcast;
1308                 netdev->stats.tx_packets = stats->tx_unicast +
1309                                            stats->tx_multicast +
1310                                            stats->tx_broadcast;
1311                 netdev->stats.rx_bytes = stats->rx_bytes;
1312                 netdev->stats.tx_bytes = stats->tx_bytes;
1313                 netdev->stats.tx_errors = stats->tx_errors;
1314                 netdev->stats.rx_dropped = stats->rx_discards;
1315                 netdev->stats.tx_dropped = stats->tx_discards;
1316                 adapter->current_stats = *stats;
1317                 }
1318                 break;
1319         case VIRTCHNL_OP_GET_VF_RESOURCES: {
1320                 u16 len = sizeof(struct virtchnl_vf_resource) +
1321                           IAVF_MAX_VF_VSI *
1322                           sizeof(struct virtchnl_vsi_resource);
1323                 memcpy(adapter->vf_res, msg, min(msglen, len));
1324                 iavf_validate_num_queues(adapter);
1325                 iavf_vf_parse_hw_config(&adapter->hw, adapter->vf_res);
1326                 if (is_zero_ether_addr(adapter->hw.mac.addr)) {
1327                         /* restore current mac address */
1328                         ether_addr_copy(adapter->hw.mac.addr, netdev->dev_addr);
1329                 } else {
1330                         /* refresh current mac address if changed */
1331                         ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr);
1332                         ether_addr_copy(netdev->perm_addr,
1333                                         adapter->hw.mac.addr);
1334                 }
1335                 spin_lock_bh(&adapter->mac_vlan_list_lock);
1336                 iavf_add_filter(adapter, adapter->hw.mac.addr);
1337                 spin_unlock_bh(&adapter->mac_vlan_list_lock);
1338                 iavf_process_config(adapter);
1339                 }
1340                 break;
1341         case VIRTCHNL_OP_ENABLE_QUEUES:
1342                 /* enable transmits */
1343                 iavf_irq_enable(adapter, true);
1344                 adapter->flags &= ~IAVF_FLAG_QUEUES_DISABLED;
1345                 break;
1346         case VIRTCHNL_OP_DISABLE_QUEUES:
1347                 iavf_free_all_tx_resources(adapter);
1348                 iavf_free_all_rx_resources(adapter);
1349                 if (adapter->state == __IAVF_DOWN_PENDING) {
1350                         adapter->state = __IAVF_DOWN;
1351                         wake_up(&adapter->down_waitqueue);
1352                 }
1353                 break;
1354         case VIRTCHNL_OP_VERSION:
1355         case VIRTCHNL_OP_CONFIG_IRQ_MAP:
1356                 /* Don't display an error if we get these out of sequence.
1357                  * If the firmware needed to get kicked, we'll get these and
1358                  * it's no problem.
1359                  */
1360                 if (v_opcode != adapter->current_op)
1361                         return;
1362                 break;
1363         case VIRTCHNL_OP_IWARP:
1364                 /* Gobble zero-length replies from the PF. They indicate that
1365                  * a previous message was received OK, and the client doesn't
1366                  * care about that.
1367                  */
1368                 if (msglen && CLIENT_ENABLED(adapter))
1369                         iavf_notify_client_message(&adapter->vsi, msg, msglen);
1370                 break;
1371
1372         case VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP:
1373                 adapter->client_pending &=
1374                                 ~(BIT(VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP));
1375                 break;
1376         case VIRTCHNL_OP_GET_RSS_HENA_CAPS: {
1377                 struct virtchnl_rss_hena *vrh = (struct virtchnl_rss_hena *)msg;
1378
1379                 if (msglen == sizeof(*vrh))
1380                         adapter->hena = vrh->hena;
1381                 else
1382                         dev_warn(&adapter->pdev->dev,
1383                                  "Invalid message %d from PF\n", v_opcode);
1384                 }
1385                 break;
1386         case VIRTCHNL_OP_REQUEST_QUEUES: {
1387                 struct virtchnl_vf_res_request *vfres =
1388                         (struct virtchnl_vf_res_request *)msg;
1389
1390                 if (vfres->num_queue_pairs != adapter->num_req_queues) {
1391                         dev_info(&adapter->pdev->dev,
1392                                  "Requested %d queues, PF can support %d\n",
1393                                  adapter->num_req_queues,
1394                                  vfres->num_queue_pairs);
1395                         adapter->num_req_queues = 0;
1396                         adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED;
1397                 }
1398                 }
1399                 break;
1400         case VIRTCHNL_OP_ADD_CLOUD_FILTER: {
1401                 struct iavf_cloud_filter *cf;
1402
1403                 list_for_each_entry(cf, &adapter->cloud_filter_list, list) {
1404                         if (cf->state == __IAVF_CF_ADD_PENDING)
1405                                 cf->state = __IAVF_CF_ACTIVE;
1406                 }
1407                 }
1408                 break;
1409         case VIRTCHNL_OP_DEL_CLOUD_FILTER: {
1410                 struct iavf_cloud_filter *cf, *cftmp;
1411
1412                 list_for_each_entry_safe(cf, cftmp, &adapter->cloud_filter_list,
1413                                          list) {
1414                         if (cf->state == __IAVF_CF_DEL_PENDING) {
1415                                 cf->state = __IAVF_CF_INVALID;
1416                                 list_del(&cf->list);
1417                                 kfree(cf);
1418                                 adapter->num_cloud_filters--;
1419                         }
1420                 }
1421                 }
1422                 break;
1423         default:
1424                 if (adapter->current_op && (v_opcode != adapter->current_op))
1425                         dev_warn(&adapter->pdev->dev, "Expected response %d from PF, received %d\n",
1426                                  adapter->current_op, v_opcode);
1427                 break;
1428         } /* switch v_opcode */
1429         adapter->current_op = VIRTCHNL_OP_UNKNOWN;
1430 }