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